Linux Professional Institute Learning Logo.
Torna al contenuto principale
  • Home
    • Tutte le Risorse
    • LPI Learning Materials
    • Collabora
    • Publishing Partner
    • Diventa un Publishing Partner
    • FAQ
    • Collaboratori
    • Contatto
  • LPI.org
105.1 Lezione 2
Argomento 105: Shell e Script di Shell
105.1 Personalizzare e utilizzare l'ambiente di shell
  • 105.1 Lezione 1
  • 105.1 Lezione 2
  • 105.1 Lezione 3
105.2 Personalizzare o scrivere semplici script
  • 105.2 Lezione 1
  • 105.2 Lezione 2
Argomento 106: Interfacce Utente e Desktop
106.1 Installare e configurare X11
  • 106.1 Lezione 1
106.2 Desktop grafici
  • 106.2 Lezione 1
106.3 Accessibilità
  • 106.3 Lezione 1
Argomento 107: Attività Amministrative
107.1 Gestire account utente e gruppo e file di sistema correlati
  • 107.1 Lezione 1
  • 107.1 Lezione 2
107.2 Automatizzare le attività di amministrazione del sistema attraverso la pianificazione
  • 107.2 Lezione 1
  • 107.2 Lezione 2
107.3 Localizzazione e internazionalizzazione
  • 107.3 Lezione 1
Argomento 108: Servizi Essenziali di Sistema
108.1 Mantenere l'orario di sistema
  • 108.1 Lezione 1
  • 108.1 Lezione 2
108.2 Logging di sistema
  • 108.2 Lezione 1
  • 108.2 Lezione 2
108.3 Concetti base dei Mail Transfer Agent (MTA)
  • 108.3 Lezione 1
108.4 Gestire stampa e stampanti
  • 108.4 Lezione 1
Argomento 109: Fondamenti di Networking
109.1 Fondamenti dei protocolli Internet
  • 109.1 Lezione 1
  • 109.1 Lezione 2
109.2 Configurazione di rete persistente
  • 109.2 Lezione 1
  • 109.2 Lezione 2
109.3 Risoluzione dei problemi di base di una rete
  • 109.3 Lezione 1
  • 109.3 Lezione 2
109.4 Configurare un client DNS
  • 109.4 Lezione 1
Argomento 110: Sicurezza
110.1 Eseguire attività di amministrazione della sicurezza
  • 110.1 Lezione 1
110.2 Configurare la sicurezza dell'host
  • 110.2 Lezione 1
110.3 Proteggere i dati con la crittografia
  • 110.3 Lezione 1
  • 110.3 Lezione 2
How to get certified
  1. Argomento 105: Shell e Script di Shell
  2. 105.1 Personalizzare e utilizzare l'ambiente di shell
  3. 105.1 Lezione 2

105.1 Lezione 2

Certificazione:

LPIC-1

Versione:

5.0

Argomento:

105 Shell e Script di Shell

Obiettivo:

105.1 Personalizzare e utilizzare l’ambiente di Shell

Lezione:

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:

  1. Creiamo il nostro file di avvio chiamato .startup_script con il seguente contenuto:

    CROCODILIAN=caiman
  2. Scriviamo uno script Bash chiamato test_env.sh con il seguente contenuto:

    #!/bin/bash
    
    echo $CROCODILIAN
  3. Abbiamo impostato il bit eseguibile per il nostro script test_env.sh:

    $ chmod +x test_env.sh
  4. 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

  1. 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

  2. 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

  3. 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\

  4. 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.

  5. Crea una variabile locale chiamata mammal e assegnale il valore gnu:

  6. 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:

  7. Trasforma mammal in una variabile d’ambiente:

  8. Cercalo con set e grep:

  9. Cercalo con env e grep:

  10. Crea, in due comandi consecutivi, una variabile d’ambiente chiamata BIRD il cui valore è penguin:

  11. Crea, in un unico comando, una variabile d’ambiente chiamata NEW_BIRD il cui valore è yellow-eyed penguin:

  12. Supponendo che tu sia user2, crea una cartella chiamata bin nella tua directory home:

  13. Digita il comando per aggiungere la cartella ~/bin al tuo PATH in modo che sia la prima directory dove bash cerca i binari:

  14. 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

  1. 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:

  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 globali (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

  1. 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

  2. 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.

  3. 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

    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\

  4. 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

  5. Crea una variabile locale chiamata mammal e assegnale il valore gnu:

    mammal=gnu
  6. 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"
  7. Trasforma mammal in una variabile d’ambiente:

    export mammal
  8. Cercalo con set e grep:

    set | grep mammal
  9. Cercalo con env e grep:

    env | grep mammal
  10. Crea, in due comandi consecutivi, una variabile d’ambiente chiamata BIRD il cui valore è penguin:

    BIRD=penguin; export BIRD
  11. 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'
  12. 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
  13. 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.

  14. 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

  1. 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'
  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)

Linux Professional Institute Inc. Tutti i diritti riservati. Visita il sito Learning Materials: https://learning.lpi.org
Quest'opera è sotto la licenza 'Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International License'.

Prossima Lezione

105.1 Personalizzare e utilizzare l'ambiente di shell (105.1 Lezione 3)

Leggi la prossima Lezione

Linux Professional Institute Inc. Tutti i diritti riservati. Visita il sito Learning Materials: https://learning.lpi.org
Quest'opera è sotto la licenza 'Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International License'.

LPI è una organizzazione non-profit.

© 2023 Linux Professional Institute (LPI) è lo standard di certificazione globale e l'organizzazione di supporto alla carriera per i Professionisti Open Source. Con più di 200,000 titolari di Certificazione, è il primo e il più grande ente di Certificazione Open Source e Linux vendor-neutral. LPI ha professionisti certificati in oltre 180 Paesi, offre i suoi Esami in più lingue e ha centinaia di Partner di formazione in tutto il mondo.

La nostra missione è promuovere l'uso dell'Open Source supportando le persone che vi lavorano.

  • LinkedIn
  • flogo-RGB-HEX-Blk-58 Facebook
  • Twitter
  • Contattaci
  • Privacy & Cookie Policy

Trovato un errore? Per favore scrivi a contattaci.

© 1999–2023 The Linux Professional Institute Inc. Tutti i diritti riservati.