{"id":3637,"date":"2026-07-16T22:55:04","date_gmt":"2026-07-16T20:55:04","guid":{"rendered":"https:\/\/rootmail.it\/courses\/lpic-1-exam-101-010-160-corso-completo-in-italiano\/lessons\/103-3-utilizzare-stream-pipe-e-reindirizzamenti\/"},"modified":"2026-07-20T21:57:31","modified_gmt":"2026-07-20T19:57:31","slug":"103-3-utilizzare-stream-pipe-e-reindirizzamenti","status":"publish","type":"lesson","link":"https:\/\/rootmail.it\/en\/courses\/lpic-1-exam-1-101-500-corso-completo-in-italiano\/lessons\/103-3-utilizzare-stream-pipe-e-reindirizzamenti\/","title":{"rendered":"103.3 Utilizzare stream, pipe e reindirizzamenti"},"content":{"rendered":"

103.3 Utilizzare stream, pipe e reindirizzamenti<\/h2>\n

Uno dei principi fondamentali dei sistemi GNU\/Linux \u00e8 la possibilit\u00e0 di far collaborare pi\u00f9 programmi attraverso lo scambio di dati. Ogni comando pu\u00f2 ricevere informazioni in ingresso, elaborarle e produrre un risultato che pu\u00f2 essere visualizzato sullo schermo, salvato in un file oppure utilizzato direttamente da un altro comando.<\/p>\n

Questo meccanismo \u00e8 reso possibile grazie ai flussi standard (stream)<\/strong>, alle pipe<\/strong> e ai reindirizzamenti<\/strong>, strumenti che consentono di costruire potenti sequenze di comandi senza dover ricorrere a programmi complessi o creare file temporanei.<\/p>\n

In questa lezione imparerai a gestire i tre flussi standard di Linux (stdin<\/strong>, stdout<\/strong> e stderr<\/strong>), a collegare pi\u00f9 comandi mediante le pipe e a reindirizzare input e output verso file o altri programmi. Queste competenze rappresentano uno dei pilastri dell’amministrazione di sistemi Linux e sono indispensabili per scrivere script efficaci e automatizzare le attivit\u00e0 quotidiane.<\/p>\n

\ud83d\udca1 Exam Tip<\/strong> Per l’esame LPIC-1 \u00e8 fondamentale conoscere il funzionamento dei tre stream standard (stdin<\/code>, stdout<\/code> e stderr<\/code>), il simbolo della pipe (|<\/code>) e i principali operatori di reindirizzamento come ><\/code>, >><\/code>, <<\/code>, 2><\/code> e 2>&1<\/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 ruolo dei flussi standard (stdin<\/code>, stdout<\/code> e stderr<\/code>);<\/li>\n
  • utilizzare le pipe per collegare pi\u00f9 comandi tra loro;<\/li>\n
  • reindirizzare l’output e gli errori verso file o altri programmi;<\/li>\n
  • utilizzare il comando tee<\/code> per visualizzare e salvare contemporaneamente l’output;<\/li>\n
  • costruire pipeline efficienti combinando i principali strumenti GNU\/Linux.<\/li>\n<\/ul>\n
    \n

    Argomenti trattati<\/h2>\n
      \n
    • I tre stream standard di Linux.<\/li>\n
    • Le pipe e la concatenazione dei comandi.<\/li>\n
    • Reindirizzamento dell’input e dell’output.<\/li>\n
    • Gestione dell’output degli errori.<\/li>\n
    • Utilizzo del comando tee<\/code>.<\/li>\n
    • Best practice nella gestione dei flussi di dati.<\/li>\n<\/ul>\n

      \u2328\ufe0f Provalo subito<\/strong>
      \nApri un terminale Linux e sperimenta le pipe e i reindirizzamenti mostrati durante la lezione. Imparare a combinare pi\u00f9 comandi \u00e8 una delle competenze pi\u00f9 importanti per utilizzare al meglio la shell Linux.<\/p><\/blockquote>\n

      103.3.1 Comprendere gli stream standard<\/h2>\n

      Ogni programma eseguito in Linux comunica con il sistema operativo attraverso uno o pi\u00f9 flussi di dati (stream)<\/strong>. Gli stream rappresentano i canali utilizzati per ricevere dati in ingresso, produrre risultati e segnalare eventuali errori.<\/p>\n

      Per impostazione predefinita, questi flussi sono collegati al terminale, ma possono essere facilmente reindirizzati verso file, altri programmi o dispositivi. Comprendere il funzionamento degli stream \u00e8 essenziale per sfruttare appieno la potenza della shell Linux.<\/p>\n

      \ud83d\udca1 Exam Tip<\/strong> Per l’esame LPIC-1 \u00e8 fondamentale conoscere i tre stream standard: stdin<\/strong>, stdout<\/strong> e stderr<\/strong>, oltre al loro comportamento predefinito.<\/p><\/blockquote>\n

      \n

      I tre stream standard<\/h3>\n

      Ogni processo Linux dispone normalmente di tre flussi standard.<\/p>\n\n\n\n\n\n\n\n
      Stream<\/th>\nNome<\/th>\nDestinazione predefinita<\/th>\n<\/tr>\n<\/thead>\n
      stdin (0)<\/strong><\/td>\nStandard Input<\/td>\nTastiera<\/td>\n<\/tr>\n
      stdout (1)<\/strong><\/td>\nStandard Output<\/td>\nTerminale<\/td>\n<\/tr>\n
      stderr (2)<\/strong><\/td>\nStandard Error<\/td>\nTerminale<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

      Ogni stream possiede un proprio file descriptor<\/strong>, un identificatore numerico utilizzato dal sistema operativo:<\/p>\n

        \n
      • 0<\/strong> \u2192 Standard Input (stdin<\/code>)<\/li>\n
      • 1<\/strong> \u2192 Standard Output (stdout<\/code>)<\/li>\n
      • 2<\/strong> \u2192 Standard Error (stderr<\/code>)<\/li>\n<\/ul>\n

        Questi numeri verranno utilizzati nei reindirizzamenti che vedremo nelle prossime sezioni.<\/p>\n

        \n

        Standard Input (stdin)<\/h3>\n

        Lo Standard Input<\/strong> rappresenta il canale attraverso il quale un programma riceve i dati in ingresso.<\/p>\n

        Per impostazione predefinita, lo stdin<\/code> \u00e8 collegato alla tastiera.<\/p>\n

        Ad esempio:<\/p>\n

        cat\r\n<\/code><\/pre>\n
        Dopo aver eseguito il comando, tutto ci\u00f2 che viene digitato viene inviato a cat<\/code>, che lo visualizza immediatamente sullo schermo.<\/p>\n
        L’esecuzione termina premendo Ctrl + D<\/strong>, che segnala la fine dell’input.<\/p>\n
        \n
        Standard Output (stdout)<\/h3>\n
        Lo Standard Output<\/strong> \u00e8 il canale utilizzato dai programmi per inviare il risultato delle operazioni eseguite.<\/p>\n
        Per impostazione predefinita, lo stdout<\/code> \u00e8 collegato al terminale.<\/p>\n
        Ad esempio:<\/p>\n
        echo \"Benvenuto in Linux\"\r\n<\/code><\/pre>\n
        Output:<\/p>\n
        Benvenuto in Linux\r\n<\/code><\/pre>\n
        Nelle prossime sezioni vedremo come reindirizzare questo output verso un file anzich\u00e9 visualizzarlo sullo schermo.<\/p>\n
        \n
        Standard Error (stderr)<\/h3>\n
        Lo Standard Error<\/strong> viene utilizzato esclusivamente per i messaggi di errore.<\/p>\n
        Anche questo flusso, per impostazione predefinita, \u00e8 collegato al terminale.<\/p>\n
        Ad esempio:<\/p>\n
        ls file_inesistente\r\n<\/code><\/pre>\n
        Output:<\/p>\n
        ls: impossibile accedere a 'file_inesistente': File o directory non esistente\r\n<\/code><\/pre>\n
        Separare lo stderr<\/code> dallo stdout<\/code> permette di gestire in modo indipendente risultati e messaggi di errore, caratteristica molto utile negli script Bash.<\/p>\n
        \n
        Perch\u00e9 esistono tre stream separati?<\/h3>\n
        La separazione dei flussi consente una gestione molto pi\u00f9 flessibile dei programmi.<\/p>\n
        Ad esempio \u00e8 possibile:<\/p>\n
          \n
        • salvare solo l’output normale in un file;<\/li>\n
        • registrare gli errori in un file separato;<\/li>\n
        • inviare l’output di un comando come input di un altro programma;<\/li>\n
        • automatizzare operazioni complesse senza modificare i programmi.<\/li>\n<\/ul>\n
          Questa architettura rappresenta uno degli elementi fondamentali della filosofia Unix.<\/p>\n
          \ud83d\udccc Da ricordare<\/strong> Anche se stdout<\/strong> e stderr<\/strong> vengono normalmente visualizzati entrambi nel terminale, si tratta di due flussi completamente distinti che possono essere reindirizzati separatamente.<\/p><\/blockquote>\n
          \n
          Best Practice<\/h3>\n
          Quando sviluppi script Bash o automatizzi attivit\u00e0 amministrative, gestisci sempre separatamente l’output normale e i messaggi di errore. Questo rende gli script pi\u00f9 affidabili, facilita il troubleshooting e permette di registrare gli errori senza perdere i risultati dell’elaborazione.<\/p>\n
          \n
          Riepilogo<\/h3>\n
            \n
          • Ogni programma Linux utilizza tre stream standard.<\/li>\n
          • stdin (0)<\/strong> riceve i dati in ingresso.<\/li>\n
          • stdout (1)<\/strong> produce l’output normale.<\/li>\n
          • stderr (2)<\/strong> produce i messaggi di errore.<\/li>\n
          • I tre stream possono essere reindirizzati indipendentemente.<\/li>\n
          • La separazione degli stream rappresenta uno dei principi fondamentali dei sistemi Unix.<\/li>\n<\/ul>\n
            103.3.2 Reindirizzamenti<\/h2>\n
            I reindirizzamenti (redirections)<\/strong> consentono di modificare la sorgente dei dati in ingresso o la destinazione dell’output prodotto da un comando. Invece di leggere i dati dalla tastiera o visualizzare il risultato sul terminale, \u00e8 possibile utilizzare file o altri dispositivi.<\/p>\n
            Questa funzionalit\u00e0 \u00e8 uno dei pilastri della shell Linux e viene utilizzata quotidianamente nell’amministrazione dei sistemi e nella scrittura di script.<\/p>\n
            \ud83d\udca1 Exam Tip<\/strong> Per l’esame LPIC-1 \u00e8 fondamentale conoscere gli operatori di reindirizzamento ><\/code>, >><\/code>, <<\/code>, 2><\/code> e la differenza tra il reindirizzamento dello stdout<\/strong> e dello stderr<\/strong>.<\/p><\/blockquote>\n
            \n
            Reindirizzare lo Standard Output<\/h3>\n
            Per impostazione predefinita, l’output di un comando viene visualizzato sul terminale (stdout).<\/p>\n
            Per salvarlo in un file si utilizza l’operatore ><\/code>.<\/p>\n
            Esempio:<\/p>\n
            echo \"Hello, World\" > hello.txt\r\n<\/code><\/pre>\n
            Se il file non esiste viene creato automaticamente.<\/p>\n
            Se il file esiste gi\u00e0, il suo contenuto viene completamente sostituito.<\/p>\n
            \u26a0\ufe0f Attenzione<\/strong> L’operatore ><\/code> sovrascrive il contenuto del file. Utilizzalo con cautela.<\/p><\/blockquote>\n
            \n
            Aggiungere dati a un file<\/h3>\n
            Per aggiungere nuovo contenuto mantenendo quello gi\u00e0 presente si utilizza l’operatore >><\/code>.<\/p>\n
            Esempio:<\/p>\n
            echo \"Hello, again\" >> hello.txt\r\n<\/code><\/pre>\n
            Il testo verr\u00e0 aggiunto alla fine del file senza cancellarne il contenuto precedente.<\/p>\n
            \n
            Reindirizzare lo Standard Error<\/h3>\n
            I messaggi di errore possono essere salvati separatamente utilizzando il file descriptor 2<\/strong>.<\/p>\n
            Esempio:<\/p>\n
            comando 2> errors.txt\r\n<\/code><\/pre>\n
            In questo caso:<\/p>\n
              \n
            • l’output normale continua ad essere visualizzato sul terminale;<\/li>\n
            • i messaggi di errore vengono salvati nel file errors.txt<\/code>.<\/li>\n<\/ul>\n
              \n
              Reindirizzare output ed errori in file separati<\/h3>\n
              \u00c8 possibile salvare separatamente l’output normale e gli errori.<\/p>\n
              Esempio:<\/p>\n
              comando > output.txt 2> errors.txt\r\n<\/code><\/pre>\n
              In questo modo:<\/p>\n
                \n
              • lo stdout<\/strong> viene salvato nel file output.txt<\/code>;<\/li>\n
              • lo stderr<\/strong> viene salvato nel file errors.txt<\/code>.<\/li>\n<\/ul>\n
                Questa tecnica \u00e8 molto utilizzata negli script Bash e nelle attivit\u00e0 di troubleshooting.<\/p>\n
                \n
                Reindirizzare stdout e stderr nello stesso file<\/h3>\n
                Quando si desidera salvare sia l’output normale sia gli errori nello stesso file \u00e8 possibile utilizzare:<\/p>\n
                comando &> combined.txt\r\n<\/code><\/pre>\n
                In Bash questo operatore reindirizza contemporaneamente sia stdout<\/code> sia stderr<\/code>.<\/p>\n
                \ud83d\udccc Da ricordare<\/strong> In molte distribuzioni Linux \u00e8 comune trovare anche la sintassi comando > file 2>&1<\/code>, che ottiene lo stesso risultato ed \u00e8 compatibile con un maggior numero di shell.<\/p><\/blockquote>\n
                \n
                Schema riassuntivo<\/h3>\n\n\n\n\n\n\n\n\n\n
                Operatore<\/th>\nFunzione<\/th>\n<\/tr>\n<\/thead>\n
                ><\/code><\/td>\nReindirizza lo stdout sovrascrivendo il file.<\/td>\n<\/tr>\n
                >><\/code><\/td>\nAggiunge lo stdout alla fine del file.<\/td>\n<\/tr>\n
                2><\/code><\/td>\nReindirizza lo stderr.<\/td>\n<\/tr>\n
                > output.txt 2> errors.txt<\/code><\/td>\nSalva stdout e stderr in due file distinti.<\/td>\n<\/tr>\n
                &> file<\/code><\/td>\nSalva stdout e stderr nello stesso file (Bash).<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
                \n
                Best Practice<\/h3>\n
                Quando esegui script o attivit\u00e0 di amministrazione, separa l’output normale dai messaggi di errore ogni volta che pu\u00f2 essere utile per il debugging. Utilizza invece un unico file di log quando desideri conservare tutte le informazioni prodotte dal comando.<\/p>\n
                \n
                Riepilogo<\/h3>\n
                  \n
                • I reindirizzamenti modificano la destinazione dell’input e dell’output dei programmi.<\/li>\n
                • ><\/code> salva lo stdout sovrascrivendo il file.<\/li>\n
                • >><\/code> aggiunge lo stdout in coda al file.<\/li>\n
                • 2><\/code> reindirizza lo stderr.<\/li>\n
                • \u00c8 possibile salvare stdout e stderr in file separati oppure nello stesso file.<\/li>\n
                • I reindirizzamenti sono uno degli strumenti fondamentali della shell Linux.<\/li>\n<\/ul>\n
                  103.3.4 Utilizzare il comando tee<\/code><\/h2>\n
                  Normalmente, quando un comando produce un output, questo viene visualizzato sul terminale oppure reindirizzato verso un file. In alcune situazioni pu\u00f2 essere utile fare entrambe le cose contemporaneamente: visualizzare il risultato sullo schermo e salvarne una copia in un file.<\/p>\n
                  Il comando tee<\/code> svolge proprio questa funzione. Legge i dati dallo Standard Input (stdin)<\/strong> e li invia contemporaneamente allo Standard Output (stdout)<\/strong> e a uno o pi\u00f9 file.<\/p>\n
                  Per questo motivo si dice che tee<\/code> “duplica” o “dirama” il flusso di dati.<\/p>\n
                  \ud83d\udca1 Exam Tip<\/strong> Per l’esame LPIC-1 \u00e8 importante ricordare che tee<\/code> legge i dati dallo stdin<\/strong> e li invia contemporaneamente al terminale e a uno o pi\u00f9 file.<\/p><\/blockquote>\n
                  \n
                  Utilizzo di base<\/h3>\n
                  La sintassi generale \u00e8:<\/p>\n
                  comando | tee file.txt\r\n<\/code><\/pre>\n
                  Ad esempio:<\/p>\n
                  echo \"Hello, World\" | tee hello.txt\r\n<\/code><\/pre>\n
                  L’output sar\u00e0:<\/p>\n
                  Hello, World\r\n<\/code><\/pre>\n
                  e contemporaneamente il testo verr\u00e0 salvato nel file hello.txt<\/code>.<\/p>\n
                  \n
                  Come funziona tee<\/code><\/h3>\n
                  Il flusso dei dati pu\u00f2 essere rappresentato nel seguente modo:<\/p>\n
                  stdin\r\n   \u2502\r\n   \u25bc\r\n  tee\r\n \u251c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u25ba Terminale (stdout)\r\n \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u25ba hello.txt\r\n<\/code><\/pre>\n
                  In questo modo \u00e8 possibile monitorare l’output di un comando senza rinunciare a salvarne una copia.<\/p>\n
                  \n
                  Salvare l’output senza interrompere una pipeline<\/h3>\n
                  Uno degli utilizzi pi\u00f9 comuni di tee<\/code> consiste nel salvare un risultato intermedio mantenendo attiva la pipeline.<\/p>\n
                  Ad esempio:<\/p>\n
                  cat access.log | grep \"ERROR\" | tee errori.log | wc -l\r\n<\/code><\/pre>\n
                  In questo caso:<\/p>\n
                    \n
                  1. grep<\/code> seleziona le righe contenenti ERROR<\/strong>;<\/li>\n
                  2. tee<\/code> salva tali righe nel file errori.log<\/code>;<\/li>\n
                  3. le stesse righe vengono inviate a wc -l<\/code>, che ne conta il numero.<\/li>\n<\/ol>\n
                    Senza tee<\/code> sarebbe necessario eseguire il comando due volte oppure creare manualmente un file temporaneo.<\/p>\n
                    \n
                    Aggiungere dati a un file<\/h3>\n
                    Per impostazione predefinita, tee<\/code> sovrascrive il file di destinazione.<\/p>\n
                    Per aggiungere il contenuto in coda si utilizza l’opzione -a<\/code>.<\/p>\n
                    Esempio:<\/p>\n
                    echo \"Nuova riga\" | tee -a log.txt\r\n<\/code><\/pre>\n
                    L’opzione -a<\/code> (append<\/strong>) mantiene il contenuto esistente e aggiunge il nuovo testo alla fine del file.<\/p>\n
                    \n
                    Quando utilizzare tee<\/code><\/h3>\n
                    Il comando tee<\/code> \u00e8 particolarmente utile quando si desidera:<\/p>\n
                      \n
                    • salvare una copia dell’output di un comando;<\/li>\n
                    • monitorare il risultato di una pipeline in tempo reale;<\/li>\n
                    • registrare log durante l’esecuzione di script;<\/li>\n
                    • evitare di eseguire due volte lo stesso comando.<\/li>\n<\/ul>\n
                      \ud83d\udccc Da ricordare<\/strong> A differenza del semplice reindirizzamento (><\/code>), tee<\/code> non interrompe il flusso della pipeline: l’output continua verso il comando successivo mentre viene contemporaneamente salvato nel file.<\/p><\/blockquote>\n
                      \n
                      Best Practice<\/h3>\n
                      Utilizza tee<\/code> quando desideri registrare l’output di un comando mantenendolo visibile sul terminale. Nelle pipeline complesse rappresenta uno strumento molto utile per il debugging e per creare file di log senza interrompere l’elaborazione dei dati.<\/p>\n
                      \n
                      Riepilogo<\/h3>\n
                        \n
                      • tee<\/code> legge i dati dallo stdin<\/strong>.<\/li>\n
                      • Invia contemporaneamente l’output al terminale e a uno o pi\u00f9 file.<\/li>\n
                      • L’opzione -a<\/code> aggiunge i dati in coda al file anzich\u00e9 sovrascriverlo.<\/li>\n
                      • tee<\/code> permette di salvare una copia dell’output senza interrompere una pipeline.<\/li>\n
                      • \u00c8 uno strumento molto utile per il logging e il debugging degli script.<\/li>\n<\/ul>\n
                        103.3.5 Utilizzare il comando xargs<\/code><\/h2>\n
                        Il comando xargs<\/code> permette di trasformare i dati ricevuti dallo Standard Input (stdin)<\/strong> negli argomenti di un altro comando. In questo modo \u00e8 possibile combinare facilmente pi\u00f9 utility Linux e automatizzare operazioni su grandi quantit\u00e0 di file o dati.<\/p>\n
                        xargs<\/code> viene spesso utilizzato insieme a comandi come find<\/code>, grep<\/code> e echo<\/code>, consentendo di costruire pipeline estremamente potenti.<\/p>\n
                        \ud83d\udca1 Exam Tip<\/strong> Per l’esame LPIC-1 \u00e8 importante sapere che xargs<\/code> legge i dati dallo stdin<\/strong> e li converte negli argomenti del comando specificato.<\/p><\/blockquote>\n
                        \n
                        Come funziona xargs<\/code><\/h3>\n
                        La sintassi generale \u00e8:<\/p>\n
                        comando | xargs altro_comando\r\n<\/code><\/pre>\n
                        L’output del primo comando viene trasformato negli argomenti del secondo comando.<\/p>\n
                        Ad esempio:<\/p>\n
                        echo \"hello.txt\" | xargs rm\r\n<\/code><\/pre>\n
                        In questo caso:<\/p>\n
                          \n
                        1. echo<\/code> invia il nome del file allo stdin<\/strong>;<\/li>\n
                        2. xargs<\/code> utilizza quel nome come argomento del comando rm<\/code>;<\/li>\n
                        3. il file hello.txt<\/code> viene eliminato.<\/li>\n<\/ol>\n
                          \n
                          Utilizzare xargs<\/code> con find<\/code><\/h3>\n
                          Uno degli utilizzi pi\u00f9 comuni consiste nel combinare find<\/code> e xargs<\/code>.<\/p>\n
                          Ad esempio:<\/p>\n
                          find \/path\/to\/dir -type f -name \"*.txt\" | xargs tar -cvf backup.tar\r\n<\/code><\/pre>\n
                          Questo comando:<\/p>\n
                            \n
                          • cerca tutti i file con estensione .txt<\/code>;<\/li>\n
                          • passa l’elenco dei file a xargs<\/code>;<\/li>\n
                          • crea l’archivio backup.tar<\/code> contenente tutti i file trovati.<\/li>\n<\/ul>\n
                            Questa tecnica permette di elaborare automaticamente grandi quantit\u00e0 di file.<\/p>\n
                            \n
                            Perch\u00e9 utilizzare xargs<\/code>?<\/h3>\n
                            xargs<\/code> \u00e8 utile quando un comando produce un elenco di elementi tramite lo stdout<\/strong>, ma il comando successivo si aspetta tali elementi come argomenti.<\/p>\n
                            Ad esempio:<\/p>\n
                            find . -name \"*.log\" | xargs ls -lh\r\n<\/code><\/pre>\n
                            oppure:<\/p>\n
                            find . -name \"*.tmp\" | xargs rm\r\n<\/code><\/pre>\n
                            In questo modo \u00e8 possibile eseguire rapidamente la stessa operazione su numerosi file.<\/p>\n
                            \n
                            Attenzione ai nomi contenenti spazi<\/h3>\n
                            Un limite di xargs<\/code> \u00e8 che, per impostazione predefinita, considera gli spazi come separatori.<\/p>\n
                            Se i nomi dei file possono contenere spazi, \u00e8 preferibile utilizzare l’opzione -print0<\/code> di find<\/code> insieme a xargs -0<\/code>.<\/p>\n
                            Esempio:<\/p>\n
                            find . -name \"*.txt\" -print0 | xargs -0 rm\r\n<\/code><\/pre>\n
                            Questa combinazione gestisce correttamente anche file con spazi o caratteri speciali nel nome.<\/p>\n
                            \ud83d\udccc Da ricordare<\/strong> La combinazione find ... -print0 | xargs -0<\/code> rappresenta la soluzione pi\u00f9 sicura quando si lavora con nomi di file arbitrari.<\/p><\/blockquote>\n
                            \n
                            Best Practice<\/h3>\n
                            Utilizza xargs<\/code> per automatizzare operazioni ripetitive su grandi quantit\u00e0 di file. Quando lavori con l’output di find<\/code>, preferisci sempre la combinazione -print0<\/code> e xargs -0<\/code> per evitare problemi con nomi contenenti spazi o caratteri speciali.<\/p>\n
                            \n
                            Riepilogo<\/h3>\n
                              \n
                            • xargs<\/code> trasforma lo stdin<\/strong> negli argomenti di un altro comando.<\/li>\n
                            • \u00c8 comunemente utilizzato insieme a find<\/code>, grep<\/code> ed echo<\/code>.<\/li>\n
                            • Permette di automatizzare operazioni su grandi quantit\u00e0 di file.<\/li>\n
                            • La combinazione find ... -print0 | xargs -0<\/code> \u00e8 la soluzione pi\u00f9 sicura per gestire file con spazi nel nome.<\/li>\n
                            • xargs<\/code> \u00e8 uno degli strumenti fondamentali della shell Linux per costruire pipeline efficienti.<\/li>\n<\/ul>\n
                              \ud83d\udcda Riepilogo della lezione<\/h2>\n
                              In questa lezione hai approfondito uno dei concetti pi\u00f9 importanti della shell Linux: la gestione dei flussi standard (stream)<\/strong>. Hai imparato come i programmi comunicano attraverso lo Standard Input (stdin)<\/strong>, lo Standard Output (stdout)<\/strong> e lo Standard Error (stderr)<\/strong>, e come utilizzare pipe e reindirizzamenti per collegare pi\u00f9 comandi tra loro.<\/p>\n
                              Hai inoltre scoperto come salvare o separare l’output dei programmi, duplicarlo con tee<\/code> e trasformare i dati provenienti dallo standard input in argomenti per altri comandi mediante xargs<\/code>.<\/p>\n
                              Concetti principali<\/h3>\n
                                \n
                              • Hai compreso il ruolo dei tre stream standard: stdin<\/strong>, stdout<\/strong> e stderr<\/strong>.<\/li>\n
                              • Hai imparato a reindirizzare l’output e gli errori verso file utilizzando gli operatori di reindirizzamento.<\/li>\n
                              • Hai utilizzato le pipe (|<\/code>)<\/strong> per creare pipeline che collegano pi\u00f9 comandi.<\/li>\n
                              • Hai scoperto come il comando tee<\/code> consente di visualizzare e salvare contemporaneamente l’output.<\/li>\n
                              • Hai imparato a utilizzare xargs<\/code> per trasformare lo standard input negli argomenti di un altro comando.<\/li>\n
                              • Hai acquisito le basi per costruire pipeline efficienti e automatizzare attivit\u00e0 di amministrazione Linux.<\/li>\n<\/ul>\n
                                \ud83c\udfaf Obiettivo raggiunto<\/strong> Al termine di questa lezione sei in grado di gestire i flussi di dati della shell Linux, creare pipeline, utilizzare i principali operatori di reindirizzamento e combinare pi\u00f9 strumenti GNU\/Linux per realizzare elaborazioni complesse in modo semplice ed efficiente.<\/p><\/blockquote>\n
                                Comandi e operatori da ricordare<\/h3>\n\n\n\n\n\n\n\n\n\n\n\n\n
                                Comando \/ Operatore<\/th>\nDescrizione<\/th>\n<\/tr>\n<\/thead>\n
                                |<\/code><\/td>\nCollega lo stdout<\/strong> di un comando allo stdin<\/strong> del comando successivo.<\/td>\n<\/tr>\n
                                ><\/code><\/td>\nReindirizza lo stdout<\/strong> sovrascrivendo il file di destinazione.<\/td>\n<\/tr>\n
                                >><\/code><\/td>\nAggiunge lo stdout<\/strong> alla fine di un file.<\/td>\n<\/tr>\n
                                <<\/code><\/td>\nUtilizza un file come stdin<\/strong>.<\/td>\n<\/tr>\n
                                2><\/code><\/td>\nReindirizza lo stderr<\/strong>.<\/td>\n<\/tr>\n
                                > file 2>&1<\/code><\/td>\nSalva stdout e stderr nello stesso file.<\/td>\n<\/tr>\n
                                tee<\/code><\/td>\nVisualizza e salva contemporaneamente l’output.<\/td>\n<\/tr>\n
                                xargs<\/code><\/td>\nTrasforma lo stdin negli argomenti di un altro comando.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
                                \ud83d\udca1 Preparazione all’esame LPIC-1<\/strong> Prima di proseguire assicurati di conoscere il ruolo di stdin<\/strong>, stdout<\/strong> e stderr<\/strong>, il funzionamento delle pipe, i principali operatori di reindirizzamento e l’utilizzo dei comandi tee<\/code> e xargs<\/code>. Questi concetti sono fondamentali sia per l’esame LPIC-1 sia per l’amministrazione quotidiana dei sistemi Linux.<\/p><\/blockquote>\n
                                \n
                                \u27a1\ufe0f Prossima lezione<\/h2>\n
                                Nella prossima lezione (103.4 Gestire file e directory<\/strong>) imparerai a utilizzare i principali comandi per creare, copiare, spostare, rinominare ed eliminare file e directory. Approfondirai inoltre la gestione dei collegamenti, dei permessi di base e delle operazioni pi\u00f9 comuni sul filesystem 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-3637","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.3 Utilizzare stream, pipe e reindirizzamenti Uno dei principi fondamentali dei sistemi GNU\/Linux \u00e8 la possibilit\u00e0 di far collaborare pi\u00f9 programmi attraverso lo scambio di dati. Ogni comando pu\u00f2 ricevere informazioni in ingresso, elaborarle e produrre un risultato che pu\u00f2 essere visualizzato sullo schermo, salvato in un file oppure utilizzato direttamente da un altro comando.…","_links":{"self":[{"href":"https:\/\/rootmail.it\/en\/wp-json\/wp\/v2\/lesson\/3637","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=3637"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/rootmail.it\/en\/wp-json\/wp\/v2\/media\/3675"}],"wp:attachment":[{"href":"https:\/\/rootmail.it\/en\/wp-json\/wp\/v2\/media?parent=3637"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}