Como obter o diretório do arquivo em execução no momento?

No nodejs eu uso __dirname . Qual é o equivalente disso em Golang?

Pesquisei no Google e descobri este artigo http://andrewbrookins.com/tech/golang-get-directory-of-the-current-file/ . Onde ele usa o código abaixo

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

Mas é o caminho certo ou idiomático para fazer em Golang?

Isso deve servir:

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 partir do Go 1.8 (Lançado em fevereiro de 2017), a maneira recomendada de fazer isso é os.Executable:

func Executable() (string, error)

Executável retorna o nome do caminho do executável que iniciou o processo atual. Não há garantia de que o caminho ainda esteja apontando para o executável correto. Se um link simbólico foi usado para iniciar o processo, dependendo do sistema operacional, o resultado pode ser o link simbólico ou o caminho apontado. Se um resultado estável for necessário, path / filepath.EvalSymlinks pode ajudar.

Para obter apenas o diretório do executável, você pode usar path/filepath.Dir.

Exemplo :

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

RESPOSTA ANTIGA:

Você deve poder usar os.Getwd

func Getwd() (pwd string, err error)

Getwd retorna um nome de caminho raiz correspondente ao diretório atual. Se o diretório atual puder ser alcançado por vários caminhos (devido a links simbólicos), Getwd poderá retornar qualquer um deles.

Por exemplo:

package main

import (
    "fmt"
    "os"
)

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

Use o pacote osext

Ele está fornecendo uma função ExecutableFolder()que retorna um caminho absoluto para a pasta onde reside o executável do programa atualmente em execução (útil para tarefas cron). É multiplataforma.

Documentação 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 retorna uma representação absoluta do caminho. Se o caminho não for absoluto, ele será associado ao diretório de trabalho atual para transformá-lo em um caminho absoluto.

Conforme declarado no comentário, isso retorna o diretório que está ativo no momento.

se você usar desta maneira:

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

você obterá o caminho / tmp quando estiver executando um programa usando algum IDE como o GoLang, porque o executável salvará e executará em / tmp

Eu acho que a melhor maneira de obter o diretório de trabalho atual ou '.' é :

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

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

a função os.Getwd () retornará o diretório de trabalho atual. e tudo isso sem o uso de qualquer biblioteca externa: D

Se você usa o pacote osext da kardianos e precisa testar localmente, como comentou Derek Dowling:

Isso funciona bem até que você queira usá-lo com vá em main.go para desenvolvimento local. Não tenho certeza da melhor forma de contornar isso sem criar previamente um executável a cada vez.

A solução para isso é criar um utilitário gorun.exe em vez de usar go run. O utilitário gorun.exe compila o projeto usando "go build" e depois o executa no diretório normal do seu projeto.

Eu tive esse problema com outros compiladores e me vi criando esses utilitários, pois eles não são fornecidos com o compilador ... é especialmente arcano com ferramentas como C, nas quais você precisa compilar e vincular e depois executá-lo (muito trabalho).

Se alguém gostar da minha idéia do gorun.exe (ou elf), provavelmente o carregarei no github em breve ..

Desculpe, esta resposta é um comentário, mas não posso comentar porque ainda não tenho uma reputação grande o suficiente.

Como alternativa, "go run" pode ser modificado (se já não tiver esse recurso) para ter um parâmetro como "go run -notemp" para não executar o programa em um diretório temporário (ou algo semelhante). Mas eu preferiria apenas digitar gorun ou "gor", pois é mais curto que um parâmetro complicado. Gorun.exe ou gor.exe precisaria ser instalado no mesmo diretório do seu compilador go

A implementação de gorun.exe (ou gor.exe) seria trivial, como fiz com outros compiladores em apenas algumas linhas de código ... (famosas últimas palavras ;-)

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

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

Demonstração 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)
}

Às vezes isso é suficiente, o primeiro argumento sempre será o caminho do arquivo

package main

import (
    "fmt"
    "os"
)


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

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

A resposta de Gustavo Niemeyer é ótima. Mas no Windows, o proc de tempo de execução está principalmente em outro diretório, como este:

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

Se você usar o caminho relativo do arquivo, como "/config/api.yaml", isso usará o caminho do projeto onde seu código existe.