Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# $ máx. N
<a name="maxN"></a>

Nuevo a partir de la versión 8.0.1.

El `$maxN` operador de Amazon DocumentDB devuelve los N valores más altos. Cuando se usa como acumulador en una `$group` etapa, devuelve una matriz con los N valores máximos de cada grupo. Cuando se usa como operador de expresión matricial, devuelve los N elementos máximos de una matriz.

**Parámetros**
+ `input`: una expresión que se convierte en la matriz o el campo desde el que se devuelven los `n` valores máximos.
+ `n`: expresión que se resuelve en un entero positivo que especifica cuántos valores máximos se devolverán.

## Comportamiento
<a name="maxN-behavior"></a>

**Comportamiento del operador de expresiones matriciales **
+ No puede especificar un valor `n` inferior a`1`.
+ `$maxN`filtra los `null` valores que se encuentran en la `input` matriz.
+ Si el valor especificado `n` es mayor o igual al número de elementos de la `input` matriz, `$maxN` devuelve todos los elementos de la `input` matriz.
+ Si se `input` resuelve en un valor que no es de matriz, se produce un error en la operación de agregación.
+ Si `input` contiene elementos numéricos y de cadena, los elementos de cadena se ordenan antes que los numéricos según el orden de comparación de BSON.

**Comportamiento del acumulador **
+ Cuando se usa como acumulador, `n` debe ser una expresión integral positiva que sea una constante o que dependa del valor de. `_id` `$group`
+ `$maxN`filtra los valores nulos y faltantes.
+ Si el grupo contiene menos de `n` elementos, `$maxN` devuelve todos los elementos del grupo.
+ `$maxN`compara los datos de entrada siguiendo el orden de comparación de BSON para determinar el tipo de salida apropiado. Cuando los datos de entrada contienen varios tipos de datos, el tipo `$maxN` de salida es el más alto en el orden de comparación.

**Orden de salida **

`$maxN`devuelve valores sin ningún orden de clasificación en particular. Si es obligatorio garantizar un orden de clasificación determinado, utilícelo `$topN` en su lugar o envuelva el resultado con`$sortArray`.

## Ejemplo (MongoDB Shell)
<a name="maxN-examples"></a>

El siguiente ejemplo muestra cómo usar el `$maxN` acumulador para recuperar las dos puntuaciones más altas de cada asignatura.

**Cree documentos de muestra **

```
db.scores.insertMany([
  { subject: "math", score: 85 },
  { subject: "math", score: 72 },
  { subject: "math", score: 93 },
  { subject: "math", score: 68 },
  { subject: "science", score: 90 },
  { subject: "science", score: 78 },
  { subject: "science", score: 65 },
  { subject: "science", score: 88 }
]);
```

**Ejemplo de consulta **

```
db.scores.aggregate([
  { $group: { _id: "$subject", highestTwo: { $maxN: { input: "$score", n: 2 } } } }
]);
```

**Salida**

```
[
  { "_id": "math", "highestTwo": [85, 93] },
  { "_id": "science", "highestTwo": [88, 90] }
]
```

## Ejemplo de uso de expresiones (MongoDB Shell)
<a name="maxN-expression-examples"></a>

El `$maxN` operador también se puede usar como expresión dentro de una `$project` etapa para devolver los N elementos más grandes de un campo de matriz.

**Crea documentos de muestra **

```
db.readings.insertMany([
  { _id: 1, sensor: "A", values: [45, 12, 78, 3, 56] },
  { _id: 2, sensor: "B", values: [90, 23, 67, 11, 44] }
]);
```

**Ejemplo de consulta **

```
db.readings.aggregate([
  { $project: {
      highestThree: { $maxN: { input: "$values", n: 3 } }
    }}
]);
```

**Salida**

```
[
  { "_id": 1, "highestThree": [45, 56, 78] },
  { "_id": 2, "highestThree": [44, 90, 67] }
]
```

## Ejemplos de código
<a name="maxN-code"></a>

Para ver un ejemplo de código sobre el uso `$maxN` del operador, elija la pestaña correspondiente al idioma que desee utilizar. Los siguientes ejemplos muestran tanto el uso del acumulador (en`$group`) como el uso de expresiones (en`$project`):

------
#### [ Node.js ]

```
const { MongoClient } = require('mongodb');

async function example() {
  const client = new MongoClient('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');

  try {
    await client.connect();
    const db = client.db('test');

    // Accumulator usage: N largest values per group
    const scores = db.collection('scores');
    const accumulatorResult = await scores.aggregate([
      { $group: { _id: "$subject", highestTwo: { $maxN: { input: "$score", n: 2 } } } }
    ]).toArray();
    console.log('Accumulator result:', accumulatorResult);

    // Expression usage: N largest elements from an array field
    const readings = db.collection('readings');
    const expressionResult = await readings.aggregate([
      { $project: { highestThree: { $maxN: { input: "$values", n: 3 } } } }
    ]).toArray();
    console.log('Expression result:', expressionResult);

  } finally {
    await client.close();
  }
}

example();
```

------
#### [ Python ]

```
from pymongo import MongoClient

def example():
    client = MongoClient('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')

    try:
        db = client['test']

        # Accumulator usage: N largest values per group
        scores = db['scores']
        accumulator_result = list(scores.aggregate([
            { '$group': { '_id': '$subject', 'highestTwo': { '$maxN': { 'input': '$score', 'n': 2 } } } }
        ]))
        print('Accumulator result:', accumulator_result)

        # Expression usage: N largest elements from an array field
        readings = db['readings']
        expression_result = list(readings.aggregate([
            { '$project': { 'highestThree': { '$maxN': { 'input': '$values', 'n': 3 } } } }
        ]))
        print('Expression result:', expression_result)

    finally:
        client.close()

example()
```

------