Veintiuno, JSON

1. Introducción

Para el almacenamiento persistente de datos en la memoria o el conmutador de red es a menudo cadena de formato JSON empleado, vaya idiomas JSON
serialización y deserialización paquete JSON
para ir proporciona tipos básicos y se puede utilizar directamente en línea con la serialización paquete de tipo JSON y de operación de serialización
de la estructura se puede obtener mediante la conversión de la relación entre las etiquetas y atributos declarados cadena JSON, llamado el JSON etiqueta, formato común
es:
⚫ JSON:
forma predeterminada, se puede omitir, utilizando las teclas de JSON nombres de atributos, tipos de atributos por el correspondiente escriba
⚫ JSON: "clave"
nombres clave JSON con la tecla del nombre especificado
JSON ⚫: "-"
esta propiedad se ignora
⚫ JSON: "clave, del tipo"
nombre de clave JSON con la tecla del nombre especificado, escriba el tipo especificado del tipo
⚫ JSON: clave", omitempty "
JSON clave nombre de clave nombre especificado, se omite el valor de este atributo cuando un valor cero
⚫ JSON:" clave, tipo, omitempty "
JSON nombre de clave clave nombre especificado, el tipo del tipo tipo especificado, un valor cero cuando se omite el valor de los mismos esta propiedad
⚫ JSON: "escriba"
tipo tipo tipo especificado
⚫ JSON: "omitempty"
omitiendo el valor del atributo a un valor cero

2. Funciones comunes

Mariscal: datos de secuencia para ir idioma en cadena JSON
sangría: La cadena de formato JSON
unmarshal: una cadena de datos JSON deserializado lenguaje ir
MarshalIndent: idioma ir para la serialización de datos como cadena de formato JSON
válido: verificar que la cadena JSON correcta

3.Encoder 与 Decoder

Codificador y el decodificador se construyen JSON serialización y deserialización en corriente constructor respectivamente
NewEncoder newDecoder y, respectivamente, para lograr los parámetros de interfaces necesarias y io.Reader io.Writer objeto
Encoder.Encode serialización
deserialización Decoder.Decode de

Ejemplo 4

(1) convertir una cadena

package main

import (
   "encoding/json"
   "fmt"
)

func main() {
   //json.Marshal()     序列化 内存=>字符串/字节切片
   //json.Unmarshal()   反序列化 字符串/字节切片  =>内存
   //转换json格式
   selice := []string{"aa","aaaa","aaaaaa"}
   bytes ,err :=  json.Marshal(selice)
   fmt.Printf("%v %v \n",string(bytes),err)
   //json转换 字符串切片
   var name []string
   err = json.Unmarshal(bytes,&name)
   fmt.Println(name)
   //字符串切片 转换json的时候格式化
   bytes ,err = json.MarshalIndent(name,"","\t")
   if err == nil {
      fmt.Println(string(bytes))
   }
   //验证是否可以转换为json
   fmt.Println(json.Valid([]byte("[aa aaaa aaaaaa]")))
}

(2) Estructura de la conversión

package main

import (
   "encoding/json"
   "fmt"
)
type Addr struct {
   No int `json:"no"`
   Street string `json:"street"`
}
//结构体要进行序列化或者反序列化 内部元素属性必须是公开的也就是大写
type User struct {
   ID int`json:"-"`  //这个表示忽略
   Name string
   Age int`json:"age,int,omitempty"`   //第一个表示属性名  第二个表示类型  第三个表示 如果是零值就忽略
   desc string
   Addr Addr `json:"addr"`
}

func main() {
   user :=User{
      ID:   1,
      Name: "b",
      Age:  0,
      desc: "c",
      Addr: Addr{
         No: 1,
         Street: "aa",
      },
   }
   bytes ,_ := json.MarshalIndent(user,"","\t")
   fmt.Println(string(bytes))
   var users User
   json.Unmarshal(bytes,&users)
   fmt.Println(users)
}

(3) La conversión de tipo personalizado

package main

import (
   "encoding/json"
   "fmt"
)

//自定义类型json转换

const (
   Large = iota //large
   Medium     //medium
   Small        //small
)

type Size int

func (s Size)  MarshalText() ([]byte,error){
   switch s {
   case Large:
      return []byte("large"),nil
   case Medium:
      return []byte("medium"),nil
   case Small:
      return []byte("small"),nil
   default:
      return []byte("unknow"),nil
   }
}

func (s *Size) UnmarshalText(byte []byte) error{
   switch string(byte) {
   case "large":
      *s = Large
   case "medium":
      *s = Medium
   case "small":
      *s = Small
   default:
      *s = Small
   }
   return nil
}



func main() {
   var size Size = Medium
   bytes,_ := json.Marshal(size)
   fmt.Println(string(bytes))
   json.Unmarshal(bytes,&size)
   fmt.Println(size)


   sizes := []Size{Large,Large,Small,Medium}
   bytes,_ = json.Marshal(sizes)
   fmt.Println(string(bytes))
   var size02 []Size
   json.Unmarshal(bytes,&size02)
   fmt.Println(size02)
}