В MongoDB, $indexOfBytes Операторът на тръбопровода за агрегиране търси низ за среща на подниз и връща UTF-8 байтов индекс на първото появяване.
Индексът на UTF байтовете е базиран на нула (т.е. започва от 0 ).
Синтаксис
Синтаксисът е така:
{ $indexOfBytes: [ <string expression>, <substring expression>, <start>, <end> ] }Къде:
<string expression>е низът за търсене.<substring expression>е поднизът, който искате да намерите в низа.<start>е незадължителен аргумент, който определя начална позиция на индекса за търсене. Може да бъде всеки валиден израз, който се разрешава до неотрицателно цяло число.<end>е незадължителен аргумент, който определя крайна индексна позиция за търсенето. Може да бъде всеки валиден израз, който се разрешава до неотрицателно цяло число.
Ако посочената стойност не е намерена, $indexOfBytes връща -1 .
Ако има няколко екземпляра на посочената стойност, се връща само първият.
Пример
Да предположим, че имаме колекция, наречена test със следните документи:
{ "_id" : 1, "data" : "c 2021" }
{ "_id" : 2, "data" : "© 2021" }
{ "_id" : 3, "data" : "ไม้เมือง" }
Ето пример за прилагане на $indexOfBytes към тези документи:
db.test.aggregate(
[
{ $match: { _id: { $in: [ 1, 2, 3 ] } } },
{
$project:
{
_id: 0,
data: 1,
result: { $indexOfBytes: [ "$data", "2021" ] }
}
}
]
)Резултат:
{ "data" : "c 2021", "result" : 2 }
{ "data" : "© 2021", "result" : 3 }
{ "data" : "ไม้เมือง", "result" : -1 }
Можем да видим, че първите два документа са дали различни резултати, въпреки че поднизът изглежда е в една и съща позиция за всеки документ. В първия документ поднизът беше намерен в позиция на байтов индекс 2 , докато вторият документ го имаше на 3 .
Причината за това е, че символът за авторско право (© ) във втория документ заема 2 байта. c символ (в първия документ) използва само 1 байт. Знакът за интервал също използва 1 байт.
Резултатът от $indexOfBytes е базиран на нула (индексът започва от 0 ), и така в крайна сметка получаваме резултат от 2 и 3 съответно.
По отношение на третия документ поднизът изобщо не беше намерен и така резултатът е -1 .
Ето още един пример, освен че този път търсим тайландски знак:
db.test.aggregate(
[
{ $match: { _id: { $in: [ 1, 2, 3 ] } } },
{
$project:
{
_id: 0,
data: 1,
result: { $indexOfBytes: [ "$data", "เ" ] }
}
}
]
)Резултат:
{ "data" : "c 2021", "result" : -1 }
{ "data" : "© 2021", "result" : -1 }
{ "data" : "ไม้เมือง", "result" : 9 }
В този случай потърсихме знак, който се появява на трета позиция в третия документ и неговият UTF-8 байтов индекс се връща като 9 .
Това е така, защото в този случай всеки знак използва 3 байта. Но вторият знак има диакритичен знак, който също е 3 байта. Следователно, първите два знака (включително диакритиката) използват 9 байта. Като се има предвид индексирането на базата на нула, техните UTF-8 байтови индекси варират от 0 до 8 . Това означава, че третият знак започва от позиция 9 .
Вижте MongoDB $strLenBytes за пример, който връща броя на байтовете за всеки знак в този конкретен низ.
Посочете начална позиция
Можете да предоставите трети аргумент, за да посочите начална позиция на индекса за търсене.
Да предположим, че имаме следния документ:
{ "_id" : 4, "data" : "ABC XYZ ABC" }
Ето пример за прилагане на $indexOfBytes с изходна позиция:
db.test.aggregate(
[
{ $match: { _id: { $in: [ 4 ] } } },
{
$project:
{
_id: 0,
data: 1,
result: { $indexOfBytes: [ "$data", "ABC", 1 ] }
}
}
]
)Резултат:
{ "data" : "ABC XYZ ABC", "result" : 8 }
В този случай вторият екземпляр на подниз беше върнат. Това е така, защото започнахме търсенето на позиция 1 , а първият екземпляр на подниза започва от позиция 0 (преди началната позиция за търсене).
Ако началната позиция е число, по-голямо от дължината на байта на низа или по-голямо от крайната позиция, $indexOfBytes връща -1 .
Ако е отрицателно число, $indexOfBytes връща грешка.
Посочете крайна позиция
Можете също да предоставите четвърти аргумент, за да посочите крайната позиция на индекса за търсене.
Ако предоставите този аргумент, трябва да посочите и начална позиция. Ако не го направите, този аргумент ще бъде интерпретиран като отправна точка.
Пример:
db.test.aggregate(
[
{ $match: { _id: { $in: [ 4 ] } } },
{
$project:
{
_id: 0,
data: 1,
result: { $indexOfBytes: [ "$data", "XYZ", 0, 5 ] }
}
}
]
)Резултат:
{ "data" : "ABC XYZ ABC", "result" : -1 }
Резултатът е -1 което означава, че поднизът не е намерен. Това е така, защото започнахме търсенето на позиция 0 и го завърши на позиция 5 , следователно не улавя подниз.
Ето какво се случва, ако увеличим позицията на крайния индекс:
db.test.aggregate(
[
{ $match: { _id: { $in: [ 4 ] } } },
{
$project:
{
_id: 0,
data: 1,
result: { $indexOfBytes: [ "$data", "XYZ", 0, 7 ] }
}
}
]
)Резултат:
{ "data" : "ABC XYZ ABC", "result" : 4 } Този път стойността беше включена и нейната индексна позиция беше върната.
Ако крайната позиция е число, по-малко от началната позиция, $indexOfBytes връща -1 .
Ако е отрицателно число, $indexOfBytes връща грешка.
Липсващи полета
Ако полето не е в документа, $indexOfBytes връща null .
Да предположим, че имаме следния документ:
{ "_id" : 5 }
Ето какво се случва, когато приложим $indexOfBytes :
db.test.aggregate(
[
{ $match: { _id: { $in: [ 5 ] } } },
{
$project:
{
_id: 0,
data: 1,
result: { $indexOfBytes: [ "$data", "XYZ" ] }
}
}
]
)Резултат:
{ "result" : null } Нулеви стойности
Ако първият аргумент е null , $indexOfBytes връща null .
Да предположим, че имаме следния документ:
{ "_id" : 6, "data" : null }
Ето какво се случва, когато приложим $indexOfBytes :
db.test.aggregate(
[
{ $match: { _id: { $in: [ 6 ] } } },
{
$project:
{
_id: 0,
data: 1,
result: { $indexOfBytes: [ "$data", "XYZ" ] }
}
}
]
)Резултат:
{ "data" : null, "result" : null }
Въпреки това, когато вторият аргумент (т.е. поднизът) е null , се връща грешка:
db.test.aggregate(
[
{ $match: { _id: { $in: [ 1 ] } } },
{
$project:
{
_id: 0,
data: 1,
result: { $indexOfBytes: [ "$data", null ] }
}
}
]
)Резултат:
uncaught exception: Error: command failed: {
"ok" : 0,
"errmsg" : "$indexOfBytes requires a string as the second argument, found: null",
"code" : 40092,
"codeName" : "Location40092"
} : 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 Грешен тип данни
Ако първият аргумент е грешен тип данни (т.е. не се разрешава до низ), $indexOfBytes връща грешка.
Да предположим, че имаме следния документ:
{ "_id" : 7, "data" : 123 }
Ето какво се случва, когато приложим $indexOfBytes към този документ:
db.test.aggregate(
[
{ $match: { _id: { $in: [ 7 ] } } },
{
$project:
{
_id: 0,
data: 1,
result: { $indexOfBytes: [ "$data", "XYZ" ] }
}
}
]
)Резултат:
uncaught exception: Error: command failed: {
"ok" : 0,
"errmsg" : "$indexOfBytes requires a string as the first argument, found: double",
"code" : 40091,
"codeName" : "Location40091"
} : 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
Както се казва в съобщението за грешка, $indexOfBytes requires a string as the first argument .
