{"id":3641,"date":"2026-07-18T14:07:55","date_gmt":"2026-07-18T12:07:55","guid":{"rendered":"https:\/\/rootmail.it\/courses\/lpic-1-exam-101-010-160-corso-completo-in-italiano\/lessons\/103-7-ricercare-testo-nei-file-utilizzando-le-espressioni-regolari\/"},"modified":"2026-07-20T21:58:20","modified_gmt":"2026-07-20T19:58:20","slug":"103-7-ricercare-testo-nei-file-utilizzando-le-espressioni-regolari","status":"publish","type":"lesson","link":"https:\/\/rootmail.it\/en\/courses\/lpic-1-exam-1-101-500-corso-completo-in-italiano\/lessons\/103-7-ricercare-testo-nei-file-utilizzando-le-espressioni-regolari\/","title":{"rendered":"103.7 Ricercare testo nei file utilizzando le espressioni regolari"},"content":{"rendered":"

103.7 Ricercare testo nei file utilizzando le espressioni regolari<\/h2>\n

Le espressioni regolari<\/strong> (in inglese Regular Expressions<\/em>, spesso abbreviate in regex<\/strong>) sono uno degli strumenti pi\u00f9 potenti disponibili nei sistemi Linux per la ricerca e l’elaborazione del testo. Consentono di descrivere modelli di ricerca attraverso una sintassi compatta, permettendo di individuare parole, numeri, indirizzi, percorsi e qualsiasi altro schema ricorrente all’interno di file di testo. Le espressioni regolari sono utilizzate da numerosi strumenti del sistema, tra cui grep<\/code>, sed<\/code>, awk<\/code>, find<\/code> e molti linguaggi di programmazione. Per questo motivo rappresentano una competenza fondamentale per ogni amministratore Linux. In questa lezione imparerai a utilizzare le espressioni regolari di base per effettuare ricerche efficienti nei file di testo mediante il comando grep<\/code>.<\/p>\n

\ud83d\udca1 Exam Tip<\/strong> Per l’esame LPIC-1 \u00e8 fondamentale conoscere le espressioni regolari di base (Basic Regular Expressions – BRE), i principali metacaratteri e il loro utilizzo con il comando grep<\/code>.<\/p><\/blockquote>\n

\n

\ud83c\udfaf Obiettivi della lezione<\/h2>\n

Al termine di questa lezione sarai in grado di:<\/p>\n

    \n
  • comprendere il funzionamento delle espressioni regolari;<\/li>\n
  • ricercare testo all’interno dei file utilizzando grep<\/code>;<\/li>\n
  • utilizzare i principali metacaratteri delle espressioni regolari;<\/li>\n
  • costruire semplici pattern di ricerca;<\/li>\n
  • distinguere tra testo letterale e caratteri speciali.<\/li>\n<\/ul>\n
    \n

    Argomenti trattati<\/h2>\n
      \n
    • Introduzione alle espressioni regolari.<\/li>\n
    • Ricerca di testo con grep<\/code>.<\/li>\n
    • Metacaratteri pi\u00f9 comuni (.<\/code>, *<\/code>, ^<\/code>, $<\/code>, []<\/code>).<\/li>\n
    • Classi di caratteri e intervalli.<\/li>\n
    • Espressioni regolari di base (BRE) ed estese (ERE).<\/li>\n
    • Utilizzo pratico delle regex nell’amministrazione di sistemi Linux.<\/li>\n<\/ul>\n

      Provalo subito<\/strong>
      \nApri un terminale e crea un semplice file di testo contenente alcune righe con parole e numeri. Durante la lezione utilizzerai grep<\/code> e le espressioni regolari per ricercare rapidamente le informazioni desiderate.<\/p><\/blockquote>\n

      103.7.1 Introduzione alle espressioni regolari<\/h2>\n

      Le espressioni regolari<\/strong> (Regular Expressions o regex<\/strong>) sono sequenze di caratteri utilizzate per descrivere un modello di ricerca (search pattern<\/em>). Invece di cercare una parola esatta, permettono di individuare tutte le stringhe che rispettano determinate regole.<\/p>\n

      Le regex sono ampiamente utilizzate nell’amministrazione di sistemi Linux per analizzare file di log, verificare configurazioni, cercare informazioni all’interno di grandi quantit\u00e0 di testo e automatizzare numerose attivit\u00e0.<\/p>\n

      Molti strumenti Linux, come grep<\/code>, sed<\/code>, awk<\/code> e numerosi linguaggi di programmazione, supportano le espressioni regolari.<\/p>\n

      \ud83d\udca1 Exam Tip<\/strong> Per l’esame LPIC-1 \u00e8 importante comprendere che una regex descrive un modello di ricerca e non una stringa specifica. Lo stesso pattern pu\u00f2 quindi corrispondere a numerose stringhe differenti.<\/p><\/blockquote>\n

      \n

      Che cos’\u00e8 una regex?<\/h3>\n

      Una regex \u00e8 composta da caratteri normali e da metacaratteri<\/strong>, cio\u00e8 simboli con un significato speciale.<\/p>\n

      Ad esempio, il seguente pattern:<\/p>\n

      ^a.*z$\r\n<\/code><\/pre>\n
      corrisponde a qualsiasi stringa che:<\/p>\n
        \n
      • inizia con la lettera a<\/code>;<\/li>\n
      • pu\u00f2 contenere zero o pi\u00f9 caratteri qualsiasi;<\/li>\n
      • termina con la lettera z<\/code>.<\/li>\n<\/ul>\n
        Ad esempio, il pattern corrisponde alle seguenti stringhe:<\/p>\n
        abz\r\nalphabetz\r\namazingz\r\n<\/code><\/pre>\n
        mentre non corrisponde a:<\/p>\n
        pizza\r\nzebra\r\napple\r\n<\/code><\/pre>\n
        \n
        Analisi del pattern<\/h3>\n
        Il pattern:<\/p>\n
        ^a.*z$\r\n<\/code><\/pre>\n
        \u00e8 composto da quattro elementi fondamentali:<\/p>\n\n\n\n\n\n\n\n\n
        Elemento<\/th>\nSignificato<\/th>\n<\/tr>\n<\/thead>\n
        ^<\/code><\/td>\nInizio della riga.<\/td>\n<\/tr>\n
        a<\/code><\/td>\nLa stringa deve iniziare con la lettera “a”.<\/td>\n<\/tr>\n
        .*<\/code><\/td>\nQualsiasi carattere ripetuto zero o pi\u00f9 volte.<\/td>\n<\/tr>\n
        z$<\/code><\/td>\nLa stringa deve terminare con la lettera “z”.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
        Nelle prossime sezioni analizzeremo in dettaglio il significato di ciascun metacarattere.<\/p>\n
        \n
        Perch\u00e9 utilizzare le espressioni regolari?<\/h3>\n
        Le regex consentono di effettuare ricerche molto pi\u00f9 potenti rispetto alla semplice ricerca di una parola.<\/p>\n
        Ad esempio, \u00e8 possibile cercare:<\/p>\n
          \n
        • tutte le righe che iniziano con una determinata parola;<\/li>\n
        • indirizzi IP;<\/li>\n
        • indirizzi e-mail;<\/li>\n
        • date in uno specifico formato;<\/li>\n
        • numeri di telefono;<\/li>\n
        • file con nomi che seguono un determinato schema.<\/li>\n<\/ul>\n
          Questa flessibilit\u00e0 rende le espressioni regolari uno strumento indispensabile per l’amministrazione di sistemi Linux.<\/p>\n
          \ud83d\udccc Da ricordare<\/strong> Una regex non cerca necessariamente una parola precisa, ma tutte le stringhe che rispettano il modello definito dal pattern.<\/p><\/blockquote>\n
          \n
          Best Practice<\/h3>\n
          Quando inizi a lavorare con le espressioni regolari, costruisci i pattern in modo graduale. Parti da una ricerca semplice e aggiungi progressivamente i metacaratteri necessari. Questo approccio rende le regex pi\u00f9 facili da comprendere, verificare e correggere.<\/p>\n
          \n
          Riepilogo<\/h3>\n
            \n
          • Una espressione regolare descrive un modello di ricerca.<\/li>\n
          • Le regex sono utilizzate da strumenti come grep<\/code>, sed<\/code> e awk<\/code>.<\/li>\n
          • I metacaratteri permettono di definire criteri di ricerca molto flessibili.<\/li>\n
          • Il pattern ^a.*z$<\/code> individua le stringhe che iniziano con a<\/code> e terminano con z<\/code>.<\/li>\n
          • Le espressioni regolari sono fondamentali nell’amministrazione dei sistemi Linux.<\/li>\n<\/ul>\n
            103.7.2 Espressioni regolari di base (BRE) ed estese (ERE)<\/h2>\n
            Linux supporta due principali varianti delle espressioni regolari:<\/p>\n
              \n
            • Basic Regular Expressions (BRE)<\/strong>;<\/li>\n
            • Extended Regular Expressions (ERE)<\/strong>.<\/li>\n<\/ul>\n
              Entrambe consentono di descrivere modelli di ricerca, ma differiscono per il modo in cui interpretano alcuni metacaratteri.<\/p>\n
              Nella pratica quotidiana incontrerai entrambe le sintassi, poich\u00e9 strumenti diversi utilizzano una variante differente.<\/p>\n
              \ud83d\udca1 Exam Tip<\/strong> Per l’esame LPIC-1 \u00e8 importante conoscere la differenza tra BRE<\/strong> ed ERE<\/strong> e sapere che grep<\/code> utilizza BRE per impostazione predefinita, mentre grep -E<\/code> abilita le Extended Regular Expressions.<\/p><\/blockquote>\n
              \n
              Basic Regular Expressions (BRE)<\/h3>\n
              Le Basic Regular Expressions<\/strong> rappresentano la sintassi tradizionale delle espressioni regolari.<\/p>\n
              Alcuni metacaratteri, come:<\/p>\n
                \n
              • +<\/code><\/li>\n
              • ?<\/code><\/li>\n
              • |<\/code><\/li>\n
              • ()<\/code><\/li>\n<\/ul>\n
                non hanno un significato speciale e devono essere preceduti dal carattere di escape \\<\/code>.<\/p>\n
                Ad esempio:<\/p>\n
                grep 'colou\\?r' file.txt\r\n<\/code><\/pre>\n
                oppure:<\/p>\n
                grep 'a\\+b' file.txt\r\n<\/code><\/pre>\n
                \n
                Extended Regular Expressions (ERE)<\/h3>\n
                Le Extended Regular Expressions<\/strong> estendono la sintassi BRE introducendo metacaratteri aggiuntivi e rendendo le espressioni pi\u00f9 semplici da leggere.<\/p>\n
                Con ERE i metacaratteri:<\/p>\n
                  \n
                • +<\/code><\/li>\n
                • ?<\/code><\/li>\n
                • |<\/code><\/li>\n
                • ()<\/code><\/li>\n<\/ul>\n
                  sono interpretati direttamente e non richiedono il carattere di escape.<\/p>\n
                  Ad esempio:<\/p>\n
                  grep -E 'colou?r' file.txt\r\n<\/code><\/pre>\n
                  oppure:<\/p>\n
                  grep -E 'a+b' file.txt\r\n<\/code><\/pre>\n
                  L’opzione -E<\/code> indica a grep<\/code> di utilizzare le Extended Regular Expressions.<\/p>\n
                  \n
                  BRE ed ERE a confronto<\/h3>\n\n\n\n\n\n\n\n\n
                  Caratteristica<\/th>\nBRE<\/th>\nERE<\/th>\n<\/tr>\n<\/thead>\n
                  +<\/code><\/td>\n\\+<\/code><\/td>\n+<\/code><\/td>\n<\/tr>\n
                  ?<\/code><\/td>\n\\?<\/code><\/td>\n?<\/code><\/td>\n<\/tr>\n
                  |<\/code><\/td>\n\\|<\/code><\/td>\n|<\/code><\/td>\n<\/tr>\n
                  ()<\/code><\/td>\n\\( \\)<\/code><\/td>\n()<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
                  \n
                  Quando utilizzare BRE ed ERE?<\/h3>\n
                  Nella maggior parte dei casi:<\/p>\n
                    \n
                  • grep<\/code> utilizza le BRE<\/strong>;<\/li>\n
                  • grep -E<\/code> utilizza le ERE<\/strong>.<\/li>\n<\/ul>\n
                    Le ERE sono generalmente pi\u00f9 leggibili perch\u00e9 richiedono meno caratteri di escape.<\/p>\n
                    \ud83d\udccc Da ricordare<\/strong> Le Extended Regular Expressions non sostituiscono le Basic Regular Expressions: rappresentano semplicemente una sintassi pi\u00f9 estesa e comoda da utilizzare.<\/p><\/blockquote>\n
                    \n
                    Best Practice<\/h3>\n
                    Quando lavori con pattern complessi, preferisci grep -E<\/code>. Le espressioni risultano pi\u00f9 leggibili e richiedono meno caratteri di escape, riducendo la possibilit\u00e0 di errori.<\/p>\n
                    \n
                    Riepilogo<\/h3>\n
                      \n
                    • Linux supporta le Basic Regular Expressions (BRE)<\/strong> e le Extended Regular Expressions (ERE)<\/strong>.<\/li>\n
                    • grep<\/code> utilizza BRE per impostazione predefinita.<\/li>\n
                    • grep -E<\/code> abilita le Extended Regular Expressions.<\/li>\n
                    • Nelle BRE alcuni metacaratteri devono essere preceduti dal carattere \\<\/code>.<\/li>\n
                    • Le ERE rendono le espressioni regolari pi\u00f9 semplici da leggere e scrivere.<\/li>\n<\/ul>\n
                      103.7.3 Concetti fondamentali delle espressioni regolari<\/h2>\n
                      Le espressioni regolari sono costruite utilizzando una serie di metacaratteri<\/strong>, cio\u00e8 simboli che assumono un significato particolare all’interno di un pattern di ricerca. Comprendere questi elementi \u00e8 fondamentale per creare espressioni regolari efficaci e interpretare correttamente i risultati ottenuti.<\/p>\n
                      In questa sezione analizzeremo i concetti pi\u00f9 importanti: caratteri speciali, classi di caratteri, quantificatori e ancore.<\/p>\n
                      \ud83d\udca1 Exam Tip<\/strong> Per l’esame LPIC-1 \u00e8 fondamentale conoscere il significato dei principali metacaratteri, delle classi di caratteri, dei quantificatori e delle ancore ^<\/code> e $<\/code>.<\/p><\/blockquote>\n
                      \n
                      Caratteri speciali (Metacaratteri)<\/h3>\n
                      I metacaratteri sono simboli che assumono un significato speciale all’interno di una regex.<\/p>\n
                      Uno dei pi\u00f9 utilizzati \u00e8 il punto (.<\/code>), che rappresenta un qualsiasi carattere singolo.<\/p>\n
                      Ad esempio:<\/p>\n
                      a.c\r\n<\/code><\/pre>\n
                      corrisponde a stringhe come:<\/p>\n
                      abc\r\naxc\r\na1c\r\n<\/code><\/pre>\n
                      ma non a:<\/p>\n
                      ac\r\nabbc\r\n<\/code><\/pre>\n
                      Un altro metacarattere molto importante \u00e8 l’asterisco:<\/p>\n
                      *\r\n<\/code><\/pre>\n
                      che indica zero o pi\u00f9 ripetizioni<\/strong> del carattere che lo precede.<\/p>\n
                      Ad esempio:<\/p>\n
                      ab*\r\n<\/code><\/pre>\n
                      corrisponde a:<\/p>\n
                      a\r\nab\r\nabb\r\nabbb\r\n<\/code><\/pre>\n
                      \n
                      Classi di caratteri<\/h3>\n
                      Le classi di caratteri<\/strong> sono racchiuse tra parentesi quadre:<\/p>\n
                      [ ]\r\n<\/code><\/pre>\n
                      e consentono di indicare che \u00e8 accettato uno qualsiasi dei caratteri contenuti al loro interno.<\/p>\n
                      Ad esempio:<\/p>\n
                      [aeiou]\r\n<\/code><\/pre>\n
                      corrisponde a qualsiasi vocale.<\/p>\n
                      \u00c8 possibile definire anche intervalli:<\/p>\n
                      [a-z]\r\n<\/code><\/pre>\n
                      qualsiasi lettera minuscola.<\/p>\n
                      [A-Z]\r\n<\/code><\/pre>\n
                      qualsiasi lettera maiuscola.<\/p>\n
                      [0-9]\r\n<\/code><\/pre>\n
                      qualsiasi cifra.<\/p>\n
                      Le classi possono essere combinate:<\/p>\n
                      [A-Za-z0-9]\r\n<\/code><\/pre>\n
                      corrisponde a qualsiasi carattere alfanumerico.<\/p>\n
                      \n
                      Quantificatori<\/h3>\n
                      I quantificatori<\/strong> specificano quante volte un carattere o un gruppo pu\u00f2 comparire.<\/p>\n
                      Uno dei pi\u00f9 utilizzati \u00e8:<\/p>\n
                      {n,m}\r\n<\/code><\/pre>\n
                      che indica:<\/p>\n
                        \n
                      • almeno n<\/strong> occorrenze;<\/li>\n
                      • al massimo m<\/strong> occorrenze.<\/li>\n<\/ul>\n
                        Ad esempio:<\/p>\n
                        [0-9]{2,4}\r\n<\/code><\/pre>\n
                        corrisponde a numeri composti da due, tre oppure quattro cifre.<\/p>\n
                        Altri quantificatori comuni sono:<\/p>\n\n\n\n\n\n\n\n\n\n
                        Quantificatore<\/th>\nSignificato<\/th>\n<\/tr>\n<\/thead>\n
                        *<\/code><\/td>\nZero o pi\u00f9 occorrenze.<\/td>\n<\/tr>\n
                        +<\/code><\/td>\nUna o pi\u00f9 occorrenze.<\/td>\n<\/tr>\n
                        ?<\/code><\/td>\nZero oppure una occorrenza.<\/td>\n<\/tr>\n
                        {n}<\/code><\/td>\nEsattamente n occorrenze.<\/td>\n<\/tr>\n
                        {n,m}<\/code><\/td>\nDa n a m occorrenze.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
                        \n
                        Ancore<\/h3>\n
                        Le ancore<\/strong> non rappresentano caratteri, ma posizioni all’interno della riga.<\/p>\n
                        Le principali sono:<\/p>\n\n\n\n\n\n\n
                        Ancora<\/th>\nSignificato<\/th>\n<\/tr>\n<\/thead>\n
                        ^<\/code><\/td>\nInizio della riga.<\/td>\n<\/tr>\n
                        $<\/code><\/td>\nFine della riga.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
                        Ad esempio:<\/p>\n
                        ^Linux\r\n<\/code><\/pre>\n
                        trova solamente le righe che iniziano con la parola “Linux”.<\/p>\n
                        Mentre:<\/p>\n
                        server$\r\n<\/code><\/pre>\n
                        trova esclusivamente le righe che terminano con la parola “server”.<\/p>\n
                        Combinando entrambe le ancore:<\/p>\n
                        ^Linux$\r\n<\/code><\/pre>\n
                        si individua una riga contenente esclusivamente la parola “Linux”.<\/p>\n
                        \n
                        Riepilogo dei principali metacaratteri<\/h3>\n\n\n\n\n\n\n\n\n\n\n\n\n
                        Simbolo<\/th>\nSignificato<\/th>\n<\/tr>\n<\/thead>\n
                        .<\/code><\/td>\nQualsiasi carattere singolo.<\/td>\n<\/tr>\n
                        *<\/code><\/td>\nZero o pi\u00f9 occorrenze.<\/td>\n<\/tr>\n
                        +<\/code><\/td>\nUna o pi\u00f9 occorrenze.<\/td>\n<\/tr>\n
                        ?<\/code><\/td>\nZero oppure una occorrenza.<\/td>\n<\/tr>\n
                        []<\/code><\/td>\nClasse di caratteri.<\/td>\n<\/tr>\n
                        {n,m}<\/code><\/td>\nIntervallo di ripetizione.<\/td>\n<\/tr>\n
                        ^<\/code><\/td>\nInizio della riga.<\/td>\n<\/tr>\n
                        $<\/code><\/td>\nFine della riga.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
                        \ud83d\udccc Da ricordare<\/strong> I metacaratteri modificano il significato della ricerca. Se si desidera cercare uno di questi simboli come semplice carattere, \u00e8 generalmente necessario precederlo con il carattere di escape \\<\/code>.<\/p><\/blockquote>\n
                        \n
                        Best Practice<\/h3>\n
                        Quando costruisci una regex complessa, procedi per piccoli passi. Inizia con un pattern semplice e aggiungi progressivamente classi di caratteri, quantificatori e ancore, verificando ogni volta che il risultato ottenuto sia quello desiderato.<\/p>\n
                        \n
                        Riepilogo<\/h3>\n
                          \n
                        • I metacaratteri permettono di definire modelli di ricerca avanzati.<\/li>\n
                        • Le classi di caratteri ([]<\/code>) consentono di selezionare uno tra pi\u00f9 caratteri possibili.<\/li>\n
                        • I quantificatori definiscono il numero di occorrenze di un elemento.<\/li>\n
                        • Le ancore ^<\/code> e $<\/code> identificano rispettivamente l’inizio e la fine della riga.<\/li>\n
                        • La combinazione di questi elementi consente di costruire espressioni regolari molto potenti.<\/li>\n<\/ul>\n
                          103.7.4 Utilizzare gli strumenti che supportano le espressioni regolari<\/h2>\n
                          Le espressioni regolari diventano realmente utili quando vengono utilizzate insieme agli strumenti della riga di comando. Linux mette a disposizione numerose utility in grado di interpretare pattern di ricerca, filtrare informazioni e modificare automaticamente il contenuto dei file.<\/p>\n
                          Tra gli strumenti pi\u00f9 importanti troviamo grep<\/code>, egrep<\/code>, fgrep<\/code>, sed<\/code> e la pagina di manuale regex(7)<\/code>, che descrive in dettaglio il funzionamento delle espressioni regolari nei sistemi Linux.<\/p>\n
                          \ud83d\udca1 Exam Tip<\/strong> Per l’esame LPIC-1 \u00e8 importante conoscere le differenze tra grep<\/code>, grep -E<\/code>, grep -F<\/code> e il comando sed<\/code>, oltre a sapere dove reperire la documentazione ufficiale delle espressioni regolari.<\/p><\/blockquote>\n
                          \n
                          Ricercare testo con grep<\/code><\/h3>\n
                          Il comando grep<\/code> (Global Regular Expression Print<\/strong>) ricerca le righe di un file che corrispondono a un determinato pattern.<\/p>\n
                          La sintassi generale \u00e8:<\/p>\n
                          grep 'pattern' filename\r\n<\/code><\/pre>\n
                          Ad esempio:<\/p>\n
                          grep 'error' logfile.txt\r\n<\/code><\/pre>\n
                          Il comando visualizza tutte le righe contenenti la parola error<\/code>.<\/p>\n
                          Per impostazione predefinita, grep<\/code> utilizza le Basic Regular Expressions (BRE)<\/strong>.<\/p>\n
                          \n
                          Utilizzare le Extended Regular Expressions con grep -E<\/code><\/h3>\n
                          Le Extended Regular Expressions (ERE)<\/strong> possono essere abilitate mediante l’opzione:<\/p>\n
                          grep -E 'pattern' filename\r\n<\/code><\/pre>\n
                          Storicamente era disponibile anche il comando:<\/p>\n
                          egrep 'pattern' filename\r\n<\/code><\/pre>\n
                          Oggi egrep<\/code> \u00e8 considerato un alias di grep -E<\/code> e, nei sistemi moderni, \u00e8 preferibile utilizzare direttamente grep -E<\/code>.<\/p>\n
                          Le ERE consentono di utilizzare metacaratteri come +<\/code>, ?<\/code>, |<\/code> e ()<\/code> senza doverli precedere con il carattere di escape.<\/p>\n
                          \n
                          Ricercare stringhe letterali con grep -F<\/code><\/h3>\n
                          Quando non \u00e8 necessario utilizzare le espressioni regolari, \u00e8 possibile effettuare una semplice ricerca testuale mediante:<\/p>\n
                          grep -F 'string' filename\r\n<\/code><\/pre>\n
                          Storicamente questo comportamento era disponibile attraverso il comando:<\/p>\n
                          fgrep 'string' filename\r\n<\/code><\/pre>\n
                          Anche in questo caso, nei sistemi Linux moderni \u00e8 consigliabile utilizzare direttamente grep -F<\/code>.<\/p>\n
                          Questo comando interpreta il pattern come una normale stringa, ignorando qualsiasi metacarattere.<\/p>\n
                          \n
                          Modificare il testo con sed<\/code><\/h3>\n
                          Il comando sed<\/code> (Stream Editor<\/strong>) permette di filtrare e trasformare il testo utilizzando le espressioni regolari.<\/p>\n
                          Uno degli utilizzi pi\u00f9 comuni consiste nella sostituzione di testo.<\/p>\n
                          Ad esempio:<\/p>\n
                          sed 's\/pattern\/replacement\/g' filename\r\n<\/code><\/pre>\n
                          dove:<\/p>\n
                            \n
                          • s<\/code> indica una sostituzione;<\/li>\n
                          • pattern<\/code> rappresenta il testo da cercare;<\/li>\n
                          • replacement<\/code> \u00e8 il testo sostitutivo;<\/li>\n
                          • g<\/code> applica la sostituzione a tutte le occorrenze presenti nella riga.<\/li>\n<\/ul>\n
                            Ad esempio:<\/p>\n
                            sed 's\/Linux\/GNU\\\/Linux\/g' file.txt\r\n<\/code><\/pre>\n
                            sostituisce tutte le occorrenze della parola “Linux” con “GNU\/Linux”.<\/p>\n
                            \n
                            Consultare la documentazione<\/h3>\n
                            Linux mette a disposizione una pagina di manuale dedicata alle espressioni regolari.<\/p>\n
                            \u00c8 possibile consultarla con:<\/p>\n
                            man 7 regex\r\n<\/code><\/pre>\n
                            Questa documentazione descrive in dettaglio:<\/p>\n
                              \n
                            • la sintassi delle regex;<\/li>\n
                            • i metacaratteri disponibili;<\/li>\n
                            • le differenze tra BRE ed ERE;<\/li>\n
                            • il comportamento delle implementazioni POSIX.<\/li>\n<\/ul>\n
                              \n
                              Confronto tra gli strumenti<\/h3>\n\n\n\n\n\n\n\n\n\n
                              Comando<\/th>\nFunzione<\/th>\n<\/tr>\n<\/thead>\n
                              grep<\/code><\/td>\nRicerca utilizzando le Basic Regular Expressions (BRE).<\/td>\n<\/tr>\n
                              grep -E<\/code><\/td>\nRicerca utilizzando le Extended Regular Expressions (ERE).<\/td>\n<\/tr>\n
                              grep -F<\/code><\/td>\nRicerca stringhe letterali senza interpretare metacaratteri.<\/td>\n<\/tr>\n
                              sed<\/code><\/td>\nFiltra e modifica testo mediante espressioni regolari.<\/td>\n<\/tr>\n
                              man 7 regex<\/code><\/td>\nDocumentazione ufficiale delle espressioni regolari POSIX.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
                              \ud83d\udccc Da ricordare<\/strong> Nei sistemi Linux moderni i comandi egrep<\/code> e fgrep<\/code> sono mantenuti principalmente per compatibilit\u00e0. \u00c8 preferibile utilizzare rispettivamente grep -E<\/code> e grep -F<\/code>.<\/p><\/blockquote>\n
                              \n
                              Best Practice<\/h3>\n
                              Utilizza grep<\/code> per le ricerche semplici, grep -E<\/code> quando hai bisogno delle espressioni regolari estese e grep -F<\/code> quando desideri cercare testo letterale senza interpretare i metacaratteri. Prima di costruire pattern complessi, consulta la documentazione disponibile tramite man 7 regex<\/code>.<\/p>\n
                              \n
                              Riepilogo<\/h3>\n
                                \n
                              • grep<\/code> utilizza le Basic Regular Expressions.<\/li>\n
                              • grep -E<\/code> abilita le Extended Regular Expressions.<\/li>\n
                              • grep -F<\/code> ricerca semplici stringhe letterali.<\/li>\n
                              • sed<\/code> permette di modificare il testo utilizzando le espressioni regolari.<\/li>\n
                              • man 7 regex<\/code> fornisce la documentazione ufficiale delle regex nei sistemi Linux.<\/li>\n<\/ul>\n
                                \ud83d\udcda Riepilogo della lezione<\/h2>\n
                                In questa lezione hai scoperto il funzionamento delle espressioni regolari<\/strong> (Regular Expressions), uno degli strumenti pi\u00f9 potenti per la ricerca e l’elaborazione del testo nei sistemi Linux. Hai imparato a costruire semplici pattern di ricerca, a utilizzare i principali metacaratteri e a distinguere tra espressioni regolari di base (BRE) ed estese (ERE).<\/p>\n
                                Hai inoltre visto come strumenti come grep<\/code> e sed<\/code> sfruttano le regex per individuare, filtrare e modificare informazioni contenute nei file di testo.<\/p>\n
                                Concetti principali<\/h3>\n
                                  \n
                                • Hai compreso che una espressione regolare<\/strong> descrive un modello di ricerca e non una stringa specifica.<\/li>\n
                                • Hai imparato a utilizzare i principali metacaratteri come .<\/code>, *<\/code>, +<\/code>, ?<\/code>, []<\/code>, ^<\/code> e $<\/code>.<\/li>\n
                                • Hai scoperto il funzionamento delle classi di caratteri e dei quantificatori.<\/li>\n
                                • Hai distinto le Basic Regular Expressions (BRE)<\/strong> dalle Extended Regular Expressions (ERE)<\/strong>.<\/li>\n
                                • Hai utilizzato grep<\/code>, grep -E<\/code>, grep -F<\/code> e sed<\/code> per effettuare ricerche e trasformazioni di testo.<\/li>\n
                                • Hai imparato a consultare la documentazione ufficiale mediante man 7 regex<\/code>.<\/li>\n<\/ul>\n
                                  \ud83c\udfaf Obiettivo raggiunto<\/strong> Al termine di questa lezione sei in grado di utilizzare le espressioni regolari per ricercare informazioni nei file di testo e comprendere i pattern utilizzati dai principali strumenti di amministrazione dei sistemi Linux.<\/p><\/blockquote>\n
                                  Metacaratteri principali<\/h3>\n\n\n\n\n\n\n\n\n\n\n\n\n
                                  Simbolo<\/th>\nSignificato<\/th>\n<\/tr>\n<\/thead>\n
                                  .<\/code><\/td>\nQualsiasi carattere singolo.<\/td>\n<\/tr>\n
                                  *<\/code><\/td>\nZero o pi\u00f9 occorrenze.<\/td>\n<\/tr>\n
                                  +<\/code><\/td>\nUna o pi\u00f9 occorrenze (ERE).<\/td>\n<\/tr>\n
                                  ?<\/code><\/td>\nZero oppure una occorrenza (ERE).<\/td>\n<\/tr>\n
                                  []<\/code><\/td>\nClasse di caratteri.<\/td>\n<\/tr>\n
                                  {n,m}<\/code><\/td>\nIntervallo di ripetizione.<\/td>\n<\/tr>\n
                                  ^<\/code><\/td>\nInizio della riga.<\/td>\n<\/tr>\n
                                  $<\/code><\/td>\nFine della riga.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
                                  Comandi da ricordare<\/h3>\n\n\n\n\n\n\n\n\n\n
                                  Comando<\/th>\nDescrizione<\/th>\n<\/tr>\n<\/thead>\n
                                  grep<\/code><\/td>\nRicerca testo utilizzando le Basic Regular Expressions.<\/td>\n<\/tr>\n
                                  grep -E<\/code><\/td>\nRicerca utilizzando le Extended Regular Expressions.<\/td>\n<\/tr>\n
                                  grep -F<\/code><\/td>\nRicerca stringhe letterali senza interpretare metacaratteri.<\/td>\n<\/tr>\n
                                  sed<\/code><\/td>\nFiltra e modifica testo mediante espressioni regolari.<\/td>\n<\/tr>\n
                                  man 7 regex<\/code><\/td>\nConsulta la documentazione ufficiale delle regex POSIX.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
                                  \ud83d\udca1 Preparazione all’esame LPIC-1<\/strong> Prima di proseguire assicurati di conoscere il significato dei principali metacaratteri, la differenza tra BRE ed ERE e il funzionamento dei comandi grep<\/code>, grep -E<\/code> e sed<\/code>. Le espressioni regolari rappresentano uno degli argomenti pi\u00f9 ricorrenti dell’esame LPIC-1.<\/p><\/blockquote>\n
                                  \n
                                  \u27a1\ufe0f Prossima lezione<\/h2>\n
                                  Nella prossima lezione (103.8 Modificare file di testo di base<\/strong>) imparerai a utilizzare gli editor di testo da terminale pi\u00f9 diffusi, con particolare attenzione a vi<\/code> e vim<\/code>. Scoprirai come creare, modificare e salvare file direttamente dalla riga di comando, una competenza indispensabile per qualsiasi amministratore Linux.<\/p>\n
                                  \ud83d\udcd6 Materiale di approfondimento<\/strong> Consulta il PDF allegato alla lezione per esercitarti con laboratori guidati, scenari realistici e quiz di autovalutazione.<\/p><\/blockquote>\n","protected":false},"comment_status":"open","ping_status":"closed","template":"","class_list":["post-3641","lesson","type-lesson","status-publish","has-post-thumbnail","hentry"],"uagb_featured_image_src":[],"uagb_author_info":{"display_name":"Rootmail Academy","author_link":"https:\/\/rootmail.it\/en\/author\/"},"uagb_comment_info":0,"uagb_excerpt":"103.7 Ricercare testo nei file utilizzando le espressioni regolari Le espressioni regolari (in inglese Regular Expressions, spesso abbreviate in regex) sono uno degli strumenti pi\u00f9 potenti disponibili nei sistemi Linux per la ricerca e l’elaborazione del testo. Consentono di descrivere modelli di ricerca attraverso una sintassi compatta, permettendo di individuare parole, numeri, indirizzi, percorsi e…","_links":{"self":[{"href":"https:\/\/rootmail.it\/en\/wp-json\/wp\/v2\/lesson\/3641","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/rootmail.it\/en\/wp-json\/wp\/v2\/lesson"}],"about":[{"href":"https:\/\/rootmail.it\/en\/wp-json\/wp\/v2\/types\/lesson"}],"replies":[{"embeddable":true,"href":"https:\/\/rootmail.it\/en\/wp-json\/wp\/v2\/comments?post=3641"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/rootmail.it\/en\/wp-json\/wp\/v2\/media\/3679"}],"wp:attachment":[{"href":"https:\/\/rootmail.it\/en\/wp-json\/wp\/v2\/media?parent=3641"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}