I comandi e le utility di Linux: leggere i file

head

Il comando head legge le prime 10 righe di un file:

	head test.htm

E' possibile specificare un differente numero di righe da leggere:

	head -n numero file
	head -numero file

	head -n 20 test.htm
	head -20 test.htm

E' possibile specificare più di un file: in questo caso, le righe del file sono precedute dal nome del file.

	head -20 test.htm prova.txt

E' possibile anche specificare i byte da stampare:

	head -c nMoltiplicatore prova.txt
	head --bytes nMoltiplicatore prova.txt

dove n è un numero e Moltiplicatore è un suffisso, che indica:

	b 512
		head -c 2b prova.txt
	kB 1000
		head -c 1kB prova.txt
	K 1024
		head -c 1K prova.txt
	MB 1000*1000
	M 1024*1024
	GB 1000*1000*1000
	G 1024*1024*1024

Se il numero ( n ) è preceduto da un trattino, viene stampato tutto il file, eccetto gli ultimi nMoltiplicatore byte:

	head -c -2b prova.txt

o le ultime n righe:

	head -n -5 prova.txt

grep

Il comando grep ( Global Regular-Expression Print ) cerca un testo all'interno di un file:

	grep [options] pattern [files]

dove pattern è una stringa di testo o una espressione regolare ( default ). Per essere certi che pattern sia trattato come stringa testuale, usate l'opzione -F:

	grep -F '192.168.1.1' *
	grep --fixed-strings '192.168.1.1' *

In questo esempio, stiamo cercando la stringa testuale '192.168.1.1', all'interno di tutti i file ( * ) della directory corrente. Attenzione: spesso, l'output di grep è molto corposo. In questi casi, inviate l'output di grep al comando less. Per esempio:

	grep Package: available | less

cerca la stringa di testo "Package:", all'interno del file available, mentre less elenca i risultati, sfogliando una pagina alla volta. Il comando grep può effettuare la ricerca anche all'interno di più file. Per esempio:

	grep Package: available status

cerca la stringa di testo "Package:", all'interno dei file available e status. In questo modo, è possibile cercare una stringa di testo, o un pattern, all'interno dell'intero filesystem. Per esempio:

	grep 'Package: jfsutils' *

cerca la stringa di testo 'Package: jfsutils' in tutti i file della directory corrente, mentre:

	grep -r 'Package: jfsutils' *
	grep -R 'Package: jfsutils' *
	grep --recursive 'Package: jfsutils' *

cerca la stringa di testo 'Package: jfsutils' in tutti i file della directory corrente e in tutte le sottodirectory ( -r, o -R, o --recursive ). E' possibile essere anche più selettivi. Per escludere uno o più file, per esempio, utilizzare l'opzione:

	grep --exclude=lock "Package: jfsutils" *
	grep --exclude=*-old "Package: jfsutils" *

Nel primo caso, stiamo chiedendo a grep di escludere il file lock, mentre nel secondo caso stiamo chiedendo a grep di escludere tutti i file contenenti la sequenza -old. L'opzione --exclude accetta i metacaratteri di shell: *. ? e []. Per escludere un'intera directory, nel caso di una ricerca ricorsiva:

	grep -r --exclude-dir=triggers "Package: jfsutils" *

dove stiamo escludendo l'intera sottodirectory triggers. E' possibile chiedere a grep di escludere dalla ricerca i file binari ( non testuali ):

	grep -r --binary-files=without-match "Package: jfsutils" *

Il comando grep restituisce la riga o le righe del file che contengono la stringa di testo ricercata ( pattern ). Per esempio:

	grep 'Package: jfsutils' available

cerca la stringa di testo 'Package: jfsutils' all'interno del file available e restituisce la riga:

Package: jfsutils

Nel caso il comando grep dovesse cercare in più di un file, l'output comprenderebbe, per ogni riga, il nome del file che la contiene:

	grep 'Package: jfsutils' *

available:Package: jfsutils
available-old:Package: jfsutils

dove leggiamo che grep ha trovato la stringa cercata nei file: available e available-old. E' possibile farsi restituire anche qualche riga dopo e qualche riga prima del file, specificando le opzioni -A ( after ) e -B ( before ). Per esempio:

	grep -B4 -A4 'Package: jfsutils' available

restituisce:

 you in complete control of your editing.
Original-Maintainer: Loic Minier <lool@dooz.org>
Python-Version: current

Package: jfsutils
Priority: optional
Section: admin
Installed-Size: 1128
Maintainer: Ubuntu Developers <ubuntu-devel-discuss@lists.ubuntu.com>

Se -A e -B sono uguali, come nel nostro esempio, lo stesso risultato può essere ottenuto con l'opzione -C:

	grep -C 4 "Package: jfsutils" available
	grep -4 "Package: jfsutils" available
	grep --context 4 "Package: jfsutils" available

E' possibile, anche, chiedere a grep di restituirci, oltre alla riga o alle righe del file, anche il numero di ciascuna riga ( dove la prima riga del file è la riga 1 ):

	grep -n 'Package: jfsutils' available
	grep --line-number 'Package: jfsutils' available
416:Package: jfsutils

	grep -n 'Package: jfsutils' available status
available:416:Package: jfsutils

	grep -n -A4 -B4 'Package: jfsutils' available
412- you in complete control of your editing.
413-Original-Maintainer: Loic Minier <lool@dooz.org>
414-Python-Version: current
415-
416:Package: jfsutils
417-Priority: optional
418-Section: admin
419-Installed-Size: 1128
420-Maintainer: Ubuntu Developers <ubuntu-devel-discuss@lists.ubuntu.com>

E' possibile, anche, chiedere a grep di restituirci, al posto del numero di ciascuna riga, il byte di offset di ciascun riscontro, calcolato a partire dal byte zero ( inizio del file ):

	grep -b "Package: jfsutils" available
	grep --byte-offset "Package: jfsutils" available

17769:Package: jfsutils

Se si desidera ricevere, come output, solo la stringa di testo cercata, e non l'intera linea del file, utilizzare l'opzione -o ( --only-matching ):

	grep -o "Package:" available
	grep --only-matching "Package:" available

E' possibile, anche, chiedere a grep di restituirci solo il numero delle occorrenze riscontrate, senza riportare alcuna riga del file:

	grep -c 'Package: jfsutils' available
	grep --count 'Package: jfsutils' available

Se l'opzione -c ( --count ) viene applicata ad una ricerca su più file, grep restituirà una riga per file, con il nome del file ed il numero delle occorrenze riscontrate:

	grep -c 'Package: jfsutils' available status
	grep --count 'Package: jfsutils' available status

available:1
status:0

Quando si effettua una ricerca su più file, è possibile chiedere a grep di restituire solo il nome o i nomi del file o dei file che contengono la stringa di testo:

	grep -l "Package: libio" *
	grep --files-with-matches "Package: libio" *

available
available-old
status
status-old

Quando si effettua una ricerca su più file, è possibile chiedere a grep di restituire solo il nome o i nomi del file o dei file che non contengono la stringa di testo:

	grep -L "Package: libio" *
	grep --files-without-match "Package: libio" *

Se si desidera limitare il numero di righe restituite da grep, utilizzare l'opzione m ( --max-count ):

	grep -m 10 "Package:" available
	grep --max-count 10 "Package:" available

Il comando grep, nelle sue ricerche, è case-sensitive ( considera "Package:" diverso da "package:" ). Per renderlo case-insensitive, aggiungere l'opzione il comando -i:

	grep -i package: available
	grep --ignore-case package: available

Se si desidera invertire la ricerca, cioè trovare tutte le righe che non contengano la stringa testuale, utilizzare l'opzione -v:

	grep -v package: available
	grep --invert-match package: available

Questi due comandi cercano tutte le righe del file available, che non contengano la stringa di testo "Package:". Invece di cercare una stringa testuale, è possibile chiedere a grep di cercare un pattern, all'interno del file o dei file indicati. Un pattern indica l'esistenza delle espressioni regolari. Quindi, con grep, è possibile utilizzare:

i quantificatori:

?	zero o una occorrenza
*	da zero a molte occorrenze
+	da una a molte occorrenze
{n}	solo "n" occorrenze
{n,}	almeno "n" occorrenze
{n,m}	da "n" a "m" occorrenze

le classi di caratteri:

[...]	classe di caratteri
-	range: a-zA-Z0-9
\w	un carattere alfanumerico
\d	una cifra
\s	uno spazio
.	un carattere qualsiasi
\W	un carattere non alfanumerico
\D	un carattere non cifra
\S	un carattere non spazio

le àncore:

^	inizio stringa
$	fine stringa
\b	limite di parola

altri metacaratteri:

|	OR
(...)	subpattern ( sottostringhe )

Occorre fare attenzione, però, a quale motore delle espressioni regolari si utilizza, poichè, a seconda del motore utilizzato, alcuni metacaratteri potrebbero non essere riconosciuti. I metacaratteri sopra menzionati, per esempio, sono i metacaratteri riconosciuti dal motore delle espressioni regolari di Perl. Per essere certi che vengano riconosciuti, è sufficiente chiedere a grep di utilizzare il motore delle espressioni regolari di Perl:

	grep -P "Package: \S+" status
	grep --perl-regexp "Package: \S+" status

Per tornare ad utilizzare il motore delle espressioni regolari di default, invece, è sufficiente utilizzare l'opzione:

	grep -G "Package: \S\+" status
	grep --basic-regexp "Package: \S\+" status

Naturalmente, trattandosi dell'impostazione di default, l'opzione -G ( --basic-regexp, in forma estesa ) risulta inutile o, quanto meno, ridondante. Il motore di base delle espressioni regolari utilizza le backslash per riconoscere alcuni metacaratteri:

\?
\+
\{
\|
\(
\)

Questo non vale per la terza classe di espressioni regolari accettate da grep, le Espressioni Regolari Estese, che possono essere invocate nel modo seguente:

	grep -E "Package: \S+" status
	grep --extended-regexp "Package: \S+" status

A parte questi metacaratteri, nella versione GNU di grep, non dovrebbero sussistere altre differenze tra il motore di base delle espressioni regolari ed il motore delle Espressioni Regolari Estese. Per entrambi, dovrebbero essere accettati i seguenti metacaratteri:

[...]	classe di caratteri
-	range: a-zA-Z0-9
.	un carattere qualsiasi
^	inizio stringa
\<	inizio stringa
\>	fine stringa
$	fine stringa
\b	limite di parola
\B	no limite di parola

Il motore di base delle espressioni regolari ed il motore delle Espressioni Regolari Estese, poi, riconoscono le classi di carattere POSIX ( Portable Operating System Interface for Unix ), il cui significato dovrebbe essere chiaro:

[:alnum:]	carattere alfanumerico
[:alpha:]
[:digit:]
[:xdigit:]	numero esadecimale 0-F
[:cntrl:]	carattere di controllo
[:print:]	no carattere di controllo
[:space:]
[:graph:]	no spazio
[:lower:]
[:upper:]
[:punct:]	carattere di punteggiatura

C'è una opzione del comando grep che corrisponde all'uso dell'àncora \b, all'interno del pattern. Come sappiamo, \b indica il "word boundary", cioè il limite, il confine, di una parola: un elemento di lunghezza zero che viene interposto tra un carattere ( \w ) ed un non carattere ( \W ). Scrivere, per esempio:

	grep "apt" available

restituirebbe 192 risultati ( nel mio PC ), poichè il pattern "apt" trova riscontro in stringhe quali:

apt
laptops
libraptor1
capture

Se volessimo, invece, limitare la ricerca alle sole righe in cui il pattern appare come parola singola intera, dovremmo specificare:

	grep "\bapt\b" available

ed il numero dei riscontri si abbasserebbe sensibilmente ( 70, nel mio caso ). Occorre ricordare che il motore delle espressioni regolari considera "word" le lettere, i numeri e gli underscore: tutto il resto è considerato "boundary". Non stupiamoci, quindi, di trovare, tra i risultati, sequenze quali:

ia32-apt-get
apt-utils

visto che il trattino rientra tra i "boundary". Ebbene, l'opzione che possiamo utilizzare, per ottenere lo stesso risultato, è l'opzione -w ( --word-regexp, nella sua forma estesa ):

	grep -w "apt" available
	grep --word-regexp "apt" available

Se poi volessimo che il pattern coincidesse, addirittura, con l'intera riga ( e non solo con una singola parola intera ), potremmo utilizzare l'opzione -x ( --line-regexp, nella sua forma estesa ):

	grep -x "apt" available
	grep --line-regexp "apt" available

Ci sono ancora un paio di opzioni che potrebbero risultare molto utili:

	grep -q "Package:" available
	grep --quiet "Package:" available
	grep --silent "Package:" available

Questi tre comandi sono tutti equivalenti e fanno la stessa cosa: non producono alcun output. E' possibile, infatti, invocare grep all'interno di uno script, il quale si aspetterebbe, presumibilmente, il solo codice di uscita:

0	trovato uno o più riscontri
1	nessun riscontro
2	errore

Se, invece, si desidera sopprimere i soli messaggi di errore:

	grep -s "Package: libio" *
	grep --no-messages "Package: libio" *

Questo evita la cascata di messaggi di errore, prodotti dall'attraversamento di directory o dal tentativo di lettura di file per i quali non abbiamo i permessi necessari.

egrep

Il comando egrep ( Extended Global Regular-Expression Print ) cerca un testo all'interno di un file, esattamente come il comando grep, ma utilizza le espressioni regolari estese. Quindi, i tre comandi seguenti sono assolutamente equivalenti:

	egrep "Package: jfsutils" available status
	grep -E "Package: jfsutils" available status
	grep --extended-regexp "Package: jfsutils" available status