How to map a TypeScript array of multiple values to Go struct

I'm trying to find the best way to map a TypeScript array of multiple values to a struct in Go. What do you recommend?

data: [number, number, number, string, string, boolean, [string, number]?][];

This is the data in JSON format:

{
  "data": [
    [
      35241,
      7753,
      7750,
      "0xbb2b8038a1640196fbe3e38816f3e67cba72d940",
      "spot",
      true
    ],
    [60259, 7746, null, "#7746/USD", "internal", true, ["requote", 145]]
  ]
}

For now, what I'm doing is unmarshaling it into a struct using interface{}

Data [][]interface{} `json:"data"`

But then I have to do a type assertion for every field

for _, asset := range assetsAndPairs.Data.Pairs.Data {
	fmt.Println(asset[0].(float64))
}

Wondering if there is a better way.

You could define your own struct with a custom unmarshal func like this:

package main

import (
	"encoding/json"
	"errors"
	"fmt"
)

var json_data = []byte(`{
  "data": [
    [
      35241,
      7753,
      7750,
      "0xbb2b8038a1640196fbe3e38816f3e67cba72d940",
      "spot",
      true
    ],
    [60259, 7746, null, "#7746/USD", "internal", true, ["requote", 145]]
  ]
}`)

func main() {
	var doc Document
	if err := json.Unmarshal(json_data, &doc); err != nil {
		panic(err)
	}
	for _, r := range doc.Data {
		fmt.Printf("%+v\n", r)
		if r.Optional != nil {
			fmt.Printf("  with optional: %+v\n", *r.Optional)
		}
	}
}

type Document struct {
	Data []Row `json:"data"`
}

type Row struct {
	SomeInt    int
	SomeString string
	// Simplified
	Optional *MoreData
}

type MoreData struct {
	SomeString string
	SomeInt    int
}

func (row *Row) UnmarshalJSON(data []byte) error {
	var elements []json.RawMessage
	if err := json.Unmarshal(data, &elements); err != nil {
		return err
	}
	if len(elements) < 6 {
		return errors.New("too few elements")
	}

	if err := json.Unmarshal(elements[0], &row.SomeInt); err != nil {
		return err
	}
	if err := json.Unmarshal(elements[3], &row.SomeString); err != nil {
		return err
	}

	if len(elements) == 7 {
		var more MoreData
		if err := json.Unmarshal(elements[6], &more); err != nil {
			return err
		}
		row.Optional = &more
	}

	return nil
}

func (more *MoreData) UnmarshalJSON(data []byte) error {
	var elements []json.RawMessage
	if err := json.Unmarshal(data, &elements); err != nil {
		return err
	}
	if len(elements) < 2 {
		return errors.New("too few elements")
	}

	if err := json.Unmarshal(elements[0], &more.SomeString); err != nil {
		return err
	}
	if err := json.Unmarshal(elements[1], &more.SomeInt); err != nil {
		return err
	}

	return nil
}

https://go.dev/play/p/zLgENBZ0fkC

Based in your example data I'm assuming the numbers are integers. If the JSON can contain floating point numbers (which would be valid number), you would have to adjust the type of course...

I think you could use reflect to define a struct with each field related to an index of data's type and define the UnmarshalJSON function similarly to what @some-user did.

package main

import (
	"encoding/json"
	"fmt"
	"reflect"
	"strconv"
	"strings"
)

var json_data = []byte(`{
	"data": [
	  [
		35241,
		7753,
		7750,
		"0xbb2b8038a1640196fbe3e38816f3e67cba72d940",
		"spot",
		true
	  ],
	  [60259, 7746, null, "#7746/USD", "internal", true, ["requote", 145]]
	]
  }`)

func main() {
	var doc Document
	if err := json.Unmarshal(json_data, &doc); err != nil {
		panic(err)
	}
	for _, r := range doc.Data {
		fmt.Printf("%+v\n", r)
		if r.G != nil {
			fmt.Printf("  with optional: %+v\n", r.G)
		}
	}
}

type Document struct {
	Data []*Row `json:"data"`
}

type Row struct {
	A int           `idx:"0"`
	B int           `idx:"1"`
	C int           `idx:"2"`
	D string        `idx:"3"`
	E string        `idx:"4"`
	F string        `idx:"5"`
	G *OptionalItem `idx:"6,optional"`
}

func (r *Row) UnmarshalJSON(data []byte) error {
	typ := reflect.TypeOf(r)
	val := reflect.ValueOf(r)

	return unmarshalArray(typ, val, data)
}

type OptionalItem struct {
	A string `idx:"0"`
	B string `idx:"1"`
}

func (oi *OptionalItem) UnmarshalJSON(data []byte) error {
	typ := reflect.TypeOf(oi)
	val := reflect.ValueOf(oi)

	return unmarshalArray(typ, val, data)
}

func unmarshalArray(typ reflect.Type, val reflect.Value, data []byte) error {
	var items []json.RawMessage
	if err := json.Unmarshal(data, &items); err != nil {
		return err
	}

	for i := 0; i < typ.Elem().NumField(); i++ {
		field := typ.Elem().Field(i)

		if value, ok := field.Tag.Lookup("idx"); ok {
			idx, optional, err := splitTag(value)
			if err != nil {
				return err
			}

			if !optional || (optional && len(items) > idx) {
				if string(items[idx]) == "null" {
					continue
				}

				valueField := val.Elem().FieldByName(field.Name)
				if _, ok := valueField.Interface().(json.Unmarshaler); ok {
					if err := json.Unmarshal(items[idx], valueField.Addr().Interface()); err != nil {
						return err
					}
				} else {
					if valueField.Kind() == reflect.String {
						valueField.SetString(string(items[idx]))
					} else if valueField.Kind() == reflect.Int {
						number, err := strconv.Atoi(string(items[idx]))
						if err != nil {
							return err
						}
						valueField.SetInt(int64(number))
					} else {
						valueField.Set(reflect.ValueOf(items[idx]))
					}
				}
			}
		}
	}

	return nil
}

func splitTag(tag string) (idx int, optional bool, err error) {
	ops := strings.Split(tag, ",")
	if len(ops) < 1 {
		err = fmt.Errorf("empty 'idx' tag")
		return
	} else if len(ops) > 1 {
		optional = ops[1] == "optional"
	}

	idx, err = strconv.Atoi(ops[0])
	if err != nil {
		return
	}

	return
}

https://go.dev/play/p/x8hC_8JfjGG

There are still some checks missing but it does illustrates the idea.