Comandi utili

ls	(elenco file della directory corrente in ordine ASCII)
ls -l	(elenco dettagliato)

cd path	(cambiare directory posizionandosi al path specificato)
cp file path	(copia un file in un certo path)
mv file path	(sposta un file in un carto path)
rm file	(rimuove il file specificato)
rm -r fileOdirectory	(rimuove ricorsivmente il file, la direcotry e i relativi sotto-file e sotto-directory)
chmod xxx fileOdirectory	(cambia i diritti su di un file o directory, xxx � un numero in notazione ottale. La prima cifra indica i diritti del proprietario del file, il secondo indica i diriti del gruppo cui appartiene il proprietario del file, il terzo indica i diritti di qualunque altro utente. L'accesso in lettura vale 4, in scrittura 2 e in esecuzione 1. es. 754 = 4+2+1 per il prorpeitario, 4+1 per il gruppo, 4 per chiunque altro)

comando > file	(scrive l'output stdout di un comando in un file)
comando >> file	(accoda l'output stdout di un comando al contenuto di un file)
comando < file	(ottiene l'input stdin per un comando da un file)
comando 2> file	(scrive stderr su un file)
comando | comando	(invia l'output stdout del primo comando all'input stdinn del secondo comando)

source o . file	(esegue il contenuto del file copiando una riga per volta nell'attuale processo di bash)
./file	(esegue in batch il contenuto di un file, creando un sottoprocesso di bash)

echo	(stampa qualcosa sullo stdout e va a capo)
echo -n	(stampa qualcosa sullo stdout senza andare a capo)

printf	(formatta stampa qualcosa sullo stduot)
   Formato (%)    Tipo            Risultato
  --------------------------------------------------------------------------
       c          char            singolo carattere
      i,d         int             numero decimale
       o          int             numero ottale
      x,X         int             numero esadecimale
                                  (notazione maiuscola o minuscola)
       u          int             intero senza segno
       s          char *          stampa una stringa terminata con \0
       f          double/float    formato -m.ddd...
      e,E           "             formato scientifico
				  -1.23e002
      g,G           "             "e" o "f" ma piu' compatti
       %            -             stampa il carattere %
  --------------------------------------------------------------------------
  Tra il simbolo % ed il carattere di formato, e' possibile mettere:
     - (segno meno)         - giustificazione a sinistra;
     numero intero          - ampiezza del campo
     m.d                    - m=ampiezza del campo, d=precisione del numero
                              di cifre dopo il punto decimale, o numero di
                              caratteri da una stringa

  Cosi', ad esempio, potremo avere:
     printf "%-2.3f\n" 17.23478
  e l'output a video sara':
     17.235

read		(legge una stringa dallo stdin e la scrive nella variabile REPLY)
read var	(legge una stringa dallo stdin e la scrive nella variabile var)
read -n z	(legge al massimo z caratteri)
read -p "s"	(mostra la stringa "s" prima di leggere l'input)
reat -t z	(aspetta z secondi prima di uscire al prompt e se z non � definita usa TIMEOUT)

cat

basename path	(restituisce il nome dell'ultima directory del path specificato)
dirname path	(restituisce tutto ill path trine l'ultima directory)

wc	(conta newline, parole e caratteri)
	-l	(conta solo newline)
	-w	(conta solo parole)
	-m	(conta solo caratteri)

seq k	(manda in stdout i numeri da 1 a k, uno per riga)

grep
Comando per filtrare il testo all'interno di file specificati utilizzando un'espressione regolare.
Sintassi: grep [opzioni] [-e] modello1 [-e modello2 …] [--] [file1 [file2 …] ]
Caratteri speciali: \<stringa (inizia per stringa), stringa\> (finisce per stringa), [xyz] (uno qualunque di quei caratteri), [^xyz] (un qualunque carattere tranne quelli), [x-y] (un qualunque carattere compreso tra quelli), ^ (inizio della riga), $ (fine della riga).
Opzioni utili: 
	-i	(Ignora le differenze tra lettere maiuscole e minuscole)
	-n	(Precede ogni linea dei risultati con il numero di linea all'interno del file (partendo da 1))
	-l	(Indica solo i nomi dei file in cui � stata trovata almeno una corrispondenza (ciascun file � elencato una sola volta, indipendentemente dal numero di corrispondenze in esso trovate))
	-v	(Nega i modelli specificati, producendo un elenco delle linee che non soddisfano alcun modello)
	-c	(Produce per ciascun file solo il conteggio del numero di linee che corrispondono)

sed
Comando utile per molte cose tra cui sostituire i match di pattern con determinate stringhe.
Caratteri speciali: . (qualsiasi carattere), * (qualunque iterazione del carattere precedente), & (l'intera stringa in input)
Sintassi di un comando di sostituzione: s/pattern/stringa/ esegue per ogni riga la sostituzione del pattern con la stringa specificata.
es: echo roma | sed 's/ro/co/' restituisce coma

awk	(linguaggio di programmazione interpretato, utilizzabile come filtro in questo modo: awk {'print $1'} (stampa il primo campo della riga sullo stdin), awk {'print $1, $3'}	(stampa il primo ed i lterzo campo della riga sullo stdin). I campi sono separati da spazi)

sort	(comando che legge uno o più file di testo (o lo standard input) e ne ordina le linee alfabeticamente oppure secondo il criterio specificato, producendo il risultato sullo standard output o su di un file)
	-u	(Elimina dal risultato le linee duplicate (analogamente a quanto fatto dal comando uniq))
	-f	(Non distingue tra caratteri maiuscoli e minuscoli)
	-r	(Inverte il senso di ordinamento, producendo i risultati a partire dal valore maggiore)
	-n	(Ordina numericamente invece che alfabeticamente)
	-k chiave_di_ordinamento	(Indica una porzione della linea da usare come chiave per l'ordinamento. È possibile specificare questa opzione più volte per definire più chiavi di ordinamento da usare in cascata)

uniq	(scarta ogni linea identica alla precedente)
	-c	(precede ogni linea con un conteggio del numero di volte consecutive in cui � ripetuta)
	-f num	(nel calcolare l'unicità scarta un numero di campi pari a num separati da spazi vuoti)

head	(comando che mostra sullo standard output le prime linee di uno o più file di testo, o dei dati provenienti dallo standard input)
	-n num	(mostra le prime num righe)

tail	(che mostra sullo standard output le ultime linee di dati provenienti da uno o più file di testo o dallo standard input)
	-f	(Se i dati provengono da un file o da una named pipe, fa in modo che tail rimanga in esecuzione (invece di terminare subito) rilevando e mostrando eventuali aggiunte effettuate da parte di altri processi)
	-n pos	(Indica la posizione pos nel file a partire dalla quale mostrare i risultati, espressa in numero di linee a partire dalla fine dei dati (con 1 che indica l'ultima linea). Se pos � preceduto dal segno + (ad esempio +45), la posizione � calcolata invece a partire dall'inizio dei dati (la prima linea ha posizione +1))
	-pos	(Forma storica dell'opzione -n (ad esempio tail -3 equivale a tail -n 3))

tar	(crea archivi, estra, aggiugne e rimuove file da essi)
	-c	(crea archizio)
	-x	(estrae archivio)
	-z	(compressione gzip)
	-j	(compressione bz2)
	-f	(file di output)

who	(mostra sullo standard output gli utenti attualmente collegati al sistema)
whoami	(mostra il nome dell'utente attuale)

sleep k	(mette il sistema in attesa per k secondi)

date	(mostra la data e l'orario attuali, il formato lo si esprime con una stringa del tipo date '+DATE: %m/%d/%y%nTIME:%H:%M:%S')

tr stringa1 stringa2	(trasforma i caratteri della prima stringa trovati nello stdin nei caratteri dellastringa 2, es. echo ciao | tr 'ci' 'bl' manda suto stdout la stringa blao)

set (imposta una serie di valori come i valori di $1 ... $K )

shift (sposta di uno a sinistra i valori delle variabili di input: $1 = $2; $2 = $3; etc. )

ps aux (mostra tutti i processi in esecuzione e relativi proprietari più altre informazioni)
ps -o uid -o "%U" -A	(mostra la coppia uid username e stampa una riga per ogni processo in esecuzione)

variabili predefinitie:
$PS1	(prompt)
$PS2	(prompt secondario)
$PWD	(directory corrente)
$OLDPWD	(directory precedente)
$PATH	(path entro cui cercare gli eseguibili, separati dal carattere ":")
$UID	(id dell'utente attuale)
$RANDOM	(un numero casuale)
$HISFILE	(ubicazione del file che contiene la history)
*
@
#	(numero di parametri con cui � stato chiamato uno script)

array:
nomearray[*] (restituisce concatenazione di tutti elementi usano IFS come separatore)
nomearray[@] (restituisce concatenazione di tutti elementi)
nomearray[#] (restituisce il numero di variabili inizializzate nell'array)

globbing: (riconoscimento di pattern per path/filename)
* (qualunque stringa)
? (qualuqnue carattere)
[xyz] (uno qualunque di quei caratteri)
[!xyz] (un qualunque carattere tranne quelli)
[x-y] (un qualunque carattere compreso tra quelli)

brace expansion; (genera pattern per path/filename)
{x..y} (tutti i caratteri compresi tra quelli, es: touch a{1..3} genera a1, a2 e a3)

espansione varabili:
${var X stringa} (X = 	:- (espande var se esiste altrimenti espande stringa)
			:= (espande var se esiste altrimenti espande stringa e la assegna a var)
			:? (espande var se esiste altrimenti restituisce stringa sullo stderr)
			+  (testa var senza influenzarla) )

${var X pattern} (X =	#  (taglia il più corto match di pattern a partire dall'inizio)
			## (taglia il più lungo match di pattern a partire dall'inizio)
			%  (taglia il più corto match di pattern a partire dalla fine)
			%% (taglia il più lungo match di pattern a partire dalla fine) )

${var X pattern / stringa} (X =	/  (sostituisce stringa al primo match di pattern)
				// (sostituisce stringa a tutti i match di pattern) )

Aritmetica:
let " var = espressione "
$((espressione))
((espressione))
,	(tra un'espressione e l'altra all'interno delle parentesi tonde con $, le esegue tutte ma ritorna come valore solo l'utlima)
bc	(linguaggio per calcolare in virgola mobile, es: k=$(echo "scale=$z; $x/$y" | bc ); echo $k; stampa il risultato di $x/$y con $z cifre decimali)
b#n	(rappresentazione in base b del numero n, es: 2#11 = 10#3)

test:
test o [	(comando che valuta la verità di un espressione)
	-e, -f, -d	(operatori unario su file: esiste, � un file regoalre, � una directory)
	-n, -o		(operatori binari su file: più nuovo, più vecchio)
	-n, -z		(operatori unari su stringe: non � vuota, � vuota)
	=, !=, <, >	(operatori binari su stringhe: uguale, diversa, maggiore, minore in ordine di ASCII)
	-eq, -ne, -lt, -le, -gt, -ge	(operatori binarii su interi: uguale, diverso, minore, minore uguale, maggiore, maggiore uguale)