문자열 배열로 텍스트 파일 읽기 (및 쓰기)

문자열 배열 안팎으로 텍스트 파일을 읽고 쓰는 기능은 상당히 일반적인 요구 사항이라고 생각합니다. 또한 처음에 데이터베이스에 액세스 할 필요가없는 언어로 시작할 때 매우 유용합니다. Golang에 존재합니까?
예 :

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

과

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

중복보다는 기존의 것을 사용하고 싶습니다.

Go1.1 릴리스 부터 파일에서 줄을 쉽게 읽을 수 있는 bufio.Scanner API가 있습니다. 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)
    }
}

파일이 너무 크지 않으면 다음 ioutil.ReadFile과 strings.Split같은 및 함수를 사용하여 수행 할 수 있습니다 .

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

ioutil 및 strings 패키지 에 대한 설명서를 읽을 수 있습니다 .

첫 번째 답변을 업데이트 할 수 없습니다.
어쨌든 Go1 출시 후 몇 가지 주요 변경 사항이 있으므로 아래와 같이 업데이트했습니다.

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

이를 위해 bufio 패키지 와 함께 os.File ( io.Reader 인터페이스 를 구현 함)을 사용할 수 있습니다 . 그러나 이러한 패키지는 파일 크기에 관계없이 고정 메모리 사용량을 염두에두고 빌드되며 매우 빠릅니다.

불행히도 이것은 전체 파일을 메모리로 읽는 것을 조금 더 복잡하게 만듭니다. 줄 제한을 초과하는 경우 bytes.Buffer 를 사용 하여 줄의 일부를 연결할 수 있습니다 . 어쨌든 프로젝트에서 직접 라인 리더를 사용하는 것이 좋습니다 (특히 텍스트 파일의 크기를 모르는 경우!). 그러나 파일이 작 으면 다음 예제로 충분할 수 있습니다.

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

또 다른 대안은 io.ioutil.ReadAll 을 사용 하여 한 번에 전체 파일을 읽고 나중에 한 줄씩 자르는 것입니다. 파일에 줄을 다시 쓰는 방법에 대한 명시적인 예제를 제공하지는 않지만 기본적으로 os.Create()예제에있는 것과 유사한 루프 가 뒤 따릅니다 (참조 main()).

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

또는

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