How to parse json without a defined stucture?

I want to parse this JSON :

{
        "error": null,
        "id": "tutu",
        "result": {
                "param1": 559,
                "param2": "yo",
                "param3": {"tab":["a", "b"], "param4":"hello"},
 
        }
}

The problem is that I want a flexible solution if the JSON structure changes: I want to be able to access each field with a key system (like in Javascript) without knowing in advance the JSON structure:

fmt.Println(jsonObj["result"]["param3"]["tab"][1])

Is it possible to do it ?

Yes, it is possible, although the fact that you need to assert the types makes it a bit unwieldy:

package main

import (
    "encoding/json"
    "fmt"
)

func main() {
    b := []byte(`
    {
        "error": null,
        "id": "tutu",
        "result": {
                "param1": 559,
                "param2": "yo",
                "param3": {"tab":["a", "b"], "param4": "hello"}
        }
    }
    `)

    var jsonObj interface{}

    err := json.Unmarshal(b, &jsonObj)

    if err != nil {
        panic(err)
    }

    msg := jsonObj.(map[string]interface{})
    result := msg["result"].(map[string]interface{})
    param3 := result["param3"].(map[string]interface{})
    tab := param3["tab"].([]interface{})

    fmt.Println(tab[1])
}

This prints

b

like you would expect.

Note that this program will panic: not just if the JSON fails to parse, but also if the JSON does not exactly match the program's expectations: missing keys, different types and so on.

The Generic JSON with interface section of the JSON and Go article on The Go Blog has an example of checking the actual type of the thing at runtime; as was suggested in the comments, it's easy to forget.

First, in your case unmarshall directly into map[string]interface{} to save an assertion.

    var jsonObj map[string]interface{}
    err := json.Unmarshal(b, &jsonObj)

Second, remember to check the assertion

    result, ok := jsonObj["result"].(map[string]interface{})
    if !ok {
        panic("not json obj")
    }

    param3, ok := result["param3"].(map[string]interface{})
    if !ok {
        panic("not json obj")
    }

    tab, ok := param3["tab"].([]interface{})
    if !ok {
        panic("not json arr")
    }

Lastly, you can declare a new type and "hide" the assertions in its methods

type AnyObj map[string]interface{}

func (obj AnyObj) MustObject(name string) AnyObj {
    v, ok := obj[name].(map[string]interface{})
    if !ok {
        panic("not json obj")
    }
    return AnyObj(v)
}

func (obj AnyObj) MustArray(name string) []interface{} {
    v, ok := obj[name].([]interface{})
    if !ok {
        panic("not json arr")
    }
    return v
}

Then use like this:

func main() {
    var jsonObj AnyObj
    err := json.Unmarshal(b, &jsonObj)
    if (err != nil) {
        panic(err);
    }

    tab := jsonObj.MustObject("result").MustObject("param3").MustArray("tab")

    fmt.Println(tab[1])    
}

check it here https://play.golang.org/p/ucdMZ0VEKcr

this is mine used fastjson:

package main

import (
	"fmt"
	"github.com/valyala/fastjson"
)

type ParseValue struct {
	*fastjson.Value
}

func Parse(b []byte) (*ParseValue, error) {
	var p fastjson.Parser
	v, err := p.ParseBytes(b)
	if err != nil {
		return nil, err
	}
	return &ParseValue{v}, nil
}

func (p *ParseValue) GetString(keys ...string) string {
	return string(p.GetStringBytes(keys...))
}

func main() {
	b := []byte(`
    {
        "error": null,
        "id": "tutu",
        "result": {
                "param1": 559,
                "param2": "yo",
                "param3": {"tab":["a", "b"], "param4": "hello"}
        }
    }
    `)

	v, err := Parse(b)
	if err != nil {
		panic(err)
	}

	r := v.GetString("result", "param3", "tab", "1")
	fmt.Println(r)

	rr := v.GetUint("result", "param1")
	fmt.Println(rr)

	// output:
	// b
	// 559
}