105.1 Lezione 3

Certificate:

LPIC-1

Version:

5.0

Topic:

105 Shell e Script di Shell

Objective:

105.1 Personalizzare e utilizzare l’ambiente di Shell

Lesson:

3 di 3

Introduzione

Dopo aver esaminato le shell, gli script di avvio e le variabili nelle lezioni precedenti, completeremo l’intero argomento della personalizzazione della shell dando un’occhiata a due elementi di shell molto interessanti: alias e funzioni. In effetti l’intero gruppo di variabili, alias e funzioni — e la loro influenza reciproca — è ciò che costituisce l’ambiente della shell.

Il principale punto di forza di queste due caratteristiche di Shell ha a che fare con il concetto di incapsulamento: offrono la possibilità di mettere insieme — sotto un unico comando — una serie di ulteriori comandi ripetitivi o ricorrenti.

Creazione di Alias

Un alias è un nome sostitutivo per altro/i comando/i. Può essere eseguito come fosse un qualsiasi altro eseguibile, ma esegue invece uno o più comandi e relative opzioni base della definizione dell’alias stesso.

La sintassi per la dichiarazione degli alias è abbastanza semplice. Gli alias vengono dichiarati scrivendo la parola chiave alias seguita dall’assegnazione dello stesso. Nello specifico, l’assegnazione dell’alias consiste nel nome dell’alias, un carattere di uguale e uno o più commandi:

alias alias_name=command(s)

Per esempio:

$ alias oldshell=sh

Questo strano alias avvierà un’istanza della shell sh originale quando l’utente digita oldshell sul terminale:

$ oldshell
$

Il potere degli alias sta nel fatto che ci permette di scrivere versioni brevi di comandi lunghi:

$ alias ls='ls --color=auto'

Note	Per informazioni su `ls` e sui suoi colori, digita `man dir_colors` sul terminale.

Allo stesso modo, possiamo creare alias per una serie di comandi concatenati - il punto e virgola (;) è usato come delimitatore. Possiamo, per esempio, avere un alias che ci fornisce informazioni sulla posizione dell’eseguibile git e sulla sua versione:

$ alias git_info='which git;git --version'

Per richiamare un alias, digitiamo il suo nome nel terminale:

$ git_info
/usr/bin/git
git version 2.7.4

Il comando alias produrrà un elenco di tutti gli alias disponibili nel sistema:

$ alias
alias git-info='which git;git --version'
alias ls='ls --color=auto'
alias oldshell='sh'

Il comando unalias rimuove gli alias. Possiamo, per esempio, unalias git-info e vedere come scompare dall’elenco:

$ unalias git-info
$ alias
alias ls='ls --color=auto'
alias oldshell='sh'

Come abbiamo visto con l'`alias hi='echo We salute you.'` in una lezione precedente, dobbiamo racchiudere i comandi tra virgolette (singole o doppie) quando — a causa di argomenti o parametri — contengono spazi :

$ alias greet='echo Hello world!'
$ greet
Hello world!

I comandi con spazi includono anche quelli con opzioni:

$ alias ll='ls -al'

Ora ll elencherà tutti i file, inclusi quelli nascosti (a), nel formato lungo (l).

Possiamo utilizzare le variabili negli alias:

$ reptile=uromastyx
$ alias greet='echo Hello $reptile!'
$ greet
Hello uromastyx!

La variabile può essere assegnata anche all’interno dell’alias:

$ alias greet='reptile=tortoise; echo Hello $reptile!'
$ greet
Hello tortoise!

Possiamo sfuggire (escape) a un alias con \:

$ alias where?='echo $PWD'
$ where?
/home/user2
$ \where?
-bash: where?: command not found

L’escape di un alias è utile quando quest’ultimo ha lo stesso nome di un normale comando. In questo caso, l’alias ha la precedenza sul comando originale, che però è ancora accessibile mediante l’escape dell’alias.

Allo stesso modo, possiamo inserire un alias all’interno di un altro alias:

$ where?
/home/user2
$ alias my_home=where?
$ my_home
/home/user2

Inoltre, possiamo anche inserire una funzione all’interno di un alias come verrà mostrato di seguito.

Espansione e Valutazione delle Virgolette negli Alias

Quando si utilizzano virgolette con variabili di ambiente, le virgolette singole rendono dinamica l’espansione:

$ alias where?='echo $PWD'
$ where?
/home/user2
$ cd Music
$ where?
/home/user2/Music

Differentemente, con le virgolette doppie l’espansione viene eseguita in modo statico:

$ alias where?="echo $PWD"
$ where?
/home/user2
$ cd Music
$ where?
/home/user2

Persistenza degli Alias: Script di Avvio

Proprio come con le variabili, affinché i nostri alias acquisiscano persistenza, dobbiamo inserirli negli script di inizializzazione. Come già sappiamo, un buon file in cui gli utenti possono inserire i propri alias personali è ~/.bashrc. Probabilmente troverai già alcuni alias (la maggior parte dei quali commentati e pronti per essere utilizzati rimuovendo il # iniziale):

$ grep alias .bashrc
# enable color support of ls and also add handy aliases
    alias ls='ls --color=auto'
    #alias dir='dir --color=
    #alias vdir='vdir --color=
    #alias grep='grep --color=
    #alias fgrep='fgrep --color'
    #alias egrep='egrep --color=
# some more ls aliases
#ll='ls -al'
#alias la='ls -A'
#alias l='ls -CF'
# ~/.bash_aliases, instead of adding them here directly.
if [ -f ~/.bash_aliases ]; then
   . ~/.bash_aliases

Come puoi leggere nelle ultime tre righe, ci viene offerta la possibilità di avere il nostro file dedicato agli alias — ~/.bash_aliases — e di farlo richiamare da .bashrc. Quindi possiamo seguire questa strada, popolando tale file:

###########
# .bash_aliases:
# a file to be populated by the user's personal aliases (and sourced by ~/.bashrc).
###########
alias git_info='which git;git --version'
alias greet='echo Hello world!'
alias ll='ls -al'
alias where?='echo $PWD'

Creazione di Funzioni

Rispetto agli alias, le funzioni sono più programmatiche e flessibili, specialmente quando si tratta di sfruttare tutto il potenziale delle variabili incorporate speciali di Bash e dei parametri posizionali. Sono anche ottimi per lavorare con strutture di controllo del flusso come loop o condizionali. Possiamo pensare a una funzione come a un comando che include la logica attraverso blocchi o raccolte di altri comandi.

Due Sintassi per la Creazione di Funzioni

Esistono due sintassi valide per definire le funzioni.

Usando la parola chiave function

Da un lato, possiamo usare la parola chiave function, seguita dal nome della funzione e dai comandi tra parentesi graffe:

function function_name {
command #1
command #2
command #3
.
.
.
command #n
}

Usando ()

Dall’altro, possiamo tralasciare la parola chiave function e utilizzare invece due parentesi subito dopo il nome della funzione:

function_name() {
command #1
command #2
command #3
.
.
.
command #n
}

È normale inserire funzioni in file o script. Tuttavia, possono anche essere scritti direttamente nel prompt della shell con ogni comando su una riga diversa — nota PS2(>) che indica una nuova riga dopo un’interruzione di riga:

$ greet() {
> greeting="Hello world!"
> echo $greeting
> }

In ogni caso e indipendentemente dalla sintassi che scegliamo, se decidiamo di saltare le interruzioni di riga e scrivere una funzione in una sola riga, i comandi devono essere separati da punto e virgola (notare anche il punto e virgola dopo l’ultimo comando):

$ greet() { greeting="Hello world!"; echo $greeting; }

bash non ha dato errori quando abbiamo premuto Invio, quindi la nostra funzione è pronta per essere invocata. Per richiamare una funzione, dobbiamo digitare il suo nome nel terminale:

$ greet
Hello world!

Proprio come con le variabili e gli alias, se vogliamo che le funzioni siano persistenti durante i riavvii del sistema, dobbiamo inserirle negli script di inizializzazione della shell come /etc/bash.bashrc (globale) o ~/.bashrc (locale).

Warning

Dopo aver aggiunto alias o funzioni a qualsiasi file di script di avvio, è necessario creare tali file con . o source affinché le modifiche abbiano effetto se non si desidera disconnettersi e rientrare di nuovo o riavviare il sistema.

Variabili Speciali Integrate di Bash

La Bourne Again Shell viene fornita con una serie di variabili speciali particolarmente utili per funzioni e script. Sono "speciali" perché possono essere solo referenziate, non assegnate. Ecco un elenco di quelle più rilevanti:

$?

Il riferimento di questa variabile si espande al risultato dell’ultimo comando eseguito. Un valore di 0 significa successo:

$ ps aux | grep bash
user2      420  0.0  0.4  21156  5012 pts/0    Ss   17:10   0:00 -bash
user2      640  0.0  0.0  12784   936 pts/0    S+   18:04   0:00 grep bash
$ echo $?
0

Un valore diverso da 0 indica un errore:

user1@debian:~$ ps aux |rep bash
-bash: rep: command not found
user1@debian:~$ echo $?
127

$$

Si espande al PID della shell (ID processo):

$ ps aux | grep bash
user2      420  0.0  0.4  21156  5012 pts/0    Ss   17:10   0:00 -bash
user2      640  0.0  0.0  12784   936 pts/0    S+   18:04   0:00 grep bash
$ echo $$
420

$!

Si espande al PID dell’ultimo job in background:

$ ps aux | grep bash &
[1] 663
$ user2      420  0.0  0.4  21156  5012 pts/0    Ss+  17:10   0:00 -bash
user2      663  0.0  0.0  12784   972 pts/0    S    18:08   0:00 grep bash
^C
[1]+  Done                   ps aux | grep bash
$ echo $!
663

Note	Ricorda, la e commerciale (`&`) viene utilizzata per avviare i processi in background.

Parametri posizionali da $0 a $9

Si espandono ai parametri o agli argomenti passati alla funzione (alias o script) — $0 si espande al nome dello script o della shell.

Creiamo una funzione per dimostrare i parametri posizionali — nota PS2(>) che indica nuove righe dopo le interruzioni di riga:

$ special_vars() {
> echo $0
> echo $1
> echo $2
> echo $3
}

Ora, invocheremo la funzione (special_vars) passandole tre parametri (debian, ubuntu, zorin):

$ special_vars debian ubuntu zorin
-bash
debian
ubuntu
zorin

Ha funzionato come previsto.

Warning

Sebbene il passaggio di parametri posizionali agli alias sia tecnicamente possibile, non è affatto funzionale poiché - con gli alias - i parametri posizionali vengono sempre passati alla fine:

$ alias great_editor='echo $1 is a great text editor'
$ great_editor emacs
is a great text editor emacs

Altre variabili integrate speciali di Bash includono:

$#: Si espande al numero di argomenti passati al comando.
$@, $*: Si espandono agli argomenti passati al comando.
$_: Si espande all’ultimo parametro o al nome dello script (fare riferimento a man bash per saperne di più!):

Variabili all’interno di Funzioni

Naturalmente, le variabili possono essere utilizzate all’interno delle funzioni.

Dimostriamolo creando un nuovo file vuoto chiamato funed e inserendo la seguente funzione:

editors() {

editor=emacs

echo "My editor is: $editor. $editor is a fun text editor."
}

Come avrai già intuito, dobbiamo prima cercare il file per poter invocare la funzione:

$ . funed

E ora possiamo testarlo:

$ editors
My editor is emacs. emacs is a fun text editor.

Come puoi notare, affinché la funzione editors possa lavorare correttamente, la variabile editor deve prima essere impostata. L’ambito di quella variabile è locale rispetto alla shell corrente e possiamo farvi riferimento finché dura la sessione:

$ echo $editor
emacs

Insieme alle variabili locali possiamo anche includere nella nostra funzione variabili d’ambiente:

editors() {

editor=emacs

echo "The text editor of $USER is: $editor."
}

editors

Nota come questa volta abbiamo deciso di chiamare la funzione dall’interno del file stesso (editors nell’ultima riga). In questo modo, quando richiamiamo il file, questo avverrà anche per la funzione senza soluzione di continuità:

$ . funed
The text editor of user2 is: emacs.

Parametri Posizionali nelle Funzioni

Qualcosa di simile si verifica con i parametri posizionali.

Possiamo passarli alle funzioni dall’interno del file o dello script (nota l’ultima riga: editors tortoise):

editors() {

editor=emacs

echo "The text editor of $USER is: $editor."
echo "Bash is not a $1 shell."
}

editors tortoise

Richiamiamo il file e dimostriamo che funziona:

$ . funed
The text editor of user2 is: emacs.
Bash is not a tortoise shell.

E possiamo anche passare parametri posizionali alle funzioni dalla riga di comando. Per dimostrarlo, ci liberiamo dell’ultima riga del file:

editors() {

editor=emacs

echo "The text editor of $USER is: $editor."
echo "Bash is not a $1 shell."
}

Quindi, dobbiamo richiamare il file:

$ . funed

Infine, invochiamo la funzione con tortoise come parametro posizionale $1 nella riga di comando:

$ editors tortoise
The text editor of user2 is: emacs.
Bash is not a tortoise shell.

Funzioni negli Script

Le funzioni si trovano principalmente negli script Bash.

Trasformare il nostro file funed in uno script (lo chiameremo funed.sh) è davvero un gioco da ragazzi:

#!/bin/bash

editors() {

editor=emacs

echo "The text editor of $USER is: $editor."
echo "Bash is not a $1 shell."
}

editors tortoise

Questo è tutto! Abbiamo aggiunto solo due righe:

La prima riga è shebang e definisce quale programma interpreterà lo script: #!/bin/bash. Curiosamente, quel programma è lo stesso bash.
L’ultima riga è semplicemente l’invocazione della funzione.

Ora resta solo una cosa: dobbiamo rendere eseguibile lo script:

$ chmod +x funed.sh

E ora è pronto per essere eseguito:

$ ./funed.sh
The text editor of user2 is: emacs.
Bash is not a tortoise shell.

Note	Imparerai tutto sullo shell scripting nelle prossime lezioni.

Una Funzione all’Interno di un Alias

Come detto sopra, possiamo inserire una funzione all’interno di un alias:

$ alias great_editor='gr8_ed() { echo $1 is a great text editor; unset -f gr8_ed; }; gr8_ed'

Questo lungo valore alias merita una spiegazione. Cerchiamo di scomporlo:

Prima c’è la funzione stessa: gr8_ed() {echo $1 is a great text editor; unset -f gr8_ed; }
L’ultimo comando nella funzione — unset -f gr8_ed — ripristina la funzione in modo che non rimanga nella sessione attuale di bash dopo che l’alias è stato richiamato.
Ultimo ma non meno importante, per avere una corretta invocazione dell’alias, dobbiamo prima invocare anche la funzione: gr8_ed.

Richiamiamo l’alias e dimostriamo che funziona:

$ great_editor emacs
emacs is a great text editor

Come mostrato sopra in unset -f gr8_ed, il comando unset non è usato solo per annullare l’impostazione delle variabili, ma anche per le funzioni. In effetti, ci sono opzioni specifiche:

unset -v: per le variabili
unset -f: per le funzioni

Se usato senza interruttori, unset proverà prima a annullare l’impostazione di una variabile e, se fallisce, proverà a disattivare una funzione.

Una Funzione all’Interno di una Funzione

Diciamo ora di voler comunicare due cose a user2 ogni volta che accede al sistema:

Saluta e consiglia/elogia un editor di testo.
Dato che sta iniziando a mettere molti file video Matroska nella sua cartella $HOME/Video, vogliamo anche darle un avvertimento.

Per raggiungere questo scopo, abbiamo inserito le seguenti due funzioni in /home/user2/.bashrc:

La prima funzione (check_vids) esegue il controllo dei file .mkv e l’avviso:

check_vids() {
    ls -1 ~/Video/*.mkv > /dev/null 2>&1
    if [ "$?" = "0" ];then
        echo -e "Remember, you must not keep more than 5 video files in your Video folder.\nThanks."
    else
	echo -e "You do not have any videos in the Video folder. You can keep up to 5.\nThanks."
    fi
}

check_vids svolge tre compiti:

Elenca i file mkv in ~/Video inviando l’output — e qualsiasi errore — al cosiddetto bit-bucket (/dev/null).
Verifica il successo dell’output del comando precedente.
A seconda del risultato del test, riproduce uno dei due messaggi.

La seconda funzione è una versione modificata della nostra funzione editors:

editors() {

editor=emacs

echo "Hi, $USER!"
echo "$editor is more than a text editor!"

check_vids
}

editors

È importante osservare due cose:

L’ultimo comando di editors invoca check_vids in modo che entrambe le funzioni vengano concatenate: il saluto, la lode, il controllo e l’avvertimento vengono eseguiti in sequenza.
editors stesso è il punto di ingresso alla sequenza di funzioni, quindi viene invocato nell’ultima riga (editors).

Ora, accediamo come user2 e dimostriamo che funziona:

# su - user2
Hi, user2!
emacs is more than a text editor!
Remember, you must not keep more than 5 video files in your Video folder.
Thanks.

Esercizi Guidati

Completa la tabella con “Sì” o “No” considerando le capacità di alias e funzioni:

Caratteristica Alias? Funzioni?

È possibile utilizzare variabili locali

È possibile utilizzare variabili d’ambiente

Può essere evitato con \

Può essere ricorsivo

Molto produttivo se utilizzato con parametri posizionali

Immetti il comando che elenca tutti gli alias nel sistema:
Scrivi un alias chiamato logg che elenchi tutti i file ogg in ~/Music — uno per riga:
Richiama l’alias per dimostrare che funziona:
Ora, modifica l’alias in modo che mostri l’utente di sessione e i due punti prima dell’elenco:
Richiamalo di nuovo per dimostrare che anche questa nuova versione funziona:
Elenca di nuovo tutti gli alias e controlla che il tuo alias logg appaia nell’elenco:
Rimuovi l’alias

Studia le colonne “Nome alias” e “Comandi resi alias” e assegna correttamente gli alias ai loro valori:

Nome Alias Commando(i) resi Alias Assegnazione Alias

b

bash

bash_info

which bash + echo "$BASH_VERSION"

kernel_info

uname -r

greet

echo Hi, $USER!

computer

pc=slimbook + echo My computer is a $pc

Come root, scrivi una funzione chiamata my_fun in /etc/bash.bashrc. La funzione deve salutare l’utente e dirgli qual è il suo percorso personale. Richiamalo in modo che l’utente riceva entrambi i messaggi ogni volta che accede:
Accedi come user2 per verificare che funzioni:
Scrivi la stessa funzione in una sola riga:
Richiama la funzione
Rimuovi la funzione:
Questa è una versione modificata della funzione special_vars:
```
$ special_vars2() {
> echo $#
> echo $_
> echo $1
> echo $4
> echo $6
> echo $7
> echo $_
> echo $@
> echo $?
> }
```
Questo è il comando che usiamo per invocarlo:
```
$ special_vars2 crying cockles and mussels alive alive oh
```
Indovina il risultato:

Riferimento Valore

echo $#

echo $_

echo $1

echo $4

echo $6

echo $7

echo $_

echo $@

echo $?
Basandosi sulla funzione di esempio (check_vids) nella sezione “Una funzione all’interno di una funzione”, scrivi una funzione chiamata check_music da includere in uno script di avvio bash che accetta parametri posizionali in modo che possiamo modificare facilmente:
- il tipo di file da controllare: ogg
- la directory in cui vengono salvati i file: ~/Music
- il tipo di file da conservare: music
- il numero di file salvati: 7

Esercizi Esplorativi

Le funzioni di sola lettura sono quelle il cui contenuto non è possibile modificare. Fai una ricerca sulle funzioni di sola lettura e completa la seguente tabella:

Nome Funzione Rendila readonly Mostra tutte le Funzioni readonly

my_fun
Cerca nel web come modificare PS1 e qualsiasi altra cosa di cui potresti aver bisogno per scrivere una funzione chiamata fyi (da inserire in uno script di avvio) che fornisce all’utente le seguenti informazioni:
- nome dell’utente
- home directory
- nome dell’host
- tipo di sistema operativo
- percorso di ricerca per eseguibili
- directory di posta
- quanto spesso viene controllata la posta
- quanteo è profonda la sessione corrente in termine di numero di Shell
- prompt (dovresti modificarlo in modo che mostri <user>@<host-date>)

Sommario

In questa lezione abbiamo imparato:

Sia gli alias sia le funzioni sono caratteristiche importanti della shell che ci consentono di incapsulare blocchi ricorrenti di codice.
Gli alias sono utili per avere versioni più brevi di comandi lunghi e/o complicati.
Le funzioni sono procedure che implementano la logica e ci consentono di automatizzare le attività, specialmente se utilizzate negli script.
La sintassi per scrivere alias e funzioni.
Come concatenare vari comandi mediante il punto e virgola (;).
Come utilizzare correttamente le virgolette con alias.
Come rendere persistenti alias e funzioni.
Variabili speciali built-in in Bash: $?, $$, $!, parametri posizionali ($0-$9), $#, $@, $* e $_.
Come utilizzare variabili e parametri posizionali con le funzioni.
Come utilizzare le funzioni negli script.
Come richiamare una funzione da un alias.
Come richiamare una funzione da un’altra funzione.
Le basi per creare uno script bash.

Comandi utilizzati in questa lezione: alias:: Crea alias.

unalias: Rimuove alias.
cd: Cambia directory.
grep: Stampa le linee che corrispondono a un pattern.
function: Parola chiave della Shell per creare funzioni.
.: Richiama (Source) a file.
source: Richiama (Source) a file.
ps: Mostra un’istantanea dei processi in corso.
echo: Visualizza una riga di testo.
chmod: Modifica i bit di modalità di un file, per esempio, renderlo eseguibile.
unset: Annulla le variabili e le funzioni.
su: Cambia lo user ID o diventa superutente.

Risposte agli Esercizi Guidati

Completa la tabella con “Sì” o “No” considerando le capacità di alias e funzioni:

Caratteristica Alias? Funzioni?

È possibile utilizzare variabili locali

Sì

È possibile utilizzare variabili d’ambiente

Sì

Può essere evitato con \

Sì

Può essere ricorsivo

Sì

Molto produttivo se utilizzato con parametri posizionali

Sì

Immettere il comando che elenca tutti gli alias nel sistema:
```
alias
```
Scrivi un alias chiamato logg che elenchi tutti i file ogg in ~/Music — uno per riga:
```
alias logg='ls -1 ~/Music/*ogg'
```
Richiama l’alias per dimostrare che funziona:
```
logg
```
Ora, modifica l’alias in modo che mostri l’utente di sessione e i due punti prima dell’elenco:
```
alias logg='echo $USER:; ls -1 ~/Music/*ogg'
```
Richiamalo di nuovo per dimostrare che anche questa nuova versione funziona:
```
logg
```
Elenca di nuovo tutti gli alias e controlla che il tuo alias logg appaia nell’elenco:
```
alias
```
Rimuovi l’alias:
```
unalias logg
```

Studia le colonne “Nome alias” e “Comandi resi alias” e assegna correttamente gli alias ai loro valori:

Nome Alias Commando(i) resi Alias Assegnazione Alias

b

bash

alias b=bash

bash_info

which bash + echo "$BASH_VERSION"

alias bash_info='which bash; echo "BASH_VERSION"'

kernel_info

uname -r

alias kernel_info='uname -r'

greet

echo Hi, $USER!

alias greet='echo Hi, $USER'

computer

pc=slimbook + echo My computer is a $pc

alias computer='pc=slimbook; echo My computer is a $pc'

Note	Le virgolette singole possono anche essere sostituite da doppie.

Come root, scrivi una funzione chiamata my_fun in /etc/bash.bashrc. La funzione deve salutare l’utente e dirgli qual è il suo percorso personale. Richiamalo in modo che l’utente riceva entrambi i messaggi ogni volta che accede:

Opzione A:
```
my_fun() {
echo Hello, $USER!
echo Your path is: $PATH
}
my_fun
```
Opzione B:
```
function my_fun {
echo Hello, $USER!
echo Your path is: $PATH
}
my_fun
```
Accedi come user2 per verificare che funzioni:
```
su - user2
```

Scrivi la stessa funzione in una sola riga:

Opzione A:

my_fun() { echo "Hello, $USER!"; echo "Your path is: $PATH"; }

Opzione B:

function my_fun { echo "Hello, $USER!"; echo "Your path is: $PATH"; }

Richiama la funzione
```
my_fun
```
Rimuovi la funzione:
```
unset -f my_fun
```
Questa è una versione modificata della funzione special_vars:
```
$ special_vars2() {
> echo $#
> echo $_
> echo $1
> echo $4
> echo $6
> echo $7
> echo $_
> echo $@
> echo $?
> }
```
Questo è il comando che usiamo per invocarlo:
```
$ special_vars2 crying cockles and mussels alive alive oh
```
Indovina il risultato:

Riferimento Valore

echo $#

7

echo $_

7

echo $1

crying

echo $4

mussels

echo $6

alive

echo $7

oh

echo $_

oh

echo $@

crying cockles and mussels alive alive oh

echo $?

0
Basandosi sulla funzione di esempio (check_vids) nella sezione “Una funzione all’interno di una funzione”, scrivi una funzione chiamata check_music da includere in uno script di avvio bash che accetta parametri posizionali in modo che possiamo modificare facilmente:
- il tipo di file da controllare: ogg
- la directory in cui vengono salvati i file: ~/Music
- il tipo di file da conservare: music
- il numero di file salvati: 7
  check_music() { ls -1 ~/$1/*.$2 > ~/.mkv.log 2>&1 if [ "$?" = "0" ];then echo -e "Remember, you must not keep more than $3 $4 files in your $1 folder.\nThanks." else echo -e "You do not have any $4 files in the $1 folder. You can keep up to $3.\nThanks." fi } check_music Music ogg 7 music

Risposte agli Esercizi Esplorativi

Le funzioni di sola lettura sono quelle il cui contenuto non è possibile modificare. Fai una ricerca sulle funzioni di sola lettura e completa la seguente tabella:

Nome Funzione

Rendila readonly

Mostra tutte le Funzioni readonly

my_fun

readonly -f my_fun

readonly -f
Cerca nel web come modificare PS1 e qualsiasi altra cosa di cui potresti aver bisogno per scrivere una funzione chiamata fyi (da inserire in uno script di avvio) che fornisce all’utente le seguenti informazioni:
- nome dell’utente
- home directory
- nome dell’host
- tipo di sistema operativo
- percorso di ricerca per eseguibili
- directory di posta
- quanto spesso viene controllata la posta
- quanteo è profonda la sessione corrente in termine di numero di Shell
- prompt (dovresti modificarlo in modo che mostri <user>@<host-date>)PP
  fyi() { echo -e "For your Information:\n Username: $USER Home directory: $HOME Host: $HOSTNAME Operating System: $OSTYPE Path for executable files: $PATH Your mail directory is $MAIL and is searched every $MAILCHECK seconds. The current level of your shell is: $SHLVL" PS1="\u@\h-\d " } fyi