我一直在尝试自己学习Go,但在尝试读取和写入普通文件时,我被难住了。
我可以到inFile, _:= os。Open(INFILE, 0,0),但实际上获取文件的内容没有意义,因为read函数以[]字节作为参数。
func (file *File) Read(b []byte) (n int, err Error)
我一直在尝试自己学习Go,但在尝试读取和写入普通文件时,我被难住了。
我可以到inFile, _:= os。Open(INFILE, 0,0),但实际上获取文件的内容没有意义,因为read函数以[]字节作为参数。
func (file *File) Read(b []byte) (n int, err Error)
当前回答
让我们列出一个与Go 1兼容的列表,其中包括在Go中读写文件的所有方法。
因为文件API最近发生了变化,大多数其他答案都不适合Go 1。他们也想念bufio,这很重要。
在下面的例子中,我通过从文件中读取并写入目标文件来复制一个文件。
从基础开始
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。打开和操作。创建它们是os.OpenFile的方便包装器。我们通常不需要直接调用OpenFile。
注意处理EOF。Read尝试在每次调用时填充buf,并返回io。EOF作为错误,如果它达到文件的结束这样做。在这种情况下,buf仍将保存数据。对Read的后续调用返回0作为读取的字节数和相同的io。EOF作为错误。任何其他错误都会导致恐慌。
使用bufio
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在这里只是充当缓冲区,因为我们与数据没有太多关系。在大多数其他情况下(特别是文本文件),bufio非常有用,它为我们提供了一个很好的API,可以轻松灵活地读写,同时它在幕后处理缓冲。
注意:以下代码适用于较旧的Go版本(Go 1.15及之前)。事情发生了变化(ioutil自Go 1.16以来已弃用)。关于新方法,看看这个答案。
使用ioutil
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)
}
}
易如反掌!但只有在确定处理的不是大文件时才使用它。
其他回答
请注意。ioutil自Go 1.16起已弃用。
使用较新的Go版本,读取/写入文件或从文件中写入文件很容易。从文件中读取:
package main
import (
"fmt"
"io/ioutil"
)
func main() {
data, err := ioutil.ReadFile("text.txt")
if err != nil {
return
}
fmt.Println(string(data))
}
写入文件:
package main
import "os"
func main() {
file, err := os.Create("text.txt")
if err != nil {
return
}
defer file.Close()
file.WriteString("test\nhello")
}
这将覆盖文件的内容(如果文件不存在,则创建一个新文件)。
请注意。由于Go 1.16 ReadFile在os包中。
试试这个:
package main
import (
"io";
)
func main() {
contents,_ := io.ReadFile("filename");
println(string(contents));
io.WriteFile("filename", contents, 0644);
}
这是一个很好的版本(但请注意,ioutil自Go 1.16以来已弃用):
package main
import (
"io/ioutil";
)
func main() {
contents,_ := ioutil.ReadFile("plikTekstowy.txt")
println(string(contents))
ioutil.WriteFile("filename", contents, 0644)
}
Read方法接受一个字节参数,因为这是它将读入的缓冲区。这是某些圈子里的常用成语,仔细想想还是有道理的。
通过这种方式,您可以确定读取器将读取多少字节,并检查返回值以查看实际读取了多少字节,并适当地处理任何错误。
正如其他人在他们的回答中指出的那样,bufio可能是您从大多数文件读取所需要的。
我再加一个提示,因为它真的很有用。从文件中读取一行的最好方法不是使用ReadLine方法,而是使用ReadBytes或ReadString方法。
让我们列出一个与Go 1兼容的列表,其中包括在Go中读写文件的所有方法。
因为文件API最近发生了变化,大多数其他答案都不适合Go 1。他们也想念bufio,这很重要。
在下面的例子中,我通过从文件中读取并写入目标文件来复制一个文件。
从基础开始
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。打开和操作。创建它们是os.OpenFile的方便包装器。我们通常不需要直接调用OpenFile。
注意处理EOF。Read尝试在每次调用时填充buf,并返回io。EOF作为错误,如果它达到文件的结束这样做。在这种情况下,buf仍将保存数据。对Read的后续调用返回0作为读取的字节数和相同的io。EOF作为错误。任何其他错误都会导致恐慌。
使用bufio
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在这里只是充当缓冲区,因为我们与数据没有太多关系。在大多数其他情况下(特别是文本文件),bufio非常有用,它为我们提供了一个很好的API,可以轻松灵活地读写,同时它在幕后处理缓冲。
注意:以下代码适用于较旧的Go版本(Go 1.15及之前)。事情发生了变化(ioutil自Go 1.16以来已弃用)。关于新方法,看看这个答案。
使用ioutil
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)
}
}
易如反掌!但只有在确定处理的不是大文件时才使用它。