Formato de datos del documento: JSON extendido

Overview

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

Formatos JSON extendidos

MongoDB Extended JSON ofrece diferentes formatos de cadena para representar datos BSON. Cada formato cumple con las normas JSON RFC y cumple casos de uso específicos.

El formato extendido,también conocido como formato canónico, ofrece representaciones específicas para cada tipo de BSON,lo que permite una conversión bidireccional sin pérdida de información. El formato relajado es más conciso y se asemeja más al JSON convencional, pero no representa toda la información de tipo, como el tamaño de bytes 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, consulte nuestro artículo sobre JSON y BSON y la referencia JSON extendido en el manual de 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

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

Este ejemplo muestra cómo puedes leer una cadena JSON extendida 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 una cadena JSON extendida y desagrupar 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]}

Escribir JSON extendido

Puede generar una cadena JSON extendida a partir de una instancia de una estructura Go o un documento BSON llamando al método bson.MarshalExtJSON(). El siguiente ejemplo crea una cadena JSON extendida en formato relajado a partir de una estructura o un documento BSON. Seleccione el Struct o la pestaña 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 cadena de salida está en formato canónico (extendido) o relajado. En el ejemplo anterior, se pasa false como 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 API:

• DesmarshalExtJSON()

• MarshalExtJSON()

• MarshalExtJSONIndent()