[successivo] [precedente] [inizio] [fine] [indice generale] [indice ridotto] [indice analitico] [home] [volume] [parte]


Capitolo 184.   Ricerche

Esistono due tipi di ricerche possibili: quelle all'interno dei file per identificare delle stringhe che corrispondono a un modello e quelle fatte all'interno di un file system alla ricerca di file o directory in base alle loro caratteristiche (nome, date e altri attributi).

Per questo si utilizzano due programmi di servizio fondamentali: Grep per le ricerche di stringhe e Find per la ricerca dei file.

Tabella 184.1. Riepilogo dei programmi utili per eseguire delle ricerche.

Nome Descrizione
grep Scandisce file di testo usando un'espressione regolare.
bool Scandisce file di testo alla ricerca di stringhe messe in relazione attraverso operatori booleani.
look Esegue una ricerca binaria all'interno di un file ordinato.
find Scandisce file e directory alla ricerca di corrispondenze con le caratteristiche esteriori di questi.

184.1   Grep GNU

Il programma Grep (1) esegue una ricerca all'interno dei file in base a un modello espresso normalmente in forma di espressione regolare.

Storicamente sono esistite tre versioni di questo programma: grep, egrep e fgrep, ognuna specializzata in un tipo di ricerca. Attualmente, Grep GNU, corrispondente a quello che si utilizza normalmente nei sistemi GNU, comprende tutte queste funzionalità. In alcuni casi, per mantenere la compatibilità con il passato, possono trovarsi distribuzioni che mettono a disposizione anche i programmi egrep e fgrep in forma originale.

L'eseguibile grep compie una ricerca all'interno dei file indicati come argomento oppure all'interno dello standard input:

grep [opzioni] modello [file...]
grep [opzioni] -e modello [file...]
grep [opzioni] -f file_modello [file...]

Il modello di ricerca può essere semplicemente il primo degli argomenti che seguono le opzioni, oppure può essere indicato precisamente come argomento dell'opzione -e, oppure ancora può essere contenuto in un file che viene indicato attraverso l'opzione -f. La tabella 184.2 elenca le opzioni principali.

Tabella 184.2. Opzioni principali di grep.

Opzione Descrizione
-G
Utilizza un'espressione regolare elementare (comportamento predefinito).
-E
Utilizza un'espressione regolare estesa. Se si avvia il programma con il nome egrep, è come utilizzare l'eseguibile grep con l'opzione -E.
-F
Utilizza un modello fatto di stringhe fisse. Se si avvia il programma con il nome fgrep, è come utilizzare l'eseguibile grep con l'opzione -F.
-e modello
Specifica il modello di ricerca.
-f file
Specifica il nome di un file contenente il modello di ricerca.
-i
Ignora la differenza tra maiuscole e minuscole.
-n
Aggiunge il numero di riga.
-c
Emette solo il totale delle righe corrispondenti per ogni file.
-h
Elimina l'intestazione normale per le ricerche su più file.
-l
Emette solo i nomi dei file per i quali la ricerca ha avuto successo.
-L
Emette solo i nomi dei file per i quali la ricerca non ha avuto successo.
-v
Inverte il senso della ricerca: valgono le righe che non corrispondono.

Segue la descrizione di alcuni esempi. Nella sezione successiva vengono descritte brevemente le espressioni regolari utilizzabili con Grep GNU.

184.1.1   Espressioni regolari

Un'espressione regolare è un modello che descrive un insieme di stringhe. Le espressioni regolari sono costruite, in maniera analoga alle espressioni matematiche, combinando espressioni più brevi.

Per tradizione esistono due tipi di espressioni regolari: elementari, o BRE, ed estese, o ERE (si vedano in particolare i capitoli dedicati alle espressioni regolari in generale: 665 e 666). Il programma grep originale è in grado di interpretare solo quelle elementari, Grep GNU interpreta correttamente anche quelle estese nonostante il suo funzionamento predefinito sia sempre basato su quelle elementari. Le espressioni regolari elementari sono limitate rispetto a quelle estese; in questo particolare adattamento di grep si ottengono le stesse funzionalità, pur se con una sintassi leggermente diversa da quella normale.

In generale, la sintassi delle espressioni regolari non è uguale per tutti i programmi che ne fanno uso, anche se esiste lo standard POSIX, che però è difficile trovare applicato in modo fedele.

Senza costringere il lettore a studiare subito i capitoli 665 e 666, dedicati alle espressioni regolari, viene data una descrizione sommaria delle espressioni regolari estese secondo GNU e alla fine viene descritto come si comportano quelle elementari.

Il punto di partenza sono le espressioni regolari con le quali si ottiene una corrispondenza con un solo carattere. La maggior parte dei caratteri, includendo tutte le lettere e le cifre numeriche, sono espressioni regolari che corrispondono a loro stessi. Ogni metacarattere con significati speciali può essere utilizzato per il suo valore normale facendolo precedere dalla barra obliqua inversa (\).

Una fila di caratteri racchiusa tra parentesi quadre corrisponde a un carattere qualunque tra quelli indicati; se all'inizio di questa fila c'è l'accento circonflesso, si ottiene una corrispondenza con un carattere qualunque diverso da quelli della fila. Per esempio, l'espressione regolare [0123456789] corrisponde a una cifra numerica qualunque, mentre [^0123456789] corrisponde a un carattere qualunque purché non sia una cifra numerica.

All'interno delle parentesi quadre, invece che indicare un insieme di caratteri, è possibile indicarne un intervallo, mettendo il carattere iniziale e finale separati da un trattino (-). I caratteri che vengono rappresentati in questo modo dipendono dalla codifica che ne determina la sequenza. Per esempio, in base alla codifica ASCII, l'espressione regolare [9-A] rappresenta un carattere qualsiasi tra: 9, :, ;, <, =, >, ?, @ e A.

All'interno delle parentesi quadre si possono indicare delle classi di caratteri attraverso il loro nome: [:alnum:], [:alpha:], [:cntrl:], [:digit:], [:graph:], [:lower:], [:print:], [:punct:], [:space:], [:upper:] e [:xdigit:]. Per essere usati, questi nomi di classi possono solo apparire all'interno di un'espressione tra parentesi quadre, di conseguenza, per esprimere la corrispondenza con un carattere alfanumerico qualunque si può utilizzare l'espressione regolare [[:alnum:]]. Nello stesso modo, per esprimere la corrispondenza con un carattere non alfanumerico qualunque si può utilizzare l'espressione regolare [^[:alnum:]].

Il punto (.) corrisponde a un carattere qualsiasi. Il simbolo \w è un sinonimo di [[:alnum:]] e \W è un sinonimo di [^[:alnum:]].

L'accento circonflesso (^) e il dollaro ($) sono metacaratteri che corrispondono rispettivamente alla stringa nulla all'inizio e alla fine di una riga. I simboli \< e \> corrispondono rispettivamente alla stringa nulla all'inizio e alla fine di una parola.

Quando per qualche ragione si hanno difficoltà a indicare dei caratteri che per l'espressione sarebbero comunque caratteri normali, è possibile utilizzare il simbolo \ anteriormente, purché questo non rappresenti a sua volta un altro metacarattere.

Un'espressione regolare che genera una corrispondenza con un carattere singolo, può essere seguita da uno o più operatori di ripetizione. Questi sono rappresentati attraverso i simboli ?, *, + e dai «contenitori» rappresentati da particolari espressioni tra parentesi graffe. La tabella 184.3 mostra l'uso che si può fare di questi operatori.

Tabella 184.3. Operatori di ripetizione nelle espressioni regolari estese gestite da Grep GNU.

Codifica Corrispondenza.
x*
Nessuna o più volte x. Equivalente a x{0,}.
x?
Nessuna o al massimo una volta x. Equivalente a x{0,1}.
x+
Una o più volte x. Equivalente a x{1,}.
x{n}
Esattamente n volte x.
x{n,}
Almeno n volte x.
x{n,m}
Da n a m volte x.

Due espressioni regolari possono essere concatenate (in sequenza) generando un'espressione regolare corrispondente alla sequenza di due sottostringhe che rispettivamente corrispondono alle due sottoespressioni.

Due espressioni regolari possono essere unite attraverso l'operatore |; l'espressione regolare risultante corrisponde a una stringa qualunque per la quale sia valida la corrispondenza di una delle due sottoespressioni.

La ripetizione (attraverso gli operatori di ripetizione) ha la precedenza sul concatenamento che a sua volta ha la precedenza sull'alternanza (quella che si ha utilizzando l'operatore |). Una sottoespressione può essere racchiusa tra parentesi tonde per modificare queste regole di precedenza.

La notazione \n, dove n è una singola cifra numerica diversa da zero, rappresenta un riferimento all'indietro a una corrispondenza già avvenuta tra quelle di una sottoespressione precedente racchiusa tra parentesi tonde. La cifra numerica indica l'n-esima sottoespressione tra parentesi a partire da sinistra.

Nelle espressioni regolari elementari, i metacaratteri ?, +, {, |, ( e ) perdono il loro significato speciale. Al loro posto si possono utilizzare gli stessi simboli preceduti dalla barra obliqua inversa: \?, \+, \{, \|, \( e \).

La descrizione fatta delle espressioni regolari estese di Grep GNU è incompleta. Per i dettagli mancanti conviene consultare i capitoli che trattano in maniera specifica questo argomento, come già indicato in precedenza.

184.1.2   zGrep

Normalmente, i programmi eseguibili (o i collegamenti) che compongono Grep, sono accompagnati da una serie di script che facilitano le ricerche all'interno di file compressi con Gzip o con Compress:

zgrep [opzioni] modello [file...]
zegrep [opzioni] modello [file...]
zfgrep [opzioni] modello [file...]

L'utilizzo è equivalente ai programmi grep, egrep e fgrep, con la differenza che si intendono scandire file compressi. Di solito, tali script funzionano correttamente anche se in realtà i file da analizzare non sono compressi affatto.

184.2   Bool

Bool (2) è un programma relativamente semplice per la scansione di file di testo, alla ricerca di segmenti contenenti una corrispondenza con delle stringhe, collegate tra di loro attraverso un'espressione booleana:

bool [opzioni] espressione [file...]

Come si può intuire dal modello sintattico, la ricerca può avvenire all'interno di uno o più file indicati alla fine della riga di comando, oppure da quanto proviene dallo standard input.

L'espressione di ricerca è una stringa fatta di parole ed eventualmente da sottostringhe, collegate attraverso operatori booleani ed eventualmente parentesi tonde per modificare l'ordine di interpretazione. La tabella successiva elenca gli operatori disponibili.

Tabella 184.4. Operatori utilizzabili nelle espressioni di ricerca di Bool.

Espressione Descrizione.
stringa
L'espressione si avvera se la stringa si trova nel testo.
stringa_1 near stringa_2
L'espressione si avvera se entrambe le stringhe si trovano nel testo, a una distanza massima stabilita (10 parole in modo predefinito, oppure un valore diverso se si usa l'opzione -D).
espr_1 and espr_2
L'espressione complessiva si avvera se entrambe le sottoespressioni si avverano simultaneamente nel testo.
espr_1 or espr_2
L'espressione complessiva si avvera se almeno una delle sottoespressioni si avvera nel testo.
espr_1 not espr_2
L'espressione complessiva si avvera se la sottoespressione alla sinistra si avvera, mentre quella a destra no.
(espressione)
Fa in modo che la sottoespressione contenuta tra parentesi sia eseguita interamente, prima di valutare ciò che si trova all'esterno.

Bool è in grado di riconoscere i file in formato HTML e in tal caso interpreta correttamente le entità SGML (come per esempio à, è, ì , ò e ù), in qualità dei caratteri corrispondenti. Inoltre, per indicare caratteri particolari nell'espressione di ricerca si possono usare le stesse entità SGML, sia per i file HTML, sia per i file di testo comuni.

Si osservi che se un file di testo, o comunque un file che non viene riconosciuto come file HTML, contiene stringhe che assomigliano a entità SGML, queste possono essere individuate solo letteralmente, ma in tal caso diventa necessario usare degli accorgimenti. Negli esempi alla fine della sezione viene riportato un caso di questo tipo.

Nella tabella successiva vengono riportate solo poche opzioni essenziali, ma altre opzioni importanti sono disponibili e possono essere conosciute facilmente consultando la pagina di manuale bool(1).

Tabella 184.5. Alcune opzioni.

Opzione Descrizione
-D
--distance
Consente di stabilire la distanza massima tra le stringhe cercate quando si usa l'operatore near.
-i
--ignore-case
Rende indifferente il confronto tra maiuscole e minuscole.
-n
--line-number
Mostra anche il numero di riga dove si ottiene la corrispondenza con l'espressione di ricerca.
-O n
--occurrences=n
Mostra al massimo n righe sullo schermo del testo in cui si forma la corrispondenza con l'espressione di ricerca. Se si indica il valore zero, si ottiene la visualizzazione di tutte le righe che contengono una corrispondenza, anche se il risultato complessivo dell'espressione di ricerca è falso.
-q
--quiet
Non mostra alcunché. Serve per ottenere un esito esclusivamente attraverso quanto restituito dal programma.

Segue la descrizione di alcuni esempi, dove in particolare il file COPYING, usato per la scansione, contiene il testo della licenza GNU GPL versione 2. Si osservi che i comandi degli esempi vengono eseguiti attraverso una shell compatibile con quella di Bourne, o con una shell POSIX.

A conclusione degli esempi che fanno riferimento alla scansione del file COPYING, si può immaginare di disporre del file di testo prova.txt, che contiene le righe seguenti:

      7 Le parole "perch&eacute;" e "poich&eacute;" sono scritte
      8 usando l'accento acuto nella vocale finale.

In queste condizioni, il programma interpreta il testo in modo letterale, perché non c'è alcun motivo per attribuire alle stringhe &eacute; un significato particolare, al contrario di quello che invece sarebbe se il file fosse in formato HTML. Pertanto, se fosse necessario individuare la stringa perch&eacute; da questo file, occorrerebbe un modello particolare:

perch&amp;eacute;

Segue l'esempio del comando, tenendo conto che si usa una shell POSIX, o comunque una shell compatibile con quella di Bourne (senza le virgolette, la e-commerciale verrebbe interpretata come la richiesta di eseguire sullo sfondo il comando che appare fino a quel punto):

bool "perch&eacute;" prova.txt[Invio]

Le parole "perch&eacute;" e "poich&eacute;" sono scritte usa

Se si tentasse di scrivere la stringa di ricerca con la lettera vocale normale (secondo la codifica usata localmente), non si otterrebbe alcunché, proprio perché il programma non ha motivo di interpretare la stringa &eacute; in modo diverso da quello letterale:

bool perché prova.txt[Invio]

184.2.1   L'uso dell'opzione «-O 0»

Il programma bool, se usato con l'opzione -O 0, si comporta in un modo apparentemente anomalo. In pratica, mostra tutte le corrispondenze con le stringhe indicate nel modello di ricerca, anche se nel complesso, l'espressione fornita non si avvera. Per ovviare a questo inconveniente, al posto di zero si può indicare un valore elevato, per esempio 9 999. A ogni modo, anche utilizzando l'opzione -O 0 (infinito), il programma restituisce un valore corretto (Vero solo se l'espressione si avvera). L'autore di questo programma, Marc Tardif, spiega attraverso un paio di messaggi le motivazioni per questa scelta, aggiungendo anche qualche esempio pratico di utilizzo. Le parti salienti di questi messaggi vengono pubblicate con il permesso di Marc Tardif:

Date: Thu, 23 Sep 2004 20:38:23 -0400
From: Marc Tardif <mtardif (ad) interunion·ca>
To: <daniele (ad) swlibero·org>
Subject: Re: GNU Bool

[...]

The option -O, --occurences, is documented as follows in the manpage:

Print NUM lines (default 1) of context for each pattern. No output is printed if the boolean expression is false. Every match is printed if NUM is set to 0, even if the expression if false.

As you noticed, this may produce output which contradicts the given boolean expression. In short, the reason is to provide a reasonable and bounded consumption of the system's resources.

In long, the purpose of GNU Bool to evaluate an expression consisting of multiple patterns. For the sake of our discussion, lets expand on your example and use the expression "license not foobar". Also, lets assume you want to output all the occurences if the expression is true as you expected the option -O to behave. First, the parser would read the input file COPYING and record each occurence of the patterns "license" and "foobar". Second, the boolean expression "license not foobar" would be evaluated. Third, if the expression is true, all the occurences of "license" would be output.

The problem is that the input size and the number of occurences are undetermined. Therefore, in the first step described above, the number of contexts being recorded would also be undetermined. Considering each context requires some form of storage, whether it be in memory or in file, this makes it difficult to predict the resources necessary to parse input. For example, consider the following command:

tcpdump | bool -O 0 "icmp or http"[Invio]

If GNU Bool was to record each occurence generated by the tcpdump command, this could require a prohibitive amount of resources in a matter of minutes on a busy server. A responsible operating system would limit the resource consumption but another operating system might crash when all the memory and swap have been exhausted.

The solution is to output every occurence in order to make resource consumption more predictable. However, to prevent information from being lost, the truthfullness of the boolean expression is output as the return value. For example:

bool -O 0 -n "license or freedom" COPYING > /dev/null[Invio]

echo $?[Invio]

0

bool -O 0 -n "license not freedom" COPYING > /dev/null[Invio]

echo $?[Invio]

1

[...]

Date: Sun, 26 Sep 2004 14:41:22 -0400
From: Marc Tardif <mtardif (ad) interunion·ca>
To: <daniele (ad) swlibero·org>
Subject: Re: GNU Bool

[...]

Instead of using memory to store an undetermined number of contexts, it is possible to fall back on the filesystem and only display the contexts upon a successful match. Consider the following combination of commands:

bool -O 0 'license not foobar' COPYING > /tmp/$$ \
  \&& cat /tmp/$$ ; \
  \rm /tmp/$$
[Invio]

The problem with the above is that the return value of the bool command is lost due to the trailing rm command. If this information is not necesary, the time saved typing is certainly worthwhile. However, a non-zero return value does not always indicate no matches were found. For example, a return value of 2 indicates there were syntax errors in the expression or other system errors. The solution is to extend the above commands to preserve the return value:

bool -O 0 'license not foobar' COPYING > /tmp/$$ ; \
  \ret=$? ; \
  \[ $ret -eq 0 ] && cat /tmp/$$ ; \
  \rm /tmp/$$ ; \
  \return $ret
[Invio]

This combination of commands can be typed directly on the shell or stored in a shell script. Either way, the user is always in control.

184.3   Look

Il programma Look (3) serve a eseguire una ricerca binaria all'interno di un file di testo, confrontando solo la prima parte delle righe:

look [opzioni] stringa [file...]

A differenza di Grep, questo programma esegue soltanto una comparazione letterale della stringa indicata, con la parte iniziale delle righe; inoltre, i file scanditi devono essere ordinati.

Date queste limitazioni, l'importanza del programma look è solo storica, perché si può sostituire facilmente con Grep.

Eventualmente, attraverso le opzioni è possibile limitare il confronto ai soli caratteri alfanumerici e si può fare in modo di ignorare la differenza tra lettere maiuscole e minuscole. Se non viene specificato alcun file per la ricerca nella riga di comando, la scansione viene tentata nel file /usr/share/dict/words

Il programma look esegue un confronto byte per byte e non è in grado di adattarsi alla configurazione locale del linguaggio.

Eventualmente si può consultare la pagina di manuale look(1).

184.4   Find

Il programma Find (4) esegue una ricerca, all'interno di uno o più percorsi, per i file che soddisfano delle condizioni determinate, legate alla loro apparenza esterna e non al loro contenuto. Per ogni file o directory trovati, può essere eseguito un comando (programma, script o altro) che a sua volta può svolgere delle operazioni su di essi.

Questa sezione non descrive tutte le funzionalità di Find. Una volta appresi i rudimenti del suo funzionamento, conviene consultare il documento info find oppure la pagina di manuale find(1).

Find si compone in pratica dell'eseguibile find, che ha una sintassi piuttosto insolita, oltre che complessa, anche se dallo schema seguente non sembrerebbe così.

In particolare è indispensabile tenere a mente che molti dei simboli utilizzati negli argomenti dell'eseguibile find potrebbero essere interpretati e trasformati dalla shell, di conseguenza può essere necessario utilizzare le tecniche che la shell stessa offre per evitarlo.

find [percorso...] [espressione]

Find esegue una ricerca all'interno dei percorsi indicati per i file che soddisfano l'espressione di ricerca. Il primo argomento che inizia con -, (, ), , o ! (trattino, parentesi tonda, virgola, punto esclamativo) viene considerato come l'inizio dell'espressione, mentre gli argomenti precedenti sono interpretati come parte dell'insieme dei percorsi di ricerca.

Se non vengono specificati percorsi di ricerca, si intende la directory corrente; se non viene specificata alcuna espressione, o semplicemente se non viene specificato nulla in contrario, viene emesso l'elenco dei nomi trovati.

Il concetto di espressione nella documentazione di Find è piuttosto ampio e bisogna fare un po' di attenzione. Si può scomporre idealmente nello schema seguente:

[opzione...] [condizioni]

A loro volta, le condizioni possono essere di due tipi: test e azioni. Ma, mentre le opzioni devono apparire prima, test e azioni possono essere mescolati tra loro.

Le opzioni rappresentano un modo di configurare il funzionamento del programma, così come di solito accade nei programmi di servizio. Le condizioni sono espressioni che generano un risultato logico e come tali vanno trattate: per concatenare insieme più condizioni occorre utilizzare gli operatori booleani.

Tabella 184.21. Alcune opzioni importanti. Le opzioni si collocano prima delle condizioni (test e azioni).

Opzione Descrizione
-depth
Elabora prima il contenuto delle directory. In pratica si ottiene una scansione che parte dal livello più profondo fino al più esterno.
-xdev
-mount
Non esegue la ricerca nelle directory contenute all'interno di file system differenti da quello di partenza. Tra i due è preferibile usare -xdev.
-noleaf
Non ottimizza la ricerca. Questa opzione è necessaria quando si effettuano ricerche all'interno di file system che non seguono le convenzioni Unix, come nel caso di CD-ROM senza le estensioni necessario, o partizioni Dos.

L'esempio seguente elenca tutti i file e le directory a partire dalla posizione corrente restando nell'ambito del file system di partenza:

find . -xdev -print[Invio]

Come già accennato, i test sono condizioni che vengono valutate per ogni file e directory incontrati. Il risultato delle condizioni può essere Vero o Falso. Quando vengono indicate più condizioni, queste devono essere unite in qualche modo attraverso degli operatori booleani per ottenere una sola grande condizione. Se non viene specificato diversamente, viene utilizzato automaticamente l'operatore AND: -and.

All'interno dei test, gli argomenti numerici possono essere preceduti o meno da un segno:

+n
Indica un numero maggiore di n.
-n
Indica un numero minore di n.
n
Indica un numero esattamente uguale a n.

Nelle tabelle successive, vengono raggruppati per tipo alcuni testi disponibili.

Tabella 184.23. Test sulla proprietà dei file o delle directory.

Test Descrizione
-uid n
Si avvera quando il numero UID (utente) del file o della directory è uguale a n.
-user nome_dell'utente
Si avvera quando il file o la directory appartiene all'utente indicato.
-nouser
Si avvera per i file e le directory di proprietà di utenti non esistenti.
-gid n
Si avvera quando il numero GID (gruppo) del file o della directory è uguale a n.
-group nome_del_gruppo
Si avvera quando il file o la directory appartiene al gruppo indicato.
-nogroup
Si avvera per i file e le directory di proprietà di gruppi non esistenti.

Tabella 184.24. Test sui permessi dei file o delle directory.

Test Descrizione
-perm permessi
Si avvera quando i permessi del file o della directory corrispondono esattamente a quelli indicati con questo test. I permessi si possono indicare in modo numerico (ottale) o simbolico.
-perm -permessi
Si avvera quando i permessi del file o della directory comprendono almeno quelli indicati con questo test.
-perm +permessi
Si avvera quando alcuni dei permessi indicati nel modello di questo test corrispondono a quelli del file o della directory.

Tabella 184.25. Test sulle caratteristiche dei nomi dei file o delle directory.

Test Descrizione
-name modello
Si avvera quando viene incontrato un nome di file o directory corrispondente al modello indicato, all'interno del quale si possono utilizzare i caratteri jolly. La comparazione avviene utilizzando solo il nome del file (o della directory) escludendo il percorso precedente. I caratteri jolly (*, ?, [, ]) non possono corrispondere al punto iniziale (.) che appare nei cosiddetti file nascosti.
-iname modello
Si comporta come -name, ma non tiene conto della differenza tra maiuscole e minuscole (iname = insensitive name).
-lname modello
Si avvera quando si tratta di un collegamento simbolico e il suo contenuto corrisponde al modello che può essere espresso utilizzando anche i caratteri jolly. Un collegamento simbolico può contenere anche l'indicazione del percorso necessario a raggiungere un file o una directory reale. Il modello espresso attraverso i caratteri jolly non tiene conto in modo particolare dei simboli punto (.) e barra obliqua (/) che possono essere contenuti all'interno del collegamento.
-ilname modello
Si comporta come -lname, ma non tiene conto della differenza tra maiuscole e minuscole (ilname = insensitive lname).
-path modello
Si avvera quando il modello, esprimibile utilizzando caratteri jolly, corrisponde a un percorso. Per esempio, un modello del tipo ./i*no può corrispondere al file ./idrogeno/ossigeno.
-ipath modello
Si comporta come -path, ma non tiene conto della differenza tra maiuscole e minuscole (ipath = insensitive path).
-regexp modello
Si avvera quando l'espressione regolare indicata corrisponde al file o alla directory incontrati. Per la verifica della corrispondenza, attraverso l'espressione regolare, viene utilizzato anche il percorso e non solo il nome del file o della directory. Quindi, per ottenere la corrispondenza con il file ./carbonio si può utilizzare l'espressione regolare .*bonio oppure .*bo..o, ma non c.*io.
-iregexp modello
Si comporta come -regexp, ma non tiene conto della differenza tra maiuscole e minuscole (iregexp = insensitive regexp).

Tabella 184.26. Test sulla data di modifica dei file o delle directory.

Test Descrizione
-mmin n
Si avvera quando la data di modifica del file o della directory corrisponde a n minuti fa.
-mtime n
Si avvera quando la data di modifica del file o della directory corrisponde a n giorni fa. Più precisamente, il valore n fa riferimento a multipli di 24 ore.
-newer file
Si avvera quando la data di modifica del file o della directory è più recente di quella del file indicato.

Tabella 184.27. Test sulla data di accesso ai file o alle directory.

Test Descrizione
-amin n
Si avvera quando la data di accesso del file o della directory corrisponde a n minuti fa.
-atime n
Si avvera quando la data di accesso del file o della directory corrisponde a n giorni fa. Più precisamente, il valore n fa riferimento a multipli di 24 ore.
-anewer file
Si avvera quando la data di accesso del file o della directory è più recente di quella del file indicato.

Tabella 184.28. Test sulla data di creazione o del cambiamento di stato dei file o delle directory.

Test Descrizione
-cmin n
Si avvera quando la data di creazione del file o della directory corrisponde a n minuti fa.
-ctime n
Si avvera quando la data di creazione del file o della directory corrisponde a n giorni fa. Più precisamente, il valore n fa riferimento a multipli di 24 ore.
-cnewer file
Si avvera quando la data di creazione del file o della directory è più recente di quella del file indicato.

Tabella 184.29. Test sulla dimensione dei file o delle directory.

Test Descrizione
-empty
Si avvera quando il file o la directory sono vuoti.
-size n[b|c|k|w]
Si avvera quando la dimensione del file o della directory ha una dimensione pari a n. L'unità di misura è rappresentata dalla lettera che segue il numero:
b   blocchi da 512 byte e rappresenta il valore predefinito in mancanza dell'indicazione di questa lettera;
c   byte (caratteri);
k   blocchi da 1 024 byte (1 Kibyte);
w   parole di 2 byte.

Tabella 184.30. Test vari.

Test Descrizione
-true
Sempre vero.
-false
Sempre falso.
-fstype tipo_di_file_system
Si avvera quando il file o la directory si trova in un file system del tipo indicato (vedere tabella 167.2).
-inum n
Si avvera quando il file o la directory ha il numero di inode corrispondente a n.
-type categoria
Si avvera se l'elemento analizzato appartiene alla categoria indicata:
b   dispositivo a blocchi;
c   dispositivo a caratteri;
d   directory;
p   file FIFO (pipe con nome);
f   file normale (regular file);
l   collegamento simbolico;
s   socket.

Le condizioni possono essere costruite anche utilizzando alcuni operatori booleani e le parentesi. Quando questi vengono utilizzati, la valutazione delle condizione viene fatta eseguendo il minimo numero indispensabile di operazioni. Ciò significa che di fronte a un operatore AND si verifica la prima condizione e solo se questa risulta vera si passa a verificare la seconda; di fronte a un operatore OR si verifica la prima condizione e solo se questa risulta falsa si passa a verificare la seconda. Infatti, per sapere che il risultato di un'operazione AND è Falso basta sapere che almeno una delle due condizioni in ingresso ha un valore Falso; per sapere che il risultato di un'operazione OR è Vero basta sapere che almeno una delle due condizioni in ingresso ha il valore Vero.

Tabella 184.31. Operatori booleani.

Operatore Descrizione
(   )
Le parentesi tonde stabiliscono la precedenza nell'esecuzione dei test.
!
-not
Davanti a un'espressione si comporta come negazione logica, ovvero è equivalente a NOT.
-a
-and
Tra due espressioni si comporta come l'operatore logico AND. In mancanza dell'indicazione di un operatore logico tra due condizioni si intende AND.
-o
-or
Tra due espressioni si comporta come l'operatore logico OR.

Le azioni sono delle operazioni da compiere per ogni file o directory che si ottiene dalla scansione. Queste azioni generano però un risultato che viene interpretato in maniera logica. Dipende da come vengono concatenate le varie condizioni (test e azioni) se, e in corrispondenza di quanti file, vengono eseguite queste azioni.

Tabella 184.32. Alcune azioni.

Azione Descrizione
-exec comando ; 
Esegue il comando indicato, nella directory di partenza, restituendo il valore Vero se il comando restituisce il valore zero. Tutti gli argomenti che seguono vengono considerati come parte del comando fino a quando viene incontrato il simbolo punto e virgola (;). All'interno del comando, la stringa {} viene interpretata come sinonimo del file che è attualmente in corso di elaborazione. Se la shell interpreta questo simbolo occorre utilizzare il meccanismo della protezione per evitarlo.
-ok comando ; 
Si comporta come -exec ma, prima di eseguire il comando, chiede conferma all'utente. Se il comando non viene eseguito, restituisce il valore Falso.
-print
Si avvera sempre ed emette il nome completo dei file (e delle directory) che avverano l'insieme delle condizioni. È l'azione predefinita, se non ne vengono indicate delle altre.
Il programma Find di GNU considera questa l'azione predefinita, per cui non è necessario indicarla per ottenere un output sullo schermo. Generalmente, Find non ha un'azione predefinita e questo può mettere in crisi un utente di un sistema GNU quando passa a un altro sistema Unix. Questo è il motivo per il quale viene sempre indicata l'azione negli esempi seguenti, anche se non sarebbe necessario.

Segue la descrizione di alcuni esempi.


1) Grep GNU   GNU GPL

2) Bool GNU   GNU GPL

3) BSD utils   UCB BSD

4) GNU findutils   GNU GPL


Appunti di informatica libera 2008 --- Copyright © 2000-2008 Daniele Giacomini -- <appunti2 (ad) gmail·com>


Dovrebbe essere possibile fare riferimento a questa pagina anche con il nome ricerche_1.htm

[successivo] [precedente] [inizio] [fine] [indice generale] [indice ridotto] [indice analitico] [home]

Valid ISO-HTML!

CSS validator!

Gjlg Metamotore e Web Directory