MongoDB $round

Dans MongoDB, le $round l'opérateur de pipeline d'agrégation arrondit un nombre à un entier entier ou à une décimale spécifiée.

Vous avez la possibilité de spécifier le nombre de décimales pour lesquelles arrondir le nombre. Pour ce faire, passez un deuxième argument. Le premier argument est le nombre à arrondir, et le deuxième argument (facultatif) est le nombre de décimales auxquelles l'arrondir.

Exemple

Supposons que nous ayons une collection appelée test avec les documents suivants :

{ "_id" : 1, "data" : 8.99 }
{ "_id" : 2, "data" : 8.45 }
{ "_id" : 3, "data" : 8.451 }
{ "_id" : 4, "data" : -8.99 }
{ "_id" : 5, "data" : -8.45 }
{ "_id" : 6, "data" : -8.451 }
{ "_id" : 7, "data" : 8 }
{ "_id" : 8, "data" : 0 }

Nous pouvons utiliser le $round opérateur pour arrondir les valeurs dans les data champ :

db.test.aggregate(
   [
     {
       $project:
          {
            _id: 0,
            data: 1,
            rounded: { $round: [ "$data" ] }
          }
     }
   ]
)

Résultat :

{ "data" : 8.99, "rounded" : 9 }
{ "data" : 8.45, "rounded" : 8 }
{ "data" : 8.451, "rounded" : 8 }
{ "data" : -8.99, "rounded" : -9 }
{ "data" : -8.45, "rounded" : -8 }
{ "data" : -8.451, "rounded" : -8 }
{ "data" : 8, "rounded" : 8 }
{ "data" : 0, "rounded" : 0 }

Spécifiez une décimale

Nous avons la possibilité d'utiliser un deuxième argument pour spécifier le nombre de décimales pour lesquelles arrondir le nombre.

Exemple :

db.test.aggregate(
   [
     {
       $project:
          {
            _id: 0,
            data: 1,
            rounded: { $round: [ "$data", 1 ] }
          }
     }
   ]
)

Résultat :

{ "data" : 8.99, "rounded" : 9 }
{ "data" : 8.45, "rounded" : 8.4 }
{ "data" : 8.451, "rounded" : 8.5 }
{ "data" : -8.99, "rounded" : -9 }
{ "data" : -8.45, "rounded" : -8.4 }
{ "data" : -8.451, "rounded" : -8.5 }
{ "data" : 8, "rounded" : 8 }
{ "data" : 0, "rounded" : 0 }

Décimales négatives

Le deuxième argument peut être n'importe quelle expression valide qui se résout en un entier compris entre -20 et 100, exclusif. Par conséquent, vous pouvez spécifier une décimale négative.

Lorsque vous faites cela, le nombre est arrondi à gauche de la décimale. Si la valeur absolue de l'entier négatif est supérieure au nombre, le résultat est 0 .

Supposons que nous ajoutions les documents suivants à notre collection :

{ "_id" : 9, "data" : 8111.32 }
{ "_id" : 10, "data" : 8514.321 }
{ "_id" : 11, "data" : 8999.454 }

Voici un exemple d'utilisation de plusieurs décimales négatives lors de l'application de $round à ces documents :

db.test.aggregate(
   [
     { $match: { _id: { $in: [ 9, 10, 11 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            a: { $round: [ "$data", -1 ] },
            b: { $round: [ "$data", -2 ] },
            c: { $round: [ "$data", -3 ] },
            d: { $round: [ "$data", -4 ] },
            e: { $round: [ "$data", -5 ] }
          }
     }
   ]
).pretty()

Résultat :

{
	"data" : 8111.32,
	"a" : 8110,
	"b" : 8100,
	"c" : 8000,
	"d" : 10000,
	"e" : 0
}
{
	"data" : 8514.321,
	"a" : 8510,
	"b" : 8500,
	"c" : 9000,
	"d" : 10000,
	"e" : 0
}
{
	"data" : 8999.454,
	"a" : 9000,
	"b" : 9000,
	"c" : 9000,
	"d" : 10000,
	"e" : 0
}

Décimale du zéro

Lorsque vous fournissez une décimale de 0 , le $round l'opérateur arrondit en utilisant le premier chiffre à droite de la décimale et renvoie la valeur entière arrondie.

Exemple :

db.test.aggregate(
   [
     {
       $project:
          {
            _id: 0,
            data: 1,
            rounded: { $round: [ "$data", 0 ] }
          }
     }
   ]
)

Résultat :

{ "data" : 8.99, "rounded" : 9 }
{ "data" : 8.45, "rounded" : 8 }
{ "data" : 8.451, "rounded" : 8 }
{ "data" : -8.99, "rounded" : -9 }
{ "data" : -8.45, "rounded" : -8 }
{ "data" : -8.451, "rounded" : -8 }
{ "data" : 8, "rounded" : 8 }
{ "data" : 0, "rounded" : 0 }
{ "data" : 8111.32, "rounded" : 8111 }
{ "data" : 8514.321, "rounded" : 8514 }
{ "data" : 8999.454, "rounded" : 8999 }

Types de nombres

Le nombre à arrondir peut être n'importe quelle expression valide qui se résout en entier, double, décimal ou long. La valeur de retour correspond au type de données de la valeur d'entrée.

Donc, si nous ajoutons les documents suivants à notre collection :

{ "_id" : 12, "data" : NumberDecimal("128.4585") }
{ "_id" : 13, "data" : NumberDecimal("128.12345678912") }

Nous pouvons appliquer $round aux data champ :

db.test.aggregate(
   [
     { $match: { _id: { $in: [ 12, 13 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            a: { $round: [ "$data", -1 ] },
            b: { $round: [ "$data", 0 ] },
            c: { $round: [ "$data", 3 ] },
            d: { $round: [ "$data", 4 ] },
            e: { $round: [ "$data", 5 ] }
          }
     }
   ]
).pretty()

Résultat :

{
	"data" : NumberDecimal("128.4585"),
	"a" : NumberDecimal("1.3E+2"),
	"b" : NumberDecimal("128"),
	"c" : NumberDecimal("128.458"),
	"d" : NumberDecimal("128.4585"),
	"e" : NumberDecimal("128.45850")
}
{
	"data" : NumberDecimal("128.12345678912"),
	"a" : NumberDecimal("1.3E+2"),
	"b" : NumberDecimal("128"),
	"c" : NumberDecimal("128.123"),
	"d" : NumberDecimal("128.1235"),
	"e" : NumberDecimal("128.12346")
}

Arrondi aux décimales nulles

Si le deuxième argument est null , le résultat est null .

Exemple :

db.test.aggregate(
   [
     { $match: { _id: { $in: [ 1, 2, 3 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            rounded: { $round: [ "$data", null ] }
          }
     }
   ]
)

Résultat :

{ "data" : 8.99, "rounded" : null }
{ "data" : 8.45, "rounded" : null }
{ "data" : 8.451, "rounded" : null }

Arrondir une valeur nulle

Si la valeur à arrondir est null , le résultat est null .

Supposons que nous ajoutions le document suivant à la collection :

{ "_id" : 14, "data" : null }

Et nous utilisons $round pour arrondir la valeur nulle :

db.test.aggregate(
   [
     { $match: { _id: { $in: [ 14 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            rounded: { $round: [ "$data", null ] }
          }
     }
   ]
)

Résultat :

{ "data" : null, "rounded" : null }

Arrondi à l'infini

Si le nombre à arrondir est Infinity , le résultat est Infinity . De même, si c'est -Infinity , le résultat est -Infinity .

Ajoutons deux documents avec de telles valeurs :

{ "_id" : 15, "data" : Infinity }
{ "_id" : 16, "data" : -Infinity }

Et arrondissons-les :

db.test.aggregate(
   [
     { $match: { _id: { $in: [ 15, 16 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            rounded: { $round: [ "$data", 2 ] }
          }
     }
   ]
)

Résultat :

{ "data" : Infinity, "rounded" : Infinity }
{ "data" : -Infinity, "rounded" : -Infinity }

Arrondir NaN

Arrondi NaN résultats en NaN .

db.test.aggregate(
   [
     { $match: { _id: { $in: [ 1, 2 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            rounded: { $round: [ "$data" * 2 ] }
          }
     }
   ]
)

Résultat :

{ "data" : 8.99, "rounded" : NaN }
{ "data" : 8.45, "rounded" : NaN }

Types non numériques

Si vous essayez d'arrondir une valeur dont le type de données est incorrect (c'est-à-dire qu'il ne s'agit pas d'un nombre entier, double, décimal ou long), une erreur est renvoyée.

Supposons que nous ajoutions le document suivant à notre collection :

{ "_id" : 17, "data" : "Thirty five" }

Et maintenant, nous essayons d'arrondir les data champ :

db.test.aggregate(
   [
     { $match: { _id: { $in: [ 17 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            rounded: { $round: [ "$data" ] }
          }
     }
   ]
)

Résultat :

uncaught exception: Error: command failed: {
	"ok" : 0,
	"errmsg" : "$round only supports numeric types, not string",
	"code" : 51081,
	"codeName" : "Location51081"
} : aggregate failed :
[email protected]/mongo/shell/utils.js:25:13
[email protected]/mongo/shell/assert.js:18:14
[email protected]/mongo/shell/assert.js:639:17
[email protected]/mongo/shell/assert.js:729:16
[email protected]/mongo/shell/db.js:266:5
[email protected]/mongo/shell/collection.js:1058:12
@(shell):1:1