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

mover varios archivos en linux

Question

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 él usa el código debajo

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

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

Answer 1

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

func Executable() (string, error)

El ejecutable devuelve el nombre de ruta del ejecutable que inició el proceso actual. No hay garantía de que la ruta todavía esté apuntando 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, puede usar path/filepath.Dir .

Example :

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 enraizado correspondiente al directorio actual. Si se puede llegar al directorio actual a través de varias 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)
}

Answer 2

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

Answer 3

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

Esto funciona bien hasta que quieras usarlo con go main.go para el desarrollo local. No estoy seguro de cuál es la mejor manera de evitar eso sin tener que crear un archivo 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ía el proyecto usando "ir compilación", luego lo ejecutaría 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 incluyen con el compilador ... es especialmente misterioso 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é pronto a github ..

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

Alternativamente, "go run" podría modificarse (si ya no tiene esta característica) 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 enrevesado. Gorun.exe o gor.exe tendrían que instalarse en el mismo directorio que su compilador go

La implementación de gorun.exe (o gor.exe) sería trivial, ya que lo he hecho con otros compiladores en solo unas pocas líneas de código ... (últimas palabras famosas ;-)

Answer 4

Usa el paquete osext

Proporciona la función ExecutableFolder() que devuelve una ruta de acceso absoluta a la carpeta donde reside el ejecutable del programa en ejecución (ú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)
}

Answer 5

filepath.Abs("./")

Abs devuelve una representación absoluta de la ruta. Si la ruta no es absoluta, se unirá al directorio de trabajo actual para convertirla en una ruta absoluta.

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