+
+
+ |
+
+ Go ofrece soporte integrado para la codificación y
+ decodificación de JSON, incluyendo para tipos de datos
+ integrados y personalizados.
+
+ |
+
+
+
+ |
+
+
+
+ |
+
+ |
+
+  
+ package main
+ |
+
+
+
+ |
+
+ |
+
+
import (
"encoding/json"
"fmt"
"os"
)
- |
-
-
-
- |
- We’ll use these two structs to demonstrate encoding and
-decoding of custom types below.
-
- |
-
-
+ |
+
+
+
+ |
+
+ Usaremos estas dos estructuras para demostrar la codificación y
+ decodificación de tipos personalizados a continuación.
+
+
+ |
+
+
type response1 struct {
Page int
Fruits []string
}
- |
-
-
-
- |
- Only exported fields will be encoded/decoded in JSON.
-Fields must start with capital letters to be exported.
-
- |
-
-
+ |
+
+
+
+ |
+
+ Solo los campos exportados serán codificados/decodificados en JSON.
+ Los campos deben comenzar con letras mayúsculas para ser exportados.
+
+ |
+
+
type response2 struct {
Page int `json:"page"`
Fruits []string `json:"fruits"`
}
- |
-
-
-
- |
-
- |
-
-
- func main() {
- |
-
-
-
- |
- First we’ll look at encoding basic data types to
-JSON strings. Here are some examples for atomic
-values.
-
- |
-
-
- bolB, _ := json.Marshal(true)
+
|
+
+
+
+ |
+
+ |
+
+
+ func main() {
+ |
+
+
+
+ |
+
+ Primero veremos la codificación de tipos de datos básicos a
+ cadenas JSON. Aquí hay algunos ejemplos para valores atómicos.
+
+
+ |
+
+
+ bolB, _ := json.Marshal(true)
fmt.Println(string(bolB))
- |
-
-
-
- |
-
- |
-
-
- intB, _ := json.Marshal(1)
+
|
+
+
+
+ |
+
+ |
+
+
+ intB, _ := json.Marshal(1)
fmt.Println(string(intB))
- |
-
-
-
- |
-
- |
-
-
- fltB, _ := json.Marshal(2.34)
+
|
+
+
+
+ |
+
+ |
+
+
+ fltB, _ := json.Marshal(2.34)
fmt.Println(string(fltB))
- |
-
-
-
- |
-
- |
-
-
- strB, _ := json.Marshal("gopher")
+
|
+
+
+
+ |
+
+ |
+
+
+ strB, _ := json.Marshal("gopher")
fmt.Println(string(strB))
- |
-
-
-
- |
- And here are some for slices and maps, which encode
-to JSON arrays and objects as you’d expect.
-
- |
-
-
- slcD := []string{"apple", "peach", "pear"}
+
|
+
+
+
+ |
+
+ Y aquí hay algunos para slices y mapas, que se codifican
+ en arreglos y objetos JSON como esperarías.
+ |
+
+
+ slcD := []string{"apple", "peach", "pear"}
slcB, _ := json.Marshal(slcD)
fmt.Println(string(slcB))
- |
-
-
-
- |
-
- |
-
-
- mapD := map[string]int{"apple": 5, "lettuce": 7}
+
|
+
+
+
+ |
+
+ |
+
+
+ mapD := map[string]int{"apple": 5, "lettuce": 7}
mapB, _ := json.Marshal(mapD)
fmt.Println(string(mapB))
- |
-
-
-
- |
- The JSON package can automatically encode your
-custom data types. It will only include exported
-fields in the encoded output and will by default
-use those names as the JSON keys.
-
- |
-
-
- res1D := &response1{
+
|
+
+
+
+ |
+
+ El paquete JSON puede codificar automáticamente tus
+ tipos de datos personalizados. Solo incluirá campos exportados
+ en la salida codificada y por defecto
+ usará esos nombres como las claves JSON.
+ |
+
+
+ res1D := &response1{
Page: 1,
Fruits: []string{"apple", "peach", "pear"}}
res1B, _ := json.Marshal(res1D)
fmt.Println(string(res1B))
- |
-
-
-
- |
- You can use tags on struct field declarations
-to customize the encoded JSON key names. Check the
-definition of response2 above to see an example
-of such tags.
-
- |
-
-
- res2D := &response2{
+
|
+
+
+
+ |
+
+ Puedes usar etiquetas en las declaraciones de campos de estructuras
+ para personalizar los nombres de las claves JSON codificadas. Revisa la
+ definición de response2 arriba para ver un ejemplo
+ de tales etiquetas.
+
+
+ |
+
+
+ res2D := &response2{
Page: 1,
Fruits: []string{"apple", "peach", "pear"}}
res2B, _ := json.Marshal(res2D)
fmt.Println(string(res2B))
- |
-
-
-
- |
- Now let’s look at decoding JSON data into Go
-values. Here’s an example for a generic data
-structure.
-
- |
-
-
- byt := []byte(`{"num":6.13,"strs":["a","b"]}`)
- |
-
-
-
- |
- We need to provide a variable where the JSON
-package can put the decoded data. This
-map[string]interface{} will hold a map of strings
-to arbitrary data types.
-
- |
-
-
- var dat map[string]interface{}
- |
-
-
-
- |
- Here’s the actual decoding, and a check for
-associated errors.
-
- |
-
-
- if err := json.Unmarshal(byt, &dat); err != nil {
+
|
+
+
+
+ |
+
+ Ahora veamos la decodificación de datos JSON en valores de Go.
+ Aquí hay un ejemplo para una estructura de datos genérica.
+ |
+
+
+ byt := []byte(`{"num":6.13,"strs":["a","b"]}`)
+ |
+
+
+
+ |
+
+ Necesitamos proporcionar una variable donde el paquete JSON
+ pueda poner los datos decodificados. Este
+ map[string]interface{} contendrá un mapa de cadenas
+ a tipos de datos arbitrarios.
+
+
+
+ |
+
+
+ var dat map[string]interface{}
+ |
+
+
+
+ |
+
+ Aquí está la decodificación real y una verificación de
+ errores asociados.
+
+ |
+
+
+ if err := json.Unmarshal(byt, &dat); err != nil {
panic(err)
}
fmt.Println(dat)
- |
-
-
-
- |
- In order to use the values in the decoded map,
-we’ll need to convert them to their appropriate type.
-For example here we convert the value in num to
-the expected float64 type.
-
- |
-
-
- num := dat["num"].(float64)
+
|
+
+
+
+ |
+
+ Para usar los valores en el mapa decodificado,
+ necesitaremos convertirlos a su tipo apropiado.
+ Por ejemplo, aquí convertimos el valor en num al
+ tipo float64 esperado.
+
+
+
+ |
+
+
+ num := dat["num"].(float64)
fmt.Println(num)
- |
-
-
-
- |
- Accessing nested data requires a series of
-conversions.
-
- |
-
-
- strs := dat["strs"].([]interface{})
+
|
+
+
+
+ |
+
+ Acceder a datos anidados requiere una serie de
+ conversiones.
+ |
+
+
+ strs := dat["strs"].([]interface{})
str1 := strs[0].(string)
fmt.Println(str1)
- |
-
-
-
- |
- We can also decode JSON into custom data types.
-This has the advantages of adding additional
-type-safety to our programs and eliminating the
-need for type assertions when accessing the decoded
-data.
-
- |
-
-
- str := `{"page": 1, "fruits": ["apple", "peach"]}`
+
|
+
+
+
+ |
+
+ También podemos decodificar JSON en tipos de datos personalizados.
+ Esto tiene las ventajas de agregar seguridad de tipo adicional
+ a nuestros programas y eliminar la
+ necesidad de afirmaciones de tipo al acceder a los datos
+ decodificados.
+
+ |
+
+
+ str := `{"page": 1, "fruits": ["apple", "peach"]}`
res := response2{}
json.Unmarshal([]byte(str), &res)
fmt.Println(res)
fmt.Println(res.Fruits[0])
- |
-
-
-
- |
- In the examples above we always used bytes and
-strings as intermediates between the data and
-JSON representation on standard out. We can also
-stream JSON encodings directly to os.Writers like
-os.Stdout or even HTTP response bodies.
-
- |
-
-
+ |
+
+
+
+ |
+
+ En los ejemplos anteriores siempre usamos bytes y
+ cadenas como intermediarios entre los datos y
+ la representación JSON en la salida estándar. También podemos
+ transmitir codificaciones JSON directamente a os.Writers como
+ os.Stdout o incluso cuerpos de respuesta HTTP.
+
+
+
+
+ |
+
+
enc := json.NewEncoder(os.Stdout)
d := map[string]int{"apple": 5, "lettuce": 7}
enc.Encode(d)
}
- |
-
-
-