105.1 Lezione 2

Certificate:

LPIC-1

Version:

5.0

Topic:

105 Shell e Script di Shell

Objective:

105.1 Personalizzare e utilizzare l’ambiente di Shell

Lesson:

2 di 3

Introduzione

Pensa a una variabile come a una scatola immaginaria in cui collocare temporaneamente un’informazione. Come con i suoi script di inizializzazione, Bash classifica le variabili come di shell/locali (quelle che vivono solo entro i limiti della shell in cui sono state create) o di ambiente/globali (quelle ereditate dalle shell secondarie e/o dai processi). Nella lezione precedente abbiamo esaminato la shell e i loro script di configurazione/inizializzazione. È ora importante sottolineare che la potenza di questi file di avvio risiede nel fatto che ci consentono di utilizzare variabili - così come alias e funzioni - che ci aiutano a creare e personalizzare l’ambiente shell di nostra scelta.

Variabili: Assegnazione e Riferimento

Una variabile può essere definita come un nome contenente un valore.

In Bash, dare un valore a un nome è chiamato assegnazione variabile ed è il modo in cui creiamo o impostiamo le variabili. Il processo di accesso al valore contenuto nel nome è chiamato riferimento variabile.

La sintassi per l’assegnazione delle variabili è:

<variable_name>=<variable_value>

Per esempio:

$ distro=zorinos

La variabile distro è uguale a zorinos, cioè c’è una porzione di memoria che contiene il valore zorinos, con distro che è il puntatore a essa.

Da notare, tuttavia, che non può esserci spazio su entrambi i lati del segno di uguale quando si assegna una variabile:

$ distro =zorinos
-bash: distro: command not found
$ distro= zorinos
-bash: zorinos: command not found

A causa del nostro errore, Bash ha letto distro e zorinos come comandi.

Per fare riferimento a una variabile (ovvero, per verificarne il valore) usiamo il comando echo facendo precedere al nome della variabile un segno $:

$ echo $distro
zorinos

Nomi di Variabili

Quando si sceglie il nome delle variabili, ci sono alcune regole che dobbiamo prendere in considerazione.

Il nome di una variabile può contenere lettere (a-z, A-Z), numeri (0-9) e trattini bassi (_):

$ distro=zorinos
$ echo $distro
zorinos
$ DISTRO=zorinos
$ echo $DISTRO
zorinos
$ distro_1=zorinos
$ echo $distro_1
zorinos
$ _distro=zorinos
$ echo $_distro
zorinos

Il nome di una variabile non può iniziare con un numero, altrimenti Bash si confonde:

$ 1distro=zorinos
-bash: 1distro=zorinos: command not found

Non può contenere spazi (nemmeno usando le virgolette); per convenzione, vengono utilizzati i trattini bassi:

$ "my distro"=zorinos
-bash: my: command not found
$ my_distro=zorinos
$ echo $my_distro
zorinos

Valori di Variabili

Per quanto riguarda il riferimento o il valore delle variabili è anche importante considerare una serie di regole.

Le variabili possono contenere qualsiasi carattere alfanumerico (a-z, A-Z, 0-9) così come la maggior parte degli altri caratteri (?, !, *, ., /, ecc.):

$ distro=zorin12.4?
$ echo $distro
zorin12.4?

I valori delle variabili devono essere racchiusi tra virgolette se contengono spazi singoli:

$ distro=zorin 12.4
-bash: 12.4: command not found
$ distro="zorin 12.4"
$ echo $distro
zorin 12.4
$ distro='zorin 12.4'
$ echo $distro
zorin 12.4

I valori delle variabili devono anche essere racchiusi tra virgolette se contengono caratteri come quelli usati per il reindirizzamento (<, >) o il simbolo di pipe (|). L’unica cosa che fa il seguente comando è creare un file vuoto chiamato zorin:

$ distro=>zorin
$ echo $distro

$ ls zorin
zorin

Funziona, però, quando usiamo le virgolette:

$ distro=">zorin"
$ echo $distro
>zorin

Tuttavia, le virgolette singole e doppie non sono sempre intercambiabili. A seconda di ciò che stiamo facendo con una variabile (assegnazione o riferimento), l’uso delle une o delle altre ha implicazioni e produrrà risultati diversi. Nel contesto dell’assegnazione di variabili le virgolette singole prendono tutti i caratteri del valore della variabile letteralmente, mentre le virgolette doppie consentono la sostituzione delle variabili:

$ lizard=uromastyx
$ animal='My $lizard'
$ echo $animal
My $lizard
$ animal="My $lizard"
$ echo $animal
My uromastyx

D’altra parte, quando si fa riferimento a una variabile il cui valore include alcuni spazi iniziali (o extra) — a volte combinati con asterischi — è obbligatorio utilizzare le virgolette doppie dopo il comando echo per evitare field splitting e pathname expansion:

$ lizard="   genus   |   uromastyx"
$ echo $lizard
genus | uromastyx
$ echo "$lizard"
   genus   |   uromastyx

Se il riferimento della variabile contiene un punto esclamativo di chiusura, questo deve essere l’ultimo carattere della stringa (altrimenti Bash penserà che ci riferiamo a un evento history):

$ distro=zorin.?/!os
-bash: !os: event not found
$ distro=zorin.?/!
$ echo $distro
zorin.?/!

Qualsiasi carattere di backslash deve essere preceduto da un’altro backslash . Inoltre, se il backslash è l’ultimo carattere della stringa e non ne mettiamo un’altro, Bash interpreterà che vogliamo un’interruzione di riga e ci darà una nuova riga:

$ distro=zorinos\
>
$ distro=zorinos\\
$ echo $distro
zorinos\

Nelle prossime due sezioni riassumeremo le principali differenze tra le variabili locali e di ambiente.

Variabili Locali o di Shell

Le variabili locali o di shell esistono solo nella shell in cui vengono create. Per convenzione, le variabili locali sono scritte in lettere minuscole.

Creiamo una variabile locale per eseguire alcuni test. Come spiegato sopra, scegliamo un nome di variabile appropriato e lo associamo a un valore appropriato. Per esempio:

$ reptile=tortoise

Usiamo ora il comando echo per fare riferimento alla nostra variabile e controllare che tutto sia andato come previsto:

$ echo $reptile
tortoise

In alcuni scenari, come durante la scrittura di script, l’immutabilità può essere una caratteristica interessante delle variabili. Se vogliamo che le nostre variabili siano immutabili, possiamo crearle readonly:

$ readonly reptile=tortoise

Oppure in due parti:

$ reptile=tortoise
$ readonly reptile

Ora, se proviamo a cambiare il valore di reptile, Bash si rifiuterà:

$ reptile=lizard
-bash: distro: readonly variable

Note	Per elencare tutte le variabili di sola lettura nella nostra sessione corrente, digita `readonly` o `readonly -p` nel terminale.

Un comando utile quando si ha a che fare con le variabili locali è set.

set restituisce tutte le variabili e le funzioni della shell attualmente assegnate. Dal momento che possono essere molte righe (provalo tu stesso!), si consiglia di usarlo in combinazione con un paginatore come less:

$ set | less
BASH=/bin/bash
BASHOPTS=checkwinsize:cmdhist:complete_fullquote:expand_aliases:extglob:extquote:force_fignore:histappend:interactive_comments:login_shell:progcomp:promptvars:sourcepath
BASH_ALIASES=()
BASH_ARGC=()
BASH_ARGV=()
BASH_CMDS=()
BASH_COMPLETION_COMPAT_DIR=/etc/bash_completion.d
BASH_LINENO=()
BASH_SOURCE=()
BASH_VERSINFO=([0]="4" [1]="4" [2]="12" [3]="1" [4]="release" [5]="x86_64-pc-linux-gnu")
BASH_VERSION='4.4.12(1)-release'
(...)

C’è la nostra variabile reptile?

$ set | grep reptile
reptile=tortoise

Sì, c’è!

Tuttavia, reptile, essendo una variabile locale, non verrà trasmessa da alcun processo "figlio" generato dalla shell corrente:

$ bash
$ set | grep reptile
$

E, naturalmente, non possiamo nemmeno visualizzare il suo valore:

$ echo $reptile
$

Note	Digitando il comando `bash` nel terminale apriamo una nuova shell (figlia).

Per annullare l’impostazione di qualsiasi variabile (sia locale che globale), usiamo il comando unset:

$ echo $reptile
tortoise
$ unset reptile
$ echo $reptile
$

Note	`unset` deve essere seguito dal solo nome della variabile (non preceduto dal simbolo `$`).

Variabili Globali o di Ambiente

Esistono variabili globali o di ambiente per la shell corrente e per tutti i processi successivi generati da essa. Per convenzione, le variabili d’ambiente sono scritte in lettere maiuscole:

$ echo $SHELL
/bin/bash

Possiamo passare ricorsivamente il valore di queste variabili ad altre variabili e il valore di queste ultime si espanderà infine a quello delle prime:

$ my_shell=$SHELL
$ echo $my_shell
/bin/bash
$ your_shell=$my_shell
$ echo $your_shell
/bin/bash
$ our_shell=$your_shell
$ echo $our_shell
/bin/bash

Affinché una variabile di shell locale diventi una variabile di ambiente, è necessario utilizzare il comando export:

$ export reptile

Con export reptile abbiamo trasformato la nostra variabile locale in una variabile d’ambiente in modo che le shell secondarie (figlie) possano riconoscerla e usarla:

$ bash
$ echo $reptile
tortoise

Allo stesso modo, export può essere utilizzato per impostare ed esportare una variabile, tutto in una volta:

$ export amphibian=frog

Ora possiamo aprire una nuova istanza di Bash e fare riferimento con successo alla nuova variabile:

$ bash
$ echo $amphibian
frog

Note	Con `export -n <VARIABLE-NAME>` la variabile verrà nuovamente trasformata in una variabile di shell locale.

Il comando export ci darà anche un elenco di tutte le variabili d’ambiente esistenti quando digitato da solo (o con l’opzione -p):

$ export
declare -x HOME="/home/user2"
declare -x LANG="en_GB.UTF-8"
declare -x LOGNAME="user2"
(...)
declare -x PATH="/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games"
declare -x PWD="/home/user2"
declare -x SHELL="/bin/bash"
declare -x SHLVL="1"
declare -x SSH_CLIENT="192.168.1.10 49330 22"
declare -x SSH_CONNECTION="192.168.1.10 49330 192.168.1.7 22"
declare -x SSH_TTY="/dev/pts/0"
declare -x TERM="xterm-256color"
declare -x USER="user2"
declare -x XDG_RUNTIME_DIR="/run/user/1001"
declare -x XDG_SESSION_ID="8"
declare -x reptile="tortoise"

Note	Il comando `declare -x` è equivalente a `export`.

Altri due comandi che possono essere usati per stampare un elenco di tutte le variabili d’ambiente. Sono env e printenv:

$ env
SSH_CONNECTION=192.168.1.10 48678 192.168.1.7 22
LANG=en_GB.UTF-8
XDG_SESSION_ID=3
USER=user2
PWD=/home/user2
HOME=/home/user2
SSH_CLIENT=192.168.1.10 48678 22
SSH_TTY=/dev/pts/0
MAIL=/var/mail/user2
TERM=xterm-256color
SHELL=/bin/bash
SHLVL=1
LOGNAME=user2
XDG_RUNTIME_DIR=/run/user/1001
PATH=/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games
_=/usr/bin/env

Oltre a essere un’alternativa a env, possiamo usare printenv in un modo simile a come usiamo il comando echo per verificare il valore di una variabile:

$ echo $PWD
/home/user2
$ printenv PWD
/home/user2

Nota, tuttavia, che con printenv il nome della variabile non è preceduto da $.

Note	`PWD` memorizza il percorso della directory di lavoro attuale. Apprenderemo in seguito questa e altre variabili d’ambiente comuni.

Esecuzione di un Programma in un Ambiente Modificato

env può essere usato per modificare l’ambiente della shell al momento dell’esecuzione di un programma.

Per avviare una nuova sessione Bash con un ambiente il più vuoto possibile — cancellando la maggior parte delle variabili (così come le funzioni e gli alias) — useremo env con l’opzione -i:

$ env -i bash

Ora la maggior parte delle nostre variabili di ambiente sono scomparse:

$ echo $USER
$

E ne rimangono solo poche:

$ env
LS_COLORS=
PWD=/home/user2
SHLVL=1
_=/usr/bin/printenv

Possiamo anche usare env per impostare una particolare variabile per un particolare programma.

Nella nostra lezione precedente, parlando di shell non di login non interattive, abbiamo visto come gli script non leggano alcun file di avvio standard ma cerchino invece il valore della variabile BASH_ENV e lo usano come file di avvio se esiste.

Dimostriamo questo processo:

Creiamo il nostro file di avvio chiamato .startup_script con il seguente contenuto:
```
CROCODILIAN=caiman
```
Scriviamo uno script Bash chiamato test_env.sh con il seguente contenuto:
```
#!/bin/bash

echo $CROCODILIAN
```
Abbiamo impostato il bit eseguibile per il nostro script test_env.sh:
```
$ chmod +x test_env.sh
```
Infine, usiamo env per impostare BASH_ENV su .startup_script per l’esecuzione di test_env.sh:
```
$ env BASH_ENV=/home/user2/.startup_script ./test_env.sh
caiman
```
Il comando env è implicito anche se lo eliminiamo:
```
$ BASH_ENV=/home/user2/.startup_script ./test_env.sh
caiman
```

Note	Se non capisci la riga `#!/bin/bash` o il comando `chmod+x`, niente panico! Impareremo tutto il necessario sullo scripting della shell nelle prossime lezioni. Per ora, ricorda che per eseguire uno script dalla sua directory usiamo `./some_script`.

Variabili d’Ambiente Comuni

È giunto il momento di rivedere alcune delle variabili di ambiente più rilevanti impostate nei file di configurazione di Bash.

DISPLAY

Relativo al server X, il valore di questa variabile è normalmente costituito da tre elementi:

Il nome host (la sua assenza significa localhost) dove è in esecuzione il server X.
I due punti come delimitatore.
Un numero (normalmente è 0 e si riferisce al display del computer).
```
$ printenv DISPLAY
:0
```
Un valore vuoto per questa variabile indica un server senza un sistema X Window. Un numero extra — come in my.xserver:0:1 — farebbe riferimento al numero dello schermo se ne esistesse più di uno.

HISTCONTROL

Questa variabile controlla quali comandi vengono salvati in HISTFILE (vedi sotto). Esistono tre possibili valori:

ignorespace

I comandi che iniziano con uno spazio non verranno salvati.

ignoredups

Un comando uguale al precedente non verrà salvato.

ignoreboth

I comandi che rientrano in una delle due categorie precedenti non verranno salvati.

$ echo $HISTCONTROL
ignoreboth

HISTSIZE

Questo imposta il numero di comandi da salvare in memoria durante la sessione della shell.

$ echo $HISTSIZE
1000

HISTFILESIZE

Questo imposta il numero di comandi da salvare in HISTFILE dall’inizio alla fine della sessione:

$ echo $HISTFILESIZE
2000

HISTFILE

Il nome del file che memorizza tutti i comandi mentre vengono digitati. Per impostazione predefinita, questo file si trova in ~/.bash_history:

$ echo $HISTFILE
/home/user2/.bash_history

Note	Per visualizzare il contenuto di `HISTFILE`, è sufficiente digitare `history`. In alternativa, possiamo specificare il numero di comandi che vogliamo vedere passando un argomento (il numero dei comandi più recenti) a `history` come in `history 3`.

HOME

Questa variabile memorizza il percorso assoluto della directory home dell’utente corrente e viene impostata quando l’utente effettua il login.

Il seguente codice — da ~/.profile — è autoesplicativo (fornisce "$HOME/.bashrc" se esiste):

    # include .bashrc if it exists
    if [ -f "$HOME/.bashrc" ]; then
	. "$HOME/.bashrc"
    fi

Note	Se non capisci bene l’istruzione `if`, non preoccuparti: fai riferimento alle lezioni sullo scripting di shell.

Ricorda che ~ è equivalente a $HOME:

$ echo ~; echo $HOME
/home/carol
/home/carol

Note	I comandi possono essere concatenati con un punto e virgola (`;`).

Possiamo anche dimostrarlo con un’istruzione if:

$ if [ ~ == "$HOME" ]; then echo "true"; else echo "false"; fi
true

Note	Ricorda: il segno di uguale `=` viene utilizzato per l’assegnazione delle variabili. `==` viene utilizzato per verificare l’uguaglianza.

HOSTNAME

Questa variabile memorizza il nome TCP/IP del computer host:

$ echo $HOSTNAME
debian

HOSTTYPE

Memorizza l’architettura del processore del computer host:

$ echo $HOSTTYPE
x86_64

LANG

Questa variabile salva le impostazioni internazionali del sistema:

$ echo $LANG
en_UK.UTF-8

LD_LIBRARY_PATH

Questa variabile è costituita da un insieme di directory separate da due punti dove si trovano le librerie condivise:

$ echo $LD_LIBRARY_PATH
/usr/local/lib

MAIL

Questa variabile memorizza il file in cui Bash cerca la casella di posta dell’utente:

$ echo $MAIL
/var/mail/carol

Un altro valore comune per questa variabile è /var/spool/mail/$USER.

MAILCHECK

Questa variabile memorizza un valore numerico che indica in secondi la frequenza con cui Bash controlla la nuova posta:

$ echo $MAILCHECK
60

PATH

Questa variabile di ambiente memorizza l’elenco delle directory in cui Bash cerca i file eseguibili quando gli viene chiesto di eseguire qualsiasi programma. Nella nostra macchina di esempio questa variabile è impostata tramite il file /etc/profile a livello di sistema:

if [ "`id -u`" -eq 0 ]; then
  PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
else
  PATH="/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games"
fi
export PATH

Attraverso l’istruzione if viene testata l’identità dell’utente e — a seconda del risultato del test (root o altro) — otterremo un PATH o l’altro. Infine il PATH scelto viene propagato con export.

Osserva due cose riguardo al valore di PATH:

I nomi delle directory vengono scritti utilizzando percorsi assoluti.

I due punti vengono utilizzati come delimitatori.

Se volessimo includere la cartella /usr/local/sbin nel PATH per gli utenti regolari, modificheremo la riga in modo che assomigli a questo:

(...)
else
  PATH="/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games:/usr/local/sbin"
fi
export PATH

Ora possiamo vedere come cambia il valore della variabile quando accediamo come utente normale:

# su - carol
$ echo $PATH
/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games:/usr/local/sbin

Note	Avremmo potuto anche aggiungere `/usr/local/sbin` al `PATH` dell’utente dalla riga di comando digitando `PATH=/usr/local/sbin:$PATH` o `PATH=$PATH:/usr/local/sbin` Nel primo caso rendiamo `/usr/local/sbin` la prima directory in cui cercare i file eseguibili, nel secondo lo rendiamo l’ultimo.

PS1

Questa variabile memorizza il valore del prompt di Bash. Nella seguente porzione di codice (anche da /etc/profile), l’istruzione if verifica l’identità dell’utente e fornisce di conseguenza un prompt specifico (# per root o $ per utenti regolari):

if [ "`id -u`" -eq 0 ]; then
  PS1='# '
else
  PS1='$ '
fi

Note	L `id` di `root` è `0`. Diventa `root` e provalo tu stesso con `id -u`.

Altre variabili del prompt includono:

PS2: Normalmente impostato su > e usato come prompt di continuazione per lunghi comandi multilinea.
PS3: Usato come prompt per il comando select.
PS4: Normalmente impostato su + e utilizzato per il debug.

SHELL

Questa variabile memorizza il percorso assoluto della shell corrente:

$ echo $SHELL
/bin/bash

USER

Memorizza il nome dell’utente corrente:

$ echo $USER
carol

Esercizi Guidati

Osserva l’assegnazione della variabile nella colonna “Comando(i)” e indica se la variabile risultante è “Locale” o “Globale”:

Comando(i) Locale Globale

debian=mother

ubuntu=deb-based

mint=ubuntu-based; export mint

export suse=rpm-based

zorin=ubuntu-based
Studia il “Comando” e l' “Output” e spiegane il significato:

Comando Output Significato

echo $HISTCONTROL

ignoreboth

echo ~

/home/carol

echo $DISPLAY

reptilium:0:2

echo $MAILCHECK

60

echo $HISTFILE

/home/carol/.bash_history

Le variabili vengono impostate in modo errato nella colonna “Command Errato”. Fornisci le informazioni mancanti sotto “Comando Giusto” e “Riferimento della Variabile” in modo da ottenere l'“Output Previsto”:

Comando Errato Comando Giusto Riferimento della Variabile Output Previsto

lizard =chameleon

chameleon

cool lizard=chameleon

chameleon

lizard=cha|me|leon

cha|me|leon

lizard=/** chameleon **/

/** chamelon **/

win_path=C:\path\to\dir\

C:\path\to\dir\

Considera lo scopo e scrivi il comando appropriato:

Scopo Comando

Imposta la lingua della shell corrente sullo spagnolo UTF-8 (es_ES.UTF-8).

Stampa il nome della directory di lavoro corrente.

Fai riferimento alla variabile d’ambiente che memorizza le informazioni sulle connessioni ssh.

Imposta PATH per includere /home/carol/scripts come ultima directory in cui cercare gli eseguibili.

Imposta il valore di my_path come PATH.

Imposta il valore di my_path a quello della variabile PATH.

Crea una variabile locale chiamata mammal e assegnale il valore gnu:
Usando la sostituzione delle variabili, crea un’altra variabile locale chiamata var_sub con il valore appropriato in modo che quando ci si richiama tramite echo $var_sub otteniamo: The value of mammal is gnu:
Trasforma mammal in una variabile d’ambiente:
Cercalo con set e grep:
Cercalo con env e grep:
Crea, in due comandi consecutivi, una variabile d’ambiente chiamata BIRD il cui valore è penguin:
Crea, in un unico comando, una variabile d’ambiente chiamata NEW_BIRD il cui valore è yellow-eyed penguin:
Supponendo che tu sia user2, crea una cartella chiamata bin nella tua directory home:
Digita il comando per aggiungere la cartella ~/bin al tuo PATH in modo che sia la prima directory dove bash cerca i binari:
Per garantire che il valore di PATH rimanga inalterato durante i riavvii, quale parte di codice — sotto forma di un’istruzione if — inseriresti in ~/.profile?

Esercizi Esplorativi

let: valuta le espressioni aritmetiche:
- Cerca nella pagine di man o una ricerca web per let e le sue implicazioni quando si impostano le variabili e crea una nuova variabile locale denominata my_val il cui valore è 10 — come risultato della somma di 5 più 5:
  
  Ora crea un’altra variabile chiamata your_val il cui valore è 5 — come risultato della divisione del valore di "my_val" per 2:
Il risultato di un comando in una variabile? Ovviamente questo è possibile; si chiama sostituzione di comando. Investigalo e studia la seguente funzione chiamata music_info:
```
music_info(){
latest_music=`ls -l1t ~/Music | head -n 6`
echo -e "Your latest 5 music files:\n$latest_music"
}
```
Il risultato del comando ls -l1t ~/Music | head -n 6 diventa il valore della variabile latest_music. Quindi si fa riferimento alla variabile latest_music nel comando echo (che restituisce il numero totale di byte occupati dalla cartella Music e gli ultimi cinque file musicali memorizzati nella cartella Music — uno per riga).

Quale dei seguenti è un’alternativa valida a:
```
latest_music=`ls -l1t ~/Music | head -n 6`
```
Opzione A:
```
latest_music=$(ls -l1t ~/Music| head -n 6)
```
Opzione B:
```
latest_music="(ls -l1t ~/Music| head -n 6)"
```
Opzione C:
```
latest_music=((ls -l1t ~/Music| head -n 6))
```

Sommario

In questa lezione abbiamo imparato:

Le variabili sono una parte molto importante dell’ambiente della shell poiché vengono utilizzate dalla shell stessa e da altri programmi.
Come assegnare e fare riferimento alle variabili.
Le differenze tra le variabili locali e globlali (o di ambiente).
Come creare variabili readonly.
Come trasformare una variabile locale in una variabile d’ambiente con il comando export.
Come elencare tutte le variabili d’ambiente.
Come eseguire un programma in un ambiente modificato.
Come rendere le variabili persistenti con l’aiuto degli script di avvio.
Alcune variabili d’ambiente comuni: DISPLAY, HISTCONTROL, HISTSIZE, HISTFILESIZE, HISTFILE, HOME, HOSTNAME, HOSTTYPE, LANG, LD_LIBRARY_PATH, MAIL, MAILCHECK, PATH, PS1 (e altre variabili di prompt), SHELL e USER.
Il significato della tilde (~).
Le basi delle istruzioni if.

Comandi utilizzati in questa lezione:

echo: Mostra il valore di una variabile
ls: Elenca il contenuto della directory.
readonly: Rende le variabili immutabili. Elenca tutte le variabili di sola lettura nella sessione corrente.
set: Elenca tutte le variabili e le funzioni nella sessione corrente.
grep: Stampa le linee che corrispondono a un pattern.
bash: Esegue una nuova shell Bash
unset: Annulla le variabili.
export: Trasforma una variabile locale in una variabile d’ambiente. Elenca le variabili d’ambiente.
env: Elenca le variabili d’ambiente. Esegue un programma in un ambiente modificato.
printenv: Elenca le variabili d’ambiente. Fai riferimento a una variabile.
chmod: Modifica i bit di modalità di un file, per esempio, renderlo eseguibile.
history: Elenca i comandi precedenti.
su: Cambia lo user ID o diventa superutente.
id: Visualizza lo user ID.

Risposte agli Esercizi Guidati

Osserva l’assegnazione della variabile nella colonna “Comando(i)” e indica se la variabile risultante è “Locale” o “Globale”:

Comando(i) Locale Globale

debian=mother

Sì

No

ubuntu=deb-based

Sì

No

mint=ubuntu-based; export mint

No

Sì

export suse=rpm-based

No

Sì

zorin=ubuntu-based

Sì

No

Studia il “Comando” e l' “Output” e spiegane il significato:

Comando Output Significato

echo $HISTCONTROL

ignoreboth

Sia i comandi duplicati che quelli che iniziano con uno spazio non verranno salvati nell' history.

echo ~

/home/carol

La HOME di carol è /home/carol.

echo $DISPLAY

reptilium:0:2

Il sistema reptilium ha X come server in esecuzione e stiamo usando la seconda schermata del display .

echo $MAILCHECK

60

La posta verrà controllata ogni minuto.

echo $HISTFILE

/home/carol/.bash_history

L'`history` sarà salvata all’interno di /home/carol/.bash_history.

Comando Errato Comando Giusto Riferimento della Variabile Output Previsto

lizard =chameleon

lizard=chameleon

echo $lizard

chameleon

cool lizard=chameleon

cool_lizard=chameleon (per esempio)

echo $cool_lizard

chameleon

lizard=cha|me|leon

lizard="cha|me|leon" o lizard='cha|me|leon'

echo $lizard

cha|me|leon

lizard=/** chameleon **/

lizard="/** chameleon **/" o lizard='/** chameleon **/'

echo "$lizard"

/** chamelon **/

win_path=C:\path\to\dir\

win_path=C:\\path\\to\\dir\\

echo $win_path

C:\path\to\dir\

Considera lo scopo e scrivi il comando appropriato:

Scopo Comando

Imposta la lingua della shell corrente sullo spagnolo UTF-8 (es_ES.UTF-8).

LANG=es_ES.UTF-8

Stampa il nome della directory di lavoro corrente.

echo $PWD o pwd

Fare riferimento alla variabile d’ambiente che memorizza le informazioni sulle connessioni ssh.

echo $SSH_CONNECTION

Imposta PATH per includere /home/carol/scripts come ultima directory in cui cercare gli eseguibili.

PATH=$PATH:/home/carol/scripts

Imposta il valore di my_path come PATH.

my_path=PATH

Imposta il valore di my_path a quello della variabile PATH.

my_path=$PATH

Crea una variabile locale chiamata mammal e assegnale il valore gnu:
```
mammal=gnu
```
Usando la sostituzione delle variabili, crea un’altra variabile locale chiamata var_sub con il valore appropriato in modo che, quando si richiama tramite echo $var_sub, si ottenga: The value of mammal is gnu:
```
var_sub="The value of mammal is $mammal"
```
Trasforma mammal in una variabile d’ambiente:
```
export mammal
```
Cercalo con set e grep:
```
set | grep mammal
```
Cercalo con env e grep:
```
env | grep mammal
```
Crea, in due comandi consecutivi, una variabile d’ambiente chiamata BIRD il cui valore è penguin:
```
BIRD=penguin; export BIRD
```
Crea, in un unico comando, una variabile d’ambiente chiamata NEW_BIRD il cui valore è yellow-eyed penguin:
```
export NEW_BIRD="yellow-eyed penguin"
```
o
```
export NEW_BIRD='yellow-eyed penguin'
```
Supponendo che tu sia user2, crea una cartella chiamata bin nella tua directory home:
```
mkdir ~/bin
```
o
```
mkdir /home/user2/bin
```
o
```
mkdir $HOME/bin
```
Digita il comando per aggiungere la cartella ~/bin al tuo PATH in modo che sia la prima directory dove bash cerca i binari:
```
PATH="$HOME/bin:$PATH"
```
PATH=~/bin:$PATH o PATH=/home/user2/bin:$PATH sono egualmente validi.
Per garantire che il valore di PATH rimanga inalterato durante i riavvii, quale parte di codice — sotto forma di un’istruzione if — inseriresti in ~/.profile?
```
if [ -d "$HOME/bin" ] ; then
    PATH="$HOME/bin:$PATH"
fi
```

Risposte agli Esercizi Esplorativi

let: valuta le espressioni aritmetiche:
- Cerca nella pagine di man o una ricerca web per let e le sue implicazioni quando si impostano le variabili e crea una nuova variabile locale denominata my_val il cui valore è 10 — come risultato della somma di 5 più 5:
  let "my_val = 5 + 5"
  o
  let 'my_val = 5 + 5'
- Ora crea un’altra variabile chiamata your_val il cui valore è 5 — come risultato della divisione del valore di "my_val" per 2:
  let "your_val = $my_val / 2"
  o
  let 'your_val = $my_val / 2'
Il risultato di un comando in una variabile? Ovviamente questo è possibile; si chiama sostituzione di comando. Investigalo e studia la seguente funzione chiamata music_info:
```
music_info(){
latest_music=`ls -l1t ~/Music | head -n 6`
echo -e "Your latest 5 music files:\n$latest_music"
}
```
Il risultato del comando ls -l1t ~/Music | head -n 6 diventa il valore della variabile latest_music. Quindi si fa riferimento alla variabile latest_music nel comando echo (che restituisce il numero totale di byte occupati dalla cartella Music e gli ultimi cinque file musicali memorizzati nella cartella Music — uno per riga).

Quale dei seguenti è un’alternativa valida a:
```
latest_music=`ls -l1t ~/Music | head -n 6`
```
È l’opzione A:
```
latest_music=$(ls -l1t ~/Music| head -n 6)
```