golang-cookbook

Appearance

在 Go 语言中，os 包提供了与操作系统交互的功能，允许你执行文件和目录操作、进程管理、环境变量访问等操作。os 包是 Go 标准库中的核心包之一，常用于文件读写、路径操作、环境变量获取等。

1. 文件和目录操作 ​

1.1. 打开和创建文件 ​

  • os.Open()：打开一个文件用于读取，文件必须存在。
go
file, err := os.Open("example.txt")
if err != nil {
    log.Fatal(err)
}
defer file.Close()
  • os.Create()：创建一个文件，如果文件已经存在，则截断文件（即清空内容），用于写入。
go
file, err := os.Create("newfile.txt")
if err != nil {
    log.Fatal(err)
}
defer file.Close()

1.2. 读取文件 ​

读取文件的内容可以通过 os.File 的 Read 方法或 ioutil.ReadFile() 来实现。以下是使用 os.Open() 打开文件并读取数据的示例：

go
file, err := os.Open("example.txt")
if err != nil {
    log.Fatal(err)
}
defer file.Close()

content := make([]byte, 1024)
n, err := file.Read(content)
if err != nil && err != io.EOF {
    log.Fatal(err)
}

fmt.Printf("Read %d bytes: %s\n", n, content[:n])

1.3. 写入文件 ​

使用 os.File 的 Write 方法将数据写入文件：

go
file, err := os.Create("output.txt")
if err != nil {
    log.Fatal(err)
}
defer file.Close()

content := []byte("Hello, Go!")
_, err = file.Write(content)
if err != nil {
    log.Fatal(err)
}

或者使用 WriteString：

go
file, err := os.Create("output.txt")
if err != nil {
    log.Fatal(err)
}
defer file.Close()

_, err = file.WriteString("Hello, Go!")
if err != nil {
    log.Fatal(err)
}

1.4. 获取文件信息 ​

你可以使用 os.Stat() 获取文件或目录的信息：

go
fileInfo, err := os.Stat("example.txt")
if err != nil {
    log.Fatal(err)
}

fmt.Println("File size:", fileInfo.Size())
fmt.Println("Is directory:", fileInfo.IsDir())
fmt.Println("Last modified:", fileInfo.ModTime())

1.5. 删除文件 ​

os.Remove() 用于删除文件或空目录：

go
err := os.Remove("file_to_delete.txt")
if err != nil {
    log.Fatal(err)
}

删除非空目录需要使用 os.RemoveAll()：

go
err := os.RemoveAll("directory_to_delete")
if err != nil {
    log.Fatal(err)
}

1.6. 创建目录 ​

使用 os.Mkdir() 创建一个目录，或者 os.MkdirAll() 创建多级目录（如果父目录不存在会一并创建）：

go
err := os.Mkdir("newdir", 0755)
if err != nil {
    log.Fatal(err)
}

err = os.MkdirAll("parentdir/childdir", 0755)
if err != nil {
    log.Fatal(err)
}

1.7. 列出目录内容 ​

os.ReadDir() 返回指定目录的文件列表：

go
entries, err := os.ReadDir(".")
if err != nil {
    log.Fatal(err)
}

for _, entry := range entries {
    fmt.Println(entry.Name())
}

2. 路径操作 ​

Go 提供了一些帮助函数来操作文件路径，通常与 path/filepath 和 os 包一起使用。

2.1. 获取当前工作目录 ​

go
cwd, err := os.Getwd()
if err != nil {
    log.Fatal(err)
}
fmt.Println("Current working directory:", cwd)

2.2. 改变工作目录 ​

go
err := os.Chdir("/path/to/directory")
if err != nil {
    log.Fatal(err)
}

2.3. 路径连接 ​

使用 path/filepath.Join() 来连接文件路径，确保路径的正确性（自动处理不同操作系统的分隔符）：

go
import "path/filepath"

path := filepath.Join("folder", "subfolder", "file.txt")
fmt.Println(path)

2.4. 获取文件绝对路径 ​

go
absolutePath, err := filepath.Abs("example.txt")
if err != nil {
    log.Fatal(err)
}
fmt.Println("Absolute path:", absolutePath)

2.5. 路径是否存在 ​

go
_, err := os.Stat("example.txt")
if os.IsNotExist(err) {
    fmt.Println("File does not exist")
} else if err != nil {
    fmt.Println("Error:", err)
} else {
    fmt.Println("File exists")
}

3. 环境变量 ​

Go 语言允许你读取和设置环境变量。os 包提供了 Getenv、Setenv 和 Unsetenv 等函数来访问和操作环境变量。

3.1. 获取环境变量 ​

go
value := os.Getenv("HOME")
fmt.Println("HOME environment variable:", value)

3.2. 设置环境变量 ​

go
err := os.Setenv("MY_VAR", "some_value")
if err != nil {
    log.Fatal(err)
}

fmt.Println("MY_VAR is set")

3.3. 删除环境变量 ​

go
err := os.Unsetenv("MY_VAR")
if err != nil {
    log.Fatal(err)
}

fmt.Println("MY_VAR has been removed")

4. 进程管理 ​

os 包也提供了一些管理操作系统进程的功能，例如获取进程的 ID 或终止进程。

4.1. 获取进程 ID ​

go
pid := os.Getpid()
fmt.Println("Current process ID:", pid)

4.2. 获取父进程 ID ​

go
ppid := os.Getppid()
fmt.Println("Parent process ID:", ppid)

4.3. 终止进程 ​

go
os.Exit(1) // 退出程序，状态码为 1 表示程序异常退出

5. 文件权限 ​

os 包还可以用来获取或修改文件的权限。

5.1. 获取文件权限 ​

go
fileInfo, err := os.Stat("example.txt")
if err != nil {
    log.Fatal(err)
}

fmt.Printf("File permissions: %s\n", fileInfo.Mode())

5.2. 修改文件权限 ​

go
err := os.Chmod("example.txt", 0644)
if err != nil {
    log.Fatal(err)
}

5.3. 修改文件的拥有者 ​

go
err := os.Chown("example.txt", 1001, 1001) // 用户ID、组ID
if err != nil {
    log.Fatal(err)
}

6. 系统调用与信号处理 ​

Go 的 os 包也支持系统级的信号处理和其他低级操作。

6.1. 处理信号 ​

通过 os/signal 包来处理操作系统信号（如终止、挂起等），并响应特定信号：

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

func main() {
    sigs := make(chan os.Signal, 1)
    signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)

    sig := <-sigs
    fmt.Println("Received signal:", sig)
}

7. 总结 ​

  • os 包提供了与操作系统交互的多种功能，包括文件、目录操作，进程管理，环境变量访问等。
  • 常用功能包括文件的打开、创建、删除，路径操作（如获取绝对路径、路径连接），以及进程的管理（如获取进程 ID，退出进程等）。
  • 通过 os 包，你可以实现基本的文件系统操作、环境配置管理和跨平台的路径处理等。

使用 os 包可以帮助你在 Go 程序中与操作系统进行交互，处理文件和目录，管理进程和环境变量等。