Una delle cose che ho sempre amato del terminale Linux è ciò che puoi ottenere usando le espressioni regolari. Sia che abbiamo bisogno di trovare testo complicato o sostituirlo con qualcos'altro, l'uso di espressioni regolari può semplificare notevolmente il lavoro. Cominciamo dall'inizio:
Cos'è un'espressione regolare?
Un'espressione regolare è una serie di caratteri speciali che ci consentono di descrivere un testo che vogliamo trovare. Ad esempio, se volessimo cercare la parola "linux" sarebbe sufficiente inserire quella parola nel programma che stiamo utilizzando. La parola stessa è un'espressione regolare. Finora sembra molto semplice, ma cosa succede se vogliamo trovare tutti i numeri in un determinato file? O tutte le righe che iniziano con una lettera maiuscola? In quei casi non puoi più mettere una semplice parola. La soluzione è utilizzare un'espressione regolare.
Espressioni regolari e pattern di file.
Prima di entrare nell'argomento delle espressioni regolari, desidero chiarire un malinteso comune sulle espressioni regolari. Un'espressione regolare non è ciò che inseriamo come parametro in comandi come rm, cp, ecc. Per fare riferimento a vari file sul disco rigido. Quello sarebbe un file pattern. Le espressioni regolari, sebbene simili in quanto utilizzano alcuni caratteri comuni, sono diverse. Un pattern di file viene lanciato contro i file sul disco rigido e restituisce quelli che corrispondono completamente al pattern, mentre un'espressione regolare viene lanciata contro un testo e restituisce le righe che contengono il testo cercato. Ad esempio, l'espressione regolare corrispondente al modello *.* sarebbe qualcosa di simile ^.*\..*$
Tipi di espressioni regolari.
Non tutti i programmi utilizzano le stesse espressioni regolari. Non molto di meno. Esistono diversi tipi più o meno standard di espressioni regolari, ma ci sono programmi che cambiano leggermente la sintassi, includono le proprie estensioni o usano anche caratteri completamente diversi. Pertanto, quando vuoi usare espressioni regolari con un programma che non conosci bene, la prima cosa da fare è guardare il manuale o la documentazione del programma per vedere come sono le espressioni regolari che riconosce.
Innanzitutto, ci sono due tipi principali di espressioni regolari, che sono contenute nello standard POSIX, che è ciò che usano gli strumenti Linux. Sono le espressioni regolari di base ed estese. Molti dei comandi che funzionano con le espressioni regolari, come grep o sed, consentono di utilizzare questi due tipi. Ne parlerò di seguito. Ci sono anche le espressioni regolari in stile PERL, e poi ci sono programmi come vim o emacs che usano varianti di queste. A seconda di ciò che vogliamo fare, potrebbe essere più appropriato utilizzare l'uno o l'altro.
Testare le espressioni regolari.
La sintassi delle espressioni regolari non è banale. Quando dovremo scrivere un'espressione regolare complicata ci troveremo di fronte a una stringa di caratteri speciali impossibile da capire a prima vista, quindi per imparare a usarli è essenziale avere un modo per fare tutti i test che vogliamo e vedere facilmente i risultati. Questo è il motivo per cui ora inserirò diversi comandi con i quali possiamo eseguire i test e sperimentare tutto ciò di cui abbiamo bisogno fino a quando non avremo dominato le espressioni regolari.
Il primo è il comando grep. Questo è il comando che useremo più frequentemente per fare ricerche. La sintassi è la seguente:
grep [-E] 'REGEX' FICHERO
COMANDO | grep [-E] 'REGEX'
Raccomando sempre di mettere le espressioni regolari tra virgolette singole in modo che la shell non si alzi. Il primo modo è trovare un'espressione regolare in un file. Il secondo consente di filtrare l'output di un comando tramite un'espressione regolare. Per impostazione predefinita, grep utilizza espressioni regolari di base. L'opzione -E serve per l'utilizzo di espressioni regolari estese.
Un trucco che può aiutarci a vedere come funzionano le espressioni regolari è abilitare l'uso del colore nel comando grep. In questo modo, verrà evidenziata la parte del testo che corrisponde all'espressione regolare che stiamo utilizzando. Per attivare il colore nel comando grep, assicurati che la variabile d'ambiente GREP_OPTIONS contenere in valore --color, che può essere fatto con questo comando:
GREP_OPTIONS=--color
Possiamo metterlo nel .bashrc per averlo sempre attivato.
Un altro modo per utilizzare le espressioni regolari è utilizzare il comando sed. È più adatto per sostituire il testo, ma può essere utilizzato anche per la ricerca. La sintassi sarebbe come questa:
sed -n[r] '/REGEX/p' FICHERO
COMANDO | sed -n[r] '/REGEX/p'
Il comando sed utilizza anche espressioni regolari di base per impostazione predefinita, è possibile utilizzare espressioni regolari estese con l'opzione -r.
Un altro comando che voglio anche nominare è awk. Questo comando può essere utilizzato per molte cose, in quanto ti consente di scrivere script nel tuo linguaggio di programmazione. Se quello che vogliamo è cercare un'espressione regolare in un file o nell'output di un comando, il modo per usarla sarebbe il seguente:
awk '/REGEX/' FICHERO
COMANDO | awk '/REGEX/'
Questo comando utilizza sempre espressioni regolari estese.
Per fare i nostri test avremo anche bisogno di un testo che servirà da esempio per cercare in esso. Possiamo usare il seguente testo:
- Lista de páginas wiki: ArchLinux: https://wiki.archlinux.org/ Gentoo: https://wiki.gentoo.org/wiki/Main_Page CentOS: http://wiki.centos.org/ Debian: https://wiki.debian.org/ Ubuntu: https://wiki.ubuntu.com/ - Fechas de lanzamiento: Arch Linux: 11-03-2002 Gentoo: 31/03/2002 CentOs: 14-05-2004 03:32:38 Debian: 16/08/1993 Ubuntu: 20/10/2004 Desde Linux Rulez.
Questo è il testo che userò per gli esempi nel resto del post, quindi ti consiglio di copiarlo in un file per averlo a portata di mano dal terminale. Puoi mettere il nome che vuoi. L'ho chiamato regex.
Inizio lezione.
Ora abbiamo tutto ciò di cui abbiamo bisogno per iniziare a testare le espressioni regolari. Andiamo a poco a poco. Metterò diversi esempi di ricerche con espressioni regolari in cui spiegherò a cosa serve ogni carattere. Non sono ottimi esempi, ma dato che avrò un post molto lungo, non voglio complicarlo più. E ho solo intenzione di grattare la superficie di ciò che può essere fatto con le espressioni regolari.
La più semplice di tutte è cercare una parola specifica, ad esempio, supponiamo di voler cercare tutte le righe che contengono la parola "Linux". Questo è il più semplice, poiché dobbiamo solo scrivere:
grep 'Linux' regex
E possiamo vedere il risultato:
ArcoLinux: https://wiki.archlinux.org/ Arch Linux: 11-03-2002 Da Linux regola.
Queste sono le tre righe che contengono la parola "Linux" che, se abbiamo usato il trucco del colore, apparirà evidenziata. Notare che riconosce la parola che stiamo cercando anche se fa parte di una parola più lunga come in "ArchLinux". Tuttavia, non evidenzia la parola "linux" che appare nell'URL "https://wiki.archlinux.org/". Questo perché appare lì con la "l" minuscola e l'abbiamo cercata in maiuscolo. Il comando grep ha opzioni per questo, ma non ne parlerò in un articolo sulle espressioni regolari.
Con questo semplice test possiamo trarre la prima conclusione:
- Un carattere normale inserito in un'espressione regolare corrisponde a se stesso.
Vale a dire che se metti la lettera "a" cercherà la lettera "a". Sembra logico, vero? 🙂
Supponiamo ora di voler cercare la parola "CentO" seguita da qualsiasi carattere, ma solo da un singolo carattere. Per questo possiamo usare il carattere ".", Che è un carattere jolly che corrisponde a qualsiasi carattere, ma solo a uno:
grep 'CentO.' regex
E il risultato è:
CentOS: http://wiki.centos.org/ CentOS: 14-05-2004 03:32:38
Il che significa che include la "S" in "CentOS" anche se in un caso è maiuscolo e in un altro minuscolo. Se qualsiasi altro personaggio apparisse in quel luogo, lo includerebbe anche. Abbiamo già la seconda regola:
- Il personaggio "." corrisponde a qualsiasi carattere.
Non è più così banale come sembrava, ma con questo non possiamo fare molto. Andiamo un po 'oltre. Supponiamo di voler trovare le righe in cui compaiono l'anno 2002 e 2004. Sembrano due ricerche, ma possono essere fatte contemporaneamente in questo modo:
grep '200[24]' regex
Il che significa che vogliamo trovare il numero 200 seguito da 2 o 4. E il risultato è questo:
Arch Linux: 11-03-2002 Gentoo: 31/03 /2002 CentOS: 14-05-2004 03:32:38 Ubuntu: 20/10/2004
Il che ci porta alla terza regola:
- Più caratteri racchiusi tra parentesi corrispondono a uno qualsiasi dei caratteri all'interno delle parentesi.
Le parentesi danno più gioco. possono essere utilizzati anche per escludere caratteri. Ad esempio, supponiamo di voler cercare siti in cui appare il carattere ":", ma non è seguito da "/". Il comando sarebbe così:
grep ':[^/]' regex
È semplicemente questione di mettere un "^" come primo carattere all'interno della parentesi. Puoi mettere tutti i caratteri che desideri di seguito. Il risultato di questo ultimo comando è il seguente:
ArchLinux: https://wiki.archlinux.org/ Gentoo: https://wiki.gentoo.org/wiki/Main_Page CentOS: http://wiki.centos.org/ Debian: https://wiki.debian.org/ Ubuntu: https://wiki.ubuntu.com/ Arch Linux: 11-03-2002 Gentoo: 31/03/2002 CentOs: 14-05-2004 03:32:38 Debian: 16/08/1993 Ubuntu: 20/10/2004
Ora i ":" dietro i nomi delle distro sono evidenziati, ma non quelli negli URL perché gli URL hanno "/" dopo di loro.
- Mettere il carattere "^" all'inizio di una parentesi corrisponde a qualsiasi carattere tranne gli altri caratteri nella parentesi.
Un'altra cosa che possiamo fare è specificare un intervallo di caratteri. Ad esempio, per cercare qualsiasi numero seguito da un "-", sarebbe simile a questo:
grep '[0-9]-' regex
Con questo stiamo specificando un carattere compreso tra 0 e 9 e quindi un segno meno. Vediamo il risultato:
ArchLinux: 11-03-CentO del 2002: 14-05-2004 03: 32: 38
È possibile specificare più intervalli tra parentesi per mescolare anche intervalli con singoli caratteri.
- L'inserimento di due caratteri separati da "-" all'interno delle parentesi corrisponde a qualsiasi carattere all'interno dell'intervallo.
Vediamo ora se possiamo selezionare la prima parte degli URL. Quello che dice "http" o "https". Differiscono solo nella "s" finale, quindi facciamolo come segue:
grep -E 'https?' regex
Il punto interrogativo viene utilizzato per rendere facoltativo il carattere alla sua sinistra. Ma ora abbiamo aggiunto l'opzione -E al comando. Questo perché l'interrogatorio è una caratteristica delle espressioni regolari estese. Finora stavamo utilizzando espressioni regolari di base, quindi non abbiamo dovuto inserire nulla. Vediamo il risultato:
ArchLinux: https: //wiki.archlinux.org/ Gentoo: https: //wiki.gentoo.org/wiki/Main_Page CentOS: http: //wiki.centos.org/ Debian: https: //wiki.debian.org/ Ubuntu: https: //wiki.ubuntu.com/
Quindi abbiamo già una nuova regola:
- Un carattere seguito da "?" corrisponde a quel carattere o nessuno. Questo è valido solo per le espressioni regolari estese.
Ora cercheremo due parole completamente diverse. Vediamo come trovare le righe che contengono sia la parola "Debian" che "Ubuntu".
grep -E 'Debian|Ubuntu' regex
Con la barra verticale possiamo separare due o più espressioni regolari diverse e cercare le linee che corrispondono a ciascuna di esse:
Debian: https://wiki.debian.org/ Ubuntu: https://wiki.ubuntu.com/ Debian: 16 / 08 / 1993 Ubuntu: 20 / 10 / 2004
- Il personaggio «|» serve per separare più espressioni regolari e corrisponde a nessuna di esse. È anche specifico per le espressioni regolari estese.
Continuiamo. Adesso cercheremo la parola "Linux", ma solo dove non è attaccata ad un'altra parola a sinistra. Possiamo farlo in questo modo:
grep '\
Qui il carattere importante è "<", ma deve essere evitato mettendo "\" davanti in modo che grep lo interpreti come un carattere speciale. Il risultato è il seguente:
Arco Linux: 11-03-2002 Da Linux regola.
Puoi anche usare "\>" per cercare parole che non sono una accanto all'altra. Facciamo un esempio. Proviamo questo comando:
grep 'http\>' regex
L'output che produce è questo:
CentOS: http: //wiki.centos.org/
È uscito "Http", ma non "https", perché in "https" c'è ancora un carattere a destra della "p" che può essere parte di una parola.
- I caratteri "<" e ">" corrispondono rispettivamente all'inizio e alla fine di una parola. Questi caratteri devono essere sottoposti a escape in modo che non vengano interpretati come caratteri letterali.
Andiamo con le cose un po 'più complicate. Il carattere "+" corrisponde al carattere alla sua sinistra, ripetuto almeno una volta. Questo carattere è disponibile solo con espressioni regolari estese. Con esso possiamo cercare, ad esempio, sequenze di più numeri in una riga che iniziano con ":".
grep -E ':[0-9]+' regex
risultato:
CentOs: 14/05/2004 03: 32: 38
Il numero 38 è evidenziato anche perché inizia anche con ":".
- Il carattere "+" corrisponde al carattere alla sua sinistra, ripetuto almeno una volta.
Puoi anche controllare il numero di ripetizioni utilizzando "{" e "}". L'idea è di mettere tra parentesi graffe un numero che indichi il numero esatto di ripetizioni che vogliamo. Puoi anche inserire un intervallo. Vediamo esempi dei due casi.
Per prima cosa troveremo tutte le sequenze di quattro cifre che ci sono:
grep '[0-9]\{4\}' regex
Si noti che le parentesi graffe devono essere precedute da caratteri di escape se si utilizzano espressioni regolari di base, ma non se si utilizzano quelle estese. Con esteso sarebbe così:
grep -E '[0-9]{4}' regex
E il risultato in entrambi i casi sarebbe questo:
Arch Linux: 11-03-2002 Gentoo: 31/03 /2002 CentOS: 14-05-2004 03:32:38 Debian: 16/08/1993 Ubuntu: 20/10 /2004
- I caratteri "{" e "}" con un numero tra di loro corrispondono al carattere precedente ripetuto il numero di volte specificato.
Ora l'altro esempio con le parentesi graffe. Supponiamo di voler trovare parole che abbiano da 3 a 6 lettere minuscole. Potremmo fare quanto segue:
grep '[a-z]\{3,6\}' regex
E il risultato sarebbe questo:
- Lista de paginas wiki: PERRCHLinus: https:/ /wiki.Archlinux.org/ Gpoi: https:/ /wiki.gentoo.org/wiki/Main_P CentOS: http:/ /wiki.CentOS.org/ Debian: https:/ /wiki.debian.org/ Obuntù: https:/ /wiki.ubuntu.com/ - Ftu manchi de lancio: PERRCH Linus: 11-03-2002 Gpoi: 31/03/2002 CentOs: 14-05-2004 03:32:38 Debian: 16/08/1993 Ubuntù: 20/10/2004 Dince Linus Rulez.
Che, come puoi vedere, non assomiglia molto a quello che volevamo. Questo perché l'espressione regolare trova le lettere all'interno di altre parole più lunghe. Proviamo quest'altra versione:
grep '\<[a-z]\{3,6\}\>' regex
risultato:
- Elenco delle pagine wiki: ArchLinux: https:/ /wiki.archlinux.org/ Gentoo: https:/ /wiki.gentoo.org/wiki/ Main_Page CentOS: http:/ /wiki.CentOS.org/ Debian: https:/ /wiki.debian.org/ Ubuntu: https:/ /wiki.ubuntu.com/
Questo sembra già più come quello che volevamo. Quello che abbiamo fatto è richiedere che la parola inizi appena prima della prima lettera e finisca subito dopo l'ultima.
- I caratteri "{" e "}" con due numeri separati da una virgola corrispondono al carattere precedente ripetuto il numero di volte indicato dai due numeri.
Diamo ora un'occhiata a un carattere che è un numero primo di "+". È "*" e il suo funzionamento è molto simile solo che corrisponde a qualsiasi numero di caratteri compreso lo zero. Cioè, fa la stessa cosa del "+" ma non richiede che il carattere alla sua sinistra appaia nel testo. Ad esempio, proviamo a cercare quegli indirizzi che iniziano su wiki e finiscono su org:
grep 'wiki.*org' regex
Vediamo il risultato:
ArchLinux: https: //wiki.archlinux.org/ Gentoo: https: //wiki.gentoo.org/ wiki / Main_Page CentOS: http: //wiki.centos.org/ Debian: https: //wiki.debian.org/
Perfetto.
Ora l'ultimo personaggio che vedremo. Il carattere "\" viene utilizzato per eseguire l'escape del carattere alla sua destra in modo che perda il suo significato speciale. Ad esempio: supponiamo di voler individuare le linee che terminano con un punto. La prima cosa che potrebbe venirci in mente potrebbe essere questa:
grep '.$' regex
Il risultato non è quello che stiamo cercando:
- Elenco delle pagine wiki: ArchLinux: https://wiki.archlinux.org/ Gentoo: https://wiki.gentoo.org/wiki/Main_Page CentOS: http://wiki.centos.org/ Debian: https://wiki.debian.org/ Ubuntu: https://wiki.ubuntu.com/ - Date di rilascio: Arch Linux: 11-03-2002 Gentoo: 31/03/2002 CentOs: 14-05-2004 03:32:38 Debian: 16/08/1993 Ubuntu: 20/10/2004 Desde Linux regole.
Questo perché il "." corrisponde a qualsiasi cosa, in modo che l'espressione regolare corrisponda all'ultimo carattere di ogni riga, qualunque essa sia. La soluzione è questa:
grep '\.$' regex
Ora il risultato è quello che vogliamo:
Desde Linux regole.
Gioco finito
Sebbene l'argomento delle espressioni regolari sia così complesso che darei per una serie di articoli, penso di averti già dato abbastanza dolore. Se sei riuscito ad arrivare, complimenti. E se hai letto tutto questo in una volta, prendi un'aspirina o qualcosa del genere, perché non può essere buono.
Per ora è tutto. Se ti piace questo articolo, forse puoi scriverne un altro. Nel frattempo, ti consiglio di provare tutte le espressioni regolari nel terminale per vedere chiaramente come funzionano. E ricorda: solo Chuck Norris può analizzare l'HTML usando espressioni regolari.
Cosa sarebbe la nostra vita senza la regex?
L'articolo è molto utile, ma lo leggerò a poco a poco. Molte grazie.
Grazie per il commento. Continuo a non credere che il mio articolo sia uscito. 🙂 È uscito con qualche errore, ma spero che sia utile. 🙂
Grazie youssssssss! ..
Qualche tempo fa ho dovuto studiare un po 'di espressioni regolari .. .. ti ringrazio per l'insegnamento .. e la guida passo passo per impararle ognuna ..
Molto bene! .. .. vado a prendere quell'aspirina .. ee
Prego. Coraggio e che le espressioni regolari non possono con te. 🙂
Post fantastico! Ottimo lavoro. Mi chiedo quante ore ti ci siano volute 😀
LOL !! La domanda è: quante ore mi ci sarebbero volute se avessi detto tutto quello che intendevo dire? Infinito !! 🙂
una cosa che non sapevo, buon articolo!
Grazie. È un piacere condividerlo con te.
ottima spiegazione. complimenti! davvero utile!
Sono contento che tu l'abbia trovato utile. Quindi è un piacere scrivere
Questo dovrebbe andare in un posto speciale. Come il primo piano ma hanno un'utilità molto specifica. Abbastanza utile, anche se mi piacerebbe vederlo applicato a Vim.
Questa è una questione di chiedermi. Ho in mente qualche altro articolo sulle espressioni regolari. E potrei parlare di vim in loro. Presenta alcune differenze rispetto a quanto ho spiegato in questo articolo. È questione di andare avanti. 🙂
Bene!
Il tuo articolo è molto bello, è curioso, recentemente (proprio ora) ho pubblicato sul mio sito una voce che stavo preparando da qualche giorno in cui ho raccolto un elenco di metacaratteri per le espressioni regolari e alcuni esempi. Ed è stato giusto entrare DesdeLinux e vedere una voce sullo stesso argomento!
Se può consolarla, la mia è MOLTO PIÙ FIGA 😀
Certamente le regex sono una delle cose più utili, di solito le uso per tagliare l'output dei comandi e mantenere la parte che mi interessa, per poi interagire con essa in uno script bash, per esempio. Li ho usati molto anche all'università, e sono di vitale importanza nella costruzione di compilatori (nella definizione di lessicografici e parser). Insomma, un mondo intero.
Saluti e ottimo lavoro.
Grazie mille.
Mi è piaciuto anche il tuo articolo. È più conciso del mio. Può servire come riferimento rapido. È una coincidenza che li abbiamo scritti nello stesso momento. Puoi vedere che le persone sono interessate all'argomento. 🙂
Espressioni regolari per dummies =), ora è più chiaro per me, tra l'altro un modo per avere l'output con il colore per grep, è creare un alias in .bashrc alias grep = 'grep –color = always', nel caso funziona per qualcuno.
saluti
Vero. Questo è un altro modo per farlo. Grazie per l'input. 🙂
O_O… contributo !!! O_O ...
Grazie mille per il post, stavo aspettando qualcosa del genere lol, lo lascio aperto per leggerlo con calma a casa senza problemi a concentrarmi lol.
Grazie per l'articolo, davvero 😀
Sapevo che ti sarebbe piaciuto. LOL !! La verità è che mancano molte cose, ma ho già in mente una seconda parte. 🙂
Ottimo articolo, se solo l'avessi letto ieri, la lezione che ho dato oggi sarebbe stata ancora più facile per i miei studenti!
LOL !! Peccato che sia arrivato in ritardo, ma sono contento che sia utile. 🙂
Finalmente !!!, ottimo il post .... Finalmente ho trovato qualcosa che spiega chiaramente le espressioni regolari ...
Ci sono molte informazioni là fuori, ma è più difficile trovare qualcosa che sia facile da capire. Sono contento di aver colmato quel vuoto. 🙂
Saluti.
Hey ho bisogno di aiuto, devo fare una ricerca in / var / logs con il formato: yymmdd, e i log arrivano come 130901.log -130901.log, devo cercare tutti quelli che sono tra il 1 settembre e l'11 ottobre , L'unica cosa che sono riuscito a fare è stata rimuovere tutto settembre ma non so come fare la catena completa:
es: 1309 [0-3] mi restituisce i log tra il 1 settembre e il 30 settembre, ma non so come entrare anche nella stessa catena dall'1 all'11 ottobre.
Farlo usando le espressioni regolari è un po 'complicato. Mi viene in mente che qualcosa del genere potrebbe funzionare:
13(09[0-3]|10(0|1[01]))
È un'espressione regolare estesa. Non dici quale strumento stai utilizzando, quindi non posso fornirti ulteriori dettagli.
Comunque, penso che questo sia il caso invece di usare espressioni regolari è meglio farlo con find. Puoi provare qualcosa di simile:
trova. -newermt '01 sep '-a! -newermt '11 ott '-print
Fortuna. Spero che questo possa aiutarti.
Ciao! Prima di tutto, volevo ringraziarti per il tuo lavoro dato che questa pagina è nella mia "top 3" dei migliori siti Linux.
Mi stavo esercitando e non sapevo perché una RegExp su un numero di telefono non funzionasse per me ed era che mi mancava la «-E» (cosa che ho capito grazie a questo post).
Volevo chiederti se non conosci un buon pdf o un sito dove ci sono esercizi su RegExp, anche se con un po 'di immaginazione puoi esercitarti a inventarli tu stesso.
Saluti, Pablo.
Molto bene, ho appena letto tutto e sì, ora ho bisogno di un'aspirina 🙂
La migliore spiegazione che ho visto delle espressioni regolari. Ringrazio l'autore per aver condiviso questo lavoro.
Saluti.
Mi è davvero piaciuta un'ottima spiegazione