关于后端:go操作文件大全

57次阅读

共计 17096 个字符，预计需要花费 43 分钟才能阅读完成。

Go 文件操作大全

1 介绍

万物皆文件

UNIX 的一个根底设计就是 ” 万物皆文件 ”(everything is a file)。咱们不用晓得一个文件到底映射成什么，操作系统的设施驱动形象成文件。操作系统为设施提供了文件格式的接口。

Go 语言中的 reader 和 writer 接口也相似。咱们只需简略的读写字节，不用晓得 reader 的数据来自哪里，也不用晓得 writer 将数据发送到哪里。
你能够在 /dev 下查看可用的设施，有些可能须要较高的权限能力拜访。

2 基本操作

2.1 创立空文件

// 创立新文件，如果文件存在，有内容会清空
func makeNewFile() {newFile, err := os.Create("test.txt")
    if err != nil {log.Fatal(err)
    }
    log.Println(newFile)
    err = newFile.Close()
    if err != nil {log.Fatal(err)
    }
}

2.2 Truncate 文件

-rw-r--r--  1 zhangqiuli24  staff   697B Oct  8 14:30 test.txt

// 重制文件
// 裁剪一个文件到 100 个字节。// 如果文件原本就少于 100 个字节，则文件中原始内容得以保留，残余的字节以 null 字节填充。// 如果文件原本超过 100 个字节，则超过的字节会被摈弃。// 这样咱们总是失去准确的 100 个字节的文件。// 传入 0 则会清空文件。func truncateFile(){err := os.Truncate("test.txt", 100)
    if err != nil {log.Fatal(err)
    }
}

-rw-r--r--  1 zhangqiuli24  staff   100B Oct  8 14:32 test.txt

2.3 文件信息

// 文件信息
func fileInfos(){
    // 如果文件不存在，则返回谬误
    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\n", fileInfo.Sys())
    fmt.Printf("System info: %+v\n\n", fileInfo.Sys())
}

$ go run main.go
File name: test.txt
Size in bytes: 100
Permissions: -rw-r--r--
Last modified: 2022-10-08 14:32:02.822465128 +0800 CST
Is Directory:  false
System interface type: *syscall.Stat_t
System info: &{Dev:16777231 Mode:33188 Nlink:1 Ino:47887641 Uid:502 Gid:20 Rdev:0 Pad_cgo_0:[0 0 0 0] Atimespec:{Sec:1665210724 Nsec:86545989} Mtimespec:{Sec:1665210722 Nsec:822465128} Ctimespec:{Sec:1665210722 Nsec:822465128} Birthtimespec:{Sec:1665210638 Nsec:435434306} Size:100 Blocks:8 Blksize:4096 Flags:0 Gen:0 Lspare:0 Qspare:[0 0]}

2.4 重命名和挪动

//rename 和 move 原理一样
func renameAndMove(){
    originalPath := "test.txt"
    newPath := "test2.txt"
    err := os.Rename(originalPath, newPath)
    if err != nil {log.Fatal(err)
    }
}

2.5 删除文件

// 删除文件
func removeFile(){err := os.Remove("test.txt")
    if err != nil {log.Fatal(err)
    }
}

2.6 关上和敞开文件

func openCloseFile(){
    // 简略地以只读的形式关上。上面的例子会介绍读写的例子。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 的形式关上
}

2.7 查看文件是否存在

// 查看文件是否存在
func checkFileExist(){
    // 文件不存在则返回 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)
}

2.8 查看读写权限

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()}

2.9 扭转权限、拥有者、工夫戳

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)
    }
}

2.10 硬链接和软链接

一个一般的文件是一个指向硬盘的 inode 的中央。
硬链接创立一个新的指针指向同一个中央。只有所有的链接被删除后文件才会被删除。硬链接只在雷同的文件系统中才工作。你能够认为一个硬链接是一个失常的链接。

symbolic link，又叫软连贯，和硬链接有点不一样，它不间接指向硬盘中的雷同的中央，而是通过名字援用其它文件。他们能够指向不同的文件系统中的不同文件。并不是所有的操作系统都反对软链接。

package main
import (
    "os"
    "log"
    "fmt"
)
func main() {
    // 创立一个硬链接。// 创立后同一个文件内容会有两个文件名，扭转一个文件的内容会影响另一个。// 删除和重命名不会影响另一个。err := os.Link("original.txt", "original_also.txt")
    if err != nil {log.Fatal(err)
    }
    fmt.Println("creating sym")
    // Create a symlink
    err = os.Symlink("original.txt", "original_sym.txt")
    if err != nil {log.Fatal(err)
    }
    // Lstat 返回一个文件的信息，然而当文件是一个软链接时，它返回软链接的信息，而不是援用的文件的信息。// Symlink 在 Windows 中不工作。fileInfo, err := os.Lstat("original_sym.txt")
    if err != nil {log.Fatal(err)
    }
    fmt.Printf("Link info: %+v", fileInfo)
    // 扭转软链接的拥有者不会影响原始文件。err = os.Lchown("original_sym.txt", os.Getuid(), os.Getgid())
    if err != nil {log.Fatal(err)
    }
}

3 读写

3.1 复制文件

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)
    }
}

3.2 跳转到文件指定地位(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)
}
$ go run main.go
Just moved to 5: 5
Just moved back two: 3
Current position: 3
Position after seeking 0,0: 0

3.3 写文件

能够应用 os 包写入一个关上的文件。
因为 Go 可执行包是动态链接的可执行文件，你 import 的每一个包都会减少你的可执行文件的大小。其它的包如io、`ioutil`、`bufio`提供了一些办法，然而它们不是必须的。

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!\n")
    bytesWritten, err := file.Write(byteSlice)
    if err != nil {log.Fatal(err)
    }
    log.Printf("Wrote %d bytes.\n", bytesWritten)
}

3.4 快写文件

ioutil包有一个十分有用的办法 WriteFile() 能够解决创立/关上文件、写字节 slice 和敞开文件一系列的操作。如果你须要简洁疾速地写字节 slice 到文件中，你能够应用它。

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

3.5 应用缓存写

bufio包提供了带缓存性能的 writer，所以你能够在写字节到硬盘前应用内存缓存。当你解决很多的数据很有用，因为它能够节俭操作硬盘 I / O 的工夫。在其它一些状况下它也很有用，比方你每次写一个字节，把它们攒在内存缓存中，而后一次写入到硬盘中，缩小硬盘的磨损以及晋升性能。

package main

import (
    "bufio"
    "log"
    "os"
)

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\n", bytesWritten)
    // 写字符串到 buffer
    // 也能够应用 WriteRune() 和 WriteByte()
    bytesWritten, err = bufferedWriter.WriteString("Buffered string\n",)
    if err != nil {log.Fatal(err)
    }
    log.Printf("Bytes written: %d\n", bytesWritten)
    // 查看缓存中的字节数
    unflushedBufferSize := bufferedWriter.Buffered()
    log.Printf("Bytes buffered: %d\n", unflushedBufferSize)
    // 还有多少字节可用（未应用的缓存大小）bytesAvailable := bufferedWriter.Available()
    if err != nil {log.Fatal(err)
    }
    log.Printf("Available buffer: %d\n", bytesAvailable)
    // 写内存 buffer 到硬盘
    bufferedWriter.Flush()
    // 抛弃还没有 flush 的缓存的内容，革除谬误并把它的输入传给参数中的 writer
    // 当你想将缓存传给另外一个 writer 时有用
    bufferedWriter.Reset(bufferedWriter)
    bytesAvailable = bufferedWriter.Available()
    if err != nil {log.Fatal(err)
    }
    log.Printf("Available buffer: %d\n", 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\n", bytesAvailable)
}

$ go run main.go
2022/10/08 14:54:43 Bytes written: 3
2022/10/08 14:54:43 Bytes written: 16
2022/10/08 14:54:43 Bytes buffered: 19
2022/10/08 14:54:43 Available buffer: 4077
2022/10/08 14:54:43 Available buffer: 4096
2022/10/08 14:54:43 Available buffer: 8000

偏移量写入

import "os"
 
func writeAt(filename string) error {data := []byte{
  0x41, // A
  0x73, // s
  0x20, // space
  0x20, // space
  0x67, // g
 }
 f, err := os.OpenFile(filename, os.O_WRONLY, 0666)
 if err != nil{return err}
 _, err = f.Write(data)
 if err != nil{return err}
 
 replaceSplace := []byte{
  0x6F, // o
  0x6E, // n
 }
 _, err = f.WriteAt(replaceSplace, 2)
 if err != nil{return err}
 f.Close()
 return nil
}

3.6 读取最多 N 个字节

os.File提供了文件操作的基本功能，而 io、ioutil、bufio 提供了额定的辅助函数。

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\n", bytesRead)
    log.Printf("Data read: %s\n", byteSlice)
}

3.7 读取正好 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\n", numBytesRead)
    log.Printf("Data read: %s\n", byteSlice)
}

3.8 读取至多 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\n", numBytesRead)
    log.Printf("Data read: %s\n", byteSlice)
}

3.9 读取全副字节

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\n", data)
    fmt.Printf("Data as string: %s\n", data)
    fmt.Println("Number of bytes read:", len(data))
}

3.10 快读到内存

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\n", data)
}

3.11 应用缓存读

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

$ cat test.txt                                                 
ABCBuffered string
0
lllllllllllll

package main

import (
    "bufio"
    "fmt"
    "log"
    "os"
)

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\n", byteSlice)
    // 读取，指针同时挪动
    numBytesRead, err := bufferedReader.Read(byteSlice)
    if err != nil {log.Fatal(err)
    }
    fmt.Printf("Read %d bytes: %s\n", numBytesRead, byteSlice)
    // 读取一个字节, 如果读取不胜利会返回 Error
    myByte, err := bufferedReader.ReadByte()
    if err != nil {log.Fatal(err)
    }
    fmt.Printf("Read 1 byte: %c\n", myByte)
    // 读取到分隔符，蕴含分隔符，返回 byte slice
    dataBytes, err := bufferedReader.ReadBytes('\n')
    if err != nil {log.Fatal(err)
    }
    fmt.Printf("Read bytes: %s\n", dataBytes)
    // 读取到分隔符，蕴含分隔符，返回字符串
    dataString, err := bufferedReader.ReadString('\n')
    if err != nil {log.Fatal(err)
    }
    fmt.Printf("Read string: %s\n", dataString)
    // 这个例子读取了很多行，所以 test.txt 应该蕴含多行文本才不至于出错
}

$ go run main.go
Peeked at 5 bytes: ABCBu
Read 5 bytes: ABCBu
Read 1 byte: f
Read bytes: fered string

Read string: 0

3.12 应用 scanner

Scanner是 bufio 包下的类型, 在解决文件中以分隔符分隔的文本时很有用。
通常咱们应用换行符作为分隔符将文件内容分成多行。在 CSV 文件中，逗号个别作为分隔符。
os.File文件能够被包装成 bufio.Scanner，它就像一个缓存 reader。
咱们会调用 Scan() 办法去读取下一个分隔符，应用 Text() 或者 Bytes() 获取读取的数据。

分隔符能够不是一个简略的字节或者字符，有一个非凡的办法能够实现分隔符的性能，以及将指针挪动多少，返回什么数据。
如果没有定制的 SplitFunc 提供，缺省的 ScanLines 会应用 newline 字符作为分隔符，其它的分隔函数还包含 ScanRunes 和ScanWords, 皆在 bufio 包中。

// To define your own split function, match this fingerprint
type SplitFunc func(data []byte, atEOF bool) (advance int, token []byte, err error)
// Returning (0, nil, nil) will tell the scanner
// to scan again, but with a bigger buffer because
// it wasn't enough data to reach the delimiter

上面的例子中，为一个文件创建了bufio.Scanner，并依照单词一一读取：

package main
import (
    "os"
    "log"
    "fmt"
    "bufio"
)
func main() {file, err := os.Open("test.txt")
    if err != nil {log.Fatal(err)
    }
    scanner := bufio.NewScanner(file)
    // 缺省的分隔函数是 bufio.ScanLines, 咱们这里应用 ScanWords。// 也能够定制一个 SplitFunc 类型的分隔函数
    scanner.Split(bufio.ScanWords)
    // scan 下一个 token.
    success := scanner.Scan()
    if success == false {
        // 呈现谬误或者 EOF 是返回 Error
        err = scanner.Err()
        if err == nil {log.Println("Scan completed and reached EOF")
        } else {log.Fatal(err)
        }
    }
    // 失去数据，Bytes() 或者 Text()
    fmt.Println("First word found:", scanner.Text())
    // 再次调用 scanner.Scan()发现下一个 token}
$ cat test.txt
AvScanner 是 bufio 包下的类型, 在解决文件中以分隔符分隔的文本时很有用。通常咱们应用换行符作为分隔符将文件内容分成多行。在 CSV 文件中，逗号个别作为分隔符。os.File 文件能够被包装成 bufio.Scanner，它就像一个缓存 reader。咱们会调用 Scan()办法去读取下一个分隔符，应用 Text()或者 Bytes()获取读取的数据。分隔符能够不是一个简略的字节或者字符，有一个非凡的办法能够实现分隔符的性能，以及将指针挪动多少，返回什么数据。如果没有定制的 SplitFunc 提供，缺省的 ScanLines 会应用 newline 字符作为分隔符，其它的分隔函数还包含 ScanRunes 和 ScanWords, 皆在 bufio 包中。BCBuffered string
0
lllllllllllll

 
$ go run main.go
First word found: AvScanner 是 bufio 包下的类型, 在解决文件中以分隔符分隔的文本时很有用。First word found: AvScanner 是 bufio 包下的类型, 在解决文件中以分隔符分隔的文本时很有用。

4 压缩

4.1 打包(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", "\x61\x62\x63\n"},
    }
    // 上面将要打包的内容写入到打包文件中，顺次写入。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)
    }
}

4.2 抽取(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)
            }
        }
    }
}

4.3 压缩文件

// 这个例子中应用 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!\n"))
    if err != nil {log.Fatal(err)
    }
    log.Println("Compressed data written to file.")
}

4.4 解压缩文件

// 这个例子中应用 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)
    }
}

5 其它

5.1 临时文件和目录

ioutil提供了两个函数: TempDir() 和 TempFile()。
应用结束后，调用者负责删除这些临时文件和文件夹。
有一点益处就是当你传递一个空字符串作为文件夹名的时候，它会在操作系统的长期文件夹中创立这些我的项目（/tmp on Linux）。
os.TempDir()返回以后操作系统的长期文件夹。

package main
import (
     "os"
     "io/ioutil"
     "log"
     "fmt"
)
func main() {
     // 在零碎长期文件夹中创立一个长期文件夹
     tempDirPath, err := ioutil.TempDir("","myTempDir")
     if err != nil {log.Fatal(err)
     }
     fmt.Println("Temp dir created:", tempDirPath)
     // 在长期文件夹中创立临时文件
     tempFile, err := ioutil.TempFile(tempDirPath, "myTempFile.txt")
     if err != nil {log.Fatal(err)
     }
     fmt.Println("Temp file created:", tempFile.Name())
     // ... 做一些操作 ...
     // 敞开文件
     err = tempFile.Close()
     if err != nil {log.Fatal(err)
    }
    // 删除咱们创立的资源
     err = os.Remove(tempFile.Name())
     if err != nil {log.Fatal(err)
    }
     err = os.Remove(tempDirPath)
     if err != nil {log.Fatal(err)
    }
}

5.2 通过 HTTP 下载文件

package main
import (
     "os"
     "io"
     "log"
     "net/http"
)
func main() {newFile, err := os.Create("devdungeon.html")
     if err != nil {log.Fatal(err)
     }
     defer newFile.Close()
     url := "http://www.devdungeon.com/archive"
     response, err := http.Get(url)
     defer response.Body.Close()
     // 将 HTTP response Body 中的内容写入到文件
     // Body 满足 reader 接口，因而咱们能够应用 ioutil.Copy
     numBytesWritten, err := io.Copy(newFile, response.Body)
     if err != nil {log.Fatal(err)
     }
     log.Printf("Downloaded %d byte file.\n", numBytesWritten)
}

5.3 哈希和摘要

package main
import (
    "crypto/md5"
    "crypto/sha1"
    "crypto/sha256"
    "crypto/sha512"
    "log"
    "fmt"
    "io/ioutil"
)
func main() {
    // 失去文件内容
    data, err := ioutil.ReadFile("test.txt")
    if err != nil {log.Fatal(err)
    }
    // 计算 Hash
    fmt.Printf("Md5: %x\n\n", md5.Sum(data))
    fmt.Printf("Sha1: %x\n\n", sha1.Sum(data))
    fmt.Printf("Sha256: %x\n\n", sha256.Sum256(data))
    fmt.Printf("Sha512: %x\n\n", sha512.Sum512(data))
}

下面的例子复制整个文件内容到内存中，传递给 hash 函数。
另一个形式是创立一个 hash writer, 应用 Write、WriteString、Copy 将数据传给它。
上面的例子应用 md5 hash, 但你能够应用其它的 Writer。

package main
import (
    "crypto/md5"
    "log"
    "fmt"
    "io"
    "os"
)
func main() {file, err := os.Open("test.txt")
    if err != nil {log.Fatal(err)
    }
    defer file.Close()
    // 创立一个新的 hasher, 满足 writer 接口
    hasher := md5.New()
    _, err = io.Copy(hasher, file)
    if err != nil {log.Fatal(err)
    }
    // 计算 hash 并打印后果。// 传递 nil 作为参数，因为咱们不通参数传递数据，而是通过 writer 接口。sum := hasher.Sum(nil)
    fmt.Printf("Md5 checksum: %x\n", sum)
}

本文由 mdnice 多平台公布

正文完
后端
发表至： 后端
2022-10-08
 0
关于后端:Go学习二十七反射学习使用
关于后端:小白晋级大师如何设计一个支持10万人用的ChatGPT对接系统
关于后端:GoLand-202313最新版安装激活教程附激活码亲测有效
关于后端:ToplingDB-分布式-Compact天然的协同