Curso de Regex

Los fundamentos de las regex: patrones literales, clases de caracteres básicas, el comodín `.` y el escape de metacaracteres.

1. 1.1Patrones literalesCaracteres normales, sensibilidad al caso y primera ejecución: coincidencia e índice.~8 min
2. 1.2Clases básicas: \d \w \sLas clases predefinidas para dígitos, caracteres de palabra y espacios (y sus versiones negadas).~10 min
3. 1.3El comodín: el punto `.`El carácter `.` coincide con casi todo: qué incluye, qué no, y por qué se necesita la flag `s`.~8 min
4. 1.4Escape de metacaracteresLos 12 metacaracteres a escapar con `\`, cuándo se necesita la doble barra invertida y por qué.~10 min

Cuánto repetir: `*`, `+`, `?`, intervalos `{n,m}` y la diferencia entre greedy y lazy.

1. 2.1`*`, `+`, `?`Cero o más, uno o más, opcional: los tres cuantificadores básicos.~10 min
2. 2.2Cantidades exactas `{n,m}`Exactamente `n`, de `n` a `m`, al menos `n`: el cuantificador numérico.~10 min
3. 2.3Greedy vs lazyPor defecto los cuantificadores son avaros (`.*`); añade `?` para la versión perezosa (`.*?`).~10 min
4. 2.4Backtracking: conceptosQué hace el motor cuando un cuantificador avaro falla, y por qué puede costar caro.~12 min

Posición, no carácter: anclar al inicio/final de la cadena, a los límites de palabra, y al inicio/final de cada línea con la flag `m`.

1. 3.1Inicios y finales: `^` y `$`Anclar un patrón al primer o al último carácter de la cadena.~8 min
2. 3.2Límites de palabra: `\b` `\B`La transición entre caracteres de palabra y de no-palabra; buscar palabras completas.~10 min
3. 3.3Flag `m`: multilíneaCon la flag `m`, `^` y `$` se anclan al inicio/final de cada línea.~10 min
4. 3.4Líneas vacías y trimPatrones útiles: coincidir con líneas vacías, hacer trim de los espacios al inicio/final de una línea.~10 min

Agrupar con `()`, elegir entre alternativas con `|`, evitar la captura con `(?:...)`, dar nombres a los grupos con `(?<nome>...)` y referirse a una captura previa con backreferences.

1. 4.1Grupos de captura: `(...)`Paréntesis para agrupar y capturar; acceso a los grupos 1, 2, 3… en las coincidencias.~10 min
2. 4.2Alternativas: `|`La barra vertical para elegir entre dos o más subpatrones; precedencia y paréntesis.~10 min
3. 4.3Grupos de no captura: `(?:...)`Agrupar sin crear una captura: útil para cuantificar o alternar.~10 min
4. 4.4Grupos con nombre y referencias`(?<nome>...)` para dar un nombre; `\1` `\k<nome>` para referirse a la captura.~12 min

Definir conjuntos personalizados con `[...]`, usar rangos, negar con `[^...]` y acceder a las propiedades Unicode con `\p{...}` y la flag `u`.

1. 5.1Conjuntos de caracteres: `[abc]`Corchetes para definir un conjunto de caracteres permitidos en una posición.~8 min
2. 5.2Rangos en las clases: `[a-z0-9]`Intervalos con el guion; combinar rangos y caracteres individuales.~8 min
3. 5.3Negación: `[^...]`Una clase negada coincide con cualquier cosa excepto los caracteres enumerados.~8 min
4. 5.4Unicode property escapes`\p{L}`, `\p{N}`, `\p{Script=...}` con flag `u`: clases semánticas Unicode.~12 min

Aseveraciones de ancho cero: mirar hacia adelante o hacia atrás en la cadena sin consumir caracteres. Lookahead `(?=)` `(?!)`, lookbehind `(?<=)` `(?<!)`.

1. 6.1Lookahead positivo: `(?=...)`Verifica que después de la posición actual siga un cierto patrón, sin consumirlo.~10 min
2. 6.2Lookahead negativo: `(?!...)`Verifica que después de la posición actual NO siga un cierto patrón.~10 min
3. 6.3Lookbehind: `(?<=...)` `(?<!...)`Las versiones de "mirar atrás" de los lookarounds; soporte ES2018+.~12 min
4. 6.4Lookaround en la prácticaExtraer un valor sin incluir el contexto, validar contraseñas, parsear números delimitados.~12 min

Todos los flags (incluidos `d`, `v`), `String.prototype.replace`/`replaceAll`/`split` con regex, referencias `$1`/`$<nombre>` en la cadena de reemplazo y callbacks de reemplazo.

1. 7.1Todos los flags en detalle`g i m s u v y d`: qué hace cada uno y cómo se combinan.~12 min
2. 7.2Reemplazo básico y `$1`Reemplazar coincidencias con una cadena fija o con referencias `$1` / `$<nombre>`.~10 min
3. 7.3Reemplazo con callbackFunción de reemplazo: transformar cada coincidencia con código JS arbitrario, acceso a los grupos.~12 min
4. 7.4Split con regexSeparar una cadena mediante un patrón (CSV permisivo, tokenizador minimal).~10 min

Aplicar todo sobre problemas reales: validar emails, parsear registros (logs), extraer URLs/IPs y escribir patrones seguros frente a ReDoS.

1. 8.1Validar un emailUn patrón "suficientemente bueno" para emails, explicando los pros y contras.~12 min
2. 8.2Parser de logs de ApacheExtraer IP, método, ruta y código de estado de una línea de registro con grupos con nombre.~12 min
3. 8.3Extraer URLs e IPsReconocer URLs http(s) y direcciones IPv4 en medio de texto libre.~12 min
4. 8.4Escribir patrones ReDoS-safeReconocer patrones catastróficos (`(a+)+b`), refactorizarlos, usar cuantificadores de tipo atómico.~14 min