Tôi đã cố gắng tự học, nhưng tôi đã cố gắng đọc và ghi vào các tệp thông thường.
Tôi có thể hiểu được inFile, _ := os.Open(INFILE, 0, 0), nhưng thực sự việc lấy nội dung của tệp không có ý nghĩa gì, bởi vì chức năng đọc lấy []bytetham số.
func (file *File) Read(b []byte) (n int, err Error)Câu trả lời:
Hãy tạo một danh sách tương thích với Go 1 về tất cả các cách để đọc và ghi tệp trong Go.
Bởi vì API tệp đã thay đổi gần đây và hầu hết các câu trả lời khác không hoạt động với Go 1. Họ cũng bỏ lỡ bufioIMHO quan trọng.
Trong các ví dụ sau tôi sao chép một tệp bằng cách đọc từ nó và ghi vào tệp đích.
Bắt đầu với những điều cơ bản
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)
}
}
}
Ở đây tôi đã sử dụng os.Openvà os.Createđó là các trình bao bọc thuận tiện xung quanh os.OpenFile. Chúng tôi thường không cần gọi OpenFiletrực tiếp.
Thông báo điều trị EOF. Readcố gắng điền bufvào mỗi cuộc gọi và trả về io.EOFlà lỗi nếu nó đến cuối tập tin khi thực hiện. Trong trường hợp bufnày vẫn sẽ giữ dữ liệu. Các cuộc gọi tiếp theo Readtrả về 0 là số byte được đọc và giống io.EOFnhư lỗi. Bất kỳ lỗi nào khác sẽ dẫn đến hoảng loạn.
Sử dụng 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)
}
}
bufiochỉ đóng vai trò là bộ đệm ở đây, vì chúng ta không liên quan nhiều đến dữ liệu. Trong hầu hết các tình huống khác (đặc biệt với các tệp văn bản) bufiorất hữu ích bằng cách cung cấp cho chúng tôi một API đẹp để đọc và viết dễ dàng và linh hoạt, trong khi nó xử lý bộ đệm phía sau hậu trường.
Sử dụng 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)
}
}
Dễ như ăn bánh! Nhưng chỉ sử dụng nó nếu bạn chắc chắn rằng bạn không xử lý các tệp lớn.
panic("error in writing")) là không cần thiết.
Đây là phiên bản tốt:
package main
import (
"io/ioutil";
)
func main() {
contents,_ := ioutil.ReadFile("plikTekstowy.txt")
println(string(contents))
ioutil.WriteFile("filename", contents, 0644)
}
0x777là không có thật. Trong mọi trường hợp, nó nên giống 0644hoặc 0755(bát phân, không phải hex).
Sử dụng io.Copy
package main
import (
"io"
"log"
"os"
)
func main () {
// open files r and w
r, err := os.Open("input.txt")
if err != nil {
panic(err)
}
defer r.Close()
w, err := os.Create("output.txt")
if err != nil {
panic(err)
}
defer w.Close()
// do the actual work
n, err := io.Copy(w, r)
if err != nil {
panic(err)
}
log.Printf("Copied %v bytes\n", n)
}
Nếu bạn không muốn phát minh lại bánh xe, io.Copyvà io.CopyNcó thể phục vụ tốt cho bạn. Nếu bạn kiểm tra nguồn của hàm io.Copy, thì đó không phải là một trong những giải pháp của Mostafa (thực sự là 'cơ bản') được đóng gói trong thư viện Go. Họ đang sử dụng một bộ đệm lớn hơn đáng kể so với anh ta, mặc dù.
w.Sync()sauio.Copy(w, r)
io.Copy()sẽ chỉ ghi dữ liệu bạn cung cấp cho nó, vì vậy nếu tệp hiện có nhiều nội dung hơn, nó sẽ không bị xóa, điều này có thể dẫn đến tệp bị hỏng.
w, err := os.Create("output.txt"), những gì bạn mô tả sẽ không xảy ra, bởi vì "Tạo tạo hoặc cắt bớt tệp đã đặt tên. Nếu tệp đã tồn tại, nó sẽ bị cắt ngắn." golang.org/pkg/os/#Create .
Với các phiên bản Go mới hơn, việc đọc / ghi vào / từ tệp rất dễ dàng. Để đọc từ một tập tin:
package main
import (
"fmt"
"io/ioutil"
)
func main() {
data, err := ioutil.ReadFile("text.txt")
if err != nil {
return
}
fmt.Println(string(data))
}
Để ghi vào một tập tin:
package main
import "os"
func main() {
file, err := os.Create("text.txt")
if err != nil {
return
}
defer file.Close()
file.WriteString("test\nhello")
}
Điều này sẽ ghi đè lên nội dung của một tệp (tạo một tệp mới nếu nó không có ở đó).
[]bytelà một lát (tương tự như một chuỗi con) của tất cả hoặc một phần của mảng byte. Hãy nghĩ về lát cắt như một cấu trúc giá trị với trường con trỏ ẩn để hệ thống định vị và truy cập tất cả hoặc một phần của mảng (lát cắt), cộng với các trường về độ dài và dung lượng của lát cắt mà bạn có thể truy cập bằng cách sử dụng len()và cap()các hàm .
Đây là một bộ khởi động làm việc cho bạn, nó đọc và in một tệp nhị phân; bạn sẽ cần thay đổi inNamegiá trị bằng chữ để chỉ một tệp nhỏ trên hệ thống của bạn.
package main
import (
"fmt";
"os";
)
func main()
{
inName := "file-rw.bin";
inPerm := 0666;
inFile, inErr := os.Open(inName, os.O_RDONLY, inPerm);
if inErr == nil {
inBufLen := 16;
inBuf := make([]byte, inBufLen);
n, inErr := inFile.Read(inBuf);
for inErr == nil {
fmt.Println(n, inBuf[0:n]);
n, inErr = inFile.Read(inBuf);
}
}
inErr = inFile.Close();
}
ifkhối
Thử cái này:
package main
import (
"io";
)
func main() {
contents,_ := io.ReadFile("filename");
println(string(contents));
io.WriteFile("filename", contents, 0644);
}Chỉ cần nhìn vào tài liệu, có vẻ như bạn chỉ cần khai báo bộ đệm loại [] byte và chuyển nó để đọc, sau đó sẽ đọc đến nhiều ký tự đó và trả về số lượng ký tự thực sự đã đọc (và một lỗi).
Các tài liệu nói
Đọc đọc tối đa len (b) byte từ Tệp. Nó trả về số byte đã đọc và một Lỗi, nếu có. EOF được báo hiệu bằng số không có lỗi được đặt thành EOF.
Điều đó không làm việc?
EDIT: Ngoài ra, tôi nghĩ rằng có lẽ bạn nên sử dụng giao diện Reader / Writer được khai báo trong gói bufio thay vì sử dụng gói os .
Phương thức Read lấy tham số byte vì đó là bộ đệm mà nó sẽ đọc vào. Đó là một Thành ngữ phổ biến trong một số vòng tròn và có ý nghĩa khi bạn nghĩ về nó.
Bằng cách này, bạn có thể xác định có bao nhiêu byte sẽ được người đọc đọc và kiểm tra sự trở lại để xem có bao nhiêu byte thực sự được đọc và xử lý bất kỳ lỗi nào một cách thích hợp.
Như những người khác đã chỉ ra trong câu trả lời của họ, bufio có lẽ là những gì bạn muốn đọc từ hầu hết các tập tin.
Tôi sẽ thêm một gợi ý khác vì nó thực sự hữu ích. Đọc một dòng từ một tệp được hoàn thành tốt nhất không phải bằng phương pháp ReadLine mà là phương thức ReadBytes hoặc ReadString.