Comment rationaliser la lecture et l'écriture de CSV dans Go pour améliorer les performances ?

Lecture et écriture CSV efficaces dans Go

Dans le code Go fourni, le processus de lecture et d'écriture CSV entraîne des problèmes de performances importants. Pour résoudre ce problème, explorons une approche alternative qui rationalise ces opérations.

Lecture efficace des CSV

Au lieu de charger l'intégralité du fichier CSV en mémoire puis de le traiter, nous peut exploiter la capacité de csv.Reader à traiter une ligne à la fois. Cela réduit considérablement l'utilisation de la mémoire et améliore les performances. L'extrait de code suivant illustre cette approche :

<code class="go">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 <- rec
        }
    }()
    return
}</code>

Cette fonction prend un io.Reader en entrée et renvoie un canal qui génère des tranches de chaînes représentant les enregistrements CSV.

Écriture CSV efficacement

De même, pour écrire des CSV, nous pouvons utiliser la méthode csv.Writer consistant à écrire une ligne à la fois pour améliorer les performances. Le code pour une écriture CSV efficace est en grande partie similaire à la lecture CSV :

<code class="go">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)
            }
        }
    }()
}</code>

Cette fonction prend un csv.Writer et une tranche de tranches de chaînes (représentant les données CSV) comme entrées et écrit les données de manière asynchrone. au fichier CSV.

Intégration

Avec les fonctions optimisées de lecture et d'écriture CSV en place, la logique principale du programme peut être réécrite pour utiliser ces fonctions pour une amélioration performances :

<code class="go">func main() {
    recordsCh := processCSV(os.Open("./path/to/datafile.csv"))
    outfile, err := os.Create("./where/to/write/resultsfile.csv"))
    if err != nil {
        log.Fatal("Unable to open output")
    }
    defer outfile.Close()
    writer := csv.NewWriter(outfile)
    writer.Write([]string{"time", "value", "score"})
    for record := range recordsCh {
        time := record[0]
        value := record[1]
        
        // calculate scores; THIS EXTERNAL METHOD CANNOT BE CHANGED
        score := calculateStuff(value)
        
        valueString := strconv.FormatFloat(floatValue, 'f', 8, 64)
        scoreString := strconv.FormatFloat(prob, 'f', 8, 64)
        writer.Write([]string{time, valueString, scoreString})
    }
    writer.Flush()
}</code>

Ce code révisé lit efficacement le fichier CSV et calcule les scores à la volée, tout en conservant des performances élevées en lecture et en écriture.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!