MongoDB $trunc

Dans MongoDB, le $trunc l'opérateur de pipeline d'agrégation tronque 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 tronquer le nombre. Pour ce faire, passez un deuxième argument. Le premier argument est le nombre à tronquer et le deuxième argument (facultatif) est le nombre de décimales à tronquer.

L'omission du deuxième argument tronque tous les chiffres à droite de la décimale et renvoie la valeur entière entière.

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 $trunc opérateur pour tronquer les valeurs dans les data champ :

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

Résultat :

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

Notez que $trunc n'arrondit pas les nombres comme $round Est-ce que. Le $trunc l'opérateur tronque simplement le nombre. Si nous avions appliqué $round à cette collection, les premier et quatrième documents auraient été arrondis à 9 et -9 respectivement.

Spécifiez une décimale

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

Exemple :

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

Résultat :

{ "data" : 8.99, "truncated" : 8.9 }
{ "data" : 8.45, "truncated" : 8.4 }
{ "data" : 8.451, "truncated" : 8.4 }
{ "data" : -8.99, "truncated" : -8.9 }
{ "data" : -8.45, "truncated" : -8.4 }
{ "data" : -8.451, "truncated" : -8.4 }
{ "data" : 8, "truncated" : 8 }
{ "data" : 0, "truncated" : 0 }

Encore une fois, cela tronque simplement le nombre. Si nous avions utilisé $round , il aurait arrondi certains de ces nombres.

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 tronqué à gauche de la décimale. Si la valeur absolue de l'entier négatif est supérieure au nombre de chiffres à gauche de la décimale, 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 $trunc à ces documents :

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

Résultat :

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

Décimale du zéro

Lorsque vous fournissez une décimale de 0 , le $trunc L'opérateur tronque tous les chiffres à droite de la décimale et renvoie la valeur entière entière.

Exemple :

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

Résultat :

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

Types de nombres

Le nombre à tronquer 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 $trunc aux data champ :

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

Résultat :

{
	"data" : NumberDecimal("128.4585"),
	"a" : NumberDecimal("1.2E+2"),
	"b" : NumberDecimal("128"),
	"c" : NumberDecimal("128.458"),
	"d" : NumberDecimal("128.4585"),
	"e" : NumberDecimal("128.45850")
}
{
	"data" : NumberDecimal("128.12345678912"),
	"a" : NumberDecimal("1.2E+2"),
	"b" : NumberDecimal("128"),
	"c" : NumberDecimal("128.123"),
	"d" : NumberDecimal("128.1234"),
	"e" : NumberDecimal("128.12345")
}

Tronquer à des 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,
            truncated: { $trunc: [ "$data", null ] }
          }
     }
   ]
)

Résultat :

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

Tronquer une valeur nulle

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

Supposons que nous ajoutions le document suivant à la collection :

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

Et nous utilisons $trunc pour tronquer la valeur nulle :

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

Résultat :

{ "data" : null, "truncated" : null }

Tronquer l'infini

Si le nombre à tronquer 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 tronquons-les :

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

Résultat :

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

Tronquer NaN

Tronquer NaN résultats en NaN .

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

Résultat :

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

Types non numériques

Si vous essayez de tronquer 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 de tronquer les data champ :

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

Résultat :

uncaught exception: Error: command failed: {
	"ok" : 0,
	"errmsg" : "$trunc 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