{"id":3635,"date":"2026-07-16T15:39:37","date_gmt":"2026-07-16T13:39:37","guid":{"rendered":"https:\/\/rootmail.it\/courses\/lpic-1-exam-101-010-160-corso-completo-in-italiano\/lessons\/103-1-lavorare-dalla-riga-di-comando\/"},"modified":"2026-07-20T21:56:39","modified_gmt":"2026-07-20T19:56:39","slug":"103-1-lavorare-dalla-riga-di-comando","status":"publish","type":"lesson","link":"https:\/\/rootmail.it\/en\/courses\/lpic-1-exam-1-101-500-corso-completo-in-italiano\/lessons\/103-1-lavorare-dalla-riga-di-comando\/","title":{"rendered":"103.1 Lavorare dalla riga di comando"},"content":{"rendered":"

103.1 Lavorare dalla riga di comando<\/h2>\n

La riga di comando (Command Line Interface – CLI)<\/strong> rappresenta uno degli strumenti pi\u00f9 potenti e versatili di un sistema Linux. Sebbene gli ambienti desktop moderni offrano interfacce grafiche intuitive, gran parte dell’amministrazione di server, sistemi cloud e infrastrutture Linux viene ancora oggi eseguita direttamente dal terminale.<\/p>\n

La shell consente di interagire con il sistema operativo attraverso comandi testuali, offrendo un controllo preciso sulle operazioni di gestione, automazione e configurazione. Imparare a utilizzare efficacemente la riga di comando significa acquisire una competenza fondamentale per qualsiasi amministratore di sistemi Linux.<\/p>\n

In questa lezione scoprirai come utilizzare la shell, comprendere la sintassi dei comandi, ottenere assistenza tramite la documentazione integrata e personalizzare il tuo ambiente di lavoro. Imparerai inoltre a navigare nel filesystem e a sfruttare gli strumenti essenziali che rendono la riga di comando uno degli elementi distintivi dell’ecosistema GNU\/Linux.<\/p>\n

\n

\ud83d\udca1 Exam Tip<\/strong> Per l’esame LPIC-1 \u00e8 fondamentale conoscere la struttura dei comandi Linux, l’utilizzo della shell, le variabili d’ambiente, la cronologia dei comandi, il completamento automatico (tab completion) e gli strumenti di aiuto come man<\/code>, info<\/code> e --help<\/code>.<\/p>\n<\/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 della shell Linux e della riga di comando;<\/li>\n
  • eseguire correttamente comandi e interpretarene la sintassi;<\/li>\n
  • utilizzare la cronologia dei comandi e il completamento automatico;<\/li>\n
  • consultare la documentazione integrata tramite man<\/code>, info<\/code> e --help<\/code>;<\/li>\n
  • utilizzare le variabili d’ambiente e personalizzare il comportamento della shell;<\/li>\n
  • acquisire le competenze fondamentali per lavorare quotidianamente dal terminale Linux.<\/li>\n<\/ul>\n
    \n

    Argomenti trattati<\/h2>\n
      \n
    • Introduzione alla shell Linux.<\/li>\n
    • Struttura e sintassi dei comandi.<\/li>\n
    • Cronologia dei comandi e completamento automatico.<\/li>\n
    • Documentazione integrata: man, info e help.<\/li>\n
    • Variabili d’ambiente e shell environment.<\/li>\n
    • Best practice per lavorare dalla riga di comando.<\/li>\n<\/ul>\n
      \n

      \u2328\ufe0f Provalo subito<\/strong>
      Apri un terminale Linux ed esegui i comandi mostrati durante la lezione. La pratica \u00e8 il modo migliore per acquisire familiarit\u00e0 con la shell e sviluppare sicurezza nell’utilizzo della riga di comando.<\/p>\n<\/blockquote>\n

      103.1.1 Comandi di base della shell e sequenze di comandi<\/h2>\n

      La shell<\/strong> \u00e8 l’interprete dei comandi di Linux. Il suo compito \u00e8 ricevere i comandi digitati dall’utente, interpretarli ed eseguirli, consentendo di interagire direttamente con il sistema operativo.<\/p>\n

      Ogni comando immesso nel terminale segue generalmente una struttura composta da:<\/p>\n

        \n
      • il nome del comando<\/strong>;<\/li>\n
      • eventuali opzioni<\/strong>;<\/li>\n
      • uno o pi\u00f9 argomenti<\/strong>.<\/li>\n<\/ul>\n

        Ad esempio:<\/p>\n

        ls -l \/home\r\n<\/code><\/pre>\n
        In questo comando:<\/p>\n
          \n
        • ls<\/code> \u00e8 il comando;<\/li>\n
        • -l<\/code> \u00e8 un’opzione che abilita il formato dettagliato;<\/li>\n
        • \/home<\/code> \u00e8 l’argomento, ovvero la directory da visualizzare.<\/li>\n<\/ul>\n
          \n
          \ud83d\udca1 Exam Tip<\/strong> Comprendere la sintassi dei comandi Linux \u00e8 fondamentale. La maggior parte dei comandi segue lo schema comando [opzioni] [argomenti]<\/strong>.<\/p>\n<\/blockquote>\n
          \n
          Visualizzare la directory corrente<\/h3>\n
          Uno dei primi comandi da conoscere \u00e8 pwd<\/code> (Print Working Directory<\/strong>), che mostra il percorso completo della directory in cui ci si trova.<\/p>\n
          Esempio:<\/p>\n
          $ pwd\r\n\/home\/user\r\n<\/code><\/pre>\n
          Questo comando \u00e8 particolarmente utile quando si lavora da terminale e si desidera conoscere rapidamente la posizione corrente all’interno del filesystem.<\/p>\n
          \n
          Eseguire pi\u00f9 comandi in sequenza<\/h3>\n
          La shell permette di eseguire pi\u00f9 comandi consecutivamente utilizzando il carattere ;<\/code> (punto e virgola).<\/p>\n
          Ad esempio:<\/p>\n
          $ cd \/var\/log; ls\r\n<\/code><\/pre>\n
          In questo caso:<\/p>\n
            \n
          1. la shell cambia directory con cd \/var\/log<\/code>;<\/li>\n
          2. successivamente esegue ls<\/code>, mostrando il contenuto della nuova directory.<\/li>\n<\/ol>\n
            Entrambi i comandi vengono eseguiti indipendentemente dal risultato del precedente.<\/p>\n
            \n
            Quando utilizzare il punto e virgola (;)<\/h3>\n
            Il separatore ;<\/code> \u00e8 utile quando si desidera eseguire rapidamente una serie di operazioni.<\/p>\n
            Ad esempio:<\/p>\n
            mkdir laboratorio; cd laboratorio; touch prova.txt; ls -l\r\n<\/code><\/pre>\n
            La shell eseguir\u00e0 ogni comando nell’ordine indicato, senza interrompersi anche se uno dei comandi dovesse restituire un errore.<\/p>\n
            \n
            \ud83d\udccc Da ricordare<\/strong> Il separatore ;<\/code> esegue sempre tutti i comandi. Nelle prossime lezioni vedrai operatori come &&<\/code> e ||<\/code>, che consentono invece di controllare l’esecuzione in base al successo o al fallimento del comando precedente.<\/p>\n<\/blockquote>\n
            \n
            Best Practice<\/h3>\n
            Quando lavori da terminale, verifica sempre la directory corrente con pwd<\/code> prima di eseguire operazioni che modificano file o directory. Inoltre, utilizza le sequenze di comandi solo quando sei certo dell’ordine di esecuzione e degli effetti che ogni comando produrr\u00e0.<\/p>\n
            \n
            Riepilogo<\/h3>\n
              \n
            • La shell interpreta ed esegue i comandi inseriti dall’utente.<\/li>\n
            • La sintassi generale di un comando \u00e8: comando [opzioni] [argomenti]<\/strong>.<\/li>\n
            • Il comando pwd<\/code> visualizza la directory di lavoro corrente.<\/li>\n
            • Il separatore ;<\/code> consente di eseguire pi\u00f9 comandi in sequenza.<\/li>\n
            • I comandi separati da ;<\/code> vengono eseguiti indipendentemente dal risultato dei precedenti.<\/li>\n<\/ul>\n
              103.1.2 L’ambiente della shell e le variabili<\/h2>\n
              Ogni volta che apri un terminale Linux viene avviata una sessione della shell<\/strong>. Durante questa sessione, la shell mantiene un insieme di informazioni chiamate variabili d’ambiente (Environment Variables)<\/strong>, utilizzate sia dal sistema operativo sia dalle applicazioni per memorizzare impostazioni e configurazioni.<\/p>\n
              Le variabili d’ambiente permettono, ad esempio, di conoscere la directory personale dell’utente, il percorso in cui cercare i comandi eseguibili, il nome dell’utente connesso e molte altre informazioni utili.<\/p>\n
              \n
              \ud83d\udca1 Exam Tip<\/strong> Per l’esame LPIC-1 \u00e8 importante conoscere la differenza tra variabili locali e variabili d’ambiente, sapere utilizzare i comandi export<\/code>, unset<\/code>, echo<\/code> ed env<\/code> e comprendere il significato della variabile PATH<\/code>.<\/p>\n<\/blockquote>\n
              \n
              Visualizzare il valore di una variabile<\/h3>\n
              Per visualizzare il contenuto di una variabile si utilizza il comando echo<\/code>, precedendo il nome della variabile con il simbolo $<\/code>.<\/p>\n
              Ad esempio:<\/p>\n
              $ echo $HOME\r\n\/home\/user\r\n<\/code><\/pre>\n
              In questo caso viene visualizzato il contenuto della variabile HOME<\/code>, che identifica la directory personale dell’utente corrente.<\/p>\n
              Alcune variabili molto comuni sono:<\/p>\n
                \n
              • HOME<\/code> \u2013 directory personale dell’utente;<\/li>\n
              • USER<\/code> \u2013 nome dell’utente connesso;<\/li>\n
              • PATH<\/code> \u2013 elenco delle directory in cui la shell cerca i comandi eseguibili;<\/li>\n
              • SHELL<\/code> \u2013 shell utilizzata dall’utente.<\/li>\n<\/ul>\n
                \n
                Visualizzare tutte le variabili d’ambiente<\/h3>\n
                Per elencare tutte le variabili d’ambiente disponibili nella sessione corrente \u00e8 possibile utilizzare:<\/p>\n
                env\r\n<\/code><\/pre>\n
                Se invece si desidera cercare una variabile specifica:<\/p>\n
                env | grep HOME\r\n<\/code><\/pre>\n
                oppure:<\/p>\n
                env | grep PATH\r\n<\/code><\/pre>\n
                Questo metodo \u00e8 particolarmente utile quando il numero di variabili \u00e8 elevato.<\/p>\n
                \n
                Creare una variabile d’ambiente<\/h3>\n
                Per creare una variabile d’ambiente e renderla disponibile anche ai processi figli si utilizza il comando export<\/code>.<\/p>\n
                Esempio:<\/p>\n
                export VARNAME=\"value\"\r\n<\/code><\/pre>\n
                Successivamente \u00e8 possibile verificarne il contenuto:<\/p>\n
                echo $VARNAME\r\n<\/code><\/pre>\n
                La variabile rimarr\u00e0 disponibile fino alla chiusura della sessione della shell, salvo diversa configurazione nei file di inizializzazione.<\/p>\n
                \n
                Eliminare una variabile<\/h3>\n
                Per rimuovere una variabile dalla sessione corrente si utilizza il comando:<\/p>\n
                unset VARNAME\r\n<\/code><\/pre>\n
                Dopo l’esecuzione del comando, la variabile non sar\u00e0 pi\u00f9 disponibile.<\/p>\n
                \n
                Variabili locali e variabili d’ambiente<\/h3>\n
                In Linux esistono due principali categorie di variabili.<\/p>\n\n\n\n\n\n\n
                Tipo<\/th>\nComando<\/th>\nVisibilit\u00e0<\/th>\n<\/tr>\n<\/thead>\n
                Variabile locale<\/td>\nVARNAME=value<\/code><\/td>\nDisponibile solo nella shell corrente.<\/td>\n<\/tr>\n
                Variabile d’ambiente<\/td>\nexport VARNAME=value<\/code><\/td>\nDisponibile anche ai processi figli avviati dalla shell.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
                Ad esempio:<\/p>\n
                MESSAGGIO=\"Benvenuto\"\r\nexport MESSAGGIO\r\n<\/code><\/pre>\n
                Dopo l’utilizzo di export<\/code>, qualsiasi programma avviato dalla shell potr\u00e0 accedere alla variabile MESSAGGIO<\/code>.<\/p>\n
                \n
                \ud83d\udccc Da ricordare<\/strong> Una variabile creata senza export<\/code> \u00e8 una variabile locale e non viene ereditata dai processi figli. L’utilizzo di export<\/code> la trasforma in una variabile d’ambiente.<\/p>\n<\/blockquote>\n
                \n
                La variabile PATH<\/h3>\n
                Una delle variabili pi\u00f9 importanti \u00e8 PATH<\/code>.<\/p>\n
                Essa contiene l’elenco delle directory in cui la shell ricerca i programmi eseguibili quando viene digitato un comando.<\/p>\n
                Per visualizzarne il contenuto:<\/p>\n
                echo $PATH\r\n<\/code><\/pre>\n
                L’output \u00e8 composto da pi\u00f9 directory separate dal carattere :<\/code> (due punti), ad esempio:<\/p>\n
                \/usr\/local\/bin:\/usr\/bin:\/bin:\/usr\/sbin:\/sbin\r\n<\/code><\/pre>\n
                Quando digiti un comando come ls<\/code>, la shell lo cerca automaticamente nelle directory elencate in PATH<\/code>.<\/p>\n
                \n
                Best Practice<\/h3>\n
                Utilizza le variabili d’ambiente per personalizzare il comportamento della shell e delle applicazioni senza modificare direttamente i programmi. Evita di alterare la variabile PATH<\/code> senza comprenderne il funzionamento, poich\u00e9 un’impostazione errata potrebbe impedire l’esecuzione dei comandi di sistema.<\/p>\n
                \n
                Riepilogo<\/h3>\n
                  \n
                • Le variabili d’ambiente memorizzano informazioni sulla sessione della shell.<\/li>\n
                • echo $VARIABILE<\/code> visualizza il contenuto di una variabile.<\/li>\n
                • env<\/code> elenca tutte le variabili d’ambiente disponibili.<\/li>\n
                • export<\/code> crea una variabile d’ambiente accessibile anche ai processi figli.<\/li>\n
                • unset<\/code> elimina una variabile dalla sessione corrente.<\/li>\n
                • PATH<\/code> indica le directory in cui la shell ricerca i programmi eseguibili.<\/li>\n<\/ul>\n
                  103.1.3 Utilizzare la cronologia dei comandi<\/h2>\n
                  La shell Linux mantiene automaticamente una cronologia dei comandi<\/strong> eseguiti dall’utente. Questa funzionalit\u00e0 permette di richiamare rapidamente comandi utilizzati in precedenza, evitando di doverli digitare nuovamente e aumentando notevolmente la produttivit\u00e0 durante il lavoro da terminale.<\/p>\n
                  La cronologia \u00e8 particolarmente utile durante l’amministrazione dei sistemi, il troubleshooting e l’automazione delle attivit\u00e0 ripetitive.<\/p>\n
                  \n
                  \ud83d\udca1 Exam Tip<\/strong> Per l’esame LPIC-1 \u00e8 importante conoscere il comando history<\/code>, l’utilizzo di !!<\/code>, dei riferimenti !n<\/code> e !-n<\/code>, la ricerca tramite Ctrl + R<\/strong> e il file ~\/.bash_history<\/code>.<\/p>\n<\/blockquote>\n
                  \n
                  Visualizzare la cronologia dei comandi<\/h3>\n
                  Per visualizzare l’elenco dei comandi eseguiti nella shell \u00e8 sufficiente utilizzare:<\/p>\n
                  history\r\n<\/code><\/pre>\n
                  L’output mostra ogni comando preceduto da un numero progressivo.<\/p>\n
                  Ad esempio:<\/p>\n
                  100  pwd\r\n101  ls -l\r\n102  cd \/var\/log\r\n103  cat syslog\r\n<\/code><\/pre>\n
                  Questa numerazione permette di richiamare rapidamente un comando specifico.<\/p>\n
                  \n
                  Ripetere comandi gi\u00e0 eseguiti<\/h3>\n
                  La shell consente di rieseguire rapidamente i comandi presenti nella cronologia.<\/p>\n
                  Per ripetere l’ultimo comando eseguito:<\/p>\n
                  !!\r\n<\/code><\/pre>\n
                  Per eseguire il comando precedente di due posizioni:<\/p>\n
                  !-2\r\n<\/code><\/pre>\n
                  \u00c8 inoltre possibile richiamare un comando specifico utilizzando il numero mostrato dal comando history<\/code>.<\/p>\n
                  Ad esempio:<\/p>\n
                  !101\r\n<\/code><\/pre>\n
                  In questo caso verr\u00e0 rieseguito il comando numero 101<\/strong> presente nella cronologia.<\/p>\n
                  \n
                  \ud83d\udccc Da ricordare<\/strong> I comandi richiamati mediante !<\/code> vengono eseguiti immediatamente. Verifica sempre che il comando richiamato sia quello desiderato, soprattutto se pu\u00f2 modificare file o configurazioni.<\/p>\n<\/blockquote>\n
                  \n
                  Ricercare nella cronologia<\/h3>\n
                  Quando la cronologia contiene molti comandi, \u00e8 possibile effettuare una ricerca interattiva premendo:<\/p>\n
                  Ctrl + R\r\n<\/code><\/pre>\n
                  Dopo aver premuto la combinazione di tasti, \u00e8 sufficiente iniziare a digitare una parte del comando desiderato.<\/p>\n
                  Ad esempio, digitando:<\/p>\n
                  ssh\r\n<\/code><\/pre>\n
                  la shell mostrer\u00e0 automaticamente l’ultimo comando contenente la parola ssh<\/code>.<\/p>\n
                  Premendo nuovamente Ctrl + R<\/code> \u00e8 possibile scorrere i risultati precedenti.<\/p>\n
                  Per eseguire il comando trovato \u00e8 sufficiente premere Invio<\/strong>.<\/p>\n
                  \n
                  La cronologia permanente<\/h3>\n
                  Nella shell Bash la cronologia dei comandi viene normalmente salvata nel file:<\/p>\n
                  ~\/.bash_history\r\n<\/code><\/pre>\n
                  Questo file consente di mantenere la cronologia anche dopo la chiusura della sessione.<\/p>\n
                  \u00c8 possibile visualizzarne il contenuto con:<\/p>\n
                  cat ~\/.bash_history\r\n<\/code><\/pre>\n
                  oppure:<\/p>\n
                  less ~\/.bash_history\r\n<\/code><\/pre>\n
                  La dimensione della cronologia e il numero di comandi conservati possono essere configurati tramite specifiche variabili d’ambiente.<\/p>\n
                  \n
                  Perch\u00e9 utilizzare la cronologia?<\/h3>\n
                  L’utilizzo della cronologia offre numerosi vantaggi:<\/p>\n
                    \n
                  • riduce il tempo necessario per digitare comandi ripetitivi;<\/li>\n
                  • semplifica il troubleshooting;<\/li>\n
                  • consente di recuperare rapidamente comandi complessi;<\/li>\n
                  • riduce il rischio di errori di digitazione.<\/li>\n<\/ul>\n
                    Per un amministratore Linux rappresenta uno degli strumenti pi\u00f9 utili durante il lavoro quotidiano.<\/p>\n
                    \n
                    Best Practice<\/h3>\n
                    Utilizza la ricerca con Ctrl + R<\/strong> per recuperare rapidamente i comandi utilizzati pi\u00f9 frequentemente. Prima di rieseguire un comando tramite !!<\/code> o !n<\/code>, verifica sempre che sia quello desiderato, soprattutto se potrebbe modificare il sistema o eliminare dati.<\/p>\n
                    \n
                    Riepilogo<\/h3>\n
                      \n
                    • history<\/code> visualizza l’elenco dei comandi eseguiti.<\/li>\n
                    • !!<\/code> riesegue l’ultimo comando.<\/li>\n
                    • !-n<\/code> richiama un comando eseguito nelle posizioni precedenti della cronologia.<\/li>\n
                    • !numero<\/code> esegue il comando identificato dal relativo numero nella cronologia.<\/li>\n
                    • Ctrl + R<\/strong> permette di cercare rapidamente un comando nella cronologia.<\/li>\n
                    • La cronologia permanente della shell Bash \u00e8 memorizzata nel file ~\/.bash_history<\/code>.<\/li>\n<\/ul>\n
                      103.1.4 Eseguire comandi tramite il PATH e utilizzando percorsi assoluti o relativi<\/h2>\n
                      Quando digiti un comando nel terminale, la shell deve individuare il programma da eseguire. Per farlo utilizza una variabile d’ambiente chiamata PATH<\/strong>, che contiene l’elenco delle directory nelle quali cercare i file eseguibili.<\/p>\n
                      Se il comando viene trovato in una delle directory presenti nel PATH<\/code>, viene eseguito automaticamente. In caso contrario, \u00e8 necessario specificare manualmente il percorso del file eseguibile.<\/p>\n
                      \n
                      \ud83d\udca1 Exam Tip<\/strong> Per l’esame LPIC-1 \u00e8 importante comprendere il funzionamento della variabile PATH<\/code>, conoscere il comando which<\/code> e sapere come eseguire programmi presenti al di fuori delle directory incluse nel PATH.<\/p>\n<\/blockquote>\n
                      \n
                      La variabile PATH<\/h3>\n
                      La variabile PATH<\/code> contiene un elenco di directory separate dal carattere :<\/code> (due punti).<\/p>\n
                      Per visualizzarne il contenuto \u00e8 possibile utilizzare:<\/p>\n
                      echo $PATH\r\n<\/code><\/pre>\n
                      Un esempio di output potrebbe essere:<\/p>\n
                      \/usr\/local\/bin:\/usr\/bin:\/bin:\/usr\/sbin:\/sbin\r\n<\/code><\/pre>\n
                      Quando esegui un comando come:<\/p>\n
                      ls\r\n<\/code><\/pre>\n
                      la shell cerca automaticamente il programma ls<\/code> in ciascuna delle directory elencate nel PATH<\/code>, fino a trovarlo.<\/p>\n
                      \n
                      Individuare la posizione di un comando<\/h3>\n
                      Per sapere quale programma verr\u00e0 eseguito quando si digita un comando \u00e8 possibile utilizzare which<\/code>.<\/p>\n
                      Ad esempio:<\/p>\n
                      $ which ls\r\n\/bin\/ls\r\n<\/code><\/pre>\n
                      Il comando restituisce il percorso completo dell’eseguibile trovato nella variabile PATH<\/code>.<\/p>\n
                      Questo \u00e8 particolarmente utile quando esistono pi\u00f9 versioni dello stesso programma installate nel sistema.<\/p>\n
                      \n
                      Eseguire un programma fuori dal PATH<\/h3>\n
                      Se un programma non si trova in una delle directory presenti nella variabile PATH<\/code>, \u00e8 necessario specificarne il percorso completo.<\/p>\n
                      Ad esempio:<\/p>\n
                      \/percorso\/del\/mio_script.sh\r\n<\/code><\/pre>\n
                      oppure:<\/p>\n
                      \/home\/user\/script_backup.sh\r\n<\/code><\/pre>\n
                      In questo caso la shell eseguir\u00e0 direttamente il file indicato.<\/p>\n
                      \n
                      Eseguire un programma nella directory corrente<\/h3>\n
                      Per motivi di sicurezza, la directory corrente (.<\/code>) non \u00e8 normalmente inclusa nella variabile PATH<\/code>.<\/p>\n
                      Se desideri eseguire uno script presente nella directory in cui ti trovi, devi specificarlo esplicitamente utilizzando:<\/p>\n
                      .\/nome_script.sh\r\n<\/code><\/pre>\n
                      Ad esempio:<\/p>\n
                      .\/backup.sh\r\n<\/code><\/pre>\n
                      Il prefisso .\/<\/code> indica alla shell di eseguire il file presente nella directory corrente.<\/p>\n
                      \n
                      \ud83d\udccc Da ricordare<\/strong> Digitare semplicemente backup.sh<\/code> potrebbe non funzionare se la directory corrente non \u00e8 presente nella variabile PATH<\/code>. In questo caso \u00e8 necessario utilizzare .\/backup.sh<\/code>.<\/p>\n<\/blockquote>\n
                      \n
                      Percorsi assoluti e percorsi relativi<\/h3>\n
                      Esistono due modi per specificare il percorso di un file eseguibile.<\/p>\n\n\n\n\n\n\n
                      Tipo di percorso<\/th>\nEsempio<\/th>\n<\/tr>\n<\/thead>\n
                      Percorso assoluto<\/td>\n\/home\/user\/script.sh<\/code><\/td>\n<\/tr>\n
                      Percorso relativo<\/td>\n.\/script.sh<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
                      Il percorso assoluto parte sempre dalla directory radice (\/<\/code>), mentre quello relativo dipende dalla directory corrente.<\/p>\n
                      \n
                      Best Practice<\/h3>\n
                      Evita di aggiungere la directory corrente (.<\/code>) alla variabile PATH<\/code>. Questa pratica pu\u00f2 rappresentare un rischio per la sicurezza, poich\u00e9 potrebbe portare all’esecuzione accidentale di programmi con lo stesso nome dei comandi di sistema. Quando desideri eseguire uno script presente nella directory corrente, utilizza sempre il prefisso .\/<\/code>.<\/p>\n
                      \n
                      Riepilogo<\/h3>\n
                        \n
                      • La variabile PATH<\/code> indica alla shell dove cercare i programmi eseguibili.<\/li>\n
                      • echo $PATH<\/code> visualizza le directory contenute nel PATH.<\/li>\n
                      • which comando<\/code> mostra il percorso dell’eseguibile utilizzato.<\/li>\n
                      • I programmi esterni al PATH devono essere eseguiti specificandone il percorso.<\/li>\n
                      • .\/programma<\/code> permette di eseguire uno script presente nella directory corrente.<\/li>\n
                      • I percorsi possono essere assoluti o relativi.<\/li>\n<\/ul>\n
                        103.1.5 Le virgolette nella shell (Quoting)<\/h2>\n
                        Quando si lavora con la shell Linux, alcuni caratteri hanno un significato speciale. Ad esempio, il simbolo $<\/code> identifica una variabile, mentre spazi e caratteri speciali possono modificare il modo in cui un comando viene interpretato.<\/p>\n
                        Il quoting<\/strong> \u00e8 il meccanismo che permette di controllare l’interpretazione di testo e caratteri speciali da parte della shell. Utilizzare correttamente le virgolette \u00e8 fondamentale per scrivere comandi affidabili, evitare errori e gestire correttamente stringhe contenenti spazi o variabili.<\/p>\n
                        \n
                        \ud83d\udca1 Exam Tip<\/strong> Per l’esame LPIC-1 \u00e8 importante conoscere la differenza tra virgolette doppie (“”)<\/strong> e virgolette singole (”)<\/strong>, in particolare il comportamento delle variabili d’ambiente e dei caratteri speciali.<\/p>\n<\/blockquote>\n
                        \n
                        Virgolette doppie (“”)<\/h3>\n
                        Le virgolette doppie<\/strong> preservano la maggior parte dei caratteri contenuti nella stringa, ma permettono comunque alla shell di espandere le variabili d’ambiente e alcune sequenze speciali.<\/p>\n
                        Ad esempio:<\/p>\n
                        $ echo \"La tua home \u00e8: $HOME\"\r\nLa tua home \u00e8: \/home\/user\r\n<\/code><\/pre>\n
                        In questo caso la shell sostituisce automaticamente $HOME<\/code> con il valore della variabile d’ambiente.<\/p>\n
                        Le virgolette doppie sono particolarmente utili quando una stringa contiene spazi e variabili contemporaneamente.<\/p>\n
                        \n
                        Virgolette singole (”)<\/h3>\n
                        Le virgolette singole<\/strong> preservano il valore letterale di tutti i caratteri contenuti nella stringa.<\/p>\n
                        La shell non interpreta variabili, caratteri speciali o sostituzioni.<\/p>\n
                        Ad esempio:<\/p>\n
                        $ echo 'La tua home \u00e8: $HOME'\r\nLa tua home \u00e8: $HOME\r\n<\/code><\/pre>\n
                        In questo caso il testo viene visualizzato esattamente come \u00e8 stato digitato.<\/p>\n
                        Le virgolette singole sono utili quando si desidera impedire qualsiasi elaborazione della stringa da parte della shell.<\/p>\n
                        \n
                        Confronto tra virgolette doppie e singole<\/h3>\n\n\n\n\n\n\n
                        Tipo<\/th>\nEspande le variabili?<\/th>\nUtilizzo principale<\/th>\n<\/tr>\n<\/thead>\n
                        \"...\"<\/code><\/td>\n\u2714 S\u00ec<\/td>\nStringhe con variabili o caratteri da espandere.<\/td>\n<\/tr>\n
                        '...'<\/code><\/td>\n\u2718 No<\/td>\nTesto da mantenere esattamente come scritto.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
                        \n
                        Quando utilizzare il quoting?<\/h3>\n
                        Le virgolette vengono utilizzate frequentemente anche per gestire percorsi o nomi di file contenenti spazi.<\/p>\n
                        Ad esempio:<\/p>\n
                        cd \"\/home\/user\/Documenti di lavoro\"\r\n<\/code><\/pre>\n
                        oppure:<\/p>\n
                        cp \"Relazione finale.pdf\" backup\/\r\n<\/code><\/pre>\n
                        Senza le virgolette, la shell interpreterebbe ogni parola separata da uno spazio come un argomento distinto.<\/p>\n
                        \n
                        Best Practice<\/h3>\n
                        Quando una stringa contiene spazi, utilizza sempre le virgolette. Se desideri che le variabili vengano sostituite con il loro valore, usa le virgolette doppie<\/strong>. Se invece vuoi mantenere il testo esattamente come \u00e8 stato scritto, utilizza le virgolette singole<\/strong>.<\/p>\n
                        \n
                        Riepilogo<\/h3>\n
                          \n
                        • Il quoting<\/strong> controlla il modo in cui la shell interpreta testo e caratteri speciali.<\/li>\n
                        • Le virgolette doppie (“”)<\/strong> espandono le variabili d’ambiente.<\/li>\n
                        • Le virgolette singole (”)<\/strong> mantengono il testo letterale.<\/li>\n
                        • Le virgolette sono indispensabili quando una stringa contiene spazi.<\/li>\n
                        • Scegli il tipo di virgolette in base al comportamento desiderato della shell.<\/li>\n<\/ul>\n
                          103.1.6 Altri comandi utili della shell<\/h2>\n
                          Oltre ai comandi utilizzati quotidianamente per navigare nel filesystem e gestire i file, Linux mette a disposizione numerosi strumenti che consentono di ottenere informazioni sul sistema, consultare la documentazione e comprendere il funzionamento della shell.<\/p>\n
                          In questa sezione vedremo alcuni dei comandi pi\u00f9 utili durante l’amministrazione di un sistema Linux.<\/p>\n
                          \n
                          \ud83d\udca1 Exam Tip<\/strong> Per l’esame LPIC-1 \u00e8 importante conoscere il funzionamento dei comandi type<\/code>, man<\/code>, uname<\/code> e date<\/code>, oltre a sapere quando utilizzarli.<\/p>\n<\/blockquote>\n
                          \n
                          Il comando type<\/code><\/h3>\n
                          Il comando type<\/code> permette di sapere come la shell interpreta un comando.<\/p>\n
                          Pu\u00f2 indicare se il comando \u00e8:<\/p>\n
                            \n
                          • un comando interno (builtin);<\/li>\n
                          • un alias;<\/li>\n
                          • una funzione della shell;<\/li>\n
                          • un programma eseguibile presente nel filesystem.<\/li>\n<\/ul>\n
                            Ad esempio:<\/p>\n
                            $ type echo\r\necho is a shell builtin\r\n<\/code><\/pre>\n
                            Oppure:<\/p>\n
                            $ type ls\r\nls is \/usr\/bin\/ls\r\n<\/code><\/pre>\n
                            Questo comando \u00e8 molto utile durante il troubleshooting e quando si desidera capire quale versione di un comando verr\u00e0 eseguita.<\/p>\n
                            \n
                            Consultare la documentazione con man<\/code><\/h3>\n
                            Linux integra una vasta documentazione consultabile tramite il comando man<\/code> (manual<\/strong>).<\/p>\n
                            Per aprire il manuale di un comando:<\/p>\n
                            man ls\r\n<\/code><\/pre>\n
                            Ogni pagina di manuale contiene:<\/p>\n
                              \n
                            • descrizione del comando;<\/li>\n
                            • sintassi;<\/li>\n
                            • opzioni disponibili;<\/li>\n
                            • esempi di utilizzo.<\/li>\n<\/ul>\n
                              Per uscire dalla pagina del manuale \u00e8 sufficiente premere il tasto q<\/strong>.<\/p>\n
                              \n
                              Visualizzare informazioni sul sistema con uname<\/code><\/h3>\n
                              Il comando uname<\/code> visualizza informazioni sul sistema operativo e sul kernel Linux.<\/p>\n
                              Ad esempio:<\/p>\n
                              uname\r\n<\/code><\/pre>\n
                              mostra normalmente il nome del kernel.<\/p>\n
                              Per ottenere tutte le informazioni disponibili:<\/p>\n
                              uname -a\r\n<\/code><\/pre>\n
                              L’output include generalmente:<\/p>\n
                                \n
                              • nome del kernel;<\/li>\n
                              • hostname;<\/li>\n
                              • versione del kernel;<\/li>\n
                              • architettura del processore;<\/li>\n
                              • data di compilazione del kernel.<\/li>\n<\/ul>\n
                                \n
                                Visualizzare data e ora con date<\/code><\/h3>\n
                                Il comando date<\/code> permette di visualizzare la data e l’ora correnti del sistema.<\/p>\n
                                Ad esempio:<\/p>\n
                                date\r\n<\/code><\/pre>\n
                                \u00c8 inoltre possibile personalizzare il formato dell’output.<\/p>\n
                                Per visualizzare solo la data nel formato ISO:<\/p>\n
                                date +%F\r\n<\/code><\/pre>\n
                                Output:<\/p>\n
                                2026-07-16\r\n<\/code><\/pre>\n
                                Il comando date<\/code> viene spesso utilizzato negli script Bash per registrare eventi nei file di log.<\/p>\n
                                \n
                                Quando utilizzare questi comandi<\/h3>\n\n\n\n\n\n\n\n\n
                                Comando<\/th>\nFunzione<\/th>\n<\/tr>\n<\/thead>\n
                                type<\/code><\/td>\nIndividua la natura di un comando (builtin, alias o eseguibile).<\/td>\n<\/tr>\n
                                man<\/code><\/td>\nVisualizza il manuale di un comando.<\/td>\n<\/tr>\n
                                uname -a<\/code><\/td>\nMostra informazioni dettagliate sul sistema e sul kernel.<\/td>\n<\/tr>\n
                                date<\/code><\/td>\nVisualizza data e ora del sistema.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
                                \n
                                Best Practice<\/h3>\n
                                Quando hai dubbi sull’utilizzo di un comando, consulta sempre la relativa pagina del manuale con man<\/code>. Durante la scrittura di script Bash utilizza date<\/code> per registrare data e ora delle operazioni e type<\/code> per verificare rapidamente la natura di un comando prima di utilizzarlo.<\/p>\n
                                \n
                                Riepilogo<\/h3>\n
                                  \n
                                • type<\/code> identifica se un comando \u00e8 un builtin, un alias, una funzione o un programma eseguibile.<\/li>\n
                                • man<\/code> consente di consultare la documentazione integrata di Linux.<\/li>\n
                                • uname -a<\/code> visualizza informazioni dettagliate sul sistema operativo e sul kernel.<\/li>\n
                                • date<\/code> mostra la data e l’ora del sistema ed \u00e8 molto utilizzato negli script.<\/li>\n
                                • Questi strumenti rappresentano una parte fondamentale del lavoro quotidiano di un amministratore Linux.<\/li>\n<\/ul>\n
                                  \ud83d\udcda Riepilogo della lezione<\/h2>\n
                                  In questa lezione hai scoperto come utilizzare la riga di comando Linux<\/strong>, uno degli strumenti pi\u00f9 potenti a disposizione di un amministratore di sistema. Hai imparato a comprendere la struttura dei comandi, utilizzare le variabili d’ambiente, sfruttare la cronologia della shell, comprendere il funzionamento della variabile PATH<\/code> e utilizzare correttamente le virgolette per controllare l’interpretazione dei comandi.<\/p>\n
                                  Hai inoltre conosciuto alcuni strumenti fondamentali come type<\/code>, man<\/code>, uname<\/code> e date<\/code>, indispensabili per lavorare in modo efficace dalla riga di comando.<\/p>\n
                                  Concetti principali<\/h3>\n
                                    \n
                                  • Hai compreso il ruolo della shell<\/strong> come interprete dei comandi Linux.<\/li>\n
                                  • Hai imparato la sintassi generale dei comandi e come eseguire pi\u00f9 operazioni in sequenza.<\/li>\n
                                  • Hai utilizzato le variabili locali e le variabili d’ambiente attraverso i comandi export<\/code>, echo<\/code>, env<\/code> e unset<\/code>.<\/li>\n
                                  • Hai imparato a consultare e riutilizzare la cronologia dei comandi con history<\/code>, !!<\/code>, !n<\/code> e Ctrl + R<\/strong>.<\/li>\n
                                  • Hai compreso il funzionamento della variabile PATH<\/code> e l’esecuzione di programmi mediante percorsi assoluti e relativi.<\/li>\n
                                  • Hai imparato la differenza tra virgolette singole e doppie e il loro effetto sull’espansione delle variabili.<\/li>\n
                                  • Hai conosciuto strumenti essenziali come type<\/code>, man<\/code>, uname<\/code> e date<\/code>.<\/li>\n<\/ul>\n
                                    \n
                                    \ud83c\udfaf Obiettivo raggiunto<\/strong> Al termine di questa lezione sei in grado di utilizzare la shell Linux con maggiore sicurezza, comprendere il comportamento dei comandi e sfruttare gli strumenti fondamentali della riga di comando per amministrare un sistema Linux.<\/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
                                    Comando<\/th>\nDescrizione<\/th>\n<\/tr>\n<\/thead>\n
                                    pwd<\/code><\/td>\nVisualizza la directory di lavoro corrente.<\/td>\n<\/tr>\n
                                    history<\/code><\/td>\nMostra la cronologia dei comandi eseguiti.<\/td>\n<\/tr>\n
                                    !!<\/code><\/td>\nRiesegue l’ultimo comando.<\/td>\n<\/tr>\n
                                    !n<\/code><\/td>\nEsegue il comando identificato dal numero n<\/em> nella cronologia.<\/td>\n<\/tr>\n
                                    echo $VARIABILE<\/code><\/td>\nVisualizza il contenuto di una variabile.<\/td>\n<\/tr>\n
                                    env<\/code><\/td>\nElenca le variabili d’ambiente.<\/td>\n<\/tr>\n
                                    export<\/code><\/td>\nCrea una variabile d’ambiente.<\/td>\n<\/tr>\n
                                    unset<\/code><\/td>\nElimina una variabile.<\/td>\n<\/tr>\n
                                    which comando<\/code><\/td>\nMostra il percorso dell’eseguibile associato a un comando.<\/td>\n<\/tr>\n
                                    type comando<\/code><\/td>\nIndica la natura di un comando (builtin, alias, funzione o eseguibile).<\/td>\n<\/tr>\n
                                    man comando<\/code><\/td>\nApre il manuale di un comando.<\/td>\n<\/tr>\n
                                    uname -a<\/code><\/td>\nVisualizza informazioni dettagliate sul sistema.<\/td>\n<\/tr>\n
                                    date<\/code><\/td>\nMostra la data e l’ora correnti.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
                                    \n
                                    \ud83d\udca1 Preparazione all’esame LPIC-1<\/strong> Prima di proseguire assicurati di conoscere la sintassi dei comandi Linux, il funzionamento delle variabili d’ambiente, la gestione della cronologia, il ruolo della variabile PATH<\/code>, la differenza tra virgolette singole e doppie e l’utilizzo dei principali strumenti di consultazione della documentazione.<\/p>\n<\/blockquote>\n
                                    \n
                                    \u27a1\ufe0f Prossima lezione<\/h2>\n
                                    Nella prossima lezione (103.2 Elaborare flussi di testo con i filtri<\/strong>) scoprirai come utilizzare i principali strumenti GNU per elaborare e trasformare il testo. Imparerai a filtrare, ordinare, confrontare e manipolare il contenuto dei file mediante comandi come cat<\/code>, head<\/code>, tail<\/code>, cut<\/code>, sort<\/code>, uniq<\/code>, wc<\/code> e molti altri.<\/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-3635","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.1 Lavorare dalla riga di comando La riga di comando (Command Line Interface – CLI) rappresenta uno degli strumenti pi\u00f9 potenti e versatili di un sistema Linux. Sebbene gli ambienti desktop moderni offrano interfacce grafiche intuitive, gran parte dell’amministrazione di server, sistemi cloud e infrastrutture Linux viene ancora oggi eseguita direttamente dal terminale. La shell…","_links":{"self":[{"href":"https:\/\/rootmail.it\/en\/wp-json\/wp\/v2\/lesson\/3635","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=3635"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/rootmail.it\/en\/wp-json\/wp\/v2\/media\/3673"}],"wp:attachment":[{"href":"https:\/\/rootmail.it\/en\/wp-json\/wp\/v2\/media?parent=3635"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}