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 
		*/ 
	} 
}