Wiki Ubuntu-it

Indice
Partecipa
FAQ
Wiki Blog
------------------
Ubuntu-it.org
Forum
Chiedi
Chat
Cerca
Planet
  • Pagina non alterabile
  • Informazioni
  • Allegati
  • Differenze per "OroroMunroe/Prove0"
Differenze tra le versioni 6 e 12 (in 6 versioni)
Versione 6 del 24/09/2008 21.47.00
Dimensione: 16165
Autore: OroroMunroe
Commento:
Versione 12 del 25/09/2008 10.21.04
Dimensione: 0
Commento:
Le cancellazioni sono segnalate in questo modo. Le aggiunte sono segnalate in questo modo.
Linea 1: Linea 1:
#format wiki
#LANGUAGE it
[[BR]]
[[Indice()]]

= Presentazione =

Questa ''non'' è una guida, e ''non'' è solo una lista di comandi. È da intendersi più come un ''prontuario'' dei comandi più comuni.[[BR]]
Tutti i comandi sono nella stessa pagina, quindi si può usare una funzione di ricerca del browser, oppure i link qui a fianco.

Per i principianti: indico con * i comandi che è opportuno imparare subito.
Indico con b i comandi builtin (mi riferisco alla shell `bash`).

Rimando anche al sito [http://www.coresis.com/extra/linuxcorsobase/programma.htm], c'è un bel corso introduttivo a Linux,
e a [AmministrazioneSistema/ComandiBase] dove sono descritti più in dettaglio i comandi di base.
Per iniziare c'è un topic qui [http://forum.ubuntu-it.org/index.php/topic,57229.0.html].
Qui sta il manualinux [http://www.manualinux.com/].
Un'altra lista di comandi è qui: [http://www.perpetualpc.net/srtd_commands_rev.html].

Questo file deriva, alla lontana, da una lista di comandi di FreeBSD: [http://www.freebsd.org/doc/it_IT.ISO8859-15/books/unix-introduction/command-summary.html].

= Lista comandi =

== Sistema ==

||<tablestyle="border:2" :35%>||<2%>| ||
||'''Comando/Sintassi'''|| || '''Cosa fa'''||
||`alias` ''newname''= "stringa" ||b||Crea un nuovo comando, che per&ograve; esiste soltanto in memoria volatile. D'altra parte &egrave; pi&ugrave; veloce di uno script.||
||`bg %` ''job-number''||b||esegue in background un processo della lista dei job. Ossia, tale processo non blocca la shell. Si veda anche `jobs`.||
||`chsh (passwd -e/-s) `''username[[BR]]login_shell''``|| ||cambia la shell di login dell'utente (spesso solamente attraverso il super-user)||
||`command `''comando''``||b||Esegue il comando `''comando''`, ignorando tutti i possibili ''alias'' che sono stati definiti. Confronta `builtin`.||
||`date [`''opzioni''`]`|| ||riporta data e ora corrente||
||`disown `''%job''``||b||elimina un certo `''%job''` dalla lista dei job, ma senza chiuderlo. Confronta `kill`.||
||`echo [`''stringa di testo''`]`||b||riporta la stringa di testo specificata in standard output||
||`eject [-t]`|| ||espelle / richiude il vassoio CD||
||`exit`||b||chiude la shell||
||`fg %`''job-number''``||b||esegue in foreground un processo interrotto. Ossia, la shell &egrave; bloccata finch&egrave; il processo non termina. Si veda anche `jobs`.||
||`free`|| ||Visualizza quanta memoria (RAM e swap) &egrave; attualmente usata e quanta &egrave; libera. Confronta invece `df, du`||
||`grub-install --root-directory=`''floppy-gi&agrave;-montato''` `''device''``[[BR]]`grub-install --root-directory=/media/floppy fd0`|| ||Installa GRUB su floppy (disco d'avvio). Poi sar&agrave; necessario copiare anche il `menu.lst` su `/media/floppy/boot/grub`.||
||`help `''comando''``||b||visualizza una breve schermata d'aiuto, per le funzioni built-in. Confrontare `man` e `info`.||
||`hostname`|| ||visualizza o setta (solamente super-user) il nome della macchina attuale||
||`jobs`||b||Elenca i ''jobs'' attuali, ossia i programmi che sono stati ''sospesi'' durante la sessione (tipicamente sono stati sospesi usando CTRL+Z) ma anche quelli che sono stati lanciati con &#38;. Si veda anche `kill`.||
||`kill [`''opzioni''`] [-`''SEGNALE''`] [`''pid''`|%`''job''`]`||b||manda un segnale al processo specificato dall'identificatore di processo (`''pid''`) o dall'identificatore di job (%`''job''`). Il segnale di default &egrave; SEGKILL, che termina il processo. NB. il processo deve essere attivo: se &egrave; stato bloccato e.g. con CTRL+Z, bisogna poi riattivarlo con `fg`, e solo allora ricever&agrave; il segnale. Confronta `disown`.||
||`lpq [`''opzioni''`]`|| ||<|2>visualizza lo stato dei job di stampa||
||`lpstat [`''opzioni''`]`|| ||
||`lpr [`''opzioni''`] `''file''``|| ||<|2>stampa sulla stampante specificata||
||`lp [`''opzioni''`] `''file''``|| ||
||`lprm [`''opzioni''`]`|| ||<|2>rimuove un job di stampa dalla coda di stampa||
||`cancel [`''opzioni''`]`|| ||
||`ps [`''opzioni''`]`|| ||Visualizza lo stato e il ''pid'' dei processi attivi, aperti dalla finestra attuale. Usare l'opzione `-adef` o `-ax` per avere tutti i processi e pi&ugrave; dettagli. Confronta `top`.||
||`pushd `''newdir''`` || ||<|3>Per cambiare directory salvando la precendente in uno stack usare `pushd`. `popd` recupera la prima dello stack, `dirs` mostra il contenuto dello stack.||
||`popd`|| ||
||`dirs`|| ||
||`pstree`|| ||visualizza tutti i processi attivi con un diagramma ad albero. I processi dovrebbero generarsi tutti da `init`.||
||`pwd`||b*||visualizza la directory di lavoro (corrente)||
||`reboot`|| ||<|4>Riavvia / Spegne il sistema. Confronta `shutdown`.||
||`halt`|| ||
||`poweroff` || ||
||`init 6`|| ||
||`script `''file''`` || ||memorizza ogni cosa che appare sullo schermo in un file fino a quando si esegue `exit`||
||`set`[[BR]]set `''varname''=''content''`[[BR]]PATH=/usr/lib:$PATH|| ||visualizza/setta le variabili d'ambiente||
||`shutdown -r` `''time''`[[BR]]`shutdown -h` `''time''`|| ||Riavvia / spegne il sistema dopo un tempo presfissato. ''time'' pu&ograve; essere: numero minuti, oppure `hh:mm`, oppure `now`. Se non specifichi `-r / -h` fa casino... (arresta, ma non spegne n&eacute; riavvia)||
||`source `''file''``||b||<|3>legge i comandi dal file specificato e li esegue nella shell corrente. `source` per la shell C, `.` per la shell Bourne. Usare solo il punto significa che lo script &egrave; "incluso" anzich&egrave; "richiamato".||
||`. &#47;`''file''``||*||
||`. `''file''``||
||`stty [`''opzioni''`]` || ||setta o visualizza le opzioni del terminale di controllo||
||`suspend` ||b||blocca la shell fino alla ricezione di un segnale `SIGCONT`.||
||`unset `''varname''`` ||b||Elimina la variabile d'ambiente `''varname''`.||
||`unalias `''aliasname''`` ||b||Elimina `''aliasname''` dalla lista degli alias.||
||`uname`[[BR]]`uname -a` || ||Ottiene il nome del sistema operativo, la versione del kernel e altro.||
||`wait `''job-or-pid''`` ||b ||Aspetta la terminazione del ''job'' o del processo ''PID'' indicato.||
||`which `''comando''`` || ||riporta il percorso del comando o l'alias di shell in uso||
||`X`|| ||(da console) avvia il server X||

[[BR]]

== Accounts ==


||<tablestyle="border:2" :35%>'''Comando/Sintassi'''||<2%> || '''Cosa fa'''||
||`adduser `''opzioni''` `|| ||crea un nuovo utente, o un nuovo gruppo (di utenti), o aggiunge un utente ad un gruppo esistente.||
||`addgroup `''group''`` || ||crea un nuovo gruppo (di utenti). Per modificare i gruppi non ho trovato comandi, ma si pu&ograve; modificare direttamente i file `/etc/group`||
||`chgrp [`''opzioni''`] `''gruppo file''`` || ||cambia il gruppo di appartenenza di un file||
||`chmod `''permessi''` `''file''``[[BR]]`chmod a+rw `''file''``[[BR]]`chmod +x `''script''``[[BR]] `chmod 755 /`` || ||cambia i permessi di accesso a file o directory. Confronta `chown`.[[BR]] I permessi possono essere specificati con `a/u/g/o` (all/user/group/others) seguito da `+/-` seguito da `r/w/x` (read/write/execute). Se si vogliono settare ''tutti'' i possibili permessi, conviene specificarli come triple ottali di numeri per user, group, others:[[BR]] 4 -> r[[BR]] 2 -> w[[BR]] 1 -> x[[BR]] esempio: `chmod 741 ''file''`[[BR]] corrisponde a: `chmod u+rwx,g+r-wx,o+x-wr`[[BR]] d&agrave; al proprietario di ''file'' il permesso di lettura, scrittura e esecuzione, al gruppo solo di lettura e agli altri solo di esecuzione (paradossale lo so &egrave; un esempio...).[[BR]] (`-r` per cambiare i permessi ricorsivamente di tutte le sottodirectory)||
||`chown [`''opzioni''`] `''proprietario ''[:''gruppo'']'' file''``[[BR]]`chown -r `''utente'':''utente''` /home/`''utente''``|| ||cambia il proprietario di un file (`-r` per cambiare i permessi ricorsivamente di tutte le sottodirectory)||
||`groupadd `''gruppo''``|| ||Analogo ad `addgroup`, ma &egrave; di pi&ugrave; basso livello. Di preferenza usare l'altro (almeno in Debian).||
||`id`|| ||visualizza i dati dell'utente attualmente loggato||
||`login`|| ||<|2>comandi tradizionali per il login/logout; ma sono inutili, servono solamente da console (cosiddetta ''login shell''). Confronta `exit`||
||`logout`||b||
||`last`|| ||dice chi si &egrave; loggato, quando e da dove (utile su server).||
||`passwd [`''opzioni''`]`||*||setta o modifica la propria password||
||`su [`''nomeutente''`]`||*||Login del super-user. MA in Kubuntu tale super-user potrebbe anche non esistere (&egrave; il mio caso),quindi ignorare questo comando.||
||`sudo [-u `''nomeutente''`] `''comando''``||*||Comando eseguito in modalit&agrave; super-user. Verr&agrave; richiesta la password. Vedere `kdesudo`.||
||`sudo [-u `''nomeutente''`] -i`||*||Passa alla modalit&agrave; super-user.||
||`ulimit [`''opzioni''`]`||b||Visualizza/modifica i limiti di utilizzo di alcune risorse del sistema da parte dell'utente. (A rigore, sono i limiti ''della shell'').||
||`useradd `''opzioni''``|| ||Analogo ad `adduser`, ma &egrave; di pi&ugrave; basso livello. Di preferenza usare l'altro (almeno in Debian).||
||`who` o `w`|| ||riporta chi &egrave; &#8220;loggato&#8221; e quali processi ha in esecuzione||
||`whoami```|| ||visualizza il nome dell'utente attuale||



[[BR]]
== Gestione dei Filesystem ==

||<tablestyle="border:2" :35%>'''Comando/Sintassi'''||<2%> || '''Cosa fa'''||
||`df`|| ||riporta il sommario dei blocchi del disco e degli ''inode'' liberi e usati. Confronta invece `free,du`.||
||`du [`''directory''` o `''file''`]`|| ||Riassume l'uso del disco di ogni file, ricorsivamente per le directory. Confronta invece `free,df`.||
||`fsck [`''opzioni''`] `''device''``[[BR]]`fsck.ext2 [`''opzioni''`] `''device''``[[BR]]...|| ||File system Check: verifica l'integrit&agrave;, ripara il filesystem||
||`fdisk -l`[[BR]]`fdisk [`''opzioni''`] `''device''``|| ||Visualizza / modifica la tabella delle partizioni di un'unit&agrave; disco. (occorre essere super-user anche solo per visualizzare).||
||`fdformat [`''opzioni''`] `''device''`` || ||Formattazione "a basso livello" (???) in generaele quello che serve &egrave; `mkfs`.||
||`mkfs `''device''``[[BR]]`mkfs.ext2 `''device''``[[BR]]...||*||Make file system: formatta un disco||
||`mount [-t `''filesystem''`] `''something somewhere''``[[BR]]`sudo mount -t ext2 /dev/fd0 /media/floppy` ||*||Monta una periferica. `''somewhere''` sar&agrave; il suo nuovo indirizzo (da usare come `''device''`)... deve essere una cartella gi&agrave; esistente!!! Per smontare vedere `umount`||
||`sync || ||Sincronizza un filesystem con la sua cache, ossia scrive su disco gli eventuali dati "in attesa".||
||`umount `''device''``||*||Smonta una periferica. `Confronta mount.`||
||`vol_id -u `''nome_device''``[[BR]]`vol_id -u /dev/sda1`|| ||Ottiene info (in particolare l'UUID) sulla device||


[[BR]]

==Gestione files==

||<tablestyle="border:2" :35%>'''Comando/Sintassi'''||<2%> || '''Cosa fa'''||
||`cd [`''directory''`]`||b*||cambia directory||
||`cmp [`''opzioni''`] `''file1 file2''``|| ||confronta due file e visualizza dove avvengono le differenze (file di testo e file binari). Confronta `diff`.||
||`cp [`''opzioni''`] `''file1 file2''``||*||copia ``''file1''`` in `''file2''``. Questo comando crea o sovrascrive ``''file2''``.||
||`dd [if=`''infile''`] [of=`''outfile''`] [operando=`''valore''`]`|| ||copia un file, converte tra ASCII e EBCDIC o scambia l'ordine di byte, come specificato ||
||`file [`''opzioni''`] `''filename''``|| ||classifica il tipo di file||
||`find `''directory''` [`''opzioni''`] [`''azioni''`]`[[BR]]`find / -xdev -iname "`''filename.ext''"``[[BR]]`find . -name '*.tmp' -exec rm {} \;` ||*||<|2>cerca file basandosi sul tipo o su uno schema. Pu&ograve; anche effettuare una prefissata operazione su tutti i files trovati (e.g. `grep` per cercare i file che contengono un certo testo)||
||`sudo find . -xdev -iname '.*' -type f -exec grep ''text'' '{}' \; -print0|more`|| ||
||`locate `''filename-pattern''``||*||cerca file basandosi sul `''filename-pattern''`. A differenza di `find`, cerca i files solamente all'interno di un suo database, che deve essere aggiornato con `updatedb`.||
||`ln `''sorgente destinazione''`` ||<|2>||<|2>Crea un hard-link di nome ``''destinazione''`` a ``''sorgente''``. '''Non &egrave;''' un nuovo file! La struttura della directory UNIX non &egrave; ad albero, ma piuttosto a grafo aciclico, quindi lo stesso file pu&ograve; essere raggiunto da pi&ugrave; cartelle. Si pu&ogtrave; linkare soltanto un file, e sullo stesso volume.[[BR]] Invece con l'opzione `-s` crea un sotf-link di nome ``''destinazione''`` a ``''sorgente''``. Ossia, un nuovo file che punta all'altro.||
||`ln -s `''sorgente destinazione''``|| ||
||`ls [`''opzioni''`] [`''directory''` o `''file''`]` ||*||elenca il contenuto della directory specificata o i permessi del file specificato (`-l` visualizza i dettagli; `-r` le sottodirectory)||
||`mkdir [`''opzioni''`] `''directory''``||*||crea una directory||
||`mv [`''opzioni''`] `''file1 file2''``||*||muove ``''file1''`` in `''file2''``. Il file &egrave; semplicemente rinominato.||
||`pwd`||b*||stampa la directory di lavoro (corrente)||
||`rm [`''opzioni''`] `''file''``[[BR]]`rm -r `''file''``||*||rimuove (elimina) un file o una directory (`-r` elimina ricorsivamente la directory ed il suo contenuto) (`-1` chiede conferma prima di eliminare i file)||
||`rmdir [`''opzioni''`] `''directory''``||*||rimuove una directory '''vuota'''||
||`touch [`''opzioni''`] [`''data/ora''`] `''file''``|| ||"tocca" un file senza modificarlo, ossia aggiorna l'ora di ultima modifica. Se il file non esiste, di default lo crea.||
||`tree [`''directory''`] || ||visualizza il contenuto di una directory e delle sotto-directory||
||`updatedb`||*||aggiorna il database per la ricerca di files (cfr. `locate`). Bisogna essere super-user.||
||`uudecode [`''file''`]`|| ||decodifica un file codificato con `uuencode`, riportandolo al file originale||
||`uuencode [`''file''`] `''nuovo_nome''``|| ||codifica un file binario in codice ASCII 7-bit; utile quando lo si trasmette via email, per essere poi decodificato come ``''nuovo_nome''`` alla destinazione||
||`whatis [`''opzioni''`] `''filename''``|| ||dice (se riesce) che tipo di oggetto &egrave; filename. Per i comandi ne d&agrave; la descrizione.||
||`whereis [`''opzioni''`] `''comando''``||* ||riporta le locazioni del binario, del sorgente e della pagina `man` per il comando specificato||

[[BR]]


== Archivi ==

||<tablestyle="border:2" :35%>'''Comando/Sintassi'''||<2%> || '''Cosa fa'''||
||`bzip2 [`''opzioni''`] `''files''``||<|2>||<|2>comprime / decomprime un archivio `.bz2`||
||`bunzip2 `''file.bz2''``|| ||
||`bzcat `''file''`.bz2` || ||concatena (lista) il file decompresso a video, lasciando il file compresso su
disco||
||`compress [`''opzioni''`] `''file''``||<|2>||<|2>comprime / decomprime un archivio `.Z` (che contiene un singolo file).||
||`uncompress `''file.Z''``|| ||
||`gzip [`''opzioni''`] `''file''``||<|2>*||<|2>comprime / decomprime un archivio `.gz` (che contiene un singolo file)||
||`gunzip [`''opzioni''`] `''file''``||
||`zcat `''file''`.Z`|| ||concatena (lista) il file decompresso a video, lasciando il file compresso su
disco||
||`tar [`''opzioni''`] [`''files''`]`[[BR]]`tar -xvf ''nomearchivio''.tar`[[BR]]`tar -cvf''nomearchivio''.tar ''files''`[[BR]]`tar -zxvf ''nomearchivio''.tgz`[[BR]]`tar -zcvf ''nomearchivio''.tgz ''files''` ||*||De/comprime archivi `.tar` ("archivio a nastro", non compresso)[[BR]] Estrae un archivio[[BR]] Crea un nuovo archivio[[BR]] Estrae un archivio compresso `.tar.gz` (o `.tgz`).[[BR]] Crea un nuovo archivio compresso `.tar.gz` (o `.tgz`).||
||`zip `[options] ''filename''``||<|2> ||<|2>Comprime / decomprime archivi `.zip`.||
||`unzip `''filename''``||

[[BR]]


== Files testuali ==

||<tablestyle="border:2" :35%>'''Comando/Sintassi'''||<2%> || '''Cosa fa'''||
||`awk/nawk [`''opzioni''`] `''file''``|| ||esamina schemi in un file e processa i risultati||