Aquesta lliçó salda un deute que arrosseguem des del Mòdul 2. Quan vam presentar grep a 02-02 vam dir explícitament que els seus patrons són molt més potents que els comodins i que ho deixàvem per més endavant; quan a 02-05 vam comparar el globbing amb altres formes d'aparellar text, ho vam tornar a ajornar. I en tancar 05-03 va quedar clar on fa mal: el toolkit sap validar rutes, processos i codis de sortida, però quan ha de validar text —que --data 2026-08-03 sigui una data de debò, que una IP sigui una IP, que una línia d'app.log tingui l'estructura esperada— recorre a comparacions fràgils amb globs. Les expressions regulars són el llenguatge que resol això, i amb l'operador =~ de Bash validen i extreuen en un sol pas.

1. Regex enfront del globbing
2. Els tres sabors: BRE, ERE i PCRE
3. Literals, el punt i les classes
4. Classes POSIX
5. Àncores
6. Quantificadors i avarícia
7. Alternança, agrupació i retroreferències
8. Escapaments i barres invertides dins de cometes
9. L'operador =~ de Bash
10. BASH_REMATCH: validar i extreure alhora
11. Validacions reals
12. Extracció amb grep -o
13. Quan NO fer servir regex

Les dues sintaxis s'assemblen prou per confondre, i signifiquen coses diferents:

Els dos paranys de la taula són els que causen gairebé tots els errors de principiant. Primer: en regex, * no significa res per si sol; modifica l'element que té al davant, així que *.log és una regex incorrecta i el que vols escriure és .*\.log. Segon: grep ERROR troba la paraula en qualsevol posició de la línia, mentre que [[ $x == ERROR ]] exigeix igualtat completa. Per exigir la línia sencera en regex cal ancorar: ^ERROR$.

Existeixen tres dialectes, i la diferència pràctica és en quins caràcters necessiten barra invertida:

• BRE (Basic): +, ?, {, |, ( i ) són literals; per fer-los servir com a metacaràcters cal escapar-los (\+, \|).
• ERE (Extended): aquests caràcters són metacaràcters directament. És el dialecte còmode.
• PCRE (estil Perl): ERE més dreceres (\d, \w, \s, \b), quantificadors mandrosos (*?) i molt més.

La recomanació pràctica: fes servir ERE sempre que puguis (grep -E, sed -E, awk, [[ =~ ]]). Tota aquesta lliçó està escrita en ERE tret d'on s'indiqui. grep -P no està disponible a tots els sistemes —no el porta macOS ni alguns contenidors mínims—, així que evita'l en scripts portables.

La majoria dels caràcters es representen a si mateixos. Els especials són . [ ] ^ $ * + ? { } ( ) | \.

Dins dels claudàtors gairebé tot perd el seu significat especial: [.*+] aparella un punt, un asterisc o un signe més literals. Les tres excepcions són ^ (si va primer, nega), - (si va al mig, forma rang: posa'l al principi o al final perquè sigui literal) i ] (ha d'anar el primer).

El . és l'error més comú en buscar extensions o IPs: grep -E '192.168.1.1' també troba 192x168y1z1. Per a un punt literal, escapa'l: 192\.168\.1\.1.

A grep -E '[[:digit:]]{4}-[[:digit:]]{2}' app.log, els noms van entre [: :] dins d'uns claudàtors de classe, d'aquí el doble parell:

Per què preferir-les a [0-9]? Per les locales. Un rang com [a-z] s'interpreta segons l'ordre de col·lació de l'idioma configurat: en algunes locales inclou caràcters accentuats i en altres no, i [A-z] (error tipogràfic freqüent) abasta a més [, \, ], ^, _ i la cometa invertida. [[:alpha:]] significa «lletra» en qualsevol locale, sense sorpreses, i en un servidor on LANG pot canviar entre desplegaments això és exactament el que vols. Per a dígits, [0-9] i [[:digit:]] són equivalents a la pràctica; per a lletres, la diferència és real.

^ i $ no consumeixen cap caràcter: marquen posicions. I \b marca un límit de paraula, la frontera entre un caràcter de paraula i un que no ho és: grep -E 'jruiz' també troba jruizperez, mentre que grep -E '\bjruiz\b' acota al repartidor exacte.

Ancorar és també una qüestió de rendiment i de seguretat: una validació sense ^ i $ accepta brossa al voltant del que és vàlid, que és com s'esmunyen dades malformades cap a un informe.

Els quantificadors són avariciosos (greedy): consumeixen tot el que poden i després recularan just el necessari perquè la resta encaixi. L'efecte pràctic es veu en extreure la ruta d'una línia d'acces.log:

.* entre cometes dobles aparella fins a l'última cometa de la línia, no fins a la primera. L'idioma robust és [^X]* —«tot el que no sigui el delimitador»—, que no depèn de l'avarícia. ERE no té quantificadors mandrosos (.*?); això és PCRE. En ERE, [^"]* és la resposta.

L'alternança té la prioritat més baixa de tot el llenguatge, així que ^ERROR|WARN$ significa «comença per ERROR, o acaba en WARN», que gairebé mai no és el que es vol. Els parèntesis ho arreglen i, a més, capturen el fragment aparellat per reutilitzar-lo: \1 és el contingut del primer grup, \2 el del segon. Els grups es numeren per l'ordre dels seus parèntesis d'obertura.

Les retroreferències són cares i no totes les eines les admeten en tots els sabors (awk no en té), però el seu valor de debò apareix a la secció 10, on Bash les exposa com un array, i a sed (06-02), on permeten reescriure text conservant trossos de l'original.

Aquí és on es perd més temps del que ningú confessaria. Hi ha dos nivells d'interpretació: primer el shell processa les cometes, i el que sobrevisqui arriba a la regex.

Regla d'or: els patrons regex van sempre entre cometes simples. A dins no s'interpreta res, i el que escrius és exactament el que rep l'eina. L'única excepció és quan necessites interpolar una variable —grep -E "^[0-9]+,[^,]+,$ciutat," enviaments.csv—, i llavors convé construir el patró en una variable a part.

Els caràcters que necessiten escapament per ser literals són . [ ] ^ $ * + ? { } ( ) | \. I la barra invertida mateixa s'escriu \\ a la regex, cosa que dins de cometes dobles del shell es converteix en \\\\: un motiu més per fer servir cometes simples.

Bash porta un motor ERE integrat, disponible només dins de [[ ]]: if [[ "$data" =~ ^[0-9]{4}-[0-9]{2}-[0-9]{2}$ ]]; then .... Dues regles de sintaxi, i totes dues són contraintuïtives:

1. El patró NO va entre cometes. Si escrius [[ "$x" =~ "^[0-9]+$" ]], les cometes converteixen el patró en una cadena literal i només aparellarà si $x conté exactament aquests caràcters. És l'error més freqüent amb =~, i no dona cap avís: simplement no coincideix mai.
2. La cadena de l'esquerra SÍ que va entre cometes, com sempre, per protegir-la de la divisió en paraules (03-06).

Si el patró és complex o conté espais, desa'l en una variable i fes servir la variable sense cometes —és la manera llegible i portable de tenir-ho tot sota control—:

A més, =~ no està ancorat per defecte: [[ abc123 =~ [0-9]+ ]] és cert. Per validar, ancora sempre amb ^ i $.

Aquesta és la raó per la qual =~ mereix una secció pròpia. Després d'un aparellament amb èxit, Bash omple l'array BASH_REMATCH: la posició 0 és el text complet aparellat i les següents són els grups capturats, en ordre.

Compara-ho amb l'alternativa: un cut per a la data, un altre per a l'hora, un tr -d '[]' per al nivell i un ${linia#* } repetit quatre vegades per al missatge. Aquí, una sola comprovació valida el format i extreu els quatre camps, sense llançar ni un sol procés extern. En un bucle sobre un app.log de cent mil línies, la diferència es compta en minuts.

Els espais del patró van escapats (\ ) perquè, dins de [[ ]], el patró sense cometes està subjecte a la divisió en paraules. Desar-lo en una variable evita aquest soroll:

BASH_REMATCH se sobreescriu amb cada =~ amb èxit i no es neteja quan un falla, així que copia el que necessitis immediatament després de la comprovació, dins de l'if.

Fixa't en el disseny de RE_DATA: no es conforma amb [0-9]{2} per al mes, sinó que exigeix 01-12 amb l'alternança (0[1-9]|1[0-2]). Tot i així no valida la data, només la seva forma: 2026-02-31 la supera. Per saber si la data existeix cal date -d "$f" &>/dev/null, que ja coneixes de 04-06. La regla general: la regex valida el format; la semàntica es comprova a part.

RE_OCTET mostra l'altre principi: construir per parts. Escriure la regex d'IPv4 d'una tirada és il·legible; compondre-la des d'un octet és evident. I així es depura, incrementalment: prova primer ^[0-9]{4}, després afegeix el mes, després el dia. Eines com regex101.com expliquen cada element i mostren les captures en viu, i al terminal n'hi ha prou amb grep -oE sobre un fitxer d'exemple per veure què aparella de debò.

Quan el que vols no és la línia sinó el fragment:

Aquesta última parella amaga un matís que espatlla informes: grep -c compta línies que contenen almenys una coincidència; si una línia en té tres, segueix comptant 1. Per comptar coincidències cal fer servir -o i comptar línies de la sortida.

grep -o és l'eina de la canonada; BASH_REMATCH és la del bucle. Si ja estàs recorrent el fitxer línia a línia amb while IFS= read -r (04-01), =~ evita llançar un procés per línia.

Les regex són un llenguatge regular, i hi ha estructures que no són regulars. Insistir-hi produeix codi que funciona amb els exemples i falla en producció:

• CSV amb comes dins de cometes. "Sevilla, Est" trenca qualsevol cut -d, i qualsevol regex ingènua. Els CSV de Veloz Envíos són simples i per això IFS=, n'hi ha prou; el dia que deixin de ser-ho, l'eina és awk amb un separador ben definit (06-01) o un analitzador de debò.
• HTML i XML. Imbricació arbitrària: no és un llenguatge regular. Hi ha una resposta llegendària a Stack Overflow sobre això, i té raó.
• JSON. Mateixa raó. L'eina és jq, i arriba a 06-05.
• Rutes i noms de fitxer. Ja tens find (05-01) i les expansions ${s##*/} (04-04).

I un avís de rendiment: patrons amb quantificadors imbricats com (a+)+ poden provocar retrocés catastròfic i penjar el procés amb una entrada curta. Si la teva regex necessita imbricar quantificadors, gairebé sempre hi ha una formulació més simple.

• Posar entre cometes el patró de =~. Es converteix en literal i no aparella mai, sense cap avís.
• Fer servir cometes dobles en un patró de grep. El shell es menja les barres invertides. Cometes simples.
• Oblidar d'escapar el punt. 192.168.1.1 aparella 19216811 i moltes coses més.
• *.log com a regex. * modifica l'anterior; s'escriu .*\.log.
• No ancorar una validació. [[ $x =~ [0-9]+ ]] accepta abc123def com a número.
• ^ERROR|WARN$ sense parèntesis. L'alternança té la prioritat més baixa i parteix l'expressió sencera.
• Refiar-se de grep -c per comptar coincidències. Compta línies. Fes servir grep -o | wc -l.
• Consell: desa cada regex en una variable readonly RE_ALGUNA_COSA amb nom descriptiu, a prop del principi de l'script. Es documenta sola, es reutilitza, es prova per separat i desapareix el soroll de cometes.

Exercici 1. Escriu validar_data() que accepti només AAAA-MM-DD amb mes 01-12 i dia 01-31, i a més verifiqui que la data existeix de debò (rebutjant 2026-02-31). Ha de retornar 0 o 1 sense imprimir res.

Exercici 2. Recorre /var/log/veloz/app.log amb un sol bucle i produeix un recompte per nivell (INFO, WARN, ERROR), mostrant a més l'hora i el missatge del primer ERROR del dia, sense llançar processos externs dins del bucle.

Exercici 3. Extreu d'acces.log les IPs que hagin provocat almenys un codi 5xx, juntament amb quantes vegades, ordenades de major a menor.

Solució 1.

Dues capes: la regex descarta el que ni tan sols té forma de data —barat, sense processos— i date -d resol el que la regex no pot saber, com els anys de traspàs. L'ordre importa: si date anés primer, acceptaria entrades com next friday.

Solució 2.

És el patró comptador de 04-03 alimentat per BASH_REMATCH. El || continue converteix la validació en un filtre que protegeix el recompte de línies escombraries, i tot passa dins de Bash: ni un cut, ni un grep, ni un procés per línia.

Solució 3.

El primer grep selecciona les línies el codi de les quals va després de la petició entre cometes —l'espai i la cometa eviten confondre'l amb un nombre de bytes que comenci per 5—, i el segon extreu només la IP inicial. El (\.[0-9]{1,3}){3} mostra que un grup també es pot quantificar. La rematada sort | uniq -c | sort -rn és l'idioma del Mòdul 2, que ara encaixa amb l'extracció precisa que només les regex donen.

Una regex descriu text, no noms de fitxer, i els seus metacaràcters s'assemblen als del globbing només prou per enganyar: * modifica l'element anterior, . és el comodí d'un caràcter i .* és l'equivalent de l'* del shell. Dels tres sabors, ERE és el punt dolç i el parlen grep -E, sed -E, awk i el =~ de Bash. La sintaxi es construeix amb literals, ., classes [...] amb la seva negació [^...], classes POSIX [[:digit:]] immunes a la locale, àncores ^, $ i \b, quantificadors *, +, ? i {n,m} —avariciosos, d'aquí l'idioma [^"]*—, alternança | de prioritat mínima i grups ( ) que capturen. Els patrons van sempre entre cometes simples, tret d'=~, on el patró va sense cometes i el millor és desar-lo en una variable readonly. I aquí hi ha la joia: BASH_REMATCH converteix una comprovació en una extracció de tots els camps alhora, sense llançar processos, ideal per a bucles llargs. El que no has de fer amb regex és analitzar CSV amb cometes, HTML o JSON: per a això hi ha eines específiques que arriben al Mòdul 6.

informe-diari.sh ja valida la seva --data i descompon app.log en un sol pas. El que queda per resoldre és la sortida: avui imprimeix per pantalla amb printf solts, i si vols l'informe en un fitxer has de redirigir tot l'script des de fora. No sap escriure a dos llocs alhora, ni mantenir obert un fitxer de registre mentre treballa, ni compondre una plantilla d'informe de diverses línies sense vint printf. A 05-05 entren els descriptors de fitxer, els here-documents, els here-strings i la substitució de processos: la maquinària d'entrada/sortida que converteix la sortida del toolkit en una cosa que es pot dirigir amb precisió.