一秋麸、os包的學(xué)習(xí)與使用(文件跌榔，目錄，進(jìn)程的操作)

參考
golang語言中os包的學(xué)習(xí)與使用(文件递宅，目錄帘靡，進(jìn)程的操作)

1.os中一些常用函數(shù)的使用

package main;

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

//os包中的一些常用函數(shù)

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

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

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

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

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

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

    //獲取進(jìn)程ID
    fmt.Println(os.Getpid());

    //獲取父進(jìn)程ID
    fmt.Println(os.Getppid());

    //獲取環(huán)境變量的值
    fmt.Println(os.Getenv("GOPATH"));

    //設(shè)置環(huán)境變量的值
    os.Setenv("TEST", "test");

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

    //創(chuàng)建文件
    f1, _ := os.Create("./1.txt");
    defer f1.Close();

    //修改文件權(quán)限
    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);
    }

    //修改文件的訪問時(shí)間和修改時(shí)間
    os.Chtimes("./1.txt", time.Now().Add(time.Hour), time.Now().Add(time.Hour));

    //獲取所有環(huán)境變量
    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];
    }));

 

    //創(chuàng)建目錄
    os.Mkdir("abc", os.ModePerm);

    //創(chuàng)建多級(jí)目錄
    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下通過底層結(jié)構(gòu)的設(shè)備和索引節(jié)點(diǎn)是否相同來判斷
    //其他系統(tǒng)可能是通過文件絕對(duì)路徑來判斷
    fs1, _ := f1.Stat();
    f2, _ := os.Open("./1.txt");
    fs2, _ := f2.Stat();
    fmt.Println(os.SameFile(fs1, fs2));

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

比如golang 操作 系統(tǒng)環(huán)境變量小例子

func testEnv() {
    //臨時(shí)設(shè)置 系統(tǒng)環(huán)境變量
    err := os.Setenv("XIAO", "xiaochuan")
    if err != nil {
        fmt.Println(err.Error())
    }
    //獲取環(huán)境變量
    fmt.Println(os.Getenv("XIAO"))
    fmt.Println(os.Getenv("GOPATH"))
    //獲取全部系統(tǒng)環(huán)境變量 獲取的是 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中一些常用文件函數(shù)的使用

package main

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

//os包中關(guān)于文件的操作函數(shù)

func main() {
    //創(chuàng)建文件捻爷，返回一個(gè)文件指針
    f3, _ := os.Create("./3.txt");
    defer f3.Close();

    //以讀寫方式打開文件吟逝，如果不存在則創(chuàng)建文件沦疾，等同于上面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();
 
    //修改文件權(quán)限造虎，類似os.chmod
    f1.Chmod(0777);

    //修改文件所有者傅蹂，類似os.chown
    f1.Chown(0, 0);

    //返回文件的句柄，通過NewFile創(chuàng)建文件需要文件句柄
    fmt.Println(f1.Fd());

    //從文件中讀取數(shù)據(jù)
    buf := make([]byte, 128);
    //read每次讀取數(shù)據(jù)到buf中
    for n, _ := f1.Read(buf); n != 0; n, _ = f1.Read(buf) {
        fmt.Println(string(buf[:n]));
    }

    //向文件中寫入數(shù)據(jù)
    for i := 0; i < 5; i++ {
        f3.Write([]byte("寫入數(shù)據(jù)" + strconv.Itoa(i) + "\r\n"));
    }

    //返回一對(duì)關(guān)聯(lián)的文件對(duì)象
    //從r中可以讀取到從w寫入的數(shù)據(jù)
    r, w, _ := os.Pipe();

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

    //從r中讀取數(shù)據(jù)
    n, _ := r.Read(buf);
    fmt.Println(string(buf2[:n]));

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

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

    //讀取目錄的內(nèi)容贬派，返回一個(gè)FileInfo的slice
    //參數(shù)大于0，最多返回n個(gè)FileInfo
    //參數(shù)小于等于0澎媒，返回所有FileInfo
    fi, _ := dir.Readdir(-1);
    for _, v := range fi {
        fmt.Println(v.Name());
    }

    //讀取目錄中文件對(duì)象的名字
    names, _ := dir.Readdirnames(-1);
    fmt.Println(names);

    //獲取文件的詳細(xì)信息，返回FileInfo結(jié)構(gòu)
    fi3, _ := f3.Stat();
    
    //文件名
    fmt.Println(fi3.Name());

    //文件大小
    fmt.Println(fi3.Size());

    //文件權(quán)限
    fmt.Println(fi3.Mode());

    //文件修改時(shí)間
    fmt.Println(fi3.ModTime());

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

這里os.Open或其他方法波桩，默認(rèn)路徑是work directory戒努，本文后面會(huì)做詳細(xì)解釋。

3.os中關(guān)于進(jìn)程的操作

package main

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

//os包中關(guān)于進(jìn)程的操作函數(shù)

func main() {
    //設(shè)置新進(jìn)程的屬性
    attr := &os.ProcAttr{
        //files指定新進(jìn)程繼承的活動(dòng)文件對(duì)象
        //前三個(gè)分別為镐躲，標(biāo)準(zhǔn)輸入储玫、標(biāo)準(zhǔn)輸出、標(biāo)準(zhǔn)錯(cuò)誤輸出
        Files: []*os.File{os.Stdin, os.Stdout, os.Stderr},

        //新進(jìn)程的環(huán)境變量
        Env: os.Environ(),
    }

    //win下通過記事本打開1.txt
    //開始一個(gè)新進(jìn)程
    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("進(jìn)程ID：", p.Pid);

    //通過進(jìn)程ID查找進(jìn)程
    p2, _ := os.FindProcess(p.Pid);
    fmt.Println(p2);

    //等待10秒萤皂，執(zhí)行函數(shù)
    time.AfterFunc(time.Second*10, func() {
        //向p進(jìn)程發(fā)送退出信號(hào)
        p.Signal(os.Kill);
    });

    //等待進(jìn)程p的退出撒穷，返回進(jìn)程狀態(tài)
    ps, _ := p.Wait();
    fmt.Println(ps.String());
}

二、設(shè)置配置文件路徑

1.os.args

參考Golang 命令行 os.Args 和 flag包
程序獲取運(yùn)行他時(shí)給出的參數(shù)裆熙，可以通過os包來實(shí)現(xiàn)端礼。先看代碼：

package main

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

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

運(yùn)行起來得到的如下：

$go run main.go 1 3 -X ?
參數(shù)0: /tmp/go-build116558042/command-line-arguments/_obj/exe/main
參數(shù)1: 1
參數(shù)2: 3
參數(shù)3: -X
參數(shù)4: ?

可以看到，命令行參數(shù)包括了程序路徑本身入录，以及通常意義上的參數(shù)蛤奥。 程序中os.Args的類型是 []string ，也就是字符串切片僚稿。所以可以在for循環(huán)的range中遍歷凡桥，還可以用 len(os.Args) 來獲取其數(shù)量。

image.png

如果在goland中設(shè)置output directory蚀同，就會(huì)輸出：

參數(shù)0: D:\go\TestFile\bin\go_build_TestPath1_go.exe

也就是說缅刽，output directory對(duì)應(yīng)著os.Args[0]啊掏，即go run執(zhí)行的目錄
PS:這里也能看到下面一個(gè)Working directory，對(duì)應(yīng)的正是os.Getwd()衰猛，wd即是Working directory縮寫迟蜜，當(dāng)然可以更改默認(rèn)值，變成在bin文件夾下：D:\go\TestFile\bin

2.Args[0]為什么不能直接作為程序的絕對(duì)路徑

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

假設(shè)文件在/home/XXX/a
args[0]獲取的是相對(duì)路徑腕侄，或者說小泉，就是你使用什么命令啟動(dòng)的。
如果你用./a啟動(dòng)的話冕杠，args[0]就是./a微姊，不是絕對(duì)路徑。
如果你用./XXX/a啟動(dòng)的話分预，args[0]就是./XXX/a兢交，不是絕對(duì)路徑。
如果用/home/XXX/a啟動(dòng)笼痹，那么獲取到的就是/home/XXX/a配喳。

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

獲取可執(zhí)行文件的絕對(duì)路徑(不包括文件名)晴裹，請(qǐng)用：

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

補(bǔ)充：獲取可執(zhí)行文件的絕對(duì)路徑（包括文件名），請(qǐng)用：

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

3.LookPath

參考
golang中os/exec包用法
Go知識(shí)點(diǎn)記錄
Golang學(xué)習(xí) - 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) //在環(huán)境變量PATH指定的目錄中搜索可執(zhí)行文件救赐，如file中有斜杠涧团，則只在當(dāng)前目錄搜索。返回完整路徑或者相對(duì)于當(dāng)前目錄的一個(gè)相對(duì)路徑经磅。

package main

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

func main() {
        
        //可執(zhí)行文件我放在/home/yejianfeng/handcode/test
        //我執(zhí)行的路徑是/home/yejianfeng/
        
        //獲取當(dāng)前目錄
        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)

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

Go語言學(xué)習(xí)之path/filepath包(the way to go)
4.Abs
func Abs(path string) (string, error)
檢測(cè)地址是否是絕對(duì)地址泌绣，是絕對(duì)地址直接返回，不是絕對(duì)地址预厌，會(huì)添加當(dāng)前工作路徑到參數(shù)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

“/”表示當(dāng)前路徑下

5.golang 正確獲取絕對(duì)路徑的方法

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

func main() {
    fmt.Println("GoLang 獲取程序運(yùn)行絕對(duì)路徑")
    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 “相對(duì)”路徑問題

1.傳遞參數(shù)

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()進(jìn)行多層判斷

參見 beego L133-L146 讀取 app.conf 的代碼苗沧，該寫法可兼容 go build 和在項(xiàng)目根目錄執(zhí)行 go run ，但是若跨目錄執(zhí)行 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崎页，可以當(dāng)作filename="app.conf"，首先會(huì)直接使用workPath進(jìn)行拼接：workPath, err := os.Getwd()腰埂，相當(dāng)于運(yùn)行路徑下比如D:\go\TestFile飒焦，拼接完成后就是D:\go\TestFile\conf\app.conf，然后使用utils.FileExists判斷這個(gè)文件是否存在。如果不存在牺荠，會(huì)用AppPath拼接翁巍。

這里AppPath是D:\go\TestFile\bin，這是因?yàn)槲覀兊?code>os.Args[0]=D:\go\TestFile\bin\go_build_TestPath1_go.exe休雌，filepath.Dir會(huì)返回路徑最后一個(gè)元素的目錄灶壶。如果對(duì)照goland上面的設(shè)置，可以看出workPath對(duì)應(yīng)的是Working directory杈曲，AppPath對(duì)應(yīng)的是output directory驰凛。

3.配置全局系統(tǒng)變量

參見 gogs L351 讀取GOGS_WORK_DIR進(jìn)行拼接的代碼

// 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: "http://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.利用系統(tǒng)自帶變量

簡單來說就是通過系統(tǒng)自帶的全局變量，例如$HOME等担扑，將配置文件存放在$HOME/conf或/etc/conf下恰响。這樣子就能更加固定的存放配置文件，不需要額外去設(shè)置一個(gè)環(huán)境變量（這點(diǎn)今早與一位SFer討論了一波涌献，感謝）胚宦。