MongoDB $indexOfArray

In MongoDB der $indexOfArray Der Aggregations-Pipeline-Operator durchsucht ein Array nach einem Vorkommen eines bestimmten Werts und gibt den Array-Index des ersten Vorkommens zurück.

Syntax

Die Syntax sieht so aus:

{ $indexOfArray: [ <array expression>, <search expression>, <start>, <end> ] }

Wo:

• <array expression> ist das zu durchsuchende Array.
• <search expression> ist der Wert, den Sie im Array finden möchten.
• <start> ist ein optionales Argument, das einen Startpunkt angibt, nach dem im Array gesucht werden soll. Kann ein beliebiger gültiger Ausdruck sein, der sich in eine nicht negative ganze Zahl auflösen lässt.
• <end> ist ein optionales Argument, das eine Endindexposition für die Suche angibt. Kann ein beliebiger gültiger Ausdruck sein, der sich in eine nicht negative ganze Zahl auflösen lässt.

In MongoDB sind Arrays nullbasiert, sodass die Indexzählung bei null beginnt (0 ).

Wenn der angegebene Wert nicht gefunden wird, $indexOfArray gibt -1 zurück .

Wenn mehrere Instanzen des angegebenen Werts vorhanden sind, wird nur die erste zurückgegeben.

Beispiel

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

{ "_id" : 1, "prod" : "Bat", "sizes" : [ "XS", "M", "L" ] }
{ "_id" : 2, "prod" : "Hat", "sizes" : [ "XS", "S", "L", "XL" ] }
{ "_id" : 3, "prod" : "Cap", "sizes" : [ "XXS", "XS", "M", "XL" ] }
{ "_id" : 4, "prod" : "Zap", "sizes" : [ 10, 12, 15 ] }
{ "_id" : 5, "prod" : "Tap", "sizes" : [ 15, 16, 20 ] }

Hier ist ein Beispiel für die Anwendung von $indexOfArray zu diesen Dokumenten:

db.products.aggregate(
   [
     { $match: { _id: { $in: [ 1, 2, 3, 4, 5 ] } } },
     {
       $project:
          {
            _id: 0,
            sizes: 1,
            result: { $indexOfArray: [ "$sizes", "XS" ] }
          }
     }
   ]
)

Ergebnis:

{ "sizes" : [ "XS", "M", "L" ], "result" : 0 }
{ "sizes" : [ "XS", "S", "L", "XL" ], "result" : 0 }
{ "sizes" : [ "XXS", "XS", "M", "XL" ], "result" : 1 }
{ "sizes" : [ 10, 12, 15 ], "result" : -1 }
{ "sizes" : [ 15, 16, 20 ], "result" : -1 }

In den ersten beiden Dokumenten wurde der Suchwert an Position 0 gefunden (Arrays sind nullbasiert).

Im dritten Dokument wurde es an Position 1 gefunden . Beachten Sie, dass die Suche nach einer exakten Übereinstimmung erfolgte. Position 0 wurde nicht zurückgegeben , obwohl der Wert an Position 0 enthält den Suchwert (also XXS enthält XS ).

Der Suchwert wurde in den letzten beiden Dokumenten nicht gefunden, also -1 wurde zurückgegeben.

Hier ist ein weiteres Beispiel, außer dass wir dieses Mal nach einem numerischen Wert suchen:

db.products.aggregate(
   [
     { $match: { _id: { $in: [ 1, 2, 3, 4, 5 ] } } },
     {
       $project:
          {
            _id: 0,
            sizes: 1,
            result: { $indexOfArray: [ "$sizes", 15 ] }
          }
     }
   ]
)

Ergebnis:

{ "sizes" : [ "XS", "M", "L" ], "result" : -1 }
{ "sizes" : [ "XS", "S", "L", "XL" ], "result" : -1 }
{ "sizes" : [ "XXS", "XS", "M", "XL" ], "result" : -1 }
{ "sizes" : [ 10, 12, 15 ], "result" : 2 }
{ "sizes" : [ 15, 16, 20 ], "result" : 0 }

Geben Sie eine Startposition an

Sie können ein drittes Argument angeben, um eine Startindexposition für die Suche anzugeben.

Beispiel:

db.products.aggregate(
   [
     { $match: { _id: { $in: [ 4, 5 ] } } },
     {
       $project:
          {
            _id: 0,
            sizes: 1,
            result: { $indexOfArray: [ "$sizes", 15, 1 ] }
          }
     }
   ]
)

Ergebnis:

{ "sizes" : [ 10, 12, 15 ], "result" : 2 }
{ "sizes" : [ 15, 16, 20 ], "result" : -1 }

In diesem Fall wurde der Suchausdruck im zweiten Dokument (Dokument 5) nicht gefunden. Das liegt daran, dass wir die Suche an Position 1 gestartet haben , und obwohl dieses Dokument den Suchausdruck enthält, befindet es sich an Position 0 (vor der Startposition für die Suche).

Geben Sie eine Endposition an

Sie können auch ein viertes Argument angeben, um die letzte Indexposition für die Suche anzugeben.

Wenn Sie dieses Argument angeben, müssen Sie auch eine Ausgangsposition angeben. Andernfalls wird dieses Argument als Ausgangspunkt interpretiert.

Beispiel:

db.products.aggregate(
   [
     { $match: { _id: { $in: [ 1, 2, 3 ] } } },
     {
       $project:
          {
            _id: 0,
            sizes: 1,
            result: { $indexOfArray: [ "$sizes", "XS", 0, 1 ] }
          }
     }
   ]
)

Ergebnis:

{ "sizes" : [ "XS", "M", "L" ], "result" : 0 }
{ "sizes" : [ "XS", "S", "L", "XL" ], "result" : 0 }
{ "sizes" : [ "XXS", "XS", "M", "XL" ], "result" : -1 }

Das dritte Dokument gab -1 zurück was bedeutet, dass der Suchausdruck nicht gefunden wurde.

Folgendes passiert, wenn wir die Endindexposition um 1 erhöhen:

db.products.aggregate(
   [
     { $match: { _id: { $in: [ 1, 2, 3 ] } } },
     {
       $project:
          {
            _id: 0,
            sizes: 1,
            result: { $indexOfArray: [ "$sizes", "XS", 0, 2 ] }
          }
     }
   ]
)

Ergebnis:

{ "sizes" : [ "XS", "M", "L" ], "result" : 0 }
{ "sizes" : [ "XS", "S", "L", "XL" ], "result" : 0 }
{ "sizes" : [ "XXS", "XS", "M", "XL" ], "result" : 1 }

Dieses Mal wurde der Wert eingeschlossen und seine Indexposition zurückgegeben.

Leere Arrays

Das Durchsuchen eines leeren Arrays gibt -1 zurück .

db.products.aggregate(
   [
     { $match: { _id: { $in: [ 6 ] } } },
     {
       $project:
          {
            _id: 0,
            sizes: 1,
            result: { $indexOfArray: [ "$sizes", "XS" ] }
          }
     }
   ]
)

Ergebnis:

{ "sizes" : [ ], "result" : -1 }

Fehlende Felder

Wenn sich das Feld nicht im Dokument befindet, $indexOfArray gibt null zurück .

Angenommen, wir haben das folgende Dokument:

{ "_id" : 8, "prod" : "Map" }

Folgendes passiert, wenn wir $indexOfArray anwenden :

db.products.aggregate(
   [
     { $match: { _id: { $in: [ 8 ] } } },
     {
       $project:
          {
            _id: 0,
            sizes: 1,
            result: { $indexOfArray: [ "$sizes", "XS" ] }
          }
     }
   ]
)

Ergebnis:

{ "result" : null }

Nullwerte

Wenn der Array-Ausdruck null ist (anstelle eines Arrays), $indexOfArray gibt null zurück .

Angenommen, wir haben das folgende Dokument:

{ "_id" : 7, "prod" : "Lap", "sizes" : null }

Folgendes passiert, wenn wir $indexOfArray anwenden :

db.products.aggregate(
   [
     { $match: { _id: { $in: [ 7 ] } } },
     {
       $project:
          {
            _id: 0,
            sizes: 1,
            result: { $indexOfArray: [ "$sizes", "XS" ] }
          }
     }
   ]
)

Ergebnis:

{ "sizes" : null, "result" : null }

Wenn der Suchausdruck jedoch null ist , ist das Ergebnis -1 , es sei denn, der Array-Ausdruck ist auch null oder sein Feld fehlt:

db.products.aggregate(
   [
     { $match: { _id: { $in: [ 1, 2, 3, 4, 5, 6, 7, 8 ] } } },
     {
       $project:
          {
            _id: 0,
            sizes: 1,
            result: { $indexOfArray: [ "$sizes", null ] }
          }
     }
   ]
)

Ergebnis:

{ "sizes" : [ "XS", "M", "L" ], "result" : -1 }
{ "sizes" : [ "XS", "S", "L", "XL" ], "result" : -1 }
{ "sizes" : [ "XXS", "XS", "M", "XL" ], "result" : -1 }
{ "sizes" : [ 10, 12, 15 ], "result" : -1 }
{ "sizes" : [ 15, 16, 20 ], "result" : -1 }
{ "sizes" : [ ], "result" : -1 }
{ "sizes" : null, "result" : null }
{ "result" : null }

Falscher Datentyp

Wenn der Array-Ausdruck den falschen Datentyp hat, $indexOfArray gibt einen Fehler zurück.

Angenommen, wir haben das folgende Dokument:

{ "_id" : 9, "prod" : "Box", "sizes" : "XXL" }

Folgendes passiert, wenn wir $indexOfArray anwenden zu diesem Dokument:

db.products.aggregate(
   [
     { $match: { _id: { $in: [ 9 ] } } },
     {
       $project:
          {
            _id: 0,
            sizes: 1,
            result: { $indexOfArray: [ "$sizes", "XXL" ] }
          }
     }
   ]
)

Ergebnis:

uncaught exception: Error: command failed: {
	"ok" : 0,
	"errmsg" : "$indexOfArray requires an array as a first argument, found: string",
	"code" : 40090,
	"codeName" : "Location40090"
} : 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

Wie die Fehlermeldung besagt, benötigt $indexOfArray requires an array as a first argument .