在golang中的变量中解析Json

how do I parse this json

[
  [
    [
      "Odio los lunes",
      "i hate mondays",
      null,
      null,
      1
    ]
  ],
  null,
  "en"
]

to show just Odio los lunes?

Implement unmarshalar to fetch the value required from nested array and parse it into and struct using unmarshal like:

package main

import (
    "fmt"
    "encoding/json"
)

func(item *Result) UnmarshalJSON(data []byte)error{
    var v []interface{}
    if err:= json.Unmarshal(data, &v);err!=nil{
        fmt.Println(err)
        return err
    }
    item.Data = v[0].(interface{}).([]interface{})[0].([]interface{})[0].(string)
    return nil
}

type Result struct {
    Data string
}

func main() {
    var result Result
    jsonString := []byte(`[[["Odio los lunes", "i hate mondays", null, null, 1]], null, "en"]`)
    if err := json.Unmarshal(jsonString, &result); err != nil{
        fmt.Println(err)
    }
    //fmt.Printf("%+v
",result)
    value := result.Data
    fmt.Println(value)
}

Playground example

A simple approach would be to parse the JSON document as an interface{} ("any type") and grab the target string value by asserting the parsed structure. For example (on the go playground):

func main() {
  str := GetTargetString([]byte(jsonstr))
  fmt.Println(str) // => "Odio los lunes"
}

func GetTargetString(bs []byte) string {
  var doc interface{}
  if err := json.Unmarshal(bs, &doc); err != nil {
    panic(err)
  }
  return doc.([]interface{})[0].([]interface{})[0].([]interface{})[0].(string)
}

The "GetTargetString" function will panic if the given byte slice does not contain a valid JSON document or if the structure of the document isn't adequately similar (that is, an array whose first element is an array, whose first element is an array, whose first element is a string).

A more idiomatic (and generally safer) approach would be to inspect the types using the special two-return-value form of the type assertion and return a tuple of (string, error), e.g.:

if err := json.Unmarshal(jsonString, &result); err != nil {
  return "", err
}

array0, ok := doc.([]interface{})
if !ok {
  return "", fmt.Errorf("JSON document is not an array")
}

array1, ok := array0[0].([]interface{})
if !ok {
  return "", fmt.Errorf("first element is not an array")
}

// ...

It is much simpler (and faster) with fastjson:

var p fastjson.Parser
v, err := p.Parse(input)
if err != nil {
    log.Fatal(err)
}
fmt.Printf("v[0][0][0]: %s", v.GetStringBytes("0", "0", "0"))