Golang os 包與設定配置檔案路徑

一、os包的學習與使用(檔案，目錄，程式的操作)

參考\
golang語言中os包的學習與使用(檔案，目錄，程式的操作)

1.os中一些常用函式的使用

package main;

import (
    "os"
    "fmt"
    "time"
    "strings"
)

//os包中的一些常用函式

func main() {
    //獲取主機名
    fmt.Println(os.Hostname());

    //獲取當前目錄
    fmt.Println(os.Getwd());

    //獲取使用者ID
    fmt.Println(os.Getuid());

    //獲取有效使用者ID
    fmt.Println(os.Geteuid());

    //獲取組ID
    fmt.Println(os.Getgid());

    //獲取有效組ID
    fmt.Println(os.Getegid());

    //獲取程式ID
    fmt.Println(os.Getpid());

    //獲取父程式ID
    fmt.Println(os.Getppid());

    //獲取環境變數的值
    fmt.Println(os.Getenv("GOPATH"));

    //設定環境變數的值
    os.Setenv("TEST", "test");

    //改變當前工作目錄
    os.Chdir("C:/");
    fmt.Println(os.Getwd());

    //建立檔案
    f1, _ := os.Create("./1.txt");
    defer f1.Close();

    //修改檔案許可權
    if err := os.Chmod("./1.txt", 0777); err != nil {
        fmt.Println(err);
    }

    //修改檔案所有者
    if err := os.Chown("./1.txt", 0, 0); err != nil {
        fmt.Println(err);
    }

    //修改檔案的訪問時間和修改時間
    os.Chtimes("./1.txt", time.Now().Add(time.Hour), time.Now().Add(time.Hour));

    //獲取所有環境變數
    fmt.Println(strings.Join(os.Environ(), "\r\n"));

    //把字串中帶${var}或$var替換成指定指符串
    fmt.Println(os.Expand("${1} ${2} ${3}", func(k string) string {
        mapp := map[string]string{
            "1": "111",
            "2": "222",
            "3": "333",
        };
        return mapp[k];
    }));

    //建立目錄
    os.Mkdir("abc", os.ModePerm);

    //建立多級目錄
    os.MkdirAll("abc/d/e/f", os.ModePerm);

    //刪除檔案或目錄
    os.Remove("abc/d/e/f");

    //刪除指定目錄下所有檔案
    os.RemoveAll("abc");

    //重新命名檔案
    os.Rename("./2.txt", "./2_new.txt");

    //判斷是否為同一檔案
    //unix下通過底層結構的裝置和索引節點是否相同來判斷
    //其他系統可能是通過檔案絕對路徑來判斷
    fs1, _ := f1.Stat();
    f2, _ := os.Open("./1.txt");
    fs2, _ := f2.Stat();
    fmt.Println(os.SameFile(fs1, fs2));

    //返回臨時目錄
    fmt.Println(os.TempDir());
}

比如golang 操作 系統環境變數小例子

func testEnv() {
    //臨時設定 系統環境變數
    err := os.Setenv("XIAO", "xiaochuan")
    if err != nil {
        fmt.Println(err.Error())
    }
    //獲取環境變數
    fmt.Println(os.Getenv("XIAO"))
    fmt.Println(os.Getenv("GOPATH"))
    //獲取全部系統環境變數 獲取的是 key=val 的[]string
    for _, v := range os.Environ() {
        str := strings.Split(v, "=")
        fmt.Printf("key=%s,val=%s \n", str[0], str[1])
    }
}
-------------------------
xiaochuan
D:\go\helloworld;D:\go
...

2.os中一些常用檔案函式的使用

package main

import (
    "os"
    "fmt"
    "strconv"
)

//os包中關於檔案的操作函式

func main() {
    //建立檔案，返回一個檔案指標
    f3, _ := os.Create("./3.txt");
    defer f3.Close();

    //以讀寫方式開啟檔案，如果不存在則建立檔案，等同於上面os.Create
    f4, _ := os.OpenFile("./4.txt", os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0666);
    defer f4.Close();

    //開啟檔案，返回檔案指標
    f1, _ := os.Open("./1.txt");
    defer f1.Close();

    //修改檔案許可權，類似os.chmod
    f1.Chmod(0777);

    //修改檔案所有者，類似os.chown
    f1.Chown(0, 0);

    //返回檔案的控制程式碼，通過NewFile建立檔案需要檔案控制程式碼
    fmt.Println(f1.Fd());

    //從檔案中讀取資料
    buf := make([]byte, 128);
    //read每次讀取資料到buf中
    for n, _ := f1.Read(buf); n != 0; n, _ = f1.Read(buf) {
        fmt.Println(string(buf[:n]));
    }

    //向檔案中寫入資料
    for i := 0; i < 5; i++ {
        f3.Write([]byte("寫入資料" + strconv.Itoa(i) + "\r\n"));
    }

    //返回一對關聯的檔案物件
    //從r中可以讀取到從w寫入的資料
    r, w, _ := os.Pipe();

    //向w中寫入字串
    w.WriteString("寫入w");
    buf2 := make([]byte, 128);

    //從r中讀取資料
    n, _ := r.Read(buf);
    fmt.Println(string(buf2[:n]));

    //改變工作目錄
    os.Mkdir("a", os.ModePerm);
    dir, _ := os.Open("a");

    //改變工作目錄到dir，dir必須為一個目錄
    dir.Chdir();
    fmt.Println(os.Getwd());

    //讀取目錄的內容，返回一個FileInfo的slice
    //引數大於0，最多返回n個FileInfo
    //引數小於等於0，返回所有FileInfo
    fi, _ := dir.Readdir(-1);
    for _, v := range fi {
        fmt.Println(v.Name());
    }

    //讀取目錄中檔案物件的名字
    names, _ := dir.Readdirnames(-1);
    fmt.Println(names);

    //獲取檔案的詳細資訊，返回FileInfo結構
    fi3, _ := f3.Stat();

    //檔名
    fmt.Println(fi3.Name());

    //檔案大小
    fmt.Println(fi3.Size());

    //檔案許可權
    fmt.Println(fi3.Mode());

    //檔案修改時間
    fmt.Println(fi3.ModTime());

    //是否是目錄
    fmt.Println(fi3.IsDir());
}

這裡os.Open或其他方法，預設路徑是work directory，本文後面會做詳細解釋。

3.os中關於程式的操作

package main

import (
    "os"
    "fmt"
    "time"
)

//os包中關於程式的操作函式

func main() {
    //設定新程式的屬性
    attr := &os.ProcAttr{
        //files指定新程式繼承的活動檔案物件
        //前三個分別為，標準輸入、標準輸出、標準錯誤輸出
        Files: []*os.File{os.Stdin, os.Stdout, os.Stderr},

        //新程式的環境變數
        Env: os.Environ(),
    }

    //win下通過記事本開啟1.txt
    //開始一個新程式
    p, err := os.StartProcess("C:\\Windows\\System32\\notepad.exe", 
    []string{"C:\\Windows\\System32\\notepad.exe", "D:\\1.txt"}, attr);

    if err != nil {
        fmt.Println(err);
    }

    fmt.Println(p);
    fmt.Println("程式ID：", p.Pid);

    //通過程式ID查詢程式
    p2, _ := os.FindProcess(p.Pid);
    fmt.Println(p2);

    //等待10秒，執行函式
    time.AfterFunc(time.Second*10, func() {
        //向p程式傳送退出訊號
        p.Signal(os.Kill);
    });

    //等待程式p的退出，返回程式狀態
    ps, _ := p.Wait();
    fmt.Println(ps.String());
}

二、設定配置檔案路徑

1.os.args

參考Golang 命令列 os.Args 和 flag包\
程式獲取執行他時給出的引數，可以通過os包來實現。先看程式碼：

package main

import (
    "fmt"
    "os"
    "strconv"
)

func main () {
    for idx, args := range os.Args {
        fmt.Println("引數" + strconv.Itoa(idx) + ":", args)
    }
}

執行起來得到的如下：

$go run main.go 1 3 -X ?
引數0: /tmp/go-build116558042/command-line-arguments/_obj/exe/main
引數1: 1
引數2: 3
引數3: -X
引數4: ?

可以看到，命令列引數包括了程式路徑本身，以及通常意義上的引數。 程式中os.Args的型別是 []string ，也就是字串切片。所以可以在for迴圈的range中遍歷，還可以用 len(os.Args) 來獲取其數量。

\

image.png

\

如果在goland中設定output directory，就會輸出：

引數0: D:\go\TestFile\bin\go_build_TestPath1_go.exe

也就是說，output directory對應著os.Args[0]，即go run執行的目錄\
PS:這裡也能看到下面一個Working directory，對應的正是os.Getwd()，wd即是Working directory縮寫，當然可以更改預設值，變成在bin資料夾下：D:\go\TestFile\bin

2.Args[0]為什麼不能直接作為程式的絕對路徑

curFilename := os.Args[0]
Path, err := exec.LookPath(curFilename)
binaryPath, err = filepath.Abs(Path)
dir := filepath.Dir(binaryPath)

//怎麼不直接使用 filepath.Abs(filepath.Dir(os.Args[0]))
//還要通過一層LookPath

假設檔案在/home/XXX/a\
args[0]獲取的是相對路徑，或者說，就是你使用什麼命令啟動的。\
如果你用./a啟動的話，args[0]就是./a，不是絕對路徑。\
如果你用./XXX/a啟動的話，args[0]就是./XXX/a，不是絕對路徑。\
如果用/home/XXX/a啟動，那麼獲取到的就是/home/XXX/a。

argv[0]的做法來自C語言，因此其他語言的argv[0]也就保持了和C語言一致。

獲取可執行檔案的絕對路徑(不包括檔名)，請用：

filepath.Abs(filepath.Dir(os.Args[0]))
返回：/home/XXX

補充：獲取可執行檔案的絕對路徑（包括檔名），請用：

filepath.Abs(os.Args[0])
返回：/home/XXX/a

3.LookPath

參考\
golang中os/exec包用法\
Go知識點記錄\
Golang學習 - path/filepath 包

func main() {
    f, err := exec.LookPath("ls")
    if err != nil {
        fmt.Println(err)
    }
    fmt.Println(f) //  /bin/ls
}

func LookPath(file string) (string, error) //在環境變數PATH指定的目錄中搜尋可執行檔案，如file中有斜槓，則只在當前目錄搜尋。返回完整路徑或者相對於當前目錄的一個相對路徑。

package main

import(
        "os"
        "log"
        "os/exec"
        "path"
)

func main() {

        //可執行檔案我放在/home/yejianfeng/handcode/test
        //我執行的路徑是/home/yejianfeng/

        //獲取當前目錄
        file, _ := os.Getwd()
        //current path: /home/yejianfeng
        log.Println("current path:", file)

        file, _ := exec.LookPath(os.Args[0])
        //exec path: handcode/test
        log.Println("exec path:", file)

        dir,_ := path.Split(file)
        //exec folder relative path: handcode/
        log.Println("exec folder relative path:", dir)

        //改變當前工作目錄
        os.Chdir(dir)
        wd, _ := os.Getwd()
        //exec folder absolute path: /home/yejianfeng/handcode
        log.Println("exec folder absolute path:", wd)
}

Go語言學習之path/filepath包(the way to go)\
4.Abs\
func Abs(path string) (string, error)\
檢測地址是否是絕對地址，是絕對地址直接返回，不是絕對地址，會新增當前工作路徑到引數path前，然後返回

func TestAbs() {
    fpt, err := filepath.Abs("/hello")
    if err != nil {
        panic(err)
    }
    fmt.Println(fpt)

    fpt, err = filepath.Abs("helleeo")
    if err != nil {
        panic(err)
    }
    fmt.Println(fpt)
}

列印資訊：

/hello
/home/xxx/workspace/gotestworkspace/golangtest/helleeo

“/”表示當前路徑下

5.golang 正確獲取絕對路徑的方法

import (
    "fmt"
    "os"
    "os/exec"
    "path/filepath"
    "strings"
)

func main() {
    fmt.Println("GoLang 獲取程式執行絕對路徑")
    fmt.Println(GetCurrPath())
}

func GetCurrPath() string {
    file, _ := exec.LookPath(os.Args[0])
    path, _ := filepath.Abs(file)
    index := strings.LastIndex(path, string(os.PathSeparator))
    ret := path[:index]
    return ret
}

三、聊一聊，Golang “相對”路徑問題

1.傳遞引數

func main() {
    var appPath string
    flag.StringVar(&appPath, "app-path", "app-path")
    flag.Parse()
    fmt.Printf("App path: %s", appPath)
}
----------
go run main.go --app-path "Your project address"

2.增加os.Getwd()進行多層判斷

參見 beego L133-L146 讀取 app.conf 的程式碼，該寫法可相容 go build 和在專案根目錄執行 go run ，但是若跨目錄執行 go run 就不行

func init() {
    BConfig = newBConfig()
    var err error
    if AppPath, err = filepath.Abs(filepath.Dir(os.Args[0])); err != nil {
        panic(err)
    }
    workPath, err := os.Getwd()
    if err != nil {
        panic(err)
    }
    var filename = "app.conf"
    if os.Getenv("BEEGO_RUNMODE") != "" {
        filename = os.Getenv("BEEGO_RUNMODE") + ".app.conf"
    }
    appConfigPath = filepath.Join(workPath, "conf", filename)
    if !utils.FileExists(appConfigPath) {
        appConfigPath = filepath.Join(AppPath, "conf", filename)
        if !utils.FileExists(appConfigPath) {
            AppConfig = &beegoAppConfig{innerConfig: config.NewFakeConfig()}
            return
        }
    }
    if err = parseConfig(appConfigPath); err != nil {
        panic(err)
    }
}

這裡主要目的就是找到appConfigPath。如果忽略BEEGO_RUNMODE，可以當作filename="app.conf"，首先會直接使用workPath進行拼接：workPath, err := os.Getwd()，相當於執行路徑下比如D:\go\TestFile，拼接完成後就是D:\go\TestFile\conf\app.conf，然後使用utils.FileExists判斷這個檔案是否存在。如果不存在，會用AppPath拼接。

這裡AppPath是D:\go\TestFile\bin，這是因為我們的os.Args[0]=D:\go\TestFile\bin\go_build_TestPath1_go.exe，filepath.Dir會返回路徑最後一個元素的目錄。如果對照goland上面的設定，可以看出workPath對應的是Working directory，AppPath對應的是output directory。

3.配置全域性系統變數

參見 gogs L351 讀取GOGS_WORK_DIR進行拼接的程式碼

// execPath returns the executable path.
func execPath() (string, error) {
    file, err := exec.LookPath(os.Args[0])
    if err != nil {
        return "", err
    }
    return filepath.Abs(file)
}

func init() {
    IsWindows = runtime.GOOS == "windows"
    log.New(log.CONSOLE, log.ConsoleConfig{})

    var err error
    if AppPath, err = execPath(); err != nil {
        log.Fatal(2, "Fail to get app path: %v\n", err)
    }

    // Note: we don't use path.Dir here because it does not handle case
    //  which path starts with two "/" in Windows: "//psf/Home/..."
    AppPath = strings.Replace(AppPath, "\\", "/", -1)
}

// WorkDir returns absolute path of work directory.
func WorkDir() (string, error) {
    wd := os.Getenv("GOGS_WORK_DIR")
    if len(wd) > 0 {
        return wd, nil
    }

    i := strings.LastIndex(AppPath, "/")
    if i == -1 {
        return AppPath, nil
    }
    return AppPath[:i], nil
}

// NewContext initializes configuration context.
// NOTE: do not print any log except error.
func NewContext() {
    workDir, err := WorkDir()
    if err != nil {
        log.Fatal(2, "Fail to get work directory: %v", err)
    }

    Cfg, err = ini.LoadSources(ini.LoadOptions{
        IgnoreInlineComment: true,
    }, bindata.MustAsset("conf/app.ini"))
    if err != nil {
        log.Fatal(2, "Fail to parse 'conf/app.ini': %v", err)
    }

    CustomPath = os.Getenv("GOGS_CUSTOM")
    if len(CustomPath) == 0 {
        CustomPath = workDir + "/custom"
    }

    if len(CustomConf) == 0 {
        CustomConf = CustomPath + "/conf/app.ini"
    }
...

4.利用系統自帶變數

簡單來說就是通過系統自帶的全域性變數，例如$HOME等，將配置檔案存放在$HOME/conf或/etc/conf下。這樣子就能更加固定的存放配置檔案，不需要額外去設定一個環境變數（這點今早與一位SFer討論了一波，感謝）。

作者：合肥懶皮
連結：https://www.jianshu.com/p/cec7cc3b3d98\
來源：簡書