Bagaimana cara mendapatkan direktori file yang sedang berjalan?

Dalam nodejs saya menggunakan __dirname . Apa yang setara dengan ini di Golang?

Saya telah mencari di Google dan menemukan artikel ini http://andrewbrookins.com/tech/golang-get-directory-of-the-current-file/ . Di mana dia menggunakan kode di bawah ini

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

Tetapi apakah ini cara yang tepat atau idiomatis untuk dilakukan di Golang?

Ini harus dilakukan:

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: As of Go 1.8 (Dirilis Februari 2017) cara yang disarankan untuk melakukan ini adalah dengan os.Executable:

func Executable() (string, error)

Executable mengembalikan nama path untuk executable yang memulai proses saat ini. Tidak ada jaminan bahwa path masih menunjuk ke executable yang benar. Jika symlink digunakan untuk memulai proses, tergantung pada sistem operasi, hasilnya mungkin symlink atau jalur yang ditunjuk. Jika diperlukan hasil yang stabil, jalur / filepath.EvalSymlinks mungkin membantu.

Untuk mendapatkan direktori executable yang bisa Anda gunakan path/filepath.Dir.

Contoh :

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

JAWABAN TUA:

Anda harus bisa menggunakannya os.Getwd

func Getwd() (pwd string, err error)

Getwd mengembalikan nama jalur yang di-root sesuai dengan direktori saat ini. Jika direktori saat ini dapat dicapai melalui beberapa jalur (karena tautan simbolik), Getwd dapat mengembalikan salah satu dari mereka.

Sebagai contoh:

package main

import (
    "fmt"
    "os"
)

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

Gunakan paket osext

Ini menyediakan fungsi ExecutableFolder()yang mengembalikan jalur absolut ke folder tempat program yang saat ini dijalankan dapat dijalankan (berguna untuk pekerjaan cron). Ini lintas platform.

Dokumentasi 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 mengembalikan representasi absolut jalan. Jika path tidak absolut, itu akan bergabung dengan direktori kerja saat ini untuk mengubahnya menjadi path absolut.

Seperti yang dinyatakan dalam komentar, ini mengembalikan direktori yang saat ini aktif.

jika Anda menggunakan cara ini:

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

Anda akan mendapatkan path / tmp ketika Anda menjalankan program menggunakan beberapa IDE seperti GoLang karena executable akan menyimpan dan menjalankan dari / tmp

Saya pikir cara terbaik untuk mendapatkan Direktori Pekerjaan saat ini atau '.' adalah :

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

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

fungsi os.Getwd () akan mengembalikan direktori kerja saat ini. dan semuanya tanpa menggunakan perpustakaan eksternal apa pun: D

Jika Anda menggunakan paket osext oleh kardianos dan Anda perlu menguji secara lokal, seperti Derek Dowling berkomentar:

Ini berfungsi dengan baik sampai Anda ingin menggunakannya dengan go run main.go untuk pengembangan lokal. Tidak yakin bagaimana cara terbaik untuk menyiasatinya tanpa membangun executable terlebih dahulu setiap kali.

Solusi untuk ini adalah membuat utilitas gorun.exe alih-alih menggunakan go run. Utilitas gorun.exe akan mengkompilasi proyek menggunakan "pergi membangun", kemudian jalankan segera setelah itu, di direktori normal proyek Anda.

Saya punya masalah dengan kompiler lain dan menemukan diri saya membuat utilitas ini karena mereka tidak dikirim dengan kompiler ... itu terutama misterius dengan alat-alat seperti C di mana Anda harus mengkompilasi dan menghubungkan dan kemudian menjalankannya (terlalu banyak pekerjaan).

Jika ada yang menyukai ide saya tentang gorun.exe (atau peri), saya akan segera mengunggahnya ke github ..

Maaf, jawaban ini dimaksudkan sebagai komentar, tetapi saya tidak dapat berkomentar karena saya belum memiliki reputasi yang cukup besar.

Atau, "go run" dapat dimodifikasi (jika belum memiliki fitur ini) untuk memiliki parameter seperti "go run -notemp" untuk tidak menjalankan program dalam direktori sementara (atau yang serupa). Tapi saya lebih suka mengetik gorun atau "gor" karena lebih pendek dari parameter yang berbelit-belit. Gorun.exe atau gor.exe perlu diinstal di direktori yang sama dengan kompiler go Anda

Menerapkan gorun.exe (atau gor.exe) akan sepele, karena saya telah melakukannya dengan kompiler lain hanya dalam beberapa baris kode ... (kata-kata terakhir yang terkenal ;-)

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

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

Demo Lengkap:

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

Terkadang ini cukup, argumen pertama akan selalu menjadi path file

package main

import (
    "fmt"
    "os"
)


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

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

Jawaban Gustavo Niemeyer luar biasa. Tetapi di Windows, runtime proc sebagian besar berada di dir lain, seperti ini:

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

Jika Anda menggunakan jalur file relatif, seperti "/config/api.yaml", ini akan menggunakan jalur proyek Anda di mana kode Anda ada.