MongoDB $mod

In MongoDB ist der $mod Aggregations-Pipeline-Operator dividiert eine Zahl durch eine andere und gibt den Rest zurück.

Um $mod zu verwenden , übergeben Sie die beiden Zahlen in einem Array. Der $mod Der Operator dividiert die erste Zahl durch die zweite Zahl und gibt den Rest zurück. Mit anderen Worten, die erste Zahl ist der Dividende und die zweite Zahl der Divisor.

Die Argumente können alle gültigen Ausdrücke sein, solange sie in Zahlen aufgelöst werden.

Beispiel

Angenommen, wir haben eine Sammlung namens data mit folgenden Dokumenten:

{ "_id" : 1, "a" : 10, "b" : 2 }
{ "_id" : 2, "a" : 10, "b" : 3 }
{ "_id" : 3, "a" : 10.5, "b" : 2 }

Wir können den $mod verwenden Operator innerhalb einer Aggregationspipeline, um den a zu teilen Feld durch das b Feld und geben den Rest zurück:

db.data.aggregate(
   [
     { $match: { _id: { $in: [ 1, 2, 3 ] } } },
     { $project: { 
        _id: 0,
        a: 1,
        b: 1,
        result: { $mod: [ "$a", "$b" ] } } 
         }
   ]
)

Ergebnis:

{ "a" : 10, "b" : 2, "result" : 0 }
{ "a" : 10, "b" : 3, "result" : 1 }
{ "a" : 10.5, "b" : 2, "result" : 0.5 }

Mit anderen Worten, wir erhalten a modulo b .

Wenn wir b erhalten wollen modulo a , müssten wir sie austauschen.

Beispiel:

db.data.aggregate(
   [
     { $match: { _id: { $in: [ 1, 2, 3 ] } } },
     { $project: { 
        _id: 0,
        a: 1,
        b: 1,
        result: { $mod: [ "$b", "$a" ] } } 
         }
   ]
)

Ergebnis:

{ "a" : 10, "b" : 2, "result" : 2 }
{ "a" : 10, "b" : 3, "result" : 3 }
{ "a" : 10.5, "b" : 2, "result" : 2 }

Negative Zahlen

Angenommen, wir fügen unserer Sammlung die folgenden Dokumente hinzu:

{ "_id" : 4, "a" : -10, "b" : 3 }
{ "_id" : 5, "a" : 10, "b" : -3 }
{ "_id" : 6, "a" : -10, "b" : -3 }

Dazu gehören negative Zahlen. Aber das ist kein Problem, denn negative Zahlen sind immer noch Zahlen, und wir können sicherlich den Modulo erhalten, wenn wir mit negativen Zahlen arbeiten.

Beispiel:

db.data.aggregate(
   [
     { $match: { _id: { $in: [ 4, 5, 6 ] } } },
     { $project: { 
        _id: 0,
        a: 1,
        b: 1,
        result: { $mod: [ "$a", "$b" ] } } 
         }
   ]
)

Ergebnis:

{ "a" : -10, "b" : 3, "result" : -1 }
{ "a" : 10, "b" : -3, "result" : 1 }
{ "a" : -10, "b" : -3, "result" : -1 }

Falscher Datentyp

Die für $mod bereitgestellten Argumente kann jeder gültige Ausdruck sein, solange er in Zahlen aufgelöst wird.

Angenommen, wir haben das folgende Dokument:

{ "_id" : 7, "a" : "Ten", "b" : 2 }

Und wir wenden $mod an zu diesem Dokument:

db.data.aggregate(
   [
     { $match: { _id: { $in: [ 7 ] } } },
     { $project: { 
        _id: 0,
        a: 1,
        b: 1,
        result: { $mod: [ "$a", "$b" ] } } 
         }
   ]
)

Ergebnis:

uncaught exception: Error: command failed: {
	"ok" : 0,
	"errmsg" : "$mod only supports numeric types, not string and double",
	"code" : 16611,
	"codeName" : "Location16611"
} : 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

Der Fehler besagt, dass $mod only supports numeric types .

Nullwerte

Bereitstellung von null für eines der Argumente gibt null zurück .

Angenommen, wir haben die folgenden Dokumente:

{ "_id" : 8, "a" : 10, "b" : null }
{ "_id" : 9, "a" : null, "b" : 10 }
{ "_id" : 10, "a" : null, "b" : null }

Und wir wenden $mod an zu diesen Dokumenten:

db.data.aggregate(
   [
     { $match: { _id: { $in: [ 8, 9, 10 ] } } },
     { $project: { 
        _id: 0,
        a: 1,
        b: 1,
        result: { $mod: [ "$a", "$b" ] } } 
         }
   ]
)

Ergebnis:

{ "a" : 10, "b" : null, "result" : null }
{ "a" : null, "b" : 10, "result" : null }
{ "a" : null, "b" : null, "result" : null }

Fehlende Felder

Fehlende Felder geben null zurück .

Angenommen, wir haben die folgenden Dokumente:

{ "_id" : 11, "a" : 10 }
{ "_id" : 12, "b" : 2 }
{ "_id" : 13 }

Wenden Sie $mod an :

db.data.aggregate(
   [
     { $match: { _id: { $in: [ 11, 12, 13 ] } } },
     { $project: { 
        _id: 0,
        a: 1,
        b: 1,
        result: { $mod: [ "$a", "$b" ] } } 
         }
   ]
)

Ergebnis:

{ "a" : 10, "result" : null }
{ "b" : 2, "result" : null }
{ "result" : null }

Fügen Sie Ihre eigene Nummer hinzu

Sie sind nicht unbedingt auf die Zahlen in den Dokumenten beschränkt. Sie können Ihre eigenen Zahlen verwenden, wenn Sie ein Feld durch einen festen Betrag dividieren müssen.

Beispiel:

db.data.aggregate(
   [
     { $match: { _id: { $in: [ 1, 2, 3 ] } } },
     { $project: { 
        _id: 0,
        a: 1,
        b: 1,
        result: { $mod: [ "$a", 5.2 ] } } 
         }
   ]
)

Ergebnis:

{ "a" : 10, "b" : 2, "result" : 4.8 }
{ "a" : 10, "b" : 3, "result" : 4.8 }
{ "a" : 10.5, "b" : 2, "result" : 0.09999999999999964 }