## Cosa imparerai in questo corso

In questo corso di circa 1 ora (1 ora e due minuti per la precisione) imparerai le basi per utilizzare il terminale su sistemi Unix. Ho voluto includere anche la parte relativa a Windows, perché anche sul sistema operativo di Microsoft ci sono Prompt dei Comandi e Powershell che permettono di fare tante belle cose se si sanno usare, soprattutto Powershell.

Il corso è girato su Windows e per eseguire i comandi Unix mi avvalgo di WSL (Windows Subsystem for Linux) con immagine Ubuntu. Per maggiori informazioni su come abilitare WSL sul tuo sistema operativo Microsoft [segui la guida ufficiale](https://learn.microsoft.com/it-it/windows/wsl/install).

Hai completato il corso? Se hai 2 minuti vorrei sapere la tua opinione per poter migliorare la qualità in futuro. Il feedback è anonimo e per inviarmelo puoi compilare questo [modulo Google](https://forms.gle/Xf8zKkhKPLkkdStx6). Grazie!

Manuel Ricci

316135391_10228434730003413_3440617797997573835_n.webp

In questa raccolta trovi i corsi base di informatica che possono aiutarti a comprendere meglio il tuo computer e gli strumenti che hai a disposizione.

Non trovi il corso che fa al caso tuo? Ti andrebbe di dirmi qual è? Così mi aiuterai ad alimentare il catalogo corsi e otterrai il corso che desideri. Per suggerirmi un corso puoi [compilare il modulo google che trovi qui](https://forms.gle/SLdYyE4B4JUiEcjU7).

Informatica di base

Impariamo uno dei comandi di base per poter osservare cosa c'è dentro una directory con le sue varie opzioni.

Attorno al terminale aleggia sempre una certo non so che di mistero. Si tratta di uno strumento molto potente, il quale permette di fare praticamente tutto all’interno del proprio sistema.

Di seguito riporterò i comandi di base per poter iniziare ad usare un terminale Unix, come quello presente sulle distribuzioni Linux e MacOs, e il relativo equivalente, se presente, da usare in Windows, il quale differisce nella maggior parte delle volte.

**Indice dei contenuti**

- [Navigazione](#navigazione)
- [Creazione](#creazione)
- [Copia](#copia "#copia")
- [Spostamento](#spostamento "#spostamento")
- [Rimozione](#Rimozione)
- [Referenze](#referenze "#referenze")
- [Pulizia](#pulizia "#pulizia")

## Navigazione

Forse il comando più utilizzato è sicuramente `ls`, il suo scopo è quello di elencare i file e le sotto directory presenti in una directory.

```batch
ls
```

Se sprovvisto di opzioni, `ls` mostrerà il contenuto della directory corrente.

Di base, quando si apre il terminale ci si trova nella directory Home dell’utente che sta usando il terminale, la quale viene contraddistinta dal carattere tilde (`~`).

```batch
ls nome-directory
```

Se `ls` viene fatto seguire dal nome di una directory è possibile vederne il contenuto.

Oltre ai percorsi relativi è possibile scrivere anche quelli assoluti, ottenendo lo stesso medesimo risultato.

```batch
ls nome-directory/\*.jpg
```

Mettiamo il caso che stai cercando un file, ma ti ricordi il formato del file, ma non il nome. Per poter filtrare i risultati di `ls` basterà usare il carattere jolly asterisco (`*`) seguito dall’estensione.

```batch
ls -R
```

Occhio ad usare questa opzione perché se si ti trovi in una cartella particolarmente affollata potrebbe mostrare a video parecchie informazioni (in quel caso se vuoi interrompere il processo di scansione puoi usare la combinazione di tasti `command + c` o `ctrl + c`).

L’opzione `-R` di fatto permette di mostrare in maniera ricorsiva i contenuti della varie sottodirectory della directory specificata (quella corrente se non ne specifichi nessuna).

Questo evita di dover riscrivere il comando `ls` per ogni sotto directory.

```batch
ls -l
```

L’opzione `-l` permette di mostrare le varie voci in colonna con tutte le varie informazioni relative ai permessi (lettura, scrittura ed esecuzione).

```batch
ls -m
```

Se sei un amante degli elenchi separati da virgole, allora l’opzione `-m` fa per te.

```batch
ls -a
```

Stai cercando la cartella di git, ma non la trovi? Normale, si tratta di una directory nascosta e `ls` non la mostra, per ovviare al problema basta usare l’opzione `-a`.

```batch
ls -r
```

Da non confondere con `-R` (che sta per ricorsivo), `-r` o nella sua versione estesa `--reverse` permette di mostrare i file e le directory nell’ordine inverso rispetto a quello principale.

```batch
ls -X
```

L’opzione `-X` permette di ordinare i file e le directory per estensione.

```batch
ls -t
```

L’opzione `-t` ordina i file per data e ora.

```batch
ls -S
```

L’opzione `-S` ordina i contenuti per dimensione.

```batch
ls -h # Senza l'opzione -l non mostra nulla di speciale
ls -lh # Così va meglio
```

L’opzione `-h` mostra le dimensioni dei file in Kilobyte, Megabyte e Gigabyte.

L’equivalente di `ls` in Windows è `dir`.

```batch
pwd
```

Con `ls` archiviato possiamo andare avanti. Il comando qui sopra è `pwd` abbreviazione di print working directory.

Mentre si naviga da terminale può capitare di perdere l’orientamento, `pwd` corre in nostro soccorso mostrando il percorso corrente.

L’equivalente di `pwd` in Windows è `cd`.

```batch
cd
```

Il comando `cd`, da solo, sui sistemi Unix fa tornare alla directory home, mentre su Windows è l’equivalente di `pwd`.

In generale cd permette di cambiare directory.

```batch
cd ~
```

Facendo seguire cd da una tilde (~), rendiamo esplicito il voler ritornare nella nostra directory Home.

```batch
cd -
```

Il meno ti porta alla directory precedente.

```batch
cd directory/sotto-directory
```

Facendo seguire un percorso a `cd`, cambieremo directory, raggiungendo quella desiderata.

Non c’è differenza tra Unix e Windows, `cd` è equivalente.

## Creazione

```batch
touch
```

Lo scopo principale del comando `touch` è quello di modificare l’accesso e l’ora di modifica di un file, ma in realtà è il suo scopo secondario a risultare super utile. `touch` infatti viene largamente impiegato per la creazione di file vuoti.

```batch
touch test.txt
```

Facendo seguire touch dal nome di un file e relativa estensione, verrà creato suddetto file nella directory corrente.

Se invece vuoi anche scrivere qualcosa destro il file da creare puoi usare questo comando:

```batch
echo "Hello, World!" > test.txt
```

`echo` da solo si limita a mostrare quanto richiesto, in questo caso la stringa `"Hello, World!"`, ma facendolo seguire da `> test.txt` rendiamo esplicito il fatto che tale risultato debba essere inserito all’interno di un file, il quale se non esiste verrà creato automaticamente.

Per modifiche più complesse puoi sempre usare `nano`.

```batch
nano test.txt
```

Sono consapevole del fatto che nano non piaccia a tutti, ma è un buon punto di partenza per iniziare.

L’equivalente di touch in Windows è abbastanza particolare: `type nul > testo.txt`

Mentre se si vuole creare un file con del contenuto si usa lo stesso comando di Unix `echo`.

```batch
cat <nome-file>
```

Lo scopo principale di `cat` è quello di concatenare, ma può anche essere usato per mostrare il contenuto di un file se fatto seguire dal nome del file interessato.

Per vedere solo una prima parte del contenuto puoi usare il comando `tail`.

```batch
cat <nome-file-1> <nome-file-2>
```

Mettendo uno o più file separati da uno spazio, `cat` mostrerà la concatenazione che ne risulterà.

```batch
cat <nome-file-1> <nome-file-2> > <nome-file-risultato>
```

Se vogliamo salvare il risultato della concatenazione basta far seguire alla lista di file da concatenare `> <nome-file-risultato>` come già visto con `echo`.

L’equivalente di cat in Windows è `type`, per il resto la sintassi è identica.

```batch
mkdir <nome-cartella>
```

Il comando permette di creare una cartella.

```batch
mkdir -p immagini/animali/cani
```

Mentre con `mkdir` senza opzioni è possibile creare una cartella, con l’opzione `-p` è possibile creare anche le sottocartelle.

```batch
mkdir -v <nome-cartella> # oppure
mkdir --verbose <nome-cartella>
```

Come gli esempi visti in precedenza `-v` è l’opzione che attiva la modalità verbosa mostrando i passaggi compiuti da `mkdir`.

`mkdir` è valido anche per Windows.

## Copia

```batch
cp
```

`cp` è il comando che permette all’utente di copiare un file.

```batch
cp <nome-file>.<estensione> <nome-file-copia>.<estensione>
```

Da solo, ovviamente, non ha alcun effetto. Per copiare un file bisogna far seguire il nome del file da copiare e il nome della copia.

Nel caso ci fosse un conflitto, il terminale vi avviserà.

```batch
cp tes\* test.txt
```

Il carattere jolly (`*`) è ideato per i più pigri i quali non vogliono scrivere tutto il nome del file da copiare.

Se il file deve essere copiato in una directory basta specificare il percorso al posto del solo nome.

```batch
cp -v
```

Come già visto in precedenza anche `cp`, ha la sua modalità verbose.

```batch
cp -R
```

Di default, `cp` emetterà un’errore qualora si provasse a copiare una cartella non vuota, per ovviare al problema basta usare l’opzione `-R`.

```batch
cp -a
```

Per quanto ci siano comandi più avanzati per effettuare copie di backup, `cp` rimane comunque l’alternativa più semplice. Grazie all’opzione `-a` verrà creato una copia evitando di copiare eventuali collegamenti simbolici che potrebbero appesantire il processo di copiatura.

In Windows l’equivalente di `cp` è `copy`, mentre per la copia ricorsiva (quella con l’opzione `-R`) l’equivalente è `xcopy`.

## Spostamento

```batch
mv
```

`mv` è un comando particolare, di fatto permette di spostare i file all’interno del sistema, ma ha anche una seconda finalità, la rinominazione.

```batch
mv <nome-file> <directory>
```

Sposta un file in una directory.

```batch
mv <nome-file> <nuovo-nome-file>
```

Se al posto di un percorso specifichiamo un nuovo nome di file, `mv` rinominerà il suddetto file.

L’equivalente Windows di `mv` è `move`.

## Rimozione

```batch
rm
```

`rm`, il quale sta per remove, permette appunto di rimuovere file e cartelle.

```batch
rm \*
```

Con l’ausilio del carattere jolly `rm` eliminerà tutti i file (non le directory).

```batch
rm -v
```

Come già visto in precedenza, anche `rm` ha la sua opzione verbose, la quale mostrerà l’avanzamento della rimozione.

```batch
rm -i
```

`rm` ha anche una modalità interattiva, la quale mostrerà per ogni file un prompt, dove sarà necessario dare una conferma per procedere con la cancellazione. Il prompt accetta `y` per yes e `n` per no.

```batch
rmdir
```

Per rimuovere una cartella vuota **non si usa `rm -R`**, ma `rmdir`. Attenzione! Se la cartella contiene dei file il comando fallirà, avvisandoci che la cartella non è vuota.

```batch
rm -Rf
```

Per rimuovere le cartelle e i relativi file e sotto directory bisogna usare il comando `rm` seguito dalle opzioni `-R` e `-f`.

L’equivalente di `rm` in Windows è `del`, mentre nel caso di rimozione di cartelle e file e sotto directory contenuti in esse l’equivalente è `deltree`. Per la rimozione di cartelle vuote non c’è differenza.

## Referenze

```batch
man <comando>
```

Il comando `man` mostra il manuale di un comando specifico.

```batch
man ls
```

Mostrerà tutto ciò che c’è da sapere sul comando `ls`.

```batch
man -k list
```

Se non si è sicuri di quale comando utilizzare per eseguire una determinata task, l’opzione `-k` seguito dalla funzionalità cercherà tutti i comandi che mostrano una lista.

```batch
man -f ls # Oppure
whatis ls
```

A differenza di `man` che mostra un vero e proprio manuale, `man -f` o `whatis` mostrano una riga di descrizione abbastanza intuitiva che fa intendere la funzione del comando.

L’equivalente di `man` in Windows è `help`.

```batch
info
```

Il comando `info` è praticamente `man` sotto steroidi. Le pagine man presentavano diversi problemi, per ovviare al problema, il progetto GNU ha creato un formato apposito: le pagine info. Tali pagine sono scritte meglio rispetto a quelle di man e sono decisamente più accessibili per la consultazione.

```batch
info ls
```

Mostrerà la pagina info del comando `ls`.

Non esiste corrispondenza in Windows per il comando `info`.

## Pulizia

```batch
clear
```

Può capitare di fare un po’ di casino. Per poter ripulire il terminale dalle righe scritte e mostrate finora si può usare il comando `clear`.

Vuoi utilizzare iil terminale, ma non sai da dove iniziare? In questo articolo ti mostro i coomandi di base validi sia per sistemi Unix che per Windows.

Comandi base per usare il terminale Unix

Non avendo un riferimento specifico del dove ci troviamo, a volte si tende a perdersi e per ritrovarsi basta usare pwd.

Tutto molto bello, ma dobbiamo anche spostarci nel sistema. Come? Con il comando che vediamo in questa lezione.

Creiamo i nostri file e modifichiamoli direttamente da terminale.

Vogliamo vedere il contenuto di un file o più file, cat fa al caso nostro.

I nostri file mica possono stare tutti in giro, impariamo ad organizzarli in cartelle, creando innanzitutto le cartelle.

Copia i file in giro per il nostro sistema con il comando cp.

Spostiamo i file dentro e fuori le cartelle con l'apposito comando.

Rimuoviamo quello che abbiamo creato in questo corso direttamente da terminale.

Il manuale sempre sotto MANo. L'hai capita? No? Guarda la lezione e capirai.

Terrminaimo con il comando che forse useremo più di frequente se siamo maniaci del pulito.

Imparare ad usare il terminale Unix (con alternativa Windows)

Cosa imparerai in questo corso

Lezioni

Cosa imparerai in questo corso

Lezioni

Ritrovare la bussola con pwd

Navigare nel sistema con cd

Creare e modificare file da terminale

Concatenare dei file con cat

Creare directory

Copiare i file

Spostare i file

Rimuovere file e cartelle

Dove trovare la documentazione direttamente nel terminale

Pulire il terminale