Reto: expresión regular para contraseñas

Curso de Modelado de Datos en MongoDB

Introducción

Modelado de Datos en MongoDB para E-commerce

Modelado de Datos en MongoDB: Uso de JSON y Diagrama Entidad-Relación

Modelamiento de Datos: Metodología y Restricciones en Bases de Datos

Proyecto

Creación de Clúster y Bases de Datos en Mongo Atlas

Modelado de Workloads en Bases de Datos con MongoDB

Configuración de Entorno y Conexión a MongoDB con VSCode

Validación de datos

Validación de Datos en MongoDB: Mantén la Integridad de la Información

Validaciones de Datos: Numbers, Booleanos y Enums en JSON Schema

Validación de Arrays y Subdocumentos en Bases de Datos NoSQL

Validación de Passwords con Expresiones Regulares en MongoDB

Validación de Datos en MongoDB: JSON Schema y Actualizaciones

Relaciones

Relaciones en Bases de Datos NoSQL: Embebidas y Referenciales

Relaciones 1 a 1 embebidas en bases de datos: cuándo y cómo usarlas

Relaciones Uno a Uno Referenciadas en Bases de Datos Documentales

Relaciones Uno a Muchos: Embebidas y Referenciadas en Bases de Datos

Relaciones Uno a Muchos con Referencias en Bases de Datos

Relaciones Muchos a Muchos en Bases de Datos: Tiendas y Productos

Relaciones Muchos a Muchos en Bases de Datos Documentales

Bonus: patrones

Desnormalización en Bases de Datos Documentales: Optimización Avanzada

Aplicación del Computed Pattern en Bases de Datos MongoDB

Balance entre Simplicidad y Rendimiento en MongoDB

Próximos pasos

Modelado de Datos con MongoDB: Relaciones y Consultas Avanzadas

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Si ya tienes una cuenta,

Recursos

¿Cómo validar contraseñas con expresiones regulares?

Las expresiones regulares son una herramienta poderosa y versátil que puedes utilizar para validar patrones complejos de texto. En esta sesión, te mostraré cómo implementarlas para validar contraseñas de usuarios en una base de datos.

¿Qué pasos necesitamos para configurar la colección de usuarios?

En primer lugar, debes crear una nueva carpeta para organizar tu colección y archivos correspondientes al proceso de validación. Dentro de esta carpeta, deberás gestionar los siguientes archivos:

Colección: Definición de la estructura para la colección de productos o usuarios.
Eliminación de colección: Archivo para borrar la colección cuando sea necesario.
Inserción de datos: Permite agregar nuevos registros y datos a la colección.
Consulta o query: Facilita la búsqueda y consulta de los documentos en la base de datos.

¿Cómo integrar una expresión regular en el esquema?

Al trabajar con esquemas para tu colección de usuarios, se busca garantizar que el password cumpla con ciertas características esenciales. Para ello, debes incluir una validación que use expresiones regulares.

Implementación de una expresión regular para contraseñas:

{
  password: {
    type: String,
    pattern: /^[A-Za-z0-9]{8,}$/
  }
}

^[A-Za-z0-9]{8,}$: Esta expresión asegura que el password contenga letras mayúsculas (A-Z), minúsculas (a-z), y números (0-9), con una longitud mínima de 8 caracteres.

¿Cómo probar la validación de contraseñas?

Una vez definida la expresión regular, es fundamental probar que efectivamente el campo password cumple con los criterios impuestos. Sigue estos pasos:

Eliminar esquema previo: Usa drop para asegurarte de no tener esquemas antiguos que puedan interferir.
Insertar usuarios válidos e inválidos: Prueba insertando documentos que no cumplan con los requisitos para verificar que se marcan como inválidos. Luego, inserta uno que cumpla y verifica su aceptación.

¿Por qué son importantes las expresiones regulares?

Las expresiones regulares no sólo validan contraseñas; su uso se extiende a diversas aplicaciones:

Validación de formatos específicos: Como números telefónicos y direcciones de email.
Filtrado de cadenas de texto: Pueden usarse para buscar y modificar texto en archivos o formularios web.
Soporte multidisciplinario: Su aplicabilidad trasciende a múltiples lenguajes como Python, JavaScript, y PHP.

¿Dónde ampliar más sobre expresiones regulares?

Finalmente, si te intrigó el potencial de las expresiones regulares y deseas profundizar, te recomiendo buscar recursos didácticos disponibles en plataformas educativas como Platzi, donde puedes encontrar cursos especializados en este tema. ¡Continúa ampliando tus habilidades en programación y desarrollo backend!

Aportes 10

Preguntas 1

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

BALFRE VAZQUEZ CASTREJON

hace 2 años

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/

José Manuel Romo

hace 7 meses

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)

hace 2 años

use("platzi_store");

db.users.drop();
db.createCollection("users", {
  validator: {
    $jsonSchema: {
      bsonType: "object",
      required: ["email", "password", "role"],
      properties: {
        name: {
          bsonType: "string",
        },
        last_name: {
          bsonType: "string",
        },
        email: {
          bsonType: "string",
        },
        password: {
          bsonType: "string",
          pattern: "^[A-Za-z0-9]{8,}$",
        },
        age: {
          bsonType: "number",
          minimum: 18,
          maximum: 99,
        },
        isSingle: {
          bsonType: "bool",
        },
        role: {
          enum: ["customer", "seller", "admin"],
        },
      },
    },
  },
});

Emanuel Salazar

hace 6 meses

¿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` .

Félix Alberto Uc Hernández

hace 5 meses

`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}$"` }

Emanuel Salazar

hace 6 meses

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.

Ronaldo Jiménez

hace un año

```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 } ``` }

Adrian Andres Landazuri Rivas

hace un año

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.

Sebastián Groselj Pausic

hace 2 años

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
},

Martín de la Rosa

hace 2 años

excellent! muy bien explicado.