Golang - Can't get array of objects after fetching JSON

After I make a request to a server - I get JSON like this:

{
  "actions": [
    {
      "class": "...",
      "parameters": [
        { ... }
        { ... }
       ]
    }
  ]
  ...
}

The type of the variable I've put this data in, is map[string]interface{}.

I want to access the parameters array in the first object of the actions array. I can successfully get the class property - data.(map[string]interface{})["class"].

However, if I try the same for the parameters property - I get nil ...

I tried data.(map[string][]interface{})["parameters"] - but I get error panic: interface conversion: interface {} is map[string]interface {}, not map[string][]interface {}.

Any idea what I'm missing here?

EDIT:

The Golang code for this is this:

func main() {

    var jsonResult map[string]interface{}

    errorFromJsonFetching := utils.GetJSON(theUrl, &jsonResult)
    if errorFromJsonFetching != nil {
      fmt.Printf("Error from checking deploy build: %#v\n", errorFromJsonFetching)
    }

    // get the top level "actions" prop ..
    actionZero := jsonResult["actions"].([]interface{})[0]

    fmt.Printf("Class prop: /%v %T\n", actionZero.(map[string]interface{})["class"], actionZero)
    fmt.Printf("Parameters prop: /%v %T\n", actionZero.(map[string]interface{})["parameters"], actionZero)

}

The GetJSON function is from another file in the project:

func GetJSON (url string, result interface{}) error {

  fmt.Printf("Getting JSON from %v\n", url)

  resp, err := http.Get(url)

  if err != nil {
    return fmt.Errorf("Cannot fetch URL %q: %v\n", url, err)
  }

  defer resp.Body.Close()

  if resp.StatusCode != http.StatusOK {
    return fmt.Errorf("Bad resposne status code: %s\n", resp.Status)
  }

  // attempt to put the JSON in the `result` ..
  err = json.NewDecoder(resp.Body).Decode(&result)

  if err != nil {
    return fmt.Errorf("Could not decode the JSON from response, err: %v\n", err)
  }

  return nil;
}

EDIT2:

Thanks to the ideas of @larsks in the comments - I created a minimal code sample with JSON in a string, directly in main.go file - and all worked fine.

Then I went ahead to the browser again and tried to fetch the data again - from directly hitting the URL or with $.getJSON from a page - and both returned one and the same JSON data.

However, in my Go code, when I dump the JSON data - I see this for the first member of actions:

map[_class:hudson.model.ParametersDefinitionProperty parameterDefinitions:[map[...

So when I try to get the parameters array by the key parameterDefinitions - then I get the array of object ... :O

Sooooo ... I don't know what's happening ... either Go itself modifies the JSON data when it gets it from the backend, or the backend itself returns different things, depending on how the data is being fetched.

(The backend is the Jenkins API by the way ... so I don't know why I get parameterDefinitions instead of parameters in Go ... ...)

Thanks for updating your question; having the correct data makes it easier to answer.

It's best if the code you include in your question is something we can just grab and run -- that means it compiles and runs, and when given the sample data in your question, it produces the behavior you're asking about.

I've modified your code so that I can run it locally, primarily by replacing the GetJSON method with something that reads from a file named data.json instead of hitting an API:

package main

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

func GetJSON(result interface{}) error {
  datafile, err := os.Open("data.json")
  if err != nil {
    panic(err)
  }

  return json.NewDecoder(datafile).Decode(&result)
}

func main() {
  var jsonResult map[string]interface{}

  errorFromJsonFetching := GetJSON(&jsonResult)
  if errorFromJsonFetching != nil {
    fmt.Printf("Error from checking deploy build: %#v\n", errorFromJsonFetching)
  }

  // get the top level "actions" prop ..
  actionZero := jsonResult["actions"].([]interface{})[0]

  fmt.Printf("Class prop: /%v %T\n", actionZero.(map[string]interface{})["class"], actionZero)
  fmt.Printf("Parameters prop: /%v %T\n", actionZero.(map[string]interface{})["parameters"], actionZero)
}

If I feed it this sample data, which I believe matches the structure of what you show in your question:

{
  "actions": [
    {
      "class": "Name of class",
      "parameters": [
        {
          "name": "alice",
          "color": "blue"
        },
        {
          "name": "bob",
          "count": 10,
        },
        {
          "name": "mallory",
          "valid": false,
        }
      ]
    }
  ]
}

It produces the following output:

Class prop: /Name of class map[string]interface {}
Parameters prop: /[map[color:blue name:alice] map[count:10 name:bob] map[name:mallory valid:false]] map[string]interface {}

This doesn't produce a nil value for the parameters key. In order to more fully answer your question, can you update it so that it has sample data and code that reproduces the behavior you're asking baout?