En MongoDB, el $substrCP El operador de canalización de agregación devuelve la subcadena de una cadena, en función de los índices de puntos de código UTF-8 especificados.
Sintaxis
La sintaxis es así:
{ $substrCP: [ <string expression>, <code point index>, <code point count> ] }donde:
<string expression>es la cadena. Puede ser cualquier expresión válida siempre que se resuelva en una cadena.<code point index>es donde comenzar la subcadena. Puede ser cualquier expresión válida siempre que se resuelva en un número entero no negativo.<code point count>es por cuántos puntos de código debe continuar la subcadena. Puede ser cualquier expresión válida siempre que se resuelva en un número entero no negativo o un número que se pueda representar como un número entero.
Ejemplo
Imagina que tenemos una colección llamada tests con el siguiente documento:
{ "_id" : 1, "data" : "Red Firetruck" }
Podemos usar $substrCP así:
db.test.aggregate(
[
{ $match: { _id: { $in: [ 1 ] } } },
{
$project:
{
_id: 0,
data: 1,
result: { $substrCP: [ "$data", 0, 3 ] }
}
}
]
)Resultado:
{ "data" : "Red Firetruck", "result" : "Red" } El índice comienza en cero, por lo que nuestra subcadena comenzó al comienzo de la cadena y continuó durante tres puntos de código.
En este caso, usamos caracteres ingleses y cada carácter tiene un punto de código. Esto nos facilita contar cuántos puntos de código usar.
Ejecutemos otro ejemplo:
db.test.aggregate(
[
{ $match: { _id: { $in: [ 1 ] } } },
{
$project:
{
_id: 0,
data: 1,
result_1: { $substrCP: [ "$data", 4, 4 ] },
result_2: { $substrCP: [ "$data", 8, 5 ] },
result_3: { $substrCP: [ "$data", 8, 20 ] }
}
}
]
).pretty()Resultado:
{
"data" : "Red Firetruck",
"result_1" : "Fire",
"result_2" : "truck",
"result_3" : "truck"
} Observe en nuestro tercer resultado que especificamos más puntos de código de los que estaban disponibles, pero simplemente devolvió todos los caracteres al final de la cadena.
Marcas diacríticas
Algunos caracteres tienen una marca diacrítica agregada, lo que da como resultado varios puntos de código.
Supongamos que tenemos una colección llamada thai que contiene los siguientes documentos:
{ "_id" : 1, "data" : "ไม้เมือง" }
{ "_id" : 2, "data" : "ไ" }
{ "_id" : 3, "data" : "ม้" }
{ "_id" : 4, "data" : "เ" }
{ "_id" : 5, "data" : "มื" }
{ "_id" : 6, "data" : "อ" }
{ "_id" : 7, "data" : "ง" } Estos documentos contienen caracteres tailandeses. Podemos ver que dos de estos caracteres incluyen un diacrítico (un pequeño glifo encima del glifo inicial).
Los documentos del 2 al 7 simplemente enumeran cada uno de los caracteres que se encuentran en el documento 1.
Antes de tomar una subcadena, averigüemos cuántos puntos de código tiene cada uno de estos caracteres usando $strLenCP operador:
db.thai.aggregate(
[
{
$project:
{
_id: 0,
data: 1,
result: { $strLenCP: "$data" }
}
}
]
)Resultado:
{ "data" : "ไม้เมือง", "result" : 8 }
{ "data" : "ไ", "result" : 1 }
{ "data" : "ม้", "result" : 2 }
{ "data" : "เ", "result" : 1 }
{ "data" : "มื", "result" : 2 }
{ "data" : "อ", "result" : 1 }
{ "data" : "ง", "result" : 1 } Podemos ver que los dos caracteres con signos diacríticos tienen dos puntos de código y los otros tienen un punto de código.
Apliquemos $substrCP al primer documento:
db.thai.aggregate(
[
{ $match: { _id: { $in: [ 1 ] } } },
{
$project:
{
_id: 0,
data: 1,
result: { $substrCP: [ "$data", 1, 2 ] }
}
}
]
)Resultado:
{ "data" : "ไม้เมือง", "result" : "ม้" }
Basado en nuestro punto de partida de 1 y nuestro recuento de puntos de código de 2 , obtenemos el segundo carácter y su diacrítico asociado.
Separar los glifos
En el ejemplo anterior, nuestro tercer argumento era 2, de modo que devolvía el carácter y el diacrítico juntos. Esto es lo que sucede cuando proporcionamos un tercer argumento de 1.
db.thai.aggregate(
[
{ $match: { _id: { $in: [ 1 ] } } },
{
$project:
{
_id: 0,
data: 1,
result: { $substrCP: [ "$data", 1, 1 ] }
}
}
]
)Resultado:
{ "data" : "ไม้เมือง", "result" : "ม" } El primer carácter se devuelve sin el signo diacrítico.
Otros tipos de datos
El $substrCP El operador solo funciona en cadenas. Sin embargo, si tiene otro tipo de datos, aún debería funcionar, siempre que pueda resolverse en una cadena.
Supongamos que tenemos el siguiente documento:
{ "_id" : 2, "data" : 123456 }
Los data el campo contiene un número.
Esto es lo que sucede cuando aplicamos $substrCP a ese campo:
db.test.aggregate(
[
{ $match: { _id: { $in: [ 2 ] } } },
{
$project:
{
_id: 0,
data: 1,
result: { $substrCP: [ "$data", 1, 2 ] }
}
}
]
)Resultado:
{ "data" : 123456, "result" : "23" } Se las arregló para hacer bien el trabajo (aunque tenga en cuenta que el resultado es una cadena, no un número).
Tenemos otro documento con un objeto Fecha:
{ "_id" : 3, "data" : ISODate("2021-01-03T23:30:15.100Z") }
Ahora apliquemos $substrCP a ese documento:
db.test.aggregate(
[
{ $match: { _id: { $in: [ 3 ] } } },
{
$project:
{
_id: 0,
data: 1,
result: { $substrCP: [ "$data", 0, 4 ] }
}
}
]
)Resultado:
{ "data" : ISODate("2021-01-03T23:30:15.100Z"), "result" : "2021" } Así que también funcionó bien en este escenario.
Valores nulos
Si la cadena es null , el resultado es una cadena vacía.
Supongamos que tenemos el siguiente documento:
{ "_id" : 4, "data" : null }
Esto es lo que sucede cuando aplicamos $substrCP a ese documento:
db.test.aggregate(
[
{ $match: { _id: { $in: [ 4 ] } } },
{
$project:
{
_id: 0,
data: 1,
result: { $substrCP: [ "$data", 1, 2 ] }
}
}
]
)Resultado:
{ "data" : null, "result" : "" } Campo faltante
Intentar obtener una subcadena de un campo que no existe da como resultado una cadena vacía.
Supongamos que tenemos el siguiente documento:
{ "_id" : 5 }
Aplicar $substrCP :
db.test.aggregate(
[
{ $match: { _id: { $in: [ 5 ] } } },
{
$project:
{
_id: 0,
data: 1,
result: { $substrCP: [ "$data", 1, 2 ] }
}
}
]
)Resultado:
{ "result" : "" }
