---
title: "Primi passi nel terminale"
domain: cloud-computing
level: foundations
duration: "30 min"
objectives:
  - "Aprire un terminale su Windows (WSL), macOS o Linux e spiegare cosa sono un comando, un argomento e il prompt."
  - "Muoversi tra le cartelle ed elencarne il contenuto con `pwd`, `ls` e `cd`."
  - "Creare, leggere, copiare, spostare ed eliminare file e cartelle con `mkdir`, `touch`, `cat`, `cp`, `mv` e `rm`."
  - "Leggere i messaggi di errore e ottenere aiuto con `--help` e `man`."
lang: it
source_hash: 971f61ae4796
---

# Primi passi nel terminale

## Perché è importante
Immagina di chiedere a un amico di riordinare la tua raccolta di foto. Potresti stargli accanto e indicargli ogni foto. Oppure potresti dargli un breve elenco scritto di istruzioni. L'elenco è più veloce, si può controllare e domani puoi darlo a un'altra persona e ottenere lo stesso risultato.

Questa è l'idea del terminale. Invece di fare clic su icone e menu, scrivi brevi istruzioni e il computer le esegue. Un server cloud di solito non ha schermo, mouse né desktop: scrivere è l'unico modo per parlargli. Anche i laboratori di questo corso usano un terminale, perché le istruzioni scritte sono esatte, ripetibili e facili da copiare.

Sembra intimidatorio: una finestra quasi vuota con un cursore che lampeggia. In pratica, una dozzina di comandi copre quasi tutto ciò che serve.

## Obiettivi di apprendimento
- Aprire un terminale su Windows (WSL), macOS o Linux e spiegare cosa sono un comando, un argomento e il prompt.
- Muoversi tra le cartelle ed elencarne il contenuto con `pwd`, `ls` e `cd`.
- Creare, leggere, copiare, spostare ed eliminare file e cartelle con `mkdir`, `touch`, `cat`, `cp`, `mv` e `rm`.
- Leggere i messaggi di errore e ottenere aiuto con `--help` e `man`.

## Concetti chiave

### Cosa sono un terminale e una shell
Pensa a un ristorante. Dici al cameriere cosa vuoi e il cameriere porta il piatto da una cucina che non vedi mai.

Il **terminale** è il tavolo: una finestra in cui scrivi testo e leggi testo. La **shell** (interprete dei comandi) è il cameriere: un programma che legge ciò che hai scritto, chiede al computer di eseguirlo e riporta la risposta sotto forma di testo. La shell più comune su Linux si chiama **bash**; quella predefinita su macOS è **zsh** (si pronuncia "zi-scell"). Per i comandi di questo modulo si comportano allo stesso modo.

![Tre schede collegate da frecce. A sinistra, tu: scrivi un comando e premi Invio. Al centro, il terminale e la shell: il terminale è la finestra e la shell legge il comando. A destra, il tuo computer: esegue il programma e restituisce il risultato. Una freccia con l'etichetta comando, come testo, va da sinistra a destra; una seconda freccia con l'etichetta risultato, come testo, torna da destra a sinistra.](../../../assets/diagrams/terminal-how-it-works.it.svg)

*Figura 1. Scrivi un comando come testo; la shell lo passa al computer e stampa il risultato come testo.*

> [!CHECK]
> Nel paragone con il ristorante, quale parte è la shell?
>
> - [ ] Il tavolo a cui ti siedi: la finestra in cui scrivi
> - [x] Il cameriere: il programma che legge il comando e riporta il risultato
> - [ ] La cucina: i file del tuo computer
>
> Il terminale è la finestra. La shell è il programma al suo interno che legge ed esegue ciò che scrivi.

### Il prompt, i comandi, le opzioni e gli argomenti
Quando apri un terminale, vedi una riga di testo e un cursore che lampeggia. Quella riga è il **prompt**. Significa "sono pronto, scrivi qualcosa". Spesso mostra il tuo nome utente, il nome del computer e la cartella in cui ti trovi, e termina con `$` (bash) o `%` (zsh). Il prompt c'è già: non lo scrivi mai. I comandi di esempio di questo modulo lo omettono, così puoi copiarli direttamente.

Ciò che scrivi è un **comando**: il nome di un programma da eseguire. Lo concludi premendo Invio. Molti comandi accettano altri due tipi di parole:

- Un'**opzione** (chiamata anche flag) cambia il modo in cui il comando funziona. Di solito inizia con un trattino: `-l`, oppure con due trattini per un nome lungo: `--help`.
- Un **argomento** dice al comando su cosa agire, come il nome di un file o di una cartella.

Le parole sono separate da spazi e le maiuscole contano: `Photos` e `photos` sono nomi diversi.

![La riga user@laptop:~$ ls -l photos divisa in quattro parti colorate. Il prompt, user@laptop:~$, indica che il terminale è pronto; c'è già e non lo scrivi. Il comando, ls, è il programma che vuoi eseguire. L'opzione, -l, cambia come funziona il comando; le opzioni spesso iniziano con un trattino. L'argomento, photos, è ciò su cui agisce il comando, un file o una cartella. Dopo aver scritto, premi Invio.](../../../assets/diagrams/terminal-command-anatomy.it.svg)

*Figura 2. Scrivi solo il comando, le sue opzioni e i suoi argomenti. Il prompt c'è già.*

> [!CHECK]
> In `ls -l photos`, cos'è `photos`?
>
> - [ ] Il comando
> - [ ] Un'opzione
> - [x] Un argomento
>
> `ls` è il comando, `-l` è un'opzione e `photos` è l'argomento: la cartella su cui agire.

### Cartelle e percorsi
Il tuo computer conserva tutto in **cartelle** (chiamate anche **directory**), e le cartelle possono contenere altre cartelle, come uno schedario. Vista dall'alto, è un albero.

In cima all'albero c'è la **cartella radice**, scritta `/`. Tutto ciò che c'è nel computer si trova al suo interno. Dentro la radice, una cartella chiamata `home` contiene una cartella per ogni persona. La tua è la tua **cartella home**, il posto in cui vivono i tuoi file. La scorciatoia `~` (chiamata tilde) significa sempre "la mia cartella home".

Un **percorso** è l'indirizzo di un file o di una cartella: l'elenco delle cartelle da attraversare, separate da `/`.

- Un **percorso assoluto** inizia con `/` e funziona da qualsiasi punto, come un indirizzo postale completo: `/home/user/terminal-practice/notes`.
- Un **percorso relativo** parte dalla cartella in cui ti trovi, come dire "qui accanto": `notes` significa "la cartella chiamata notes proprio qui".

Due nomi speciali aiutano con i percorsi relativi: `.` significa "questa cartella" e `..` significa "la cartella sopra questa".

![Un albero di cartelle letto da sinistra a destra. La cartella radice, scritta /, è la cima di tutto. Al suo interno c'è home, poi user, che è la tua cartella home e si scrive anche ~. Dentro user c'è terminal-practice, che contiene due cartelle: notes, con il file todo.txt, e photos, con il file cat.jpg. Sotto l'albero ci sono tre schede. Un percorso assoluto inizia con una barra e funziona da qualsiasi punto, per esempio /home/user/terminal-practice/notes. Un percorso relativo parte dalla cartella in cui ti trovi, quindi da terminal-practice è semplicemente notes. Due scorciatoie: un punto indica la cartella corrente e due punti la cartella sopra.](../../../assets/diagrams/terminal-folder-tree.it.svg)

*Figura 3. L'albero delle cartelle. La stessa cartella si può raggiungere con un percorso assoluto o con uno relativo, a seconda di dove ti trovi.*

Il terminale ha sempre una **cartella corrente**, il posto in cui "si trova". Un nuovo terminale parte dalla tua cartella home. Tre comandi ti permettono di guardarti intorno e di muoverti:

| Comando | Cosa fa | Esempio |
|---|---|---|
| `pwd` | **P**rints the **w**orking **d**irectory (stampa la directory di lavoro): dove ti trovi ora | `pwd` |
| `ls` | **L**i**s**ta cosa c'è in una cartella. `-l` mostra i dettagli (dimensione, data); `-a` mostra anche gli elementi nascosti, i cui nomi iniziano con un punto | `ls -l` |
| `cd` | **C**hange **d**irectory (cambia directory). `cd` da solo torna alla home | `cd notes`, `cd ..`, `cd ~/photos` |

> [!CHECK]
> Sei in `/home/user/terminal-practice/notes`. Quale comando ti porta in `/home/user/terminal-practice`?
>
> - [ ] `cd .`
> - [x] `cd ..`
> - [ ] `cd ~`
>
> `..` significa la cartella sopra. `.` è la cartella in cui sei già e `~` porta alla tua cartella home, che è più in alto.

### Lavorare con file e cartelle
Quando sai muoverti, questi comandi creano e gestiscono le cose. Lo schema è sempre lo stesso: il comando, poi ciò su cui agire.

| Comando | Cosa fa | Esempio |
|---|---|---|
| `mkdir` | Crea una cartella | `mkdir photos` |
| `touch` | Crea un file vuoto (o aggiorna la data di uno esistente) | `touch todo.txt` |
| `echo` | Stampa testo. Con `>`, il testo va in un file invece che sullo schermo | `echo "Buy milk" > todo.txt` |
| `cat` | Stampa il contenuto di un file | `cat todo.txt` |
| `cp` | Copia: `cp <origine> <destinazione>` | `cp todo.txt backup.txt` |
| `mv` | Sposta o rinomina: `mv <origine> <destinazione>` | `mv backup.txt old.txt` |
| `rm` | Rimuove (elimina) un file | `rm old.txt` |
| `clear` | Pulisce lo schermo (i tuoi file non vengono toccati) | `clear` |

Alcuni dettagli evitano sorprese ai principianti:

- `>` scrive testo in un file e **sostituisce ciò che c'era**. `>>` aggiunge in fondo. Entrambi si chiamano **reindirizzamento**: l'output va in un file invece che sullo schermo.
- `mv` fa due lavori: con un nuovo nome come destinazione rinomina; con una cartella come destinazione sposta il file al suo interno.
- Per eliminare una cartella usa `rm -r <cartella>`: l'opzione `-r` significa "ricorsivo", la cartella e tutto ciò che contiene.

> [!WARNING]
> `rm` **non ha il cestino**. Un file eliminato è perso, senza annullamento. Rileggi il comando due volte e fai molta attenzione con `rm -r`.

Due funzioni rendono più facile scrivere. La **cronologia**: premi la freccia su per richiamare i comandi precedenti, poi Invio per eseguirli di nuovo. E il **completamento con Tab**: scrivi le prime lettere di un nome e premi Tab, e la shell lo completa. Fa risparmiare digitazione ed evita errori di battitura.

> [!CHECK]
> Cosa fa `mv draft.txt final.txt` quando non esiste alcun file chiamato `final.txt`?
>
> - [ ] Copia `draft.txt` in `final.txt` e li tiene entrambi
> - [x] Rinomina `draft.txt` in `final.txt`
> - [ ] Elimina `draft.txt`, perché viene "spostato" da nessuna parte
>
> `mv` sposta un file verso un nuovo nome o luogo. Spostarlo nella stessa cartella con un nuovo nome equivale a rinominarlo. Il nome originale scompare.

### Leggere gli errori e chiedere aiuto
Un errore di battitura produce un messaggio di errore. Non è un fallimento: è il computer che ti dice, in testo, cosa non ha capito. Ce ne sono tre che compaiono continuamente.

![Tre schede. Command not found: hai scritto male il comando o non è installato, come in pwdd; controlla l'ortografia. No such file or directory: il nome è sbagliato o sei in un'altra cartella, come in cat shopping.txt; usa pwd e ls per orientarti. Permission denied: il sistema non ti lascia farlo con questo file, come in cat /etc/shadow; spesso è una protezione, quindi non forzare. I messaggi del terminale compaiono in inglese.](../../../assets/diagrams/terminal-errors.it.svg)

*Figura 4. Tre errori comuni, un esempio che provoca ciascuno e cosa fare.*

La formulazione varia: bash stampa `bash: pwdd: command not found`; zsh su macOS stampa `zsh: command not found: pwdd`. Il terminale mostra questi messaggi in inglese (o nella lingua del sistema, a seconda di come è configurato), per questo li vedrai in inglese nei blocchi di codice di questo modulo.

Quando non sai come funziona un comando, chiediglielo:

- La maggior parte dei comandi Linux accetta `--help`, che stampa un breve riepilogo: `mkdir --help`.
- `man <comando>` (abbreviazione di **manuale**) apre la **pagina di manuale** completa di un comando: `man ls`. Usa i tasti freccia o la barra spaziatrice per scorrere, `/parola` per cercare e `q` per uscire. Non dimenticare `q`: è la via d'uscita.

> [!NOTE]
> Su macOS molti comandi integrati non capiscono `--help`; usa `man`. Alcune installazioni minime di Linux o WSL non hanno pagine di manuale (`No manual entry`); usa invece `--help`.

> [!CHECK]
> Scrivi `cat notes.txt` e vedi `No such file or directory`. Qual è la prima mossa più utile?
>
> - [ ] Reinstallare il terminale
> - [x] Eseguire `pwd` e `ls` per controllare dove sei e cosa c'è nella cartella
> - [ ] Eseguire di nuovo il comando con `rm` davanti
>
> Il messaggio di solito indica un nome sbagliato o la cartella sbagliata. Guardarsi intorno con `pwd` e `ls` mostra quale delle due.

## Come funziona
Quando premi Invio, accadono quattro cose:

1. La shell divide la riga in parole: la prima è il comando, le altre sono opzioni e argomenti.
2. Cerca un programma con quel nome. Se non ne esiste nessuno, ottieni `command not found`.
3. Avvia il programma e gli passa le opzioni e gli argomenti.
4. Il programma svolge il suo lavoro, stampa l'eventuale risultato e termina. Il prompt ritorna.

### Aprire un terminale sul tuo computer
- **Windows.** I laboratori usano comandi Linux, e il modo più semplice per avere Linux su Windows è **WSL** (Windows Subsystem for Linux, sottosistema Windows per Linux), una funzione di Microsoft che esegue Linux dentro Windows. Apri il menu Start, cerca PowerShell, fai clic con il tasto destro e scegli **Esegui come amministratore**. Scrivi `wsl --install`, premi Invio, attendi e riavvia il PC quando richiesto. Poi apri **Ubuntu** dal menu Start; la prima volta ti chiede di scegliere un nome utente e una password (mentre scrivi la password non compare nulla sullo schermo: è normale). Consulta la guida di Microsoft nei Riferimenti. Alcuni PC aziendali o scolastici bloccano WSL: chiedi al tuo reparto IT o usa una macchina Linux.
- **macOS.** Premi Cmd + Spazio, scrivi `Terminal` e premi Invio. Esegue zsh e i comandi di questo modulo si comportano allo stesso modo.
- **Linux.** Cerca nel menu un'applicazione chiamata Terminale, Konsole o simile. Su molti desktop, Ctrl + Alt + T la apre.

## Esempio pratico
Stai preparando i bagagli per un viaggio e vuoi una cartella per i tuoi appunti e le tue foto. Leggi ogni riga, poi confronta con l'output.

```bash
mkdir -p trip/photos
cd trip
echo "Passport, charger, umbrella" > packing.txt
cp packing.txt packing-v1.txt
mv packing-v1.txt photos/
ls
ls photos
cat packing.txt
```

Output atteso:
```text
packing.txt  photos
packing-v1.txt
Passport, charger, umbrella
```

(`ls` stampa in colonne quando condivide una riga, come qui; contano i nomi, non la spaziatura.)

- `mkdir -p trip/photos` crea `trip` e, al suo interno, `photos`. L'opzione `-p` crea in un colpo solo le cartelle superiori mancanti.
- `cd trip` entra nella nuova cartella. `echo ... > packing.txt` crea il file con quel testo.
- `cp` fa una copia e `mv` sposta la copia in `photos/`.
- Il primo `ls` mostra cosa c'è in `trip`, il secondo cosa c'è in `photos`, e `cat` stampa il testo del file.

I comandi che hanno successo di solito non stampano nulla. Il silenzio significa "fatto".

## Errori comuni
- **Scrivere il prompt.** Copiare `$ ls` o `user@laptop:~$ ls` nel terminale non funziona. Scrivi solo ciò che viene dopo il prompt.
- **Maiuscole ed errori di battitura.** `Notes` non è `notes`. Usa il completamento con Tab per evitare errori.
- **Spazi nei nomi.** `mkdir my notes` crea due cartelle. Usa i trattini (`my-notes`) o le virgolette.
- **Sovrascrivere con `>`.** `echo "new" > file.txt` sostituisce il contenuto precedente. Usa `>>` per aggiungere.
- **Non sapere dove ti trovi.** Molti errori nascono dal trovarsi nella cartella sbagliata. `pwd` è gratis: usalo spesso.

## Considerazioni sulla sicurezza
Il terminale fa esattamente ciò che gli dici, con gli stessi permessi che hai tu. Alcune abitudini lo mantengono sicuro:

- Esegui solo comandi che capisci. Fai attenzione ai comandi copiati da siti web, chat o video: leggili prima e cerca ogni parte che non conosci.
- `rm` non si può annullare. Controlla il percorso prima di premere Invio e non eseguire mai `rm -r` su una cartella che non hai guardato con `ls`.
- Alcuni comandi iniziano con `sudo`, che li esegue con tutti i poteri di amministratore. I laboratori di questo modulo non ne hanno mai bisogno. Se un comando inizia con `sudo` e non capisci perché, fermati e chiedi.
- Un messaggio `Permission denied` è spesso il sistema che protegge file importanti. Non cercare un modo per aggirarlo.

## Riepilogo
- Il terminale è una finestra in cui scrivere istruzioni; la shell le esegue. È preciso, ripetibile e funziona su server senza schermo.
- Una riga di comando è un comando, seguito da opzioni (che cambiano il comportamento) e argomenti (su cosa agire). Il prompt non lo scrivi mai.
- I file vivono in un albero di cartelle. `~` è la tua cartella home, `.` è qui, `..` è un livello sopra. I percorsi sono assoluti (iniziano con `/`) o relativi.
- `pwd`, `ls` e `cd` ti permettono di guardarti intorno; `mkdir`, `touch`, `echo >`, `cat`, `cp`, `mv` e `rm` creano e modificano le cose. `rm` non si può annullare.
- Gli errori sono messaggi da leggere: `command not found`, `No such file or directory` e `Permission denied` indicano ciascuno una causa precisa. `--help` e `man` spiegano qualsiasi comando.

## Glossario
| Termine | Definizione |
|---|---|
| terminale | Una finestra in cui scrivi comandi di testo e leggi risultati in testo. |
| shell | Il programma dentro il terminale che legge i tuoi comandi e li esegue. |
| bash, zsh | Due shell comuni: bash sulla maggior parte dei sistemi Linux, zsh su macOS. |
| prompt | Il testo prima del cursore che mostra che il terminale è pronto. Non lo scrivi. |
| comando | Il nome del programma che chiedi alla shell di eseguire, come `ls`. |
| opzione (flag) | Una parola, di solito con `-` iniziale, che cambia il modo in cui un comando funziona. |
| argomento | Una parola che dice a un comando su cosa agire, come il nome di un file o di una cartella. |
| cartella (directory) | Un contenitore che racchiude file e altre cartelle. |
| cartella radice | La cima dell'albero delle cartelle, scritta `/`. |
| cartella home | La tua cartella personale, scritta `~`. |
| percorso | L'indirizzo di un file o di una cartella, come nomi di cartelle separati da `/`. |
| percorso assoluto | Un percorso che inizia con `/` e funziona da qualsiasi punto. |
| percorso relativo | Un percorso che parte dalla cartella corrente. |
| cartella corrente | La cartella in cui il terminale "si trova"; `pwd` la stampa. |
| reindirizzamento | Inviare l'output di un comando in un file con `>` (sostituire) o `>>` (aggiungere) invece che sullo schermo. |
| cronologia | L'elenco dei comandi scritti in precedenza; la freccia su li richiama. |
| completamento con Tab | Premere Tab per lasciare che la shell completi un nome che hai iniziato a scrivere. |
| pagina di manuale (man page) | Il manuale completo di un comando, aperto con `man <comando>`. |
| WSL | Windows Subsystem for Linux: una funzione di Windows che esegue Linux dentro Windows. |

## Verifica la comprensione
1. Spiega in due frasi perché chi lavora nel cloud preferisce i comandi scritti ai clic.
2. Sei nella tua cartella home e vuoi leggere `/home/user/terminal-practice/notes/todo.txt`. Scrivi un comando con un percorso assoluto e uno con un percorso relativo.
3. Un collega dice: "`rm` ha spostato il mio file nel cestino, posso recuperarlo." Cosa rispondi?

## Riferimenti
- [Install WSL — Microsoft Learn](https://learn.microsoft.com/en-us/windows/wsl/install)
- [The Linux command line for beginners — Ubuntu tutorial](https://ubuntu.com/tutorials/command-line-for-beginners)
- [Terminal User Guide — Apple Support](https://support.apple.com/guide/terminal/welcome/mac)
- [GNU Coreutils manual](https://www.gnu.org/software/coreutils/manual/coreutils.html)
