登录/ 注册
 找回密码
 立即注册
关闭

CSDN热搜

程序园 精品问答 技术交流 资源下载
返回列表 发新帖
首页 › 业界区 › 安全 ›16.目录与文件

16.目录与文件

艺轫 2025-10-1 12:58:24
猛犸象科技工作室:网站开发，备案域名，渗透，服务器出租，DDOS/CC攻击，TG加粉引流
16.目录与文件

    任何编程语言在运行时都依赖于操作系统，所以程序在运行时会对系统文件、目录等执行一些相应操作，例如文件读写、执行系统命令、创建新的目录等。在Go语言中，可以使用内置包os实现了多种操作系统的操作指令，如主机、用户、进程、环境变量、目录与文件操作、终端执行等。
16.1 路径操作

    存储设备保存着各种各样的数据，但需要一种方便快捷的模式让用户可以快速定位到相应数据资源的位置，而操作系统则提供一种基于路径字符串的表达式来解决此类问题，它像一棵倒置的层级目录树，从根开始。

  • 相对路径：不是以根目录开始的路径，例如：../xx、./xx
  • 绝对路径：以斜杆做为开始的路径，例如：/home/、/var/log、C:\windows
  • 路径分隔符：不同的操作系统的路径分隔符也不太一样，Windows的分隔符为 \，而Linux系统则为 /
    为了方便处理，Go语言标准库提供path包和path/filepath来处理路径问题。而path/filepath是path的扩展，使用起来更加方便，一般使用path/filepath即可
16.1.1 路径拼接

    由于路径是字符串，直接使用字符串拼接即可完成，另外也可以使用join方法，示例如下所示：
  1. package main
  3. import (
  4.         "fmt"
  5.         "path/filepath"
  6. )
  8. func main() {
  9.         pathA := "C:" + "\\surpass" + "\" + "data"
  10.         pathB := filepath.Join("C:", "\\surpass", "\", "data")
  11.         fmt.Printf("pathA: %+v\n", pathA)
  12.         fmt.Printf("pathB: %+v\n", pathB)
  13. }
复制代码
    代码运行结果如下所示：
  1. pathA: C:\surpass\data
  2. pathB: C:\surpass\data
复制代码
16.1.2 路径分解

    在一些场景下，我们仅需要路径中的一部分数据，这时候则可以使用路径分解功能，示例代码如下所示：
  1. package main
  3. import (
  4.         "fmt"
  5.         "path/filepath"
  6. )
  8. func main() {
  9.         path := filepath.Join("C:", "\\surpass", "\", "data", "\\surpass.json")
  10.         // 拆解出路径和文件名
  11.         dir, file := filepath.Split(path)
  12.         fmt.Printf("路径为：%+v,文件名为：%+v\n", dir, file)
  13.         // 功能类似于dirname 和 basename
  14.         fmt.Printf("路径为：%+v,文件名为：%+v,扩展名为：%+v\n", filepath.Dir(path), filepath.Base(path), filepath.Ext(path))
  15. }
复制代码
    代码运行结果如下所示：
  1. 路径为：C:\surpass\data\,文件名为：surpass.json
  2. 路径为：C:\surpass\data,文件名为：surpass.json,扩展名为：.json
复制代码
16.1.3 其他功能

    示例代码如下所示：
  1. package main
  3. import (
  4.         "fmt"
  5.         "path/filepath"
  6. )
  8. func main() {
  9.         pathA := filepath.Join("C:", "\\surpass", "\", "data", "\\surpass.json")
  10.         pathB := filepath.Join("..", "\\surpass", "\\data")
  11.         // 判断是否为绝对路径
  12.         fmt.Printf("pathA是否为绝对路径：%+v,pathB是否为绝对路径：%+v\n", filepath.IsAbs(pathA), filepath.IsAbs(pathB))
  14.         // 在使用Clean函数后，返回等价的最短路径
  15.         // 清除当前路径中的 . 和 ..
  16.         // 使用Join方法时，会自动调用Clean方法
  17.         pathC := "\\surpass\\test\\data\" + "..\\.." + "\\test\" + "\\code"
  18.         pathD := filepath.Join("\\surpass\\test\\data\", "..\\..", "\\test", "\\code")
  19.         fmt.Printf("原始pathC：%+v,调用Clean方法之后:%+v\n", pathC, filepath.Clean(pathC))
  20.         fmt.Printf("调用Join方法之后pathD：%+v\n", pathD)
  22.         // 路径匹配
  23.         pathE := filepath.Join("data-1")
  24.         // 匹配0个或多个非 / 字符
  25.         if matchE, err := filepath.Match("*", pathE); err == nil {
  26.                 fmt.Printf("pathE: %+v,匹配结果：%+v\n", pathE, matchE)
  27.         }
  28.         if matchF, err := filepath.Match("data-[0-9]", pathE); err == nil {
  29.                 fmt.Printf("pathE: %+v,匹配结果：%+v\n", pathE, matchF)
  30.         }
  31. }
复制代码
    代码运行结果如下所示：
  1. pathA是否为绝对路径：true,pathB是否为绝对路径：false
  2. 原始pathC：\surpass\test\data\..\..\test\\code,调用Clean方法之后:\surpass\test\code
  3. 调用Join方法之后pathD：\surpass\test\code
  4. pathE: data-1,匹配结果：true
  5. pathE: data-1,匹配结果：true
复制代码
16.2 目录操作

16.2.1 常规操作

    示例代码如下所示：
  1. package main
  3. import (
  4.         "fmt"
  5.         "os"
  6. )
  8. func main() {
  9.         // 获取当前目录
  10.         if curPath, err := os.Getwd(); err == nil {
  11.                 fmt.Printf("当前目录：%+v\n", curPath)
  12.         }
  14.         // 获取当前家目录
  15.         if userDir, err := os.UserHomeDir(); err == nil {
  16.                 fmt.Printf("家目录：%+v\n", userDir)
  17.         }
  19.         // 切换目录路径
  20.         os.Chdir("F:\")
  21.         if curPath, err := os.Getwd(); err == nil {
  22.                 fmt.Printf("当前目录：%+v\n", curPath)
  23.         }
  25.         // 创建目录或多级目录
  26.         dirnameA := "F:\\testA"
  27.         dirnameB := "F:\\testA\\surpassA\\surpassB"
  28.         oldDirnameC := "F:\\testA\\surpassC"
  29.         newDirnameC := "F:\\testA\\surpassC-NewDirName"
  30.         os.Mkdir(dirnameA, os.ModePerm)    // 相当于mkdir，要求父路径都已经存在，才能创建目录成功，否则报错
  31.         os.MkdirAll(dirnameB, os.ModePerm) // 相当于mkdir -p
  32.         os.MkdirAll(oldDirnameC, os.ModePerm)
  34.         // 判断目录是否存在
  35.         if _, err := os.Stat(dirnameB); err == nil {
  36.                 fmt.Printf("路径: %+v 存在\n", dirnameB)
  37.         }
  39.         _, err := os.Stat(dirnameB)
  40.         fmt.Printf("文件是否不存在？%+v\n", os.IsNotExist(err))
  42.         // 文件夹重命名
  43.         os.Rename(oldDirnameC, newDirnameC)
  44.         // 删除目录
  45.         os.Remove(dirnameB)    // 相当于 rm -f
  46.         os.RemoveAll(dirnameA) // 相当于rm -rf
  48.         if _, err := os.Stat(dirnameB); err != nil {
  49.                 fmt.Printf("路径: %+v 不存在\n", dirnameB)
  50.         }
  52.         // 判断目录是否存在
  53.         _, err = os.Stat(dirnameB)
  54.         fmt.Printf("文件是否不存在？%+v\n", os.IsNotExist(err))
  55. }
复制代码
    在创建目录时，注意事项如下所示：

  • os.Mkdir()  ：相当于mkdir，要求父路径都已经存在，才能创建目录成功，否则报错
  • os.MkdirAll() ：相当于mkdir -p
  • os.Remove() ：相当于 rm -f
  • os.RemoveAll()：相当于rm -rf
    代码运行结果如下所示：
  1. 当前目录：c:\Users\Surpass\Documents\GolangProjets\src\go-learning-note\02-代码\16\1605-目录操作
  2. 家目录：C:\Users\Surpass
  3. 当前目录：F:\
  4. 路径: F:\testA\surpassA\surpassB 存在
  5. 文件是否不存在？false
  6. 路径: F:\testA\surpassA\surpassB 不存在
  7. 文件是否不存在？true
复制代码
16.2.2 目录遍历

    在日常开发过程，目录遍历是非常重要的，而遍历目录又可以分为遍历当前目录和递归遍历目录，可以使用以下方法对目录进行遍历，示例代码如下所示：

  • 目录结构：
  1. Test/
  2. ├── data-1
  3. │   ├── data-11
  4. │   │   └── data-11.json
  5. │   └── data-12
  6. ├── data-2
  7. │   └── data-21
  8. │       └── data-21.txt
  9. └── test.txt
复制代码

  • 目录遍历代码
  1. package main
  3. import (
  4.         "fmt"
  5.         "io/fs"
  6.         "io/ioutil"
  7.         "os"
  8.         "path/filepath"
  9. )
  11. func main() {
  12.         dir := "F:\\Test"
  13.         fmt.Println("仅遍历当前目录，但不递归-使用os.ReadDir")
  14.         // 仅遍历当前目录，但不递归
  15.         if de, err := os.ReadDir(dir); err != nil {
  16.                 fmt.Printf("遍历目录%+v出错，错误信息:%+v\n", dir, err)
  17.         } else {
  18.                 for i, v := range de {
  19.                         fmt.Printf("索引%+v - 名字: %+v 是否为文件夹： %+v\n", i, v.Name(), v.IsDir())
  20.                 }
  21.         }
  23.         fmt.Println("仅遍历当前目录，但不递归-使用ioutil.ReadDir")
  24.         // 仅遍历当前目录，但不递归，但推荐使用os.ReadDir()
  25.         if fileInfo, err := ioutil.ReadDir(dir); err != nil {
  26.                 fmt.Printf("遍历目录%+v出错，错误信息:%+v\n", dir, err)
  27.         } else {
  28.                 for i, v := range fileInfo {
  29.                         fmt.Printf("索引%+v - 名字: %+v 是否为文件夹： %+v\n", i, v.Name(), v.IsDir())
  30.                 }
  31.         }
  33.         fmt.Println("递归遍历目录-使用filepath.WalkDir")
  34.         // 递归遍历目录，且包含自身
  35.         filepath.WalkDir(dir, func(path string, d fs.DirEntry, err error) error {
  36.                 fmt.Printf("路径: %+v 文件或文件夹: %+v\n", path, d.Name())
  37.                 return err
  38.         })
  39.        
  40.         fmt.Println("递归遍历目录-使用filepath.Walk")
  41.         filepath.Walk(dir, func(path string, info fs.FileInfo, err error) error {
  42.                 fmt.Printf("路径: %+v 文件或文件夹: %+v\n", path, info.Name())
  43.                 return err
  44.         })
  45. }
复制代码
    代码运行结果如下所示：
  1. 仅遍历当前目录，但不递归-使用os.ReadDir
  2. 索引0 - 名字: data-1 是否为文件夹： true
  3. 索引1 - 名字: data-2 是否为文件夹： true
  4. 索引2 - 名字: test.txt 是否为文件夹： false
  6. 仅遍历当前目录，但不递归-使用ioutil.ReadDir
  7. 索引0 - 名字: data-1 是否为文件夹： true
  8. 索引1 - 名字: data-2 是否为文件夹： true
  9. 索引2 - 名字: test.txt 是否为文件夹： false
  11. 递归遍历目录-使用filepath.WalkDir
  12. 路径: F:\Test 文件或文件夹: Test
  13. 路径: F:\Test\data-1 文件或文件夹: data-1
  14. 路径: F:\Test\data-1\data-11 文件或文件夹: data-11
  15. 路径: F:\Test\data-1\data-11\data-11.json 文件或文件夹: data-11.json
  16. 路径: F:\Test\data-1\data-12 文件或文件夹: data-12
  17. 路径: F:\Test\data-2 文件或文件夹: data-2
  18. 路径: F:\Test\data-2\data-21 文件或文件夹: data-21
  19. 路径: F:\Test\data-2\data-21\data=21.txt 文件或文件夹: data=21.txt
  20. 路径: F:\Test\test.txt 文件或文件夹: test.txt
  22. 递归遍历目录-使用filepath.Walk
  23. 路径: F:\Test 文件或文件夹: Test
  24. 路径: F:\Test\data-1 文件或文件夹: data-1
  25. 路径: F:\Test\data-1\data-11 文件或文件夹: data-11
  26. 路径: F:\Test\data-1\data-11\data-11.json 文件或文件夹: data-11.json
  27. 路径: F:\Test\data-1\data-12 文件或文件夹: data-12
  28. 路径: F:\Test\data-2 文件或文件夹: data-2
  29. 路径: F:\Test\data-2\data-21 文件或文件夹: data-21
  30. 路径: F:\Test\data-2\data-21\data=21.txt 文件或文件夹: data=21.txt
  31. 路径: F:\Test\test.txt 文件或文件夹: test.txt
复制代码
16.3 文件操作

16.3.1 常规操作

    这里的常规操作是指文件的创建、判断是否存在、重命名、修改权限、属主属组等操作，示例操作如下所示：
  1. package main
  3. import (
  4.         "fmt"
  5.         "os"
  6.         "path/filepath"
  7.         "time"
  8. )
  10. func main() {
  11.         oldFilename := "F:\\Test\\surpass.json"
  12.         newFilename := "F:\\Test\\surpass.json.rename"
  14.         //如果文件不存在，则创建相应的目录和文件
  15.         //如果相应的目录存在，则不创建目录
  16.         if _, err := os.Stat(oldFilename); os.IsNotExist(err) {
  17.                 fmt.Printf("文件%+v不存在\n", oldFilename)
  18.                 dirName := filepath.Dir(oldFilename)
  19.                 if err := os.MkdirAll(dirName, os.ModePerm); err != nil {
  20.                         fmt.Printf("创建目录%+v出错，错误信息：%+v\n", dirName, err)
  21.                         return
  22.                 }
  23.                 // 文件创建
  24.                 if f, err := os.Create(oldFilename); err == nil {
  25.                         defer f.Close()
  26.                         fmt.Printf("文件%+v创建成功\n", oldFilename)
  27.                 } else {
  28.                         fmt.Printf("文件%+v创建失败，错误信息：%+v\n", oldFilename, err)
  29.                 }
  30.         }
  32.         // 文件重命名
  33.         // Windows里面注意重命名时，是否有其他进程打开或占用该文件
  34.         if err := os.Rename(oldFilename, newFilename); err != nil {
  35.                 fmt.Printf("重命名文件%+v失败，错误信息：%+v\n", oldFilename, err)
  36.         }
  38.         // 修改文件权限,一般适用于Linux
  39.         if err := os.Chmod(newFilename, 0777); err != nil {
  40.                 fmt.Printf("修改文件权限%+v失败，错误信息：%+v\n", newFilename, err)
  41.         }
  43.         // 修改访问和修改时间
  44.         now := time.Now().Add(time.Hour * -2)
  45.         if err := os.Chtimes(newFilename, now, now); err != nil {
  46.                 fmt.Printf("修改文件时间%+v失败，错误信息：%+v\n", newFilename, err)
  47.         }
  49.         // 修改文件属主和属组，适用于Linux，且需要注意权限，Windows不支持该方法
  50.         if err := os.Chown(newFilename, 0, 0); err != nil {
  51.                 fmt.Printf("修改属主和属组时间%+v失败，错误信息：%+v\n", newFilename, err)
  52.         }
  54.         // 删除单个文件
  55.         if err := os.Remove(newFilename); err != nil {
  56.                 fmt.Printf("删除文件%+v失败，错误信息：%+v\n", newFilename, err)
  57.         }
  59.         if err := os.RemoveAll(filepath.Dir(newFilename)); err != nil {
  60.                 fmt.Printf("删除文件夹%+v失败，错误信息：%+v\n", filepath.Dir(newFilename), err)
  61.         }
  62. }
复制代码
16.3.2 文件读写

    文件本质上就是存储在存储设备上，并且经过序列化的二进制数据，如果我们需要对一个文件进行读写操作，一般可以拆分为找到文件、打开文件、执行操作(读写) 等几个步骤。

  • 在打开文件会涉及到很多的读写模式，例如只读、只写、追加等模式
  • 读取文件本质上可以理解为如何读取字节数组中的数据
  • 写文件本质上可以理解为向字节数组中写入新的元素或者覆盖某些元素
16.3.2.1 文件打开与读取

    在Go语言中打开文件常常使用os模块中的Open和OpenFile方法。示例代码如下所示：
  1. package main
  3. import (
  4.         "fmt"
  5.         "os"
  6. )
  8. func main() {
  9.         // 文件内容为：Surpass
  10.         filename := "F:\\Test\\surpass.txt"
  11.         // 以只读方式打开文件
  12.         f, err := os.Open(filename)
  13.         if err != nil {
  14.                 fmt.Printf("打开文件%+v出错，错误信息:%+v\n", filename, err)
  15.                 panic(err)
  16.         }
  18.         defer f.Close()
  19.         // 读取文件
  20.         var buffer = make([]byte, 3)
  21.         for {
  22.                 // 成功读取n字节
  23.                 n, err := f.Read(buffer)
  24.                 if err != nil {
  25.                         // 文件读到结尾时，EOF n=0
  26.                         fmt.Printf("读取文件出错:%+v\n", err)
  27.                         break
  28.                 }
  29.                 // 注意事项：
  30.                 // 因为每次读取3个字节，直到文件结尾
  31.                 // 但由于buffer未做清空处理，当读到文件末尾时，如果不够3个字节时，
  32.                 // 则仅拿当前已经读取到内容替换相应位置的字节
  33.                 // 而前一次的内容因未替换，也会输出，导致存在数据污染
  34.                 fmt.Printf("从%+v成功读取到%+v个字节，转换后结果%+v，未使用切片处理的结果：%+v\n", buffer[:n], n, string(buffer[:n]), buffer)
  35.         }
  36. }
复制代码
    代码运行结果如下所示：
  1. 从[83 117 114]成功读取到3个字节，转换后结果Sur，未使用切片处理的结果：[83 117 114]
  2. 从[112 97 115]成功读取到3个字节，转换后结果pas，未使用切片处理的结果：[112 97 115]
  3. 从[115]成功读取到1个字节，转换后结果s，未使用切片处理的结果：[115 97 115]
  4. 读取文件出错:EOF
复制代码
16.3.2.2 文件带定位读取

    通过前面文件打开可以看出，不管文件有多大，但在读取时都是一点一点读取到内存中，且该操作是从前向后依次读取的。这种方式也称之为顺序读取，但若现在有一个超大的文件，只需要读取其中一段数据，该如何读取呢？
    在前面，我们提到过文件实际是经过序列化的数据，既意味着文件可以看成是一个非常大的字节数组。读取操作实际上是从字节数组里面获取部分或全部数据。因此，读取文件可以理解为，有一个指针指向特定的位置，其随着指针不断向后移动，从而实现读取数据的功能。既然这样，那我们在读取文件的时候，提前指定指针的位置，就可以读取任意位置的数据了，而在Go语言中提供了Seek方法来实现该功能，其用法如下所示：
  1. Seek(offset int64, whence int) (ret int64, err error)
复制代码
    whence功能如下所示：

  • whence=0：相对于文件开头位置，offset只能为正，否则报错
  • whence=1：相对于文件当前位置，offset可以为正，也可以为负，但在为负时，不能超过左边界，即文件开头
  • whence=2：相对于文件结尾位置，offset可以为正，也可以为负，但在为负时，不能超过左边界，即文件开头
    特殊的用法如下所示：
  1. // 将文件指针移动至文件开头
  2. Seek(0,0)
  3. // 将文件指针移动到文件末尾
  4. Seek(0,2)
复制代码
    示例代码如下所示：
  1. package main
  3. import (
  4.         "fmt"
  5.         "os"
  6. )
  8. func main() {
  9.         // 文件内容为：SurpassGoTestFileSeek
  10.         filename := "F:\\Test\\surpass.txt"
  11.         // 以只读方式打开文件
  12.         if f, err := os.Open(filename); err == nil {
  13.                 defer f.Close()
  14.                 buffer := make([]byte, 5)
  15.                 var n int
  16.                 if n, err = f.Read(buffer); err != nil {
  17.                         fmt.Printf("读取文件：%+v出错，错误信息：%+v\n", filename, err)
  18.                 }
  19.                 fmt.Printf("文件已经读取到位置:%v,内容为:%+v\n", n, string(buffer[:n]))
  20.                 // seek
  21.                 // whence=0 文件开头
  22.                 // whence=1 当前位置
  23.                 // whence=2 文件结尾
  24.                 ret, _ := f.Seek(2, 0)
  25.                 fmt.Printf("文件当前偏移量为： %v\n", ret)
  26.                 n, _ = f.Read(buffer)
  27.                 fmt.Printf("使用seek，相对于文件头，文件%+v从%+v开始读取，结果为%+v\n", filename, ret, string(buffer[:n]))
  28.                 // whence=1正偏移量
  29.                 ret, _ = f.Seek(2, 1)
  30.                 fmt.Printf("文件当前偏移量为： %v\n", ret)
  31.                 n, _ = f.Read(buffer)
  32.                 fmt.Printf("使用seek，相对于当前位置正偏移量，文件%+v从%+v开始读取，结果为%+v\n", filename, ret, string(buffer[:n]))
  33.                 // whence=1负偏移量
  34.                 ret, _ = f.Seek(-3, 1)
  35.                 fmt.Printf("文件当前偏移量为： %v\n", ret)
  36.                 n, _ = f.Read(buffer)
  37.                 fmt.Printf("使用seek，相对于当前位置负偏移量，文件%+v从%+v开始读取，结果为%+v\n", filename, ret, string(buffer[:n]))
  39.                 // whence=2 正偏移量，因为相对于文件末尾，再偏移是读取不到数据的
  40.                 ret, _ = f.Seek(1, 2)
  41.                 fmt.Printf("文件当前偏移量为： %v\n", ret)
  42.                 n, _ = f.Read(buffer)
  43.                 fmt.Printf("使用seek，相对于文件末尾正偏移量，文件%+v从%+v开始读取，结果为%+v\n", filename, ret, string(buffer[:n]))
  45.                 // whence=2 负偏移量
  46.                 ret, _ = f.Seek(-12, 2)
  47.                 fmt.Printf("文件当前偏移量为： %v\n", ret)
  48.                 n, _ = f.Read(buffer)
  49.                 fmt.Printf("使用seek，相对于文件末尾负偏移量，文件%+v从%+v开始读取，结果为%+v\n", filename, ret, string(buffer[:n]))
  51.                 // 另外类似于Seek的方法为ReadAt，偏移量相对于文件开头，但不影响当前文件指针
  52.                 var offset int64 = 10
  53.                 n, _ = f.ReadAt(buffer, offset)
  54.                 fmt.Printf("使用ReadAt，相对于文件开头偏移，文件%+v从%+v开始读取，结果为%+v\n", filename, offset, string(buffer[:n]))
  56.                 n, _ = f.Read(buffer)
  57.                 fmt.Printf("使用Read，从文件%+v读取到的结果为%+v\n", filename, string(buffer[:n]))
  58.         }
  59. }
复制代码
    文件运行结果如下所示：
  1. 文件已经读取到位置:5,内容为:Surpa
  2. 文件当前偏移量为： 2
  3. 使用seek，相对于文件头，文件F:\Test\surpass.txt从2开始读取，结果为rpass
  4. 文件当前偏移量为： 9
  5. 使用seek，相对于当前位置正偏移量，文件F:\Test\surpass.txt从9开始读取，结果为TestF
  6. 文件当前偏移量为： 11
  7. 使用seek，相对于当前位置负偏移量，文件F:\Test\surpass.txt从11开始读取，结果为stFil
  8. 文件当前偏移量为： 22
  9. 使用seek，相对于文件末尾正偏移量，文件F:\Test\surpass.txt从22开始读取，结果为
  10. 文件当前偏移量为： 9
  11. 使用seek，相对于文件末尾负偏移量，文件F:\Test\surpass.txt从9开始读取，结果为TestF
  12. 使用ReadAt，相对于文件开头偏移，文件F:\Test\surpass.txt从10开始读取，结果为estFi
  13. 使用Read，从文件F:\Test\surpass.txt读取到的结果为ileSe
复制代码
16.3.2.3 文件使用缓冲读取

    使用Read读取，是非常偏向于底层的，但操作起来不太方便。在Go语言同时也提供了bufio包，实现了对文件的二进制或文本文件的处理方法。
    如果要使用带buffer的方式读取文件，bufio.Reader构造函数为：
  1. func NewReader(rd io.Reader) *Reader {
  2.         return NewReaderSize(rd, defaultBufSize)
  3. }
复制代码
    在以上构造函数中，要求传入的参数为io.Reader，其定义的类型为接口类型，如下所示：
  1. type Reader interface {
  2.         Read(p []byte) (n int, err error)
  3. }
复制代码
    也就意味着，传入的参数需要实现接口Reader方法，而os.File实现了该接口的Read方法。默认为4096字节。示例代码如下所示：
  1. package main
  3. import (
  4.         "bufio"
  5.         "fmt"
  6.         "os"
  7. )
  9. func main() {
  10.         // 文件内容为：Surpass测试GoTestFileSeek\n测试\n学习Go
  11.         filename := "F:\\Test\\surpass.txt"
  12.         f, err := os.Open(filename)
  13.         defer f.Close()
  14.         if err != nil {
  15.                 fmt.Printf("读取文件错误: %v\n", err)
  16.         }
  17.         // 复制了f的内指针，相当自己再另外打开一次
  18.         reader := bufio.NewReader(f)
  19.         buffer := make([]byte, 5)
  20.         n, _ := reader.Read(buffer)
  21.         fmt.Printf("Read方法 - 读取文件%+v,读取了%+v字节，读取结果:%+v\n", filename, n, string(buffer[:n]))
  23.         // 按字节进行读取
  24.         b1, _ := reader.ReadByte()
  25.         fmt.Printf("ReadByte方法 - 读取文件%+v,读取结果:%+v\n", filename, string(b1))
  27.         // 这里调整文件指针无用，带buffer内部有自己一个文件指针
  28.         f.Seek(0, 0)
  30.         // 遇到分隔符后停止，同时包含分隔符，适用于需要按指定分隔符的读取操作，比例按行读取\n
  31.         b2, _ := reader.ReadBytes('s')
  32.         fmt.Printf("ReadBytes方法 - 读取文件%+v,读取结果:%+v\n", filename, string(b2))
  34.         // 适用于读取非英文字符的文件内容
  35.         r, size, _ := reader.ReadRune()
  36.         fmt.Printf("ReadRune方法 - 读取文件%+v，读取结果：%+v，读取长度:%+v\n", filename, r, size)
  38.         line, _ := reader.ReadSlice('\n')
  39.         fmt.Printf("ReadSlice方法 - 读取文件%+v，读取结果：%+v\n", filename, string(line))
  41.         str, _ := reader.ReadString('\n')
  42.         fmt.Printf("ReadString方法 - 读取文件%+v，读取结果：%+v\n", filename, str)
  43. }
复制代码
    代码运行结果如下所示：
  1. Read方法 - 读取文件F:\Test\surpass.txt,读取了5字节，读取结果:Surpa
  2. ReadByte方法 - 读取文件F:\Test\surpass.txt,读取结果:s
  3. ReadBytes方法 - 读取文件F:\Test\surpass.txt,读取结果:s
  4. ReadRune方法 - 读取文件F:\Test\surpass.txt，读取结果：27979，读取长度:3
  5. ReadSlice方法 - 读取文件F:\Test\surpass.txt，读取结果：试GoTestFileSeek
  6. ReadString方法 - 读取文件F:\Test\surpass.txt，读取结果：测试
复制代码
16.3.2.4 文件打开Flag

    我们来看看os.OpenFile的方法定义：
  1. func OpenFile(name string, flag int, perm FileMode) (*File, error)
复制代码
    OpenFile方法共有3个参数，其中参数flag为int类型，代表文件读写模式，参数perm是FileMode类型，代表文件的相应权限，默认为0或0666。而内置的os.Open定义如下所示：
  1. func Open(name string) (*File, error) {
  2.         return OpenFile(name, O_RDONLY, 0)
  3. }
复制代码
    通过其定义可以看出，也是基于OpenFile定义，而相应的参数Flag设置为O_RDONLY，代表以只读方式打开。在Go语言中，os默认定义了以下几种文件读写模式，且每一种都胡详细的说明，源码如下所示：
  1. const (
  2.         // Exactly one of O_RDONLY, O_WRONLY, or O_RDWR must be specified.
  3.         // 以下三种模式为互斥模式
  4.         O_RDONLY int = syscall.O_RDONLY // open the file read-only.
  5.         O_WRONLY int = syscall.O_WRONLY // open the file write-only.
  6.         O_RDWR   int = syscall.O_RDWR   // open the file read-write.
  7.         // The remaining values may be or'ed in to control behavior.
  8.         // 追加写入模式
  9.         O_APPEND int = syscall.O_APPEND // append data to the file when writing.
  10.         // 文件不存在时则创建
  11.         O_CREATE int = syscall.O_CREAT  // create a new file if none exists.
  12.         // 如果和O_CREATE一起使用，则要求文件必须不存在，否则则报错
  13.         O_EXCL   int = syscall.O_EXCL   // used with O_CREATE, file must not exist.
  14.         // 同步IO，等待前面一次IO完成后再进行
  15.         O_SYNC   int = syscall.O_SYNC   // open for synchronous I/O.
  16.         // 打开文件时，先清空再写入，即覆盖模式
  17.         O_TRUNC  int = syscall.O_TRUNC  // truncate regular writable file when opened.
  18. )
复制代码

  • O_RDONLY、O_WRONLY、O_RDWR：单独使用，如果文件不存在会报错，即要求在读写文件时，该文件必须存在
  • O_RDONLY：以只读模式打开，一般较少使用
  • O_RDONLY | O_APPEND 等价于 O_RDWR | O_APPEND  前者的写法存在歧义，推荐使用后者写法
    文件权限的源码定义如下所示：
[code]const (        // The single letters are the abbreviations        // used by the String method's formatting.        ModeDir        FileMode = 1
目录文件

使用道具 举报

相关推荐
骆贵
2025-11-27 04:52:07

举报

猛犸象科技工作室:网站开发，备案域名，渗透，服务器出租，DDOS/CC攻击，TG加粉引流
谢谢分享，辛苦了
昝梓菱
前天 16:30

举报

程序园永久vip申请，500美金$，无限下载程序园所有程序/软件/数据/等
感谢分享，学习下。
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册
发帖
艺轫
前天 16:30

0

粉丝关注

21

主题发布

板块介绍填写区域，请于后台编辑
微信扫一扫