Jak uzyskać katalog aktualnie uruchomionego pliku?

W nodejs używam __dirname . Co to jest równoważne w Golang?

Poszukałem go i znalazłem ten artykuł http://andrewbrookins.com/tech/golang-get-directory-of-the-current-file/ . Gdzie używa poniżej kodu

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

Ale czy jest to właściwy sposób, czy idiomatyczny sposób w Golang?

To powinno to zrobić:

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)
}

EDYCJA: Od wersji 1.8 (wydanej w lutym 2017 r.) Zalecanym sposobem jest os.Executable:

func Executable() (string, error)

Plik wykonywalny zwraca nazwę ścieżki do pliku wykonywalnego, który rozpoczął bieżący proces. Nie ma gwarancji, że ścieżka nadal wskazuje poprawny plik wykonywalny. Jeśli do uruchomienia procesu użyto dowiązania symbolicznego, w zależności od systemu operacyjnego, rezultatem może być dowiązanie symboliczne lub wskazana przez niego ścieżka. Jeśli potrzebny jest stabilny wynik, ścieżka / filepath.EvalSymlinks może pomóc.

Aby uzyskać tylko katalog pliku wykonywalnego, możesz użyć path/filepath.Dir.

Przykład :

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)
}

STARA ODPOWIEDŹ:

Powinieneś być w stanie używać os.Getwd

func Getwd() (pwd string, err error)

Getwd zwraca zrootowaną nazwę ścieżki odpowiadającą bieżącemu katalogowi. Jeśli do bieżącego katalogu można dotrzeć wieloma ścieżkami (z powodu dowiązań symbolicznych), Getwd może zwrócić dowolną z nich.

Na przykład:

package main

import (
    "fmt"
    "os"
)

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

Użyj pakietu osext

Zapewnia funkcję, ExecutableFolder()która zwraca bezwzględną ścieżkę do folderu, w którym znajduje się aktualnie wykonywalny program (przydatny do zadań cron). Jest wieloplatformowy.

Dokumentacja online

package main

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

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

filepath.Abs("./")

Abs zwraca absolutną reprezentację ścieżki. Jeśli ścieżka nie jest bezwzględna, zostanie połączona z bieżącym katalogiem roboczym, aby przekształcić ją w ścieżkę bezwzględną.

Jak stwierdzono w komentarzu, zwraca katalog, który jest obecnie aktywny.

jeśli skorzystasz w ten sposób:

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

dostaniesz ścieżkę / tmp, gdy uruchomisz program przy użyciu jakiegoś IDE, takiego jak GoLang, ponieważ plik wykonywalny zapisze i uruchomi się z / tmp

myślę, że najlepszym sposobem na uzyskanie aktualnego katalogu roboczego lub „.” jest :

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

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

funkcja os.Getwd () zwróci bieżący katalog roboczy. i to wszystko bez korzystania z zewnętrznej biblioteki: D

Jeśli używasz pakietu osext od kardianos i musisz testować lokalnie, jak skomentował Derek Dowling:

Działa to dobrze, dopóki nie chcesz go używać z go run main.go do rozwoju lokalnego. Nie wiem, jak najlepiej to obejść bez wcześniejszego budowania pliku wykonywalnego.

Rozwiązaniem tego jest utworzenie narzędzia gorun.exe zamiast używania go run. Narzędzie gorun.exe skompiluje projekt przy użyciu „go build”, a następnie uruchomi go zaraz po tym, w normalnym katalogu projektu.

Miałem ten problem z innymi kompilatorami i odkryłem, że robię te narzędzia, ponieważ nie są one dostarczane z kompilatorem ... jest to szczególnie tajemnicze z narzędziami takimi jak C, gdzie musisz skompilować i połączyć, a następnie uruchomić (zbyt dużo pracy).

Jeśli komuś spodoba się mój pomysł na gorun.exe (lub elfa), prawdopodobnie wkrótce załaduję go do github ..

Przepraszamy, ta odpowiedź ma charakter komentarza, ale nie mogę komentować, ponieważ nie mam jeszcze wystarczająco dużej reputacji.

Alternatywnie, „go run” można zmodyfikować (jeśli nie ma już tej funkcji), aby mieć parametr taki jak „go run -notemp”, aby nie uruchamiać programu w katalogu tymczasowym (lub coś podobnego). Ale wolałbym po prostu wpisywać gorun lub „gor”, ponieważ jest on krótszy niż zwinięty parametr. Gorun.exe lub gor.exe musiałby zostać zainstalowany w tym samym katalogu, co kompilator go

Wdrożenie gorun.exe (lub gor.exe) byłoby trywialne, ponieważ zrobiłem to z innymi kompilatorami w zaledwie kilku wierszach kodu ... (słynne ostatnie słowa ;-)

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

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

Pełna wersja 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)
}

Czasami to wystarczy, pierwszym argumentem zawsze będzie ścieżka do pliku

package main

import (
    "fmt"
    "os"
)


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

    // or
    dir, _ := os.Getwd()
    fmt.Println(dir)
}

Odpowiedź Gustavo Niemeyera jest świetna. Ale w systemie Windows proces uruchomieniowy jest przeważnie w innym katalogu, takim jak ten:

"C:\Users\XXX\AppData\Local\Temp"

Jeśli użyjesz względnej ścieżki pliku, na przykład "/config/api.yaml", użyje ścieżki projektu, w której istnieje kod.