MongoDB $trunc

In MongoDB, il $trunc l'operatore della pipeline di aggregazione tronca un numero a un intero intero oa una cifra decimale specificata.

Hai la possibilità di specificare per quante cifre decimali troncare il numero. Per fare ciò, passa un secondo argomento. Il primo argomento è il numero da troncare e il secondo argomento (facoltativo) è il numero di cifre decimali in cui troncarlo.

L'omissione del secondo argomento tronca tutte le cifre a destra del decimale e restituisce l'intero valore intero.

Esempio

Supponiamo di avere una collezione chiamata test con i seguenti documenti:

{ "_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 }

Possiamo usare il $trunc per troncare i valori nei data campo:

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

Risultato:

{ "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 }

Nota che $trunc non arrotonda numeri come $round fa. Il $trunc l'operatore tronca semplicemente il numero. Se avessimo applicato $round a questa raccolta il primo e il quarto documento sarebbero stati arrotondati a 9 e -9 rispettivamente.

Specifica un punto decimale

Abbiamo la possibilità di utilizzare un secondo argomento per specificare a quante cifre decimali troncare il numero.

Esempio:

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

Risultato:

{ "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 }

Ancora una volta, questo tronca semplicemente il numero. Se avessimo usato $round , avrebbe arrotondato alcuni di questi numeri.

Punti decimali negativi

Il secondo argomento può essere qualsiasi espressione valida che si risolve in un numero intero compreso tra -20 e 100, esclusivo. Pertanto, è possibile specificare una cifra decimale negativa.

Quando si esegue questa operazione, il numero viene troncato a sinistra della cifra decimale. Se il valore assoluto dell'intero negativo è maggiore del numero di cifre a sinistra del decimale, il risultato è 0 .

Supponiamo di aggiungere i seguenti documenti alla nostra raccolta:

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

Ecco un esempio di utilizzo di vari decimali negativi quando si applica $trunc a quei documenti:

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()

Risultato:

{
	"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
}

Punto decimale di zero

Quando fornisci una cifra decimale di 0 , il $trunc tronca tutte le cifre a destra del decimale e restituisce l'intero valore intero.

Esempio:

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

Risultato:

{ "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 }

Tipi di numeri

Il numero da troncare può essere qualsiasi espressione valida che si risolve in un numero intero, doppio, decimale o lungo. Il valore restituito corrisponde al tipo di dati del valore di input.

Quindi se aggiungiamo i seguenti documenti alla nostra collezione:

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

Possiamo applicare $trunc ai data campo:

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()

Risultato:

{
	"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")
}

Tronco in posizioni decimali nulle

Se il secondo argomento è null , il risultato è null .

Esempio:

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

Risultato:

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

Tronco di un valore nullo

Se il valore da troncare è null , il risultato è null .

Supponiamo di aggiungere il seguente documento alla raccolta:

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

E usiamo $trunc per troncare il valore nullo:

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

Risultato:

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

Trontare l'infinito

Se il numero da troncare è Infinity , il risultato è Infinity . Allo stesso modo, se è -Infinity , il risultato è -Infinity .

Aggiungiamo due documenti con tali valori:

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

E tronchiamoli:

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

Risultato:

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

Troncare NaN

Troncando NaN risulta in NaN .

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

Risultato:

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

Tipi non numerici

Se provi a troncare un valore che è del tipo di dati errato (cioè non è un intero, doppio, decimale o lungo), viene restituito un errore.

Supponiamo di aggiungere il seguente documento alla nostra raccolta:

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

E ora proviamo a troncare i data campo:

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

Risultato:

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