Go-json解码到接口及根据键获取值

Go-json解码到接口及根据键获取值

package main

import (

	"encoding/json"

	"fmt"

	"github.com/bitly/go-simplejson"

)

type JsonServer struct {

	ServerName string

	ServerIP   string

}

type JsonServers struct {

	Servers []JsonServer

}

func main() {

	var s JsonServers

	str := `{"servers":[{"serverName":"Shanghai_VPN","serverIP":"127.0.0.1"},{"serverName":"Beijing_VPN","serverIP":"127.0.0.2"}]}`

	json.Unmarshal([]byte(str), &s)

	fmt.Println(s) //{[{Shanghai_VPN 127.0.0.1} {Beijing_VPN 127.0.0.2}]}

	b := []byte(`{"Name":"Wednesday","Age":6,"Parents":["Gomez","Morticia"]}`)

	var f interface{}

	json.Unmarshal(b, &f)

	fmt.Printf("%+v\n", f) // map[Name:Wednesday Age:6 Parents:[Gomez Morticia]]

	m := f.(map[string]interface{})

	for k, v := range m {

		switch vv := v.(type) {

		case string:

			fmt.Println(k, "is string", vv) //Name is string Wednesday

		case int:

			fmt.Println(k, "is int", vv)

		case float64:

			fmt.Println(k, "is float64", vv) //Age is float64 6

		case []interface{}:

			fmt.Println(k, "is an array:") //Parents is an array:

			//0 Gomez

			//1 Morticia

			for i, u := range vv {

				fmt.Println(i, u)

			}

		default:

			fmt.Println(k, "is of a type I don't know how to handle")

		}

	}

	/**

	如您所见，我们现在可以通过interface{}解析未知格式的JSON并键入断言。

	以上示例是官方解决方案，但类型断言并不总是方便。

	因此，我推荐一个名为simplejson的开源项目，由bitly创建和维护。

	以下是如何使用此项目处理未知格式的JSON的示例：

	go get ithub.com/bitly/go-simplejson

	*/

        // 根据键获取值

	js, err := simplejson.NewJson([]byte(`{

    "test": {

        "array": [1, "2", 3],

        "int": 10,

        "float": 5.150,

        "bignum": 9223372036854775807,

        "string": "simplejson",

        "bool": true

    }

}`))

	if err != nil {

		fmt.Println("err:", err)

	}

	arr, _ := js.Get("test").Get("array").Array() //arr: [1 2 3]

	fmt.Println("arr:", arr)

	i, _ := js.Get("test").Get("int").Int() //i: 10

	fmt.Println("i:", i)

	ms := js.Get("test").Get("string").MustString() //ms: simplejson

	fmt.Println("ms:", ms)

}

json解码到接口

package main

import (

	"encoding/json"

	"fmt"

)

func main() {

	jsonBuf := `

	{

		"company": "itcast",

		"subjects": [

			"Go",

			"C++",

			"Python",

			"Test"

		],

		"isok": true,

		"price": 666.666

	}

	`

	//创建一个map

	m := make(map[string]interface{}, 4)

	err := json.Unmarshal([]byte(jsonBuf), &m)

	if err != nil {

		fmt.Println("err=", err)

		return

	}

	fmt.Println("m=", m)     //m= map[company:itcast subjects:[Go C++ Python Test] isok:true price:666.666]

	fmt.Printf("m=%+v\n", m) //m=map[isok:true price:666.666 company:itcast subjects:[Go C++ Python Test]]

	var s string

	s = m["company"].(string)

	fmt.Println("s= ", s) //s=  itcast

	var s1 bool

	s1 = m["isok"].(bool)

	fmt.Println("s1= ", s1) //s1=  true

	var s2 float64

	s2 = m["price"].(float64)

	fmt.Println("s2= ", s2) //s2=  666.666

	var str string

	//类型断言

	for key, value := range m {

		// fmt.Printf("%v===>%v\n", key, value)

		switch data := value.(type) {

		case string:

			str = data

			fmt.Printf("map[%s]的值类型为string，内容为%s\n", key, str)

		case bool:

			fmt.Printf("map[%s]的值类型为bool，内容为%v\n", key, data)

		case float64:

			fmt.Printf("map[%s]的值类型为float64，内容为%v\n", key, data)

		case []string:

			fmt.Printf("map[%s]的值类型为[]stiring1，内容为%v\n", key, data)

		case []interface{}:

			fmt.Printf("map[%s]的值类型为[]stiring2，内容为%v\n", key, data)

		}

		/*

			map[company]的值类型为string，内容为itcast

			map[subjects]的值类型为[]stiring2，内容为[Go C++ Python Test]

			map[isok]的值类型为bool，内容为true

			map[price]的值类型为float64，内容为666.666

		*/

	}

}