$first (operador de array)

Nesta página

Definição

Sintaxe
Comportamento
Exemplo
Veja também

Definição

$first: Novidades na versão 4.4.
Retorna o primeiro elemento de uma matriz.
Observação
Desambiguação
Esta página descreve o operador da array $first . Para o acumulador de agregação do $first , consulte $first (aggregation accumulator).

Dica

Veja também:

$last

Sintaxe

$first tem a seguinte sintaxe:

{ $first: <expression> }

O <expression> pode ser qualquer expressão válida, desde que resolva em uma array, nula ou ausente. Para mais informações sobre expressões, consulte Expressões.

O operador $first é um apelido para a seguinte expressão $arrayElemAt :

{ $arrayElemAt: [ <array expression>, 0 ] }

Comportamento

Operandos Válidos

Operando válido para $first deve resultar em uma array nula ou ausente

Se o operando for resolvido para uma array não vazia, $first retornará o primeiro elemento na array:
Se o operando for resolvido em uma array vazia [], $first não retornará um valor.
Se o operando for nulo ou estiver ausente, $first retornará nulo.

Por exemplo, criar uma collection de teste example1 com os seguintes documentos:

db.example1.insertMany([
     { "_id" : 1, "x" : [ 1, 2, 3 ] },      // Non-empty array
     { "_id" : 2, "x" : [ [ ] ] },          // Non-empty array
     { "_id" : 3, "x" : [ null ] },         // Non-empty array
     { "_id" : 4, "x" : [ ] },              // Empty array
     { "_id" : 5, "x" : null },             // Is null
     { "_id" : 6 }                          // Is Missing
])

Em seguida, o seguinte adiciona um novo campo firstElem cujo valor é derivado da aplicação do operador $first ao campo x :

db.example1.aggregate([
   { $addFields: { firstElem: { $first: "$x" } } }
])

O operador retorna os seguintes documentos:

{ "_id" : 1, "x" : [ 1, 2, 3 ], "firstElem" : 1 }
{ "_id" : 2, "x" : [ [ ] ], "firstElem" : [ ] }
{ "_id" : 3, "x" : [ null ], "firstElem" : null }
{ "_id" : 4, "x" : [ ] }                          // No output
{ "_id" : 5, "x" : null, "firstElem" : null }
{ "_id" : 6, "firstElem" : null }

Operandos inválidos

Se o operando não for resolvido para uma matriz, nulo ou ausente, a operação de agregação como um todo apresentará erro.

Por exemplo, criar uma collection de teste example2 com os seguintes documentos:

db.example2.insertMany([
   { "_id" : 1, "x" : [ 1, 2, 3 ] },
   { "_id" : 2, "x" : 2 },             // x is not an array/null or missing
])

Em seguida, a seguinte operação de agregação retorna um erro devido ao documento { "_id" : 2, "x" : 2 } :

db.example2.aggregate( { $addFields: { firstElem: { $first: "$x" } } } )

Ou seja, a operação retorna o seguinte:

2020-01-20T18:31:13.431-05:00 E  QUERY    [js] uncaught exception: Error: command failed: {
   "ok" : 0,
   "errmsg" : "$first's argument must be an array, but is double",
   "code" : 28689,
   "codeName" : "Location28689"
} : aggregate failed :

Exemplo

Criar uma collection de amostra runninglog com os seguintes documentos:

db.runninglog.insertMany([
   { "_id" : 1, "team" : "Anteater", log: [ { run: 1, distance: 8 }, { run2: 2, distance: 7.5 }, { run: 3, distance: 9.2 } ] },
   { "_id" : 2, "team" : "Bears", log: [ { run: 1, distance: 18 }, { run2: 2, distance: 17 }, { run: 3, distance: 16 } ] },
   { "_id" : 3, "team" : "Cobras", log: [ { run: 1, distance: 2 } ] }
])

A seguinte agregação utiliza o operador $first e $last na array log para recuperar as informações da primeira execução e da última execução:

db.runninglog.aggregate([
   { $addFields: { firstrun: { $first: "$log" }, lastrun: { $last: "$log" } } }
])

A operação retorna os seguintes resultados:

{ "_id" : 1, "team" : "Anteater", "log" : [ { "run" : 1, "distance" : 8 }, { "run2" : 2, "distance" : 7.5 }, { "run" : 3, "distance" : 9.2 } ],
      "firstrun" : { "run" : 1, "distance" : 8 }, "lastrun" : { "run" : 3, "distance" : 9.2 } }
{ "_id" : 2, "team" : "Bears", "log" : [ { "run" : 1, "distance" : 18 }, { "run2" : 2, "distance" : 17 }, { "run" : 3, "distance" : 16 } ],
      "firstrun" : { "run" : 1, "distance" : 18 }, "lastrun" : { "run" : 3, "distance" : 16 } }
{ "_id" : 3, "team" : "Cobras", "log" : [ { "run" : 1, "distance" : 2 } ],
      "firstrun" : { "run" : 1, "distance" : 2 }, "lastrun" : { "run" : 1, "distance" : 2 } }

Para calcular a alteração entre a primeira e a última distâncias, a operação a seguir usa $cond e $size operadores para calcular a diferença (ou seja, $subtract) as duas distâncias se houver dois ou mais elementos na array log :

db.runninglog.aggregate([
  { $addFields: { firstrun: { $first: "$log" }, lastrun: { $last: "$log" } } },
  { $project: { team: 1, progress:
      {
        $cond: {
           if: { $gt: [ { $size:"$log" }, 1 ] } ,
           then: { $subtract: [ "$lastrun.distance", "$firstrun.distance"] },
           else: "Not enough data." }
      }
  }}
])

A operação retorna os seguintes documentos:

{ "_id" : 1, "team" : "Anteater", "progress" : 1.1999999999999993 }
{ "_id" : 2, "team" : "Bears", "progress" : -2 }
{ "_id" : 3, "team" : "Cobras", "progress" : "Not enough data." }

Por padrão, mongosh usa o ponto double de 64bits para números. Para melhorar a precisão, você pode usar Decimal128 em vez disso.

Veja também

Voltar

$firstN

$floor