¿Cómo obtener el directorio del archivo actualmente en ejecución?

En nodejs uso __dirname . ¿Cuál es el equivalente de esto en Golang?

Busqué en Google y descubrí este artículo http://andrewbrookins.com/tech/golang-get-directory-of-the-current-file/ . Donde usa el siguiente código

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

¿Pero es la forma correcta o idiomática de hacer en Golang?

Esto debería hacerlo:

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

EDITAR: A partir de Go 1.8 (lanzado en febrero de 2017), la forma recomendada de hacerlo es con os.Executable:

func Executable() (string, error)

El ejecutable devuelve el nombre de ruta para el ejecutable que inició el proceso actual. No hay garantía de que la ruta todavía apunte al ejecutable correcto. Si se utilizó un enlace simbólico para iniciar el proceso, dependiendo del sistema operativo, el resultado podría ser el enlace simbólico o la ruta a la que apuntaba. Si se necesita un resultado estable, path / filepath.EvalSymlinks podría ayudar.

Para obtener solo el directorio del ejecutable que puede usar path/filepath.Dir.

Ejemplo :

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

ANTIGUA RESPUESTA:

Deberías poder usar os.Getwd

func Getwd() (pwd string, err error)

Getwd devuelve un nombre de ruta rooteado correspondiente al directorio actual. Si se puede acceder al directorio actual a través de múltiples rutas (debido a enlaces simbólicos), Getwd puede devolver cualquiera de ellas.

Por ejemplo:

package main

import (
    "fmt"
    "os"
)

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

Usar paquete osext

Proporciona una función ExecutableFolder()que devuelve una ruta absoluta a la carpeta donde reside el ejecutable del programa que se está ejecutando actualmente (útil para trabajos cron). Es multiplataforma.

Documentación en línea

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 devuelve una representación absoluta de ruta. Si la ruta no es absoluta, se unirá con el directorio de trabajo actual para convertirla en una ruta absoluta.

Como se indicó en el comentario, esto devuelve el directorio que está actualmente activo.

si usas de esta manera:

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

obtendrá la ruta / tmp cuando esté ejecutando el programa usando algún IDE como GoLang porque el ejecutable guardará y se ejecutará desde / tmp

Creo que la mejor manera de obtener el directorio de trabajo actual o '.' es :

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

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

la función os.Getwd () devolverá el directorio de trabajo actual. y todo sin usar ninguna biblioteca externa: D

Si usa el paquete osext de kardianos y necesita probarlo localmente, como Derek Dowling comentó:

Esto funciona bien hasta que desee utilizarlo con go run main.go para el desarrollo local. No estoy seguro de cuál es la mejor manera de evitar eso sin crear un ejecutable de antemano cada vez.

La solución a esto es hacer una utilidad gorun.exe en lugar de usar go run. La utilidad gorun.exe compilará el proyecto usando "go build", luego lo ejecutará inmediatamente después, en el directorio normal de su proyecto.

Tuve este problema con otros compiladores y me encontré haciendo estas utilidades ya que no se envían con el compilador ... es especialmente arcano con herramientas como C donde tienes que compilar y vincular y luego ejecutarlo (demasiado trabajo).

Si a alguien le gusta mi idea de gorun.exe (o elf), probablemente lo subiré a github pronto ...

Lo sentimos, esta respuesta se entiende como un comentario, pero no puedo comentar porque todavía no tengo una reputación lo suficientemente grande.

Alternativamente, "go run" podría modificarse (si aún no tiene esta función) para tener un parámetro como "go run -notemp" para no ejecutar el programa en un directorio temporal (o algo similar). Pero preferiría simplemente escribir gorun o "gor", ya que es más corto que un parámetro complicado. Gorun.exe o gor.exe tendrían que instalarse en el mismo directorio que su compilador go

Implementar gorun.exe (o gor.exe) sería trivial, como lo hice con otros compiladores en solo unas pocas líneas de código ... (últimas palabras famosas ;-)

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 veces esto es suficiente, el primer argumento siempre será la ruta del archivo

package main

import (
    "fmt"
    "os"
)


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

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

La respuesta de Gustavo Niemeyer es genial. Pero en Windows, el proceso de ejecución se encuentra principalmente en otro directorio, como este:

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

Si usa la ruta relativa del archivo, como "/config/api.yaml", esto usará la ruta del proyecto donde existe su código.