Go红队开发—文件操作

目录

• 文件操作
  
  
  
  • 创建目录
    
  • 创建文件
    
  • 获取File信息
    
  • 文件重命名
    
  • 删除文件
    
  • 打开关闭文件
    
  • 判断文件是否存在
    
  • 判断文件是否有读取权限
    
  • 复制文件
    
  • Read读取
    
  • ReadFull读取
    
  • ReadAtLeast读取
    
  • ReadAll读取
    
  • bufio读取
    
  • Write写入
    
  • WriteFile快速写入
    
  • 暂时文件目录
    
  • 下载文件
    
  • 文件指针操作
    
  • 修改文件权限/拥有者/时间戳
    
  • 知识细节补充
    
    
    
    • OS.OpenFile
      
    • bufio
      
    • os.Stat
      
    • os.fileInfo
      
    • 文件权限
      
    
    
  
  

文件操作

由于在上一期编解码中对文件有操作需求，以是这一期补上文件操作功能.
依旧是直接放代码，加快学习进度，代码拿着就用即可，都是内置的功能函数。
PS:一些函数参数或者功能解释都放在代码注释里面了
创建目录

1. // 创建目录
3. func createDir() {
5.     err := os.Mkdir("test_dir", os.ModePerm)
7.     if err != nil {
9.         fmt.Println("创建目录失败")
11.         return
13.     }
15.     fmt.Println("创建目录成功")
17. }

复制代码

创建文件

1. // 创建文件
3. func createFile(filename string) {
5.     newfile, err := os.Create(filename)
7.     defer newfile.Close()
9.     if err != nil {
11.         fmt.Println("创建文件失败:", err)
13.         return
15.     }
16.     fmt.Println("创建文件成功:", newfile.Name())
18. }

复制代码

获取File信息

文件与目录都能判断

1. func getFileInfo() {
3.     //path := "test_dir"
5.     path := "test.txt"
7.     fileInfo, err := os.Stat(path)
9.     if err != nil {
11.         fmt.Println(err)
13.         return
15.     }
17.     fmt.Println("文件名:", fileInfo.Name())
19.     fmt.Println("文件大小:", fileInfo.Size())
21.     fmt.Println("文件权限:", fileInfo.Mode())
23.     fmt.Println("最后一次修改时间:", fileInfo.ModTime())
25.     fmt.Println("是否为目录: ", fileInfo.IsDir())
27.     //fmt.Println("系统接口类型: %T", fileInfo.Sys())
29.     //fmt.Println("系统信息: %+v", fileInfo.Sys())
31. }

复制代码

文件重命名

1. // 文件重命名
3. func renameFile() {
5.     oldFileName := "text.txt"
7.     newFileName := "newtest.txt"
9.     err := os.Rename(oldFileName, newFileName)
11.     if err != nil {
13.         fmt.Println("重命名出错：", err)
15.         return
17.     }
19. }

复制代码

删除文件

1. // 删除文件
3. func removeFile(fileaName string) {
5.     err := os.Remove(fileaName)
7.     if err != nil {
9.         fmt.Println("删除失败：", err)
11.         return
13.     }
15.     fmt.Println(fileaName, "删除成功")
17. }

复制代码

打开关闭文件

1. // 打开关闭文件
3. // 介绍原始open打开文件与OpenFile可以提供更多的选项打开文件
5. func open_close_file() {
7.   
9.     fmt.Println("os.Open打开文件")
11.     file, err := os.Open("test.txt")
13.     defer file.Close() //延迟关闭文件，建议打开文件后都习惯性写一个
15.     if err != nil {
17.         fmt.Println("os.Open打开文件失败:", err)
19.         return
21.     }
23.     fmt.Println("os.Open文件打开成功")
25.     //---------------------------------------------
27.     fmt.Println("os.OpenFile打开文件")
29.     file, err = os.OpenFile("test.txt", os.O_CREATE|os.O_APPEND|os.O_RDWR, 0666)
31.     defer file.Close()
33.     if err != nil {
35.         fmt.Println("os.OpenFile打开文件失败:", err)
37.         return
39.     }
41.     fmt.Println("os.OpenFile打开文件成功")
43. }

复制代码

判断文件是否存在

1. // 判断文件是否存在
3. func isExistFile(fileName string) {
5.     _, err := os.Stat(fileName)
7.     if err != nil {
9.         //因为报出错误可能有很多种原因，想要知道是不是文件不存在导致的err还需要验证
11.         if os.IsNotExist(err) {
13.             fmt.Println("确认这个错误是文件不存在导致的：", err)
15.         }
17.   
19.     }
21. }

复制代码

判断文件是否有读取权限

1. // 判断文件是否有读写权限
3. func isPermission() {
5.   
7.     file, err := os.OpenFile("test.txt", os.O_RDONLY, 0666) //直接给O_WRONLY标志，可以判断是否有写权限
9.     defer file.Close()
11.     if err != nil {
13.         if os.IsPermission(err) {
15.             fmt.Println("没有读取权限：", err)
17.         }
19.     }
21.     fmt.Println("可读")
23.   
25.     file, err = os.OpenFile("test.txt", os.O_WRONLY, 0666) //直接给O_WRONLY标志，可以判断是否有写权限
27.     defer file.Close()
29.     if err != nil {
31.         if os.IsPermission(err) {
33.             fmt.Println("没有写权限", err)
35.         }
37.     }
39.     fmt.Println("可写")
41.   
43. }

复制代码

复制文件

1. // 文件复制
3. func copyFile() {
5.   
7.     //打开一个你要复制的文件
9.     src_file, src_err := os.Open("test.txt")
11.     defer src_file.Close()
13.     if src_err != nil {
15.         fmt.Println("文件打开失败：", src_err)
17.     }
19.   
21.     //创建一个新文件用来复制内容到这里(其实可以用存在的文件继续打开也行，主要是用file句柄而已)
23.     des_file, des_err := os.Create("newtest.txt")
25.     defer des_file.Close()
27.     if des_err != nil {
29.         fmt.Println("文件创建失败", des_err)
31.     }
33.   
35.     //复制内容到新文件中
37.     bytesWritten, err := io.Copy(des_file, src_file) //bytesWritten是计算复制的长度
39.     if err != nil {
41.         fmt.Println("复制失败：", err)
43.     }
45.     fmt.Println("写入了：", bytesWritten)
47.   
49.     // 将文件内容flush到硬盘中,这操作对于我们现在来说是不必要的，
51.     // 因为在大多数情况下，程序正常退出时，数据会被操作系统自动刷新到磁盘。
53.     // 当我们在不断地写入内容的时候可能就需要不定期的进行flush
55.     err = des_file.Sync()
57. }

复制代码

Read读取

1. // ---------------------------------------------------
3. // 读取文件内容
5. // ---------------------------------------------------
7. // Read读取文件内容，返回读取的长度和内容，如果读取的长度小于切片的长度，说明文件读取完了
9. func readFile() {
11.     //打开文件
13.     file, err := os.OpenFile("test.txt", os.O_RDWR, 0666)
15.     defer file.Close()
17.     if err != nil {
19.         fmt.Println("打开文件失败：", err)
21.         return
23.     }
25.     bytes_content := make([]byte, 10)           //Read就是传进内容到这个切片空间中
27.     contentlen, err := file.Read(bytes_content) //返回的是读取的长度
29.     if err != nil {
31.         fmt.Println("读取文件失败：", err)
33.         return
35.     }
37.     fmt.Printf("读取长度：%d\n", contentlen)
39.     fmt.Println("读取内容：", string(bytes_content))
41. }

复制代码

ReadFull读取

1. // ReadFull读取文件内容，返回读取的长度和内容，如果读取的长度小于切片的长度会返回错误
3. func readFullFile() {
5.     //打开文件
7.     file, err := os.OpenFile("test.txt", os.O_RDWR, 0666)
9.     defer file.Close()
11.     if err != nil {
13.         fmt.Println("打开文件失败：", err)
15.         return
17.     }
19.   
21.     //ReadFull就是传进内容到这个bytes_content切片空间中，如果给的空间大于读取的内容就会报错，小于的的话给多少读多少
23.     bytes_content := make([]byte, 2)
25.     contentlen, err := io.ReadFull(file, bytes_content) //返回的是读取的长度
27.     if err != nil {
29.         fmt.Println("读取文件失败：", err)
31.         return
33.     }
35.     fmt.Printf("读取长度：%d\n", contentlen)
37.     fmt.Println("读取内容：", string(bytes_content))
39. }

复制代码

ReadAtLeast读取

1. // ReadAtLeast至少读取xx bytes文件内容
3. func readAtLeastFile() {
5.     //打开文件
7.     file, err := os.OpenFile("test.txt", os.O_RDWR, 0666)
9.     defer file.Close()
11.     if err != nil {
13.         fmt.Println("打开文件失败：", err)
15.         return
17.     }
19.     bytes_content := make([]byte, 512) //Read就是传进内容到这个切片空间中
21.   
23.     // io.ReadAtLeast()在拿不到最小的字节内容的时候会返回错误，
25.     // 如果你不return回去，
27.     // 他会把已读的文件保留。你依旧能够打印读取到的内容
29.     //相比ReadFull，ReadAtLeast不会报错，
31.     // 只是说最小字节数是至少读取这么多，
33.     // 但是依旧会往后读取，报错会留下已读取的内容
35.     minBytes := 10
37.     contentlen, err := io.ReadAtLeast(file, bytes_content, minBytes) //返回的是读取的长度
39.     if err != nil {
41.         fmt.Println("读取文件失败：", err)
43.         //return   //取消return,依旧能打印读取到的内容
45.     }
47.     fmt.Printf("读取长度：%d\n", contentlen)
49.     fmt.Println("读取内容：", string(bytes_content))
51. }

复制代码

ReadAll读取

1. // ReadAll读取文件所有内容
3. func readAllFile() {
5.     //打开文件
7.     file, err := os.OpenFile("test.txt", os.O_RDWR, 0666)
9.     defer file.Close()
11.     if err != nil {
13.         fmt.Println("打开文件失败：", err)
15.         return
17.     }
19.     // io.ReadAll()会读取所有的文件内容，返回的是读取的长度
21.     content, err := io.ReadAll(file) //返回的是读取的长度
23.     if err != nil {
25.         fmt.Println("读取文件失败：", err)
27.         return
29.     }
31.     fmt.Println("读取内容：", string(content))
33. }

复制代码

bufio读取

以下是 bufio.Scanner 中几种常用分割符的具体阐明和示例：
bufio.ScanWords

• 分割符: 空格（ ）或连续的空缺字符（包括空格、制表符 \t、换行符 \n 等）。
  
• 行为: 每次扫描一个单词（以空缺字符分隔的字符串）。
  
• 示例:
  1. scanner.Split(bufio.ScanWords)

  复制代码
  输入:
  1. "Hello   World\nGo Programming"

  复制代码
  输出:
  1. "Hello"
  2. "World"
  3. "Go"
  4. "Programming"

  复制代码

bufio.ScanLines

• 分割符: 换行符（\n）。
  
• 行为: 每次扫描一行（以换行符分隔的字符串）。
  
• 示例:
  1. scanner.Split(bufio.ScanLines)

  复制代码
  输入:
  1. "Hello\nWorld\nGo Programming"

  复制代码
  输出:
  1. "Hello"
  2. "World"
  3. "Go Programming"

  复制代码

bufio.ScanBytes

• 分割符: 无（按字节分割）。
  
• 行为: 每次扫描一个字节。
  
• 示例:
  1. scanner.Split(bufio.ScanBytes)

  复制代码
  输入:
  1. "Hello"

  复制代码
  输出:
  1. 'H'
  2. 'e'
  3. 'l'
  4. 'l'
  5. 'o'

  复制代码

bufio.ScanRunes

• 分割符: 无（按字符分割）。
  
• 行为: 每次扫描一个字符（支持多字节字符，如中文）。
  
• 示例:
  1. scanner.Split(bufio.ScanRunes)

  复制代码
  输入:
  1. "你好，世界！"

  复制代码
  输出:
  1. '你'
  2. '好'
  3. '，'
  4. '世'
  5. '界'
  6. '！'

  复制代码

总结
分割函数分割符行为示例输入示例输出bufio.ScanWords空格（ ）或连续空缺字符每次扫描一个单词"Hello   World\nGo""Hello", "World", "Go"bufio.ScanLines换行符（\n）每次扫描一行"Hello\nWorld\nGo""Hello", "World", "Go"bufio.ScanBytes无每次扫描一个字节"Hello"'H', 'e', 'l', 'l', 'o'bufio.ScanRunes无每次扫描一个字符（支持多字节字符）"你好，世界！"'你', '好', '，', '世', '界', '！'注意事项

• bufio.ScanWords:
  
  
  
  • 会忽略连续的空缺字符（如多个空格或制表符）。
    
  • 适合处理以空格分隔的文本。
    
  
  
• bufio.ScanLines:
  
  
  
  • 会保存每行的内容（包括行尾的空缺字符）。
    
  • 适合处理逐行文本。
    
  
  
• bufio.ScanBytes:
  
  
  
  • 按字节分割，适合处理二进制数据或需要逐字节分析的场景。
    
  
  
• bufio.ScanRunes:
  
  
  
  • 按字符分割，支持多字节字符（如中文、日文、韩文等）。
    
  • 适合处理 Unicode 文本。
    
  
  

示例代码：

1. // bufio读取文件能够配合scanner一行一行读取，安全开发过程中可能用的最多，因为爆破的需求一般都是一行一行读取
3. func bufioReadFile() {
5.     //打开文件
7.     file, err := os.OpenFile("test.txt", os.O_RDWR, 0666)
9.     defer file.Close()
11.     if err != nil {
13.         fmt.Println("打开文件失败：", err)
15.         return
17.     }
19.     //bufio.NewReader()返回一个io.Reader对象，可以用来读取文件内容
21.     reader := io.Reader(file)
23.     //bufio.NewScanner()返回一个io.Scanner对象，可以用来读取文件内容
25.     scanner := bufio.NewScanner(reader)
27.     //scanner.Split(bufio.ScanWords) //按照空格分割
29.     //scanner.Split(bufio.ScanLines) //按照换行符分割 默认不写就是按照换行符分割
31.     //scanner.Split(bufio.ScanBytes) //按照字节分割
33.     //scanner.Split(bufio.ScanRunes) //按照字符分割
35.     for scanner.Scan() {
37.         fmt.Println(scanner.Text())
39.     }
41. }

复制代码

Write写入

1. // ---------------------------------------------------
3. // 写入文件内容
5. // ---------------------------------------------------
7. func write() {
9.     file, err := os.OpenFile(
11.         "test.txt",
13.         os.O_CREATE|os.O_APPEND|os.O_RDWR|os.O_APPEND,
15.         0666,
17.     )
19.     defer file.Close()
21.     if err != nil {
23.         fmt.Println("文件打开失败：", err)
25.         return
27.     }
29.     bytesWrittenLen, err := file.Write([]byte("hello hack\n"))
31.     if err != nil {
33.         fmt.Println("内容写入失败：", err)
35.         return
37.     }
39.     fmt.Printf("写入成功：%d字节长度\n", bytesWrittenLen)
41. }

复制代码

WriteFile快速写入

1. // 快速写内容
3. // 用在需要快速简洁写入内容的时候
5. func ioutil_WriteFile() {
7.     err := ioutil.WriteFile("test.txt", []byte("hello hack2\n"), 0666)
9.     if err != nil {
11.         fmt.Println("内容写入失败：", err)
13.         return
15.     }
17.   
19. }

复制代码

暂时文件目录

1.   
3. // 临时文件和目录，在开发工具的时候可能会用的上
5. func tmpDir_File() {
7.     // 第一个参数是空字符串表示TempDir 会使用系统的默认临时目录。
9.     // 在 Linux/macOS 上，通常是 /tmp。
11.     // 在 Windows 上，通常是 C:\Users\<User>\AppData\Local\Temp。
13.     tempDir, err := ioutil.TempDir("", "tmpDirName")
15.     if err != nil {
17.         fmt.Println("创建失败：", err)
19.         return
21.     }
23.     fmt.Println("目录创建成功：", tempDir)
25.   
27.     tempFile, err := ioutil.TempFile(tempDir, "temp.txt") //创建文件要给参数：tempDir目录和temp文件名字
29.     if err != nil {
31.         fmt.Println("文件创建失败：", err)
33.         return
35.     }
37.     fmt.Println("文件创建成功：", tempFile.Name())
39.   
41.     //虽然说是临时文件也耀手动关闭文件
43.     defer tempFile.Close()
45.   
47.     err = os.Remove(tempFile.Name())
49.     if err != nil {
51.         fmt.Println("文件删除失败")
53.         return
55.     }
57.   
59.     err = os.Remove(tempDir)
61.     if err != nil {
63.         fmt.Println("目录删除失败")
65.         return
67.     }
69.   
71. }

复制代码

下载文件

1. // http get downLoad文件到本地
3. func downLoadFile() {
5.     httpFile, err := os.OpenFile(
7.         "baidu.html",
9.         os.O_CREATE|os.O_RDWR,
11.         0666,
13.     )
15.     if err != nil {
17.         fmt.Println("文件打开失败")
19.     }
21.     defer httpFile.Close()
23.     url := "http://www.baidu.com"
25.     rep, err := http.Get(url)
27.     defer rep.Body.Close()
29.   
31.     written, err := io.Copy(httpFile, rep.Body)
33.     if err != nil {
35.         fmt.Println("文件复制失败:", err)
37.     }
39.     fmt.Println("下载成功，文件大小(byte)：\n", written)
41. }

复制代码

文件指针操作

1. func offsetFile() {
3.     //打开文件
5.     file, err := os.OpenFile("test.txt", os.O_RDWR, 0666)
7.     defer file.Close()
9.     if err != nil {
11.         fmt.Println("打开文件失败：", err)
13.         return
15.     }
17.     //获取文件的偏移量
19.     var (
21.         offset int64 = 1
23.         whence int   = 1
25.   
27.         //whence用来计算offset的位置
29.         // 0 = 文件开始位置
31.         // 1 = 当前位置
33.         // 2 = 文件结尾处
35.     )
37.     newP, err := file.Seek(offset, whence)
39.     if err != nil {
41.         fmt.Println("获取文件偏移量失败：", err)
43.         return
45.     }
47.     fmt.Println("文件偏移量：", newP)
49.     //直接当前位置读取文件内容
51.     bytes_content := make([]byte, 10)           //Read就是传进内容到这个切片空间中
53.     contentlen, err := file.Read(bytes_content) //返回的是读取的长度
55.     if err != nil {
57.         fmt.Println("读取文件失败：", err)
59.         return
61.     }
63.     fmt.Printf("读取长度：%d\n", contentlen)
65.     fmt.Println("读取内容：", string(bytes_content))
67.   
69. }

复制代码

修改文件权限/拥有者/时间戳

参考文章：https://colobu.com/2016/10/12/go-file-operations/
这篇文章作者写的这真的很好，全是干货。

1. package main
3. import (
5.     "log"
7.     "os"
9.     "time"
11. )
13. func main() {
15.     // 使用Linux风格改变文件权限
17.     err := os.Chmod("test.txt", 0777)
19.     if err != nil {
21.         log.Println(err)
23.     }
25.     // 改变文件所有者
27.     err = os.Chown("test.txt", os.Getuid(), os.Getgid())
29.     if err != nil {
31.         log.Println(err)
33.     }
35.     // 改变时间戳
37.     twoDaysFromNow := time.Now().Add(48 * time.Hour)
39.     lastAccessTime := twoDaysFromNow
41.     lastModifyTime := twoDaysFromNow
43.     err = os.Chtimes("test.txt", lastAccessTime, lastModifyTime)
45.     if err != nil {
47.         log.Println(err)
49.     }
51. }

复制代码

知识细节补充

OS.OpenFile

先介绍一下这个openfile功能，之前我是使用os.open来打开文件， 但是只能以只读的方式打开文件，而openfile更通用的文件打开函数，可以指定打开模式（只读、只写、读写等）和文件权限。接下来我都会使用openfile来操作文件，更精细化控制文件。
⽂件打开模式标志，在使用openfile的时候需要以一个怎样的模式打开文件
比如：os.OpenFile("example.txt", os.O_RDWR|os.O_CREATE|os.O_APPEND, 0644)
多个形式可以用|管道符分开，表现可读可写，同时CREATE表现当文件不存在的时候创建，同时APPEND表现追加模式。
更多模式可以看下面介绍

1. os.O_RDONLY：只读模式打开⽂件。
2. os.O_WRONLY：只写模式打开⽂件。
3. os.O_RDWR：读写模式打开⽂件。
4. os.O_APPEND：追加模式。如果⽂件已存在，数据将写⼊⽂件末尾。
5. os.O_CREATE：如果⽂件不存在，则创建⽂件。
6. os.O_EXCL：与 os.O_CREATE ⼀起使⽤，⽂件必须不存在。
7. os.O_SYNC：同步 I/O，保证写⼊数据和元数据同步到存储设备。
8. os.O_TRUNC：如果⽂件已存在，打开时将其⻓度截断为零。

复制代码

细节写在前头：我们读取完或者写入完后，文件指针是不在开头的，如果你读取完就直接写入就是在你读取到的当前位置写入，或者你写入完成后继续读取就是在当前位置读取，可能读取不到你想要的内容，以是file.Seek就很有须要了，或者你重新打开该文件也可以自动将指针指向开头。
演示代码：
打开一个文件写入hello hack，然后读取这个文件内容

• O_RDWR:可读可写
  
• O_CREATE:文件不存在就创建
  
• O_APPEND:追加模式
  
• 末了的0666是文件操作权限，这里就涉及到linux的文件权限问题了(忽略，后面讲)
  

1. func write_readTest() {
3.     file, err := os.OpenFile("test.txt", os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666)
5.     defer file.Close()
7.     if err != nil {
9.         fmt.Println(err)
11.         return
13.     }
15.     file.WriteString("hello hack") // 写入文件
17.     // 读取文件
19.     scanner := bufio.NewScanner(file)
21.   
23.     //读取完文件后，文件指针已经到了文件末尾，需要重新定位到文件开头
25.     // 将文件指针重新定位到文件开头
27.     file.Seek(0, 0)
29.     for scanner.Scan() {
31.         fmt.Println(scanner.Text()) //一行一行读取
33.     }
35.     if err := scanner.Err(); err != nil {
37.         fmt.Println("读取文件失败:", err)
39.     }
41.   
43. }

复制代码

bufio

我们在编解码的时候就用了这个bufio，我们可以new一个scanner来一行一行读取文件内容，如果你需要更细粒度的控制（如按字节读取），可以使用 bufio.Reader。

1. //常用方法
2. file, err := os.OpenFile("test.txt", os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666)
3.         // 读取文件
4.     scanner := bufio.NewScanner(file)
5.     for scanner.Scan() {
6.         fmt.Println(scanner.Text()) //一行一行读取
8.     }
9.     if err := scanner.Err(); err != nil {
10.         fmt.Println("读取文件失败:", err)
11.     }

复制代码

os.Stat

os.Stat 是 Go 语言中用于获取文件或目录信息的函数。它的作用是返回一个形貌文件或目录状态的对象（os.FileInfo）

• 参数 name:
  
  
  
  • 继承一个字符串参数，表现文件或目录的路径。
    
  • 可以是相对路径（如 "../example.txt 或者目录 ../dirname"）或绝对路径（如 "/home/user/example.txt"）。
    
  • 也可以是文件名（如果文件在当前工作目录下）。
    
  
  
• 返回值:
  
  
  
  • FileInfo: 一个接口类型，包含文件或目录的具体信息。
    
  • error: 如果操作失败（如文件不存在），返回错误信息。
    
  
  

os.fileInfo

os.FileInfo 是一个接口，包含以下方法：
方法名返回值类型阐明Name() stringstring返回文件或目录的名称（不包括路径）。Size() int64int64返回文件的字节大小（目录通常返回 0）。Mode() FileModeFileMode返回文件的权限和模式。ModTime() time.Timetime.Time返回文件的末了修改时间。IsDir() boolbool判断是否是目录。Sys() interface{}interface{}返回底层数据源（通常为 nil）。文件权限

使用⼋进制数表现⽂件的权限，这里是linux文件权限管理的知识，不懂自查。
os.ModePerm：⽂件的默认权限（0777）

1. os.ModeDir：表示⼀个⽬录。
2. os.ModeAppend：表示⽂件只能追加写⼊。
3. os.ModeExclusive：表示⽂件是独占的。
4. os.ModeTemporary：表示⽂件是临时⽂件。
5. os.ModeSymlink：表示⽂件是⼀个符号链接。
6. os.ModeDevice：表示⽂件是⼀个设备⽂件。
7. os.ModeNamedPipe：表示⽂件是⼀个命名管道。
8. os.ModeSocket：表示⽂件是⼀个 Unix 域套接字。
9. os.ModeSetuid：表示⽂件具有 setuid 位。
10. os.ModeSetgid：表示⽂件具有 setgid 位。
11. os.ModeCharDevice：表示⽂件是⼀个字符设备。
12. os.ModeSticky：表示⽂件具有粘滞位。
13. os.ModeIrregular：表示⽂件是⼀个不规则⽂件。

复制代码

参考文章：https://colobu.com/2016/10/12/go-file-operations

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。