os 包提供了对文件、系统和进程的操作函数

一、文件操作

1.1 常用常量

  • Stdin
  • Stdout
  • Stderr

  • ModePerm：0777

    1.2 常用函数

  • Chmod：修改文件权限

  • Chown：修改文件所属用户，用户组
  • Chtimes：修改文件访问时间和修改时间
  • IsExist:与 os.Stat 一起用于判断文件存在
  • IsNotExist:与 os.Stat 一起用于判断文件不存在
  • Link:创建软链接
  • Mkdir：创建文件夹
  • MkdirAll:创建文件夹（父目录不存在逐层创建）
  • Remove：移除文件或空文件夹
  • RemoveAll：移除所有文件

  • Rename：重命名

    1.3 常用结构体

  • File:对文件操作

    1.3.1 常用函数

  • Create：创建文件并返回文件对象指针（文件不存在则创建，文件存在则清空）

  • Open：打开文件并返回文件对象指针

  • OpenFile：按指定权限打开文件，并返回文件指针对象

    1.3.2 常用方法

  • Read：读取文件到字节切片

  • Write：写入字节切片到文件
  • WriteString：写入字符串到文件
  • Readdir：获取目录下所有文件信息
  • Readdirnames：获取目录下所有文件名
  • Seek：设置文件指针位置
  • Stat：获取文件状态信息
  • Sync：同步文件到硬盘

  • Close：关闭文件

    二、方法使用

    2.1 读取一个文件(不带缓冲的IO读取)

    1. func main() {
    2.   path := "text.txt"
    3.   f, err := os.Open(path)
    4.   if err != nil {
    5.       fmt.Println(err)
    6.       return
    7.   }
    8.   content := make([]byte, 1024)
    9.   for {
    10.       n, err := f.Read(content)
    11.       if err != nil {
    12.           if err != io.EOF {
    13.               fmt.Println(err)
    14.           }
    15.           break
    16.       }
    17.       fmt.Println(string(content[:n]))
    18.   }
    19.   f.Close()
    20. }

    2.2 创建文件

    os.Create 写文件，文件存在截断(清空)，文件不存在创建
    os.open 读取文件，文件不存在报错

    1. func main() {
    2.   path := "text.txt"
    3.   f, err := os.Create(path)
    4.   if err != nil {
    5.       fmt.Println(err)
    6.       return
    7.   }
    8.   defer f.Close()
    9.   f.Write([]byte("123456\n"))
    10.   f.Write([]byte("休息休息\n"))
    11.   f.WriteString("我是大冬")
    12. }

    2.3 标准输入输出

    标准输入 => 命令行的文件 os.Stdin
    标准输出 => 命令行的文件 os.Stdout
    标准错误输出 => 命令行的文件 os.Stderr

    1. func main() {
    2.   content := make([]byte, 3)
    3.   fmt.Print("请输入内容：")
    4.   os.Stdin.Read(content)
    5.   fmt.Println(string(content))
    6.   fmt.Printf("%q\n", string(content))
    8.   os.Stdout.WriteString("我是Stdout输出")
    10.   //fmt.Scan
    11.   //fmt.Sscan => 从字符串扫描到变量
    12.   //fmt.Fscan => 从文件扫描到变量
    13. }

    2.3.1 openfile

    func OpenFile(name string, flag int, perm FileMode) (*File, error)

  • name 代表文件的路径

  • flag 代表打开的方式
    • O_RDONLY 以只读方式打开
    • O_WRONLY 以只写方式打开
    • O_RDWR 以读写方式打开
    • O_APPEND 追加
    • O_CREATE 文件不存在时创建
    • O_EXCL 文件必须不存在
    • O_SYNC 使用同步IO
    • O_TRUNC 截断文件
  • perm 文件的权限
    1. # 日志文件存在追加方式
    2. func main() {
    3.   f, err := os.OpenFile("test.log", os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0777)
    4.   if err != nil {
    5.       return
    6.   }
    7.   defer f.Close()
    8.   fmt.Fprintf(f,"%s\n",time.Now().Format("2006-01-02 15:04:05"))
    9. }

    2.4 创建带有缓冲的buf

    2.4.1 带有缓冲的读取

    1. f, err := os.Open("text.txt")
    2.   if err != nil {
    3.       fmt.Println(err)
    4.       return
    5.   }
    6.   defer f.Close()
    7.   reader := bufio.NewReader(f)
    8. // 每行进行读取
    9.   fmt.Println(reader.ReadLine())

    2.4.2 带有缓冲的写入

    ```go func main() { f, err := os.Create(“text.txt”) if err != nil {
    1.   return
    } defer f.Close() writer := bufio.NewWriter(f) writer.WriteString(“hello 大冬\n”) writer.Flush() }
  1. <a name="DXgzd"></a>
  2. # 三、文件的操作
  3. ![](https://cdn.nlark.com/yuque/0/2021/jpeg/2788129/1627885581095-1d170f44-e2bb-4447-9e3a-c9d146c8d04e.jpeg)
  4. - 文件
  5.    - 创建 => `os.Create`
  6.    - 读取 => `os.Open`
  7.    - 获取属性 => `os.Open().Stat` / `os.Stat`
  8.    - 修改属性 => 权限，所属人
  9.       - `os.Chmod()` 修改权限
  10.       - `os.Chown()` 修改所属人
  11.    - 重命名
  12.       - `os.Rename()`
  13.    - 删除文件
  14.       - `os.Remove()`
  15. - 目录
  16.    - 创建
  17.       - `os.Mkdir("a",os.ModePerm)`
  18.       - `os.MkdirAll("a/b/c",os.ModePerm)`
  19.    - 读取 
  20.       - `os.Open`
  21.    - 获取属性
  22.       - `os.Open().Stat`
  23.       -  `os.Stat`
  24.    - 修改属性
  25.       - `os.Chmod()` 修改权限
  26.       - `os.Chown()` 修改所属人
  27.    - 重命名文件夹(移动)
  28.       - `os.Rename()`
  29.    - 删除文件夹
  30.       - `os.Remove()`
  31.       - `os.RemoveAll()`
  32. <a name="EZB0H"></a>
  33. # 四、ioutil包
  34. ![](https://cdn.nlark.com/yuque/0/2021/jpeg/2788129/1627885558156-2984b69c-caa1-4a48-83f0-db23f6a14e48.jpeg)<a name="QfW15"></a>
  35. ## 4.1 读取
  36. `ioutil.ReadAll()` 读取所有open打开的内容<br />`ioutil.ReadFile()` 直接读取文件，不需要先open<br />`ioutil.ReadDir()` 读取目录所有文件
  37. <a name="VmNjW"></a>
  38. ## 4.2 写入
  39. `ioutil.WriteFile()` 直接写入文件 => `ioutil.WriteFile("text.txt", []byte("123456"), os.ModePerm)`
  40. <a name="VRetW"></a>
  41. # 五、Path
  42. ![](https://cdn.nlark.com/yuque/0/2021/jpeg/2788129/1627885560611-49aa0927-d16d-4a83-a724-3b96451a70e6.jpeg)<a name="Wr05H"></a>
  43. ## 5.1 filepath
  44. 获取：
  46. - `filepath.Abs()` 获取文件的绝对路径
  47. - `filepath.Base()` 获取文件的名称
  48. - `filepath.Dir()`    获取文件的父目录
  49. - `filepath.Ext()` 获取文件后缀
  50. - `filepath.Glob("dir/*/*.go")` 获取dir目录里面所有子目录里的`*.go`文件 
  51. - `filepath.Walk` 获取所有子目录文件(递归)
  53. 分割和连接：
  55. - `filepath.Split()` 分割文件的父目录和文件名称
  56. - `filepath.SplitList("a;b;c")` 通过`;`分号进行分割
  57. - `filepath.Join("d:\\a","b/c/d")` 连接路径
  59. 判断：
  61. - `filepath.HasPrefix("main.go","D:\\a")` 判断是否在路径下
  62. - `filepath.IsAbs()` 判断是否是绝对路径
  64. `filepath.Walk`示例：
  65. ```go
  66. filepath.Walk("testdir", func(path string, info fs.FileInfo, err error) error {
  67.         fmt.Println(path,info.Name())
  68.         return nil
  69.     })

六、文件格式

6.1 gob文件编解码

编码一段gob文件

  1. type User struct {
  2.     Id int
  3.     Name string
  4. }
  6. func main() {
  7.     users := []User{
  8.         {1, "dadong"},
  9.         {2, "dd"},
  10.         {3, "xxd"},
  11.     }
  12.     gob.Register(User{})
  13.     file, err := os.Create("dd.gob")
  14.     if err != nil {
  15.         return
  16.     }
  17.     defer file.Close()
  18.     encoder := gob.NewEncoder(file)
  19.     encoder.Encode(users)
  20. }

解码

  1. type User struct {
  2.     Id int
  3.     Name string
  4. }
  6. func main() {
  7.     gob.Register(User{})
  8.     file,err:=os.Open("dd.gob")
  9.     if err != nil {
  10.         return
  11.     }
  12.     defer file.Close()
  13.     decoder := gob.NewDecoder(file)
  15.     var users []User
  16.     fmt.Println(decoder.Decode(&users))
  17.     fmt.Println(users)
  18. }