[successivo] [precedente] [inizio] [fine] [indice generale] [indice ridotto] [translators] [docinfo] [indice analitico] [volume] [parte]
Un file di testo è quello che può essere letto così com'è senza bisogno di interpretazioni particolari. Il modo con cui questo file viene definito chiarisce anche il tipo di contenuto che questo può avere: testo puro, senza altre informazioni.
I file di testo sono una sequenza di caratteri e simboli, separata convenzionalmente in righe di lunghezze diseguali, che così devono essere terminate attraverso un codice particolare: quello che qui viene definito codice di interruzione di riga.
La tabella 130.1 elenca i programmi a cui si accenna in questo capitolo.
|
Tabella 130.1. Riepilogo dei programmi per la gestione dei file di testo.
|
Questo codice di interruzione di riga cambia a seconda del sistema operativo. Negli ambienti Unix si usa il codice 0A16 che viene chiamato <LF>, negli ambienti Dos e derivati si utilizza la sequenza 0D0A16 corrispondente a <CR><LF>, mentre negli ambienti MAC si usa il codice 0D16 corrispondente a <CR>.
Quando si vuole fare riferimento al codice di interruzione di riga in modo astratto, cioè senza restare legati a un'architettura particolare del sistema operativo, si parla spesso di newline. La convenzione per cui il termine newline dovrebbe rappresentare idealmente ciò che si utilizza per interrompere una riga, non viene rispettata sempre. Generalmente, chi lavora con i sistemi Unix ignora il problema e utilizza il termine newline per identificare il carattere <LF>, che invece ha un nome preciso: line feed.
Utilizzando un sistema GNU, il problema derivato da questa ambiguità non si manifesta; tuttavia, leggendo i documenti che utilizzano questa espressione, occorre fare attenzione, o almeno è il caso di porsi il dubbio sul significato di ciò che si intende. Pertanto, in questo documento si utilizza la definizione «codice di interruzione di riga», in modo da non lasciare dubbi.
Nei file di testo, gli spazi sono un concetto prettamente visivo: quando si visualizza (o si stampa) un file si notano delle zone in cui non appaiono caratteri di alcun tipo.
I caratteri attraverso i quali si ottengono questi spazi sono normalmente: lo spazio vero e proprio (3016), la tabulazione (0916) e il codice di interruzione di riga.
Il modo con cui si ottiene una spaziatura dipende dal contesto. Ciò che conta è sapere distinguere tra spazio in senso generale e carattere spazio che è invece un codice particolare.
A volte si utilizza il termine blank, o spazio lineare, per indicare uno spazio in senso generale, dove di norma si intende fare riferimento indifferentemente a un numero imprecisato di caratteri spazio o tabulazione.
Il codice di interruzione di riga entra in gioco quando si ha a che fare con righe vuote. Una riga di questo tipo può contenere spazi di vario genere (spazio e tabulazione) e poi deve essere conclusa da questo codice. Ma una riga vuota, blank line, può essere veramente vuota e contenere soltanto il codice di interruzione di riga.
I programmi descritti in questo capitolo, quando sono di origine GNU (si riconoscono facilmente perché permettono di utilizzare opzioni descrittive e non solo quelle composte da una sola lettera), accettano le opzioni seguenti:
Generalmente, se ciò può avere senso, quando non viene fornito alcun file negli argomenti, si intende utilizzare lo standard input.
Alcuni programmi per l'elaborazione di file di testo emettono lo stesso file fornito come input, eventualmente dopo un qualche tipo di elaborazione elementare.
Il più semplice di questi programmi è cat che nella maggior parte dei casi viene utilizzato senza opzioni, per lo più con lo scopo di iniziare un condotto di programmi.
Il programma di servizio cat (1) emette di seguito i file indicati come argomento attraverso lo standard output, in pratica qualcosa di simile al comando TYPE del Dos:
cat [opzioni] [file...] |
|
Tabella 130.3. Alcune opzioni. |
Il programma di servizio tac (2) emette attraverso lo standard output i file forniti come argomento, invertendo l'ordine delle righe:
tac [opzioni] [file...] |
Queste righe possono essere divise in base a un codice di interruzione di riga diverso dal solito, specificandolo attraverso l'opzione -s. In pratica, tac è l'inverso di cat.
Il programma di servizio nl (3) emette attraverso lo standard output il contenuto dei file forniti come argomento con l'aggiunta dei numeri di riga per alcune o tutte le righe dell'input:
nl [opzioni] [file...] |
Il conteggio delle righe viene fatto unendo i file forniti come argomento, come se si trattasse di un file unico, azzerandolo ogni volta che viene riconosciuto l'inizio di una pagina logica. Sotto questo punto di vista, una pagina logica è composta da tre parti: testa, corpo e piede.
In condizioni normali, salvo altre indicazioni passate attraverso le opzioni, si individua la testa, il corpo e il piede, perché preceduti da una riga che contiene esattamente una stringa speciale:
|
prima della testa;
|
prima del corpo;
|
prima del piede.
Per mostrare semplicemente il funzionamento del programma, viene proposto un file di testo puro contenente esattamente le righe seguenti:
|
Supponendo che il file abbia il nome prova.txt, ecco cosa si ottiene con il comando seguente:
$ nl prova.txt[Invio]
intestazione 1
intestazione 2
intestazione 3
1 corpo 1
2 corpo 2
3 corpo 3
4 corpo 4
5 corpo 5
piede 1
piede 2
piede 3
intestazione 4
intestazione 5
intestazione 6
1 corpo 6
2 corpo 7
3 corpo 8
4 corpo 9
5 corpo 10
piede 4
piede 5
piede 6
|
Si osservi in particolare che la prima riga è vuota, perché nel file di origine si trova in quella posizione la stringa di riconoscimento dell'inizio della testa.
Si veda eventualmente il documento info nl oppure la pagina di manuale nl(1).
Il programma di servizio od (4) converte i file forniti come input in ottale o in altri formati.
Si veda eventualmente il documento info od oppure la pagina di manuale od(1).
Il programma di servizio rev (5) emette attraverso lo standard output il file fornito come argomento, invertendo l'ordine dei caratteri di ogni riga:
rev [file...] |
Il programma di servizio dog (6) è una rivisitazione di cat, a cui aggiunge in particolare la possibilità di accedere a URI esterni:
dog [opzioni] [-|file|uri]... |
Vengono mostrati alcuni esempi.
$ dog prova.txt[Invio]
Legge il file prova.txt ed emette il suo contenuto attraverso lo standard output.
$ dog http://a2.brot.dg/prova.html[Invio]
Preleva una copia di http://a2.brot.dg/prova.html ed emette l'esito attraverso lo standard output. La parte iniziale di ciò che si ottiene potrebbe apparire così:
HTTP/1.0 200 OK Date: Tue, 21 Mar 2006 16:46:00 GMT Server: Apache/2.0.54 (Debian GNU/Linux) PHP/4.3.10-16 Last-Modified: Wed, 15 Mar 2006 07:36:51 GMT ETag: "4d9a3f-3222-a39aeac0" Accept-Ranges: bytes Content-Length: 12834 Connection: close Content-Type: text/html <!DOCTYPE HTML PUBLIC "ISO/IEC 15445:2000//DTD HTML//EN"> <HTML LANG="it"> ... |
$ dog --no-header http://a2.brot.dg/prova.html > prova.html[Invio]
Preleva una copia di http://a2.brot.dg/prova.html e la salva nel file prova.html. L'uso dell'opzione --no-header serve a ottenere il file originale, senza l'aggiunta dell'intestazione che fa parte del protocollo HTTP.
Si veda la pagina di manuale dog(1).
Alcuni programmi si occupano di modificare l'impaginazione del testo, cambiandone la larghezza o aggiungendo delle intestazioni.
Il programma di servizio fmt (7) formatta il testo contenuto nei file forniti come argomento, eliminando e aggiungendo codici di interruzione di riga, in modo che il testo risulti al massimo di una data larghezza:
fmt [opzioni] [file...] |
Il risultato viene emesso attraverso lo standard output. Se non si specifica l'ampiezza massima della riga, questa si intende essere di 75 caratteri.
A titolo di esempio, si suppone che il file prova.txt contenga esattamente il testo seguente:
|
Con fmt si ottiene la rimpaginazione dei due blocchi:
$ fmt prova.txt[Invio]
bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla |
|
Si veda eventualmente il documento info fmt oppure la pagina di manuale fmt(1).
Il programma di servizio pr (8) emette attraverso lo standard output il contenuto dei file forniti come argomento, formattati opportunamente per la stampa:
pr [opzioni] [file...] |
Se non viene indicato diversamente attraverso le opzioni:
viene aggiunta un'intestazione di cinque righe, dove la terza di queste contiene l'informazione della data e dell'ora di stampa e anche del numero di pagina;
viene aggiunto un piede di pagina di quattro righe bianche;
il numero di righe per pagina è di 66;
il carattere <FF> che fosse contenuto eventualmente nei file di input, genera un salto pagina.
Nel caso si utilizzino più colonne:
le colonne hanno la stessa larghezza;
sono separate da una stringa opzionale (il cui valore predefinito è uno spazio);
le righe vengono troncate al raggiungimento della larghezza massima della colonna.
Vedere info pr oppure pr(1).
|
Tabella 130.14. Alcune opzioni.
|
Si veda eventualmente il documento info pr oppure la pagina di manuale pr(1).
Il programma di servizio fold (9) formatta il testo contenuto nei file forniti come argomento, suddividendo le righe troppo lunghe inserendo un codice di interruzione di riga al raggiungimento della colonna 80 (se non viene specificato diversamente attraverso le opzioni):
fold [opzioni] [file...] |
Il conteggio viene fatto tenendo conto dei caratteri di tabulazione come se fossero espansi, dei codici di backspace (<BS>) che diminuiscono il conteggio e dei caratteri di ritorno a carrello (<CR>) che azzerano il conteggio.
|
Tabella 130.15. Alcune opzioni.
|
Il programma di servizio column (10) trasforma l'input rappresentato dai file indicati come argomento in modo da ottenere più colonne. Il risultato viene emesso attraverso lo standard output:
column [opzioni] [file...] |
|
Tabella 130.16. Alcune opzioni.
|
Il programma di servizio colrm (11) elimina un intervallo di colonne da un file di testo:
colrm [colonna_iniziale] [colonna_finale] |
Le colonne sono espresse in caratteri. L'input è ottenuto dallo standard input e l'output viene emesso attraverso lo standard output. Se vengono omessi gli attributi, non viene eliminato alcunché. Se manca l'indicazione della colonna finale, l'eliminazione avviene a partire dalla colonna iniziale indicata fino alla fine della riga.
Segue la descrizione di alcuni esempi.
$ colrm 1 10 < documento.txt > tagliato.txt[Invio]
Vengono eliminati i primi 10 caratteri di ogni riga del file documento.txt e il risultato viene emesso in tagliato.txt.
$ colrm 81 < documento > normale.txt[Invio]
Le righe che superano gli 80 caratteri vengono tagliate.
Un tipo di file di testo è quello che contiene codici speciali di spostamento allo scopo di ottenere un aspetto particolare quando questo viene stampato. Il codice più usato in questo senso è <BS> (backspace) che normalmente viene interpretato come arretramento di una posizione. Gli effetti che si possono ottenere in questo modo sono il sottolineato e il neretto. Per esempio, per ottenere la parola «CIAO» in neretto, si utilizza una sequenza del tipo:
C<BS>CI<BS>IA<BS>AO<BS>O.
Alcuni tipi di file di testo possono contenere codici di spostamento in avanti o indietro. Alcuni di questi codici possono risultare inadatti alle unità per la visualizzazione o per la stampa, oppure possono essere disposti in modo disordinato.
Il programma di servizio col (12) emette attraverso lo standard output una trasformazione dello standard input, in modo che questo contenga solo codici per l'avanzamento di riga in avanti.
|
Tabella 130.17. Alcune opzioni.
|
L'esempio seguente trasforma il risultato di ls(1) in un file di testo normale, che viene memorizzato in /tmp/ls1.txt:
$ man 1 ls | col -bx > /tmp/ls1.txt[Invio]
Il programma di servizio colcrt (13) emette attraverso lo standard output una trasformazione dei file indicati come argomento, in modo da permettere la visualizzazione o la stampa di testi contenenti codici di spostamento di mezza riga:
colcrt [opzioni] [file...] |
In pratica, i caratteri che dovrebbero apparire stampati in una mezza riga successiva, vengono spostati nella riga (intera) successiva. Il suo funzionamento è simile a quello del programma col, ma è orientato particolarmente all'emissione di un output adatto allo schermo di un terminale.
|
Tabella 130.18. Alcune opzioni.
|
Il programma di servizio ul, (14) il cui nome sta per underline, permette di trasformare un file contenente codici di arretramento, usati per ottenere evidenziamenti e sottolineature, in modo da poterlo visualizzare correttamente in base al tipo di terminale che risulta dalla configurazione (la variabile di ambiente TERM):
ul [opzioni] [file...] |
Per comprendere il senso di questo programma, si può ridirigere su un file il risultato della lettura di una pagina di manuale:
$ man 1 ul > /tmp/ul.txt[Invio]
Se si osserva il file /tmp/ul.txt ottenuto, si può vedere che contiene dei codici di arretramento (<BS>), con lo scopo di ottenere un carattere di spessore maggiore (più nero, o più illuminato, a seconda del modo con cui il terminale funziona normalmente):
|
Se si invia questo file, così come si vede, allo schermo, non si ottiene alcun evidenziamento:
$ cat /tmp/ul.txt[Invio]
Se invece si utilizza ul, lo si vede come dovrebbe (purché il terminale sia in grado di farlo):
$ ul /tmp/ul.txt[Invio]
Eventualmente si può consultare la pagina di manuale ul(1).
Alcuni programmi si occupano di estrarre dall'input solo alcune porzioni, o solo delle informazioni riepilogative, o ancora di suddividere l'input in parti più piccole. In particolare, head, tail e split, condividono un'opzione che permette di definire una dimensione in byte, che può fare uso di un moltiplicatore, in base a quanto indicato dalla tabella 130.20.
|
Tabella 130.20. Moltiplicatori utilizzati da head, tail e split.
|
Il programma di servizio head (15) emette attraverso lo standard output la prima parte (le prime 10 righe se non viene specificato diversamente con le opzioni) dei file forniti come argomento:
head [opzioni] [file...] |
|
Tabella 130.21. Alcune opzioni.
|
Il programma di servizio tail (16) emette attraverso lo standard output la parte finale (le ultime 10 righe se non viene specificato diversamente con le opzioni) dei file forniti come argomento:
tail [opzioni] [file...] |
|
Tabella 130.22. Alcune opzioni.
|
L'esempio seguente legge la parte finale del file /var/log/messages e continua a farlo in attesa di aggiunte al file, inviando quanto ottenuto al dispositivo /dev/tty10. Il processo viene messo opportunamente sullo sfondo in modo da liberare il terminale.
# tail -f /var/log/messages > /dev/tty10 &[Invio]
Il programma di servizio split (17) suddivide il contenuto del file fornito come argomento in porzioni ordinate, di una lunghezza massima definita (di solito 1 000 righe):
split [opzioni] [file [prefisso]] |
I file che vengono generati hanno il prefisso indicato nell'argomento (oppure x se non viene specificato), seguito da una coppia di lettere che cambiano secondo una sequenza ordinata: aa, ab, ac,... Pertanto, i nomi ottenuti possono essere ordinati nello stesso modo con cui il file originale è stato suddiviso.
|
Tabella 130.23. Alcune opzioni.
|
Il programma di servizio csplit (18) serve a suddividere un file in più parti, secondo uno o più modelli. Ogni modello indicato alla fine della riga di comando, specifica l'inizio di una nuova porzione di file che si vuole ottenere:
csplit [opzioni] file modello... |
Il modello in questione può essere rappresentato da un numero, che esprime la quantità di righe da contare, per determinare l'inizio della porzione successiva, oppure da un'espressione regolare, che, a seconda della delimitazione, può anche servire a eliminare una porzione di file.
Salvo indicazione diversa, csplit genera una serie di file secondo il modello xxnn; in pratica, si tratta di una serie di file il cui nome inizia con due «x» e termina con un numero di due cifre. In particolare, con l'opzione -f è possibile stabilire un prefisso diverso da queste due «x».
Come accennato, ogni modello può essere rappresentato da un numero, o da un'espressione regolare, ma in più, può essere aggiunto un simbolo speciale che ne rappresenta la ripetizione, per permettere l'indicazione dello stesso modello per più porzioni del file:
modello [{n_ripetizioni|*}]
|
Come si vede dallo schema sintattico, l'indicazione eventuale delle ripetizioni è racchiuso tra parentesi graffe, che quindi fanno parte del comando. Quando si vogliono indicare tali parentesi graffe, è probabile che si debbano proteggere dall'interpretazione della shell. Vengono descritte di seguito le varie forme dei modelli che possono essere indicati, assieme a una spiegazione sull'uso del simbolo di ripetizione.
Tenendo conto che dovrebbe trattarsi di un programma di servizio GNU, le espressioni regolari vanno espresse secondo le convenzioni GNU. Per la precisione, vengono utilizzate le espressioni regolari estese (ERE). A questo proposito è conveniente leggere i capitoli 479 e 480.
n_righe |
Un numero puro e semplice, indica di concludere la porzione di file in corso all'n-esima riga.
/espressione_regolare/[scostamento] |
Un'espressione regolare racchiusa tra due barre oblique normali, serve a indicare la riga di inizio che deve appartenere alla prossima porzione di file. In pratica, la riga per la quale si avvera la corrispondenza, è la prima della porzione di file successiva. Se dopo la seconda barra obliqua si indica un numero preceduto da un segno + o da un segno -, significa che si vuole indicare uno scostamento da quel punto, espresso in caratteri: uno scostamento positivo sposta l'inizio dopo n caratteri dall'inizio della riga trovata; uno scostamento negativo, sposta l'inizio all'indietro di n caratteri.
%espressione_regolare%[scostamento] |
Un'espressione regolare racchiusa tra due simboli di percentuale, fa in modo che la porzione successiva, il cui inizio viene identificato attraverso l'espressione regolare stessa, non viene inserito in un file. In pratica, questa parte viene ignorata semplicemente. L'indicazione eventuale dello scostamento si comporta nello stesso modo già visto per il caso precedente.
{n}
|
{*}
|
Il simbolo di ripetizione fa in modo che il modello precedente venga ripetuto n volte, oppure, se si usa un asterisco, tante volte quante ne servono a completare la scansione del file in ingresso.
|
Tabella 130.24. Alcune opzioni. |
Segue la descrizione di alcuni esempi.
$ csplit elenco 10[Invio]
Legge il file elenco generando il file xx00 con le prime 10 righe di questo, quindi il file xx01 con le righe restanti.
$ csplit elenco 10 \{0\}[Invio]
Questo esempio serve a mostrare l'uso del simbolo di ripetizione: in questo caso, {0}, con le parentesi graffe debitamente protette, non ha effetto e il risultato è lo stesso dell'esempio precedente.
$ csplit elenco 10 \{1\}[Invio]
Legge il file elenco generando il file xx00 con le prime 10 righe di questo, il file xx01 con le 10 righe successive e il file xx02 con le righe restanti.
$ csplit -f prova elenco 10 \{1\}[Invio]
Come nell'esempio precedente, con la differenza che i file generati iniziano per prova*.
$ csplit -f prova elenco '/Pagina [0-9]*/' \{\*\}[Invio]
Suddivide il file prova, in modo che ogni porzione inizi con una riga corrispondente all'espressione regolare Pagina [0-9]*. La ricerca della corrispondenza dell'espressione regolare avviene per tutte le righe disponibili, in base alla presenza del simbolo di ripetizione indefinita: {*}. I file generati hanno tutti la radice prova.
Il programma di servizio wc (19) emette attraverso lo standard output la statistica sul conteggio dei codici di interruzione di riga (in pratica il numero delle righe), delle parole e dei byte:
wc [opzioni] [file...] |
Se attraverso le opzioni vengono specificati uno o due tipi di conteggio, quelli che non sono indicati espressamente non vengono emessi.
|
Tabella 130.25. Alcune opzioni. |
Alcuni programmi si occupano di riordinare file o di utilizzare file ordinati. L'ordinamento, la fusione, l'eliminazione degli elementi doppi e la ricerca binaria, rientrano in questo concetto.
Il programma di servizio sort (20) permette di ordinare o fondere insieme (merge) il contenuto dei file:
sort [opzioni] [file...] |
Sono disponibili tre modalità di funzionamento:
ordinamento (è la modalità predefinita);
controllo dell'ordinamento;
fusione.
Il risultato dell'ordinamento o della fusione, viene emesso attraverso lo standard output se non si specifica diversamente attraverso le opzioni.
|
Tabella 130.26. Opzioni riferite alla modalità di funzionamento.
|
|
Tabella 130.27. Opzioni riferite al tipo di ordinamento.
|
|
Tabella 130.28. Altre opzioni. |
Segue la descrizione di alcuni esempi.
$ sort /etc/passwd[Invio]
Riordina il file /etc/passwd a partire dalla prima colonna; in pratica, dal momento che si tratta del file che contiene le informazioni sulle utenze del sistema, lo riordina in base al nominativo di ognuna di queste (il primo campo).
$ sort -t : -k 1,1 /etc/passwd[Invio]
L'effetto di questo comando è praticamente identico a quello precedente, con la differenza che viene dichiarato esplicitamente l'intervento nel primo campo del file (come è noto, il file /etc/passwd è diviso in campi separati dai due punti verticali).
$ sort -n -t : -k 3,3 /etc/passwd[Invio]
Riordina il file già descritto, usando il terzo campo come chiave. In particolare, utilizza un ordinamento di tipo numerico, dal momento che il campo in questione rappresenta il numero UID di ogni utenza.
$ sort -m primo secondo > terzo[Invio]
Fonde assieme i due file primo e secondo, già ordinati in precedenza, generando il file terzo.
$ sort -u -m primo secondo > terzo[Invio]
Come nell'esempio precedente, ma in questo caso, il file che viene generato non contiene righe doppie.
Si veda eventualmente il documento info sort oppure la pagina di manuale sort(1).
Il programma di servizio uniq (21) filtra il contenuto dei file ed emette solo le righe uniche. Il file fornito come input deve essere ordinato:
uniq [opzioni] [file_in_ingresso [file_in_uscita]] |
Si veda eventualmente il documento info uniq oppure la pagina di manuale uniq(1).
Il programma di servizio comm (22) confronta due file ordinati ed emette attraverso lo standard output l'indicazione delle righe uniche nel primo e nel secondo file, oltre alle righe che i due file hanno in comune:
comm [opzioni] [file1] file2 |
Se non vengono specificate delle opzioni, viene emesso un risultato su tre colonne: la prima contiene le righe uniche del primo file, la seconda le righe uniche del secondo file, la terza le righe in comune.
|
Tabella 130.29. Alcune opzioni.
|
Alcuni programmi si occupano di elaborare porzioni di file a livello delle righe (o dei record).
Quando le righe di un file contengono informazioni strutturate in qualche modo, gli elementi di queste sono chiamati campi, inoltre, al posto del termine «riga» si preferisce utilizzare la parola record che esprime più precisamente il ruolo di questa: contenere una registrazione.
I campi di un record possono avere una dimensione fissa, oppure variabile. Nel primo caso anche i record hanno una dimensione fissa e la suddivisione in campi avviene in base alla posizione; nel secondo caso i record hanno una dimensione variabile e i campi vengono riconosciuti in base a un separatore che di solito deve essere definito.
Il programma di servizio cut (23) emette attraverso lo standard output porzioni del contenuto di ogni riga dei file indicati come argomento. Il modo con cui ciò avviene dipende dagli argomenti, attraverso i quali possono essere definite delle liste di valori o di intervalli. Il primo elemento corrisponde al numero uno.
cut [opzioni] [file...] |
|
Tabella 130.30. Alcune opzioni.
|
$ cut -b 1-10 pippo[Invio]
Emette i primi 10 byte di ogni riga del file pippo.
$ cut -b 1-10,21 pippo[Invio]
Emette per ogni riga del file pippo solo i primi 10 byte seguiti dal 21-esimo byte.
$ cut -d ":" -f 1,5 /etc/passwd[Invio]
Emette il primo e il quinto campo del file /etc/passwd. Per leggere correttamente il file, viene anche definito il tipo di separatore (:). In pratica, viene visualizzato il nominativo e il nome completo degli utenti.
Il programma di servizio paste (24) emette attraverso lo standard output l'unione, riga per riga, dei file indicati come argomento. Le righe dei file vengono prese in ordine sequenziale e unite separandole con un carattere di tabulazione. Al termine delle nuove righe ottenute, viene aggiunto il codice di interruzione di riga.
paste [opzioni] [file...] |
|
Tabella 130.31. Alcune opzioni.
|
Il programma di servizio join (25) genera un file contenente le righe che hanno chiavi identiche nei due file indicati tra gli argomenti. I due file devono essere già ordinati in base alle chiavi che si vogliono prendere in considerazione per la selezione.
join [opzioni] file1 file2 |
Si veda eventualmente il documento info join oppure la pagina di manuale join(1).
Il testo contenuto in un file può richiedere la creazione di un indice di alcune o di tutte le parole contenute. Per questo si può realizzare un programma apposito, che produca esattamente il risultato voluto, oppure ci si può servire di qualcosa di già pronto, come ptx.
Il programma di servizio ptx (26) serve a scandire un file di testo per generare una sorta di indice del suo contenuto, che può essere usato così come prodotto dal programma o può servire per l'utilizzo nell'ambito di un sistema di composizione particolare.
Il programma ptx standard dei sistemi Unix ha delle limitazioni significative, mentre la versione GNU cerca di espandere le sue possibilità. Per questa ragione, si mostrano due modelli sintattici, dove il primo, con l'opzione -G iniziale, serve a richiamare il comportamento tradizionale:
ptx -G [altre_opzioni] [file_ingresso [file_uscita]] |
ptx [altre_opzioni] [file_ingresso...] |
Si può osservare che tra i due modelli sintattici cambia anche il modo di specificare i file da leggere e da generare; in pratica, nel secondo caso il file generato viene emesso attraverso lo standard output, oppure attraverso l'uso di un'opzione apposita.
Per evitare confusione, si distinguono due gruppi di opzioni: quelle tradizionali, che corrispondono a opzioni corte con una lettera minuscola; quelle speciali della versione GNU che sono rappresentate da una lettera maiuscola.
Per cercare di capire cosa fa questo programma, conviene vedere un esempio funzionante secondo la modalità GNU. Si prende un file molto breve, come questo:
|
Supponendo che questo file si chiami terra.txt, ecco cosa succede se viene elaborato da ptx, secondo le estensioni GNU:
$ ptx terra.txt[Invio]
casca la terra, tutti giù/ Giro giro tondo, casca il mondo,
tutti giù/ Giro giro tondo, casca il mondo, casca la terra,
/giro tondo, casca il mondo, casca la terra, tutti giù per/
la terra, tutti giù per/ Giro giro tondo, casca il mondo, casca
il mondo, casca la terra, tutti giù per terra! /, casca
giù/ Giro giro tondo, casca il mondo, casca la terra, tutti
/tondo, casca il mondo, casca la terra, tutti giù per terra!
Giro giro tondo, casca il mondo, casca la terra, tutti giù/
, casca la terra, tutti giù per terra! /il mondo
tondo, casca il mondo, casca la terra, tutti giù per terra! /giro
, casca la terra, tutti giù per terra! /il mondo
terra, tutti giù/ Giro giro tondo, casca il mondo, casca la
casca il mondo, casca la terra, tutti giù per terra! /tondo,
|
Il file che si ottiene è ordinato a partire dalla colonna di testo che si trova nella parte destra; le righe sono ripetute, con uno scorrimento orizzontale, in modo da prendere in considerazione tutte le parole del testo, tenendo conto anche della loro sequenza. All'estrema sinistra può apparire una porzione del testo che avanza dalla parte destra, così, all'estrema destra può apparire una porzione di testo che non avanza dalla parte iniziale.
Evidentemente, lo scopo del programma non si limita a spezzare il testo in tutti i modi possibili, per poi riordinarlo; questo tipo di lavoro serve eventualmente per creare degli indici. A questo proposito, con le opzioni si possono indicare solo alcuni gruppi di parole di interesse, così come se ne possono escludere altre. Inoltre, il risultato dell'elaborazione può essere indicizzato in qualche modo visibile, per consentire di raggiungere la stessa cosa nel documento di partenza.
Ecco cosa si ottiene utilizzando ptx secondo la modo di funzionamento tradizionale:
$ ptx -G terra.txt[Invio]
.xx "" "" "Giro giro tondo," "" .xx "" "" "casca il mondo," "" .xx "" "" "casca la terra," "" .xx "" "Giro" "giro tondo," "" .xx "" "tutti" "giù per terra!" "" .xx "" "casca" "il mondo," "" .xx "" "casca" "la terra," "" .xx "" "casca il" "mondo," "" .xx "" "tutti giù" "per terra!" "" .xx "" "tutti giù per" "terra!" "" .xx "" "casca la" "terra," "" .xx "" "Giro giro" "tondo," "" .xx "" "" "tutti giù per terra!" "" |
Le righe sono precedute dalla stringa .xx che potrebbe servire per richiamare una macro di *roff (capitolo 409).
Usando le estensioni GNU, si può ottenere qualcosa di simile per TeX (parte liii):
$ ptx -T terra.txt[Invio]
\xx {casca la terra, tutti gi\`u}{}{Giro}{ giro tondo, casca il mondo,}{}
\xx {tutti gi\`u}{Giro giro tondo,}{casca}{ il mondo, casca la terra,}{}
\xx {}{giro tondo, casca il mondo,}{casca}{ la terra, tutti gi\`u per}{}
\xx {la terra, tutti gi\`u per}{Giro}{giro}{ tondo, casca il mondo, casca}{}
\xx {}{il mondo, casca la terra, tutti}{gi\`u}{ per terra!}{, casca}
\xx {gi\`u}{Giro giro tondo, casca}{il}{ mondo, casca la terra, tutti}{}
\xx {}{tondo, casca il mondo, casca}{la}{ terra, tutti gi\`u per terra!}{}
\xx {}{Giro giro tondo, casca il}{mondo}{, casca la terra, tutti gi\`u}{}
\xx {}{, casca la terra, tutti gi\`u}{per}{ terra!}{il mondo}
\xx {}{tondo, casca il mondo, casca la}{terra}{, tutti gi\`u per terra!}{giro}
\xx {}{, casca la terra, tutti gi\`u per}{terra}{!}{il mondo}
\xx {terra, tutti gi\`u}{Giro giro}{tondo}{, casca il mondo, casca la}{}
\xx {}{casca il mondo, casca la terra,}{tutti}{ gi\`u per terra!}{tondo,}
|
Sempre utilizzando le estensioni GNU è possibile dare un indice al risultato:
$ ptx -A terra.txt[Invio]
terra.txt:1: mondo, casca la/ Giro giro tondo, casca il terra.txt:2: Giro giro tondo, casca il mondo, casca la/ terra.txt:3: /tondo, casca il mondo, casca la terra, tutti giù/ terra.txt:1: casca la terra,/ Giro giro tondo, casca il mondo, terra.txt:4: , casca la terra, tutti giù per terra! /il mondo terra.txt:2: Giro giro tondo, casca il mondo, casca la terra,/ terra.txt:3: /, casca il mondo, casca la terra, tutti giù per/ terra.txt:2: /giro tondo, casca il mondo, casca la terra,/ terra.txt:4: la terra, tutti giù per terra! /mondo, casca terra.txt:3: /casca il mondo, casca la terra, tutti giù per terra! terra.txt:4: la terra, tutti giù per terra! /, casca terra.txt:1: casca la/ Giro giro tondo, casca il mondo, terra.txt:4: mondo, casca la terra, tutti giù per terra! /il |
Come si può vedere, si ottiene l'indicazione del file che contiene l'informazione e della riga in cui appare. Se si modifica il file, aggiungendo una sigla davanti a ogni riga, si può sfruttare questa informazione per l'indicizzazione. Il file viene modificato nel modo seguente, dove le sigle sono state scelte senza un criterio particolare:
|
$ ptx -r terra.txt[Invio]
p1.1 Giro giro tondo, p1.2 casca il mondo, p1.3 casca la terra, p1.1 Giro giro tondo, p1.4 tutti giù per terra! p1.2 casca il mondo, p1.3 casca la terra, p1.2 casca il mondo, p1.4 tutti giù per terra! p1.3 casca la terra, p1.4 tutti giù per terra! p1.1 Giro giro tondo, p1.4 tutti giù per terra! |
$ ptx -G -r terra.txt[Invio]
.xx "" "" "Giro giro tondo," "" "p1.1" .xx "" "" "casca il mondo," "" "p1.2" .xx "" "" "casca la terra," "" "p1.3" .xx "" "Giro" "giro tondo," "" "p1.1" .xx "" "tutti" "giù per terra!" "" "p1.4" .xx "" "casca" "il mondo," "" "p1.2" .xx "" "casca" "la terra," "" "p1.3" .xx "" "casca il" "mondo," "" "p1.2" .xx "" "tutti giù" "per terra!" "" "p1.4" .xx "" "tutti giù per" "terra!" "" "p1.4" .xx "" "casca la" "terra," "" "p1.3" .xx "" "Giro giro" "tondo," "" "p1.1" .xx "" "" "tutti giù per terra!" "" "p1.4" |
L'utilizzo ptx richiede un obiettivo da risolvere con questo programma. In generale potrebbe essere utile come aiuto nella realizzazione di documenti *roff (capitolo 409) e TeX o LaTeX (parte liii). In quella ipotesi si può procedere allo studio approfondito della sua documentazione: il documento info ptx oppure la pagina di manuale ptx(1).
Appunti di informatica libera 2006.07.01 --- Copyright © 2000-2006 Daniele Giacomini -- <daniele (ad) swlibero·org>
1) GNU core utilities GNU GPL
2) GNU core utilities GNU GPL
3) GNU core utilities GNU GPL
4) GNU core utilities GNU GPL
5) util-linux: rev UCB BSD
7) GNU core utilities GNU GPL
8) GNU core utilities GNU GPL
9) GNU core utilities GNU GPL
15) GNU core utilities GNU GPL
16) GNU core utilities GNU GPL
17) GNU core utilities GNU GPL
18) GNU core utilities GNU GPL
19) GNU core utilities GNU GPL
20) GNU core utilities GNU GPL
21) GNU core utilities GNU GPL
22) GNU core utilities GNU GPL
23) GNU core utilities GNU GPL
24) GNU core utilities GNU GPL
25) GNU core utilities GNU GPL
26) GNU core utilities GNU GPL
Dovrebbe essere possibile fare riferimento a questa pagina anche con il nome gestione_dei_file_di_testo.htm
[successivo] [precedente] [inizio] [fine] [indice generale] [indice ridotto] [translators] [docinfo] [indice analitico]
