3 084
contributi
m (verifica, modifiche minori per via di comandi non presenti di default) |
Wtf (discussione | contributi) Nessun oggetto della modifica |
||
(12 versioni intermedie di uno stesso utente non sono mostrate) | |||
Riga 1: | Riga 1: | ||
{{Comandi da terminale}} | {{Comandi da terminale}} | ||
== Muoversi tra le directory == | == Muoversi tra le directory ('''cd''') == | ||
Accedere da terminale ad una directory è semplicissimo, perché il comando è uguale a quello del DOS.<br> | Accedere da terminale ad una directory è semplicissimo, perché il comando è uguale a quello del DOS.<br> | ||
Per entrare nella directory “cartella” digitiamo: | Per entrare nella directory “cartella” digitiamo: | ||
Riga 24: | Riga 24: | ||
</pre> | </pre> | ||
== Visualizzare il contenuto di una directory == | == Visualizzare il contenuto di una directory ('''ls''') == | ||
Se avete bisogno di vedere cosa è presente in una cartella, tutto quello che dovrete fare sarà entrare nella cartella che volete esaminare e lanciare: | Se avete bisogno di vedere cosa è presente in una cartella, tutto quello che dovrete fare sarà entrare nella cartella che volete esaminare e lanciare: | ||
<pre> | <pre> | ||
Riga 47: | Riga 47: | ||
con cui si potranno visualizzare i file nascosti (<code>a</code>) e produrre un listato (<code>l</code>) con diversi dettagli utili (permessi di lettura/scrittura/esecuzione, utente e gruppo proprietari, dimensione, data di ultima modifica, ecc... ) | con cui si potranno visualizzare i file nascosti (<code>a</code>) e produrre un listato (<code>l</code>) con diversi dettagli utili (permessi di lettura/scrittura/esecuzione, utente e gruppo proprietari, dimensione, data di ultima modifica, ecc... ) | ||
== Creare una directory == | === Visualizzare la struttura di una directory ('''tree''') === | ||
<code>tree</code> è un comando shell che ha il compito di listare ad albero una data directory. Bisogna prima installare l'omonimo pacchetto: <pre> | |||
# apt install tree | |||
</pre> | |||
La sintassi del comando è: | |||
<pre> | |||
tree [ -adfgilnopqrstuxACDFNS ][ -L level [-R] ][ -H baseHREF ][ -T title ][ -o filename ][ --nolinks ][ -P pattern ] | |||
[ -I pattern ][ --inodes ][--device ][ --nore-port ][ --dirsfirst ][ --version ][ --help ][ directory ... ] | |||
</pre> | |||
Alcune delle numerose opzioni che possiamo passare al comando tree sono: | |||
* <code>-a</code>: Stampa a video tutti i file, compresi quelli nascosti | |||
* <code>-d</code>: Lista soltanto le directory | |||
* <code>-f</code>: Stampa tutto il percorso di ogni file | |||
* <code>-i</code>: Non stampa un output ad 'albero' | |||
* <code>-s</code>: Stampa affianco al nome del file la sua dimensione | |||
* <code>-r</code>: Riordina alfabeticamente l'output | |||
Se vogliamo ad esempio listare la cartella <code>/home/user/tmp</code>, basta dare il comando: | |||
<pre> | |||
tree /home/user/tmp | |||
</pre> | |||
== Creare una directory ('''mkdir''') == | |||
Per creare una directory da terminale, dobbiamo spostarci dentro la directory nella quale desideriamo creare la nuova directory, e digitare: | Per creare una directory da terminale, dobbiamo spostarci dentro la directory nella quale desideriamo creare la nuova directory, e digitare: | ||
<pre> | <pre> | ||
mkdir | mkdir NuovaCartella | ||
</pre> | </pre> | ||
Se volessimo creare in un colpo solo la directory | Se volessimo creare in un colpo solo la directory “NuovaCartella” e subito al suo interno la directory “sottocartella” scriviamo: | ||
<pre> | <pre> | ||
mkdir | mkdir NuovaCartella/sottocartella | ||
</pre> | </pre> | ||
== Rinominare/Spostare ('''mv''') == | |||
{{Box|Nota|Rinominare è un caso particolare di spostamento, ecco perché in entrambi i casi il comando da usare è '''mv'''.}} | |||
=== Rinominare === | |||
== | ==== Directory ==== | ||
Rinominare una cartella da terminale è semplice. Se ad esempio dobbiamo assegnare alla directory | Rinominare una cartella da terminale è semplice. Se ad esempio dobbiamo assegnare alla directory “VecchiaCartella” il nuovo nome “NuovaCartella”, dobbiamo portarci nella directory genitore e scrivere: | ||
<pre> | |||
mv VecchiaCartella/ NuovaCartella/ | |||
</pre> | |||
==== File ==== | |||
Per rinominare un file da terminale deve essere usato il comando <code>mv</code>. Volendo rinominare il file “testo.txt” in “text.txt” dovremo dirigerci prima nella directory in cui il file è presente, e poi digitare: | |||
<pre> | <pre> | ||
mv | mv testo.txt text.txt | ||
</pre> | </pre> | ||
== Spostare (tagliare ed incollare) | === Spostare (tagliare ed incollare) === | ||
==== Directory ==== | |||
Spostare (tagliare ed incollare) una directory da terminale richiede un solo semplice comando. Supponiamo di avere la seguente struttura: | Spostare (tagliare ed incollare) una directory da terminale richiede un solo semplice comando. Supponiamo di avere la seguente struttura: | ||
<pre> | <pre> | ||
Riga 70: | Riga 106: | ||
|__ ferdy | |__ ferdy | ||
| | | | ||
|__ | |__ VecchiaCartella | ||
| |__ sottocartella | | |__ sottocartella | ||
| | | | ||
|__ | |__ NuovaCartella | ||
</pre> | </pre> | ||
e di voler spostare la directory <code>sottocartella</code> dalla directory <code> | e di voler spostare la directory <code>sottocartella</code> dalla directory <code>VecchiaCartella</code> alla directory <code>NuovaCartella</code>: | ||
<pre> | <pre> | ||
cd /home/ferdy/cartella | cd /home/ferdy/cartella | ||
Riga 85: | Riga 121: | ||
</pre> | </pre> | ||
== | ==== File ==== | ||
Anche per questa operazione deve essere usato il comando <code>mv</code>. Supponiamo di avere il file "testo.txt" in una specifica directory e di volerlo spostare nella nostra directory Home. Dirigiamoci da terminale nella directory in cui il file è presente, e lanciamo: | |||
<pre> | |||
mv testo.txt /home/vostronomeutente/ | |||
</pre> | |||
== Copiare ('''cp''') == | |||
=== Directory === | |||
Copiare ed incollare una directory da terminale richiede un solo semplice comando. Supponiamo di avere la seguente struttura: | Copiare ed incollare una directory da terminale richiede un solo semplice comando. Supponiamo di avere la seguente struttura: | ||
<pre> | <pre> | ||
Riga 108: | Riga 152: | ||
L'opzione <code>-r</code> permette di estendere ricorsivamente l'opzione di copia alle eventuali sottodirectory contenute della directory "sottocartella". | L'opzione <code>-r</code> permette di estendere ricorsivamente l'opzione di copia alle eventuali sottodirectory contenute della directory "sottocartella". | ||
== | === File === | ||
Se intendiamo duplicare un file, dobbiamo usare il comando <code>cp</code>. Con questo comando si possono fare più cose: | Se intendiamo duplicare un file, dobbiamo usare il comando <code>cp</code>. Con questo comando si possono fare più cose: | ||
* copiare un file da una directory ad un'altra: | * copiare un file da una directory ad un'altra: | ||
Riga 175: | Riga 167: | ||
</pre> | </pre> | ||
== Cancellare | == Cancellare == | ||
=== Semplice ('''rm''') === | |||
==== Directory ==== | |||
{{Cautionbox|L'opzione <code>-r</code> è in grado di cancellare ricorsivamente ogni file o sottodirectory di "cartella". Prestate attenzione a come utilizzate il comando perché '''non viene chiesta alcuna conferma''' e rischiate di eliminare file o directory di sistema.}} | |||
Volendo cancellare la directory non vuota “cartella” dovremo digitare: | |||
<pre> | |||
rm -r cartella | |||
</pre> | |||
Il comando precedente funziona correttamente anche se si vogliono cancellare directory vuote. | |||
==== File ==== | |||
La cancellazione di un file da terminale è semplice, basterà digitare il comando <code>rm</code> seguito dal nome del file che si vuole cancellare. | La cancellazione di un file da terminale è semplice, basterà digitare il comando <code>rm</code> seguito dal nome del file che si vuole cancellare. | ||
Ad esempio: | Ad esempio: | ||
Riga 182: | Riga 186: | ||
</pre> | </pre> | ||
== | === Sicuro ('''shred''') === | ||
Ovvero come cancellare definitivamente un file (non si applica alle directory). | |||
<code>shred</code> è un comando shell che sovrascrive ripetutamente i FILE specificati in modo da rendere più difficile recuperare i dati, e opzionalmente li cancella. La sintassi del comando è: | <code>shred</code> è un comando shell che sovrascrive ripetutamente i FILE specificati in modo da rendere più difficile recuperare i dati, e opzionalmente li cancella. La sintassi del comando è: | ||
<pre> | <pre> | ||
Riga 197: | Riga 202: | ||
* <code>-z, --zero</code>: add a final overwrite with zeros to hide shredding | * <code>-z, --zero</code>: add a final overwrite with zeros to hide shredding | ||
== Visualizzare il contenuto di un file == | === Directory vuota ('''rmdir''') === | ||
Il comando <code>cat</code> (che analizzeremo nel dettaglio tra pochi paragrafi) | Volendo cancellare la directory “cartella”, dobbiamo scrivere: | ||
<pre> | |||
rmdir cartella | |||
</pre> | |||
Questo comando presuppone che la directory sia vuota. In caso contrario verrà restituito l’errore: | |||
<pre> | |||
rmdir: failed to remove `cartella’: La directory non è vuota | |||
</pre> | |||
== Visualizzare il contenuto di un file ('''cat''') == | |||
Il comando <code>cat</code> (che analizzeremo nel dettaglio tra pochi paragrafi) mostra ("stampa") direttamente nella finestra del terminale, subito sotto il prompt, il contenuto di un file. Ad esempio, digitate: | |||
<pre> | <pre> | ||
cat filename.txt | cat filename.txt | ||
Riga 207: | Riga 222: | ||
</pre> | </pre> | ||
== Confrontare due file == | == Modificare l'ora di accesso a un file ('''touch''') == | ||
<code>touch</code> è un comando shell che modifica l'orario di accesso o/e modifica di un file (il cosiddetto '''timestamp'''). I file vengono modificati con l'orario corrente. La sintassi del comando è: | |||
<pre> | |||
touch [-acfm] [-r file][-t orario_decimale] [-d orario] | |||
[--time={atime,access,use,mtime,modify}][--date=orario][--reference=file] | |||
[--no-create] [--help] [--version] [--] file... | |||
</pre> | |||
Le opzioni che possiamo passare al comando sono: | |||
* <code>-a</code>: Cambia l'ora di accesso di file. | |||
* <code>-c</code>: Non crea file. | |||
* <code>-m</code>: Cambia l'ora di modifica di file. | |||
* <code>-r ref_file</code>: Usa i corrispondenti orari di ref_file come i nuovi valori per gli orari da cambiare. | |||
* <code>-t orario</code>: Usa l'orario specificato come nuovo valore per gli orari cambiati. L'argomento è un numero decimale nella forma [[SS]AA]MMGGoomm[.ss] | |||
* <code>-d, --date=orario</code>: Usa orario al posto dell'ora corrente. Può contenere il nomi di mese, fusi orari, «am» e «pm», ecc. | |||
== Confrontare due file ('''diff''') == | |||
<code>diff</code> è un comando shell che trova la differenza tra due file. La sintassi del comando è: | <code>diff</code> è un comando shell che trova la differenza tra due file. La sintassi del comando è: | ||
<pre> | <pre> | ||
Riga 220: | Riga 250: | ||
* <code>-c</code>: Usa il formato «a contesto» (context output, in inglese). | * <code>-c</code>: Usa il formato «a contesto» (context output, in inglese). | ||
* <code>-d</code>: Usa un algoritmo diverso per trovare un, probabilmente, minore insieme di modifiche da fare. Questo rende diff più lento (a volte molto più lento). | * <code>-d</code>: Usa un algoritmo diverso per trovare un, probabilmente, minore insieme di modifiche da fare. Questo rende diff più lento (a volte molto più lento). | ||
== Cambiare permessi ('''chmod''') == | |||
Può succedere di aver bisogno di dover cambiare i permessi ad un file (o cartella), per consentire la lettura, la scrittura o l’esecuzione ad ogni utente, oppure al contrario per proteggerlo da utilizzi indesiderati e restringerlo ad un particolare utente o gruppo.<br/> | |||
Il comando da utilizzare per queste operazioni è <code>chmod</code>.<br/> | |||
I permessi <code>chmod</code> sono tipicamente utilizzati dai sistemi operativi UNIX e Linux. Non sono altro che le linee guida che vengono impartite al sistema sugli accessi o non accessi ad una data directory e/o file. Questi sistemi operativi offrono la possibilita di operare con un file facendo la distinzione fra 3 tipi di operatori: Proprietario (User), Gruppo (Group), Pubblici (Others). Per ciascuno di questi utenti é necessario specificare i diversi permessi riguardanti la directory e/o il file in questione. I permessi sono generalmente indicati da alcuni numeri, ovvero: | |||
* Lettura : permetti l'acceso al file ( 4 ) | |||
* Scrittura : permetti le modifiche del file da parte di un utente ( 2 ) | |||
* Esecuzione : permetti di eseguire lo script ( 1 ) | |||
Questi 3 permessi devono essere indicati per ognuno dei 3 tipi di utenti. Ad esempio <code>chmod 755</code>, non é altro che il tipo di permesso che si imposta ad un file, rendendolo: | |||
* leggibile-scrivibile-eseguibile al proprietario | |||
* leggibile-eseguibile al gruppo | |||
* leggibile-eseguibile agli altri utenti | |||
<br/> | |||
La tabella seguente indica il significato dei singoli valori | |||
{| | |||
|- | |||
! Valore binario (<code>rwx</code>) !! Valore decimale !! Permessi | |||
|- | |||
| 111 || 7 || lettura, scrittura ed esecuzione | |||
|- | |||
| 110 || 6 || lettura e scrittura | |||
|- | |||
| 101 || 5 || lettura ed esecuzione | |||
|- | |||
| 100 || 4 || solo lettura | |||
|- | |||
| 011 || 3 || scrittura ed esecuzione | |||
|- | |||
| 010 || 2 || solo scrittura | |||
|- | |||
| 001 || 1 || solo esecuzione | |||
|- | |||
| 000 || 0 || nessuno | |||
|} | |||
<br/> | |||
Il permesso <code>chmod 754</code> significa quanto segue: | |||
* Utente proprietario | |||
<pre> | |||
Totale (7) = Lettura (4, cioè sì) + Scrittura (2, cioè sì) + Esecuzione (1, cioè sì) | |||
</pre> | |||
* Utenti appartenenti al gruppo: | |||
<pre> | |||
Totale (5) = Lettura (4, cioè sì) + Scrittura (0, cioè no) + Esecuzione (1, cioè sì) | |||
</pre> | |||
* Altri utenti: | |||
<pre> | |||
Totale (4) = Lettura (4, cioè sì) + Scrittura (0, cioè no) + Esecuzione (0, cioè no) | |||
</pre> | |||
Affiancando i tre totali si ottiene il permesso 755. | |||
<br/> | |||
Per cambiare i permessi al file "testo.txt" dovremo quindi agire da autori del file e digitare: | |||
<pre> | |||
chmod xxx testo.txt | |||
</pre> | |||
{{Box|Nota|Nel caso di directory il permesso di esecuzione deve esserci sempre, ovvero se si vuole che il contenuto di una cartella sia visibile il permesso da attribuire sarà '''5''' e non '''4'''}} | |||
Al posto delle lettere <code>xxx</code> devono essere indicati i numeri ottali visti in precedenza. Ad esempio: | |||
* 755 – Lettura, scrittura, esecuzione per il proprietario, lettura, esecuzione per il gruppo ed altri utenti. | |||
* 644 – Lettura, scrittura per il proprietario, lettura per il gruppo ed altri utenti. | |||
* 666 – Lettura e scrittura per tutti. | |||
* 700 – Lettura, scrittura, esecuzione per il proprietario, nessun permesso per il gruppo ed altri. | |||
In generale valori che vanno da "0" a "7" rappresentano in forma numerica i permessi come di seguito riportato: | |||
<pre> | |||
4 è uguale a lettura(r), | |||
2 è uguale a scrittura(w), | |||
1 è uguale a esecuzione(x), | |||
0 rimuove i permessi. | |||
</pre> | |||
Il valore numerico risultante è pari alla somma di tali valori.<br> | |||
Partendo sempre da sinistra, la prima cifra si riferisce ai permessi per l'utente proprietario.<br> | |||
La seconda cifra fa riferimento ai permessi per il gruppo proprietario.<br> | |||
La terza e ultima cifra si riferisce ai permessi per gli altri utenti non appartenenti al gruppo proprietario.<br> | |||
Un'altra sintassi utilizzabile è: | |||
<pre> | |||
chmod u|g|o|a|+rwx file1/directory1 | |||
</pre> | |||
Significato delle opzioni disponibili del precedente comando: | |||
u = user - applica i permessi all'utente proprietario del file, | |||
g = group - applica i permessi al gruppo proprietario del file, | |||
o = other - applica i permessi ad altri utenti, | |||
a = all - applica i permessi a tutti gli utenti, | |||
+ = questo operatore logico aggiunge i permessi specificati, | |||
- = questo operatore logico rimuove i permessi specificati, | |||
r = indica il permesso di lettura, | |||
w = indica il permesso di scrittura, | |||
x = indica il permesso di esecuzione. | |||
== Cambiare proprietario == | |||
=== '''chown''' === | |||
Per cambiare l'utente e il gruppo proprietari di ciascun file dato (specificato dal primo argomento che non sia un'opzione) si utilizza il comando <code>chown</code> nel seguente modo: se viene dato solo un nome utente (o una user ID numerica), quell'utente diventa proprietario di ciascun file dato, il cui gruppo non viene modificato. Se il nome utente è seguito da <code>:</code> e un nome di gruppo (o una group ID numerica), senza spazi frapposti, allora anche il gruppo proprietario del file viene cambiato.<br> | |||
La sintassi del comando è: | |||
<pre> | |||
chown [opzioni] utente[:gruppo] file... | |||
</pre> | |||
Per motivi di sicurezza soltanto con [[privilegi di amministrazione]] è possibile cambiare il proprietario di un file, a prescindere che sia o meno uno dei propri. | |||
==== Esempi ==== | |||
* Cambiare il proprietario del file <code>prova.txt</code> | |||
<pre> | |||
# chown ferdy prova.txt | |||
</pre> | |||
* Cambiare proprietario e gruppo proprietario del file <code>prova.txt</code> | |||
<pre> | |||
# chown ferdy:gruppo_desiderato prova.txt | |||
</pre> | |||
* Cambiare ricorsivamente il proprietario di tutti i file della directory <code>prova</code> | |||
<pre> | |||
# chown -R ferdy prova/ | |||
</pre> | |||
=== '''chgrp''' === | |||
Per cambiare il gruppo proprietario si utilizza il comando <code>chgrp</code>. Il gruppo può essere identificato col nome o con l'ID. La sintassi del comando è: | |||
<pre> | |||
chgrp [opzioni] gruppo file... | |||
</pre> | |||
Ad esempio, per cambiare il gruppo proprietario di tutti i file contenuti nella directory <code>prova</code> si digiti: | |||
<pre> | |||
chgrp -R gruppo_voluto prova/ | |||
</pre> | |||
Per motivi di sicurezza, possono cambiare il gruppo di un file soltanto root oppure un utente che è sia proprietario del file sia membro del gruppo scelto. | |||
== Comprimere file e directory == | == Comprimere file e directory == | ||
=== '''tar''' === | |||
La creazione di un nuovo file con il comando <code>tar</code> viene fatta mediante l'opzione <code>-c</code> indicando il nome del file da creare e il file o la directory originali: | La creazione di un nuovo file con il comando <code>tar</code> viene fatta mediante l'opzione <code>-c</code> indicando il nome del file da creare e il file o la directory originali: | ||
<code> | <code> | ||
Riga 266: | Riga 420: | ||
Nota: è importante che l'archivio non sia compresso. Nel caso lo sia è possibile prima eliminare la compressione dall'archivio e poi aggiungere dei file. Alla fine verrà ricompresso il tutto. | Nota: è importante che l'archivio non sia compresso. Nel caso lo sia è possibile prima eliminare la compressione dall'archivio e poi aggiungere dei file. Alla fine verrà ricompresso il tutto. | ||
=== Esempi === | ==== Esempi ==== | ||
* Comprimere tutte le immagini jpg dentro una directory: | * Comprimere tutte le immagini jpg dentro una directory: | ||
<code> | <code> | ||
Riga 347: | Riga 501: | ||
''(Grazie a [http://nerotux.tuxfamily.org Nerotux] per gli esempi sull'utilizzo di tar)'' | ''(Grazie a [http://nerotux.tuxfamily.org Nerotux] per gli esempi sull'utilizzo di tar)'' | ||
== | == Creare un collegamento ('''ln''') == | ||
Un collegamento è un particolare tipo di file che non è altro che un rimando ad un altro file o directory. Per creare un collegamento tra file o directory si deve usare il comando <code>ln</code>. | |||
Su Linux esistono due tipi di collegamenti: Hard link e Symbolic link (quello di uso più comune). | |||
Su Linux esistono due tipi di collegamenti: Hard link e Symbolic link. | |||
=== Hard Link === | === Hard Link === | ||
Riga 438: | Riga 520: | ||
In genere, per prevenire problemi e salvo si necessiti di conservare una copia dell'inode, è quasi sempre consigliabile ricorrere a link simbolici. | In genere, per prevenire problemi e salvo si necessiti di conservare una copia dell'inode, è quasi sempre consigliabile ricorrere a link simbolici. | ||
Un link simbolico si crea specificando l'opzione <code>-s</code>: | |||
< | |||
<pre> | <pre> | ||
ln -s <file da collegare> <nome del link> | |||
</pre> | </pre> | ||
Supponiamo di avere il file testo.txt nella nostra home e di voler creare un collegamento in <code>usr/bin</code> chiamato "mylink.txt". Scriverò: | |||
< | |||
<pre> | <pre> | ||
ln -s testo.txt mylink.txt | |||
</pre> | </pre> | ||
== Ricerca di file nel sistema ('''Locate''') == | |||
== Ricerca di file nel sistema == | |||
Se siamo alla ricerca di un determinato file all’interno del nostro computer, il mio consiglio è andare su Risorse e selezionare Cerca file. In questo modo il processo sarà più rapido e meno macchinoso, ma in questa guida siamo qui per vedere come è possibile farlo anche da terminale.<br> | Se siamo alla ricerca di un determinato file all’interno del nostro computer, il mio consiglio è andare su Risorse e selezionare Cerca file. In questo modo il processo sarà più rapido e meno macchinoso, ma in questa guida siamo qui per vedere come è possibile farlo anche da terminale.<br> | ||
Il motore di ricerca da terminale si chiama <code>locate</code> e possiamo installarlo normalmente digitando: | Il motore di ricerca da terminale si chiama <code>locate</code> e possiamo installarlo normalmente digitando: | ||
Riga 597: | Riga 564: | ||
* <code>--delete</code>: elimina dalla directory di destinazione i file non più presenti nella directory sorgente | * <code>--delete</code>: elimina dalla directory di destinazione i file non più presenti nella directory sorgente | ||
Maggiori informazioni [[Rsync | qui]]. | Maggiori informazioni [[Rsync | qui]]. | ||
== Manipolazione di file ('''cat''') == | |||
Un modo veloce (soprattutto negli script) per modificare il contenuto di un file o per accodare altro testo alla sua fine è utilizzare il comando <code>cat</code>.<br> | |||
<code>cat</code> è un comando shell che legge file in sequenza e può scrivere i loro contenuti sullo standard output nella stessa sequenza. Lo scopo di cat è infatti concatenare file (generalmente di testo o che abbiano particolari intestazioni, ad esempio il formato MPEG2 usato dai VOB nei DVD video). Dimenticatevi follie quali "cat file.txt | less" o "cat file.txt | grep foo" perché è definito | |||
[http://en.wikipedia.org/wiki/Cat_%28Unix%29#Useless_use_of_cat UUOC: Useless Use Of Cat] :-) | |||
La sintassi del comando è: | |||
<pre> | |||
cat [opzioni][file ...] | |||
</pre> | |||
Note: | |||
* <code>'''>''' file.estensione</code>: Se nomefile.estensione non esiste, viene creato e viene scritto il valore al suo interno. Nel caso esistesse già, il suo valore '''verrebbe sovrascritto'''. | |||
* <code>'''>>''' nomefile.estensione</code>: Aggiunge alla fine del file il valore che gli date a riga di comando.<br> | |||
Altri comandi utili per la manipolazione veloce di file sono: | |||
* <code>head</code>, che mostra le prime dieci linee di un file. Utile quando si vuole avere un'idea del contenuto di un file senza doverlo aprire con un editor | |||
* <code>tail</code>, che mostra al contrario le ultime dieci linee di un file | |||
=== Esempi === | |||
Se vogliamo mostrare il contenuto del file di testo <code>/home/ferdy/prova.txt</code>, dobbiamo dare il comando: | |||
<pre> | |||
cat /home/ferdy/prova.txt | |||
</pre> | |||
Se vogliamo aggiungere il contenuto del file <code>/home/ferdy/aggiunte.txt</code> alla fine del file, diamo il seguente comando: | |||
<pre> | |||
cat /home/ferdy/aggiunte.txt >> /home/ferdy/prova.txt | |||
</pre> | |||
Se vogliamo unire i due file e crearne un terzo, diamo il comando: | |||
<pre> | |||
cat /home/ferdy/prova.txt /home/ferdy/aggiunte.txt > /home/ferdy/file_finale.txt | |||
</pre> | |||
Per visualizzare le prime dieci o le ultime dieci linee di un file: | |||
<pre> | |||
head /home/ferdy/prova.txt | |||
tail /home/ferdy/prova.txt | |||
</pre> | |||
Un comando preziosissimo per gli amministratori di sistema è il seguente, che permette di vedere in modo interattivo la variazione di un file di log: | |||
<pre> | |||
tail -f /var/log/syslog | ccze | |||
</pre> | |||
Nell'ultimo comando sono stati usati: | |||
* <code>'''-f</code>''' che permette a <code>tail</code> di seguire (follow) il file e i suoi cambiamenti | |||
* <code>'''| ccze'''</code> che dirige l'output di tail verso il programma <code>ccze</code>, che colorerà l'output del log rendendolo facilmente leggibile | |||
In quest'ultimo esempio, per rilasciare il terminale e riottenerne il pieno utilizzo bisogna stoppare <code>tail</code> con la combinazione di tasti <code>CTRL</code>+<code>C</code>. | |||
Un altro uso interessante di cat è creare file di testo sfruttando lo stdin della shell. | |||
Lanciamo questo comando: | |||
<pre> | |||
cat - > file.txt | |||
</pre> | |||
e possiamo scrivere il nostro testo sfruttando lo standard input come editor, si può correggere solo se non si è andati a capo e si termina con ''Ctrl-d''.<br> | |||
{{Autori | |||
|Autore = [[Utente:S3v|S3v]] | |||
|Verificata_da= | |||
:[[Utente:Wtf|Wtf]] 16:10, 26 mag 2024 (CEST) | |||
|Estesa_da = | |||
:[[Utente:Wtf|Wtf]] 16:10, 26 mag 2024 (CEST) | |||
|Numero_revisori=1 | |||
}} | |||
[[Categoria:Shell]][[Categoria:Programmi da terminale]] | [[Categoria:Shell]][[Categoria:Programmi da terminale]] |
contributi