MongoDB Expresiones regulares ($regex) con ejemplos
⚡ Resumen inteligente
MongoDB Las expresiones regulares realizan la coincidencia de patrones para encontrar cadenas dentro de los documentos, utilizando el operador $regex, el indicador $options para no distinguir entre mayúsculas y minúsculas, anclas para coincidencias exactas y delimitadores de barra diagonal cuando se desconoce el valor exacto del campo.

Las expresiones regulares se utilizan para la búsqueda de patrones, que básicamente consiste en encontrar cadenas de texto dentro de los documentos.
A veces, al recuperar documentos de una colección, es posible que no sepa exactamente cuál es el valor de campo exacto que debe buscar. Por lo tanto, se pueden utilizar expresiones regulares para ayudar a recuperar datos basados en valores de búsqueda de coincidencia de patrones.
Uso del operador $regex para la coincidencia de patrones
El operador $regex en MongoDB se utiliza para buscar cadenas específicas en la colección. El siguiente ejemplo muestra cómo se puede hacer esto.
Supongamos que tenemos nuestra misma colección de Empleados que tiene los nombres de campo “Employeeid” y “EmployeeName”. Supongamos también que tenemos los siguientes documentos en nuestra colección.
| ID de empleado | Nombre de empleado |
|---|---|
| 22 | nuevomartin |
| 2 | Mohan |
| 3 | Joe |
| 4 | MohanR |
| 100 | Guru99 |
| 6 | Viejo |
En el código que aparece a continuación, hemos utilizado el operador $regex para especificar los criterios de búsqueda.
db.Employee.find({EmployeeName : {$regex: "Gu" }}).forEach(printjson)
Code Explicación:
- Aquí queremos encontrar todos los nombres de empleados que contengan los caracteres 'Gu'. Por lo tanto, especificamos el operador $regex para definir el criterio de búsqueda de 'Gu'.
- printjson se utiliza para imprimir mejor cada documento devuelto por la consulta.
Si el comando se ejecuta correctamente, se mostrará la siguiente salida:
Salida:
El resultado muestra claramente que se devuelven aquellos documentos en los que el nombre del empleado contiene los caracteres "Gu".
Supongamos que su colección tiene los siguientes documentos con un documento adicional que contiene el nombre del empleado como “Guru999”. Si ingresó los criterios de búsqueda como “Guru99”, también devolvería el documento que tenía “Guru999”. Pero supongamos que no quisiéramos esto y solo quisiéramos devolver el documento con “Guru99”. Entonces podemos hacerlo con coincidencia de patrón exacta. Para hacer una coincidencia de patrón exacta, usaremos los caracteres ^ y $. Agregaremos el carácter ^ al principio de la cadena y $ al final de la cadena.
| ID de empleado | Nombre de empleado |
|---|---|
| 22 | nuevomartin |
| 2 | Mohan |
| 3 | Joe |
| 4 | MohanR |
| 100 | Guru99 |
| 6 | Viejo |
| 8 | Guru999 |
El siguiente ejemplo muestra cómo se puede hacer esto.
db.Employee.find({EmployeeName : {$regex: "^Guru99$"}}).forEach(printjson)
Code Explicación:
- Aquí en los criterios de búsqueda, estamos usando los caracteres ^ y $. El ^ se usa para asegurar que la cadena comience con un carácter determinado, y el $ se usa para asegurar que la cadena termine con un carácter determinado. Entonces, cuando se ejecute el código, solo recuperará la cadena con el nombre “Guru99 ".
- printjson se utiliza para imprimir mejor cada documento devuelto por la consulta.
Si el comando se ejecuta correctamente, se mostrará la siguiente salida:
Salida:
En la salida, se ve claramente que la cadena “GuruSe recuperan 99”.
Coincidencia de patrones con $options
Al usar el operador $regex, también se pueden proporcionar opciones adicionales mediante el uso de $ opciones palabra clave. Por ejemplo, supongamos que desea encontrar todos los documentos que tengan "Gu" en su nombre de empleado, independientemente de si distinguen entre mayúsculas y minúsculas o no. Si se desea tal resultado, entonces necesitamos usar el $ opciones con el parámetro de insensibilidad a mayúsculas y minúsculas.
El siguiente ejemplo muestra cómo se puede hacer esto.
Supongamos que tenemos nuestra misma colección de empleados que tiene los nombres de campo "Employeeid" y "EmployeeName".
Supongamos también que tenemos los siguientes documentos en nuestra colección.
| ID de empleado | Nombre de empleado |
|---|---|
| 22 | nuevomartin |
| 2 | Mohan |
| 3 | Joe |
| 4 | MohanR |
| 100 | Guru99 |
| 6 | Viejo |
| 7 | Guru99 |
Ahora bien, si ejecutamos la misma consulta que en el tema anterior, nunca veremos el documento con “GURU99” en el resultado. Para asegurarnos de que aparezca en el conjunto de resultados, debemos agregar el parámetro “i” de $options.
db.Employee.find({EmployeeName:{$regex: "Gu",$options:'i'}}).forEach(printjson)
Code Explicación:
- La opción $options con el parámetro 'i' (que significa insensibilidad a mayúsculas y minúsculas) especifica que queremos realizar la búsqueda independientemente de si encontramos las letras 'Gu' en minúsculas o mayúsculas.
Si el comando se ejecuta correctamente, se mostrará la siguiente salida:
Salida:
- El resultado muestra claramente que, aunque un documento contiene la palabra "Gu" en mayúsculas, el documento sigue apareciendo en el conjunto de resultados.
Coincidencia de patrones sin el operador regex
También se puede realizar la coincidencia de patrones sin el operador $regex. El siguiente ejemplo muestra cómo hacerlo.
db.Employee.find({EmployeeName: /Gu/}).forEach(printjson)
Code Explicación:
- Los delimitadores “//” sirven básicamente para especificar los criterios de búsqueda dentro de ellos. Por lo tanto, especificamos /Gu/ para encontrar nuevamente aquellos documentos que contengan 'Gu' en su EmployeeName.
Si el comando se ejecuta correctamente, se mostrará la siguiente salida:
Salida:
El resultado muestra claramente que se devuelven aquellos documentos en los que el nombre del empleado contiene los caracteres "Gu".
Obteniendo los últimos 'n' documentos de una colección
Hay varias formas de obtener los últimos n documentos de una colección.
Analicemos una de las maneras siguiendo los siguientes pasos.
El siguiente ejemplo muestra cómo se puede hacer esto.
Supongamos que tenemos nuestra misma colección de empleados que tiene los nombres de campo "Employeeid" y "EmployeeName".
Supongamos también que tenemos los siguientes documentos en nuestra colección:
| ID de empleado | Nombre de empleado |
|---|---|
| 22 | nuevomartin |
| 2 | Mohan |
| 3 | Joe |
| 4 | MohanR |
| 100 | Guru99 |
| 6 | Viejo |
| 7 | Guru99 |
db.Employee.find().sort({_id:-1}).limit(2).forEach(printjson)
Code Explicación:
- Al consultar los documentos, utilice la función de ordenación para ordenar los registros en orden inverso según el valor del campo _id en la colección. El valor -1 indica que los documentos se ordenen en orden inverso o descendente, de modo que el último documento sea el primero en mostrarse.
- Luego, usa la cláusula LIMIT para mostrar solo la cantidad de registros que deseas. Aquí hemos configurado la cláusula LIMIT (2), por lo que se mostrarán los dos últimos documentos.
Si el comando se ejecuta correctamente, se mostrará la siguiente salida:
Salida:
El resultado muestra claramente que se muestran los dos últimos documentos de la colección. Por lo tanto, hemos demostrado claramente que para obtener los últimos 'n' documentos de la colección, primero podemos ordenar los documentos en orden descendente y luego usar la cláusula de límite para devolver el número 'n' de documentos que se requieren.
Nota: : Si la búsqueda se realiza en una cadena que tiene más de, digamos, 38,000 caracteres, no mostrará los resultados correctos.










