गो में कुशल सीएसवी पढ़ना और लिखना

प्रदान किए गए गो कोड में, सीएसवी पढ़ने और लिखने की प्रक्रिया महत्वपूर्ण प्रदर्शन समस्याओं का कारण बन रही है। इसे संबोधित करने के लिए, आइए एक वैकल्पिक दृष्टिकोण का पता लगाएं जो इन परिचालनों को सुव्यवस्थित करता है। एक समय में एक पंक्ति को संसाधित करने के लिए सीएसवी.रीडर की क्षमता का लाभ उठा सकते हैं। यह मेमोरी उपयोग को काफी कम कर देता है और प्रदर्शन में सुधार करता है। निम्नलिखित कोड स्निपेट इस दृष्टिकोण को प्रदर्शित करता है:

func प्रोसेसCSV(rc io.Reader) (ch chan []string) { सीएच = बनाओ (चान []स्ट्रिंग, 10) जाओ func() { आर := सीएसवी.न्यूरीडर(आरसी) यदि _, त्रुटि := r.Read(); त्रुटि != शून्य {//हेडर पढ़ें लॉग.घातक(त्रुटि) } स्थगित करें बंद करें(ch) के लिए { rec, err := r.Read() यदि त्रुटि !=शून्य { अगर गलती == io.EOF { तोड़ना } लॉग.घातक(त्रुटि) } ch

func processCSV(rc io.Reader) (ch chan []string) {
    ch = make(chan []string, 10)
    go func() {
        r := csv.NewReader(rc)
        if _, err := r.Read(); err != nil { //read header
            log.Fatal(err)
        }
        defer close(ch)
        for {
            rec, err := r.Read()
            if err != nil {
                if err == io.EOF {
                    break
                }
                log.Fatal(err)

            }
            ch 
इसी तरह, सीएसवी लिखने के लिए, हम सुधार के लिए एक समय में एक पंक्ति लिखने की सीएसवी.राइटर की विधि का उपयोग कर सकते हैं प्रदर्शन। कुशल सीएसवी लेखन के लिए कोड काफी हद तक सीएसवी रीडिंग के समान है:
func writeCSV(wc *csv.Writer, data [][]string) {
    जाओ func() {
        डब्ल्यूसी स्थगित करें। फ्लश (शून्य)
        _, rec := रेंज डेटा के लिए {
            यदि त्रुटि := wc.Write(rec); त्रुटि != शून्य {
                लॉग.घातक(त्रुटि)
            }
        }
    }()
}
यह फ़ंक्शन इनपुट के रूप में एक सीएसवी.राइटर और स्ट्रिंग्स के स्लाइस का एक टुकड़ा (सीएसवी डेटा का प्रतिनिधित्व करता है) लेता है और डेटा को एसिंक्रोनस रूप से सीएसवी फ़ाइल में लिखता है।
func writeCSV(wc *csv.Writer, data [][]string) {
    go func() {
        defer wc.Flush(nil)
        for _, rec := range data {
            if err := wc.Write(rec); err != nil {
                log.Fatal(err)
            }
        }
    }()
}
अनुकूलित सीएसवी पढ़ने और लिखने के कार्यों के साथ, प्रोग्राम के मुख्य तर्क को उपयोग करने के लिए फिर से लिखा जा सकता है बेहतर प्रदर्शन के लिए ये कार्य:
func main() {
    रिकॉर्ड्सCh := प्रोसेसCSV(os.Open(''/path/to/datafile.csv'')
    आउटफ़ाइल, err := os.Create(''/where/to/write/resultsfile.csv'')
    यदि त्रुटि !=शून्य {
        लॉग.घातक ("आउटपुट खोलने में असमर्थ")
    }
    आउटफ़ाइल को स्थगित करें। बंद करें()
    लेखक := सीएसवी.न्यूवाइटर(आउटफाइल)
    लेखक.लिखें([]स्ट्रिंग{"समय", "मूल्य", "स्कोर"})
    रिकॉर्ड के लिए := रेंज रिकॉर्ड्सCh {
        समय := रिकार्ड[0]
        मूल्य := रिकॉर्ड[1]
        
        // स्कोर की गणना करें; इस बाहरी विधि को बदला नहीं जा सकता
        स्कोर := गणना सामग्री (मूल्य)
        
        वैल्यूस्ट्रिंग := strconv.FormatFloat(floatValue, 'f', 8, 64)
        स्कोरस्ट्रिंग := strconv.FormatFloat(prob, 'f', 8, 64)
        लेखक.लिखें([]स्ट्रिंग{समय, वैल्यूस्ट्रिंग, स्कोरस्ट्रिंग})
    }
    लेखक.फ्लश()
}
यह संशोधित कोड सीएसवी फ़ाइल को कुशलता से पढ़ता है और पढ़ने और लिखने दोनों के लिए उच्च प्रदर्शन बनाए रखते हुए तुरंत स्कोर की गणना करता है।