zoukankan      html  css  js  c++  java
  • go语言文件操作

    go语言文件操作

    基本操作

    创建空文件

    package main
    
    import (
        "log"
        "os"
    )
    
    var (
        newFile *os.File
        err     error
    )
    
    func main() {
        newFile, err = os.Create("test.txt")
        if err != nil {
            log.Fatal(err)
        }
        log.Println(newFile)
        newFile.Close()
    }
    

    截取文件

    package main
    import (
        "log"
        "os"
    )
    func main() {
        // 裁剪一个文件到100个字节。
        // 如果文件本来就少于100个字节,则文件中原始内容得以保留,剩余的字节以null字节填充。
        // 如果文件本来超过100个字节,则超过的字节会被抛弃。
        // 这样我们总是得到精确的100个字节的文件。
        // 传入0则会清空文件。
        err := os.Truncate("test.txt", 100)
        if err != nil {
            log.Fatal(err)
        }
    }
    

    得到文件信息

    package main
    import (
        "fmt"
        "log"
        "os"
    )
    var (
        fileInfo os.FileInfo
        err      error
    )
    func main() {
        // 如果文件不存在,则返回错误
        fileInfo, err = os.Stat("test.txt")
        if err != nil {
            log.Fatal(err)
        }
        fmt.Println("File name:", fileInfo.Name())
        fmt.Println("Size in bytes:", fileInfo.Size())
        fmt.Println("Permissions:", fileInfo.Mode())
        fmt.Println("Last modified:", fileInfo.ModTime())
        fmt.Println("Is Directory: ", fileInfo.IsDir())
        fmt.Printf("System interface type: %T
    ", fileInfo.Sys())
        fmt.Printf("System info: %+v
    
    ", fileInfo.Sys())
    }
    

    检查文件是否存在

    package main
    import (
        "log"
        "os"
    )
    var (
        fileInfo *os.FileInfo
        err      error
    )
    func main() {
        // 文件不存在则返回error
        fileInfo, err := os.Stat("test.txt")
        if err != nil {
            if os.IsNotExist(err) {
                log.Fatal("File does not exist.")
            }
        }
        log.Println("File does exist. File information:")
        log.Println(fileInfo)
    }
    

    打开和关闭文件

    package main
    import (
        "log"
        "os"
    )
    func main() {
        // 简单地以只读的方式打开。下面的例子会介绍读写的例子。
        file, err := os.Open("test.txt")
        if err != nil {
            log.Fatal(err)
        }
        file.Close()
        // OpenFile提供更多的选项。
        // 最后一个参数是权限模式permission mode
        // 第二个是打开时的属性    
        file, err = os.OpenFile("test.txt", os.O_APPEND, 0666)
        if err != nil {
            log.Fatal(err)
        }
        file.Close()
        // 下面的属性可以单独使用,也可以组合使用。
        // 组合使用时可以使用 OR 操作设置 OpenFile的第二个参数,例如:
        // os.O_CREATE|os.O_APPEND
        // 或者 os.O_CREATE|os.O_TRUNC|os.O_WRONLY
        // os.O_RDONLY // 只读
        // os.O_WRONLY // 只写
        // os.O_RDWR // 读写
        // os.O_APPEND // 往文件中添建(Append)
        // os.O_CREATE // 如果文件不存在则先创建
        // os.O_TRUNC // 文件打开时裁剪文件
        // os.O_EXCL // 和O_CREATE一起使用,文件不能存在
        // os.O_SYNC // 以同步I/O的方式打开
    }
    

    删除文件

    package main
    import (
        "log"
        "os"
    )
    func main() {
        err := os.Remove("test.txt")
        if err != nil {
            log.Fatal(err)
        }
    }
    

    重命名和移动

    package main
    import (
        "log"
        "os"
    )
    func main() {
        originalPath := "test.txt"
        newPath := "test2.txt"
        err := os.Rename(originalPath, newPath)
        if err != nil {
            log.Fatal(err)
        }
    }
    

    检查读写权限

    package main
    import (
        "log"
        "os"
    )
    func main() {
        // 这个例子测试写权限,如果没有写权限则返回error。
        // 注意文件不存在也会返回error,需要检查error的信息来获取到底是哪个错误导致。
        file, err := os.OpenFile("test.txt", os.O_WRONLY, 0666)
        if err != nil {
            if os.IsPermission(err) {
                log.Println("Error: Write permission denied.")
            }
        }
        file.Close()
        // 测试读权限
        file, err = os.OpenFile("test.txt", os.O_RDONLY, 0666)
        if err != nil {
            if os.IsPermission(err) {
                log.Println("Error: Read permission denied.")
            }
        }
        file.Close()
    }
    

    改变权限等信息

    package main
    import (
        "log"
        "os"
        "time"
    )
    func main() {
        // 使用Linux风格改变文件权限
        err := os.Chmod("test.txt", 0777)
        if err != nil {
            log.Println(err)
        }
        // 改变文件所有者
        err = os.Chown("test.txt", os.Getuid(), os.Getgid())
        if err != nil {
            log.Println(err)
        }
        // 改变时间戳
        twoDaysFromNow := time.Now().Add(48 * time.Hour)
        lastAccessTime := twoDaysFromNow
        lastModifyTime := twoDaysFromNow
        err = os.Chtimes("test.txt", lastAccessTime, lastModifyTime)
        if err != nil {
            log.Println(err)
        }
    }
    

    读写文件

    复制文件

    package main
    import (
        "os"
        "log"
        "io"
    )
    func main() {
        // 打开原始文件
        originalFile, err := os.Open("test.txt")
        if err != nil {
            log.Fatal(err)
        }
        defer originalFile.Close()
        // 创建新的文件作为目标文件
        newFile, err := os.Create("test_copy.txt")
        if err != nil {
            log.Fatal(err)
        }
        defer newFile.Close()
        // 从源中复制字节到目标文件
        bytesWritten, err := io.Copy(newFile, originalFile)
        if err != nil {
            log.Fatal(err)
        }
        log.Printf("Copied %d bytes.", bytesWritten)
        // 将文件内容flush到硬盘中
        err = newFile.Sync()
        if err != nil {
            log.Fatal(err)
        }
    }
    

    跳转到文件指定位置(Seek)

    package main
    import (
        "os"
        "fmt"
        "log"
    )
    func main() {
        file, _ := os.Open("test.txt")
        defer file.Close()
        // 偏离位置,可以是正数也可以是负数
        var offset int64 = 5
        // 用来计算offset的初始位置
        // 0 = 文件开始位置
        // 1 = 当前位置
        // 2 = 文件结尾处
        var whence int = 0
        newPosition, err := file.Seek(offset, whence)
        if err != nil {
            log.Fatal(err)
        }
        fmt.Println("Just moved to 5:", newPosition)
        // 从当前位置回退两个字节
        newPosition, err = file.Seek(-2, 1)
        if err != nil {
            log.Fatal(err)
        }
        fmt.Println("Just moved back two:", newPosition)
        // 使用下面的技巧得到当前的位置
        currentPosition, err := file.Seek(0, 1)
        fmt.Println("Current position:", currentPosition)
        // 转到文件开始处
        newPosition, err = file.Seek(0, 0)
        if err != nil {
            log.Fatal(err)
        }
        fmt.Println("Position after seeking 0,0:", newPosition)
    }
    

    写文件

    package main
    import (
        "os"
        "log"
    )
    func main() {
        // 可写方式打开文件
        file, err := os.OpenFile(
            "test.txt",
            os.O_WRONLY|os.O_TRUNC|os.O_CREATE,
            0666,
        )
        if err != nil {
            log.Fatal(err)
        }
        defer file.Close()
        // 写字节到文件中
        byteSlice := []byte("Bytes!
    ")
        bytesWritten, err := file.Write(byteSlice)
        if err != nil {
            log.Fatal(err)
        }
        log.Printf("Wrote %d bytes.
    ", bytesWritten)
    }
    

    快写文件

    ioutil包有一个非常有用的方法WriteFile()可以处理创建/打开文件、写字节slice和关闭文件一系列的操作。如果你需要简洁快速地写字节slice到文件中,你可以使用它。

    package main
    import (
        "io/ioutil"
        "log"
    )
    func main() {
        err := ioutil.WriteFile("test.txt", []byte("Hi
    "), 0666)
        if err != nil {
            log.Fatal(err)
        }
    }
    

    使用缓存写

    bufio包提供了带缓存功能的writer,所以你可以在写字节到硬盘前使用内存缓存。当你处理很多的数据很有用,因为它可以节省操作硬盘I/O的时间。在其它一些情况下它也很有用,比如你每次写一个字节,把它们攒在内存缓存中,然后一次写入到硬盘中,减少硬盘的磨损以及提升性能。

    package main
    import (
        "log"
        "os"
        "bufio"
    )
    func main() {
        // 打开文件,只写
        file, err := os.OpenFile("test.txt", os.O_WRONLY, 0666)
        if err != nil {
            log.Fatal(err)
        }
        defer file.Close()
        // 为这个文件创建buffered writer
        bufferedWriter := bufio.NewWriter(file)
        // 写字节到buffer
        bytesWritten, err := bufferedWriter.Write(
            []byte{65, 66, 67},
        )
        if err != nil {
            log.Fatal(err)
        }
        log.Printf("Bytes written: %d
    ", bytesWritten)
        // 写字符串到buffer
        // 也可以使用 WriteRune() 和 WriteByte()   
        bytesWritten, err = bufferedWriter.WriteString(
            "Buffered string
    ",
        )
        if err != nil {
            log.Fatal(err)
        }
        log.Printf("Bytes written: %d
    ", bytesWritten)
        // 检查缓存中的字节数
        unflushedBufferSize := bufferedWriter.Buffered()
        log.Printf("Bytes buffered: %d
    ", unflushedBufferSize)
        // 还有多少字节可用(未使用的缓存大小)
        bytesAvailable := bufferedWriter.Available()
        if err != nil {
            log.Fatal(err)
        }
        log.Printf("Available buffer: %d
    ", bytesAvailable)
        // 写内存buffer到硬盘
        bufferedWriter.Flush()
        // 丢弃还没有flush的缓存的内容,清除错误并把它的输出传给参数中的writer
        // 当你想将缓存传给另外一个writer时有用
        bufferedWriter.Reset(bufferedWriter)
        bytesAvailable = bufferedWriter.Available()
        if err != nil {
            log.Fatal(err)
        }
        log.Printf("Available buffer: %d
    ", bytesAvailable)
        // 重新设置缓存的大小。
        // 第一个参数是缓存应该输出到哪里,这个例子中我们使用相同的writer。
        // 如果我们设置的新的大小小于第一个参数writer的缓存大小, 比如10,我们不会得到一个10字节大小的缓存,
        // 而是writer的原始大小的缓存,默认是4096。
        // 它的功能主要还是为了扩容。
        bufferedWriter = bufio.NewWriterSize(
            bufferedWriter,
            8000,
        )
        // resize后检查缓存的大小
        bytesAvailable = bufferedWriter.Available()
        if err != nil {
            log.Fatal(err)
        }
        log.Printf("Available buffer: %d
    ", bytesAvailable)
    }
    

    读取最多N个字节

    os.File提供了文件操作的基本功能, 而ioioutilbufio提供了额外的辅助函数。

    package main
    import (
        "os"
        "log"
    )
    func main() {
        // 打开文件,只读
        file, err := os.Open("test.txt")
        if err != nil {
            log.Fatal(err)
        }
        defer file.Close()
        // 从文件中读取len(b)字节的文件。
        // 返回0字节意味着读取到文件尾了
        // 读取到文件会返回io.EOF的error
        byteSlice := make([]byte, 16)
        bytesRead, err := file.Read(byteSlice)
        if err != nil {
            log.Fatal(err)
        }
        log.Printf("Number of bytes read: %d
    ", bytesRead)
        log.Printf("Data read: %s
    ", byteSlice)
    }
    

    读取正好N个字节

    package main
    import (
        "os"
        "log"
        "io"
    )
    func main() {
        // Open file for reading
        file, err := os.Open("test.txt")
        if err != nil {
            log.Fatal(err)
        }
        // file.Read()可以读取一个小文件到大的byte slice中,
        // 但是io.ReadFull()在文件的字节数小于byte slice字节数的时候会返回错误
        byteSlice := make([]byte, 2)
        numBytesRead, err := io.ReadFull(file, byteSlice)
        if err != nil {
            log.Fatal(err)
        }
        log.Printf("Number of bytes read: %d
    ", numBytesRead)
        log.Printf("Data read: %s
    ", byteSlice)
    }
    

    读取至少N个字节

    package main
    import (
        "os"
        "log"
        "io"
    )
    func main() {
        // 打开文件,只读
        file, err := os.Open("test.txt")
        if err != nil {
            log.Fatal(err)
        }
        byteSlice := make([]byte, 512)
        minBytes := 8
        // io.ReadAtLeast()在不能得到最小的字节的时候会返回错误,但会把已读的文件保留
        numBytesRead, err := io.ReadAtLeast(file, byteSlice, minBytes)
        if err != nil {
            log.Fatal(err)
        }
        log.Printf("Number of bytes read: %d
    ", numBytesRead)
        log.Printf("Data read: %s
    ", byteSlice)
    }
    

    读取全部字节

    package main
    import (
        "os"
        "log"
        "fmt"
        "io/ioutil"
    )
    func main() {
        file, err := os.Open("test.txt")
        if err != nil {
            log.Fatal(err)
        }
        // os.File.Read(), io.ReadFull() 和
        // io.ReadAtLeast() 在读取之前都需要一个固定大小的byte slice。
        // 但ioutil.ReadAll()会读取reader(这个例子中是file)的每一个字节,然后把字节slice返回。
        data, err := ioutil.ReadAll(file)
        if err != nil {
            log.Fatal(err)
        }
        fmt.Printf("Data as hex: %x
    ", data)
        fmt.Printf("Data as string: %s
    ", data)
        fmt.Println("Number of bytes read:", len(data))
    }
    

    快读到内存

    package main
    import (
        "log"
        "io/ioutil"
    )
    func main() {
        // 读取文件到byte slice中
        data, err := ioutil.ReadFile("test.txt")
        if err != nil {
            log.Fatal(err)
        }
        log.Printf("Data read: %s
    ", data)
    }
    

    使用缓存读

    有缓存写也有缓存读。
    缓存reader会把一些内容缓存在内存中。它会提供比os.Fileio.Reader更多的函数,缺省的缓存大小是4096,最小缓存是16。

    package main
    import (
        "os"
        "log"
        "bufio"
        "fmt"
    )
    func main() {
        // 打开文件,创建buffered reader
        file, err := os.Open("test.txt")
        if err != nil {
            log.Fatal(err)
        }
        bufferedReader := bufio.NewReader(file)
        // 得到字节,当前指针不变
        byteSlice := make([]byte, 5)
        byteSlice, err = bufferedReader.Peek(5)
        if err != nil {
            log.Fatal(err)
        }
        fmt.Printf("Peeked at 5 bytes: %s
    ", byteSlice)
        // 读取,指针同时移动
        numBytesRead, err := bufferedReader.Read(byteSlice)
        if err != nil {
            log.Fatal(err)
        }
        fmt.Printf("Read %d bytes: %s
    ", numBytesRead, byteSlice)
        // 读取一个字节, 如果读取不成功会返回Error
        myByte, err := bufferedReader.ReadByte()
        if err != nil {
            log.Fatal(err)
        }
        fmt.Printf("Read 1 byte: %c
    ", myByte)     
        // 读取到分隔符,包含分隔符,返回byte slice
        dataBytes, err := bufferedReader.ReadBytes('
    ')
        if err != nil {
            log.Fatal(err)
        }
        fmt.Printf("Read bytes: %s
    ", dataBytes)           
        // 读取到分隔符,包含分隔符,返回字符串
        dataString, err := bufferedReader.ReadString('
    ')
        if err != nil {
            log.Fatal(err)
        }
        fmt.Printf("Read string: %s
    ", dataString)     
        //这个例子读取了很多行,所以test.txt应该包含多行文本才不至于出错
    }
    

    压缩打包

    打包(zip) 文件

    // This example uses zip but standard library
    // also supports tar archives
    package main
    import (
        "archive/zip"
        "log"
        "os"
    )
    func main() {
        // 创建一个打包文件
        outFile, err := os.Create("test.zip")
        if err != nil {
            log.Fatal(err)
        }
        defer outFile.Close()
        // 创建zip writer
        zipWriter := zip.NewWriter(outFile)
        // 往打包文件中写文件。
        // 这里我们使用硬编码的内容,你可以遍历一个文件夹,把文件夹下的文件以及它们的内容写入到这个打包文件中。
        var filesToArchive = []struct {
            Name, Body string
        } {
            {"test.txt", "String contents of file"},
            {"test2.txt", "x61x62x63
    "},
        }
        // 下面将要打包的内容写入到打包文件中,依次写入。
        for _, file := range filesToArchive {
                fileWriter, err := zipWriter.Create(file.Name)
                if err != nil {
                        log.Fatal(err)
                }
                _, err = fileWriter.Write([]byte(file.Body))
                if err != nil {
                        log.Fatal(err)
                }
        }
        // 清理
        err = zipWriter.Close()
        if err != nil {
                log.Fatal(err)
        }
    }
    

    抽取(unzip) 文件

    // This example uses zip but standard library
    // also supports tar archives
    package main
    import (
        "archive/zip"
        "log"
        "io"
        "os"
        "path/filepath"
    )
    func main() {
        zipReader, err := zip.OpenReader("test.zip")
        if err != nil {
            log.Fatal(err)
        }
        defer zipReader.Close()
        // 遍历打包文件中的每一文件/文件夹
        for _, file := range zipReader.Reader.File {
            // 打包文件中的文件就像普通的一个文件对象一样
            zippedFile, err := file.Open()
            if err != nil {
                log.Fatal(err)
            }
            defer zippedFile.Close()
            // 指定抽取的文件名。
            // 你可以指定全路径名或者一个前缀,这样可以把它们放在不同的文件夹中。
            // 我们这个例子使用打包文件中相同的文件名。
            targetDir := "./"
            extractedFilePath := filepath.Join(
                targetDir,
                file.Name,
            )
            // 抽取项目或者创建文件夹
            if file.FileInfo().IsDir() {
                // 创建文件夹并设置同样的权限
                log.Println("Creating directory:", extractedFilePath)
                os.MkdirAll(extractedFilePath, file.Mode())
            } else {
                //抽取正常的文件
                log.Println("Extracting file:", file.Name)
                outputFile, err := os.OpenFile(
                    extractedFilePath,
                    os.O_WRONLY|os.O_CREATE|os.O_TRUNC,
                    file.Mode(),
                )
                if err != nil {
                    log.Fatal(err)
                }
                defer outputFile.Close()
                // 通过io.Copy简洁地复制文件内容
                _, err = io.Copy(outputFile, zippedFile)
                if err != nil {
                    log.Fatal(err)
                }
            }
        }
    }
    

    压缩文件

    // 这个例子中使用gzip压缩格式,标准库还支持zlib, bz2, flate, lzw
    package main
    import (
        "os"
        "compress/gzip"
        "log"
    )
    func main() {
        outputFile, err := os.Create("test.txt.gz")
        if err != nil {
            log.Fatal(err)
        }
        gzipWriter := gzip.NewWriter(outputFile)
        defer gzipWriter.Close()
        // 当我们写如到gizp writer数据时,它会依次压缩数据并写入到底层的文件中。
        // 我们不必关心它是如何压缩的,还是像普通的writer一样操作即可。
        _, err = gzipWriter.Write([]byte("Gophers rule!
    "))
        if err != nil {
            log.Fatal(err)
        }
        log.Println("Compressed data written to file.")
    }
    

    解压缩文件

    // 这个例子中使用gzip压缩格式,标准库还支持zlib, bz2, flate, lzw
    package main
    import (
        "compress/gzip"
        "log"
        "io"
        "os"
    )
    func main() {
        // 打开一个gzip文件。
        // 文件是一个reader,但是我们可以使用各种数据源,比如web服务器返回的gzipped内容,
        // 它的内容不是一个文件,而是一个内存流
        gzipFile, err := os.Open("test.txt.gz")
        if err != nil {
            log.Fatal(err)
        }
        gzipReader, err := gzip.NewReader(gzipFile)
        if err != nil {
            log.Fatal(err)
        }
        defer gzipReader.Close()
        // 解压缩到一个writer,它是一个file writer
        outfileWriter, err := os.Create("unzipped.txt")
        if err != nil {
            log.Fatal(err)
        }
        defer outfileWriter.Close()
        // 复制内容
        _, err = io.Copy(outfileWriter, gzipReader)
        if err != nil {
            log.Fatal(err)
        }
    }
    

    参考文档

    go文件操作总结

    go文件操作

  • 相关阅读:
    IT发烧友,一个真正的技术交流群
    IT发烧友,一个真正的技术交流群
    IT发烧友,一个真正的技术交流群
    IT发烧友,一个真正的技术交流群
    视频加密技术演进
    数字的二进制表示方法(反码、补码)
    Spring 当 @PathVariable 遇上 【. # /】等特殊字符
    spring boot系列03--spring security (基于数据库)登录和权限控制(下)
    嵌入式Tomcat容器的参数(maxParameterCount)设定
    spring boot系列02--Thymeleaf+Bootstrap构建页面
  • 原文地址:https://www.cnblogs.com/tomyyyyy/p/14157501.html
Copyright © 2011-2022 走看看