मैं एक स्ट्रिंग चर में पूरी फाइल कैसे पढ़ सकता हूं

Question

मेरे पास बहुत सारी छोटी फाइलें हैं, मैं उन्हें लाइन से पढ़ना नहीं चाहता।

क्या गो में कोई फ़ंक्शन है जो एक स्ट्रिंग चर में पूरी फ़ाइल पढ़ेगा?

Answer 1

उपयोग करें ioutil.ReadFile:

func ReadFile(filename string) ([]byte, error)

ReadFile फ़ाइल नाम से फ़ाइल पढ़ता है और सामग्री देता है। एक सफल कॉल गलत == नहीं है, गलत नहीं है == EOF। क्योंकि ReadFile पूरी फ़ाइल को पढ़ता है, यह रिपोर्ट से प्राप्त त्रुटि के रूप में EOF को रीड से नहीं मानता है।

[]byteइसके बदले आपको मिलेगा string। यदि वास्तव में आवश्यक हो तो इसे परिवर्तित किया जा सकता है:

s := string(buf)

Comments

फिर अंतिम स्ट्रिंग परिणाम के निर्माण के लिए, आप एक बाइट स्लाइस में डेटा जमा करने के लिए एपेंड () का उपयोग कर सकते हैं जैसा कि आप प्रत्येक फ़ाइल को पढ़ते हैं, फिर संचित बाइट स्लाइस को अंतिम स्ट्रिंग परिणाम में परिवर्तित करें। वैकल्पिक रूप से आप बाइट्स पसंद कर सकते हैं।

— सोनिया

हमें बताएं कि इसे कैसे बदलना है ... सवाल बाइट सरणी के लिए नहीं पूछता है।

— काइल ब्रिडेनस्टाइन

HTML फ़ाइल खोलने के लिए इसका उपयोग करना और मुझे लगता है कि हर लाइन के बाद एक नई लाइन जोड़ी जाती है जो हमें मेरे कुछ स्वरूपण में गड़बड़ कर रही है। क्या इससे बचने का कोई उपाय है?

— जोनाथन

Answer 2

यदि आप केवल सामग्री चाहते हैं string, तो पैकेज ReadFileसे फ़ंक्शन का उपयोग करना सरल उपाय है io/ioutil। यह फ़ंक्शन एक टुकड़ा देता है, bytesजिसे आप आसानी से एक में बदल सकते हैं string।

package main

import (
    "fmt"
    "io/ioutil"
)

func main() {
    b, err := ioutil.ReadFile("file.txt") // just pass the file name
    if err != nil {
        fmt.Print(err)
    }

    fmt.Println(b) // print the content as 'bytes'

    str := string(b) // convert content to a 'string'

    fmt.Println(str) // print the content as a 'string'
}

Answer 3

मुझे लगता है कि सबसे अच्छी बात है, अगर आप वास्तव में इन सभी फ़ाइलों को संक्षिप्त करने की दक्षता के बारे में चिंतित हैं, तो उन सभी को एक ही बाइट्स बफर में कॉपी करना है।

buf := bytes.NewBuffer(nil)
for _, filename := range filenames {
  f, _ := os.Open(filename) // Error handling elided for brevity.
  io.Copy(buf, f)           // Error handling elided for brevity.
  f.Close()
}
s := string(buf.Bytes())

यह प्रत्येक फ़ाइल को खोलता है, इसकी सामग्री को buf में कॉपी करता है, फिर फ़ाइल को बंद कर देता है। आपकी स्थिति के आधार पर आपको वास्तव में इसे बदलने की आवश्यकता नहीं हो सकती है, अंतिम पंक्ति यह दिखाने के लिए है कि buf.Bytes () में आपके द्वारा खोजा जा रहा डेटा है।

Comments

नमस्ते, io.Copy buf की सामग्री को अधिलेखित करेगा? और बफ़ की क्षमता क्या है? धन्यवाद।

— वुहोहा

कॉपी को अधिलेखित नहीं किया जाएगा, यह सिर्फ buf में जोड़कर रखेगा, और buf उतना ही बढ़ेगा जितना इसे नए डेटा को समायोजित करने की आवश्यकता है।

— वाइल्ड

बफ़ में "अनंत" क्षमता है। अधिक डेटा जोड़े जाने के बाद इसका विस्तार जारी रहेगा। ioutil.eadfile एक बफ़र आवंटित करेगा जो पूरी फ़ाइल को फिट करने के लिए पर्याप्त बड़ा है और इसे पुनः लोड करने की आवश्यकता नहीं है।

— स्टीफन वेनबर्ग

क्या एक बाइटबफ़र का उपयोग करने से वास्तव में प्रदर्शन को बेहतर बनाने की तुलना में यह केवल स्लाइस (/ सरणी) के साथ जुड़ जाता है? स्मृति के बारे में क्या? कितना बड़ा अंतर है?

— Kissaki

Answer 4

मैंने इस तरह से इसे किया:

package main

import (
  "fmt"
  "os"
  "bytes"
  "log"
)

func main() {
   filerc, err := os.Open("filename")
   if err != nil{
     log.Fatal(err)
   }
   defer filerc.Close()

   buf := new(bytes.Buffer)
   buf.ReadFrom(filerc)
   contents := buf.String()

   fmt.Print(contents) 

}    

Answer 5

मैं कंप्यूटर के साथ नहीं हूं, इसलिए मैं एक मसौदा लिखता हूं। आप स्पष्ट हो सकते हैं कि मैं क्या कहता हूं।

func main(){
    const dir = "/etc/"
    filesInfo, e := ioutil.ReadDir(dir)
    var fileNames = make([]string, 0, 10)
    for i,v:=range filesInfo{
        if !v.IsDir() {
            fileNames = append(fileNames, v.Name())
        }
    }

    var fileNumber = len(fileNames)
    var contents = make([]string, fileNumber, 10)
    wg := sync.WaitGroup{}
    wg.Add(fileNumber)

    for i,_:=range content {
        go func(i int){
            defer wg.Done()
            buf,e := ioutil.Readfile(fmt.Printf("%s/%s", dir, fileName[i]))
            defer file.Close()  
            content[i] = string(buf)
        }(i)   
    }
    wg.Wait()
}