MongoDB $indexOfCP

I MongoDB, $indexOfCP aggregeringspipeline-operatören söker i en sträng efter en förekomst av en delsträng och returnerar UTF-kodpunktsindexet för den första förekomsten.

UTF-kodpunktsindexet är nollbaserat (dvs. det börjar vid 0 ).

Syntax

Syntaxen ser ut så här:

{ $indexOfCP: [ <string expression>, <substring expression>, <start>, <end> ] }

Var:

är strängen att söka.


  är den delsträng du vill hitta i strängen.
  är ett valfritt argument som anger en startindexposition för sökningen. Kan vara vilket giltigt uttryck som helst som löser sig till ett icke-negativt heltal.

  är ett valfritt argument som anger en slutindexposition för sökningen. Kan vara vilket giltigt uttryck som helst som löser sig till ett icke-negativt heltal.


 
 Om det angivna värdet inte hittas, $indexOfCP returnerar -1 .
 
 Om det finns flera instanser av det angivna värdet, returneras bara den första.
 Exempel
 
 Anta att vi har en samling som heter test med följande dokument:
 { "_id" : 1, "data" : "c 2021" }
{ "_id" : 2, "data" : "© 2021" }
{ "_id" : 3, "data" : "ไม้เมือง" }
 
 Här är ett exempel på hur du använder $indexOfCP till dessa dokument:
 db.test.aggregate(
   [
     { $match: { _id: { $in: [ 1, 2, 3 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            result: { $indexOfCP: [ "$data", "2021" ] }
          }
     }
   ]
)
 
 Resultat:
 { "data" : "c 2021", "result" : 2 }
{ "data" : "© 2021", "result" : 2 }
{ "data" : "ไม้เมือง", "result" : -1 }
 
 I de två första dokumenten hittades understrängen vid UTF-kodpunktsindexposition 2 . Givet $indexOfCP resultaten är nollbaserade (indexet börjar på 0 ) position 2 representerar den tredje kodpunkten. 
 
 Detta är ett annat resultat än vad vi skulle få om vi använder $indexOfBytes , eftersom copyright-symbolen (© ) i det andra dokumentet tar upp 2 byte. Men den använder bara en kodpunkt, vilket är samma som bokstaven c använder.
 
 När det gäller det tredje dokumentet hittades inte delsträngen alls, så resultatet är -1 .
 
 Här är ett annat exempel, förutom den här gången söker vi efter ett thailändskt tecken:
 db.test.aggregate(
   [
     { $match: { _id: { $in: [ 1, 2, 3 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            result: { $indexOfCP: [ "$data", "เ" ] }
          }
     }
   ]
)
 
 Resultat:
 { "data" : "c 2021", "result" : -1 }
{ "data" : "© 2021", "result" : -1 }
{ "data" : "ไม้เมือง", "result" : 3 }
 
 I det här fallet sökte vi efter ett tecken som finns i det tredje dokumentet, och dess UTF-8 kodpunktsindex kommer tillbaka som 3 . Givet $indexOfCP resultaten är nollbaserade, detta betyder att det är den fjärde kodpunkten. 
 
 Detta beror på att det andra tecknet har ett diakritiskt tecken, vilket också är en kodpunkt. Därför är det första tecknet en kodpunkt och det andra tecknet är två kodpunkter (inklusive diakritiken), vilket är lika med tre. Det betyder att vårt tecken börjar på fjärde positionen (som är kodpunktsnummer 3). , på grund av indexantal som börjar på 0 ).
 
 Se MongoDB $strLenCP för ett exempel som returnerar antalet kodpunkter för varje tecken i just den här strängen. Och se MongoDB $strLenBytes för att se antalet byte i samma sträng.
 Ange en startposition
 
 Du kan ange ett tredje argument för att ange en startindexposition för sökningen.
 
 Anta att vi har följande dokument:
 { "_id" : 4, "data" : "ABC XYZ ABC" }
 
 Här är ett exempel på hur du använder $indexOfCP med en startposition:
 db.test.aggregate(
   [
     { $match: { _id: { $in: [ 4 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            result: { $indexOfCP: [ "$data", "ABC", 1 ] }
          }
     }
   ]
)
 
 Resultat:
 { "data" : "ABC XYZ ABC", "result" : 8 }
 
 I det här fallet returnerades den andra instansen av delsträngen. Detta beror på att vi startade sökningen vid position 1 , och den första instansen av delsträngen börjar vid position 0 (före startpositionen för sökningen).
 
 Om startpositionen är ett nummer större än strängen eller större än slutpositionen, $indexOfCP returnerar -1 .
 
 Om det är ett negativt tal, $indexOfCP returnerar ett fel.
 Ange en slutposition
 
 Du kan också ange ett fjärde argument för att ange slutindexpositionen för sökningen.
 
 Om du ger detta argument måste du också ange en utgångsposition. Underlåtenhet att göra det kommer att resultera i att detta argument tolkas som utgångspunkten.
 
 Exempel:
 db.test.aggregate(
   [
     { $match: { _id: { $in: [ 4 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            result: { $indexOfCP: [ "$data", "XYZ", 0, 3 ] }
          }
     }
   ]
)
 
 Resultat:
 { "data" : "ABC XYZ ABC", "result" : -1 }
 
 Resultatet är -1 vilket betyder att delsträngen inte hittades. Det beror på att vi började vår sökning på position 0 och avslutade den på position 3 , därför inte fånga understrängen.
 
 Så här händer om vi ökar slutindexpositionen:
 db.test.aggregate(
   [
     { $match: { _id: { $in: [ 4 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            result: { $indexOfCP: [ "$data", "XYZ", 0, 5 ] }
          }
     }
   ]
)
 
 Resultat:
 { "data" : "ABC XYZ ABC", "result" : 4 }
 
 Den här gången inkluderades värdet och dess indexposition returnerades.
 
 Om slutpositionen är ett nummer mindre än startpositionen, $indexOfCP returnerar -1 .
 
 Om det är ett negativt tal, $indexOfCP returnerar ett fel.
 Fält saknas
 
 Om fältet inte finns i dokumentet, $indexOfCP returnerar null .
 
 Anta att vi har följande dokument:
 { "_id" : 5 }
 
 Det här är vad som händer när vi använder $indexOfCP :
 db.test.aggregate(
   [
     { $match: { _id: { $in: [ 5 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            result: { $indexOfCP: [ "$data", "XYZ" ] }
          }
     }
   ]
)
 
 Resultat:
 { "result" : null }
 Nullvärden
 
 Om det första argumentet är null , $indexOfCP returnerar null .
 
 Anta att vi har följande dokument:
 { "_id" : 6, "data" : null }
 
 Det här är vad som händer när vi använder $indexOfCP :
 db.test.aggregate(
   [
     { $match: { _id: { $in: [ 6 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            result: { $indexOfCP: [ "$data", "XYZ" ] }
          }
     }
   ]
)
 
 Resultat:
 { "data" : null, "result" : null }
 
 Men när det andra argumentet (dvs understrängen) är null , returneras ett fel:
 db.test.aggregate(
   [
     { $match: { _id: { $in: [ 1 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            result: { $indexOfCP: [ "$data", null ] }
          }
     }
   ]
)
 
 Resultat:
 uncaught exception: Error: command failed: {
	"ok" : 0,
	"errmsg" : "$indexOfCP requires a string as the second argument, found: null",
	"code" : 40094,
	"codeName" : "Location40094"
} : 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
 Fel datatyp
 
 Om det första argumentet är fel datatyp (dvs. det löser sig inte till en sträng), $indexOfCP returnerar ett fel.
 
 Anta att vi har följande dokument:
 { "_id" : 7, "data" : 123 }
 
 Det här är vad som händer när vi använder $indexOfCP till det dokumentet:
 db.test.aggregate(
   [
     { $match: { _id: { $in: [ 7 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            result: { $indexOfCP: [ "$data", "XYZ" ] }
          }
     }
   ]
)
 
 Resultat:
 uncaught exception: Error: command failed: {
	"ok" : 0,
	"errmsg" : "$indexOfCP requires a string as the first argument, found: double",
	"code" : 40093,
	"codeName" : "Location40093"
} : 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
 
 Som felmeddelandet säger kräver $indexOfCP en sträng som första argument .