{"id":3636,"date":"2026-07-16T15:57:15","date_gmt":"2026-07-16T13:57:15","guid":{"rendered":"https:\/\/rootmail.it\/courses\/lpic-1-exam-101-010-160-corso-completo-in-italiano\/lessons\/103-2-elaborare-flussi-di-testo-con-i-filtri\/"},"modified":"2026-07-20T21:56:54","modified_gmt":"2026-07-20T19:56:54","slug":"103-2-elaborare-flussi-di-testo-con-i-filtri","status":"publish","type":"lesson","link":"https:\/\/rootmail.it\/en\/courses\/lpic-1-exam-1-101-500-corso-completo-in-italiano\/lessons\/103-2-elaborare-flussi-di-testo-con-i-filtri\/","title":{"rendered":"103.2 Elaborare flussi di testo con i filtri"},"content":{"rendered":"

103.2 Elaborare flussi di testo con i filtri<\/h2>\n

L’elaborazione del testo \u00e8 una delle attivit\u00e0 pi\u00f9 comuni nell’amministrazione dei sistemi Linux. File di log, configurazioni, report e output dei comandi vengono costantemente analizzati, filtrati e trasformati per ottenere le informazioni desiderate. GNU\/Linux mette a disposizione un ricco insieme di strumenti, spesso chiamati text filters<\/strong>, che permettono di leggere, selezionare, ordinare, confrontare e modificare flussi di testo direttamente dalla riga di comando. Questi comandi sono progettati per lavorare insieme e rappresentano uno dei punti di forza della filosofia Unix: creare strumenti semplici che svolgono un compito specifico e possono essere combinati per risolvere problemi complessi. In questa lezione imparerai a utilizzare i principali filtri di testo, comprendendone il funzionamento e scoprendo come combinarli per elaborare rapidamente grandi quantit\u00e0 di dati.<\/p>\n

\n

Exam Tip<\/strong> Per l’esame LPIC-1 \u00e8 fondamentale conoscere i principali filtri di testo GNU, tra cui cat<\/code>, head<\/code>, tail<\/code>, cut<\/code>, paste<\/code>, sort<\/code>, uniq<\/code>, tr<\/code>, wc<\/code>, nl<\/code>, od<\/code>, split<\/code> e tee<\/code>, oltre a comprenderne l’utilizzo combinato mediante pipe e reindirizzamenti.<\/p>\n<\/blockquote>\n

\n

Obiettivi della lezione<\/h2>\n

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

    \n
  • comprendere il concetto di flusso di testo (text stream);<\/li>\n
  • utilizzare i principali filtri GNU per elaborare file e output dei comandi;<\/li>\n
  • visualizzare, ordinare, confrontare e trasformare dati testuali;<\/li>\n
  • estrarre informazioni specifiche da file di grandi dimensioni;<\/li>\n
  • combinare pi\u00f9 strumenti per realizzare elaborazioni efficienti dalla riga di comando.<\/li>\n<\/ul>\n
    \n

    Argomenti trattati<\/h2>\n
      \n
    • Introduzione ai flussi di testo.<\/li>\n
    • Visualizzazione del contenuto dei file.<\/li>\n
    • Filtri per selezionare e trasformare il testo.<\/li>\n
    • Ordinamento e rimozione dei duplicati.<\/li>\n
    • Conteggio di righe, parole e caratteri.<\/li>\n
    • Suddivisione e combinazione dei file di testo.<\/li>\n
    • Best practice nell’elaborazione dei flussi di testo.<\/li>\n<\/ul>\n
      \n

      Provalo subito<\/strong> Apri un terminale Linux e sperimenta i comandi mostrati durante la lezione utilizzando file di testo, log di sistema o l’output di altri comandi. Imparare a combinare i filtri GNU \u00e8 una delle competenze pi\u00f9 importanti per lavorare efficacemente in ambiente Linux.<\/p>\n<\/blockquote>\n

      103.2.1 Panoramica sui filtri di testo<\/h2>\n

      Uno dei principi fondamentali della filosofia Unix \u00e8 la possibilit\u00e0 di combinare piccoli strumenti specializzati per svolgere operazioni complesse. I filtri di testo (text filters)<\/strong> rappresentano uno degli esempi migliori di questo approccio. Un filtro \u00e8 un programma che legge dati da uno standard input (stdin)<\/strong>, li elabora e restituisce il risultato sullo standard output (stdout)<\/strong>. In questo modo \u00e8 possibile concatenare pi\u00f9 comandi, facendo s\u00ec che l’output di uno diventi l’input del successivo. Questo meccanismo rende la shell estremamente potente e permette di elaborare rapidamente grandi quantit\u00e0 di dati senza dover creare file temporanei.<\/p>\n

      \n

      Exam Tip<\/strong> Per l’esame LPIC-1 \u00e8 importante comprendere il funzionamento di stdin<\/strong>, stdout<\/strong> e dei filtri di testo, poich\u00e9 costituiscono la base dell’utilizzo delle pipe (|<\/code>) e dei reindirizzamenti.<\/p>\n<\/blockquote>\n

      \n

      Come funziona un filtro?<\/h3>\n

      Un filtro segue generalmente questo schema:<\/p>\n

      Input (stdin) \u2192 Elaborazione \u2192 Output (stdout)\r\n<\/code><\/pre>\n
      Il filtro riceve i dati in ingresso, li elabora e restituisce il risultato senza modificare direttamente il file originale. Ad esempio, il comando:<\/p>\n
      sort nomi.txt\r\n<\/code><\/pre>\n
      legge il contenuto del file nomi.txt<\/code>, ordina le righe in ordine alfabetico e visualizza il risultato sul terminale. Il file originale rimane invariato.<\/p>\n
      \n
      Standard Input e Standard Output<\/h3>\n
      In Linux ogni programma dispone normalmente di tre flussi standard.<\/p>\n\n\n\n\n\n\n\n
      Flusso<\/th>\nDescrizione<\/th>\n<\/tr>\n<\/thead>\n
      stdin<\/strong><\/td>\nDati ricevuti in ingresso dal programma.<\/td>\n<\/tr>\n
      stdout<\/strong><\/td>\nOutput normale prodotto dal programma.<\/td>\n<\/tr>\n
      stderr<\/strong><\/td>\nMessaggi di errore prodotti dal programma.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
      In questa lezione ci concentreremo principalmente su stdin<\/strong> e stdout<\/strong>. Lo stderr<\/strong> verr\u00e0 approfondito nella prossima lezione dedicata ai reindirizzamenti.<\/p>\n
      \n
      Combinare i filtri con le pipe<\/h3>\n
      I filtri vengono spesso utilizzati insieme al simbolo della pipe (|<\/code>)<\/strong>, che permette di collegare pi\u00f9 comandi. Ad esempio:<\/p>\n
      cat utenti.txt | sort\r\n<\/code><\/pre>\n
      In questo caso:<\/p>\n
        \n
      1. cat<\/code> legge il contenuto del file;<\/li>\n
      2. la pipe (|<\/code>) invia l’output al comando successivo;<\/li>\n
      3. sort<\/code> ordina il testo ricevuto.<\/li>\n<\/ol>\n
        Questo approccio consente di costruire elaborazioni molto potenti combinando strumenti semplici.<\/p>\n
        \n
         Da ricordare<\/strong> La pipe non salva i dati su disco, ma trasferisce direttamente l’output di un comando come input del comando successivo.<\/p>\n<\/blockquote>\n
        \n
        Perch\u00e9 utilizzare i filtri?<\/h3>\n
        L’utilizzo dei filtri offre numerosi vantaggi:<\/p>\n
          \n
        • consente di elaborare rapidamente grandi quantit\u00e0 di testo;<\/li>\n
        • riduce la necessit\u00e0 di creare file temporanei;<\/li>\n
        • permette di combinare facilmente pi\u00f9 comandi;<\/li>\n
        • favorisce la scrittura di script semplici ed efficienti.<\/li>\n<\/ul>\n
          Questa filosofia rappresenta uno dei principi fondamentali dei sistemi Unix e Linux.<\/p>\n
          \n
          Best Practice<\/h3>\n
          Preferisci sempre combinare piccoli strumenti tramite pipe anzich\u00e9 utilizzare un unico comando molto complesso. La filosofia Unix si basa proprio sulla collaborazione tra programmi semplici, ciascuno specializzato nello svolgere un compito specifico.<\/p>\n
          \n
          Riepilogo<\/h3>\n
            \n
          • Un filtro legge dati da stdin<\/strong>, li elabora e scrive il risultato su stdout<\/strong>.<\/li>\n
          • I filtri non modificano normalmente il file sorgente.<\/li>\n
          • Le pipe (|<\/code>) permettono di collegare pi\u00f9 comandi tra loro.<\/li>\n
          • I tre flussi standard sono stdin<\/strong>, stdout<\/strong> e stderr<\/strong>.<\/li>\n
          • I filtri costituiscono uno degli elementi fondamentali della filosofia Unix.<\/li>\n<\/ul>\n
            103.2.2 Visualizzare e concatenare il contenuto dei file<\/h2>\n
            Uno dei compiti pi\u00f9 frequenti durante l’amministrazione di un sistema Linux consiste nel consultare rapidamente il contenuto dei file di testo. GNU\/Linux mette a disposizione diversi strumenti che consentono di visualizzare file normali e compressi direttamente dal terminale, senza dover utilizzare editor di testo.<\/p>\n
            Il comando pi\u00f9 conosciuto \u00e8 cat<\/code>, ma esistono anche utility specifiche per leggere file compressi nei formati pi\u00f9 diffusi, come .gz<\/code>, .bz2<\/code> e .xz<\/code>.<\/p>\n
            \n
            \ud83d\udca1 Exam Tip<\/strong> Per l’esame LPIC-1 \u00e8 importante conoscere il comando cat<\/code> e le utility zcat<\/code>, bzcat<\/code> e xzcat<\/code>, utilizzate per visualizzare il contenuto di file compressi senza doverli estrarre preventivamente.<\/p>\n<\/blockquote>\n
            \n
            Il comando cat<\/code><\/h3>\n
            Il comando cat<\/code> (abbreviazione di concatenate<\/strong>) permette di visualizzare il contenuto di uno o pi\u00f9 file direttamente nel terminale.<\/p>\n
            Ad esempio:<\/p>\n
            cat file.txt\r\n<\/code><\/pre>\n
            Output:<\/p>\n
            Prima riga\r\nSeconda riga\r\nTerza riga\r\n<\/code><\/pre>\n
            Il comando legge il file e ne visualizza il contenuto senza apportare alcuna modifica.<\/p>\n
            \n
            Concatenare pi\u00f9 file<\/h3>\n
            Come suggerisce il nome, cat<\/code> pu\u00f2 anche concatenare pi\u00f9 file e mostrarne il contenuto come un unico flusso di testo.<\/p>\n
            Esempio:<\/p>\n
            cat file1.txt file2.txt\r\n<\/code><\/pre>\n
            L’output mostrer\u00e0 prima il contenuto di file1.txt<\/code> e successivamente quello di file2.txt<\/code>.<\/p>\n
            Questa funzionalit\u00e0 \u00e8 molto utile quando si desidera combinare rapidamente pi\u00f9 file di testo.<\/p>\n
            \n
            Visualizzare file compressi<\/h3>\n
            Linux mette a disposizione utility dedicate per leggere il contenuto dei file compressi senza doverli decomprimere manualmente.<\/p>\n
            Per archivi compressi con gzip<\/strong>:<\/p>\n
            zcat file.txt.gz\r\n<\/code><\/pre>\n
            Per archivi compressi con bzip2<\/strong>:<\/p>\n
            bzcat file.txt.bz2\r\n<\/code><\/pre>\n
            Per archivi compressi con xz<\/strong>:<\/p>\n
            xzcat file.txt.xz\r\n<\/code><\/pre>\n
            Questi comandi estraggono il contenuto “al volo” e lo inviano direttamente allo standard output, lasciando invariato il file compresso.<\/p>\n
            \n
            Quando utilizzare questi comandi?<\/h3>\n
            Questi strumenti risultano particolarmente utili per:<\/p>\n
              \n
            • consultare rapidamente file di configurazione;<\/li>\n
            • visualizzare file di log;<\/li>\n
            • leggere file compressi senza decomprimerli;<\/li>\n
            • combinare il contenuto di pi\u00f9 file in un unico flusso di testo.<\/li>\n<\/ul>\n
              Poich\u00e9 producono output sullo stdout<\/strong>, possono essere facilmente combinati con altri filtri tramite le pipe.<\/p>\n
              Ad esempio:<\/p>\n
              zcat access.log.gz | grep \"ERROR\"\r\n<\/code><\/pre>\n
              Questo comando visualizza solo le righe contenenti la parola ERROR<\/code> all’interno di un file di log compresso.<\/p>\n
              \n
              \ud83d\udccc Da ricordare<\/strong> Il comando cat<\/code> \u00e8 ideale per file di piccole dimensioni. Per file molto lunghi \u00e8 generalmente preferibile utilizzare strumenti come less<\/code> o more<\/code>, che permettono una consultazione pagina per pagina.<\/p>\n<\/blockquote>\n
              \n
              Best Practice<\/h3>\n
              Utilizza cat<\/code> per visualizzare rapidamente file di testo di dimensioni contenute o concatenare pi\u00f9 file. Quando lavori con file compressi, preferisci zcat<\/code>, bzcat<\/code> o xzcat<\/code> per consultare il contenuto senza creare copie temporanee o occupare spazio disco.<\/p>\n
              \n
              Riepilogo<\/h3>\n
                \n
              • cat<\/code> visualizza il contenuto di uno o pi\u00f9 file di testo.<\/li>\n
              • Il comando pu\u00f2 concatenare pi\u00f9 file in un unico flusso di output.<\/li>\n
              • zcat<\/code>, bzcat<\/code> e xzcat<\/code> permettono di leggere file compressi senza decomprimerli.<\/li>\n
              • Tutti questi comandi scrivono il risultato sullo stdout<\/strong> e possono essere combinati con altri filtri tramite le pipe.<\/li>\n
              • Per consultare file molto grandi \u00e8 preferibile utilizzare less<\/code> o more<\/code>.<\/li>\n<\/ul>\n
                103.2.3 Selezionare e modificare il testo<\/h2>\n
                GNU\/Linux mette a disposizione numerosi strumenti per selezionare, ordinare, trasformare e modificare il contenuto dei file di testo. Questi comandi sono progettati per lavorare sui flussi di testo e possono essere facilmente combinati tra loro tramite le pipe, permettendo di realizzare elaborazioni anche molto complesse con poche istruzioni.<\/p>\n
                In questa sezione analizzeremo alcuni dei filtri pi\u00f9 utilizzati nell’amministrazione dei sistemi Linux.<\/p>\n
                \n
                \ud83d\udca1 Exam Tip<\/strong> Per l’esame LPIC-1 \u00e8 importante conoscere il funzionamento dei comandi head<\/code>, tail<\/code>, cut<\/code>, nl<\/code>, sort<\/code>, uniq<\/code>, tr<\/code> e sed<\/code>, comprendendone gli utilizzi pi\u00f9 comuni.<\/p>\n<\/blockquote>\n
                \n
                Visualizzare l’inizio e la fine di un file<\/h3>\n
                I comandi head<\/code> e tail<\/code> consentono di visualizzare rispettivamente le prime e le ultime righe di un file.<\/p>\n
                Per mostrare le prime cinque righe:<\/p>\n
                head -n 5 file.txt\r\n<\/code><\/pre>\n
                Per mostrare le ultime dieci righe (valore predefinito):<\/p>\n
                tail file.txt\r\n<\/code><\/pre>\n
                Oppure, per visualizzarne un numero specifico:<\/p>\n
                tail -n 20 file.txt\r\n<\/code><\/pre>\n
                Questi strumenti sono particolarmente utili per consultare rapidamente file di log e file di grandi dimensioni.<\/p>\n
                \n
                Estrarre colonne di testo con cut<\/code><\/h3>\n
                Il comando cut<\/code> permette di estrarre specifiche porzioni di ogni riga, utilizzando delimitatori o posizioni fisse.<\/p>\n
                Ad esempio:<\/p>\n
                echo \"1:apple\" | cut -d: -f2\r\n<\/code><\/pre>\n
                Output:<\/p>\n
                apple\r\n<\/code><\/pre>\n
                In questo esempio:<\/p>\n
                  \n
                • -d:<\/code> specifica il carattere separatore (:<\/code>);<\/li>\n
                • -f2<\/code> indica di estrarre il secondo campo.<\/li>\n<\/ul>\n
                  \n
                  Numerare le righe con nl<\/code><\/h3>\n
                  Il comando nl<\/code> aggiunge un numero progressivo alle righe di un file.<\/p>\n
                  Esempio:<\/p>\n
                  echo -e \"apple\\nbanana\" | nl\r\n<\/code><\/pre>\n
                  Output:<\/p>\n
                       1  apple\r\n     2  banana\r\n<\/code><\/pre>\n
                  Questo comando \u00e8 utile durante l’analisi di file di configurazione o codice sorgente.<\/p>\n
                  \n
                  Ordinare il contenuto con sort<\/code><\/h3>\n
                  Il comando sort<\/code> ordina le righe di un file o di un flusso di testo.<\/p>\n
                  Esempio:<\/p>\n
                  echo -e \"banana\\napple\" | sort\r\n<\/code><\/pre>\n
                  Output:<\/p>\n
                  apple\r\nbanana\r\n<\/code><\/pre>\n
                  Per impostazione predefinita l’ordinamento \u00e8 alfabetico crescente.<\/p>\n
                  \n
                  Eliminare righe duplicate con uniq<\/code><\/h3>\n
                  Il comando uniq<\/code> identifica o rimuove righe duplicate consecutive.<\/p>\n
                  Esempio:<\/p>\n
                  echo -e \"apple\\napple\\nbanana\" | uniq\r\n<\/code><\/pre>\n
                  Output:<\/p>\n
                  apple\r\nbanana\r\n<\/code><\/pre>\n
                  \n
                  \ud83d\udccc Da ricordare<\/strong> uniq<\/code> elimina solo i duplicati consecutivi. Per ottenere un elenco completamente privo di duplicati \u00e8 comune combinarlo con sort<\/code>:<\/p>\n<\/blockquote>\n
                  sort file.txt | uniq\r\n<\/code><\/pre>\n
                  \n
                  Sostituire o eliminare caratteri con tr<\/code><\/h3>\n
                  Il comando tr<\/code> (translate) permette di sostituire o eliminare caratteri.<\/p>\n
                  Ad esempio:<\/p>\n
                  echo \"hello\" | tr 'h' 'y'\r\n<\/code><\/pre>\n
                  Output:<\/p>\n
                  yello\r\n<\/code><\/pre>\n
                  Pu\u00f2 essere utilizzato anche per convertire lettere minuscole in maiuscole:<\/p>\n
                  echo \"linux\" | tr 'a-z' 'A-Z'\r\n<\/code><\/pre>\n
                  Output:<\/p>\n
                  LINUX\r\n<\/code><\/pre>\n
                  \n
                  Modificare il testo con sed<\/code><\/h3>\n
                  Il comando sed<\/code> (Stream Editor<\/strong>) \u00e8 uno dei filtri pi\u00f9 potenti disponibili in Linux. Permette di cercare e sostituire testo direttamente all’interno di un flusso.<\/p>\n
                  Ad esempio:<\/p>\n
                  echo \"apple\" | sed 's\/apple\/orange\/'\r\n<\/code><\/pre>\n
                  Output:<\/p>\n
                  orange\r\n<\/code><\/pre>\n
                  Nell’esempio:<\/p>\n
                    \n
                  • s<\/code> indica l’operazione di sostituzione;<\/li>\n
                  • apple<\/code> \u00e8 il testo da cercare;<\/li>\n
                  • orange<\/code> \u00e8 il testo sostitutivo.<\/li>\n<\/ul>\n
                    sed<\/code> viene frequentemente utilizzato negli script Bash e nell’elaborazione automatica di file di configurazione.<\/p>\n
                    \n
                    Combinare pi\u00f9 filtri<\/h3>\n
                    Uno dei punti di forza di Linux consiste nella possibilit\u00e0 di combinare facilmente pi\u00f9 strumenti.<\/p>\n
                    Ad esempio:<\/p>\n
                    cat utenti.txt | sort | uniq\r\n<\/code><\/pre>\n
                    In questo caso:<\/p>\n
                      \n
                    1. il contenuto del file viene letto;<\/li>\n
                    2. le righe vengono ordinate alfabeticamente;<\/li>\n
                    3. i duplicati vengono eliminati.<\/li>\n<\/ol>\n
                      Questa filosofia di composizione dei comandi rappresenta uno dei principi fondamentali dei sistemi Unix.<\/p>\n
                      \n
                      Best Practice<\/h3>\n
                      Preferisci sempre l’utilizzo di piccoli filtri specializzati piuttosto che strumenti complessi per semplici operazioni. Combinando correttamente comandi come sort<\/code>, uniq<\/code>, cut<\/code> e sed<\/code> \u00e8 possibile elaborare grandi quantit\u00e0 di dati in modo rapido, leggibile ed efficiente.<\/p>\n
                      \n
                      Riepilogo<\/h3>\n
                        \n
                      • head<\/code> e tail<\/code> mostrano rispettivamente l’inizio e la fine di un file.<\/li>\n
                      • cut<\/code> estrae colonne o campi di testo.<\/li>\n
                      • nl<\/code> numera le righe.<\/li>\n
                      • sort<\/code> ordina il contenuto di un file.<\/li>\n
                      • uniq<\/code> elimina o identifica righe duplicate consecutive.<\/li>\n
                      • tr<\/code> sostituisce o elimina caratteri.<\/li>\n
                      • sed<\/code> modifica e trasforma flussi di testo.<\/li>\n
                      • Questi strumenti possono essere combinati mediante pipe per realizzare elaborazioni molto potenti.<\/li>\n<\/ul>\n
                        103.2.4 Altri strumenti utili per l’elaborazione del testo<\/h2>\n
                        GNU\/Linux offre numerose utility dedicate all’analisi e alla manipolazione dei file di testo. Alcune consentono di verificare l’integrit\u00e0 dei dati, altre di unire o suddividere file, mentre altre ancora permettono di contare righe, parole e caratteri o visualizzare il contenuto dei file in modo pi\u00f9 efficiente.<\/p>\n
                        Questi strumenti sono ampiamente utilizzati nell’amministrazione dei sistemi e possono essere facilmente combinati con gli altri filtri gi\u00e0 studiati.<\/p>\n
                        \n
                        \ud83d\udca1 Exam Tip<\/strong> Per l’esame LPIC-1 \u00e8 importante conoscere i comandi md5sum<\/code>, sha256sum<\/code>, sha512sum<\/code>, od<\/code>, paste<\/code>, split<\/code>, wc<\/code> e less<\/code>, comprendendone gli utilizzi principali.<\/p>\n<\/blockquote>\n
                        \n
                        Verificare l’integrit\u00e0 dei file<\/h3>\n
                        I comandi md5sum<\/code>, sha256sum<\/code> e sha512sum<\/code> calcolano l’hash<\/strong> di un file o di un flusso di testo.<\/p>\n
                        L’hash rappresenta un’impronta digitale del contenuto e viene utilizzato per verificare che un file non sia stato modificato o corrotto.<\/p>\n
                        Esempio:<\/p>\n
                        echo \"apple\" | md5sum\r\n<\/code><\/pre>\n
                        Per un file:<\/p>\n
                        sha256sum immagine.iso\r\n<\/code><\/pre>\n
                        Tra gli algoritmi disponibili:<\/p>\n
                          \n
                        • md5sum<\/code> \u2192 molto veloce, ma non pi\u00f9 considerato sicuro dal punto di vista crittografico;<\/li>\n
                        • sha256sum<\/code> \u2192 oggi il pi\u00f9 utilizzato per verificare l’integrit\u00e0 dei file;<\/li>\n
                        • sha512sum<\/code> \u2192 produce un hash pi\u00f9 lungo e offre un livello di sicurezza ancora maggiore.<\/li>\n<\/ul>\n
                          \n
                          Visualizzare i dati in formato ottale o esadecimale con od<\/code><\/h3>\n
                          Il comando od<\/code> (Octal Dump<\/strong>) visualizza il contenuto di un file in rappresentazioni alternative, come formato ottale, esadecimale o ASCII.<\/p>\n
                          Ad esempio:<\/p>\n
                          od file.bin\r\n<\/code><\/pre>\n
                          Oppure, per una visualizzazione esadecimale:<\/p>\n
                          od -x file.bin\r\n<\/code><\/pre>\n
                          Questo comando \u00e8 utile durante l’analisi di file binari e il debugging.<\/p>\n
                          \n
                          Unire file con paste<\/code><\/h3>\n
                          Il comando paste<\/code> combina le righe corrispondenti di due o pi\u00f9 file, affiancandole in colonne.<\/p>\n
                          Esempio:<\/p>\n
                          paste file1.txt file2.txt\r\n<\/code><\/pre>\n
                          Se i file contengono:<\/p>\n
                          file1.txt\r\n---------\r\nMario\r\nLuigi\r\n\r\nfile2.txt\r\n---------\r\nRoma\r\nMilano\r\n<\/code><\/pre>\n
                          L’output sar\u00e0:<\/p>\n
                          Mario    Roma\r\nLuigi    Milano\r\n<\/code><\/pre>\n
                          \n
                          Suddividere file con split<\/code><\/h3>\n
                          Il comando split<\/code> divide un file di grandi dimensioni in pi\u00f9 parti.<\/p>\n
                          Ad esempio:<\/p>\n
                          split -b 10K archivio.log parte_\r\n<\/code><\/pre>\n
                          In questo caso:<\/p>\n
                            \n
                          • -b 10K<\/code> indica una dimensione di 10 KB per ogni file;<\/li>\n
                          • parte_<\/code> rappresenta il prefisso dei file generati.<\/li>\n<\/ul>\n
                            Questo comando \u00e8 particolarmente utile quando \u00e8 necessario trasferire file molto grandi o elaborarli separatamente.<\/p>\n
                            \n
                            Contare righe, parole e caratteri con wc<\/code><\/h3>\n
                            Il comando wc<\/code> (Word Count<\/strong>) permette di contare:<\/p>\n
                              \n
                            • righe;<\/li>\n
                            • parole;<\/li>\n
                            • caratteri;<\/li>\n
                            • byte.<\/li>\n<\/ul>\n
                              Ad esempio, per contare il numero di righe di un file:<\/p>\n
                              wc -l file.txt\r\n<\/code><\/pre>\n
                              Per ottenere tutte le informazioni disponibili:<\/p>\n
                              wc file.txt\r\n<\/code><\/pre>\n
                              L’output mostra, nell’ordine:<\/p>\n
                                \n
                              • numero di righe;<\/li>\n
                              • numero di parole;<\/li>\n
                              • numero di byte.<\/li>\n<\/ul>\n
                                \n
                                Consultare file con less<\/code><\/h3>\n
                                Il comando less<\/code> permette di visualizzare file di testo molto grandi in modo interattivo.<\/p>\n
                                Esempio:<\/p>\n
                                less file.log\r\n<\/code><\/pre>\n
                                A differenza di cat<\/code>, less<\/code> consente di:<\/p>\n
                                  \n
                                • scorrere avanti e indietro nel file;<\/li>\n
                                • ricercare testo;<\/li>\n
                                • aprire file di grandi dimensioni senza caricarli completamente in memoria.<\/li>\n<\/ul>\n
                                  Per uscire da less<\/code> \u00e8 sufficiente premere il tasto q<\/strong>.<\/p>\n
                                  \n
                                  \ud83d\udccc Da ricordare<\/strong> less<\/code> \u00e8 generalmente preferibile a cat<\/code> quando si consultano file molto lunghi, come i log di sistema.<\/p>\n<\/blockquote>\n
                                  \n
                                  Best Practice<\/h3>\n
                                  Utilizza sha256sum<\/code> o sha512sum<\/code> per verificare l’integrit\u00e0 dei file scaricati, preferisci less<\/code> per consultare file di grandi dimensioni e sfrutta wc<\/code> e split<\/code> quando devi analizzare o suddividere grandi quantit\u00e0 di dati.<\/p>\n
                                  \n
                                  Riepilogo<\/h3>\n
                                    \n
                                  • md5sum<\/code>, sha256sum<\/code> e sha512sum<\/code> calcolano l’hash di file e dati.<\/li>\n
                                  • od<\/code> visualizza il contenuto dei file in formati alternativi.<\/li>\n
                                  • paste<\/code> unisce le righe corrispondenti di pi\u00f9 file.<\/li>\n
                                  • split<\/code> divide un file in parti pi\u00f9 piccole.<\/li>\n
                                  • wc<\/code> conta righe, parole, caratteri e byte.<\/li>\n
                                  • less<\/code> \u00e8 il visualizzatore ideale per file di grandi dimensioni.<\/li>\n<\/ul>\n
                                    \ud83d\udcda Riepilogo della lezione<\/h2>\n
                                    In questa lezione hai scoperto come utilizzare i principali filtri di testo GNU\/Linux<\/strong> per visualizzare, selezionare, ordinare e trasformare informazioni direttamente dalla riga di comando. Hai imparato a elaborare flussi di testo sfruttando strumenti semplici ma estremamente potenti, progettati per essere combinati tra loro attraverso le pipe.<\/p>\n
                                    Hai inoltre conosciuto utility dedicate alla verifica dell’integrit\u00e0 dei file, alla gestione di file compressi, alla suddivisione di grandi archivi e alla consultazione efficiente di file di grandi dimensioni.<\/p>\n
                                    Concetti principali<\/h3>\n
                                      \n
                                    • Hai compreso il funzionamento dei filtri di testo e il loro utilizzo sui flussi standard di input e output.<\/li>\n
                                    • Hai imparato a visualizzare il contenuto dei file con cat<\/code> e dei file compressi con zcat<\/code>, bzcat<\/code> e xzcat<\/code>.<\/li>\n
                                    • Hai utilizzato head<\/code> e tail<\/code> per consultare rapidamente l’inizio e la fine dei file.<\/li>\n
                                    • Hai imparato a estrarre dati con cut<\/code>, numerare righe con nl<\/code> e trasformare il testo con tr<\/code> e sed<\/code>.<\/li>\n
                                    • Hai ordinato dati con sort<\/code> ed eliminato duplicati mediante uniq<\/code>.<\/li>\n
                                    • Hai verificato l’integrit\u00e0 dei file utilizzando md5sum<\/code>, sha256sum<\/code> e sha512sum<\/code>.<\/li>\n
                                    • Hai conosciuto strumenti aggiuntivi come paste<\/code>, split<\/code>, wc<\/code>, od<\/code> e less<\/code>.<\/li>\n<\/ul>\n
                                      \n
                                      \ud83c\udfaf Obiettivo raggiunto<\/strong> Al termine di questa lezione sei in grado di elaborare efficacemente file e flussi di testo utilizzando i principali strumenti GNU\/Linux, combinandoli tra loro per risolvere rapidamente attivit\u00e0 di amministrazione e analisi dei dati.<\/p>\n<\/blockquote>\n
                                      Comandi da ricordare<\/h3>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
                                      Comando<\/th>\nDescrizione<\/th>\n<\/tr>\n<\/thead>\n
                                      cat<\/code><\/td>\nVisualizza o concatena file di testo.<\/td>\n<\/tr>\n
                                      zcat<\/code>, bzcat<\/code>, xzcat<\/code><\/td>\nVisualizzano file compressi senza decomprimerli.<\/td>\n<\/tr>\n
                                      head<\/code><\/td>\nMostra le prime righe di un file.<\/td>\n<\/tr>\n
                                      tail<\/code><\/td>\nMostra le ultime righe di un file.<\/td>\n<\/tr>\n
                                      cut<\/code><\/td>\nEstrae colonne o campi di testo.<\/td>\n<\/tr>\n
                                      nl<\/code><\/td>\nNumera le righe di un file.<\/td>\n<\/tr>\n
                                      sort<\/code><\/td>\nOrdina il contenuto di un file.<\/td>\n<\/tr>\n
                                      uniq<\/code><\/td>\nElimina o identifica righe duplicate.<\/td>\n<\/tr>\n
                                      tr<\/code><\/td>\nSostituisce o elimina caratteri.<\/td>\n<\/tr>\n
                                      sed<\/code><\/td>\nModifica e trasforma flussi di testo.<\/td>\n<\/tr>\n
                                      md5sum<\/code>, sha256sum<\/code>, sha512sum<\/code><\/td>\nCalcolano l’hash di file e dati.<\/td>\n<\/tr>\n
                                      od<\/code><\/td>\nVisualizza dati in formato ottale, esadecimale e altri formati.<\/td>\n<\/tr>\n
                                      paste<\/code><\/td>\nUnisce le righe corrispondenti di pi\u00f9 file.<\/td>\n<\/tr>\n
                                      split<\/code><\/td>\nDivide un file in parti pi\u00f9 piccole.<\/td>\n<\/tr>\n
                                      wc<\/code><\/td>\nConta righe, parole, caratteri e byte.<\/td>\n<\/tr>\n
                                      less<\/code><\/td>\nVisualizza file di grandi dimensioni in modo interattivo.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
                                      \n
                                      \ud83d\udca1 Preparazione all’esame LPIC-1<\/strong> Prima di proseguire assicurati di conoscere il funzionamento dei principali filtri GNU\/Linux e di sapere quando utilizzare strumenti come head<\/code>, tail<\/code>, cut<\/code>, sort<\/code>, uniq<\/code>, tr<\/code>, sed<\/code>, wc<\/code> e less<\/code>. Ricorda inoltre che la vera potenza di questi strumenti risiede nella possibilit\u00e0 di combinarli attraverso le pipe.<\/p>\n<\/blockquote>\n
                                      \n
                                      \u27a1\ufe0f Prossima lezione<\/h2>\n
                                      Nella prossima lezione (103.3 Utilizzare stream, pipe e reindirizzamenti<\/strong>) approfondirai il funzionamento dei flussi standard di Linux (stdin<\/code>, stdout<\/code> e stderr<\/code>) e imparerai a reindirizzare input e output, concatenare comandi con le pipe e creare elaborazioni sempre pi\u00f9 potenti direttamente dalla riga di comando.<\/p>\n
                                      \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>\n<\/blockquote>\n","protected":false},"comment_status":"open","ping_status":"closed","template":"","class_list":["post-3636","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.2 Elaborare flussi di testo con i filtri L’elaborazione del testo \u00e8 una delle attivit\u00e0 pi\u00f9 comuni nell’amministrazione dei sistemi Linux. File di log, configurazioni, report e output dei comandi vengono costantemente analizzati, filtrati e trasformati per ottenere le informazioni desiderate. GNU\/Linux mette a disposizione un ricco insieme di strumenti, spesso chiamati text filters, che…","_links":{"self":[{"href":"https:\/\/rootmail.it\/en\/wp-json\/wp\/v2\/lesson\/3636","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=3636"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/rootmail.it\/en\/wp-json\/wp\/v2\/media\/3674"}],"wp:attachment":[{"href":"https:\/\/rootmail.it\/en\/wp-json\/wp\/v2\/media?parent=3636"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}