How to read write from to a file using go

在 Go 语言中，读写文件主要通过标准库中的 io 和 os 包来进行。以下是一些基本的文件操作步骤和示例代码。

文件写入

要在 Go 中写入文件，可以使用 os 包中的 Create 和 OpenFile 函数创建或打开一个文件，并使用 Write 或 WriteString 方法写入数据。如果文件不存在，Create 函数将创建文件。而 OpenFile 函数则可以指定不同的标志来决定模式（如只读、只写或追加）和权限。

go
package main

import (
	"log"
	"os"
)

func main() {
	// 创建或者打开文件
	file, err := os.Create("example.txt")
	if err != nil {
		log.Fatal(err)
	}
	defer file.Close()

	// 写入字节数据
	byteSlice := []byte("Hello Golang!\n")
	_, err = file.Write(byteSlice)
	if err != nil {
		log.Fatal(err)
	}

	// 写入字符串数据
	_, err = file.WriteString("Writing string data to a file.\n")
	if err != nil {
		log.Fatal(err)
	}
}

文件读取

读取文件时，可以使用 os.Open 函数打开文件，并使用 io 包或 bufio 包来读取内容。bufio 包提供的 Scanner 类型通常用于读取以换行符分隔的文本文件。

go
package main

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

func main() {
	// 打开文件
	file, err := os.Open("example.txt")
	if err != nil {
		log.Fatal(err)
	}
	defer file.Close()

	// 使用 bufio.NewReader 来读取文件内容
	reader := bufio.NewReader(file)
	for {
		// 读取一行
		line, err := reader.ReadString('\n')
		if err != nil {
			// 如果读到文件的结尾，则跳出循环
			if err.Error() == "EOF" {
				break
			}
			log.Fatal(err)
		}
		fmt.Print(line)
	}
}

错误处理

在上述示例中，您可能注意到每次文件操作后都会有错误检查。这是因为读写文件时可能会遇到各种错误，例如文件不存在、没有足够的权限等。在 Go 中，错误处理是非常重要的，应始终检查每个可能失败的操作。

文件关闭

在完成文件操作后，应该使用 defer 语句确保文件被正确关闭。defer 语句会在包含它的函数结束时执行，这样可以保证即使在发生错误时文件也会被关闭。

以上就是使用 Go 语言进行文件读写的基本方法。在实际的应用中，可能还会涉及到更复杂的文件处理，例如处理大文件时可能需要分块读取，或者使用并发来加快文件处理速度等。在这些情况下，可以根据具体需求选择相应的策略和优化方法。

让我们制作一个与 Go 1 兼容的列表，列出在 Go 中读写文件的所有方法。

因为文件 API 最近发生了变化，并且大多数其他答案不适用于 Go 1。bufio恕我直言，他们也错过了重要的一点。

在以下示例中，我通过读取文件并将其写入目标文件来复制文件。

从基础开始

shell
package main

import (
    "io"
    "os"
)

func main() {
    // open input file
    fi, err := os.Open("input.txt")
    if err != nil {
        panic(err)
    }
    // close fi on exit and check for its returned error
    defer func() {
        if err := fi.Close(); err != nil {
            panic(err)
        }
    }()

    // open output file
    fo, err := os.Create("output.txt")
    if err != nil {
        panic(err)
    }
    // close fo on exit and check for its returned error
    defer func() {
        if err := fo.Close(); err != nil {
            panic(err)
        }
    }()

    // make a buffer to keep chunks that are read
    buf := make([]byte, 1024)
    for {
        // read a chunk
        n, err := fi.Read(buf)
        if err != nil && err != io.EOF {
            panic(err)
        }
        if n == 0 {
            break
        }

        // write a chunk
        if _, err := fo.Write(buf[:n]); err != nil {
            panic(err)
        }
    }
}

在这里我使用了os.Open和 ，os.Create它们是方便的包装器os.OpenFile。我们通常不需要OpenFile直接打电话。

注意处理 EOF。Read尝试填充buf每个调用，io.EOF如果这样做到达文件末尾，则返回错误。在这种情况下buf仍然会保存数据。随后的调用Read返回零作为读取的字节数，并io.EOF与错误相同。任何其他错误都会导致恐慌。

使用bufio

shell
package main

import (
    "bufio"
    "io"
    "os"
)

func main() {
    // open input file
    fi, err := os.Open("input.txt")
    if err != nil {
        panic(err)
    }
    // close fi on exit and check for its returned error
    defer func() {
        if err := fi.Close(); err != nil {
            panic(err)
        }
    }()
    // make a read buffer
    r := bufio.NewReader(fi)

    // open output file
    fo, err := os.Create("output.txt")
    if err != nil {
        panic(err)
    }
    // close fo on exit and check for its returned error
    defer func() {
        if err := fo.Close(); err != nil {
            panic(err)
        }
    }()
    // make a write buffer
    w := bufio.NewWriter(fo)

    // make a buffer to keep chunks that are read
    buf := make([]byte, 1024)
    for {
        // read a chunk
        n, err := r.Read(buf)
        if err != nil && err != io.EOF {
            panic(err)
        }
        if n == 0 {
            break
        }

        // write a chunk
        if _, err := w.Write(buf[:n]); err != nil {
            panic(err)
        }
    }

    if err = w.Flush(); err != nil {
        panic(err)
    }
}

bufio这里只是充当缓冲区，因为我们与数据没有太多关系。在大多数其他情况下（特别是文本文件），它为我们提供了一个很好的 API，可以轻松灵活地读写，同时它在幕后处理缓冲，这bufio非常有用。

---

**注意：**以下代码适用于旧版 Go 版本（Go 1.15 及之前版本）。事情已经发生了变化（自 Go 1.16 起ioutil已弃用）。对于新方法，请看一下这个答案。

使用ioutil

shell
package main

import (
    "io/ioutil"
)

func main() {
    // read the whole file at once
    b, err := ioutil.ReadFile("input.txt")
    if err != nil {
        panic(err)
    }

    // write the whole body at once
    err = ioutil.WriteFile("output.txt", b, 0644)
    if err != nil {
        panic(err)
    }
}

易如反掌！但仅当您确定不处理大文件时才使用它。

这是一个很好的版本（但请注意，自 Go 1.16 以来ioutil已弃用）：

shell
package main

import (
  "io/ioutil"; 
  )


func main() {
  contents,_ := ioutil.ReadFile("plikTekstowy.txt")
  println(string(contents))
  ioutil.WriteFile("filename", contents, 0644)
}

新方法

从 Go 1.16 开始，使用os.ReadFile将文件加载到内存中，并使用ioutil.ReadFileos.WriteFile从内存写入文件（ioutil.ReadFile现在调用os.ReadFile并已弃用）。

请小心，os.ReadFile因为它将整个文件读取到内存中。

shell
package main

import "os"
import "log"

func main() {
    b, err := os.ReadFile("input.txt")
    if err != nil {
        log.Fatal(err)
    }

    // `b` contains everything your file has.
    // This writes it to the Standard Out.
    os.Stdout.Write(b)

    // You can also write it to a file as a whole.
    err = os.WriteFile("destination.txt", b, 0644)
    if err != nil {
        log.Fatal(err)
    }
}