3.2 Lezione 1

Certificazione:

Linux Essentials

Versione:

1.6

Argomento:

3 Il Potere della Command Line

Obiettivo:

3.2 Ricerca ed Estrazione di Dati dai File

Lezione:

1 di 2

Introduzione

In questa lezione ci concentreremo su come redirigere o trasmettere informazioni da una sorgente all’altra con l’aiuto di specifici strumenti. La Command Line di Linux redirige le informazioni tramite specifici canali standard. La tastiera è considerata lo standard input (stdin o canale 0) di un comando e lo schermo è considerato lo standard output (stdout o canale 1). Esiste anche un altro canale che ha lo scopo di redirigere l’output di errore (stderr o canale 2) di un comando o i messaggi di errore di un programma. L’input e/o l’output possono essere rediretti.

Quando si esegue un comando, a volte si desidera passare determinate informazioni al comando stesso o redirigere l’output verso uno specifico file. Ciascuna di queste funzionalità verrà discussa in queste due lezioni.

Redirezione di I/O

La redirezione di I/O consente all’utente di redirigere le informazioni da o verso un comando utilizzando un file di testo. Come descritto in precedenza, lo standard input, lo standard output e lo standard error possono essere rediretti e le informazioni possono essere prese da file di testo.

Redirigere lo Standard Output

Per redirigere lo standard output su un file, invece che sullo schermo, dobbiamo utilizzare l’operatore > seguito dal nome del file. Se il file non esiste, ne verrà creato uno nuovo, altrimenti il file esistente verrà sovrascritto.

Per vedere il contenuto del file appena creato, possiamo utilizzare il comando cat. Per impostazione predefinita, questo comando visualizza il contenuto di un file sullo schermo. Consulta la pagina di manuale per saperne di più sulle sue funzionalità.

L’esempio seguente mostra come funziona l’operatore. Nel primo caso viene creato un nuovo file contenente il testo “Hello World!”:

$ echo "Hello World!" > text
$ cat text
Hello World!

Nel secondo caso, lo stesso file viene sovrascritto con il nuovo testo:

$ echo "Hello!" > text
$ cat text
Hello!

Se vogliamo aggiungere nuove informazioni alla fine del file, dobbiamo utilizzare l’operatore >>. Questo operatore crea anche un nuovo file se non riesce a trovarne uno esistente.

Il primo esempio mostra l’aggiunta di nuovo testo. Come si può vedere, il nuovo testo è stato aggiunto nella riga successiva:

$ echo "Hello to you too!" >> text
$ cat text
Hello!
Hello to you too!

Il secondo esempio mostra la creazione di un nuovo file:

$ echo "Hello to you too!" >> text2
$ cat text2
Hello to you too!

Redirigere lo Standard Error

Per redirigere soltanto i messaggi di errore, un utente dovrà utilizzare l’operatore 2> seguito dal nome del file in cui verranno scritti gli errori. Se il file non esiste, ne verrà creato uno nuovo, altrimenti il file verrà sovrascritto.

Come già spiegato, il canale per redirigere lo standard error è il canale 2. Quando si redirige lo standard error, il canale deve essere specificato, contrariamente a quanto accade per lo standard output poichè il canale 1 è impostato di default. Per esempio, il seguente comando cerca un file o una directory chiamata games e scrive soltanto l’errore nel file text-error, visualizzando lo standard output sullo schermo:

$ find /usr games 2> text-error
/usr
/usr/share
/usr/share/misc
---------Omitted output----------
/usr/lib/libmagic.so.1.0.0
/usr/lib/libdns.so.81
/usr/games
$ cat text-error
find: `games': No such file or directory

Note	Per maggiori informazioni sul comando `find`, consulta la sua pagina man.

Per esempio, il seguente comando viene eseguito senza errori e, pertanto, non verrà scritta alcuna informazione nel file text-error:

$ sort /etc/passwd 2> text-error
$ cat text-error

Come lo standard output, anche lo standard error può essere aggiunto a un file tramite l’operatore 2>>, che aggiunge il nuovo errore alla fine del file. Se il file non esiste, ne verrà creato uno nuovo. Il primo esempio mostra l’aggiunta di nuove informazioni al file, mentre il secondo esempio mostra come il comando crei un nuovo file nel caso in cui non sia possibile trovarne uno esistente con lo stesso nome:

$ sort /etc 2>> text-error
$ cat text-error
sort: read failed: /etc: Is a directory

$ sort /etc/shadow 2>> text-error2
$ cat text-error2
sort: open failed: /etc/shadow: Permission denied

Con questo tipo di redirezione, soltanto i messaggi di errore verranno rediretti verso il file; l’output normale verrà scritto sullo schermo o passerà attraverso lo standard output o stdout.

Esiste un file particolare che tecnicamente è un cestino per dati, in inglese bit bucket, (un file che accetta dell’input, ma non fa nulla con esso): /dev/null. Puoi redirigere verso di esso tutte le informazioni non importanti che potresti non voler visualizzare o non voler redirigere verso un file importante. Un esempio è mostrato qui sotto:

$ sort /etc 2> /dev/null

Redirigere lo Standard Input

Questa tipologia di redirezione viene utilizzata per inviare dati in input a un comando da un file specificato anziché da tastiera. In questo caso viene utilizzato l’operatore <, come mostrato nell’esempio seguente:

$ cat < text
Hello!
Hello to you too!

La redirezione dello standard input viene solitamente utilizzata con i comandi che non accettano argomenti. Il comando tr è uno di questi. Questo comando può essere utilizzato per trasformare il contenuto di un file modificando i caratteri presenti in esso in un certo modo, per esempio eliminando un carattere specifico dal file. L’esempio seguente mostra come eliminare il carattere l:

$ tr -d "l" < text
Heo!
Heo to you too!

Per maggiori informazioni, consulta la pagina man di tr.

Here Document

A differenza della redirezione dell’output, l’operatore << si comporta in modo diverso rispetto agli altri operatori. Questo flusso in ingresso è anche chiamato here document, che rappresenta il blocco di codice o di testo che può essere rediretto verso il comando o verso il programma interattivo. Diversi tipi di linguaggi di scripting, come bash, sh e csh sono in grado di ricevere dell’input direttamente dalla Command Line, senza utilizzare alcun file di testo.

Come si può vedere nell’esempio sotto riportato, l’operatore viene utilizzato per inviare dei dati al comando, mentre la parola che segue non specifica il nome del file. La parola viene interpretata come un delimitatore dell’input e non viene presa in considerazione come contenuto; quindi non verrà visualizzata da cat:

$ cat << hello
> hey
> ola
> hello
hey
ola

Consulta la pagina man del comando cat per avere maggiori informazioni.

Combinazioni

La prima combinazione di cui ci occuperemo combina la redirezione dello standard output e dello standard error verso lo stesso file. Vengono utilizzati gli operatori &> e &>>: & rappresenta la combinazione del canale 1 e del canale 2. Il primo operatore sovrascrive il contenuto esistente del file, mentre il secondo accoda o aggiunge le nuove informazioni alla fine del file. Entrambi gli operatori consentono la creazione di un nuovo file nel caso in cui questo non esista, proprio come nelle sezioni precedenti:

$ find /usr admin &> newfile
$ cat newfile
/usr
/usr/share
/usr/share/misc
---------Omitted output----------
/usr/lib/libmagic.so.1.0.0
/usr/lib/libdns.so.81
/usr/games
find: `admin': No such file or directory
$ find /etc/calendar &>> newfile
$ cat newfile
/usr
/usr/share
/usr/share/misc
---------Omitted output----------
/usr/lib/libmagic.so.1.0.0
/usr/lib/libdns.so.81
/usr/games
find: `admin': No such file or directory
/etc/calendar
/etc/calendar/default

Vediamo un esempio che utilizza il comando cut:

$ cut -f 3 -d "/" newfile
$ cat newfile

share
share
share
---------Omitted output----------
lib
games
find: `admin': No such file or directory
calendar
calendar
find: `admin': No such file or directory

Il comando cut, con l’opzione -f, taglia i campi specificati dal file in ingresso, nel nostro caso il terzo campo. Affinché il comando trovi il campo, è necessario specificare anche un delimitatore con l’opzione -d. Nel nostro caso il delimitatore è il carattere /.

Per saperne di più sul comando cut, consulta la sua pagina man.

Pipe

La redirezione viene principalmente utilizzata per memorizzare il risultato di un comando che deve essere elaborato da un comando diverso. Questo tipo di processo intermedio può diventare molto noioso e complicato se si desidera che i dati passino attraverso più processi. Per evitare questo, puoi collegare i comandi direttamente tramite le pipe. In altre parole, l’output del primo comando diventa automaticamente l’input del secondo comando. Questa connessione viene fatta utilizzando l’operatore | (barra verticale):

$ cat /etc/passwd | less
root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/bin/sh
bin:x:2:2:bin:/bin:/bin/sh
:

Nell’esempio sopra riportato il comando less, che si trova dopo l’operatore pipe, modifica il modo in cui il file viene visualizzato. Il comando less mostra il file di testo consentendo all’utente di scorrere su e giù di una riga per volta. less è anche usato di default per visualizzare le pagine man, come discusso nelle lezioni precedenti.

È possibile utilizzare più pipe contemporaneamente. I comandi intermedi che ricevono un input e che poi lo elaborano e producono un output sono chiamati filtri. Prendiamo il comando ls -l e proviamo a contare il numero di parole delle prime 10 righe in output. Per fare ciò, dovremo utilizzare il comando head che, per impostazione predefinita, mostra le prime 10 righe di un file e poi dovremo contare le parole usando il comando wc:

$ ls -l | head | wc -w
10

Come accennato in precedenza, per impostazione predefinita, head mostra solo le prime 10 righe del file di testo specificato. Questo comportamento può essere modificato utilizzando specifiche opzioni. Controlla la pagina man del comando per avere ulteriori informazioni.

Esiste un altro comando che visualizza la parte finale di un file: tail. Per impostazione predefinita, questo comando seleziona le ultime 10 righe e le visualizza, ma, come per head, tale numero può anche essere modificato. Controlla la pagina man di tail per maggiori dettagli.

Note	L’opzione `-f` mostra le ultime righe di un file mentre viene aggiornato. Questa caratteristica può diventare molto utile quando si monitora un file come `syslog` durante lo svolgimento di una attività.

Il comando wc (acronimo di word count) conta, per impostazione predefinita, le righe, le parole e i byte di un file. Come mostrato nell’esempio sopra riportato l’opzione -w fa sì che il comando conti solamente le parole all’interno delle righe selezionate. Le opzioni più comuni di questo comando sono: -l, che indica al comando di contare solo le righe; -c, che viene utilizzato per contare solo i byte. Nella pagina man di questo comando puoi trovare ulteriori varianti e opzioni e maggiori informazioni su wc.

Esercizi Guidati

Elenca il contenuto della tua directory corrente, mostrando anche ownership e permessi, e redirigi l’output su un file chiamato contents.txt all’interno della tua directory home.
Ordina il contenuto del file contents.txt dalla directory corrente e aggiungilo alla fine di un nuovo file chiamato contents-sorted.txt.
Mostra le ultime 10 righe del file /etc/passwd e redirigile su un nuovo file nella directory Documents del tuo utente.
Conta il numero di parole all’interno del file contents.txt e aggiungi l’output alla fine del file field2.txt nella tua directory home. Dovrai utilizzare sia la redirezione dell’input che dell’output.
Mostra le prime 5 righe del file /etc/passwd e ordina l’output in ordine alfabetico inverso.
Utilizzando il file contents.txt creato in precedenza, conta il numero di caratteri delle ultime 9 righe.
Conta il numero di file con nome test all’interno della directory /usr/share e delle sue sottodirectory. Nota: ogni riga di output del comando find rappresenta un file.

Esercizi Esplorativi

Seleziona il secondo campo del file contents.txt e redirigi lo standard output e lo standard error su un altro file chiamato field1.txt.
Utilizzando l’operatore di redirezione dell’input e il comando tr, elimina i trattini (-) dal file contents.txt.
Qual è il più grande vantaggio che si ha nel redirigere solo gli errori su un file?
Sostituisci con un singolo spazio tutti gli spazi ripetuti all’interno del file contents.txt ordinato alfabeticamente.
Da Command Line, elimina gli spazi ripetuti (come fatto nell’esercizio precedente), seleziona il nono campo e ordina in base a esso in ordine alfabetico inverso senza fare distinzione tra maiuscole e minuscole. Quante pipe hai dovuto usare?

Sommario

In questa lezione hai imparato:

I tipi di redirezione;
Come utilizzare gli operatori di redirezione;
Come utilizzare le pipe per filtrare l’output dei comandi.

Comandi utilizzati in questa lezione:

cut: Rimuove sezioni da ogni riga di un file.
cat: Visualizza o concatena file.
find: Cerca i file in una gerarchia di directory.
less: Visualizza un file, consentendo all’utente di scorrere una riga alla volta.
more: Visualizza un file, una pagina alla volta.
head: Visualizza le prime 10 righe di un file.
tail: Visualizza le ultime 10 righe di un file.
sort: Ordina i file.
wc: Conta, per impostazione predefinita, le righe, le parole e i byte di un file.

Risposte agli Esercizi Guidati

Elenca il contenuto della tua directory corrente, mostrando anche ownership e permessi, e redirigi l’output su un file chiamato contents.txt all’interno della tua directory home.
```
$ ls -l > contents.txt
```
Ordina il contenuto del file contents.txt dalla directory corrente e aggiungilo alla fine di un nuovo file chiamato contents-sorted.txt.
```
$ sort contents.txt >> contents-sorted.txt
```
Mostra le ultime 10 righe del file /etc/passwd e redirigile su un nuovo file nella directory Documents del tuo utente.
```
$ tail /etc/passwd > Documents/newfile
```
Conta il numero di parole all’interno del file contents.txt e aggiungi l’output alla fine del file field2.txt nella tua directory home. Dovrai utilizzare sia la redirezione dell’input che dell’output.
```
$ wc < contents.txt >> field2.txt
```
Mostra le prime 5 righe del file /etc/passwd e ordina l’output in ordine alfabetico inverso.
```
$ head -n 5 /etc/passwd | sort -r
```
Utilizzando il file contents.txt creato in precedenza, conta il numero di caratteri delle ultime 9 righe.
```
$ tail -n 9 contents.txt | wc -c
531
```
Conta il numero di file con nome test all’interno della directory /usr/share e delle sue sottodirectory. Nota: ogni riga di output del comando find rappresenta un file.
```
$ find /usr/share -name test | wc -l
125
```

Risposte agli Esercizi Esplorativi

Seleziona il secondo campo del file contents.txt e redirigi lo standard output e lo standard error su un altro file chiamato field1.txt.
```
$ cut -f 2 -d " " contents.txt &> field1.txt
```
Utilizzando l’operatore di redirezione dell’input e il comando tr, elimina i trattini (-) dal file contents.txt.
```
$ tr -d "-" < contents.txt
```
Qual è il più grande vantaggio che si ha nel redirigere solo gli errori su un file?

Redirigere solamente gli errori su un file può aiutare a mantenere un file di log che viene monitorato di frequente.
Sostituisci con un singolo spazio tutti gli spazi ripetuti all’interno del file contents.txt ordinato alfabeticamente.
```
$ sort contents.txt | tr -s " "
```
Da Command Line, elimina gli spazi ripetuti (come fatto nell’esercizio precedente), seleziona il nono campo e ordina in base a esso in ordine alfabetico inverso senza fare distinzione tra maiuscole e minuscole. Quante pipe hai dovuto usare?
```
$ cat contents.txt | tr -s " " | cut -f 9 -d " " | sort -fr
```
L’esercizio utilizza 3 pipe, una per ogni filtro.