Capitolo 1. Tutorial GNU/Linux

Ecco alcuni metodi di base per ottenere il prompt di shell per root usando la password di root.

Si digita Ctrl-D, cioè il tasto_Ctrl_sinistro e il tasto_d vengono premuti contemporaneamente al prompt dei comandi per chiuderà l'attività della shell. Se si è nella console a caratteri, in questo modo si ritorna al prompt di login. Anche se questi caratteri di controllo vengono indicati con le lettere maiuscole, come "control D", non è necessario premere il tasto Maiusc. Per indicare Ctrl-D viene anche usata l'espressione abbreviata ^D. In alternativa si può digitare "exit".

In quest'ultimo modo, se si è in un emulatore di terminale (x-terminal-emulator(1)), lo si può chiudere.

Quando, dopo aver fatto qualcosa di strano come "cat un-qualche-file-binario", lo schermo impazzisce digitare "reset" al prompt dei comandi. Mentre lo si digita il comando potrebbe non essere visualizzato. Si può anche usare "clear" per pulire lo schermo.

Sebbene anche l'installazione minima del sistema Debian, senza alcun ambiente desktop, fornisca le funzionalità Unix di base è una buona idea installare con apt-get(8) alcuni pacchetti aggiuntivi per la riga di comando e i terminali a caratteri basati su curses, come mc e vim con cui i principianti possono fare i primi passi. Eseguire i comandi seguenti.

# apt-get update
 ...
# apt-get install mc vim sudo aptitude
 ...

Se questi pacchetti sono già installati, nessun nuovo pacchetto sarà installato.

Potrebbe essere una buona idea leggere un po' di documentazione.

Si possono installare alcuni di questi pacchetti usando i comandi seguenti.

# apt-get install package_name

Se non si vuole usare il proprio account utente principale per le esercitazioni descritte in seguito, si può creare un account utente per esercitarsi, ad esempio pesce con il comando seguente.

# adduser fish

Rispondere a tutte le domande.

In questo modo si crea un nuovo account chiamato pesce. Dopo aver fatto pratica si può rimuover questo account e la sua directory home digitando quanto segue.

# deluser --remove-home fish

Nei sistemi non Debian e Debian specializzati, le attvità descritte sopra devono usare invece le utilità a basso livello useradd(8) e userdel(8).

Per la tipica postazione di lavoro di un unico utente, come il sistema desktop Debian su un PC portatile, è frequente l'uso di una semplice configurazione di sudo(8), come qui di seguito descritto, per permettere all'utente non privilegiato, ad esempio pinguino, di ottenere privilegi di amministratore con la sola propria password, senza quella dell'utente root.

# echo "penguin  ALL=(ALL) ALL" >> /etc/sudoers

In alternativa è uso comune usare la configurazione seguente per permettere all'utente non privilegiato, ad esempio pinguino, di ottenere privilegi di amministratore senza alcuna password.

# echo "penguin  ALL=(ALL) NOPASSWD:ALL" >> /etc/sudoers

Questo trucco dovrebbe essere usato esclusivamente per le postazioni di lavoro con un solo utente, in cui l'utente è anche l'amministratore.

	Avvertimento
	Non impostare account per utenti regolari su postazioni di lavoro multi-utente in questo modo perché ciò sarebbe un grosso problema per la sicurezza del sistema.

Attenzione

Nell'esempio precedente la password e l'account di pinguino richiedono altrettanta protezione della password e account dell'utente root. I privilegi di amministrazione in questo contesto sono forniti a qualcuno che è autorizzato ad eseguire i compiti di amministrazione del sistema sulla macchina. Non dare mai tali privilegi ad un manager del dipartimento di Amministrazione della propria azienda o al proprio capo, a meno che non siano autorizzati e capaci.

Nota

Per fornire privilegi di accesso a specifici device e file, si dovrebbe considerare l'uso dei gruppi per dare un accesso limitato, invece di usare i privilegi di root attraverso sudo(8). Con una configurazione più attenta e precisa, sudo(8) può garantire privilegi amministrativi limitati ad altri utenti in un sistema condiviso, senza rendere nota la password di root. Questo può aiutare la tracciabilità su host con più di un amministratore, in modo che si possa dire chi ha fatto cosa. D'altra parte si potrebbe anche volere che nessuno abbia tali privilegi.

Si è ora pronti a giocare con il sistema Debian senza rischi fintanto che si usa l'account utente non privilegiato.

Ecco alcune nozioni di base sui file Unix.

Per cambiare il proprietario di un file da un account root si usa chown(1). Per cambiare il gruppo di un file dall'account del proprietario o da quello di root si usa chgrp(1). Per cambiare i permessi di accesso di file o directory dall'account del proprietario o da quello di root si usa chmod(1). La sintassi di base per manipolare un file pippo è la seguente.

# chown newowner foo
# chgrp newgroup foo
# chmod  [ugoa][+-=][rwxXst][,...] foo

Per esempio si può fare in modo che l'utente pippo sia il proprietario di un albero di directory condivisa dal gruppo pluto con i seguenti comandi.

# cd /some/location/
# chown -R foo:bar .
# chmod -R ug+rwX,o=rX .

Ci sono altri tre bit speciali di permessi.

Nell'output di "ls -l" il valore di questi bit è maiuscolo se il bit di permesso di esecuzione nascosto da essi è non impostato.

L'impostazione del bit set user ID per un file eseguibile permette ad un utente di eseguire quel file con l'ID del proprietario del file (per esempio root). In modo simile, l'impostazione del bit set group ID per un file eseguibile permette ad un utente di eseguire il file con l'ID del gruppo a cui appartiene il file (per esempio root). Poiché l'impostazione di questi bit può causare rischi in termini di sicurezza, il loro uso richiede una particolare cautela.

Sembra complicato, ma è in realtà piuttosto semplice. Se si guardano le prime colonne (2-10) nell'output del comando "ls -l" e le si leggono come una rappresentazione binaria (base=2) dei permessi sui file (dove "-" equivale a "0" e "rwx" equivalgono a "1"), le ultime 3 cifre del valore numerico dei permessi dovrebbero apparire come la corretta rappresentazione dei permessi sui file in numerazione ottale (base=8).

Per esempio, provare a fare quanto segue.

$ touch foo bar
$ chmod u=rw,go=r foo
$ chmod 644 bar
$ ls -l foo bar
-rw-r--r-- 1 penguin penguin 0 Oct 16 21:39 bar
-rw-r--r-- 1 penguin penguin 0 Oct 16 21:35 foo

	Suggerimento
	Se si deve aver accesso alle informazioni visualizzate da "ls -l" in script di shell, si dovrebbero usare i comandi pertinenti, come test(1), stat(1) e readlink(1). Si possono usare anche i comandi interni della shell come "[" o "test".

I permessi che vengono applicati ad un file o una directory appena creati sono limitati dal comando interno della shell umask. Vedere dash(1), bash(1) e builtins(7).

 (file permissions) = (requested file permissions) & ~(umask value)

Il sistema Debian usa, in modo predefinito, uno schema UPG (User Private Group, gruppo privato dell'utente). Ogni volta che viene aggiunto un nuovo utente al sistema, viene creato un UPG; questo ha lo stesso nome dell'utente per il quale è stato creato e quell'utente è l'unico membro dell'UPG. Lo schema UPG rende sicura l'impostazione della umask a 0002 dato che ogni utente ha il proprio gruppo privato. (In alcune varianti di Unix è abbastanza comune impostare tutti gli utenti normali come appartenenti ad un unico gruppo users ed è in quel caso una buona idea impostare umask a 0022 per ragioni di sicurezza.)

	Suggerimento
	Abilitare UPG inserendo "umask 002" nel file ~/.bashrc.

	Avvertimento
	Assicurarsi di salvare le modifiche non ancora salvate prima di fare il riavvio o azioni simili.

Si può aggiungere l'utente pinguino ad un gruppo uccelli in due passi:

Si può rimuovere l'utente pinguino dal gruppo uccelli in due passi:

Qualsiasi tentativo di riavvio a caldo è un fragile sostituto di un vero riavvio completo nei sistemi desktop moderni.

	Nota
	In alternativa, si possono aggiungere dinamicamente gli utenti ai gruppi durante il processo di autenticazione aggiungendo la riga "auth optional pam_group.so" al file "/etc/pam.d/common-auth" e configurando "/etc/security/group.conf". (Vedere Capitolo 4, Autenticazione e controllo degli accessi.)

I dispositivi hardware sono, in un sistema Debian, semplicemente un altro tipo di file. Se si hanno problemi ad accedere a dispositivi quali CD-ROM e chiavette USB da un account utente, si dovrebbe inserire quell'utente nel gruppo appropriato.

Alcuni importanti gruppi pre-impostati dal sistema permettono ai loro membri l'accesso a file e device particolari senza i privilegi di root.

	Suggerimento
	È necessario far parte del gruppo dialout per riconfigurare il modem, comporre numeri, ecc. Se però root crea file di configurazione predefiniti per i peer fidati in "/etc/ppp/peers/", è necessario solamente far parte del grupo dip per creare una connessione IP dialup a tali peer fidati usando i comandi pppd(8), pon(1) e poff(1).

Alcuni importanti gruppi pre-impostati dal sistema permettono ai loro membri di eseguire particolari comandi senza i privilegi di root.

Per l'elenco completo degli utenti e gruppi forniti dal sistema, vedere la recente versione del documento "Utenti e gruppi" in "/usr/share/doc/base-passwd/users-and-groups.html" fornito dal pacchetto base-passwd.

Vedere passwd(5), group(5), shadow(5), newgrp(1), vipw(8), vigr(8) e pam_group(8) per informazioni sui comandi di gestione di utenti e gruppi sul sistema.

Ci sono tre tipi di orari per un file GNU/Linux.

	Nota
	ctime non è l'orario di creazione del file.

	Nota
	L'attuale significato di atime sui sistemi GNU/Linux potrebbe essere diverso dalla sua definizione storica in Unix.

	Nota
	Le opzioni di mount "noatime" e "relatime" sono introdotte per migliorare le prestazioni in lettura del file system nei normali casi d'uso. Semplici operazioni di lettura dei file con l'opzione "strictatime" comportano lunghe operazioni di scrittura per aggiornare l'attributo atime. L'attributo atime però è raramente utilizzato, a parte per il file mbox(5). Vedere mount(8).

Usare il comando touch(1) per cambiare l'orario di file esistenti.

Per gli orari, il comando ls produce in output stringhe localizzate con la localizzazione non inglese ("it_IT.UTF-8").

$ LANG=C  ls -l foo
-rw-rw-r-- 1 penguin penguin 0 Oct 16 21:35 foo
$ LANG=en_US.UTF-8  ls -l foo
-rw-rw-r-- 1 penguin penguin 0 Oct 16 21:35 foo
$ LANG=fr_FR.UTF-8  ls -l foo
-rw-rw-r-- 1 penguin penguin 0 oct. 16 21:35 foo

	Suggerimento
	Vedere Sezione 9.3.4, «Visualizzazione personalizzata di date e orari» per personalizzare l'output di "ls -l".

Ci sono due metodi per associale un file "pippo" ad un diverso nome file "pluto".

Ci sono alcuni file di device speciali.

Per far sì che MC cambi la directory di lavoro in uscita e si sposti con cd nella directory, suggerisco di modificare "~/.bashrc" per includere uno scipt fornito nel pacchetto mc.

. /usr/lib/mc/mc.sh

Vedere mc(1) (sotto l'opzione "-P") per capirne la ragione. (Se non è chiaro esattamento quello di cui sto parlando, si può tornare a questo più tardi.)

MC può essere avviato nel modo seguente.

$ mc

MC si prende cura di tutte le operazioni sui file attraverso i suoi menu, richiedendo perciò solo un minimo sforzo da parte dell'utente. Premere semplicemente F1 per ottenere la schermata di aiuto. Si può giocherellare con MC premendo semplicemente i tasti freccia e i tasti funzione.

	Nota
	In alcune console, come gnome-terminal(1), le pressioni dei tasti funzione potrebbero essere rubate dal programma di console. Si possono disabilitare queste funzionalità per gnome-terminal nei menu "Preferenze" → "Generale" e "Scorciatoie".

Se si incontrano problemi di codifica dei caratteri con visualizzazione di caratteri spazzatura, l'aggiunta dell'opzione "-a" alla riga di comando di MC può aiutare a prevenirli.

L'impostazione predefinita è con due pannelli di directory contenenti gli elenchi dei file. Un'altra utile modalità è l'impostazione della finestra destra per contenere le "informazioni" per vedere informazioni sui privilegi di accesso dei file, ecc. Di seguito sono elencati alcuni tasti essenziali. Con il demone gpm(8) in esecuzione, si può anche usare il mouse in una console a caratteri Linux. (Assicurarsi di premeri il tasto Maiusc per ottenere il comportamento normale di taglia e incolla in MC.)

L'editor interno ha un interessante schema per il taglia e incolla. La pressione di F3 marca l'inizio di una selezione, una seconda pressione di F3 marca la fine della selezione e la evidenzia. Si può poi muovere il cursore. Se si preme F6, l'area selezionata viene spostata nella posizione del cursore. Se si preme F5 l'area selezionata viene copiata ed inserita alla posizione del cursore. F2 salva il file. F10 fa uscire. La maggior parte dei tasti cursore funziona in modo intuitivo.

Si può avviare direttamente questo editor su di un file usando uno dei comandi seguenti.

$ mc -e filename_to_edit

$ mcedit filename_to_edit

Questo non è un editor multi-finestra, ma si possono usare più console Linux per ottenere lo stesso effetto. Per copiare tra finestre, usare i tasti Alt-Fn per cambiare console virtuale e usare "File→Insert file" o "File→Copy to file" per spostare una porzione di un file in un altro file.

Questo editor interno può essere rimpiazzato da qualsiasi editor esterno a propria scelta.

Inoltre molti programmi usano la variabile d'ambiente "$EDITOR" o "$VISUAL" per decidere quale editor usare. Se inizialmente non ci si trova a proprio agio con vim(1) o nano(1), si può impostare queste variabili a "mcedit" aggiungendo le righe seguenti al file "~/.bashrc".

export EDITOR=mcedit
export VISUAL=mcedit

Io raccomando di impostarle a "vim", se possibile.

Se non ci si trova a proprio agio con vim(1), si può continuare ad usare mcedit(1) per la maggior parte dei compiti di manutenzione del sistema.

MC è un visualizzatore molto intelligente. È un grande strumento per cercare parole in documenti. Lo uso sempre per i file nella directory "/usr/share/doc". È il metodo più veloce per navigare tra una massa di informazioni Linux. Questo visualizzatore può essere avviato direttamente usando uno dei comandi seguenti.

$ mc -v path/to/filename_to_view

$ mcview path/to/filename_to_view

Per far sì che queste funzionalità di visualizzazione dei file e di file virtuali funzionino, i file visualizzabili non dovrebbero essere impostati come eseguibili. Cambiare il loro stato usando chmod(1) o attraverso il menu file di MC.

MC può essere usato per accedere a file in Internet. Premere F9 per andare nel menu, usare "Invio" e "h" per attivare un file system Shell. Inserire un URL nella forma "sh://[utente@]macchina[:opzioni]/[dir-remota]", che recupera la directory remota che apparirà come una directory locale usando ssh.

Dato che la shell di login può essere utilizzata da alcuni programmi di inizializzazione del sistema, è prudente mantenerla come bash(1) e evitare di cambiare la shell di login in chsh(1).

Se si desidera usare un prompt di shell interattiva diverso, impostarlo dalla configurazione dell'emulatore di terminale in GUI o avviarlo da ~/.bashrc, ad esempio mettendoci "exec /usr/bin/zsh -i -l" o "exec /usr/bin/fish -i -l".

	Suggerimento
	Sebbene le shell in stile POSIX condividano la stessa sintassi di base, esse possono differire nel comportamento relativo a cose anche basilari, come le variabili della shell e l'espansione dei modelli glob. Per i dettagli controllare la loro documentazione.

In questo capitolo del tutorial la shell interattiva considerata è sempre bash.

Si può personalizzare il comportamento di bash(1) con "~/.bashrc".

Per esempio provare quanto segue.

# enable bash-completion
if ! shopt -oq posix; then
  if [ -f /usr/share/bash-completion/bash_completion ]; then
    . /usr/share/bash-completion/bash_completion
  elif [ -f /etc/bash_completion ]; then
    . /etc/bash_completion
  fi
fi

# CD upon exiting MC
. /usr/lib/mc/mc.sh

# set CDPATH to a good one
CDPATH=.:/usr/share/doc:~:~/Desktop:~
export CDPATH

PATH="${PATH+$PATH:}/usr/sbin:/sbin"
# set PATH so it includes user's private bin if it exists
if [ -d ~/bin ] ; then
  PATH="~/bin${PATH+:$PATH}"
fi
export PATH

EDITOR=vim
export EDITOR

	Suggerimento
	Si possono trovare altri suggerimenti sulla personalizzazione di bash(1), come Sezione 9.3.6, «Comandi colorati», in Capitolo 9, Suggerimenti per il sistema.

	Suggerimento
	Il pacchetto bash-completion permette il completamento automatico per bash.

Qui, la selezione PRINCIPALE è l'intervallo di testo evidenziato. All'interno del programma di terminale viene usato invece Shift-Ctrl-C per evitare di terminare un programma in esecuzione.

La rotella centrale presente nei mouse moderni viene considerata come il pulsante di mezzo e può essere usata per fare il corrispondente clic. Cliccare contemporaneamente con i pulsanti destro e sinistro funziona da clic di mezzo nelle situazioni in cui si hanno mouse a 2 pulsanti.

Per poter usare il mouse in una console a caratteri Linux, è necessario che gpm(8) sia in esecuzione come demone.

Il comando less(1) è il paginatore (navigatore del contenuto dei file) migliorato. Legge il file specificato nell'argomento del comando o il suo standard input. Premere "h" se si ha bisogno di aiuto nella navigazione con il comando less. Può fare molto di più di more(1) e può essere fornito di superpoteri eseguendo "eval $(lesspipe)" o "eval $(lessfile)" nello script di avvio della shell. Vedere ulteriori informazioni in "/usr/share/doc/less/LESSOPEN". L'opzione "-R" permette output raw e abilita le sequenze di escape ANSI per i colori. Vedere less(1).

	Suggerimento
	Nel comando less digitare "h" per vedere la schermata di aiuto, digitare "/" o "?" per cercare una stringa e digitare "-i" per cambiare la sensibilità a maiuscole/minuscole.

Debian è fornita con svariati editor differenti. Si raccomanda di installare, come detto in precedenza, il pacchetto vim.

Debian fornisce un accesso unificato all'editor predefinito di sistema attraverso il comando "/usr/bin/editor" in modo che altri programmi (ad esempio reportbug(1)) possano richiamarlo. Lo si può modificare con il comando seguente.

$ sudo update-alternatives --config editor

Io raccomando ai principianti la scelta di "/usr/bin/vim.basic" invece di"/usr/bin/vim.tiny" dato che supporta l'evidenziazione della sintassi.

	Suggerimento
	Molti programmi usano la variabile d'ambiente "$EDITOR" o "$VISUAL" per decidere quale editor usare (vedereSezione 1.3.5, «L'editor interno di MC» e Sezione 9.4.11, «Personalizzare i programmi da avviare». Per coerenza, in un sistema Debian, impostare queste variabili a "/usr/bin/editor". (Storicamente "$EDITOR" era "ed" e "$VISUAL" era "vi".)

Usare il programma "vimtutor" per imparare ad usare vim attraverso un corso tutorial interattivo.

Il programma vim cambia il suo comportamento in risposta ai tasti premuti in base alla modalità (mode). La digitazione con i tasti nel buffer è fatta soprattutto in modalità INSERT e in modalità REPLACE. Spostare il cursore viene fatto soprattutto in modalità NORMAL. La selezione interattiva viene fatta in modalità VISUAL. Se si digita ":" in modalità NORMAL si cambia la sua modalità in Ex-mode. Ex-mode accetta comandi.

	Suggerimento
	Vim viene distribuito con il pacchetto Netrw. Netrw supporta lettura e scrittura di file, navigazione di directory in una rete e navigazione locale! Provare Netrw con "vim ." (un punto come argomento) e leggere il suo manuale con ":help netrw".

L'output dei comandi di shell può scorrere fuori dallo schermo e potrebbe essere perduto per sempre. È buona norma registrare le attività di shell in un file in modo da poterle riguardare in seguito. Questo tipo di registro è essenziale quando si fa una qualsiasi attività di amministrazione del sistema.

	Suggerimento
	Il nuovo Vim (versione>=8.2) può essere utilizzato per registrare in modo pulito le attività di shell usando la modalità TERMINAL-JOB. Vedere Sezione 1.4.8, «Usare vim».

Il metodo base per registrare l'attività di shell è di eseguirla sotto script(1).

Per esempio, provare a fare quanto segue.

$ script
Script started, file is typescript

Eseguire qualsiasi comando di shell sotto script.

Premere Ctrl-D per uscire da script.

$ vim typescript

È bene imparare i comandi Unix di base. Il termine "Unix" è qui usato in senso lato; ogni SO clone di Unix offre di solito comandi equivalenti. Il sistema Debian non fa eccezione. Non ci si preoccupi se, al momento, alcuni comandi non funzionano come si vorrebbe. Se si usa alias nella shell, i corrispondenti output dei comandi sono diversi. Questi esempi non sono pensati per essere eseguiti necessariamente in questo ordine.

Provare tutti i comandi seguenti da un account utente non privilegiato.

Nota

Unix tradizionalmente nasconde i nomi di file che iniziano con ".". Sono tradizionalmente file contenenti informazioni di configurazione e preferenze dell'utente. Per il comando cd vedere builtins(7). Il paginatore predefinito del sistema di base di Debian è more(1) che non ha lo scorrimento all'indietro. Installando il pacchetto less, con la riga di comando "apt-get install less", less(1) diventa il paginatore predefinito e si può così scorrere il testo all'indietro usando i tasti freccia. I caratteri "[" e "]" nella espressione regolare del comando "ps aux | grep -e "[e]xim4*"" sopra citato, permettono a grep di evitare di trovare corrispondenza con sé stesso. La parte "4*" nella espressione regolare significa 0 o più ripetizioni del carattere "4" e perciò permette a grep di trovare corrispondenza sia con "exim" sia con "exim4". Sebbene il carattere "*" sia usato nei nomi di file con metacaratteri della shell e nelle espressioni regolari, il suo significato è diverso nei due casi. Si possono imparare le espressioni regolari da grep(1).

Come esercizio, esplorare le directory e dare un'occhiata al sistema usando i comandi citati sopra. Se si hanno domande su uno qualsiasi dei comandi in console, assicurarsi di leggere la pagina di manuale.

Per esempio, provare a fare quanto segue.

$ man man
$ man bash
$ man builtins
$ man grep
$ man ls

Può essere un po' difficile abituarsi allo stile delle pagine man perché sono piuttosto concise, in particolar modo le più vecchie e tradizionali. Una volta che ci si fa la mano, però, si apprezza la loro concisione.

Notare che molti comandi in stile Unix, inclusi quelli da GNU e BSD, mostrano una breve informazione di aiuto se li si invoca in uno dei modi seguenti (o in alcuni casi se lo si fa senza usare opzioni).

$ commandname --help
$ commandname -h

La localizzazione predefinita è definita nella variabile d'ambiente "$LANG" ed è configurata nella forma "LANG=xx_YY.UTF-8" dall'installatore o dalla successiva configurazione della GUI, es. "Impostazioni" → "Regione e lingua" → "Lingua" / "Formati" per GNOME.

	Nota
	Io raccomando di configurare l'ambiente di sistema usando per il momento solo la variabile "$LANG" e di tenersi alla larga dalle variabili "$LC_*" a meno che non sia strettamente necessario.

Il valore completo di localizzazione impostato nella variabile "$LANG" consiste di 3 parti: "xx_YY.ZZZZ".

Una tipica esecuzione di un comando usa una sequenza sulla riga della shell come la seguente.

$ echo $LANG
en_US.UTF-8
$ date -u
Wed 19 May 2021 03:18:43 PM UTC
$ LANG=fr_FR.UTF-8 date -u
mer. 19 mai 2021 15:19:02 UTC

In questo caso il programma date(1) viene eseguito con differenti valori di localizzazione.

Quando si digita un comando nella shell, questa cerca il comando nelle directory nell'elenco contenuto nella variabile d'ambiente "$PATH". Il valore della variabile d'ambiente "$PATH" è anche chiamato percorso di ricerca della shell.

In una installazione Debian standard, la variabile d'ambiente "$PATH" degli account utente può non includere "/usr/sbin" e "/usr/sbin". Il comando ifconfig, per esempio, deve essere eseguito con il percorso completo, come in "/usr/sbin/ifconfig". (Il comando simile ip si trova in "/usr/bin".)

Si può modificare la variabile d'ambiente "$PATH" della shell Bash tramite il file "~/.bash_profile" o "~/.bashrc".

Molti comandi memorizzano una configurazione specifica per l'utente nella directory home e cambiano il loro comportamento in base al suo contenuto. La directory home è identificata dalla variabile d'ambiente "$HOME".

Alcuni comandi accettano argomenti. Gli argomenti che iniziano con "-" o "--" sono chiamati opzioni e controllano il comportamento del comando.

$ date
Thu 20 May 2021 01:08:08 AM JST
$ date -R
Thu, 20 May 2021 01:08:12 +0900

Spesso si desidera che un comando abbia effetto su un gruppo di file senza dover digitarli tutti. I modelli di espansione dei nomi di file che usano i glob della shell, a volte detti metacaratteri o caratteri jolly, facilitano questo compito.

Per esempio, provare a fare quanto segue.

$ mkdir junk; cd junk; touch 1.txt 2.txt 3.c 4.h .5.txt ..6.txt
$ echo *.txt
1.txt 2.txt
$ echo *
1.txt 2.txt 3.c 4.h
$ echo *.[hc]
3.c 4.h
$ echo .*
. .. .5.txt ..6.txt
$ echo .*[^.]*
.5.txt ..6.txt
$ echo [^1-3]*
4.h
$ cd ..; rm -rf junk

Vedere glob(7).

	Nota
	A differenza della normale espansione dei nomi della shell, il modello shell "*" cercato dal comando find(1) con la ricerca "-name" ecc., trova corrispondenza anche con nomi di file che iniziano con ".". (Nuova funzionalità POSIX.)

	Nota
	Si può manipolare il comportamento di BASH in relazione ai modelli di glob usando le sue opzioni shopt incorporate come "dotglob", "noglob", "nocaseglob", "nullglob", "extglob", ecc. Vedere bash(1).

Ogni comando restituisce il suo stato di uscita (variabile "$?") come valore restituito.

Per esempio provare quanto segue.

$ [ 1 = 1 ] ; echo $?
0
$ [ 1 = 2 ] ; echo $?
1

	Nota
	Notare che, nel contesto logico della shell, il successo è trattato come il valore logico VERO che ha valore numerico 0 (zero). Questo è in qualche modo non intuitivo ed è bene rimarcarlo.

È bene cercare di ricordare i seguenti idiomi per comandi di shell che vengono digitati sulla stessa riga come parte del comando di shell.

Il sistema Debian è un sistema multi-tasking. I compiti sullo sfondo permettono agli utenti di eseguire più programmi in una singola shell. La gestione dei processi sullo sfondo coinvolge i comandi interni della shell jobs, fg, bg e kill. Leggere le sezioni "SIGNALS" e "JOB CONTROL" di bash(1) e builtins(1).

Per esempio, provare a fare quanto segue.

$ </etc/motd pager

$ pager </etc/motd

$ pager /etc/motd

$ cat /etc/motd | pager

Benché tutti i 4 esempi di ridirezione della shell mostrino la stessa cosa, l'ultimo esempio esegue un comando cat aggiuntivo e spreca risorse senza motivo.

La shell permette di aprire file usando il comando interno execcon un descrittore di file arbitrario.

$ echo Hello >foo
$ exec 3<foo 4>bar  # open files
$ cat <&3 >&4       # redirect stdin to 3, stdout to 4
$ exec 3<&- 4>&-    # close files
$ cat bar
Hello

I descrittori di file 0-2 sono predefiniti.

Si possono impostare alias per i comandi usati di frequente.

Per esempio, provare a fare quanto segue.

$ alias la='ls -la'

Ora "la" funziona da scorciatoia per "ls -la" che elenca tutti i file nel formato di elencazione esteso.

Si possono elencare tutti gli alias esistenti con alias (vedere la sezione "SHELL BUILTIN COMMANDS" in bash(1)).

$ alias
...
alias la='ls -la'

Si può identificare il percorso esatto o l'identità di un comando con type (vedere la sezione "SHELL BUILTIN COMMANDS") di bash(1)).

Per esempio, provare a fare quanto segue.

$ type ls
ls is hashed (/bin/ls)
$ type la
la is aliased to ls -la
$ type echo
echo is a shell builtin
$ type file
file is /usr/bin/file

In questo caso ls era stato cercato di recente mentre "file" no, percio "ls" risulta "hashed", cioè la shell ha un record interno per un accesso veloce alla posizione del comando "ls".

	Suggerimento
	Vedere Sezione 9.3.6, «Comandi colorati».

Ci sono alcuni strumenti di elaborazione del testo che sono usati molto spesso in un sistema *nix.

Le espressioni regolari di emacs sono fondamentalmente BRE, ma sono state estese per trattare "+" e "?" come i metacaratteri nelle ERE. Perciò, nelle espressioni regolari di emacs, non è necessario proteggerli con il carattere di escape "\".

Per effettuare ricerche di testo usando espressioni regolari si può usare grep(1).

Per esempio, provare a fare quanto segue.

$ egrep 'GNU.*LICENSE|Yoyodyne' /usr/share/common-licenses/GPL
GNU GENERAL PUBLIC LICENSE
GNU GENERAL PUBLIC LICENSE
Yoyodyne, Inc., hereby disclaims all copyright interest in the program

	Suggerimento
	Vedere Sezione 9.3.6, «Comandi colorati».

Per le espressioni di sostituzione alcuni caratteri hanno un significato particolare.

Per le stringhe di sostituzione Perl viene usato «$&» invece di «&» e «$n» invece di «\n».

Per esempio, provare a fare quanto segue.

$ echo zzz1abc2efg3hij4 | \
sed -e 's/\(1[a-z]*\)[0-9]*\(.*\)$/=&=/'
zzz=1abc2efg3hij4=
$ echo zzz1abc2efg3hij4 | \
sed -E -e 's/(1[a-z]*)[0-9]*(.*)$/=&=/'
zzz=1abc2efg3hij4=
$ echo zzz1abc2efg3hij4 | \
perl -pe 's/(1[a-z]*)[0-9]*(.*)$/=$&=/'
zzz=1abc2efg3hij4=
$ echo zzz1abc2efg3hij4 | \
sed -e 's/\(1[a-z]*\)[0-9]*\(.*\)$/\2===\1/'
zzzefg3hij4===1abc
$ echo zzz1abc2efg3hij4 | \
sed -E -e 's/(1[a-z]*)[0-9]*(.*)$/\2===\1/'
zzzefg3hij4===1abc
$ echo zzz1abc2efg3hij4 | \
perl -pe 's/(1[a-z]*)[0-9]*(.*)$/$2===$1/'
zzzefg3hij4===1abc

In questo esempio si faccia particolare attenzione allo stile delle espressioni regolari tra parentesi e come le stringhe corrispondenti siano usate nel processo di sostituzione del testo dai diversi strumenti.

Queste espressioni regolari possono essere usate per spostare il cursore e per fare sostituzioni di testo anche in alcuni editor.

La barra inversa, "\" alla fine della prima riga nella riga di comando di shell protegge il carattere di a capo rendendolo uno spazio e continuando l'input della riga di comando di shell nella riga successiva.

Leggere tutte le pagine man relative per imparare l'uso di questi comandi.

Il comando ed(1) può sostituire tutte le occorrenze di "DA_REGEX" con "A_TESTO" in "file".

$ ed file <<EOF
,s/FROM_REGEX/TO_TEXT/g
w
q
EOF

Il comando sed(1) può sostituire tutte le occorrenze di "DA_REGEX" con "A_TESTO" in "file".

$ sed -i -e 's/FROM_REGEX/TO_TEXT/g' file

Il comando vim(1) può sostituire tutte le occorrenze di "DA_REGEX" with "A_TESTO" in "file" usando il comando ex(1).

$ vim '+%s/FROM_REGEX/TO_TEXT/gc' '+update' '+q' file

	Suggerimento
	Il modificatore "c" nell'esempio soprastante assicura che venga chiesta la conferma interattiva per ciascuna sostituzione.

Si possono elaborare file multipli ("file1", "file2" e "file3") in modo simile con vim(1) o perl(1).

$ vim '+argdo %s/FROM_REGEX/TO_TEXT/gce|update' '+q' file1 file2 file3

	Suggerimento
	Il modificatore "e" nell'esempio soprastante evita che un errore di nessuna corrispondenza trovata ("No match") rompa il processo.

$ perl -i -p -e 's/FROM_REGEX/TO_TEXT/g;' file1 file2 file3

Nell'esempio perl(1), "-i" è per la modificain-situ di ciascun file interessato, e "-p" è perreiterare implicitamente il comando su tutti i file specificati.

	Suggerimento
	L'uso dell'opzione "-i.bak" invece di "-i" preserva una copia del file originale aggiungendo il suffisso ".bak" al suo nome file. Questo permette di ripristinare le cose più facilmente in caso di errori in sostituzioni complesse.

	Nota
	ed(1) e vim(1) usano BRE; perl(1) usa ERE.

Considerare per esempio un file ti testo chiamato "DPL" in cui sono elencati, in un formato separato da spazi, alcuni nomi di leader del progetto Debian pre-2004 e la data della loro installazione.

Ian     Murdock   August  1993
Bruce   Perens    April   1996
Ian     Jackson   January 1998
Wichert Akkerman  January 1999
Ben     Collins   April   2001
Bdale   Garbee    April   2002
Martin  Michlmayr March   2003

	Suggerimento
	Vedere "Una breve storia di Debian" per la storia della Guida del progetto Debian aggiornata.

Awk viene usato spesso per estrarre dati da questo tipo di file.

Per esempio, provare a fare quanto segue.

$ awk '{ print $3 }' <DPL                   # month started
August
April
January
January
April
April
March
$ awk '($1=="Ian") { print }' <DPL          # DPL called Ian
Ian     Murdock   August  1993
Ian     Jackson   January 1998
$ awk '($2=="Perens") { print $3,$4 }' <DPL # When Perens started
April 1996

Questo tipo di file può anche essere analizzato con le shell tipo Bash.

Per esempio, provare a fare quanto segue.

$ while read first last month year; do
    echo $month
  done <DPL
... same output as the first Awk example

In questo caso, il comando incorporato read usa i caratteri in "$IFS" (internal field separator, separatore di campi interno) per suddividere le righe in parole.

Se si modifica "$IFS" in ":", si possono analizzare facilmente con la shell i file "/etc/passwd".

$ oldIFS="$IFS"   # save old value
$ IFS=':'
$ while read user password uid gid rest_of_line; do
    if [ "$user" = "bozo" ]; then
      echo "$user's ID is $uid"
    fi
  done < /etc/passwd
bozo's ID is 1000
$ IFS="$oldIFS"   # restore old value

(Se si usa Awk per fare la stessa cosa, usare "FS=':'" per impostare il separatore di campi.)

IFS viene anche usato dalla shell per suddividere i risultati dell'espansione di parametri, sostituzione di comandi ed espansioni aritmetiche. Queste non avvengono all'interno delle virgolette singole o doppie. Il valore predefinito di IFS è la combinazione di spazio, tab e <a capo>.

Essere prudenti nell'uso di questi trucchetti di shell con IFS. Possono accadere strane cose quando la shell interpreta alcune parti dello script come suo input.

$ IFS=":,"                        # use ":" and "," as IFS
$ echo IFS=$IFS,   IFS="$IFS"     # echo is a Bash builtin
IFS=  , IFS=:,
$ date -R                         # just a command output
Sat, 23 Aug 2003 08:30:15 +0200
$ echo $(date -R)                 # sub shell --> input to main shell
Sat  23 Aug 2003 08 30 36 +0200
$ unset IFS                       # reset IFS to the default
$ echo $(date -R)
Sat, 23 Aug 2003 08:30:50 +0200

Gli script seguenti fanno alcune cose carine se inseriti in una pipe.