स्ट्रिंग सरणी में टेक्स्ट फ़ाइल पढ़ें (और लिखें)

Question

एक स्ट्रिंग सरणी में और बाहर एक टेक्स्ट फ़ाइल को पढ़ने (और लिखने) की क्षमता मुझे एक सामान्य आम आवश्यकता है। डेटाबेस को एक्सेस करने के लिए प्रारंभ में आवश्यकता को हटाने वाली भाषा से शुरू होने पर यह भी काफी उपयोगी होता है। क्या गोलांग में कोई अस्तित्व में है?
उदा। func ReadLines(sFileName string, iMinLines int) ([]string, bool) {
और func WriteLines(saBuff[]string, sFilename string) (bool) {।
मैं डुप्लिकेट के बजाय मौजूदा एक का उपयोग करना पसंद करूंगा।

Answer 1

Go1.1 रिलीज के रूप में, bufio.Scanner API है जो आसानी से फ़ाइल से लाइनें पढ़ सकता है। ऊपर से निम्न उदाहरण, स्कैनर के साथ फिर से लिखा पर विचार करें:

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

Answer 2

आप os.File (जो io.Reader इंटरफ़ेस लागू करता है) का उपयोग bufio पैकेज के साथ कर सकते हैं। हालांकि, उन संकुलों को दिमाग में निश्चित स्मृति उपयोग के साथ बनाया गया है (भले ही फ़ाइल कितनी बड़ी हो) और काफी तेज़ हैं।

दुर्भाग्य से यह पूरी फ़ाइल को स्मृति में थोड़ा और जटिल बनाता है। लाइन लाइन के हिस्सों में शामिल होने के लिए आप लाइन के हिस्सों में शामिल होने के लिए 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() देखें)।

Answer 3

पहला उत्तर अपडेट नहीं किया जा सकता है।

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

Answer 4

तो फ़ाइल बहुत बड़ी नहीं है, यह ioutil.ReadFile और strings.Split कार्यों ताकि तरह से किया जा सकता:
वैसे भी, Go1 रिलीज होने के बाद, वहाँ कुछ टूटने परिवर्तन के रूप में नीचे दिखाया गया है, इसलिए मैं अद्यतन:

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

आप ioutil और strings पैकेज पर दस्तावेज़ पढ़ सकते हैं।

Answer 5

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