I have a problem with retrieve basic user information. This is my code:

```
require_once 'facebook-php-sdk/autoload.php';
FacebookSession::setDefaultApplication('appid', 'appsecret');

try {
    $token = 'mytoken';
    $session = new FacebookSession($token);
    $request = (new FacebookRequest($session, 'GET', '/me'))->execute()->getGraphObject(GraphUser::className());
     $username = $request->getName();

    echo $username . '<br>';
} catch (FacebookRequestException $e) {
    echo'Error';
    echo $e;
}

```

but no exception is throws, and nothing is printed. What's wrong?
['https://Stackoverflow.com/questions/28806955', 'https://Stackoverflow.com', 'https://Stackoverflow.com/users/1246746/']
The notation `x.(T)` is called a [Type Assertion](http://golang.org/ref/spec#Type_assertions).

> 
> For an expression `x` of interface type and a type `T`, the primary expression `x.(T)` asserts that `x` is not `nil` and that the value stored in `x` is of type `T`.
> 
> 
> 

Your example:

```
result["args"].(map[string]interface{})["foo"]

```

It means that the value of your `results` map associated with key `"args"` is of type `map[string]interface{}` (another map with `string` keys and any values). And you want to access the element of that map associated with the key `"foo"`.

If you know noting about the input JSON format, then yes, you have to use a generic `map[string]interface{}` type to process it. If you know the exact structure of the input JSON, you can create a `struct` to match the expected fields, and doing so you can unmarshal a JSON text into a value of your custom `struct` type, for example:

```
type Point struct {
    Name string
    X, Y int
}

func main() {
    in := `{"Name":"center","X":2,"Y":3}`

    pt := Point{}
    json.Unmarshal([]byte(in), &pt)

    fmt.Printf("Result: %+v", pt)
}

```

Output:

```
Result: {Name:center X:2 Y:3}

```

Try it on the [Go Playground](http://play.golang.org/p/9P3kdq6Cg0).

Modeling your input
-------------------

Your current JSON input could be modelled with this type:

```
type Data struct {
    Args struct {
        Foo string
    }
}

```

And accessing `Foo` (try it on the [Go Playground)](http://play.golang.org/p/80dWvpwUsH):

```
d := Data{}
json.Unmarshal([]byte(in), &d)
fmt.Println("Foo:", d.Args.Foo)

```
`struct` is the best option, but if you insist, you can add a type declaration for a map, then you can add methods to help
with the type assertions:

```
package main
import "encoding/json"

type dict map[string]interface{}

func (d dict) d(k string) dict {
   return d[k].(map[string]interface{})
}

func (d dict) s(k string) string {
   return d[k].(string)
}

func main() {
   apiResponse := []byte(`{"args": {"foo": "bar"}}`)
   var result dict
   json.Unmarshal(apiResponse, &result)
   foo := result.d("args").s("foo")
   println(foo == "bar")
}

```

<https://golang.org/ref/spec#Type_declarations>