Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# millions de dollars
Nouveau depuis la version 8.0.1.
L'`$minN`opérateur d'Amazon DocumentDB renvoie les N plus petites valeurs. Lorsqu'il est utilisé comme accumulateur dans une `$group` étape, il renvoie un tableau des N valeurs minimales de chaque groupe. Lorsqu'il est utilisé comme opérateur d'expression de tableau, il renvoie les N éléments minimum d'un tableau.
**Paramètres**
+ `input`: expression qui renvoie au tableau ou au champ à partir duquel les `n` valeurs minimales doivent être renvoyées.
+ `n`: expression qui se résout en un entier positif spécifiant le nombre de valeurs minimales à renvoyer.
## Comportement
**Comportement des opérateurs d'expression de tableau **
+ Vous ne pouvez pas spécifier une valeur `n` inférieure à`1`.
+ `$minN`filtre les `null` valeurs présentes dans le `input` tableau.
+ Si la valeur spécifiée `n` est supérieure ou égale au nombre d'éléments du `input` tableau, `$minN` renvoie tous les éléments du `input` tableau.
+ Si elle est `input` résolue en une valeur non matricielle, l'opération d'agrégation entraîne des erreurs.
+ S'il `input` contient à la fois des éléments numériques et des éléments de chaîne, les éléments numériques sont triés avant les éléments de chaîne selon l'ordre de comparaison BSON.
**Comportement de l'accumulateur **
+ Lorsqu'il est utilisé comme accumulateur, `n` il doit s'agir d'une expression intégrale positive qui est soit une constante, soit dépend de la `_id` valeur de`$group`.
+ `$minN`filtre les valeurs nulles et manquantes.
+ Si le groupe contient moins d'`n`éléments, `$minN` renvoie tous les éléments du groupe.
+ `$minN`compare les données d'entrée selon l'ordre de comparaison BSON pour déterminer le type de sortie approprié. Lorsque les données d'entrée contiennent plusieurs types de données, le type `$minN` de sortie est le plus bas dans l'ordre de comparaison.
**Ordre des sorties **
`$minN`renvoie des valeurs sans ordre de tri particulier. S'il est obligatoire de garantir un ordre de tri particulier, `$bottomN` utilisez-le plutôt ou enveloppez le résultat avec`$sortArray`.
## Exemple (MongoDB Shell)
L'exemple suivant montre comment utiliser l'`$minN`accumulateur pour récupérer les deux scores les plus faibles pour chaque sujet.
**Créez des exemples de documents **
```
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 }
]);
```
**Exemple de requête **
```
db.scores.aggregate([
{ $group: { _id: "$subject", lowestTwo: { $minN: { input: "$score", n: 2 } } } }
]);
```
**Sortie**
```
[
{ "_id": "math", "lowestTwo": [72, 68] },
{ "_id": "science", "lowestTwo": [78, 65] }
]
```
## Exemple d'utilisation d'expressions (MongoDB Shell)
L'`$minN`opérateur peut également être utilisé comme expression au sein d'une `$project` étape pour renvoyer les N plus petits éléments d'un champ de tableau.
**Créez des exemples de documents **
```
db.readings.insertMany([
{ _id: 1, sensor: "A", values: [45, 12, 78, 3, 56] },
{ _id: 2, sensor: "B", values: [90, 23, 67, 11, 44] }
]);
```
**Exemple de requête **
```
db.readings.aggregate([
{ $project: {
lowestThree: { $minN: { input: "$values", n: 3 } }
}}
]);
```
**Sortie**
```
[
{ "_id": 1, "lowestThree": [45, 12, 3] },
{ "_id": 2, "lowestThree": [44, 23, 11] }
]
```
## Exemples de code
Pour afficher un exemple de code d'utilisation de l'`$minN`opérateur, choisissez l'onglet correspondant à la langue que vous souhaitez utiliser. Les exemples suivants montrent à la fois l'utilisation de l'accumulateur (in`$group`) et l'utilisation de l'expression (in`$project`) :
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function example() {
const client = new MongoClient('mongodb://:@: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 smallest values per group
const scores = db.collection('scores');
const accumulatorResult = await scores.aggregate([
{ $group: { _id: "$subject", lowestTwo: { $minN: { input: "$score", n: 2 } } } }
]).toArray();
console.log('Accumulator result:', accumulatorResult);
// Expression usage: N smallest elements from an array field
const readings = db.collection('readings');
const expressionResult = await readings.aggregate([
{ $project: { lowestThree: { $minN: { 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://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
try:
db = client['test']
# Accumulator usage: N smallest values per group
scores = db['scores']
accumulator_result = list(scores.aggregate([
{ '$group': { '_id': '$subject', 'lowestTwo': { '$minN': { 'input': '$score', 'n': 2 } } } }
]))
print('Accumulator result:', accumulator_result)
# Expression usage: N smallest elements from an array field
readings = db['readings']
expression_result = list(readings.aggregate([
{ '$project': { 'lowestThree': { '$minN': { 'input': '$values', 'n': 3 } } } }
]))
print('Expression result:', expression_result)
finally:
client.close()
example()
```
------