基础应用

文件的读写操作

在进行文件操作时，“读” 和 “写” 是最常见且重要的两个操作。

下面是一个如何读取文件和写入文件的基本样例：

package main 

import (
	"fmt"
	"io/ioutil"
	"os"
)

func main() {
	content := []byte("Hello Golang!")

	// 写入文件
	err := ioutil.WriteFile("/tmp/golang.txt", content, 0644)
	if err != nil {
		fmt.Printf("Error writing file: %v", err)
	}

	// 读取文件
	data, err := ioutil.ReadFile("/tmp/golang.txt")
	if err != nil {
		fmt.Printf("Error reading file: %v", err)
	}

	fmt.Printf("File content: %s", data)
}

当然，上述内容只是文件读写的基础操作，有更复杂的读写需求（例如需要同时进行读写）时，可以使用 os 包中其它的工具函数，如os.Open、os.Create等。

环境变量的操作

环境变量是运行时系统或应用中的一种参数，一般用来告诉应用或库它们应该如何表现。

因此，理解如何在Go中操作环境变量是很重要的。下面的例子演示了如何获取、设置和列出环境变量：

package main

import (
	"fmt"
	"os"
)

func main() {
	// 设置环境变量
	os.Setenv("GO_ENV", "production")

	// 获取环境变量
	fmt.Println("GO_ENV:", os.Getenv("GO_ENV"))

	// 迭代并打印所有环境变量
	for _, env := range os.Environ() {
		fmt.Println(env)
	}
}

命令行参数的获取

在写命令行应用的时候，我们通常需要接收并处理命令行参数。我们可以使用 os.Args 来获取命令行参数。

package main

import (
	"fmt"
	"os"
)

func main() {
    // os.Args 提供原始命令行参数访问功能。注意，切片的第一个参数是该程序的路径，并且 `os.Args[1:]` 会得到所有程序的的参数。
	argsWithProg := os.Args
	argsWithoutProg := os.Args[1:]

	// 你可以使用标准的索引位置方式取得单个参数的值。
	arg := os.Args[3]

	fmt.Println(argsWithProg)
	fmt.Println(argsWithoutProg)
	fmt.Println(arg)
}

好的，接下来我会把高级应用部分进行完善，包括进程管理、信号处理和文件锁等用法。

进阶应用

进程管理

以Go语言编写的程序本身就是一个进程，此外，你还可以创建和管理其他的进程。

Golang的os/exec标准库封装了创建和管理进程的一系列功能，具体使用可以参考以下例子：

package main

import (
	"fmt"
	"os"
	"os/exec"
)

func main() {
	fmt.Printf("我是父进程: %v\n", os.Getpid())

	cmd := exec.Command("sleep", "5")
	if err := cmd.Start(); err != nil {
		fmt.Printf("出错了：%v\n", err)
		os.Exit(1)
	}

	fmt.Printf("我创建的子进程ID为: %v\n", cmd.Process.Pid)
	cmd.Wait()
	fmt.Printf("子进程已经结束\n")
}

在代码中我们创建了一个新的shell命令进程sleeep 5，等待它的结束。

Signal处理

在使用操作系统API时，会经常和一系列信号进行交互，比如SIGTERM表示终止进程的信号，在Go语言的os/signal库中我们可以方便的处理系统信号：

package main

import (
	"fmt"
	"os"
	"os/signal"
	"syscall"
)

func main() {
	sigs := make(chan os.Signal, 1)
	done := make(chan bool, 1)

	// 注册你所关注的信号
	signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)

	go func() {
		sig := <-sigs
		fmt.Println()
		fmt.Println(sig)
		done <- true
	}()

	fmt.Println("等待信号")
	<-done
	fmt.Println("退出")
}

上述程序会一直等待，直到接收到SIGINT或SIGTERM信号。

文件锁

有时我们需要防止两个进程同时操作同一个文件，Go可以使用os.OpenFile和syscall.Flock提供简单的文件锁：

package main 

import (
	"fmt"
	"os"
	"syscall"
)

func main() {
	f, err := os.OpenFile("/tmp/go-lock.tmp", os.O_CREATE | os.O_RDWR, 0600)
	if err != nil {
		fmt.Printf("open file error: %v\n", err)
		return
	}
	defer f.Close()

	err = syscall.Flock(int(f.Fd()), syscall.LOCK_EX|syscall.LOCK_NB)
	if err != nil {
		if err == syscall.EWOULDBLOCK {
			fmt.Println("文件已经被锁定")
			return
		}
		fmt.Printf("锁定文件失败：%v\n", err)
		return
	}
	defer syscall.Flock(int(f.Fd()), syscall.LOCK_UN)

	fmt.Println("成功锁定文件")
}

在这个例子中，我们试图获得一个文件锁，如果文件已经被其他进程锁定，程序将会返回错误信息。

以上就是使用Golang os库进行操作系统调用的高级操作方式，希望对你有所帮助，请一键三连哦~

7天玩转 Golang 标准库之 os