Formato de datos de documento: JSON extendido

Overview

JSON es un formato de datos que representa los valores de objetos, arreglos, números, cadenas, booleanos y nulos. El formato Extended JSON define un conjunto reservado de claves precedidas por el carácter $ para representar información sobre el tipo de campo que se corresponde directamente con cada tipo en BSON, el formato que utiliza MongoDB para almacenar datos.

Formatos JSON extendidos

MongoDB Extended JSON presenta diferentes string formatos para representar datos BSON. Cada uno de los formatos cumple con la JSON RFC y satisface casos de uso específicos.

El formato Extendido, también conocido como el formato Canónico, presenta representaciones específicas para cada tipo BSON, lo que permite la conversión bidireccional sin pérdida de información. El formato Relajado sólo es más conciso y se parece más al JSON normal, pero no representa toda la información de tipo, como el tamaño byte específico de los campos numéricos.

La siguiente tabla proporciona descripciones de los formatos JSON:

Para obtener más información sobre JSON, BSON y JSON extendido, consulta nuestro artículo sobre JSON y BSON y la referencia de JSON extendido en el manual del MongoDB Server.

{
  "_id": { "$oid": "573a1391f29313caabcd9637" },
  "createdAt": { "$date": { "$numberLong": "1601499609" }},
  "numViews": { "$numberLong": "36520312" }
}

{
  "_id": { "$oid": "573a1391f29313caabcd9637" },
  "createdAt": { "$date": "2020-09-30T18:22:51.648Z" },
  "numViews": 36520312
}

{
  "_id": ObjectId("573a1391f29313caabcd9637"),
  "createdAt": ISODate("2020-09-30T18:22:51.648Z"),
  "numViews": NumberLong("36520312")
}

{
  "_id": { "$oid": "573a1391f29313caabcd9637" },
  "createdAt": { "$date": 1601499609 },
  "numViews": { "$numberLong": "36520312" }
}

Leer JSON extendido

Puede leer una string JSON extendida en una estructura Go llamando al método bson.UnmarshalExtJSON(). Este método analiza una Extended JSON string y almacena el resultado en el parámetro de valor especificado.

Este ejemplo muestra cómo puedes leer una string Extended JSON en la siguiente estructura Person:

type Person struct {
	ID       bson.ObjectID `bson:"_id"`
	Name     string
	Age      int
	Birthday bson.DateTime
	Address  Address
	Hobbies  []string
}
type Address struct {
	Street string
	City   string
	State  string
}

El siguiente código utiliza el método UnmarshalExtJSON() para leer un string Extended JSON y deserializar los datos en una instancia de Person:

var extJsonString = "{\"_id\":{\"$oid\":\"578f6fa2df35c7fbdbaed8c5\"},\"name\":\"Liana Ruiz\",\"age\":46,\"birthday\":{\"$date\":\"1988-01-15T00:00:00Z\"},\"address\":{\"street\":\"500 Slippery Rock Road\",\"city\":\"Round Rock\",\"state\":\"AR\"},\"hobbies\":[\"cycling\", \"baking\"]}"
var p Person
err := bson.UnmarshalExtJSON([]byte(extJsonString), false, &p)
if err != nil {
	log.Fatal(err)
}
fmt.Printf("Go Struct Representation:\n%+v\n", p)

Go Struct Representation:
{ID:ObjectID("578f6fa2df35c7fbdbaed8c5") Name:Liana Ruiz Age:46 Birthday:569203200000 Address:{Street:500 Slippery Rock Road City:Round Rock State:AR} Hobbies:[cycling baking]}

Guardar Extended JSON

Puedes generar una string JSON extendida a partir de una instancia de una estructura Go o de un documento BSON llamando al método bson.MarshalExtJSON(). El siguiente ejemplo crea una string de Extended JSON en el formato Relaxed a partir de una estructura o un documento BSON. Selecciona la pestaña Struct o bson.D para ver el ejemplo correspondiente:

var person = Person{
	ID:       bson.NewObjectID(),
	Name:     "Matteo Carisi",
	Age:      49,
	Birthday: bson.NewDateTimeFromTime(time.Date(1975, 10, 30, 0, 0, 0, 0, time.UTC)),
	Address:  Address{Street: "14a Corner Court", City: "Springfield", State: "IL"},
	Hobbies:  []string{"cooking", "birdwatching"},
}
newExtJsonStringFromStruct, err := bson.MarshalExtJSON(person, false, true)
if err != nil {
	log.Fatal(err)
}
fmt.Printf("Extended JSON Representation:\n%s\n", newExtJsonStringFromStruct)

Extended JSON Representation:
{"_id":{"$oid":"686688fa7c1a2e75405f4697"},"name":"Matteo Carisi","age":49,"birthday":{"$date":"1975-10-30T00:00:00Z"},"address":{"street":"14a Corner Court","city":"Springfield","state":"IL"},"hobbies":["cooking","birdwatching"]}

bsonDocument := bson.D{{"hello", "world"}, {"number", 1}}
newExtJsonStringFromBson, err := bson.MarshalExtJSON(bsonDocument, false, true)
if err != nil {
	panic(err)
}
fmt.Printf("Extended JSON Representation:\n%s\n", newExtJsonStringFromBson)

Extended JSON Representation:
{"hello":"world","number":1}

El segundo parámetro de MarshalExtJSON() determina si la string de salida está en formato Canónico (Extendido) o en formato Relajado. El ejemplo anterior pasa false como el parámetro canonical, por lo que la salida es JSON relajado.

formattedString, err := bson.MarshalExtJSONIndent(person, false, true, "", "  ")
if err != nil {
	log.Fatal(err)
}
fmt.Printf("%s\n", formattedString)

{
  "_id": {
    "$oid": "686688fa7c1a2e75405f4697"
  },
  "name": "Matteo Carisi",
  "age": 49,
  "birthday": {
    "$date": "1975-10-30T00:00:00Z"
  },
  "address": {
    "street": "14a Corner Court",
    "city": "Springfield",
    "state": "IL"
  },
  "hobbies": [
    "cooking",
    "birdwatching"
  ]
}

Documentación de la API

Para obtener más información sobre los métodos y tipos utilizados en esta guía, consulte la siguiente documentación de la API:

• UnmarshalExtJSON()

• MarshalExtJSON()

• MarshalExtJSONIndent()