Şu anda çalışan dosyanın dizini nasıl alınır?

Nodejs olarak kullandığım __dirname . Bunun Golang'daki karşılığı nedir?

Bu makaleyi buldum ve buldum http://andrewbrookins.com/tech/golang-get-directory-of-the-current-file/ . Aşağıdaki kodu kullandığı yerde

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

Ama Golang'da yapmanın doğru yolu mu yoksa deyimsel yolu mu?

Bunu yapmalı:

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: Go 1.8 itibariyle (Şubat 2017'de piyasaya sürüldü) bunu yapmanın önerilen yolu şudur os.Executable:

func Executable() (string, error)

Yürütülebilir dosya, geçerli işlemi başlatan yürütülebilir dosyanın yol adını döndürür. Yolun hala doğru yürütülebilir dosyayı işaret ettiğinin garantisi yoktur. İşletim sistemine bağlı olarak işlemi başlatmak için bir sembolik bağlantı kullanılmışsa, sonuç sembolik bağlantı veya işaret ettiği yol olabilir. Kararlı bir sonuç gerekiyorsa, path / filepath.EvalSymlinks yardımcı olabilir.

Sadece çalıştırılabilir dizini almak için kullanabilirsiniz path/filepath.Dir.

Örnek :

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

ESKİ CEVAP:

Kullanabilmelisin os.Getwd

func Getwd() (pwd string, err error)

Getwd, geçerli dizine karşılık gelen köklü bir yol adı döndürür. Geçerli dizine birden çok yoldan erişilebiliyorsa (sembolik bağlantılar nedeniyle), Getwd bunlardan herhangi birini döndürebilir.

Örneğin:

package main

import (
    "fmt"
    "os"
)

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

Osext paketini kullan

ExecutableFolder()Çalışmakta olan program yürütülebilir dosyasının bulunduğu klasöre mutlak bir yol döndüren bir işlev sağlar (cron işleri için yararlıdır). Çapraz platform.

Çevrimiçi belgeler

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, yolun mutlak bir temsilini döndürür. Yol mutlak değilse, mutlak bir yola dönüştürmek için geçerli çalışma diziniyle birleştirilir.

Yorumda belirtildiği gibi, bu işlem şu anda etkin olan dizini döndürür.

bu şekilde kullanırsanız:

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

yürütülebilir dosyayı kaydedip çalıştıracağı / tmp

GeçerliWorking Directory veya 'almak için en iyi yolu düşünüyorum.' dır-dir :

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

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

os.Getwd () işlevi, geçerli çalışma dizini dönecektir. ve hepsi harici bir kütüphane kullanmadan: D

Kardianos tarafından osext paketi kullanıyorsanız ve Derek Dowling'in yorumladığı gibi yerel olarak test etmeniz gerekiyorsa:

Yerel geliştirme için go run main.go ile kullanmak istediğinize kadar bu iyi çalışır. Her seferinde önceden bir yürütülebilir dosya oluşturmadan bunu nasıl çözeceğinizden emin değilim.

Bunun çözümü, go run kullanmak yerine bir gorun.exe yardımcı programı yapmaktır. Gorun.exe yardımcı programı, projeyi "go build" kullanarak derleyip projenizin normal dizininde hemen çalıştırır.

Diğer derleyiciler ile bu sorunu vardı ve derleyici ile sevk edilmediğinden kendimi bu yardımcı programları yaparken buldum ... özellikle derlemek ve bağlantı ve sonra çalıştırmak (çok fazla iş) nerede C gibi araçları ile gizlidir.

Herkes benim gorun.exe (ya da elf) fikrimi seviyorsa, muhtemelen yakında github'a yükleyeceğim ..

Maalesef, bu cevap bir yorum amaçlıdır, ancak henüz yeterince büyük bir itibara sahip olmadığım için yorum yapamam.

Alternatif olarak, "go run" (zaten bu özelliğe sahip değilse), programı geçici bir dizinde (veya benzer bir şeyde) çalıştırmak için "go run -notemp" gibi bir parametreye sahip olacak şekilde değiştirilebilir. Ama kıvrımlı bir parametreden daha kısa olduğu için sadece gorun veya "gor" yazmayı tercih ederim. Gorun.exe veya gor.exe'nin, go derleyicinizle aynı dizine yüklenmesi gerekir

Ben sadece birkaç satır kod diğer derleyiciler ile yapmış gibi gorun.exe (veya gor.exe) uygulamak önemsiz olurdu ... (ünlü son kelimeler ;-)

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

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

Tam Demo:

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

Bazen bu yeterlidir, ilk argüman her zaman dosya yolu olur

package main

import (
    "fmt"
    "os"
)


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

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

Gustavo Niemeyer'ın cevabı harika. Ancak Windows'da, çalışma zamanı proc'u çoğunlukla başka bir dizindir, şöyle:

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

Göreli dosya yolu kullanırsanız, örneğin "/config/api.yaml", kodunuzun bulunduğu proje yolunuzu kullanır.