Comment obtenir le répertoire du fichier en cours d'exécution?

Dans nodejs, j'utilise __dirname . Quel est l'équivalent de cela à Golang?

J'ai googlé et découvert cet article http://andrewbrookins.com/tech/golang-get-directory-of-the-current-file/ . Où il utilise le code ci-dessous

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

Mais est-ce la bonne façon ou la façon idiomatique de faire à Golang?

Cela devrait le faire:

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: à partir de Go 1.8 (sortie en février 2017), la méthode recommandée pour ce faire est la suivante os.Executable:

func Executable() (string, error)

L'exécutable renvoie le nom de chemin de l'exécutable qui a démarré le processus en cours. Il n'y a aucune garantie que le chemin pointe toujours vers l'exécutable correct. Si un lien symbolique a été utilisé pour démarrer le processus, selon le système d'exploitation, le résultat pourrait être le lien symbolique ou le chemin vers lequel il pointait. Si un résultat stable est nécessaire, path / filepath.EvalSymlinks peut aider.

Pour obtenir uniquement le répertoire de l'exécutable que vous pouvez utiliser path/filepath.Dir.

Exemple :

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

ANCIENNE RÉPONSE:

Vous devriez pouvoir utiliser os.Getwd

func Getwd() (pwd string, err error)

Getwd renvoie un nom de chemin enraciné correspondant au répertoire courant. Si le répertoire courant peut être atteint via plusieurs chemins (en raison de liens symboliques), Getwd peut renvoyer n'importe lequel d'entre eux.

Par exemple:

package main

import (
    "fmt"
    "os"
)

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

Utiliser le package osext

Il fournit une fonction ExecutableFolder()qui renvoie un chemin absolu vers le dossier où réside l'exécutable du programme en cours d'exécution (utile pour les tâches cron). C'est multiplateforme.

Documentation en ligne

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 renvoie une représentation absolue du chemin. Si le chemin n'est pas absolu, il sera joint au répertoire de travail actuel pour le transformer en chemin absolu.

Comme indiqué dans le commentaire, cela renvoie le répertoire actuellement actif.

si vous utilisez cette méthode:

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

vous obtiendrez le chemin / tmp lorsque vous exécutez un programme en utilisant un IDE comme GoLang parce que l'exécutable sera enregistré et exécuté à partir de / tmp

Je pense que la meilleure façon d'obtenir le répertoire de travail actuel ou '.' est :

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

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

la fonction os.Getwd () renverra le répertoire de travail actuel. et tout cela sans utiliser de bibliothèque externe: D

Si vous utilisez le package osext par kardianos et que vous devez tester localement, comme l'a commenté Derek Dowling:

Cela fonctionne bien jusqu'à ce que vous souhaitiez l'utiliser avec go run main.go pour le développement local. Je ne sais pas comment mieux contourner cela sans construire un exécutable au préalable à chaque fois.

La solution est de créer un utilitaire gorun.exe au lieu d'utiliser go run. L'utilitaire gorun.exe compilerait le projet en utilisant «go build», puis l'exécuterait juste après, dans le répertoire normal de votre projet.

J'ai eu ce problème avec d'autres compilateurs et je me suis retrouvé à faire ces utilitaires car ils ne sont pas fournis avec le compilateur ... c'est particulièrement mystérieux avec des outils comme C où vous devez compiler et lier puis l'exécuter (trop de travail).

Si quelqu'un aime mon idée de gorun.exe (ou elf), je le téléchargerai probablement sur github bientôt ..

Désolé, cette réponse se veut un commentaire, mais je ne peux pas faire de commentaire car je n'ai pas encore une réputation assez grande.

Alternativement, "go run" pourrait être modifié (s'il n'a pas déjà cette fonctionnalité) pour avoir un paramètre tel que "go run -notemp" pour ne pas exécuter le programme dans un répertoire temporaire (ou quelque chose de similaire). Mais je préférerais simplement taper gorun ou "gor" car il est plus court qu'un paramètre alambiqué. Gorun.exe ou gor.exe devraient être installés dans le même répertoire que votre compilateur go

Implémenter gorun.exe (ou gor.exe) serait trivial, comme je l'ai fait avec d'autres compilateurs en seulement quelques lignes de code ... (derniers mots célèbres ;-)

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

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

Démo complète:

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

Parfois, cela suffit, le premier argument sera toujours le chemin du fichier

package main

import (
    "fmt"
    "os"
)


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

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

La réponse de Gustavo Niemeyer est excellente. Mais dans Windows, le proc d'exécution est principalement dans un autre répertoire, comme ceci:

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

Si vous utilisez un chemin de fichier relatif, comme "/config/api.yaml", cela utilisera le chemin de votre projet là où votre code existe.