/ /

EJSON

Página inicial do Docs

Ferramentas

MongoDB Shell

EJSON

Página inicial do Docs

Ferramentas

MongoDB Shell

EJSON

EJSON.stringify()

O método EJSON.stringify() converte valores BSON em strings.

Sintaxe

O método EJSON.stringify() usa um objeto BSON como entrada e modificadores opcionais que controlam o formato da string de saída.

EJSON.stringify(BSON object, [replacer], [space], [options])

Campos de comando

O método EJSON.stringify() tem estes campos:

Campo

Tipo

necessidade

Descrição

value

Objeto BSON

Obrigatório

Transformações do objeto EJSON.stringify()

replacer

array ou função

Opcional

Modifica a saída. Se o valor existir, mas não for uma array ou uma função, EJSON.stringify() retornará todos os campos do documento .

replacer pode ser uma array ou uma função.

Valor	Efeito
array	Uma array de campos de documento a serem incluídos no resultado. Os elementos de array devem especificar os nomes dos campo a serem incluídos na string JSON retornada.
function	Uma função que utiliza dois parâmetros, `key` e `value`. `key` fornece o contexto `this` da função. EJSON retorna o `value` transformado. A função é executada para cada objeto. Os valores do objeto são substituídos pelo valor de retorno da função. Para obter um exemplo, consulte Usar uma função para transformar campos de saída.

spacer

inteiro ou string

Opcional

Controla o espaçamento na saída. Use null como um espaço reservado para replacer se você quiser especificar apenas a opção spacer .

Valor	Efeito
inteiro	O número de espaços para indentar cada nível. `10` é o máximo.
string	Um caractere para usar para recuar cada nível. Esta opção produz JSON inválido se você utilizar um caractere diferente de um espaço ou tabulação. Para mais informações, consulte JSON.stringify()

options

booleano

Opcional

Opções Adicionais de Configuração

Opção	Default	Significado
`relaxed`	`true`	Ativar o modo relaxado para JSON estendido. Retorna tipos JSON nativos em vez de anexar informações de tipo BSON, quando aplicável.

Comportamento

Você pode chamar a interface EJSON de dentro de uma sessão mongosh interativa ou da linha de comando do sistema usando --eval.

Chame a interface EJSON a partir de uma sessão interativa:

EJSON.stringify( db.sales.find().toArray(), null, 2  )

Chame a interface EJSON a partir da linha de comando do sistema:

mongosh --eval "EJSON.stringify( db.sales.find().toArray(), null, 2  )"

Para controlar como os documentos são passados para EJSON, use um dos iteradores do método do cursormongosh.

Iterador	Características
`.toArray()`	Bloqueio, armazena em buffer todo o resultado
`.foreach`	Não bloqueante, imprime documentos um a um
`.next()`	Não bloqueante, iteração manual dos resultados

Exemplos

Para tentar estes exemplos, primeiro crie uma coleção do test sales banco de dados de dados do :

db.sales.insertMany( [
   { custId: 345, purchaseDate: ISODate("2023-07-04"), quantity: 4, cost: Decimal128("100.60"), },
   { custId: 346, purchaseDate: ISODate("2023-07-12"), quantity: 3, cost: Decimal128("175.45"), },
   { custId: 486, purchaseDate: ISODate("2023-08-01"), quantity: 9, cost: Decimal128("200.53"), },
] )

Alterar espaçamento de saída

Para aumentar o recuo entre os níveis, defina a opção spacing .

EJSON.stringify( db.sales.findOne( { custId: 345 } ), null , 5 )

EJSON.stringify() recua cada nível de documento cinco espaços.

{
     "_id": {
          "$oid": "64da90c1175f5091debcab26"
     },
     "custId": 345,
     "purchaseDate": {
          "$date": "2023-07-04T00:00:00Z"
     },
     "quantity": 4,
     "cost": {
          "$numberDecimal": "100.60"
     }
}

Selecionar campos de saída

Para selecionar um subconjunto de campos de documento , use uma array para definir a opção replace .

EJSON.stringify( db.sales.find().toArray(), [ "quantity", "cost" ] )

O EJSON formata o quantity e cost para cada documento.

[{"quantity":4,"cost":{}},{"quantity":3,"cost":{}},{"quantity":9,"cost":{}}]

A opção spacing não é especificada neste exemplo, portanto, o EJSON retorna os campos selecionados em uma única linha.

Usar uma função para transformar campos de saída

Para transformar valores de campo , utilize uma função JavaScript para definir a opção replacer . Por exemplo:

let queryResults = db.sales.find().toArray()
let replacer = function( key, value ){
   if ( key === '_id' ) {
      value = undefined;
   }
   if ( key === 'quantity' ) {
      value = 2 * value;
   }
   return value;
}
EJSON.stringify( queryResults, replacer, 3 )

A função é executada recursivamente em relação ao objeto de entrada.

Saída de exemplo:

[
   {
      "custId": 345,
      "purchaseDate": {
         "$date": "2023-07-04T00:00:00Z"
      },
      "quantity": 8,
      "cost": {
         "$numberDecimal": "100.60"
      }
   },
   {
      "custId": 346,
      "purchaseDate": {
         "$date": "2023-07-12T00:00:00Z"
      },
      "quantity": 6,
      "cost": {
         "$numberDecimal": "175.45"
      }
   },
   {
      "custId": 486,
      "purchaseDate": {
         "$date": "2023-08-01T00:00:00Z"
      },
      "quantity": 18,
      "cost": {
         "$numberDecimal": "200.53"
      }
   }
]

A função replacer atualiza dois campos, _id e quantity.

EJSON.stringify() ignora campos com valores indefinidos, então configurar _id: undefined remove o campo _id da string de saída.

A função também modifica o campo quantity na string de saída. Todos os valores de quantity são multiplicados por dois na string de saída. EJSON.stringify() não atualiza a coleção.

Use uma função para transformar campos de saída em objetos aninhados

Crie a coleção salesWithAddress com endereços aninhados:

db.salesWithAddress.insertMany( [
   { custId: 345, purchaseDate: ISODate("2023-07-04"),
     quantity: 4, cost: Decimal128("100.60"),
     address: { number: 100, street: "Main Street", ZIP: 12345 } },
   { custId: 346, purchaseDate: ISODate("2023-07-12"),
     quantity: 3, cost: Decimal128("175.45"),
     address: { number: 200, street: "East Street", ZIP: 12345 } }
] )

O exemplo a seguir utiliza uma função replacer para alterar os códigos postais dos endereços para 55555:

// Retrieve the salesWithAddress contents as an array and save
// in queryResults
let queryResults = db.salesWithAddress.find().toArray()
// Define a replacer function to change the ZIP codes
let replacer = function( key, value ) {
   if (key === 'address') {
      value.ZIP = 55555;
   }
   return value;
}
// Run EJSON.stringify() to change the ZIP codes in queryResults
EJSON.stringify( queryResults, replacer, 3 )

Saída de exemplo:

[
   {
      "_id": {
         "$oid": "65498c6562f443aa1490070f"
      },
      "custId": 345,
      "purchaseDate": {
         "$date": "2023-07-04T00:00:00Z"
      },
      "quantity": 4,
      "cost": {
         "$numberDecimal": "100.60"
      },
      "address": {
         "number": 100,
         "street": "Main Street",
         "ZIP": 55555
      }
   },
   {
      "_id": {
         "$oid": "65498c6562f443aa14900710"
      },
      "custId": 346,
      "purchaseDate": {
         "$date": "2023-07-12T00:00:00Z"
      },
      "quantity": 3,
      "cost": {
         "$numberDecimal": "175.45"
      },
      "address": {
         "number": 200,
         "street": "East Street",
         "ZIP": 55555
      }
   }
]

Usar uma função para substituir strings BSON

Para uma lista de tipos de dados BSON e os respectivos códigos numéricos, consulte Tipos de BSON.

O exemplo a seguir utiliza uma função replacer para substituir as strings BSON pela string "This is a string":

// Retrieve the salesWithAddress contents as an array and save
// in queryResults
let queryResults = db.salesWithAddress.find().toArray()
// Define a replacer function to replace the strings
let replacer = function( key, value ) {
   if (typeof value === "string") {
      return "This is a string";
   }
   return value;
}
// Run EJSON.stringify() to replace the strings in queryResults
EJSON.stringify( queryResults, replacer, 3 )

Saída de exemplo:

[
   {
      "_id": {
         "$oid": "This is a string"
      },
      "custId": 345,
      "purchaseDate": {
         "$date": "This is a string"
      },
      "quantity": 4,
      "cost": {
         "$numberDecimal": "This is a string"
      },
      "address": {
         "number": 100,
         "street": "This is a string",
         "ZIP": 12345
      }
   },
   {
      "_id": {
         "$oid": "This is a string"
      },
      "custId": 346,
      "purchaseDate": {
         "$date": "This is a string"
      },
      "quantity": 3,
      "cost": {
         "$numberDecimal": "This is a string"
      },
      "address": {
         "number": 200,
         "street": "This is a string",
         "ZIP": 12345
      }
   }
]

Gravar em um arquivo de dentro do mongosh

Para gravar em um arquivo de dentro do mongosh, use a API fs . Use EJSON.stringify() para formatar a string que você passa para fs.

const sales_2023_07 = db.sales.find(
   {
      purchaseDate:
      {
          $gte: ISODate( "2023-07-01" ),
          $lte: ISODate( "2023-07-31" )
      }
   }
)
fs.writeFileSync(
   'sales_2023_07.json',
   EJSON.stringify( sales_2023_07.toArray(), null, 2 )
)

O exemplo consulta a coleção sales para vendas em julho, 2023.

sales_2023_07 armazena um objeto MongoDB BSON .
EJSON.stringify() formata o objeto como uma string JSON.
fs.writeFileSync() grava a string formatada no arquivo sales_2023_07.json no diretório onde você executou mongosh.

Executar a partir da linha de comando

Para executar uma query a partir da shell do sistema operacional, use a opção --eval .

# Note: This example is formatted to fit on the page.
mongosh --quiet \
        --eval "db.sales.find().forEach( \
                   o => print( EJSON.stringify( o ) ) )"

O comando retorna uma única linha de JSON para cada documento:

--quiet suprime as informações de conexão mongosh
--eval chama o método find
.forEach é um método JavaScript que informa à mongosh para iterar sobre a resposta
EJSON.stringify() converte cada documento em JSON

A saída é:

{"_id":{"$oid":"64da90c1175f5091debcab26"},"custId":345,"purchaseDate":{"$date":"2023-07-04T00:00:00Z"},"quantity":4,"cost":{"$numberDecimal":"100.60"}}
{"_id":{"$oid":"64da90c1175f5091debcab27"},"custId":346,"purchaseDate":{"$date":"2023-07-12T00:00:00Z"},"quantity":3,"cost":{"$numberDecimal":"175.45"}}
{"_id":{"$oid":"64da90c1175f5091debcab28"},"custId":486,"purchaseDate":{"$date":"2023-08-01T00:00:00Z"},"quantity":9,"cost":{"$numberDecimal":"200.53"}}

O formato de saída de linha única é conveniente para scripts. EJSON.stringify() também pode produzir formatação legível por humanos:

# Note: This example is formatted to fit on the page.
mongosh --quiet \
        --eval "db.sales.find().forEach( \
                   o => print( EJSON.stringify(o, null, 3 ) ) )"

A saída é:

# Note: This is only the first document.
{
   "_id": {
      "$oid": "64da90c1175f5091debcab26"
   },
   "custId": 345,
   "purchaseDate": {
      "$date": "2023-07-04T00:00:00Z"
   },
   "quantity": 4,
   "cost": {
      "$numberDecimal": "100.60"
   }
}

o é o valor BSON que EJSON.stringify() converte em cada iteração de .forEach().
null é um espaço reservado para um replacer opcional. Quando o replacer está ausente, o EJSON.stringify() retorna todos os campos que têm um valor definido.
3 é o valor spacer . Ele diz a EJSON.stringify() para recuar cada novo nível por 3 espaços.

Se você quiser que a string de saída tenha informações de tipo adicionais, adicione a opção { relaxed: false } :

# Note: This example is formatted to fit on the page.
mongosh --quiet \
        --eval "db.sales.find().forEach( \
              o => print( \
                  EJSON.stringify( o, null, 3, { relaxed: false } ) \
           ) )"

A saída é:

# Note: This is only the first document.
{
   "_id": {
      "$oid": "64da90c1175f5091debcab26"
   },
   "custId": {
      "$numberInt": "345"
   },
   "purchaseDate": {
      "$date": {
         "$numberLong": "1688428800000"
      }
   },
   "quantity": {
      "$numberInt": "4"
   },
   "cost": {
      "$numberDecimal": "100.60"
   }
}

Filtrar campos de saída

EJSON.stringify() fornece opções de formatação que reduzem a necessidade de um analisador JSON adicional como jq.

# Note: This example is formatted to fit on the page.
mongosh --quiet \
        --eval "EJSON.stringify( \
             db.sales.find( {}, \
                { _id: 0, custId: 1, quantity: 1 } ).toArray(), null, 2 \
          );"

A saída é:

[
  {
    "custId": 345,
    "quantity": 4
  },
  {
    "custId": 346,
    "quantity": 3
  },
  {
    "custId": 486,
    "quantity": 9
  }
]

Legacy tojsononeline()

O shell mongosh retorna uma saída que difere do shell mongo legado . Se você tiver scripts que exijam que a saída seja formatada de forma semelhante ao shell mongo legado , tente reformatar a saída mongosh com EJSON.stringify ().

Execute uma consulta de amostra no mongosh e mongo para ver os diferentes formatos.

db.sales.find( { custId: 345 } )

Saída legada:

{ "_id" : ObjectId("64da90c1175f5091debcab26"), "custId" : 345, "purchaseDate" : ISODate("2023-07-04T00:00:00Z"), "quantity" : 4, "cost" : NumberDecimal("100.60") }

mongosh saída:

db.sales.find( { custId: 345 } )
[
  {
    _id: ObjectId("64da90c1175f5091debcab26"),
    custId: 345,
    purchaseDate: ISODate("2023-07-04T00:00:00.000Z"),
    quantity: 4,
    cost: Decimal128("100.60")
  }
]

Formate a saída com EJSON.stringify().

EJSON.stringify( db.sales.find( { custId: 345 } ).toArray() )

[{"_id":{"$oid":"64da90c1175f5091debcab26"},"custId":345,"purchaseDate":{"$date":"2023-07-04T00:00:00Z"},"quantity":4,"cost":{"$numberDecimal":"100.60"}}]

Saiba mais

Documentação EJSON
Documentação do JSON.stringify() da Mozilla Developer Network

Voltar

serialize()

Arquivo de configuração .mongoshrc