Đọc tệp văn bản thành mảng chuỗi (và ghi)

Tôi tin rằng khả năng đọc (và ghi) một tệp văn bản vào và ra khỏi một mảng chuỗi là một yêu cầu khá phổ biến. Nó cũng khá hữu ích khi bắt đầu với một ngôn ngữ loại bỏ nhu cầu ban đầu để truy cập cơ sở dữ liệu. Có ai tồn tại ở Golang không?
ví dụ

func ReadLines(sFileName string, iMinLines int) ([]string, bool) {

và

func WriteLines(saBuff[]string, sFilename string) (bool) { 

Tôi muốn sử dụng một cái hiện có hơn là bản sao.

Kể từ phiên bản Go1.1, có một API bufio.Scanner có thể dễ dàng đọc các dòng từ một tệp. Hãy xem xét ví dụ sau từ trên, được viết lại bằng Máy quét:

package main

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

// readLines reads a whole file into memory
// and returns a slice of its lines.
func readLines(path string) ([]string, error) {
    file, err := os.Open(path)
    if err != nil {
        return nil, err
    }
    defer file.Close()

    var lines []string
    scanner := bufio.NewScanner(file)
    for scanner.Scan() {
        lines = append(lines, scanner.Text())
    }
    return lines, scanner.Err()
}

// writeLines writes the lines to the given file.
func writeLines(lines []string, path string) error {
    file, err := os.Create(path)
    if err != nil {
        return err
    }
    defer file.Close()

    w := bufio.NewWriter(file)
    for _, line := range lines {
        fmt.Fprintln(w, line)
    }
    return w.Flush()
}

func main() {
    lines, err := readLines("foo.in.txt")
    if err != nil {
        log.Fatalf("readLines: %s", err)
    }
    for i, line := range lines {
        fmt.Println(i, line)
    }

    if err := writeLines(lines, "foo.out.txt"); err != nil {
        log.Fatalf("writeLines: %s", err)
    }
}

Nếu tập tin là không quá lớn, điều này có thể được thực hiện với sự ioutil.ReadFilevà strings.Splitchức năng giống như vậy:

content, err := ioutil.ReadFile(filename)
if err != nil {
    //Do something
}
lines := strings.Split(string(content), "\n")

Bạn có thể đọc tài liệu về gói ioutil và chuỗi .

Không thể cập nhật câu trả lời đầu tiên.
Dù sao, sau khi phát hành Go1, có một số thay đổi đột phá, vì vậy tôi đã cập nhật như hình dưới đây:

package main

import (
    "os"
    "bufio"
    "bytes"
    "io"
    "fmt"
    "strings"
)

// Read a whole file into the memory and store it as array of lines
func readLines(path string) (lines []string, err error) {
    var (
        file *os.File
        part []byte
        prefix bool
    )
    if file, err = os.Open(path); err != nil {
        return
    }
    defer file.Close()

    reader := bufio.NewReader(file)
    buffer := bytes.NewBuffer(make([]byte, 0))
    for {
        if part, prefix, err = reader.ReadLine(); err != nil {
            break
        }
        buffer.Write(part)
        if !prefix {
            lines = append(lines, buffer.String())
            buffer.Reset()
        }
    }
    if err == io.EOF {
        err = nil
    }
    return
}

func writeLines(lines []string, path string) (err error) {
    var (
        file *os.File
    )

    if file, err = os.Create(path); err != nil {
        return
    }
    defer file.Close()

    //writer := bufio.NewWriter(file)
    for _,item := range lines {
        //fmt.Println(item)
        _, err := file.WriteString(strings.TrimSpace(item) + "\n"); 
        //file.Write([]byte(item)); 
        if err != nil {
            //fmt.Println("debug")
            fmt.Println(err)
            break
        }
    }
    /*content := strings.Join(lines, "\n")
    _, err = writer.WriteString(content)*/
    return
}

func main() {
    lines, err := readLines("foo.txt")
    if err != nil {
        fmt.Println("Error: %s\n", err)
        return
    }
    for _, line := range lines {
        fmt.Println(line)
    }
    //array := []string{"7.0", "8.5", "9.1"}
    err = writeLines(lines, "foo2.txt")
    fmt.Println(err)
}

Bạn có thể sử dụng os.File (triển khai giao diện io.Reader ) với gói bufio cho việc đó. Tuy nhiên, các gói đó được xây dựng với lưu ý đến việc sử dụng bộ nhớ cố định (bất kể tệp có dung lượng lớn như thế nào) và khá nhanh.

Thật không may, điều này làm cho việc đọc toàn bộ tệp vào bộ nhớ phức tạp hơn một chút. Bạn có thể sử dụng bộ đệm byte để nối các phần của dòng nếu chúng vượt quá giới hạn dòng. Dù sao, tôi khuyên bạn nên thử sử dụng trình đọc dòng trực tiếp trong dự án của bạn (đặc biệt nếu bạn không biết tệp văn bản lớn như thế nào!). Nhưng nếu tệp nhỏ, ví dụ sau có thể đủ cho bạn:

package main

import (
    "os"
    "bufio"
    "bytes"
    "fmt"
)

// Read a whole file into the memory and store it as array of lines
func readLines(path string) (lines []string, err os.Error) {
    var (
        file *os.File
        part []byte
        prefix bool
    )
    if file, err = os.Open(path); err != nil {
        return
    }
    reader := bufio.NewReader(file)
    buffer := bytes.NewBuffer(make([]byte, 1024))
    for {
        if part, prefix, err = reader.ReadLine(); err != nil {
            break
        }
        buffer.Write(part)
        if !prefix {
            lines = append(lines, buffer.String())
            buffer.Reset()
        }
    }
    if err == os.EOF {
        err = nil
    }
    return
}

func main() {
    lines, err := readLines("foo.txt")
    if err != nil {
        fmt.Println("Error: %s\n", err)
        return
    }
    for _, line := range lines {
        fmt.Println(line)
    }
}

Một giải pháp thay thế khác có thể là sử dụng io.ioutil.ReadAll để đọc toàn bộ tệp cùng một lúc và thực hiện cắt từng dòng sau đó. Tôi không cung cấp cho bạn một ví dụ rõ ràng về cách ghi các dòng trở lại tệp, nhưng về cơ bản os.Create()đó là một vòng lặp được theo sau bởi một vòng lặp tương tự như trong ví dụ (xem main()).

func readToDisplayUsingFile1(f *os.File){
    defer f.Close()
    reader := bufio.NewReader(f)
    contents, _ := ioutil.ReadAll(reader)
    lines := strings.Split(string(contents), '\n')
}

hoặc là

func readToDisplayUsingFile1(f *os.File){
    defer f.Close()
    slice := make([]string,0)

    reader := bufio.NewReader(f)

    for{

    str, err := reader.ReadString('\n')
    if err == io.EOF{
        break
    }

        slice = append(slice, str)
    }