Membaca file teks ke dalam larik string (dan menulis)

Kemampuan untuk membaca (dan menulis) file teks masuk dan keluar dari array string adalah persyaratan yang cukup umum. Ini juga sangat berguna ketika memulai dengan bahasa yang pada awalnya menghilangkan kebutuhan untuk mengakses database. Apa ada di Golang?
misalnya

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

dan

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

Saya lebih suka menggunakan yang sudah ada daripada duplikat.

Pada rilis Go1.1, ada bufio.Scanner API yang dapat dengan mudah membaca baris dari sebuah file. Pertimbangkan contoh berikut dari atas, yang ditulis ulang dengan Scanner:

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

Jika file tidak terlalu besar, ini bisa dilakukan dengan fungsi ioutil.ReadFiledan strings.Splitseperti ini:

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

Anda dapat membaca dokumentasi di ioutil dan paket string .

Tidak dapat memperbarui jawaban pertama.
Bagaimanapun, setelah Go1 rilis, ada beberapa perubahan yang melanggar, jadi saya perbarui seperti yang ditunjukkan di bawah ini:

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

Anda dapat menggunakan os.File (yang mengimplementasikan antarmuka io.Reader ) dengan paket bufio untuk itu. Namun, paket-paket tersebut dibangun dengan mempertimbangkan penggunaan memori tetap (tidak peduli seberapa besar file tersebut) dan cukup cepat.

Sayangnya hal ini membuat pembacaan seluruh file ke dalam memori menjadi sedikit lebih rumit. Anda dapat menggunakan bytes.Buffer untuk bergabung dengan bagian-bagian baris jika melebihi batas baris. Bagaimanapun, saya sarankan Anda untuk mencoba menggunakan pembaca baris secara langsung dalam proyek Anda (terutama jika tidak tahu seberapa besar file teksnya!). Tetapi jika filenya kecil, contoh berikut mungkin cukup untuk Anda:

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

Alternatif lain mungkin menggunakan io.ioutil.ReadAll untuk membaca file lengkap sekaligus dan melakukan pemotongan per baris sesudahnya. Saya tidak memberi Anda contoh eksplisit tentang cara menulis baris kembali ke file, tetapi pada dasarnya itu os.Create()diikuti oleh loop yang mirip dengan yang ada di contoh (lihat main()).

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

atau

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