it-swarm.com.de

Wie bekomme ich das Verzeichnis der aktuell laufenden Datei?

In nodejs verwende ich __dirname . Was ist das Äquivalent in Golang?

Ich habe gegoogelt und diesen Artikel gefunden http://andrewbrookins.com/tech/golang-get-directory-of-the-current-file/ . Wo er unter Code verwendet

_, filename, _, _ := runtime.Caller(1)
f, err := os.Open(path.Join(path.Dir(filename), "data.csv"))

Aber ist das der richtige Weg oder eine idiomatische Vorgehensweise in Golang?

175
ekanna

Das sollte es tun:

import (
    "fmt"
    "log"
    "os"
    "path/filepath"
)

func main() {
    dir, err := filepath.Abs(filepath.Dir(os.Args[0]))
    if err != nil {
            log.Fatal(err)
    }
    fmt.Println(dir)
}
175

BEARBEITEN: Ab Go 1.8 (Veröffentlicht im Februar 2017) wird empfohlen, dies mit os.Executable zu tun:

func Executable() (string, error)

Ausführbare Datei gibt den Pfadnamen für die ausführbare Datei zurück, die den aktuellen Prozess gestartet hat. Es gibt keine Garantie dafür, dass der Pfad weiterhin auf die richtige ausführbare Datei verweist. Wenn ein Symlink zum Starten des Prozesses verwendet wurde, ist das Ergebnis je nach Betriebssystem möglicherweise der Symlink oder der Pfad, auf den er verweist. Wenn ein stabiles Ergebnis benötigt wird, kann path/filepath.EvalSymlinks hilfreich sein.

Um nur das Verzeichnis der ausführbaren Datei abzurufen, können Sie path/filepath.Dir verwenden.

Beispiel :

_package main

import (
    "fmt"
    "os"
    "path/filepath"
)

func main() {
    ex, err := os.Executable()
    if err != nil {
        panic(err)
    }
    exPath := filepath.Dir(ex)
    fmt.Println(exPath)
}
_

ALTE ANTWORT:

Sie sollten in der Lage sein, os.Getwd zu verwenden.

_func Getwd() (pwd string, err error)
_

Getwd gibt einen verwurzelten Pfadnamen zurück, der dem aktuellen Verzeichnis entspricht. Wenn das aktuelle Verzeichnis über mehrere Pfade (aufgrund symbolischer Verknüpfungen) erreichbar ist, kann Getwd einen dieser Pfade zurückgeben.

Zum Beispiel:

_package main

import (
    "fmt"
    "os"
)

func main() {
    pwd, err := os.Getwd()
    if err != nil {
        fmt.Println(err)
        os.Exit(1)
    }
    fmt.Println(pwd)
}
_
245
Intermernet

Verwenden Sie das Paket osext

Es bietet die Funktion ExecutableFolder(), die einen absoluten Pfad zu dem Ordner zurückgibt, in dem sich die aktuell ausgeführte Programmdatei befindet (nützlich für Cron-Jobs). Es ist plattformübergreifend.

Online-Dokumentation

package main

import (
    "github.com/kardianos/osext"
    "fmt"
    "log"
)

func main() {
    folderPath, err := osext.ExecutableFolder()
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(folderPath)
}
51
filepath.Abs("./")

Abs gibt eine absolute Darstellung des Pfads zurück. Wenn der Pfad nicht .__ ist. absolut wird es mit dem aktuellen Arbeitsverzeichnis verbunden werden es in einen absoluten Pfad.

Wie im Kommentar angegeben, wird das aktuell aktive Verzeichnis zurückgegeben.

6
Acidic

Wenn Sie package osext von kardianos verwenden und lokal testen müssen, wie Derek Dowling kommentierte:

Dies funktioniert gut, bis Sie es mit go run main.go für .__ verwenden möchten. lokale Entwicklung. Nicht sicher, wie man das am besten ohne .__ umgehen kann. Erstellen Sie jedes Mal eine ausführbare Datei.

Die Lösung hierfür besteht darin, ein Dienstprogramm "gorun.exe" anstelle von "go run" zu erstellen. Das Dienstprogramm "gorun.exe" kompiliert das Projekt mit "go build" und führt es anschließend im normalen Verzeichnis Ihres Projekts aus.

Ich hatte dieses Problem mit anderen Compilern und stellte fest, dass ich diese Hilfsprogramme erstellte, da sie nicht mit dem Compiler ausgeliefert werden. Besonders bei Tools wie C muss man sie kompilieren, verknüpfen und dann ausführen (zu viel Arbeit).

Wenn jemand meine Idee von gorun.exe (oder elf) mag, werde ich sie wahrscheinlich bald in github hochladen.

Diese Antwort ist leider als Kommentar gedacht, aber ich kann nicht kommentieren, da ich keinen guten Ruf habe.

Alternativ kann "go run" geändert werden (sofern dieses Feature nicht bereits vorhanden ist), um einen Parameter wie "go run -notemp" zu haben, um das Programm nicht in einem temporären Verzeichnis (oder einem ähnlichen Element) auszuführen. Aber ich würde es vorziehen, gorun oder "gor" einzugeben, da es kürzer ist als ein gewundener Parameter. Gorun.exe oder gor.exe müssten im selben Verzeichnis wie Ihr Go-Compiler installiert werden

Die Implementierung von gorun.exe (oder gor.exe) wäre trivial, wie ich es mit anderen Compilern in nur wenigen Codezeilen gemacht habe ... (berühmte letzte Worte ;-)

2
Another Prog

wenn Sie diesen Weg verwenden: 

dir, err := filepath.Abs(filepath.Dir(os.Args[0]))
if err != nil {
    log.Fatal(err)
}
fmt.Println(dir)

sie erhalten den Pfad/tmp, wenn Sie ein Programm mit IDE wie GoLang ausführen, da die ausführbare Datei unter/tmp gespeichert und ausgeführt wird

ich denke, der beste Weg, um das currentWorking Directory oder '.' ist:

import(
  "os" 
  "fmt"
  "log"
)

func main() {
  dir, err := os.Getwd()
    if err != nil {
        log.Fatal(err)
    }
  fmt.Println(dir)
}

die Funktion os.Getwd () gibt das aktuelle Arbeitsverzeichnis zurück.

1
Bit

manchmal reicht dies aus, das firs-Argument ist immer der Dateipfad Paket Haupt

import (
    "fmt"
    "os"
)


func main() {
    fmt.Println(os.Args[0])
}
0

os.Executable: https://tip.golang.org/pkg/os/#Executable

filepath.EvalSymlinks: https://golang.org/pkg/path/filepath/#EvalSymlinks

Vollständige Demo:

package main

import (
    "fmt"
    "os"
    "path/filepath"
)

func main() {
    var dirAbsPath string
    ex, err := os.Executable()
    if err == nil {
        dirAbsPath = filepath.Dir(ex)
        fmt.Println(dirAbsPath)
        return
    }

    exReal, err := filepath.EvalSymlinks(ex)
    if err != nil {
        panic(err)
    }
    dirAbsPath = filepath.Dir(exReal)
    fmt.Println(dirAbsPath)
}
0
vikyd