Converting Struct to CSV string

I have a struct that gets Scanned in after a DB response like the below. Each field is the same len(). I'd like to take this struct and produce a CSV delimited string/

package main
import "fmt"
type Data struct {
id   []string
col1 []float64
col2 []float64
}
func main() {
d := &Data{
id:   []string{"id_1", "id_1", "id_1", "id_1"},
col1: []float64{340.384926, 321.385028, 520.341473, 500.385473},
col2: []float64{123.285031, 4087.284675, -8958.284216, -7612.283668},
}
fmt.Printf("%+v", d)
}

I'd like to loop through the struct which I believe is possible using reflect, then construct a CSV string like the following using the struct field names as the header and t he values as individual columns for that header, delimited by a comma.

`
id,col1,col2
id_1,340.384926,123.285031
id_1,321.385028,4087.284675
id_1,520.341473,-8958.284216
id_1,500.385473,-7612.283668
`

What is an efficient way to achieve this?

If possible, avoid using reflect to iterate through struct because it can result in decreased performance and reduced code readability. Don't fall for the XY problem - the ask here is to transform Data struct into csv string (Y problem), but the X problem here is avoid using struct type such as Data as starting point.

Many golang packages that manipulate csv prefer:

• [][]string: encoding/csv and struct2csv

• []Struct{}: gocsv and csv2struct

However, if Data type is unavoidable, you can first write a function that transforms Data into [][]string while avoiding using reflect:

func TransformDataTo2DSlice(d Data) [][]string {
numRows := len(d.id)
result := make([][]string, numRows+1)
// Add header row
result[0] = []string{"id", "col1", "col2"}
// Add data rows
for i := 0; i < numRows; i++ {
result[i+1] = []string{d.id[i],
strconv.FormatFloat(d.col1[i], 'f', -1, 64),
strconv.FormatFloat(d.col2[i], 'f', -1, 64),
}
}
return result
}

Next, use w.WriteAll() method from encoding/csv to easily transform [][]string to csv

func main() {
d := Data{
id:   []string{"id_1", "id_1", "id_1", "id_1"},
col1: []float64{340.384926, 321.385028, 520.341473, 500.385473},
col2: []float64{123.285031, 4087.284675, -8958.284216, -7612.283668},
}
d2dslice := TransformDataTo2DSlice(d)
// fmt.Printf("%+v", d2dslice)
// [[id, col1, col2],
// [id_1, 340.384926, 123.285031],
// [id_1, 321.385028, 4087.284675],
// [id_1, 520.341473, -8958.284216],
// [id_1,500.385473,-7612.283668]]
w := csv.NewWriter(os.Stdout)
w.WriteAll(d2dslice)
if err := w.Error(); err != nil {
log.Fatalln("error writing csv:", err)
}
// stdout:
// id,col1,col2
// id_1,340.384926,123.285031
// id_1,321.385028,4087.284675
// id_1,520.341473,-8958.284216
// id_1,500.385473,-7612.283668
}

Run the program above here: go-playground

To write csv to a string variable instead, pass in a buffer:

	buf := new(bytes.Buffer)
w := csv.NewWriter(buf)
w.WriteAll(d2dslice)
if err := w.Error(); err != nil {
log.Fatalln("error writing csv:", err)
}
csvString := buf.String()
fmt.Printf("%T\n", csvString)  // print the variable type
// string
fmt.Printf("%+v\n", csvString) // print the variable value
// id,col1,col2
// id_1,340.384926,123.285031
// id_1,321.385028,4087.284675
// id_1,520.341473,-8958.284216
// id_1,500.385473,-7612.283668

use golang package encoding/csv.

https://pkg.go.dev/encoding/csv.

• Step 1: Convert the data structure into a 2-dimensional array [][]string
• Step 2: Print the result of the 2-dimensional array.

package main

import (
	"fmt"
	"log"
	"reflect"
)

type Data struct {
	Id   []string  `json:"id"`
	Col1 []float64 `json:"col1"`
	Col2 []float64 `json:"col2"`
}

func (d *Data) String() string {
	dataType := reflect.TypeOf(*d)
	dataValue := reflect.ValueOf(*d)

	// Step 1: Convert the data structure into a 2-dimensional array.
	var result [][]string // [col][how many 'row' on each col]
	for col := 0; col < dataType.NumField(); col++ {
		filedType := dataType.Field(col)
		filedValue := dataValue.Field(col)

		if result == nil {
			colMax := dataType.NumField()
			result = make([][]string, colMax)
		}

		var rowMax int
		switch filedValue.Interface().(type) {
		case []string:
			rowMax = len(filedValue.Interface().([]string))
		case []float64:
			rowMax = len(filedValue.Interface().([]float64))
		default:
			log.Fatalf("not support type. %v", filedValue.Interface())
		}
		if result[col] == nil {
			result[col] = make([]string, rowMax+1) // 1 for header
		}

		// header
		result[col][0] = fmt.Sprintf("%v", filedType.Tag.Get("json"))

		// data
		var cell any
		for row := 1; row <= rowMax; row++ {
			switch filedValue.Interface().(type) {
			case []string:
				cell = filedValue.Interface().([]string)[row-1]
			case []float64:
				cell = filedValue.Interface().([]float64)[row-1]
			default:
				log.Fatalf("not support type. %v", filedValue.Interface())
			}
			result[col][row] = fmt.Sprintf("%v", cell)
		}
	}

	// Step 2: Print the result of the 2-dimensional array.
	str := ""
	const sep = ","
	for row := 0; row < len(result[0]); row++ {
		for col := 0; col < len(result); col++ {
			str += fmt.Sprintf("%v", result[col][row])
			if col < len(result)-1 {
				str += sep
			}
		}
		if row < len(result[0])-1 {
			str += "\n"
		}
	}
	return str
}

func main() {
	d := &Data{
		Id:   []string{"id_1", "id_1", "id_1", "id_1"},
		Col1: []float64{340.384926, 321.385028, 520.341473, 500.385473},
		Col2: []float64{123.285031, 4087.284675, -8958.284216, -7612.283668},
	}
	fmt.Println(d)
}

output:

id,col1,col2
id_1,340.384926,123.285031  
id_1,321.385028,4087.284675 
id_1,520.341473,-8958.284216
id_1,500.385473,-7612.283668

<kbd>go-playground</kbd>