Capitolo 8. Altri comandi utili
Indietro |  | Avanti

## Capitolo 8. Altri comandi utili

## 8.1. Lavorare con i file

Questa sezione descrive alcuni comandi che possono risultare utili nell'esaminare e manipolare il contenuto dei propri file.

Tabella 8.1. Utilità file

Comando/Sintassi | Cosa fa
--- | ---
`cmp [`opzioni`] `file1 file2`` | confronta due file e mostra dove avvengono le differenze (file di testo e file binari)
`cut [`opzioni`] [`file`]` | taglia specifici campi/caratteri dalle linee di un file
`diff [`opzioni`] `file1 file2`` | confronta due file e mostra le differenze (solamente file di testo)
`file [`opzioni`] `file`` | classifica il tipo di file
`find `directory` [`opzioni`] [`azioni`]` | cerca file basandosi sul tipo o su uno schema
`ln [`opzioni`] `sorgente` `destinazione`` | crea un link (collegamento) a ``sorgente`` chiamato ``destinazione``
`paste [`opzioni`] `file`` | aggiunge campi all'interno di un file
`sort [`opzioni`] `file`` | riordina le linee di un file in accordo con le opzioni specificate
`strings [`opzioni`] `file`` | riporta sequenze di 4 o più caratteri stampabili terminati con <NL> o <NULL>. Normalmente utilizzato per ricercare stringhe ASCII in file binari.
`tee [`opzioni`] `file`` | copia standard output in uno o più file
`touch [`opzioni`] [`data/ora`] `file`` | crea un file vuoto o aggiorna la data di accesso di un file esistente
`tr [`opzioni`] `stringa1 stringa2`` | traduce i caratteri di `stringa1` provenienti da standard input in quelli di `stringa2` per standard output
`uniq [`opzioni`] `file`` | rimuove le linee ripetute in un file
`wc [`opzioni`] [`file`]` | mostra il numero di parole (o di caratteri o di linee) di un file

### 8.1.1. cmp - confronta contenuti di file

Il comando cmp(1) confronta due file, e (senza opzioni) riporta la posizione della loro prima differenza. Può trattare confronti sia tra file ASCII sia tra file binari. Il comando compie una comparazione byte-per-byte.

Sintassi

`cmp [`opzioni`] `file1 file2` [`salto1`] [`salto2`]`

I numeri di salto sono i numeri di byte da saltare in ogni file prima di iniziare il confronto.

Opzioni generali

`-l` | riporta ogni differenza
`-s` | riporta solamente un valore di uscita, non le differenze tra i byte

Esempi:

Dati i file `mon.logins` e `tues.logins`:

ageorge ageorge bsmith cbetts cbetts jchen jchen jdoe jmarsch jmarsch lkeres lkeres mschmidt proy sphillip sphillip wyepp wyepp

Il confronto dei due file produce:

`%` `cmp mon.logins tues.logins` mon.logins tues.logins differ: char 9, line 2

Di default il comando riporta solamente la prima differenza trovata.

Questo comando è utile nel determinare quale versione di un file dovrebbe essere mantenuta quando c'è più di una versione dello stesso file.

### 8.1.2. diff - differenze tra file

Il comando diff(1) confronta due file, due directory, ecc., e riporta tutte le differenze tra i due. Questo comando tratta solamente file ASCII. Il suo formato di output è stato progettato per fornire i cambiamenti necessari per convertire il primo file nel secondo.

Sintassi

`diff [`opzioni`] `file1 file2``

Opzioni generali

`-b` | ignora spazi contigui
`-i` | ignora la differenza tra lettere minuscole e maiuscole
`-w` | ignora i caratteri di spazio e tab
`-e` | produce un formato di output da utilizzare con l'editor ed(1)
`-r` | esegue diff(1) ricorsivamente attraverso le sotto-directory

Esempi:

Per i file sopra citati `mon.logins` e `tues.logins`, le loro differenze sono:

`%` `diff mon.logins tues.logins` 2d1 < bsmith 4a4 > jdoe 7c7 < mschmidt --- > proy

Notare che l'output mostra sia l'elenco delle differenze sia in quale file queste esistono. Le linee del primo file sono precedute da < e quelle del secondo file sono precedute da >.

### 8.1.3. cut - seleziona parte di una linea di un file

Il comando cut(1) permette di estrarre una parte di un file che verrà utilizzata per un altro scopo.

Sintassi

`cut [`opzioni`] `file``

Opzioni generali

`-c `lista_caratteri`` | posizioni dei caratteri da selezionare (il primo carattere è in posizione 1)
`-d `delimitatore`` | delimitatore di campo (tab di default)
`-f `lista_campi`` | campi da selezionare (il primo campo è 1)

Sia la lista dei caratteri che quella dei campi possono contenere numeri (in ordine crescente) separati da virgole o da spazi bianchi e possono contenere un trattino (-) per indicare un range. La mancanza di un numero prima del trattino (esempio -5) o dopo il trattino (esempio 5-), specifica rispettivamente un range completo che inizia con il primo carattere o campo, o finisce con l'ultimo carattere o campo. I caratteri bianchi di separazione di lista devono essere chiusi tra caratteri di quoting. I campi di delimitazione possono essere chiusi tra quoting se hanno un significato speciale di shell, ad esempio quando specificano un carattere di tab o spazio.

Esempi:

In questi esempi si userà il file `users`:

jdoe John Doe 4/15/96 lsmith Laura Smith 3/12/96 pchen Paul Chen 1/5/96 jhsu Jake Hsu 4/17/96 sphilip Sue Phillip 4/2/96

Se si desidera solo lo username e il nome reale dell'utente, il comando cut(1) può essere usato per ottenere solamente queste informazioni:

`%` `cut -f 1,2 users` jdoe John Doe lsmith Laura Smith pchen Paul Chen jhsu Jake Hsu sphilip Sue Phillip

Il comando cut(1) può essere usato con altre opzioni. L'opzione `-c` permette di selezionare caratteri. Per selezionare i primi 4 caratteri:

`%` `cut -c 1-4 users`

che produrrà:

jdoe lsmi pche jhsu sphi

in questo modo si selezionano solamente i primi 4 caratteri di ogni linea.

### 8.1.4. paste - fusione di file

Il comando paste(1) permette di combinare insieme due file. In una fusione, il delimitatore di default tra le colonne è un tab, ma le opzioni permettono di usare altri delimitatori.

Sintassi

`paste [`opzioni`] `file1 file2``

Opzioni generali

`-d `lista`` | elenco dei caratteri di delimitazione
`-s` | concatena linee

L'elenco dei delimitatori può comprendere singoli caratteri come una virgola, una stringa quotata, uno spazio o alcune delle seguenti sequenze di escape:

\n | carattere newline
\t | carattere tab
\\ | carattere backslash
\0 | stringa vuota (carattere non-null)

Può essere necessario quotare i delimitatori che hanno significati speciali di shell.

Un trattino (-) al posto di un nome di file viene usato per indicare che quel campo dovrebbe venire da standard input.

Esempi:

Dato il file `users`:

jdoe John Doe 4/15/96 lsmith Laura Smith 3/12/96 pchen Paul Chen 1/5/96 jhsu Jake Hsu 4/17/96 sphilip Sue Phillip 4/2/96

e il file `phone`:

John Doe 555-6634 Laura Smith 555-3382 Paul Chen 555-0987 Jake Hsu 555-1235 Sue Phillip 555-7623

il comando paste(1) può essere usato in combinazione con il comando cut(1) per creare un nuovo file, `listing`, che include per tutti gli utenti lo username, il nome reale, l'ultimo login e il numero di telefono. Prima si estraggono i numeri di telefono all'interno del file temporaneo `temp.file`:

`%` `cut -f2 phone > temp.file` 555-6634 555-3382 555-0987 555-1235 555-7623

Il risultato può essere incollato alla fine di ogni linea di `users` e quindi rediretto nel nuovo file, `listing`:

`%` `paste users temp.file > listing` jdoe John Doe 4/15/96 237-6634 lsmith Laura Smith 3/12/96 878-3382 pchen Paul Chen 1/5/96 888-0987 jhsu Jake Hsu 4/17/96 545-1235 sphilip Sue Phillip 4/2/96 656-7623

Tutto questo può anche essere realizzato su una linea senza il file temporaneo, con lo stesso risultato:

`%` `cut -f2 phone | paste users - > listing`

In questo caso il trattino (-) funge come sostituto per il campo di input (indica cioè l'output del comando cut(1)).

### 8.1.5. touch - crea un file

Il comando touch(1) può essere usato per creare un nuovo (vuoto) file o per aggiornare l'ultima data/ora di accesso di un file esistente. Il comando viene usato primariamente quando uno script richiede la pre-esistenza di un file (ad esempio per appendere delle informazioni) o quando uno script controlla l'ultima data/ora in cui una funzione è stata realizzata.

Sintassi

`touch [`opzioni`] [`data/ora1`] `file``

`touch [`opzioni`] [-t `data/ora2`] `file``

Opzioni generali

`-a` | cambia la data/ora di accesso al file (solamente SVR4)
`-c` | non crea il file se non esiste
`-f` | forza l'azione, nonostante i permessi di lettura/scrittura del file
`-m` | cambia la data/ora di modifica del file (solamente SVR4)
`-t `data/ora2`` | usa la data/ora2 specificata, non la data/ora corrente (solamente SVR4)

Quando si usa l'opzione `-t `data/ora2``, deve essere nella forma:

[[`CC`]`YY`] `MMDDhhmm`[.`SS`]

dove:

`CC` | prime due cifre dell'anno
`YY` | seconde due cifre dell'anno
`MM` | mese, 01-12
`DD` | giorno del mese, 01-31
`hh` | ora del giorno, 00-23
`mm` | minuti, 00-59
`SS` | secondi, 00-59

Il formato dell'opzione ``data/ora1`` è:

``MMDDhhmm`[`YY`]`

dove questi simboli hanno gli stessi significati dei simboli mostrati in precedenza.

La data non può essere settata prima del 1969 o dopo il 18 Gennaio 2038 (dipende dalle versione del sistema operativo Unix).

Esempi:

Per creare un file:

`%` `touch `filename``

### 8.1.6. wc - conta le parole in un file

wc(1) sta per «conta parole»; il comando può essere usato per contare il numero di linee, di caratteri o di parole in un file.

Sintassi

`wc [`opzioni`] `file``

Opzioni generali

`-c` | conta byte
`-m` | conta caratteri (SVR4)
`-l` | conta linee
`-w` | conta parole

Se nessuna opzione viene specificata, l'opzione di default è `-lwc`.

Esempi:

Dato il file `users`:

jdoe John Doe 4/15/96 lsmith Laura Smith 3/12/96 pchen Paul Chen 1/5/96 jhsu Jake Hsu 4/17/96 sphilip Sue Phillip 4/2/96

il risultato dell'uso del comando wc(1) su tale file è il seguente:

`%` `wc users` 5 20 121 users

Il primo numero indica il numero di linee nel file, il secondo indica il numero di parole e il terzo numero indica il numero di caratteri.

Usando il comando wc(1) con una delle opzioni sopra citate (`-l` per linee; `-w` per parole o `-c` per caratteri) si ottiene come risultato solo una delle precedenti informazioni. Per esempio, `wc -l users` produce il risultato seguente:

5 users

### 8.1.7. ln - crea un link a un altro file

Il comando ln(1) crea un «link» (collegamento) o un modo aggiuntivo per accedere (o attribuisce un nome addizionale) a un altro file.

Sintassi

`ln [`opzioni`] `sorgente` [`destinazione`]`

Se non specificata, la ``destinazione`` di default è un file dello stesso nome di ``sorgente`` posto nella directory di lavoro corrente.

Opzioni generali

`-f` | forza un link nonostante i permessi della destinazione; non riporta errori (solamente SVR4 )
`-s` | crea un link simbolico

Esempi:

Un link simbolico viene usato per creare un nuovo percorso a un altro file o directory. Per esempio, se un gruppo di utenti è abituato ad usare un comando chiamato `chkmag`, ma il comando è stato riscritto e il nuovo nome è `chkit`, creando un link simbolico gli utenti eseguiranno automaticamente `chkit` quando digitano il comando `chkmag`, eliminando la transizione per il nuovo comando.

Un link simbolico può essere creato nel modo seguente:

`%` `ln -s chkit chkmag`

Ora il lungo listato per questi due file è il seguente:

16 -rwxr-x--- 1 lindadb acs 15927 Apr 23 04:10 chkit 1 lrwxrwxrwx 1 lindadb acs 5 Apr 23 04:11 chkmag -> chkit

Notare che mentre i permessi di `chkmag` sono aperti a tutti, poichè è linkato a `chkit`, le caratteristiche dei permessi, del gruppo e del proprietario di `chkit` saranno rispettate quando `chkmag` viene invocato.

Con un link simbolico, il link può esistere senza che il file o la directory a cui è collegato esista.

Un hard link può solamente essere creato per un altro file sullo stesso file system, ma non per una directory (eccetto per il super-user). Un hard link crea un nuovo elemento di directory puntante allo stesso inode del file originale. Il file linkato deve esistere prima che l'hard link possa essere creato. Il file non sarà cancellato fino a quando tutti gli hard link saranno rimossi. Per linkare i due file precedenti tramite un hard link:

`%` `ln chkit chkmag`

Quindi un lungo listato mostra che il numero di inode (742) è lo stesso per entrambi i file:

`%` `ls -il chkit chkmag` 742 -rwxr-x--- 2 lindadb acs 15927 Apr 23 04:10 chkit 742 -rwxr-x--- 2 lindadb acs 15927 Apr 23 04:10 chkmag

### 8.1.8. sort - ordina il contenuto di un file

Il comando sort(1) viene usato per ordinare le linee di un file. Si possono usare diverse opzioni per stabilire il modo di ordinamento e su quali campi ordinare il file. Senza opzioni, sort(1) confronta intere linee di un file e produce un ordinamento ASCII (prima i numeri, lettere maiuscole e quindi lettere minuscole).

Sintassi

`sort [`opzioni`] [+`pos1` [-`pos2`]] `file``

Opzioni generali

`-b` | ignora gli spazi bianchi iniziali (spazi e tab) quando si stabiliscono i carattere di inizio e di fine per la chiave di ordinamento
`-d` | ordinamento a dizionario, sono rilevanti solamente le lettere, le cifre, spazi e tab
`-f` | uguaglia lettere maiuscole e minuscole
`-k `chiave`` | ordinamento su chiavi specifiche (non disponibile su tutti i sistemi)
`-i` | ignora i caratteri non stampabili
`-n` | ordinamento numerico
`-o `outfile`` | file di output
`-r` | ribalta l'ordine
`-t `car`` | usa `car` come il carattere di separatore di campo
`-u` | unico; trascura multiple copie di linee uguali (dopo l'ordinamento)
`+`pos1` [-`pos2`]` | (vecchio stile) fornisce funzionalità simili all'opzione `-k `chiave``.

Per gli elementi di posizione (`+/-`), `pos1` è il numero di parola di inizio, iniziando da 0 e `pos2` è il numero di parola di fine. Quando -`pos2` non è specificato, il campo di ordinamento continua fino alla fine del file. Sia `pos1` che `pos2` possono essere specificati nella forma `w`.`c`, dove `w` è il numero di parola e `c` è il carattere all'interno della parola. Per c 0 si specifica il delimitatore che precede il primo carattere e 1 è il primo carattere della parola. Questi elementi possono essere seguiti da un tipo di modificatore, esempio n per numerico, b per saltare gli spazi bianchi ,ecc.

Il campo `chiave` dell'opzione `-k` ha la seguente sintassi:

`campo_inizio` [`tipo`] [ ,`campo_fine` [`tipo`] ]

dove:

`campo_inizio, campo_fine` | definiscono le chiavi per restringere l'ordinamento su una porzione di linea
`tipo` | modifica l'ordinamento: validi modificatori sono dati dai singoli caratteri (bdfiMnr) derivanti dalle simili opzioni di ordinamento, ad esempio un tipo b equivale a `-b`, ma applicato solamente nello specifico campo di azione

Esempi:

Dato il file `users`:

jdoe John Doe 4/15/96 lsmith Laura Smith 3/12/96 pchen Paul Chen 1/5/96 jhsu Jake Hsu 4/17/96 sphilip Sue Phillip 4/2/96

ordinando con sort(1) gli utenti si produce:

jdoe John Doe 4/15/96 jhsu Jake Hsu 4/17/96 lsmith Laura Smith 3/12/96 pchen Paul Chen 1/5/96 sphilip Sue Phillip 4/2/96

Se, tuttavia, si desidera un elenco in ordine di nome, si usa l'opzione per specificare su quale campo ordinare (i campi sono numerati partendo da 0):

`%` `sort +2 users` pchen Paul Chen 1/5/96 jdoe John Doe 4/15/96 jhsu Jake Hsu 4/17/96 sphilip Sue Phillip 4/2/96 lsmith Laura Smith 3/12/96

Per ribaltare l'ordine:

`%` `sort -r users` sphilip Sue Phillip 4/2/96 pchen Paul Chen 1/5/96 lsmith Laura Smith 3/12/96 jhsu Jake Hsu 4/17/96 jdoe John Doe 4/15/96

Un'opzione particolarmente utile di ordinamento è l'opzione `-u`, che elimina gli elementi duplicati nel file mentre si ordina il file. Per esempio, il file `todays.logins`:

sphillip jchen jdoe lkeres jmarsch ageorge lkeres proy jchen

mostra una lista di ogni username che ha effettuato il login nel sistema in giornata. Se si vuole conoscere quanti unici utenti abbiano effettuato il login nel sistema in giornata, usando sort(1) con l'opzione `-u`, la lista conterrà ciascun utente una volta sola. (Il comando può essere mandato in pipe a `wc -l` per ottenere direttamente il numero):

`%` `sort -u todays.logins` ageorge jchen jdoe jmarsch lkeres proy sphillip

### 8.1.9. tee - copia l'output di un comando

Il comando tee(1) manda lo standard input nel file specificato e anche nello standard output. Viene spesso usato in una pipe di comandi.

Sintassi

`tee [`opzioni`] [`file`]`

Opzioni generali

`-a` | appende l'output ai file
`-i` | ignora gli interrupt

Esempi:

In questo primo esempio l'output di who(1) è visualizzato sullo schermo e memorizzato nel file `users.file`:

brigadier: condron [55]> `who | tee users.file` condron ttyp0 Apr 22 14:10 (lcondron-pc.acs.) frank ttyp1 Apr 22 16:19 (nyssa) condron ttyp9 Apr 22 15:52 (lcondron-mac.acs)
brigadier: condron [56]> `cat users.file` condron ttyp0 Apr 22 14:10 (lcondron-pc.acs.) frank ttyp1 Apr 22 16:19 (nyssa) condron ttyp9 Apr 22 15:52 (lcondron-mac.acs)

Nel prossimo esempio l'output di who(1) viene mandato nei file `users.a` e `users.b`. Viene anche mandato in pipe con il comando wc(1), che riporta il numero di linee.

brigadier: condron [57]> `who | tee users.a users.b | wc -l` 3
brigadier: condron [58]> `cat users.a` condron ttyp0 Apr 22 14:10 (lcondron-pc.acs.) frank ttyp1 Apr 22 16:19 (nyssa) condron ttyp9 Apr 22 15:52 (lcondron-mac.acs)

Nell'esempio seguente un listato lungo di directory viene mandato nel file `files.long`. Inoltre viene messo in pipe con il comando grep(1) che riporta quali file sono stati modificati in Agosto.

brigadier: condron [60]> `ls -l | tee files.long |grep Aug` 1 drwxr-sr-x 2 condron 512 Aug 8 1995 News/ 2 -rw-r--r-- 1 condron 1076 Aug 8 1995 magnus.cshrc 2 -rw-r--r-- 1 condron 1252 Aug 8 1995 magnus.login
brigadier: condron [63]> `cat files.long` total 34 2 -rw-r--r-- 1 condron 1253 Oct 10 1995 #.login# 1 drwx------ 2 condron 512 Oct 17 1995 Mail/ 1 drwxr-sr-x 2 condron 512 Aug 8 1995 News/ 5 -rw-r--r-- 1 condron 4299 Apr 21 00:18 editors.txt 2 -rw-r--r-- 1 condron 1076 Aug 8 1995 magnus.cshrc 2 -rw-r--r-- 1 condron 1252 Aug 8 1995 magnus.login 7 -rw-r--r-- 1 condron 6436 Apr 21 23:50 resources.txt 4 -rw-r--r-- 1 condron 3094 Apr 18 18:24 telnet.ftp 1 drwxr-sr-x 2 condron 512 Apr 21 23:56 uc/ 1 -rw-r--r-- 1 condron 1002 Apr 22 00:14 uniq.tee.txt 1 -rw-r--r-- 1 condron 1001 Apr 20 15:05 uniq.tee.txt~ 7 -rw-r--r-- 1 condron 6194 Apr 15 20:18 Unixgrep.txt

### 8.1.10. uniq - rimuove linee duplicate

Il comando uniq(1) filtra le linee adiacenti duplicate in un file.

Sintassi

`uniq [`opzioni`] [+|-`n`] `file` [`nuovo.file`]`

Opzioni generali

`-d` | solo una copia delle linee ripetute
`-u` | seleziona solamente le linee non ripetute
`+`n`` | ignora i primi `n` caratteri
`-s `n`` | come sopra (solamente SVR4)
`-`n`` | salta i primi `n` campi, spazi inclusi (spazi e tab)
`-f `campi`` | come sopra (solamente SVR4)

Esempi:

Si consideri il seguente file e l'esempio, dove uniq(1) rimuove la quarta linea da `file` e mette il risultato nel file `nuovo.file`.

{Unix prompt 1} `cat file` 1 2 3 6 4 5 3 6 7 8 9 0 7 8 9 0
{Unix prompt 2} `uniq file nuovo.file`
{Unix prompt 3} `cat nuovo.file` 1 2 3 6 4 5 3 6 7 8 9 0

Qui sotto, l'opzione `-`n`` del comando uniq(1) viene usata per saltare i primi 2 campi nel file e per filtrare le linee di uscita che sono duplicate dal terzo campo in avanti.

{Unix prompt 4} `uniq -2 file` 1 2 3 6 7 8 9 0

### 8.1.11. strings - cerca stringhe ASCII

Per cercare stringhe ASCII, stampabili, in un file binario si usa il comando strings(1). Questo comando ricerca sequenze di quattro o più caratteri ASCII terminanti con un carattere newline o con un carattere null. strings(1) risulta utile per ricercare nomi di file e possibili messaggi di errore all'interno di un programma compilato, di cui non si ha il codice sorgente.

Sintassi

`strings [`opzioni`] `file``

Opzioni generali

`-n `numero`` | usa `numero` come la minima lunghezza della stringa, piuttosto di 4 (solamente SVR4)
`-``numero` | come sopra
`-t `formato`` | fa precedere alla stringa l'offset di byte dall'inizio del file; `formato` può essere: d = decimale, o = ottale x = esadecimale (solamente SVR4)
`-o` | fa precedere alla stringa l'offset di byte in decimale (solamente BSD)

Esempi:

`%` `strings /bin/cut` SUNW_OST_OSCMD nessun delimitatore specificato delimitatore non valido b:c:d:f:ns cut: -n può solo essere usato con -b cut: -d può solo essere usato con -f cut: -s può solo essere usato con -f nessuna lista specificata cut: %s non si riesce ad aprire il range specificato non è valido troppi range specificati i range devono essere crescenti carattere non valido nel range Errore interno nel processare l'input carattere multibyte non valido incapace di allocare memoria sufficiente incapace di allocare memoria sufficiente cut: uso: cut -b lista [-n] [filename ...] cut -c lista [filename ...] cut -f lista [-d delim] [-s] [filename]

### 8.1.12. file - mostra il tipo di file

Il comando file(1) esamina il file specificato e cerca di determinare che tipo di file esso sia. Questo viene fatto leggendo i primi byte del file e confrontandoli con la tabella `/etc/magic`. Il comando file(1) può determinare file di testo ASCII, file formattati tar, file compressi, ecc.

Sintassi

`file [`opzioni`] [-m `file_magico`] [-f `lista_file`] `file``

Opzioni generali

`-c` | verifica il file magico per eventuali errori nel formato
`-f `lista_file`` | ``lista_file`` contiene la lista dei file da esaminare
`-h` | non segue i link simbolici (solamente SVR4)
`-L` | segue i link simbolici (solamente BSD)
`-m `file_magico`` | usa ``file_magico`` come il file magico al posto di `/etc/magic`

Esempi:

Vengono elencati qui sotto gli output del comando `file `filename`` per alcuni file significativi.

/etc/magic: File di testo ascii /usr/local/bin/gzip: Eseguibile paginato SPARC Sun linkato dinamicamente /usr/bin/cut: Eseguibile MSB a 32 bit ELF per SPARC versione 1, linkato dinamicamente, stripped source.tar: Archivio tar USTAR source.tar.Z: Blocchi di dati compressi 16 bit

### 8.1.13. tr - traduce caratteri

Il comando tr(1) traduce caratteri da stdin(4) a stdout(4).

Sintassi

`tr [`opzioni`] `stringa1` [`stringa2`]`

Con nessuna opzione i caratteri di `stringa1` sono tradotti nei caratteri di `stringa2`, carattere per carattere, nell'ordine degli array di stringa. Il primo carattere di `stringa1` viene tradotto nel primo carattere di `stringa2`, ecc.

Un range di caratteri in una stringa viene specificato con un trattino tra il carattere superiore e quello inferiore del range, ad esempio per specificare tutte le lettere alfabetiche minuscole si usa [a-z].

Ripetizioni di caratteri in `stringa2` possono essere rappresentate con la notazione [`x`*`n`], dove il carattere `x` viene ripetuto `n` volte. Se `n` è 0 o assente, il carattere `x` viene assunto come valida corrispondenza richiesta in `stringa1`.

I caratteri possono includere le notazioni \`ottale` (BSD e SVR4) e \`carattere` (solamente SVR4). Qui `ottale` viene sostituito da una, due o tre cifre di interi ottali che codificano un carattere ASCII e `carattere` può essere uno di questi:

b | back space
f | form feed
n | newline
r | return
t | tab
v | tab verticale

La versione SVR4 di tr(1) permette l'operando :`classe`: nel campo stringa dove `classe` può assumere uno dei seguenti valori di classificazione carattere:

alpha | caratteri alfabetici
lower | caratteri alfabetici minuscoli
upper | caratteri alfabetici maiuscoli

Opzioni generali

`-c` | completa il set di caratteri in `stringa1`
`-d` | cancella i caratteri in `stringa1`
`-s` | modifica una stringa di caratteri ripetuti in `stringa1` in caratteri singoli

Esempi:

L'esempio seguente usa come file di input una lista di libri di P. G. Wodehouse Jeeves & Wooster.

The Inimitable Jeeves [1923] The Mating Season [1949] Carry On, Jeeves [1925] Ring for Jeeves [1953] Very Good, Jeeves [1930] Jeeves and the Feudal Spirit [1954] Thank You, Jeeves [1934] Jeeves in the Offing [1960] Right Ho, Jeeves [1934] Stiff Upper Lip, Jeeves [1963] The Code of the Woosters [1938] Much Obliged, Jeeves [1971] Joy in the Morning [1946] Aunts Aren't Gentlemen [1974]

Per tradurre tutte le lettere alfabetiche minuscole in maiuscole si possono usare:

`tr '[a-z]' '[A-Z]'`

oppure

`tr '[:lower:]' '[:upper:]'`

Affinchè tr(1) legga da stdin(4) si usa cat(1) in pipe con tr(1), così:

`%` `cat wodehouse | tr '[a-z]' '[A-Z]'` THE INIMITABLE JEEVES [1923] THE MATING SEASON [1949] CARRY ON, JEEVES [1925] RING FOR JEEVES [1953] VERY GOOD, JEEVES [1930] JEEVES AND THE FEUDAL SPIRIT [1954] THANK YOU, JEEVES [1934] JEEVES IN THE OFFING [1960] RIGHT HO, JEEVES [1934] STIFF UPPER LIP, JEEVES [1963] THE CODE OF THE WOOSTERS [1938] MUCH OBLIGED, JEEVES [1971] JOY IN THE MORNING [1946] AUNTS AREN'T GENTLEMEN [1974]

Ora si cancellano tutti i numeri con:

`%` `cat wodehouse | tr -d '[0-9]'` The Inimitable Jeeves [] The Mating Season [] Carry On, Jeeves [] Ring for Jeeves [] Very Good, Jeeves [] Jeeves and the Feudal Spirit [] Thank You, Jeeves [] Jeeves in the Offing [] Right Ho, Jeeves [] Stiff Upper Lip, Jeeves [] The Code of the Woosters [] Much Obliged, Jeeves [] Joy in the Morning [] Aunts Aren't Gentlemen []

Per trattenere tutte le occorrenze multiple dei caratteri e, r e f:

`%` `cat wodehouse | tr -s 'erf'` The Inimitable Jeves [1923] The Mating Season [1949] Cary On, Jeves [1925] Ring for Jeves [1953] Very Good, Jeves [1930] Jeves and the Feudal Spirit [1954] Thank You, Jeves [1934] Jeves in the Ofing [1960] Right Ho, Jeves [1934] Stif Upper Lip, Jeves [1963] The Code of the Woosters [1938] Much Obliged, Jeves [1971] Joy in the Morning [1946] Aunts Aren't Gentlemen [1974]

### 8.1.14. find - cerca file

Il comando find(1) può cercare file in modo ricorsivo nell'albero di directory indicato, confrontando il tipo di file o lo schema specificato. find(1) può quindi elencare i file o eseguire arbitrari comandi in base ai risultati.

Sintassi

`find `directory` [`opzioni di ricerca`] [`azioni`]`

Opzioni generali

Per l'opzione del tempo di ricerca, la notazione in giorni, n è:

`+`n`` | più di `n` giorni
`n` | esattamente `n` giorni
`-`n`` | meno di `n` giorni

Alcune caratteristiche dei file che find(1) può ricercare sono:

la data dell'ultimo accesso o dell'ultima modifica al file:

`-atime `n`` | data di accesso, vero se l'accesso è di `n` giorni fà
`-ctime `n`` | data di cambiamento, vero se lo stato del file è stato modificato `n` giorni fà
`-mtime `n`` | data di modifica, vero se i dati del file sono stati modificati `n` giorni fà
`-newer `filename`` | vero se più recente del file specificato
`-type `tipo`` | tipo di file, dove `tipo` può essere:
b | file speciale a blocchi
c | file speciale a caratteri
d | directory
l | link simbolico
p | file pipe (fifo)
f | file regolare
`-fstype `tipo`` | tipo di file system, dove `tipo` può essere un valido tipo di file system, esempio ufs (Unix File System) e nfs (Network File System)
`-user `username`` | vero se il file appartiene all'utente specificato
`-group `groupname`` | vero se il file appartiene al gruppo specificato
`-perm [-]`modi`` | permessi del file, dove `modi` è la modalità ottale usata dal comando chmod(1). Quando `modi` è preceduto da un segno meno, solamente i bit che sono specificati vengono confrontati.
`-exec `comando`` | esegue il comando specificato. La fine del comando viene indicata con un escape e punto e virgola (\;). L'argomento del comando, {}, sostituisce il path name corrente.
`-name `filename`` | vero se il nome del file è quello specificato. Confronti con schemi wild card sono permessi se il meta-carattere viene messo in escape per la shell con un backslash (\)
`-ls` | sempre vero. Stampa una lista lunga del path name corrente
`-print` | stampa i path name trovati (default per SVR4, non per BSD)

Sono permesse espressioni complesse. Le espressioni devono essere raggruppate tra parentesi (mettendo in escape le parentesi con un backslash per impedire alla shell di interpretarle). Il simbolo di esclamazione (!) può essere usato per negare un'espressione. Gli operatori: `-a` (and) e `-o` (or) vengono usati per raggruppare espressioni.

Esempi:

find(1) può ricercare in modo ricorsivo attraverso sotto-directory, ma per lo scopo di questi esempi saranno usati i seguenti file:

14 -rw-r--r-- 1 frank staff 6682 Feb 5 10:04 library 6 -r--r----- 1 frank staff 3034 Mar 16 1995 netfile 34 -rw-r--r-- 1 frank staff 17351 Feb 5 10:04 standard 2 -rwxr-xr-x 1 frank staff 386 Apr 26 09:51 tr25*

Per trovare tutti i file più recenti del file `library`:

`%` `find . -newer library -print` ./tr25 ./standard

Per trovare tutti i file con i permessi di lettura o esecuzione per l'utenza altri e quindi modificare gli stessi in modo da disabilitarli:

`%` `find . \( -perm -004 -o -perm -001 \) -exec chmod o-rx {} \; -exec ls -al {} \;` -rw-r----- 1 frank staff 6682 Feb 5 10:04 ./library -rwxr-x--- 1 frank staff 386 Apr 26 09:51 ./tr25 -rw-r----- 1 frank staff 17351 Feb 5 10:04 ./standard

Nell'esempio precedente le parentesi e i punti e virgola sono messi in escape con un backslash per impedire alla shell di interpretarli. Le parentesi graffe sono automaticamente rimpiazzate dai risultati della precedente ricerca e il punto e virgola chiude il comando.

Si possono ricercare alcuni nomi di file contenenti la stringa «ar» con:

`%` `find . -name \*ar\* -ls` 326584 7 -rw-r----- 1 frank staff 6682 Feb 5 10:04 ./library 326585 17 -rw-r----- 1 frank staff 17351 Feb 5 10:04 ./standard

dove l'opzione `-ls` mostra un listato lungo, numeri di inode inclusi.

Indietro |  | Avanti
7.2. Comandi di manipolazione del testo | Partenza | 8.2. Archiviazione, compressione e conversione di file

Questo, ed altri documenti, possono essere scaricati da ftp://ftp.FreeBSD.org/pub/FreeBSD/doc/

Per domande su FreeBSD, leggi la documentazione prima di contattare <questions@FreeBSD.org>.
Per domande su questa documentazione, invia una e-mail a <doc@FreeBSD.org>.