{"id":3638,"date":"2026-07-18T08:44:03","date_gmt":"2026-07-18T06:44:03","guid":{"rendered":"https:\/\/rootmail.it\/courses\/lpic-1-exam-101-010-160-corso-completo-in-italiano\/lessons\/103-4-gestire-file-e-directory\/"},"modified":"2026-07-20T21:57:42","modified_gmt":"2026-07-20T19:57:42","slug":"103-4-gestire-file-e-directory","status":"publish","type":"lesson","link":"https:\/\/rootmail.it\/en\/courses\/lpic-1-exam-1-101-500-corso-completo-in-italiano\/lessons\/103-4-gestire-file-e-directory\/","title":{"rendered":"103.4 Gestire file e directory"},"content":{"rendered":"

103.4 Gestire file e directory<\/h2>\n

La gestione di file e directory rappresenta una delle attivit\u00e0 pi\u00f9 frequenti per qualsiasi utente o amministratore Linux. Creare nuove cartelle, copiare documenti, spostare file, rinominarli o eliminarli sono operazioni quotidiane che richiedono familiarit\u00e0 con i principali comandi della shell.<\/p>\n

GNU\/Linux mette a disposizione un insieme di strumenti semplici ma estremamente potenti che consentono di amministrare il filesystem in modo rapido ed efficiente. Conoscere questi comandi \u00e8 fondamentale non solo per lavorare dalla riga di comando, ma anche per automatizzare attivit\u00e0 mediante script e gestire sistemi privi di interfaccia grafica.<\/p>\n

In questa lezione imparerai a creare, copiare, spostare ed eliminare file e directory, utilizzare collegamenti simbolici e fisici, individuare file nel filesystem e comprendere le principali operazioni di gestione del contenuto di un sistema Linux.<\/p>\n

\n

\ud83d\udca1 Exam Tip<\/strong> Per l’esame LPIC-1 \u00e8 fondamentale conoscere i principali comandi di gestione del filesystem, tra cui cp<\/code>, mv<\/code>, rm<\/code>, mkdir<\/code>, rmdir<\/code>, touch<\/code>, find<\/code>, locate<\/code>, ln<\/code> e le relative opzioni pi\u00f9 comuni.<\/p>\n<\/blockquote>\n

\n

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

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

    \n
  • creare e rimuovere file e directory;<\/li>\n
  • copiare, spostare e rinominare file e cartelle;<\/li>\n
  • utilizzare collegamenti fisici (hard link) e simbolici (symbolic link);<\/li>\n
  • ricercare file nel filesystem utilizzando gli strumenti appropriati;<\/li>\n
  • gestire in modo sicuro il contenuto del filesystem Linux.<\/li>\n<\/ul>\n
    \n

    Argomenti trattati<\/h2>\n
      \n
    • Creazione e rimozione di file e directory.<\/li>\n
    • Copia, spostamento e rinomina.<\/li>\n
    • Hard link e collegamenti simbolici.<\/li>\n
    • Ricerca dei file con find<\/code> e locate<\/code>.<\/li>\n
    • Operazioni comuni sul filesystem.<\/li>\n
    • Best practice nella gestione dei file.<\/li>\n<\/ul>\n
      \n

      \u2328\ufe0f Provalo subito<\/strong>
      Apri un terminale Linux e crea una directory di test nella tua home. Utilizzala per sperimentare i comandi presentati nella lezione senza il rischio di modificare file importanti del sistema.<\/p>\n<\/blockquote>\n

      103.4.1 Gestione di base di file e directory<\/h2>\n

      La gestione di file e directory costituisce una delle attivit\u00e0 fondamentali di qualsiasi sistema operativo. In Linux, quasi ogni elemento del sistema \u00e8 rappresentato da un file: documenti, configurazioni, dispositivi, processi e persino alcune informazioni di sistema. Per questo motivo, conoscere i principali comandi per amministrare il filesystem \u00e8 una competenza indispensabile per ogni amministratore Linux.<\/p>\n

      Essendo un diretto discendente di Unix, Linux mette a disposizione un insieme di strumenti semplici, affidabili e potenti che consentono di creare, copiare, spostare, rinominare ed eliminare file e directory direttamente dalla riga di comando.<\/p>\n

      \n

      \ud83d\udca1 Exam Tip<\/strong> Per l’esame LPIC-1 \u00e8 essenziale conoscere i principali comandi di gestione del filesystem e comprenderne il comportamento, le opzioni pi\u00f9 comuni e le differenze tra le varie operazioni.<\/p>\n<\/blockquote>\n

      \n

      Perch\u00e9 \u00e8 importante gestire correttamente i file?<\/h3>\n

      L’amministrazione di un sistema Linux richiede continuamente operazioni sul filesystem, ad esempio:<\/p>\n

        \n
      • creare directory per nuovi progetti;<\/li>\n
      • copiare file di configurazione;<\/li>\n
      • spostare o rinominare documenti;<\/li>\n
      • eliminare file non pi\u00f9 necessari;<\/li>\n
      • organizzare dati e backup.<\/li>\n<\/ul>\n

        Saper utilizzare i comandi appropriati consente di lavorare in modo rapido, preciso e sicuro, anche su sistemi privi di interfaccia grafica.<\/p>\n

        \n

        I principali comandi di gestione<\/h3>\n

        Durante questa lezione approfondirai l’utilizzo dei comandi fondamentali per amministrare file e directory.<\/p>\n\n\n\n\n\n\n\n\n\n\n\n\n\n
        Comando<\/th>\nFunzione<\/th>\n<\/tr>\n<\/thead>\n
        touch<\/code><\/td>\nCrea un file vuoto o aggiorna la data di modifica di un file esistente.<\/td>\n<\/tr>\n
        mkdir<\/code><\/td>\nCrea una nuova directory.<\/td>\n<\/tr>\n
        cp<\/code><\/td>\nCopia file e directory.<\/td>\n<\/tr>\n
        mv<\/code><\/td>\nSposta o rinomina file e directory.<\/td>\n<\/tr>\n
        rm<\/code><\/td>\nElimina file e directory.<\/td>\n<\/tr>\n
        rmdir<\/code><\/td>\nElimina directory vuote.<\/td>\n<\/tr>\n
        find<\/code><\/td>\nRicerca file e directory nel filesystem.<\/td>\n<\/tr>\n
        locate<\/code><\/td>\nRicerca rapidamente file tramite un database indicizzato.<\/td>\n<\/tr>\n
        ln<\/code><\/td>\nCrea hard link e collegamenti simbolici.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

        Nei prossimi paragrafi analizzeremo ciascun comando nel dettaglio.<\/p>\n

        \n

        Operare sul filesystem in sicurezza<\/h3>\n

        Molti comandi di gestione dei file modificano direttamente il contenuto del filesystem. Per questo motivo \u00e8 importante verificare sempre il percorso sul quale si sta operando prima di eseguire operazioni potenzialmente distruttive, come l’eliminazione di file o directory.<\/p>\n

        \n

        \ud83d\udccc Da ricordare<\/strong> In Linux molti comandi, come rm<\/code>, eliminano definitivamente i file senza spostarli nel Cestino. Prima di confermare un’operazione, verifica sempre il percorso e gli argomenti del comando.<\/p>\n<\/blockquote>\n

        \n

        Best Practice<\/h3>\n

        Prima di eseguire operazioni di copia, spostamento o eliminazione, verifica sempre la directory corrente utilizzando pwd<\/code> e il contenuto della cartella con ls<\/code>. Questa semplice abitudine riduce il rischio di modificare o cancellare accidentalmente file importanti.<\/p>\n

        \n

        Riepilogo<\/h3>\n
          \n
        • La gestione di file e directory \u00e8 una competenza fondamentale nell’amministrazione di sistemi Linux.<\/li>\n
        • Linux mette a disposizione numerosi comandi dedicati alla gestione del filesystem.<\/li>\n
        • I principali strumenti consentono di creare, copiare, spostare, rinominare, eliminare e ricercare file e directory.<\/li>\n
        • Prima di modificare il filesystem \u00e8 sempre opportuno verificare il percorso sul quale si sta operando.<\/li>\n<\/ul>\n

          103.4.2 Copiare, spostare e rimuovere file<\/h2>\n

          La gestione dei file in Linux si basa principalmente su tre comandi fondamentali: cp<\/code>, mv<\/code> e rm<\/code>. Questi strumenti permettono di copiare, spostare, rinominare ed eliminare file e directory, rappresentando alcune delle operazioni pi\u00f9 comuni nell’amministrazione di un sistema Linux.<\/p>\n

          Pur essendo semplici da utilizzare, questi comandi modificano direttamente il filesystem. \u00c8 quindi importante comprenderne il funzionamento e utilizzarli con attenzione.<\/p>\n

          \n

          \ud83d\udca1 Exam Tip<\/strong> Per l’esame LPIC-1 \u00e8 fondamentale conoscere i comandi cp<\/code>, mv<\/code> e rm<\/code>, comprese le opzioni pi\u00f9 comuni come -r<\/code>, -i<\/code>, -f<\/code> e -v<\/code>.<\/p>\n<\/blockquote>\n

          \n

          Copiare file e directory con cp<\/code><\/h3>\n

          Il comando cp<\/code> (copy<\/strong>) permette di creare una copia di uno o pi\u00f9 file oppure di intere directory.<\/p>\n

          Per copiare un file:<\/p>\n

          cp source.txt destination.txt\r\n<\/code><\/pre>\n
          Il file source.txt<\/code> viene copiato con il nome destination.txt<\/code>.<\/p>\n
          Per copiare una directory completa \u00e8 necessario utilizzare l’opzione -r<\/code> (recursive<\/strong>):<\/p>\n
          cp -r source_dir\/ destination_dir\/\r\n<\/code><\/pre>\n
          Questa opzione copia la directory e tutto il suo contenuto, comprese eventuali sottodirectory.<\/p>\n
          Alcune opzioni molto utilizzate sono:<\/p>\n
            \n
          • -r<\/code> \u2192 copia ricorsivamente directory e sottodirectory;<\/li>\n
          • -i<\/code> \u2192 richiede conferma prima di sovrascrivere un file esistente;<\/li>\n
          • -v<\/code> \u2192 visualizza i file copiati (modalit\u00e0 verbose).<\/li>\n<\/ul>\n
            \n
            Spostare o rinominare file con mv<\/code><\/h3>\n
            Il comando mv<\/code> (move<\/strong>) permette sia di spostare file e directory sia di rinominarli.<\/p>\n
            Per rinominare un file:<\/p>\n
            mv oldname.txt newname.txt\r\n<\/code><\/pre>\n
            Per spostare un file in un’altra directory:<\/p>\n
            mv documento.pdf \/home\/user\/Documenti\/\r\n<\/code><\/pre>\n
            Il comando pu\u00f2 essere utilizzato anche per spostare intere directory.<\/p>\n
            Opzioni comuni:<\/p>\n
              \n
            • -i<\/code> \u2192 richiede conferma prima della sovrascrittura;<\/li>\n
            • -v<\/code> \u2192 mostra le operazioni eseguite.<\/li>\n<\/ul>\n
              \n
              Eliminare file e directory con rm<\/code><\/h3>\n
              Il comando rm<\/code> (remove<\/strong>) elimina definitivamente file e directory.<\/p>\n
              Per eliminare un file:<\/p>\n
              rm unwanted.txt\r\n<\/code><\/pre>\n
              Per eliminare una directory e tutto il suo contenuto:<\/p>\n
              rm -r unwanted_dir\/\r\n<\/code><\/pre>\n
              L’opzione -r<\/code> consente di eliminare ricorsivamente directory e sottodirectory.<\/p>\n
              Tra le opzioni pi\u00f9 utilizzate troviamo:<\/p>\n
                \n
              • -r<\/code> \u2192 elimina directory ricorsivamente;<\/li>\n
              • -f<\/code> \u2192 forza l’eliminazione senza richiedere conferma;<\/li>\n
              • -i<\/code> \u2192 richiede conferma prima di ogni eliminazione;<\/li>\n
              • -v<\/code> \u2192 mostra i file eliminati.<\/li>\n<\/ul>\n
                \n
                \u26a0\ufe0f Attenzione<\/strong> A differenza dei sistemi operativi desktop, il comando rm<\/code> non sposta i file nel Cestino: l’eliminazione \u00e8 normalmente definitiva.<\/p>\n<\/blockquote>\n
                \n
                Confronto tra i comandi<\/h3>\n\n\n\n\n\n\n\n
                Comando<\/th>\nOperazione<\/th>\n<\/tr>\n<\/thead>\n
                cp<\/code><\/td>\nCopia file e directory.<\/td>\n<\/tr>\n
                mv<\/code><\/td>\nSposta o rinomina file e directory.<\/td>\n<\/tr>\n
                rm<\/code><\/td>\nElimina file e directory.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
                \n
                Best Practice<\/h3>\n
                Quando utilizzi cp<\/code>, mv<\/code> o rm<\/code>, considera l’uso dell’opzione -i<\/code> durante le operazioni pi\u00f9 delicate, cos\u00ec da ricevere una richiesta di conferma prima della sovrascrittura o dell’eliminazione dei file. Prima di utilizzare rm -r<\/code>, verifica sempre il percorso della directory con pwd<\/code> e controllane il contenuto con ls<\/code>.<\/p>\n
                \n
                Riepilogo<\/h3>\n
                  \n
                • cp<\/code> copia file e directory.<\/li>\n
                • cp -r<\/code> copia ricorsivamente una directory.<\/li>\n
                • mv<\/code> sposta o rinomina file e directory.<\/li>\n
                • rm<\/code> elimina file.<\/li>\n
                • rm -r<\/code> elimina directory e tutto il loro contenuto.<\/li>\n
                • Le opzioni -i<\/code>, -f<\/code> e -v<\/code> rendono questi comandi pi\u00f9 sicuri o pi\u00f9 dettagliati.<\/li>\n<\/ul>\n
                  103.4.3 Gestione delle directory<\/h2>\n
                  Le directory costituiscono la struttura portante del filesystem Linux e permettono di organizzare file e cartelle in modo gerarchico. La shell mette a disposizione numerosi comandi per creare, visualizzare e rimuovere directory, oltre a creare rapidamente nuovi file.<\/p>\n
                  Conoscere questi strumenti \u00e8 fondamentale per amministrare il filesystem in modo ordinato ed efficiente.<\/p>\n
                  \n
                  \ud83d\udca1 Exam Tip<\/strong> Per l’esame LPIC-1 \u00e8 importante conoscere i comandi mkdir<\/code>, rmdir<\/code>, ls<\/code> e touch<\/code>, comprese le opzioni pi\u00f9 comuni e il loro utilizzo pratico.<\/p>\n<\/blockquote>\n
                  \n
                  Creare directory con mkdir<\/code><\/h3>\n
                  Il comando mkdir<\/code> (make directory<\/strong>) permette di creare una nuova directory.<\/p>\n
                  Esempio:<\/p>\n
                  mkdir new_dir\r\n<\/code><\/pre>\n
                  Verr\u00e0 creata una directory chiamata new_dir<\/code> nella posizione corrente.<\/p>\n
                  Per creare contemporaneamente una struttura di directory annidate si utilizza l’opzione -p<\/code>:<\/p>\n
                  mkdir -p progetti\/linux\/lab\r\n<\/code><\/pre>\n
                  Se una delle directory intermedie non esiste, verr\u00e0 creata automaticamente.<\/p>\n
                  \n
                  Eliminare directory con rmdir<\/code><\/h3>\n
                  Il comando rmdir<\/code> elimina una directory, ma solo se \u00e8 completamente vuota.<\/p>\n
                  Esempio:<\/p>\n
                  rmdir empty_dir\r\n<\/code><\/pre>\n
                  Se la directory contiene file o sottodirectory, il comando restituir\u00e0 un messaggio di errore.<\/p>\n
                  Per eliminare directory non vuote si utilizza normalmente:<\/p>\n
                  rm -r directory\r\n<\/code><\/pre>\n
                  \n
                  Visualizzare il contenuto di una directory con ls<\/code><\/h3>\n
                  Il comando ls<\/code> elenca il contenuto di una directory.<\/p>\n
                  Per visualizzare il contenuto della directory corrente:<\/p>\n
                  ls\r\n<\/code><\/pre>\n
                  Una delle opzioni pi\u00f9 utilizzate \u00e8:<\/p>\n
                  ls -la\r\n<\/code><\/pre>\n
                  dove:<\/p>\n
                    \n
                  • -l<\/code> visualizza il formato dettagliato (permessi, proprietario, dimensioni e data);<\/li>\n
                  • -a<\/code> mostra anche i file nascosti, il cui nome inizia con un punto (.<\/code>).<\/li>\n<\/ul>\n
                    L’opzione -h<\/code> viene spesso combinata con -l<\/code> per visualizzare dimensioni pi\u00f9 leggibili:<\/p>\n
                    ls -lh\r\n<\/code><\/pre>\n
                    \n
                    Creare file con touch<\/code><\/h3>\n
                    Il comando touch<\/code> permette di creare un file vuoto.<\/p>\n
                    Esempio:<\/p>\n
                    touch newfile.txt\r\n<\/code><\/pre>\n
                    Se il file non esiste, viene creato immediatamente.<\/p>\n
                    Se invece il file esiste gi\u00e0, touch<\/code> non ne modifica il contenuto ma aggiorna il suo timestamp<\/strong>, ovvero la data e l’ora dell’ultima modifica o accesso (a seconda delle opzioni utilizzate).<\/p>\n
                    Questo comportamento \u00e8 molto utile negli script e durante i test.<\/p>\n
                    \n
                    Comandi principali per la gestione delle directory<\/h3>\n\n\n\n\n\n\n\n\n\n\n
                    Comando<\/th>\nFunzione<\/th>\n<\/tr>\n<\/thead>\n
                    mkdir<\/code><\/td>\nCrea una nuova directory.<\/td>\n<\/tr>\n
                    mkdir -p<\/code><\/td>\nCrea anche eventuali directory intermedie.<\/td>\n<\/tr>\n
                    rmdir<\/code><\/td>\nElimina una directory vuota.<\/td>\n<\/tr>\n
                    ls<\/code><\/td>\nVisualizza il contenuto di una directory.<\/td>\n<\/tr>\n
                    ls -la<\/code><\/td>\nMostra file nascosti e informazioni dettagliate.<\/td>\n<\/tr>\n
                    touch<\/code><\/td>\nCrea un file vuoto o aggiorna il timestamp di un file esistente.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
                    \n
                    \ud83d\udccc Da ricordare<\/strong> rmdir<\/code> pu\u00f2 eliminare esclusivamente directory vuote. Per rimuovere una directory contenente file \u00e8 necessario utilizzare rm -r<\/code>.<\/p>\n<\/blockquote>\n
                    \n
                    Best Practice<\/h3>\n
                    Organizza sempre i tuoi file in una struttura di directory logica e coerente. Utilizza mkdir -p<\/code> quando devi creare pi\u00f9 livelli di directory e preferisci ls -lah<\/code> durante l’amministrazione del sistema per visualizzare anche i file nascosti e le dimensioni in formato leggibile.<\/p>\n
                    \n
                    Riepilogo<\/h3>\n
                      \n
                    • mkdir<\/code> crea nuove directory.<\/li>\n
                    • mkdir -p<\/code> crea automaticamente anche le directory intermedie.<\/li>\n
                    • rmdir<\/code> elimina esclusivamente directory vuote.<\/li>\n
                    • ls<\/code> visualizza il contenuto delle directory.<\/li>\n
                    • ls -la<\/code> mostra informazioni dettagliate e file nascosti.<\/li>\n
                    • touch<\/code> crea file vuoti o aggiorna il timestamp di file esistenti.<\/li>\n<\/ul>\n
                      103.4.4 Ricercare file con find<\/code><\/h2>\n
                      Il comando find<\/code> \u00e8 uno degli strumenti pi\u00f9 potenti disponibili in Linux per la ricerca di file e directory. Permette di individuare elementi del filesystem in base a numerosi criteri, come il nome, il tipo, la dimensione, la data di modifica, il proprietario e molto altro.<\/p>\n
                      Grazie alla sua flessibilit\u00e0, find<\/code> \u00e8 ampiamente utilizzato nell’amministrazione dei sistemi, negli script Bash e nelle attivit\u00e0 di manutenzione.<\/p>\n
                      \n
                      \ud83d\udca1 Exam Tip<\/strong> Per l’esame LPIC-1 \u00e8 fondamentale conoscere il comando find<\/code>, le principali opzioni di ricerca e la possibilit\u00e0 di eseguire operazioni sui file trovati tramite l’opzione -exec<\/code>.<\/p>\n<\/blockquote>\n
                      \n
                      Struttura del comando<\/h3>\n
                      La sintassi generale \u00e8:<\/p>\n
                      find percorso criteri\r\n<\/code><\/pre>\n
                      dove:<\/p>\n
                        \n
                      • percorso<\/strong> indica la directory dalla quale iniziare la ricerca;<\/li>\n
                      • criteri<\/strong> definiscono le caratteristiche dei file da individuare.<\/li>\n<\/ul>\n
                        Ad esempio:<\/p>\n
                        find \/home\/user -name \"*.txt\"\r\n<\/code><\/pre>\n
                        ricerca tutti i file con estensione .txt<\/code> presenti nella directory indicata e nelle sue sottodirectory.<\/p>\n
                        \n
                        Ricercare file per nome<\/h3>\n
                        Per cercare tutti i file con estensione .txt<\/code>:<\/p>\n
                        find \/ -name \"*.txt\"\r\n<\/code><\/pre>\n
                        L’opzione -name<\/code> distingue tra lettere maiuscole e minuscole.<\/p>\n
                        Per effettuare una ricerca senza distinzione tra maiuscole e minuscole si utilizza:<\/p>\n
                        find \/ -iname \"*.txt\"\r\n<\/code><\/pre>\n
                        \n
                        Ricercare file modificati recentemente<\/h3>\n
                        \u00c8 possibile individuare i file modificati negli ultimi giorni mediante l’opzione -mtime<\/code>.<\/p>\n
                        Ad esempio, per trovare i file modificati nelle ultime 24 ore:<\/p>\n
                        find \/ -mtime -1\r\n<\/code><\/pre>\n
                        Alcuni esempi:<\/p>\n
                          \n
                        • -mtime -1<\/code> \u2192 modificati meno di un giorno fa;<\/li>\n
                        • -mtime 7<\/code> \u2192 modificati esattamente sette giorni fa;<\/li>\n
                        • -mtime +30<\/code> \u2192 modificati pi\u00f9 di trenta giorni fa.<\/li>\n<\/ul>\n
                          \n
                          Ricercare file in base alla dimensione<\/h3>\n
                          L’opzione -size<\/code> permette di selezionare file in funzione della loro dimensione.<\/p>\n
                          Ad esempio:<\/p>\n
                          find \/ -size +1M\r\n<\/code><\/pre>\n
                          ricerca tutti i file di dimensione superiore a 1 MB.<\/p>\n
                          Altri esempi:<\/p>\n
                            \n
                          • +100M<\/code> \u2192 maggiori di 100 MB;<\/li>\n
                          • -10k<\/code> \u2192 inferiori a 10 KB;<\/li>\n
                          • 500c<\/code> \u2192 esattamente 500 byte.<\/li>\n<\/ul>\n
                            \n
                            Eseguire operazioni sui file trovati<\/h3>\n
                            Una delle caratteristiche pi\u00f9 potenti di find<\/code> \u00e8 la possibilit\u00e0 di eseguire automaticamente un comando su ogni file trovato mediante l’opzione -exec<\/code>.<\/p>\n
                            Ad esempio:<\/p>\n
                            find . -name \"*.log\" -exec ls -lh {} \\;\r\n<\/code><\/pre>\n
                            In questo esempio:<\/p>\n
                              \n
                            • {}<\/code> rappresenta il file trovato;<\/li>\n
                            • \\;<\/code> indica la fine del comando da eseguire.<\/li>\n<\/ul>\n
                              Questa funzionalit\u00e0 \u00e8 estremamente utile negli script di amministrazione.<\/p>\n
                              \n
                              Altri criteri di ricerca<\/h3>\n
                              Tra le opzioni pi\u00f9 utilizzate troviamo:<\/p>\n\n\n\n\n\n\n\n\n\n\n\n
                              Opzione<\/th>\nDescrizione<\/th>\n<\/tr>\n<\/thead>\n
                              -name<\/code><\/td>\nRicerca per nome.<\/td>\n<\/tr>\n
                              -iname<\/code><\/td>\nRicerca per nome ignorando maiuscole e minuscole.<\/td>\n<\/tr>\n
                              -type f<\/code><\/td>\nRicerca solo file.<\/td>\n<\/tr>\n
                              -type d<\/code><\/td>\nRicerca solo directory.<\/td>\n<\/tr>\n
                              -size<\/code><\/td>\nRicerca in base alla dimensione.<\/td>\n<\/tr>\n
                              -mtime<\/code><\/td>\nRicerca in base alla data di modifica.<\/td>\n<\/tr>\n
                              -exec<\/code><\/td>\nEsegue un comando sui file trovati.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
                              \n
                              \ud83d\udccc Da ricordare<\/strong> Il comando find<\/code> esplora realmente il filesystem, quindi pu\u00f2 richiedere tempo su dischi molto grandi. Nella prossima sezione vedremo il comando locate<\/code>, molto pi\u00f9 veloce perch\u00e9 utilizza un database indicizzato.<\/p>\n<\/blockquote>\n
                              \n
                              Best Practice<\/h3>\n
                              Quando possibile, limita sempre il percorso di ricerca alla directory realmente interessata anzich\u00e9 utilizzare \/<\/code>. In questo modo le ricerche saranno pi\u00f9 rapide e produrranno risultati pi\u00f9 pertinenti. Inoltre, utilizza con attenzione l’opzione -exec<\/code>, soprattutto quando esegue comandi che modificano o eliminano file.<\/p>\n
                              \n
                              Riepilogo<\/h3>\n
                                \n
                              • find<\/code> ricerca file e directory nel filesystem.<\/li>\n
                              • -name<\/code> e -iname<\/code> consentono di cercare per nome.<\/li>\n
                              • -mtime<\/code> seleziona i file in base alla data di modifica.<\/li>\n
                              • -size<\/code> permette di ricercare file in base alla dimensione.<\/li>\n
                              • -type<\/code> distingue file e directory.<\/li>\n
                              • -exec<\/code> consente di eseguire automaticamente un comando sui file trovati.<\/li>\n<\/ul>\n
                                103.4.5 Archiviazione e backup<\/h2>\n
                                La creazione di archivi e copie di sicurezza \u00e8 una delle attivit\u00e0 pi\u00f9 importanti nell’amministrazione di un sistema Linux. Che si tratti di salvare file di configurazione, trasferire documenti o creare immagini complete di un disco, Linux mette a disposizione strumenti potenti e flessibili per gestire ogni esigenza.<\/p>\n
                                Tra le utility pi\u00f9 utilizzate troviamo tar<\/code>, cpio<\/code> e dd<\/code>, ciascuna progettata per scopi specifici.<\/p>\n
                                \n
                                \ud83d\udca1 Exam Tip<\/strong> Per l’esame LPIC-1 \u00e8 fondamentale conoscere l’utilizzo dei comandi tar<\/code>, cpio<\/code> e dd<\/code>, comprendendone le differenze e gli scenari d’impiego.<\/p>\n<\/blockquote>\n
                                \n
                                Creare archivi con tar<\/code><\/h3>\n
                                Il comando tar<\/code> (Tape Archive<\/strong>) permette di raccogliere pi\u00f9 file e directory in un unico archivio.<\/p>\n
                                Per creare un archivio:<\/p>\n
                                tar -cvf archive.tar file1 file2\r\n<\/code><\/pre>\n
                                dove:<\/p>\n
                                  \n
                                • -c<\/code> crea un nuovo archivio;<\/li>\n
                                • -v<\/code> visualizza i file elaborati (verbose);<\/li>\n
                                • -f<\/code> specifica il nome dell’archivio.<\/li>\n<\/ul>\n
                                  Per estrarre il contenuto:<\/p>\n
                                  tar -xvf archive.tar\r\n<\/code><\/pre>\n
                                  In questo caso:<\/p>\n
                                    \n
                                  • -x<\/code> estrae i file;<\/li>\n
                                  • -v<\/code> mostra le operazioni eseguite;<\/li>\n
                                  • -f<\/code> indica il file archivio.<\/li>\n<\/ul>\n
                                    \n
                                    \ud83d\udccc Da ricordare<\/strong> Il formato .tar<\/code> \u00e8 un archivio, non una compressione. Spesso viene successivamente compresso con strumenti come gzip<\/code>, bzip2<\/code> o xz<\/code>, ottenendo file con estensioni come .tar.gz<\/code>, .tar.bz2<\/code> o .tar.xz<\/code>.<\/p>\n<\/blockquote>\n
                                    \n
                                    Archiviare con cpio<\/code><\/h3>\n
                                    Il comando cpio<\/code> svolge una funzione simile a tar<\/code>, ma lavora in modo differente: legge l’elenco dei file dallo Standard Input (stdin)<\/strong>.<\/p>\n
                                    Ad esempio:<\/p>\n
                                    find . -name \"*.txt\" | cpio -ov > archivio.cpio\r\n<\/code><\/pre>\n
                                    In questo esempio:<\/p>\n
                                      \n
                                    • find<\/code> individua i file;<\/li>\n
                                    • cpio<\/code> crea un archivio contenente tutti i file trovati.<\/li>\n<\/ul>\n
                                      Sebbene oggi sia meno diffuso rispetto a tar<\/code>, cpio<\/code> \u00e8 ancora presente in numerosi sistemi Unix\/Linux ed \u00e8 richiesto dal syllabus LPIC-1.<\/p>\n
                                      \n
                                      Copiare dati a basso livello con dd<\/code><\/h3>\n
                                      Il comando dd<\/code> permette di copiare dati a livello di blocchi, senza interpretarne il contenuto.<\/p>\n
                                      Viene utilizzato principalmente per:<\/p>\n
                                        \n
                                      • creare immagini complete di dischi o partizioni;<\/li>\n
                                      • eseguire backup a basso livello;<\/li>\n
                                      • clonare dischi;<\/li>\n
                                      • scrivere immagini ISO su dispositivi USB.<\/li>\n<\/ul>\n
                                        Ad esempio, per creare un’immagine di un disco:<\/p>\n
                                        dd if=\/dev\/sda of=\/path\/to\/backup.img\r\n<\/code><\/pre>\n
                                        dove:<\/p>\n
                                          \n
                                        • if<\/code> (input file<\/strong>) indica la sorgente;<\/li>\n
                                        • of<\/code> (output file<\/strong>) indica il file di destinazione.<\/li>\n<\/ul>\n
                                          \u00c8 possibile specificare anche la dimensione dei blocchi copiati:<\/p>\n
                                          dd if=\/dev\/sda of=backup.img bs=4M status=progress\r\n<\/code><\/pre>\n
                                          L’opzione status=progress<\/code> mostra l’avanzamento della copia ed \u00e8 molto utile durante operazioni di lunga durata.<\/p>\n
                                          \n
                                          \u26a0\ufe0f Attenzione<\/strong> dd<\/code> copia i dati senza effettuare verifiche. Un errore nell’indicare il dispositivo di destinazione pu\u00f2 causare la sovrascrittura completa di un disco. Per questo motivo viene spesso scherzosamente definito Disk Destroyer<\/em>.<\/p>\n<\/blockquote>\n
                                          \n
                                          Quando utilizzare questi strumenti?<\/h3>\n\n\n\n\n\n\n\n
                                          Comando<\/th>\nUtilizzo principale<\/th>\n<\/tr>\n<\/thead>\n
                                          tar<\/code><\/td>\nCreazione ed estrazione di archivi di file e directory.<\/td>\n<\/tr>\n
                                          cpio<\/code><\/td>\nArchiviazione di file provenienti da altri comandi tramite stdin.<\/td>\n<\/tr>\n
                                          dd<\/code><\/td>\nBackup, clonazione e copia di interi dischi o partizioni.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
                                          \n
                                          Best Practice<\/h3>\n
                                          Per il backup di file e directory utilizza normalmente tar<\/code>, eventualmente combinato con strumenti di compressione. Riserva dd<\/code> alle copie a basso livello di dischi o partizioni e verifica sempre con estrema attenzione i parametri if<\/code> e of<\/code> prima di eseguire il comando.<\/p>\n
                                          \n
                                          Riepilogo<\/h3>\n
                                            \n
                                          • tar<\/code> crea ed estrae archivi di file e directory.<\/li>\n
                                          • cpio<\/code> crea archivi utilizzando l’elenco dei file ricevuto dallo stdin.<\/li>\n
                                          • dd<\/code> copia dati a livello di blocchi ed \u00e8 utilizzato per backup e clonazione di dischi.<\/li>\n
                                          • dd<\/code> utilizza i parametri if<\/code> (origine) e of<\/code> (destinazione).<\/li>\n
                                          • Prima di utilizzare dd<\/code>, verifica sempre il dispositivo di destinazione per evitare perdite di dati.<\/li>\n<\/ul>\n
                                            103.4.6 Compressione e decompressione dei file<\/h2>\n
                                            La compressione dei file consente di ridurre lo spazio occupato sul disco e velocizzare il trasferimento dei dati attraverso la rete. Linux mette a disposizione diversi algoritmi di compressione, ciascuno con caratteristiche differenti in termini di velocit\u00e0 e rapporto di compressione.<\/p>\n
                                            Tra gli strumenti pi\u00f9 utilizzati troviamo gzip<\/code>, bzip2<\/code> e xz<\/code>, accompagnati dalle rispettive utility per la decompressione.<\/p>\n
                                            \n
                                            \ud83d\udca1 Exam Tip<\/strong> Per l’esame LPIC-1 \u00e8 fondamentale conoscere i comandi gzip<\/code>, gunzip<\/code>, bzip2<\/code>, bunzip2<\/code>, xz<\/code> e unxz<\/code>, comprendendo le differenze tra i vari algoritmi di compressione.<\/p>\n<\/blockquote>\n
                                            \n
                                            Compressione con gzip<\/code><\/h3>\n
                                            gzip<\/code> \u00e8 uno degli strumenti di compressione pi\u00f9 diffusi nei sistemi Linux. Offre un buon compromesso tra velocit\u00e0 e rapporto di compressione.<\/p>\n
                                            Per comprimere un file:<\/p>\n
                                            gzip large.txt\r\n<\/code><\/pre>\n
                                            Il file originale viene sostituito dal file compresso:<\/p>\n
                                            large.txt.gz\r\n<\/code><\/pre>\n
                                            Per decomprimerlo:<\/p>\n
                                            gunzip large.txt.gz\r\n<\/code><\/pre>\n
                                            Il file originale verr\u00e0 ripristinato.<\/p>\n
                                            \n
                                            Compressione con bzip2<\/code><\/h3>\n
                                            bzip2<\/code> utilizza l’algoritmo Burrows-Wheeler<\/strong>, generalmente in grado di ottenere una compressione migliore rispetto a gzip<\/code>, a scapito di tempi di elaborazione pi\u00f9 lunghi.<\/p>\n
                                            Per comprimere un file:<\/p>\n
                                            bzip2 larger.txt\r\n<\/code><\/pre>\n
                                            Il file risultante avr\u00e0 estensione:<\/p>\n
                                            larger.txt.bz2\r\n<\/code><\/pre>\n
                                            Per decomprimerlo:<\/p>\n
                                            bunzip2 larger.txt.bz2\r\n<\/code><\/pre>\n
                                            \n
                                            Compressione con xz<\/code><\/h3>\n
                                            xz<\/code> rappresenta uno degli algoritmi di compressione pi\u00f9 efficienti disponibili in ambiente Linux. Offre un rapporto di compressione molto elevato, risultando particolarmente adatto per file di grandi dimensioni e dati binari.<\/p>\n
                                            Per comprimere un file:<\/p>\n
                                            xz largest.txt\r\n<\/code><\/pre>\n
                                            Il file ottenuto sar\u00e0:<\/p>\n
                                            largest.txt.xz\r\n<\/code><\/pre>\n
                                            Per decomprimerlo:<\/p>\n
                                            unxz largest.txt.xz\r\n<\/code><\/pre>\n
                                            \n
                                            Confronto tra i principali algoritmi<\/h3>\n\n\n\n\n\n\n\n
                                            Comando<\/th>\nEstensione<\/th>\nCaratteristiche<\/th>\n<\/tr>\n<\/thead>\n
                                            gzip<\/code><\/td>\n.gz<\/code><\/td>\nMolto veloce, buon compromesso tra velocit\u00e0 e compressione.<\/td>\n<\/tr>\n
                                            bzip2<\/code><\/td>\n.bz2<\/code><\/td>\nCompressione superiore a gzip, ma pi\u00f9 lenta.<\/td>\n<\/tr>\n
                                            xz<\/code><\/td>\n.xz<\/code><\/td>\nRapporto di compressione molto elevato, ideale per file di grandi dimensioni.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
                                            \n
                                            Compressione e archiviazione<\/h3>\n
                                            \u00c8 importante distinguere tra archiviazione<\/strong> e compressione<\/strong>.<\/p>\n
                                            Gli strumenti appena descritti comprimono un singolo file alla volta. Per comprimere pi\u00f9 file o intere directory si utilizza normalmente tar<\/code> insieme a uno di questi algoritmi.<\/p>\n
                                            Ad esempio:<\/p>\n
                                            Creare un archivio compresso con GZIP:<\/p>\n
                                            tar -czf archivio.tar.gz directory\/\r\n<\/code><\/pre>\n
                                            Creare un archivio compresso con BZIP2:<\/p>\n
                                            tar -cjf archivio.tar.bz2 directory\/\r\n<\/code><\/pre>\n
                                            Creare un archivio compresso con XZ:<\/p>\n
                                            tar -cJf archivio.tar.xz directory\/\r\n<\/code><\/pre>\n
                                            \n
                                            \ud83d\udccc Da ricordare<\/strong> gzip<\/code>, bzip2<\/code> e xz<\/code> comprimono un singolo file. Per comprimere intere directory si utilizza generalmente tar<\/code> insieme a uno di questi algoritmi.<\/p>\n<\/blockquote>\n
                                            \n
                                            Best Practice<\/h3>\n
                                            Per la maggior parte delle attivit\u00e0 quotidiane, gzip<\/code> rappresenta la scelta migliore grazie alla sua velocit\u00e0. Se l’obiettivo \u00e8 ottenere la massima compressione, ad esempio per archiviare backup o distribuire software, \u00e8 preferibile utilizzare xz<\/code>. bzip2<\/code> rimane una valida alternativa, anche se oggi viene impiegato meno frequentemente rispetto a xz<\/code>.<\/p>\n
                                            \n
                                            Riepilogo<\/h3>\n
                                              \n
                                            • gzip<\/code> e gunzip<\/code> comprimono e decomprimono file con estensione .gz<\/code>.<\/li>\n
                                            • bzip2<\/code> e bunzip2<\/code> utilizzano il formato .bz2<\/code>.<\/li>\n
                                            • xz<\/code> e unxz<\/code> utilizzano il formato .xz<\/code> e offrono il miglior rapporto di compressione.<\/li>\n
                                            • Per comprimere directory complete si utilizza normalmente tar<\/code> insieme a gzip<\/code>, bzip2<\/code> o xz<\/code>.<\/li>\n
                                            • La scelta dell’algoritmo dipende dal compromesso desiderato tra velocit\u00e0 e livello di compressione.<\/li>\n<\/ul>\n
                                              103.4.7 Altri strumenti utili<\/h2>\n
                                              Oltre ai comandi per la gestione di file, directory e archivi, Linux mette a disposizione numerose utility che facilitano l’identificazione dei file e la selezione di gruppi di elementi attraverso i cosiddetti metacaratteri (wildcard)<\/strong>. Questi strumenti semplificano il lavoro quotidiano dell’amministratore di sistema e sono ampiamente utilizzati negli script Bash.<\/p>\n
                                              In questa sezione analizzeremo il comando file<\/code> e il meccanismo del file globbing<\/strong>, fondamentale per selezionare rapidamente uno o pi\u00f9 file.<\/p>\n
                                              \n
                                              \ud83d\udca1 Exam Tip<\/strong> Per l’esame LPIC-1 \u00e8 importante conoscere il comando file<\/code> e i principali caratteri jolly utilizzati dal file globbing: *<\/code>, ?<\/code> e []<\/code>.<\/p>\n<\/blockquote>\n
                                              \n
                                              Identificare il tipo di un file con file<\/code><\/h3>\n
                                              L’estensione di un file non sempre indica il suo reale contenuto. Linux determina il tipo di un file analizzandone i dati interni anzich\u00e9 il nome.<\/p>\n
                                              Il comando file<\/code> permette di identificare il tipo di un file.<\/p>\n
                                              Esempio:<\/p>\n
                                              file unknown.txt\r\n<\/code><\/pre>\n
                                              Possibile output:<\/p>\n
                                              unknown.txt: ASCII text\r\n<\/code><\/pre>\n
                                              Altri esempi:<\/p>\n
                                              file immagine.png\r\n<\/code><\/pre>\n
                                              Output:<\/p>\n
                                              immagine.png: PNG image data\r\n<\/code><\/pre>\n
                                              Oppure:<\/p>\n
                                              file archivio.tar.gz\r\n<\/code><\/pre>\n
                                              Output:<\/p>\n
                                              archivio.tar.gz: gzip compressed data\r\n<\/code><\/pre>\n
                                              Questo comando \u00e8 particolarmente utile quando si lavora con file privi di estensione o provenienti da sorgenti esterne.<\/p>\n
                                              \n
                                              Il File Globbing<\/h3>\n
                                              Il file globbing<\/strong> \u00e8 un meccanismo della shell che permette di selezionare gruppi di file utilizzando caratteri jolly (wildcard<\/em>).<\/p>\n
                                              Prima che il comando venga eseguito, \u00e8 la shell stessa a sostituire i metacaratteri con i nomi dei file corrispondenti.<\/p>\n
                                              Ad esempio:<\/p>\n
                                              ls *.txt\r\n<\/code><\/pre>\n
                                              Se nella directory sono presenti:<\/p>\n
                                              note.txt\r\nconfig.txt\r\nbackup.log\r\n<\/code><\/pre>\n
                                              la shell eseguir\u00e0 automaticamente:<\/p>\n
                                              ls note.txt config.txt\r\n<\/code><\/pre>\n
                                              Mostrando solamente i file con estensione .txt<\/code>.<\/p>\n
                                              \n
                                              I principali caratteri jolly<\/h3>\n\n\n\n\n\n\n\n
                                              Carattere<\/th>\nSignificato<\/th>\nEsempio<\/th>\n<\/tr>\n<\/thead>\n
                                              *<\/code><\/td>\nCorrisponde a zero o pi\u00f9 caratteri.<\/td>\n*.txt<\/code><\/td>\n<\/tr>\n
                                              ?<\/code><\/td>\nCorrisponde a un solo carattere.<\/td>\nfile?.txt<\/code><\/td>\n<\/tr>\n
                                              []<\/code><\/td>\nCorrisponde a uno dei caratteri specificati.<\/td>\nfile[123].txt<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
                                              \n
                                              Esempi pratici di globbing<\/h3>\n
                                              Elencare tutti i file di testo:<\/p>\n
                                              ls *.txt\r\n<\/code><\/pre>\n
                                              Visualizzare i file con un solo carattere dopo “file”:<\/p>\n
                                              ls file?.txt\r\n<\/code><\/pre>\n
                                              Selezionare i file numerati da 1 a 3:<\/p>\n
                                              ls file[1-3].txt\r\n<\/code><\/pre>\n
                                              \u00c8 possibile utilizzare i metacaratteri con moltissimi comandi, ad esempio:<\/p>\n
                                              cp *.conf backup\/\r\n<\/code><\/pre>\n
                                              oppure:<\/p>\n
                                              rm *.tmp\r\n<\/code><\/pre>\n
                                              \n
                                              Globbing e ricerca con find<\/code><\/h3>\n
                                              \u00c8 importante distinguere il file globbing dal comando find<\/code>.<\/p>\n
                                                \n
                                              • Il globbing<\/strong> seleziona i file presenti nella directory corrente (o nel percorso specificato).<\/li>\n
                                              • find<\/code> esplora ricorsivamente il filesystem e consente ricerche molto pi\u00f9 avanzate.<\/li>\n<\/ul>\n
                                                Entrambi gli strumenti utilizzano caratteri jolly, ma operano in modo differente.<\/p>\n
                                                \n
                                                \ud83d\udccc Da ricordare<\/strong> I caratteri jolly vengono interpretati dalla shell prima<\/strong> dell’esecuzione del comando. Non \u00e8 il comando stesso a espandere il pattern, ma la shell.<\/p>\n<\/blockquote>\n
                                                \n
                                                Best Practice<\/h3>\n
                                                Utilizza il file globbing per selezionare rapidamente gruppi di file durante le operazioni quotidiane. Prima di eseguire comandi potenzialmente distruttivi, come rm *.log<\/code>, verifica sempre quali file verranno selezionati eseguendo prima un comando innocuo, ad esempio ls *.log<\/code>.<\/p>\n
                                                \n
                                                Riepilogo<\/h3>\n
                                                  \n
                                                • file<\/code> identifica il tipo reale di un file analizzandone il contenuto.<\/li>\n
                                                • Il file globbing utilizza caratteri jolly per selezionare gruppi di file.<\/li>\n
                                                • *<\/code> corrisponde a qualsiasi sequenza di caratteri.<\/li>\n
                                                • ?<\/code> corrisponde a un singolo carattere.<\/li>\n
                                                • []<\/code> seleziona uno dei caratteri specificati o un intervallo.<\/li>\n
                                                • Il globbing viene eseguito dalla shell prima dell’esecuzione del comando.<\/li>\n<\/ul>\n
                                                  \ud83d\udcda Riepilogo della lezione<\/h2>\n
                                                  In questa lezione hai imparato a gestire file e directory utilizzando i principali strumenti messi a disposizione da GNU\/Linux. Hai scoperto come creare, copiare, spostare e rimuovere file, amministrare le directory, ricercare elementi nel filesystem e utilizzare strumenti dedicati all’archiviazione, al backup e alla compressione dei dati.<\/p>\n
                                                  Hai inoltre approfondito il funzionamento del comando find<\/code>, delle utility di compressione pi\u00f9 diffuse e del meccanismo di file globbing<\/strong>, fondamentale per selezionare gruppi di file tramite caratteri jolly.<\/p>\n
                                                  Concetti principali<\/h3>\n
                                                    \n
                                                  • Hai imparato a copiare, spostare, rinominare ed eliminare file e directory con cp<\/code>, mv<\/code> e rm<\/code>.<\/li>\n
                                                  • Hai utilizzato mkdir<\/code>, rmdir<\/code>, ls<\/code> e touch<\/code> per gestire il contenuto del filesystem.<\/li>\n
                                                  • Hai imparato a ricercare file mediante il comando find<\/code> utilizzando diversi criteri di selezione.<\/li>\n
                                                  • Hai conosciuto gli strumenti di archiviazione tar<\/code>, cpio<\/code> e dd<\/code>.<\/li>\n
                                                  • Hai compreso le differenze tra gli algoritmi di compressione gzip<\/code>, bzip2<\/code> e xz<\/code>.<\/li>\n
                                                  • Hai utilizzato il comando file<\/code> per identificare il tipo reale dei file.<\/li>\n
                                                  • Hai scoperto il funzionamento del file globbing<\/strong> mediante i caratteri jolly *<\/code>, ?<\/code> e []<\/code>.<\/li>\n<\/ul>\n
                                                    \n
                                                    \ud83c\udfaf Obiettivo raggiunto<\/strong> Al termine di questa lezione sei in grado di gestire efficacemente file e directory, ricercare informazioni nel filesystem, creare archivi, comprimere dati e utilizzare i principali strumenti di amministrazione del filesystem 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\n\n\n
                                                    Comando<\/th>\nDescrizione<\/th>\n<\/tr>\n<\/thead>\n
                                                    cp<\/code><\/td>\nCopia file e directory.<\/td>\n<\/tr>\n
                                                    mv<\/code><\/td>\nSposta o rinomina file e directory.<\/td>\n<\/tr>\n
                                                    rm<\/code><\/td>\nElimina file e directory.<\/td>\n<\/tr>\n
                                                    mkdir<\/code><\/td>\nCrea nuove directory.<\/td>\n<\/tr>\n
                                                    rmdir<\/code><\/td>\nElimina directory vuote.<\/td>\n<\/tr>\n
                                                    ls<\/code><\/td>\nVisualizza il contenuto di una directory.<\/td>\n<\/tr>\n
                                                    touch<\/code><\/td>\nCrea file vuoti o aggiorna il timestamp.<\/td>\n<\/tr>\n
                                                    find<\/code><\/td>\nRicerca file e directory nel filesystem.<\/td>\n<\/tr>\n
                                                    tar<\/code><\/td>\nCrea ed estrae archivi.<\/td>\n<\/tr>\n
                                                    cpio<\/code><\/td>\nGestisce archivi tramite lo standard input.<\/td>\n<\/tr>\n
                                                    dd<\/code><\/td>\nEsegue copie a basso livello di dischi e partizioni.<\/td>\n<\/tr>\n
                                                    gzip<\/code> \/ gunzip<\/code><\/td>\nComprime e decomprime file nel formato GZIP.<\/td>\n<\/tr>\n
                                                    bzip2<\/code> \/ bunzip2<\/code><\/td>\nComprime e decomprime file nel formato BZIP2.<\/td>\n<\/tr>\n
                                                    xz<\/code> \/ unxz<\/code><\/td>\nComprime e decomprime file nel formato XZ.<\/td>\n<\/tr>\n
                                                    file<\/code><\/td>\nIdentifica il tipo reale di un file.<\/td>\n<\/tr>\n
                                                    *<\/code>, ?<\/code>, []<\/code><\/td>\nMetacaratteri utilizzati dal file globbing.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
                                                    \n
                                                    \ud83d\udca1 Preparazione all’esame LPIC-1<\/strong> Prima di proseguire assicurati di conoscere i principali comandi per la gestione del filesystem, le differenze tra archiviazione e compressione, l’utilizzo del comando find<\/code>, le utility di backup e il funzionamento dei caratteri jolly della shell. Questi argomenti sono frequentemente presenti nelle domande dell’esame LPIC-1.<\/p>\n<\/blockquote>\n
                                                    \n
                                                    \u27a1\ufe0f Prossima lezione<\/h2>\n
                                                    Nella prossima lezione (103.5 Creare, monitorare e terminare i processi<\/strong>) scoprirai come Linux gestisce i processi in esecuzione. Imparerai a visualizzarli, monitorarne lo stato, controllarne il consumo di risorse e terminarli utilizzando i principali strumenti di amministrazione del sistema.<\/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-3638","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.4 Gestire file e directory La gestione di file e directory rappresenta una delle attivit\u00e0 pi\u00f9 frequenti per qualsiasi utente o amministratore Linux. Creare nuove cartelle, copiare documenti, spostare file, rinominarli o eliminarli sono operazioni quotidiane che richiedono familiarit\u00e0 con i principali comandi della shell. GNU\/Linux mette a disposizione un insieme di strumenti semplici ma…","_links":{"self":[{"href":"https:\/\/rootmail.it\/en\/wp-json\/wp\/v2\/lesson\/3638","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=3638"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/rootmail.it\/en\/wp-json\/wp\/v2\/media\/3676"}],"wp:attachment":[{"href":"https:\/\/rootmail.it\/en\/wp-json\/wp\/v2\/media?parent=3638"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}