I MongoDB er $indexOfBytes aggregeringspipeline-operator søger i en streng efter en forekomst af en understreng og returnerer UTF-8-byteindekset for den første forekomst.
UTF-byteindekset er nul-baseret (dvs. det starter ved 0 ).
Syntaks
Syntaksen ser sådan ud:
{ $indexOfBytes:[ , , , ] } Hvor:
er strengen, der skal søges i. er den understreng, du vil finde i strengen. er et valgfrit argument, der angiver en startindeksposition for søgningen. Kan være et hvilket som helst gyldigt udtryk, der opløses til et ikke-negativt heltal. er et valgfrit argument, der angiver en afsluttende indeksposition for søgningen. Kan være et hvilket som helst gyldigt udtryk, der opløses til et ikke-negativt heltal.
Hvis den angivne værdi ikke findes, $indexOfBytes returnerer -1 .
Hvis der er flere forekomster af den angivne værdi, returneres kun den første.
Eksempel
Antag, at vi har en samling kaldet test med følgende dokumenter:
{ "_id" :1, "data" :"c 2021" }{ "_id" :2, "data" :"© 2021" }{ "_id" :3, "data" :"ไม้เมือง" }
Her er et eksempel på anvendelse af $indexOfBytes til disse dokumenter:
db.test.aggregate( [ { $match:{ _id:{ $in:[ 1, 2, 3 ] } } }, { $project:{ _id:0, data:1, result:{ $indexOfBytes:[ "$data", "2021" ] } } } ]) Resultat:
{ "data" :"c 2021", "result" :2 }{ "data" :"© 2021", "result" :3 }{ "data" :"ไม้เมือง", "result" :- 1 }
Vi kan se, at de to første dokumenter gav forskellige resultater, selvom understrengen ser ud til at være i samme position for hvert dokument. I det første dokument blev understrengen fundet ved byteindeksposition 2 , hvorimod det andet dokument havde det på 3 .
Grunden til dette er, at copyright-symbolet (© ) i det andet dokument fylder 2 bytes. c karakter (i det første dokument) bruger kun 1 byte. Mellemrumstegnet bruger også 1 byte.
Resultatet af $indexOfBytes er nul-baseret (indekset starter ved 0 ), og så ender vi med resultatet 2 og 3 hhv.
Med hensyn til det tredje dokument, blev understrengen slet ikke fundet, og derfor er resultatet -1 .
Her er et andet eksempel, bortset fra at denne gang søger vi efter et thailandsk tegn:
db.test.aggregate( [ { $match:{ _id:{ $in:[ 1, 2, 3 ] } } }, { $project:{ _id:0, data:1, result:{ $indexOfBytes:[ "$data", "เ" ] } } } ]) Resultat:
{ "data" :"c 2021", "result" :-1 }{ "data" :"© 2021", "result" :-1 }{ "data" :"ไม้เมือง", "result" :9 }
I dette tilfælde søgte vi efter et tegn, der vises på den tredje position i det tredje dokument, og dets UTF-8 byteindeks kommer tilbage som 9 .
Dette skyldes, at hvert tegn i dette tilfælde bruger 3 bytes. Men det andet tegn har et diakritisk tegn, som også er 3 bytes. Derfor bruger de to første tegn (inklusive det diakritiske tegn) 9 bytes. Givet den nul-baserede indeksering varierer deres UTF-8 byte-indekser fra 0 til 8 . Det betyder, at det tredje tegn starter ved position 9 .
Se MongoDB $strLenBytes for et eksempel, der returnerer antallet af bytes for hvert tegn i denne særlige streng.
Angiv en startposition
Du kan angive et tredje argument for at angive en startindeksposition for søgningen.
Antag, at vi har følgende dokument:
{ "_id" :4, "data" :"ABC XYZ ABC" }
Her er et eksempel på anvendelse af $indexOfBytes med en startposition:
db.test.aggregate( [ { $match:{ _id:{ $in:[ 4 ] } } }, { $project:{ _id:0, data:1, result:{ $indexOfBytes:[ "$data", "ABC", 1 ] } } } ]) Resultat:
{ "data" :"ABC XYZ ABC", "result" :8 }
I dette tilfælde blev den anden forekomst af understrengen returneret. Dette skyldes, at vi startede søgningen ved position 1 , og den første instans af understrengen starter ved position 0 (før startpositionen for søgningen).
Hvis startpositionen er et tal større end strengens byte-længde eller større end slutpositionen, $indexOfBytes returnerer -1 .
Hvis det er et negativt tal, $indexOfBytes returnerer en fejl.
Angiv en slutposition
Du kan også angive et fjerde argument for at angive den afsluttende indeksposition for søgningen.
Hvis du giver dette argument, skal du også angive en startposition. Hvis dette ikke gøres, vil dette argument blive fortolket som udgangspunktet.
Eksempel:
db.test.aggregate( [ { $match:{ _id:{ $in:[ 4 ] } } }, { $project:{ _id:0, data:1, result:{ $indexOfBytes:[ "$data", "XYZ", 0, 5 ] } } } ]) Resultat:
{ "data" :"ABC XYZ ABC", "result" :-1 }
Resultatet er -1 hvilket betyder, at understrengen ikke blev fundet. Det er fordi vi startede vores søgning på position 0 og afsluttede det på position 5 , derfor fanger understrengen ikke.
Her er, hvad der sker, hvis vi øger den afsluttende indeksposition:
db.test.aggregate( [ { $match:{ _id:{ $in:[ 4 ] } } }, { $project:{ _id:0, data:1, result:{ $indexOfBytes:[ "$data", "XYZ", 0, 7 ] } } } ]) Resultat:
{ "data" :"ABC XYZ ABC", "result" :4 } Denne gang blev værdien inkluderet, og dens indeksposition returneret.
Hvis slutpositionen er et tal mindre end startpositionen, $indexOfBytes returnerer -1 .
Hvis det er et negativt tal, $indexOfBytes returnerer en fejl.
Manglende felter
Hvis feltet ikke er i dokumentet, $indexOfBytes returnerer null .
Antag, at vi har følgende dokument:
{ "_id" :5 }
Her er, hvad der sker, når vi anvender $indexOfBytes :
db.test.aggregate( [ { $match:{ _id:{ $in:[ 5 ] } } }, { $project:{ _id:0, data:1, result:{ $indexOfBytes:[ "$data", "XYZ" ] } } } ]) Resultat:
{ "result" :null } Nul-værdier
Hvis det første argument er null , $indexOfBytes returnerer null .
Antag, at vi har følgende dokument:
{ "_id" :6, "data" :null }
Her er, hvad der sker, når vi anvender $indexOfBytes :
db.test.aggregate( [ { $match:{ _id:{ $in:[ 6 ] } } }, { $project:{ _id:0, data:1, result:{ $indexOfBytes:[ "$data", "XYZ" ] } } } ]) Resultat:
{ "data" :null, "result" :null }
Men når det andet argument (dvs. understrengen) er null , returneres en fejl:
db.test.aggregate( [ { $match:{ _id:{ $in:[ 1 ] } } }, { $project:{ _id:0, data:1, result:{ $indexOfBytes:[ "$data", null ] } } } ]) Resultat:
ufanget undtagelse:Fejl:kommando mislykkedes:{ "ok" :0, "errmsg" :"$indexOfBytes kræver en streng som det andet argument, fundet:null", "code" :40092, "codeName" :"Location40092 "} :aggregat mislykkedes :[email protected]/mongo/shell/utils.js:25:[email protected]/mongo/shell/assert.js:18:[email protected]/mongo/shell/assert. js:639:[email protected]/mongo/shell/assert.js:729:[email protected]/mongo/shell/db.js:266:[email protected]/mongo/shell/collection.js:1058:12@(shell):1:1 Forkert datatype
Hvis det første argument er den forkerte datatype (dvs. det ikke løses til en streng), $indexOfBytes returnerer en fejl.
Antag, at vi har følgende dokument:
{ "_id" :7, "data" :123 }
Her er, hvad der sker, når vi anvender $indexOfBytes til det dokument:
db.test.aggregate( [ { $match:{ _id:{ $in:[ 7 ] } } }, { $project:{ _id:0, data:1, result:{ $indexOfBytes:[ "$data", "XYZ" ] } } } ]) Resultat:
ufanget undtagelse:Fejl:kommando mislykkedes:{ "ok" :0, "errmsg" :"$indexOfBytes kræver en streng som det første argument, fundet:double", "code" :40091, "codeName" :"Location40091 "} :aggregat mislykkedes :[email protected]/mongo/shell/utils.js:25:[email protected]/mongo/shell/assert.js:18:[email protected]/mongo/shell/assert. js:639:[email protected]/mongo/shell/assert.js:729:[email protected]/mongo/shell/db.js:266:[email protected]/mongo/shell/collection.js:1058:12@(shell):1:1
Som fejlmeddelelsen siger, kræver $indexOfBytes en streng som det første argument .