Come ottenere la directory del file attualmente in esecuzione?

In nodejs uso __dirname . Qual è l'equivalente di questo in Golang?

Ho cercato su Google e ho scoperto questo articolo http://andrewbrookins.com/tech/golang-get-directory-of-the-current-file/ . Dove usa sotto il codice

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

Ma è il modo giusto o il modo idiomatico di fare a Golang?

Questo dovrebbe farlo:

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

EDIT: A partire da Go 1.8 (rilasciato a febbraio 2017) il modo raccomandato per farlo è con os.Executable:

func Executable() (string, error)

Il file eseguibile restituisce il nome del percorso del file eseguibile che ha avviato il processo corrente. Non vi è alcuna garanzia che il percorso stia ancora puntando all'eseguibile corretto. Se un collegamento simbolico è stato utilizzato per avviare il processo, a seconda del sistema operativo, il risultato potrebbe essere il collegamento simbolico o il percorso a cui puntava. Se è necessario un risultato stabile, path / filepath.EvalSymlinks potrebbe aiutare.

Per ottenere solo la directory dell'eseguibile è possibile utilizzare path/filepath.Dir.

Esempio :

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

VECCHIA RISPOSTA:

Dovresti essere in grado di usare os.Getwd

func Getwd() (pwd string, err error)

Getwd restituisce un nome di percorso rooted corrispondente alla directory corrente. Se la directory corrente è raggiungibile tramite più percorsi (a causa di collegamenti simbolici), Getwd può restituire uno di essi.

Per esempio:

package main

import (
    "fmt"
    "os"
)

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

Usa il pacchetto osext

Fornisce una funzione ExecutableFolder()che restituisce un percorso assoluto alla cartella in cui risiede l'eseguibile del programma attualmente in esecuzione (utile per i lavori cron). È multipiattaforma.

Documentazione 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 restituisce una rappresentazione assoluta del percorso. Se il percorso non è assoluto, verrà unito alla directory di lavoro corrente per trasformarlo in un percorso assoluto.

Come indicato nel commento, questo restituisce la directory che è attualmente attiva.

se usi in questo modo:

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

otterrai il percorso / tmp quando stai eseguendo un programma usando alcuni IDE come GoLang perché l'eseguibile salverà ed eseguirà da / tmp

penso che il modo migliore per ottenere l'attuale Directory di lavoro o '.' è:

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

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

la funzione os.Getwd () restituirà la directory di lavoro corrente. e tutto senza l'utilizzo di alcuna libreria esterna: D

Se usi il pacchetto osext di kardianos e devi testare localmente, come ha commentato Derek Dowling:

Funziona bene fino a quando non desideri utilizzarlo con go run main.go per lo sviluppo locale. Non sono sicuro del modo migliore per aggirare il problema senza creare un eseguibile in anticipo ogni volta.

La soluzione è creare un'utilità gorun.exe invece di utilizzare go run. L'utilità gorun.exe compilerà il progetto usando "go build", quindi lo eseguirà subito, nella normale directory del progetto.

Ho avuto questo problema con altri compilatori e mi sono ritrovato a creare queste utilità poiché non sono fornite con il compilatore ... è particolarmente arcano con strumenti come C in cui devi compilare e collegare e quindi eseguirlo (troppo lavoro).

Se a qualcuno piace la mia idea di gorun.exe (o elfo) probabilmente lo caricherò presto su github ..

Siamo spiacenti, questa risposta si intende come un commento, ma non posso commentare perché non ho ancora una reputazione abbastanza grande.

In alternativa, "go run" potrebbe essere modificato (se non ha già questa funzione) per avere un parametro come "go run -notemp" per non eseguire il programma in una directory temporanea (o qualcosa di simile). Preferirei semplicemente digitare gorun o "gor" in quanto è più breve di un parametro contorto. Gorun.exe o gor.exe dovrebbero essere installati nella stessa directory del compilatore go

L'implementazione di gorun.exe (o gor.exe) sarebbe banale, come ho fatto con altri compilatori in poche righe di codice ... (ultime parole famose ;-)

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

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

Demo completa:

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

A volte questo è sufficiente, il primo argomento sarà sempre il percorso del file

package main

import (
    "fmt"
    "os"
)


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

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

La risposta di Gustavo Niemeyer è fantastica. Ma in Windows, proc di runtime è principalmente in un'altra directory, in questo modo:

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

Se si utilizza il percorso del file relativo, ad esempio "/config/api.yaml", questo utilizzerà il percorso del progetto in cui esiste il codice.