How to parse JSON when array dimension depends on some other field of the same JSON in Go?

The task is to store GeoJSON into Go data structure. Problem I am facing that there is an array named coordinate in the JSON whose dimension changes with an other field in the same JSON named type.

For example:

{
         "type": "Point",
         "coordinates": [100.0, 0.0]
}

{
         "type": "LineString",
         "coordinates": [
             [100.0, 0.0],
             [101.0, 1.0]
         ]
}

{
         "type": "MultiPolygon",
         "coordinates": [
             [
                 [
                     [102.0, 2.0],
                     [103.0, 2.0],
                     [103.0, 3.0],
                     [102.0, 3.0],
                     [102.0, 2.0]
                 ]
             ],
             [
                 [
                     [100.0, 0.0],
                     [101.0, 0.0],
                     [101.0, 1.0],
                     [100.0, 1.0],
                     [100.0, 0.0]
                 ],
                 [
                     [100.2, 0.2],
                     [100.2, 0.8],
                     [100.8, 0.8],
                     [100.8, 0.2],
                     [100.2, 0.2]
                 ]
             ]
         ]
     }

Now if I am making an array of 2D then 1D, 3D and 4D cases are missing.

My data structure is something like this:

type Geometry struct {
     Type string `json:"type"`
     Coordinates[][][][] float64 `json:"coordinates"`
}

...


var data Geometry
json.Unmarshal([] byte(geoJsonString), &data)

I am new to language Go and JSON. Please help me out.

It's probably best to use a pre-existing package. Eg: https://pkg.go.dev/github.com/paulmach/go.geojson#UnmarshalGeometry

There are 2 main approaches if you would like to handle varied JSON structures manually with encoding/json:

1. Decode the variable type field into a json.RawMessage and continue decoding into the specific type you need.

type geometry struct {
  Type string `json:"type"`
  Coords json.RawMessage `json:"coordinates"`
}

type lineStringCoords [][]float64

var data geometry
if err := json.Unmarshal(input, &data); err != nil {
  return err
}

switch data.Type {
case "LineString":
  var lineString lineStringCoords
  if err := json.Unmarshal(data.Coords, &lineString); err != nil {
    ...
  }  ​
...
}

2. Decode the variable type field into an interface{} and use type assertions to extract the data. This is more or less the approach used by github.com/paulmac/go.geojson. This allows you to decode/explore arbitrary JSON but is more complicated to implement.

type geometry struct {
 ​Type string `json:"type"`
 ​Coords interface{} `json:"coordinates"`
}

var data geometry
if err := json.Unmarshal(input, &data); err != nil {
 ​return err
}

switch data.Type {
case "LineString":
 ​slice, ok := data.Coords.([]interface{})
 ​// Continue manually extracting the slices and copy into the appropriate output struct.
...
}