Mit Golang CSV lesen, Spalten neu anordnen und Ergebnis in eine neue CSV mit Concurrency schreiben

Question

Hier ist mein Ausgangspunkt.

Es ist ein Golang-Skript, in einem CSV mit 3 Spalten zu lesen, die Spalten neu anordnen und das Ergebnis in eine neue CSV-Datei schreiben.

package main 

import (
    "fmt" 
    "encoding/csv" 
    "io" 
    "os" 
    "math/rand" 
    "time" 
) 

func main(){ 
    start_time := time.Now() 

    // Loading csv file 
    rFile, err := os.Open("data/small.csv") //3 columns 
    if err != nil { 
    fmt.Println("Error:", err) 
    return 
    } 
    defer rFile.Close() 

    // Creating csv reader 
    reader := csv.NewReader(rFile) 

    lines, err := reader.ReadAll() 
    if err == io.EOF { 
     fmt.Println("Error:", err) 
     return 
    } 

    // Creating csv writer 
    wFile, err := os.Create("data/result.csv") 
    if err != nil { 
     fmt.Println("Error:",err) 
     return 
    } 
    defer wFile.Close() 
    writer := csv.NewWriter(wFile) 

    // Read data, randomize columns and write new lines to results.csv 
    rand.Seed(int64(time.Now().Nanosecond())) 
    var col_index []int 
    for i,line :=range lines{ 
     if i == 0 { 
     //randomize column index based on the number of columns recorded in the 1st line 
     col_index = rand.Perm(len(line)) 
    } 
    writer.Write([]string{line[col_index[0]], line[col_index[1]], line[col_index[2]]}) //3 columns 
    writer.Flush() 
} 

//print report 
fmt.Println("No. of lines: ",len(lines)) 
fmt.Println("Time taken: ", time.Since(start_time)) 

} 

Frage:

1. Ist mein Code idiomatische für Golang?

2. Wie kann ich diesem Code Parallelität hinzufügen?

Answer 1

Ihr Code ist OK. Es gibt keinen Grund für Nebenläufigkeit. Aber Sie können zumindest die Speicherbedarfsänderung im laufenden Betrieb reduzieren. Verwenden Sie einfach Read() anstelle von ReadAll(), um die Zuweisung von Slice für die Loch-Eingabedatei zu vermeiden.

for line, err := reader.Read(); err == nil; line, err = reader.Read(){ 
    if err = writer.Write([]string{line[col_index[0]], line[col_index[1]], line[col_index[2]]}); err != nil { 
      fmt.Println("Error:", err) 
      break 
    } 
    writer.Flush() 
} 

Answer 2

Bewegen Sie den col_index Initialisierung außerhalb des Schreibschleife:

if len(lines) > 0 { 
    //randomize column index based on the number of columns recorded in the 1st line 
    col_index := rand.Perm(len(lines[0])) 
    newLine := make([]string, len(col_index)) 

    for _, line :=range lines[1:] { 
     for from, to := range col_index { 
      newLine[to] = line[from] 
     } 
     writer.Write(newLine) 
     writer.Flush() 
    } 
} 

Parallelität zu verwenden, müssen Sie nicht reader.ReadAll verwenden. Erstellen Sie stattdessen eine Goroutine, die reader.Read aufruft, und schreiben Sie die Ausgabe auf einen Kanal, der das Array lines ersetzen würde. Die Hauptgoroutine würde den Kanal lesen und den Shuffle und den Schreibvorgang ausführen.