Golang os模块功能详解与示例

os 是 Go 语言标准库中与操作系统交互的核心模块，提供了丰富的功能来操作文件系统、进程、环境变量等。下面我将详细介绍 os 模块的主要功能，并提供相应的代码示例。

1. 文件与目录操作

1.1 文件操作

创建文件

package main

import (
	"fmt"
	"os"
)

func main() {
	file, err := os.Create("test.txt")
	if err != nil {
		fmt.Println("Error creating file:", err)
		return
	}
	defer file.Close()
	
	fmt.Println("File created successfully")
}

打开文件

func main() {
	// 只读方式打开
	file, err := os.Open("test.txt")
	if err != nil {
		fmt.Println("Error opening file:", err)
		return
	}
	defer file.Close()
	
	// 读写方式打开
	file, err = os.OpenFile("test.txt", os.O_RDWR|os.O_CREATE, 0644)
	if err != nil {
		fmt.Println("Error opening file:", err)
		return
	}
	defer file.Close()
}

文件信息

func main() {
	fileInfo, err := os.Stat("test.txt")
	if err != nil {
		fmt.Println("Error getting file info:", err)
		return
	}
	
	fmt.Println("File name:", fileInfo.Name())
	fmt.Println("Size:", fileInfo.Size(), "bytes")
	fmt.Println("Permissions:", fileInfo.Mode())
	fmt.Println("Last modified:", fileInfo.ModTime())
	fmt.Println("Is directory:", fileInfo.IsDir())
}

读写文件

func main() {
	// 写入文件
	err := os.WriteFile("test.txt", []byte("Hello, Go!"), 0644)
	if err != nil {
		fmt.Println("Error writing file:", err)
		return
	}
	
	// 读取文件
	data, err := os.ReadFile("test.txt")
	if err != nil {
		fmt.Println("Error reading file:", err)
		return
	}
	fmt.Println("File content:", string(data))
}

删除文件

func main() {
	err := os.Remove("test.txt")
	if err != nil {
		fmt.Println("Error removing file:", err)
		return
	}
	fmt.Println("File removed successfully")
}

1.2 目录操作

创建目录

func main() {
	// 创建单个目录
	err := os.Mkdir("mydir", 0755)
	if err != nil {
		fmt.Println("Error creating directory:", err)
		return
	}
	
	// 创建多级目录
	err = os.MkdirAll("parent/child/grandchild", 0755)
	if err != nil {
		fmt.Println("Error creating directories:", err)
		return
	}
}

读取目录

func main() {
	entries, err := os.ReadDir(".")
	if err != nil {
		fmt.Println("Error reading directory:", err)
		return
	}
	
	fmt.Println("Directory contents:")
	for _, entry := range entries {
		fmt.Println(entry.Name())
	}
}

删除目录

func main() {
	// 删除空目录
	err := os.Remove("mydir")
	if err != nil {
		fmt.Println("Error removing directory:", err)
	}
	
	// 递归删除目录及其内容
	err = os.RemoveAll("parent")
	if err != nil {
		fmt.Println("Error removing directories:", err)
	}
}

2. 环境变量操作

获取环境变量

func main() {
	// 获取单个环境变量
	path := os.Getenv("PATH")
	fmt.Println("PATH:", path)
	
	// 获取所有环境变量
	envs := os.Environ()
	for _, env := range envs {
		fmt.Println(env)
	}
}

设置环境变量

func main() {
	// 设置环境变量
	err := os.Setenv("MY_VAR", "my_value")
	if err != nil {
		fmt.Println("Error setting environment variable:", err)
		return
	}
	
	// 验证设置
	value := os.Getenv("MY_VAR")
	fmt.Println("MY_VAR:", value)
	
	// 取消设置
	err = os.Unsetenv("MY_VAR")
	if err != nil {
		fmt.Println("Error unsetting environment variable:", err)
	}
}

3. 进程操作

获取进程信息

func main() {
	// 当前进程ID
	pid := os.Getpid()
	fmt.Println("Process ID:", pid)
	
	// 父进程ID
	ppid := os.Getppid()
	fmt.Println("Parent Process ID:", ppid)
	
	// 当前工作目录
	wd, err := os.Getwd()
	if err != nil {
		fmt.Println("Error getting working directory:", err)
		return
	}
	fmt.Println("Working Directory:", wd)
	
	// 用户信息
	fmt.Println("User ID:", os.Getuid())
	fmt.Println("Group ID:", os.Getgid())
	fmt.Println("Effective User ID:", os.Geteuid())
	fmt.Println("Effective Group ID:", os.Getegid())
}

修改工作目录

func main() {
	// 获取当前目录
	wd, _ := os.Getwd()
	fmt.Println("Current directory:", wd)
	
	// 修改工作目录
	err := os.Chdir("/tmp")
	if err != nil {
		fmt.Println("Error changing directory:", err)
		return
	}
	
	// 验证修改
	newWd, _ := os.Getwd()
	fmt.Println("New directory:", newWd)
	
	// 恢复原目录
	os.Chdir(wd)
}

退出进程

func main() {
	defer fmt.Println("This will not be printed")
	
	// 立即退出进程，不执行defer
	os.Exit(1)
	
	fmt.Println("This will not be printed either")
}

4. 文件权限与所有权

修改文件权限

func main() {
	// 创建测试文件
	os.WriteFile("permission.txt", []byte("test"), 0644)
	
	// 修改权限为只读
	err := os.Chmod("permission.txt", 0444)
	if err != nil {
		fmt.Println("Error changing permissions:", err)
		return
	}
	
	// 验证修改
	info, _ := os.Stat("permission.txt")
	fmt.Println("New permissions:", info.Mode())
}

修改文件所有者

func main() {
	// 创建测试文件
	os.WriteFile("owner.txt", []byte("test"), 0644)
	
	// 修改文件所有者
	// 注意: 通常需要root权限才能修改所有者
	err := os.Chown("owner.txt", 1000, 1000) // UID和GID
	if err != nil {
		fmt.Println("Error changing owner:", err)
	}
}

5. 高级文件操作

文件链接

func main() {
	// 创建源文件
	os.WriteFile("source.txt", []byte("original content"), 0644)
	
	// 创建硬链接
	err := os.Link("source.txt", "hardlink.txt")
	if err != nil {
		fmt.Println("Error creating hard link:", err)
	}
	
	// 创建符号链接
	err = os.Symlink("source.txt", "symlink.txt")
	if err != nil {
		fmt.Println("Error creating symlink:", err)
	}
	
	// 读取符号链接指向的目标
	target, err := os.Readlink("symlink.txt")
	if err != nil {
		fmt.Println("Error reading symlink:", err)
	} else {
		fmt.Println("Symlink points to:", target)
	}
}

文件截断

func main() {
	// 创建测试文件
	os.WriteFile("truncate.txt", []byte("This is a long content"), 0644)
	
	// 截断文件为10字节
	err := os.Truncate("truncate.txt", 10)
	if err != nil {
		fmt.Println("Error truncating file:", err)
		return
	}
	
	// 验证结果
	data, _ := os.ReadFile("truncate.txt")
	fmt.Println("Truncated content:", string(data)) // 输出: "This is a"
}

6. 临时文件与目录

创建临时文件

func main() {
	// 在默认临时目录创建临时文件
	tempFile, err := os.CreateTemp("", "example.*.txt")
	if err != nil {
		fmt.Println("Error creating temp file:", err)
		return
	}
	defer os.Remove(tempFile.Name()) // 清理
	
	fmt.Println("Temp file name:", tempFile.Name())
	
	// 写入内容
	_, err = tempFile.Write([]byte("temporary content"))
	if err != nil {
		fmt.Println("Error writing to temp file:", err)
	}
	
	// 重置文件指针到开头
	tempFile.Seek(0, 0)
	
	// 读取内容
	content, _ := io.ReadAll(tempFile)
	fmt.Println("Temp file content:", string(content))
}

创建临时目录

func main() {
	// 在默认临时目录创建临时目录
	tempDir, err := os.MkdirTemp("", "example")
	if err != nil {
		fmt.Println("Error creating temp dir:", err)
		return
	}
	defer os.RemoveAll(tempDir) // 清理
	
	fmt.Println("Temp dir:", tempDir)
	
	// 在临时目录中创建文件
	tempFile := filepath.Join(tempDir, "test.txt")
	err = os.WriteFile(tempFile, []byte("test"), 0644)
	if err != nil {
		fmt.Println("Error creating file in temp dir:", err)
	}
}

7. 标准输入/输出/错误

func main() {
	// 标准输入、输出、错误
	fmt.Println("Standard Output")
	fmt.Fprintln(os.Stdout, "Also standard output")
	fmt.Fprintln(os.Stderr, "Standard Error")
	
	// 从标准输入读取
	fmt.Print("Enter text: ")
	scanner := bufio.NewScanner(os.Stdin)
	if scanner.Scan() {
		fmt.Println("You entered:", scanner.Text())
	}
}

8. 文件路径操作

虽然 path/filepath 包专门处理路径，但 os 也提供了一些基本功能：

获取可执行文件路径

func main() {
	// 获取当前可执行文件路径
	exePath, err := os.Executable()
	if err != nil {
		fmt.Println("Error getting executable path:", err)
		return
	}
	fmt.Println("Executable path:", exePath)
}

路径分隔符

func main() {
	fmt.Println("Path separator:", string(os.PathSeparator))   // 通常 "/" 或 "\"
	fmt.Println("Path list separator:", string(os.PathListSeparator)) // 通常 ":" 或 ";"
}

9. 信号处理

func main() {
	// 创建信号通道
	sigChan := make(chan os.Signal, 1)
	
	// 注册要接收的信号
	signal.Notify(sigChan, os.Interrupt, syscall.SIGTERM)
	
	fmt.Println("Waiting for signal... Press Ctrl+C to interrupt")
	
	// 阻塞等待信号
	sig := <-sigChan
	fmt.Printf("Received signal: %v\n", sig)
	
	// 执行清理工作...
	fmt.Println("Cleaning up...")
}

10. 用户与组查询

func main() {
	// 当前用户
	currentUser, err := user.Current()
	if err != nil {
		fmt.Println("Error getting current user:", err)
		return
	}
	fmt.Printf("Current user: %+v\n", currentUser)
	
	// 根据用户名查询用户
	userInfo, err := user.Lookup("root")
	if err != nil {
		fmt.Println("Error looking up user:", err)
	} else {
		fmt.Printf("Root user info: %+v\n", userInfo)
	}
	
	// 根据组ID查询组
	groupInfo, err := user.LookupGroupId(currentUser.Gid)
	if err != nil {
		fmt.Println("Error looking up group:", err)
	} else {
		fmt.Printf("Group info: %+v\n", groupInfo)
	}
}

总结

os 模块提供了与操作系统交互的丰富功能，包括：

1. 文件系统操作：创建、读写、删除文件和目录
2. 环境变量管理：获取、设置和取消设置环境变量
3. 进程控制：获取进程信息、修改工作目录、退出进程
4. 权限管理：修改文件权限和所有权
5. 高级文件操作：链接、截断、临时文件
6. 标准I/O：访问标准输入、输出和错误
7. 信号处理：捕获和处理系统信号
8. 用户/组查询：获取用户和组信息

这些功能使得 Go 程序能够与操作系统进行深度交互，实现各种系统级操作。在实际开发中，应结合 io、path/filepath 等相关包一起使用，以构建更强大的功能。