Reto: expresión regular para contraseñas

Se pueden usar con el indicador pattern
Normalmente se escriben con diagonal expression diagonal
Ej
/[0-9]/
Para mongo se elimina la diagonall y se pone en su lugar las comillas dobles
“[0-9]”

^ -> indica inicio
$ -> indica fin
“^[a-zA-Z0-9]{8,100}$”
Con letras de la y numeros minimo 8 maximo 100
“^[a-zA-Z0-9]{8,}$”
Con letras y numeros desde 8 hasta infinito

Aparte de validar campos, se pueden usar como parte de los filtros.
https://www.mongodb.com/docs/manual/reference/operator/query/regex/

¿Sabías qué? Este símbolo ^ se llama **caret**, pero también lo llaman sobrero o exponente. Su código ASCII es el 94, por lo cual lo puedes generar con: ` ALT + 94` .

`telefono`: { ` bsonType: "string"`, ` pattern: "^\\+[0-9]{1,3}[0-9]{7,12}$"` } `email`: { ` bsonType: "string"`, ` pattern: "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$"` } `codigo_postal`: { ` bsonType: "string"`, ` pattern: "^[0-9]{5}$"` } `password`: { ` bsonType: "string"`, ` pattern: "^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)(?=.*[@$!%*?&])[A-Za-z\\d@$!%*?&]{8,}$"` } `fecha`: { ` bsonType: "string"`, ` pattern: "^(\\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])$"` } `nombre`: { ` bsonType: "string"`, ` pattern: "^[a-zA-Z ]+$"` } `username`: { ` bsonType: "string"`, ` pattern: "^[a-zA-Z0-9_]{3,15}$"` }

Las expresiones regulares (regex) son patrones utilizados para buscar y manipular texto. Funcionan combinando caracteres y meta caracteres para definir las reglas de coincidencia. Por ejemplo: * `\\d` representa cualquier dígito. * `\\w` representa cualquier carácter alfanumérico. * `.` representa cualquier carácter. Se utilizan para validar datos, como correos electrónicos o contraseñas, asegurando que cumplan con ciertas condiciones. En validación de datos en MongoDB, se puede aplicar regex para validar campos como contraseñas, asegurando que contengan letras y números.

Aqui les dejo un regex que checa que se cumplan las siguientes condiciones: 1. Al menos una letra minúscula (`a-z`). 2. Al menos una letra mayúscula (`A-Z`). 3. Al menos un número (`\d`). 4. Al menos un símbolo especial (como `@`, `$`, `!`, `%`, `*`, etc.). 5. Que la contraseña tenga **al menos 8 caracteres** en total. `^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&#])[A-Za-z\d@$!%*?&#]{8,}$` ### Desglose paso a paso: #### 1. `^` (Ancla de inicio) Este carácter indica el **inicio de la cadena**. Asegura que todo lo que siga cumpla con los patrones que definamos después. Sin este símbolo, el patrón podría encontrarse en cualquier parte de la cadena. #### 2. `(?=.*[a-z])` (Al menos una letra minúscula) * `(?= ...)`: Este es un **lookahead positivo**. Un lookahead verifica si lo que sigue cumple con la condición especificada, pero no consume caracteres. En este caso, estamos verificando la presencia de ciertos caracteres. * `.*`: Este patrón significa "cero o más de cualquier carácter". Permite que la letra minúscula aparezca en cualquier parte de la contraseña. * `[a-z]`: Esto asegura que haya **al menos una letra minúscula** en la contraseña. #### 3. `(?=.*[A-Z])` (Al menos una letra mayúscula) * Igual que el paso anterior, este lookahead asegura que la contraseña contenga **al menos una letra mayúscula** en cualquier posición. #### 4. `(?=.*\d)` (Al menos un número) * `\d`: Es un atajo para cualquier **dígito numérico** (equivalente a `[0-9]`). Este lookahead asegura que haya al menos un número en la contraseña. #### 5. `(?=.*[@$!%*?&#])` (Al menos un símbolo especial) * `[@$!%*?&#]`: Esto define un **conjunto de caracteres especiales** permitidos. El lookahead se asegura de que al menos uno de estos símbolos esté presente en la contraseña. #### 6. `[A-Za-z\d@$!%*?&#]{8,}` * `[A-Za-z\d@$!%*?&#]`: Este conjunto define qué caracteres son válidos para formar la contraseña. En este caso, se permiten letras mayúsculas (`A-Z`), letras minúsculas (`a-z`), dígitos (`\d`), y los caracteres especiales permitidos (`@$!%*?&#`). * `{8,}`: Esto indica que la contraseña debe tener al **menos 8 caracteres**. El número `8` es la longitud mínima requerida, y al no especificar un número máximo, la contraseña puede ser más larga de 8 caracteres. #### 7. `$` (Ancla de fin)

```js password: { bsonType: 'string', pattern: '^(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.{8,})', // al menos una minúscula, una mayúscula, un número y 8 caracteres } ```              }

No se olviden que pueden usar herramientas como <https://regex101.com/> donde pueden probar sus expresiones regulares antes de colocarlas en la creación de sus colecciones.

Utilizando la caracteristica pattern en una propiedad, se le puede indicar mediante el estandar de regex como deben estar formado el string.

password: { // propiedad
    bsonType: 'string', // tipo del objeto
    pattern: '^[A-Za-z0-9]{8,}$' // patron regex
},