La shell di Linux Linux ha una varietà di shell differenti:

Presentazione sul tema: "La shell di Linux Linux ha una varietà di shell differenti:"— Transcript della presentazione:

1 La shell di Linux Linux ha una varietà di shell differenti:
Bourne shell (sh), C shell (csh), Korn shell (ksh), TC shell (tcsh), Bourne Again shell (bash). Sicuramente la shell più popolare è “bash”. Bash è la shell che è stata introdotta nel sistema operativo GNU. Bash è una shell sh-compatibile che incorpora utili caratteristiche della Korn shell (ksh) e della C shell (csh). Bash è conforme allo standard IEEE POSIX P1003.2/ISO Shell and Tools. Garantisce miglioramenti funzionali rispetto a sh sia per programmare che per l’uso interattivo.

2 Programming o Scripting ?
Bash non è soltanto un’eccellente interprete di comandi, ma un vero e proprio supporto per un linguaggio di script. Il linguaggio di script della shell permette di utilizzare le potenzialità della shell e di automatizzare un mucchio di compiti che richiederebbero altrimenti una grande quantità di comandi. Differenza tra linguaggi di programmazione e linguaggi di script: I linguaggi di programmazione sono in genere notevolmente più potenti e veloci dei linguaggi di script. I linguaggi di programmazione generalmente partono dal codice sorgente e vengono compilati in un eseguibile. Tale eseguibile non è facilmente portabile su differenti sistemi operativi. Un linguaggio di script parte a sua volta dal codice sorgente, ma non viene compilato in un eseguibile. Piuttosto, un interprete legge le istruzioni nel file sorgente ed esegue ciascuna istruzione. I programmi interpretati sono in genere più lenti dei programmi compilati. Il vantaggio principale è che si può facilmente portare il file sorgente su ogni sistema operativo. Bash è un linguaggio di script. Altri esempio di linguaggi di script sono Perl, Lisp, e Tcl.

3 Il primo programma bash
Occorre sapere come usare un editor di testo. Ci sono due editor di testo principali in Linux: vi (o vim), emacs (o xemacs). Dunque lanciamo un editor di testo; ad esempio: $ emacs & e digitiamo ciò che segue: #!/bin/bash echo “Hello World” La prima linea dice a Linux di utilizzare l’interprete bash per eseguire questo script. Lo chiameremo hello.sh. Ora rendiamo lo script eseguibile: $ chmod 700 hello.sh $ ls –l -rwx hello.sh

4 Il primo programma bash
Per eseguire il programma: $ hello.sh -bash: hello.sh: command not found La directory home (in cui il comando hello.sh si trova) non si trova fra quelle elencate nella variabile d’ambiente PATH echo $PATH :bin:/usr/bin:… Occorre specificare il path di hello.sh $/home/lferrari/Scripts/hello.sh $./hello.sh

5 Il secondo programma bash
Scriviamo un programma che copia tutti i files in una directory, e poi cancella la directory con tutto il suo contenuto. Ciò può essere fatto col seguente comando: $ mkdir trash $ cp * trash $ rm -rf trash Invece di essere costretti a digitare tutto ciò in modo interattivo nella shell, scriviamo uno script di shell: $ cat > trash #!/bin/bash # this script deletes some files mkdir trash cp * trash rm -rf trash echo “Deleted all files!”

6 Variabili Si possono usare le variabili come in ogni linguaggio di programmazione. I loro valori sono sempre memorizzati come stringhe, ma ci sono delle strutture nel linguaggio di shell che convertono le variabili in numeri per fare i calcoli. Non c’è bisogno di dichiarare una variabile, il solo fatto di assegnarle un valore la crea automaticamente. Esempio #!/bin/bash STR=“Hello World!” echo $STR La linea 2 crea una variabile detta STR e assegna la stringa "Hello World!" ad essa. Quindi il valore di questa variabile viene recuperato mettendo il '$' all’inizio.

7 Attenzione! Il linguaggio della shell non tipizza (assegna un tipo a) le variabili. Ciò significa che una variabile può contenere dati numerici o alfabetici. count=0 count=Sunday Cambiare il tipo di una variabile può generare confusione, sia per chi scrive lo script che per qualcuno che cerca di modificarlo, pertanto è raccomandato l’uso di un solo tipo di dati per ogni singola variabile all’interno di uno script. \ è il carattere di escape di bash, e conserva il valore letterale del carattere che segue. $ ls \* ls: *: No such file or directory

8 Virgolette singole e doppie
Quando si assegnano dati contenenti spazi o caratteri speciali, i dati devono essere racchiusi tra virgolette (singole o doppie). Quando si usano virgolette doppie (partial quoting) per stampare a video una stringa di caratteri, ogni variabile verrà sostituita dal valore che essa assume in quel momento. $ var=“test string” $ newvar=“Value of var is $var” $ echo $newvar Value of var is test string L’uso di virgolette singole (full quoting) per visualizzare una stringa di caratteri non permette la risoluzione delle variabili. $ var=’test string’ $ newvar=’Value of var is $var’ Value of var is $var

9 Esempi vari $ pippo= pluto errore $ pippo =pluto $ ls [Pp]*
$ echo $var $ echo “$var” $ echo ‘$var’ $ echo \z # z $ echo \\z # \z $ echo ‘\\z’ # \\z errore Not resolved

10 Esempi vari $ pippo=cat $ echo “comando = \” $pippo \” “
comando =“ cat ” $ echo ‘comando = \” $pippo \” ‘ comando =\” $pippo \” $ echo ‘comando = ” $pippo ” ‘ comando =” $pippo “

11 Il comando export $ echo $x # Nothing in x. $ exit # Return to parent.
Il comando export inserisce una variabile nell’ambiente, così che essa sarà accessibile ai processi figli. Per esempio: $ x=hello $ bash # Run a child shell. $ echo $x # Nothing in x. $ exit # Return to parent. $ export x $ bash $ echo $x hello # It's there. Se il processo figlio modifica x, non verrà modificato il valore originale nel processo padre. Si verifichi tale fatto cambiando x nel modo seguente: $ x=ciao $ exit hello

12 Variabili di ambiente Ci sono due tipi di variabili:
Variabili locali Variabili di ambiente Le variabili di ambiente sono definite a livello di sistema e possono di norma essere reperite usando il comando env. Le variabili di ambiente contengono valori speciali. Ad esempio, $ echo $SHELL /bin/bash $ echo $PATH /usr/X11R6/bin:/usr/local/bin:/bin:/usr/bin Le variabili di ambiente sono definite in /etc/profile, /etc/profile.d/ e ~/.bash_profile. Questi files sono files di inizializzazione e vengono letti quando la shell bash viene invocata. Al momento del logout da parte dell’utente, bash legge ~/.bash_logout.

13 Variabili di ambiente HOME: Il pathname della home dell’utente (l’argomento di default di cd). PATH: Il “search path” per i comandi. É un elenco delle directories (separate da :) nelle quali la shell cerca il comando da eseguire. Solitamente, si lancia uno script nel modo seguente: $ ./trash.sh Ponendo PATH=$PATH:. la nostra working directory viene inclusa nel “search path” per i comandi, e possiamo digitare semplicemente: $ trash.sh

14 Variabili di ambiente LOGNAME: contiene il nome dell’utente.
HOSTNAME: contiene il nome della macchina. MACHTYPE: hardware del sistema. PS1: sequenza di caratteri visualizzata davanti al prompt. \t ora \d data \w current directory \W ultima parte della current directory \u nome dell’utente \$ carattere del prompt Esempio lferrari]$ PS1=‘ciao \u *’ ciao lferrari* _ UID: contiene l’id number dell’utente (non può essere cambiato).

15 Il comando exit Il comando exit può essere usato per terminare uno script. Esso restituisce un valore, che è disponibile per il processo padre dello script. Quando uno script termina col comando exit senza ulteriori parametri, lo stato di uscita è lo stato di uscita dell’ultimo comando eseguito nello script. #!/bin/bash COMMAND_1 . . . # exit with status of last command. COMMAND_LAST exit #!/bin/bash COMMAND_1 . . . # exit with status of last command. COMMAND_LAST exit $?

16 Il comando exit Il comando exit può essere usato per terminare uno script. Esso restituisce un valore, che è disponibile per il processo padre dello script. Quando uno script termina con exit nnn dove nnn=0-255, lo stato di uscita è nnn.

17 Il Comando read Il comando read consente di leggere l’input da tastiera e memorizzarlo in una variabile. Esempio (read.sh) #!/bin/bash echo -n “Enter name of file to delete: ” read file echo “Type 'y' to remove it, 'n' to change your mind ... ” rm -i $file echo "That was YOUR decision!" La linea 3 crea una variabile chiamata file e le assegna l’input da tastiera. Quindi il valore di questa variabile viene richiamato inserendo il simbolo ‘$’ davanti ad essa.

18 Il Comando read Opzioni Esempio read –s (non stampa a video l’input)
read –nN (accetta soltanto N caratteri di input) read –p “message” (visualizza il messaggio “message”) read –tT (accetta l’input per T secondi) Esempio $ read –s –n1 -p “Yes (Y) or not (N)?” answer Yes (Y) or not (N) ? (digitare Y: non si vedrà) $ echo $answer Y

19 Sostituzione dei comandi
La “virgoletta retrograda”, o accento grave, “`” è diversa dalla virgoletta “´”. Essa viene usata per la sostituzione dei comandi: `command` $ LIST=`ls` $ echo $LIST hello.sh read.sh PS1=“`pwd`>” /home/rinaldi/didattica/> Possiamo eseguire la sostituzione dei comandi anche usando $(command) $ LIST=$(ls) rm $( find / -name “*.tmp” ) ls $( pwd ) ls $( echo /bin )

20 Esempio $ a=`echo Hello` $ echo $a $ echo ‘$a’ $ b=`ls /home`
$ echo $b $ echo $a $b $ echo “$a $b”

21 Operatori aritmetici + somma - sottrazione * moltiplicazione
/ divisione ** esponenziazione % modulo Esempio $ a=/(5+2/)*3 $ echo $a $ b=2**3 $ echo $a+$b

22 Valutazioni aritmetiche
Il costrutto let può essere usato per creare funzioni matematiche $ let X=10+2*7 $ echo $X 24 $ let Y=X+2*4 $ echo $Y 32 Un’espressione aritmetica può essere valutata usando $[expression] o $((expression)) $ echo $((123+20)) 143 $ VALORE=$[123+20] $ echo $[10*$VALORE] 1430 $ echo $[2**3] $ echo $[8%3] Non è necessario usare $X per riferirsi al valore di X

23 Valutazioni aritmetiche
Esempio (operations.sh) #!/bin/bash echo -n “Enter the first number: ”; read x echo -n “Enter the second number: ”; read y add=$(($x + $y)) sub=$(($x - $y)) mul=$(($x * $y)) div=$(($x / $y)) mod=$(($x % $y)) # print out the answers: echo “Sum: $add” echo “Difference: $sub” echo “Product: $mul” echo “Quotient: $div” echo “Remainder: $mod”

24 Costrutti condizionali
Le strutture condizionali ci permettono di decidere se eseguire un’azione oppure no, a seconda del valore di un’espressione da valutare. Il costrutto condizionale fondamentale è: if [ expression ]; then statements elif [ expression ]; else fi Le parti elif (else if) e else sono opzionali.

25 Espressioni Un’espressione può essere: un confronto fra stringhe, un confronto fra numeri, un operatore su file, un operatore logico ed è rappresentata da [ expression ]: Confronto fra stringhe: = per valutare se due stringhe sono uguali != per valutare se due stringhe sono diverse -n per valutare se la lunghezza di una stringa è maggiore di zero -z per valutare se la lunghezza di una stringa è uguale a zero Esempi: [ s1 = s2 ] (vero se s1 è uguale a s2, altrimenti falso) [ s1 != s2 ] (vero se s1 è diverso da s2, altrimenti falso) [ s1 ] (vero se s1 è non vuota, altrimenti falso) [ -n s1 ] (vero se s1 ha lunghezza maggiore di 0, altrimenti falso) [ -z s2 ] (vero se s2 ha lunghezza 0, altrimenti falso)

26 Espressioni Confronto fra numeri: Esempi:
-eq valuta se due numeri sono uguali -ge valuta se un numero è maggiore o uguale a un altro -le valuta se un numero è minore o uguale a un altro -ne valuta se due numeri sono diversi -gt valuta se un numero è maggiore di un altro -lt valuta se un numero è minore di un altro Esempi: [ n1 -eq n2 ] (vero se n1 è uguale a n2, altrimenti falso) [ n1 -ge n2 ] (vero se n1 è maggiore o uguale a n2, altrimenti falso) [ n1 -le n2 ] (vero se n1 è minore o uguale a n2, altrimenti falso) [ n1 -ne n2 ] (vero se n1 è diverso da n2, altrimenti falso) [ n1 -gt n2 ] (vero se n1 è maggiore di n2, altrimenti falso) [ n1 -lt n2 ] (vero se n1 è minore di n2, altrimenti falso)

27 #!/bin/bash # if0.sh echo -n “Enter your login name: " read name if [ “$name” = “$LOGNAME” ]; then echo “Hello, $name. How are you today ?” else echo “You are not $LOGNAME, so who are you ?” fi #!/bin/bash # if1.sh echo -n “Enter a number 1 < x < 10: " read num if [ “$num” -lt 10 ]; then if [ “$num” -gt 1 ]; then echo “$num*$num=$(($num*$num))” echo “Wrong insertion !”

28 Espressioni Operatori su files: Esempi:
-d controlla se il cammino dato rappresenta una directory -f controlla se il cammino dato rappresenta un file ordinario -e controlla se il nome del file esiste -s controlla se un file ha lunghezza maggiore di 0 -r controlla se si possiede il permesso di lettura per un file o una directory -w controlla se si possiede il permesso di scrittura per un file o una directory -x controlla se si possiede il permesso di esecuzione per un file o una directory Esempi: [ -d fname ] (vero se fname è una directory, altrimenti falso) [ -f fname ] (vero se fname è un file ordinario, altrimenti falso) [ -e fname ] (vero se fname esiste, altrimenti falso) [ -s fname ] (vero se la lunghezza di fname è maggiore di 0, altrimenti falso) [ -r fname ] (vero se fname ha il permesso di lettura, altrimenti falso) [ -w fname ] (vero se fname ha il permesso di scrittura, altrimenti falso) [ -x fname ] (vero se fname ha il permesso di esecuzione, altrimenti falso)

29 Esempio #!/bin/bash if [ -f /etc/fstab ]; then cp /etc/fstab .
echo “Done.” else echo “This file does not exist.” exit 1 fi Esercizio. Scrivere uno script di shell che prenda in input un nome di file <pippo>: Lo script controlla se esiste una cartella Backup, altrimenti la crea. Se il file cercato esiste, copia il file con lo stesso nome + .bak nella cartella Backup. Se il file non esiste, allora visualizza il messaggio “The file <pippo> does not exist!!!”

30 Soluzione #!/bin/bash if [ ! –d ./Backup ] then mkdir ./Backup fi
read –p “insert the name of a file” pippo if [ -f $pippo ] then cp $pippo ./Backup/$pippo.bak else echo “The file $pippo does not exist!!!”

31 Espressioni Operatori logici: ! negare (NOT) un’espressione logica
-a congiunzione (AND) tra due espressioni logiche -o disgiunzione (OR) tra due espressioni logiche #!/bin/bash # if3.sh echo -n “Enter a number 1 < x < 10:” read num if [ “$num” -gt 1 –a “$num” -lt 10 ]; then echo “$num*$num=$(($num*$num))” else echo “Wrong insertion !” fi

32 Espressioni Operatori logici:
&& congiunzione (AND) tra due espressioni logiche || disgiunzione (OR) tra due espressioni logiche #!/bin/bash # if4.sh echo -n "Enter a number 1 < x < 10: " read num if [ “$number” -gt 1 ] && [ “$number” -lt 10 ]; then echo “$num*$num=$(($num*$num))” else echo “Wrong insertion !” fi

33 Esempio $ cat iftrue.sh # iftrue.sh #!/bin/bash
echo “Enter a path: ”; read x if cd $x 2> /dev/null then echo “I am in $x and it contains”; ls else echo “The directory $x does not exist”; exit 1 fi $ ./iftrue.sh Enter a path: /home srinaldi afrosini riccardo … Enter a path: pippo The directory pippo does not exist

34 Parametri di shell Un parametro posizionale corrisponde ad un argomento fornito alla shell al momento dell’esecuzione di un programma. Il primo argomento specificato corrisponde alla variabile 1, il secondo argomento alla variabile 2 e così via. Il parametro posizionale “N” può essere referenziato come “${N}”, o come “$N” quando “N” consiste in una singola cifra. Parametri speciali $# è il numero dei parametri passati $0 rende il nome dello script di shell in esecuzione nonchè la sua posizione nel file system $* rende una singola parola contenente tutti i parametri passati allo script rende un array di parole contenente tutti i parametri passati allo script $ cat sparameters.sh ( sparameters.sh ) #!/bin/bash echo “$#; $0; $1; $2; $*; $ sparameters.sh alba chiara 2; ./sparameters.sh; alba; chiara; alba chiara; alba chiara

35 Trash $ cat trash.sh ( trash.sh ) #!/bin/bash if [ $# -eq 1 ]; then
if [ ! –d “$HOME/trash” ]; mkdir “$HOME/trash” fi mv $1 “$HOME/trash” else echo “Use: $0 filename” exit 1

36 Il costrutto case Viene usato per eseguire azioni basate su valori specifici. Usato spesso al posto di un costrutto if se c’è un numero elevato di condizioni. Il valore usato può essere un’espressione. Ciascun insieme di azioni deve concludersi con una coppia di punto e virgola. Il simbolo *) viene usato per accettare ogni valore non corrispondente con la lista dei valori. case $var in val1) statements;; val2) *) esac

37 Esempio #!/bin/bash ( case.sh )
echo -n “Enter a number 1 < x < 10: ” read x case $x in 2) echo “Value of x is 2.”;; 3) echo “Value of x is 3.”;; 4) echo “Value of x is 4.”;; 5) echo “Value of x is 5.”;; 6) echo “Value of x is 6.”;; 7) echo “Value of x is 7.”;; 8) echo “Value of x is 8.”;; 9) echo “Value of x is 9.”;; 1 | 10) echo “wrong number.”;; *) echo “Unrecognized value.”;; esac

38 Costrutti di iterazione
Il ciclo for viene usato quando si vuole ripetere un blocco di comandi in corrispondenza di valori tratti da un elenco. for var in list do istruzioni done Le istruzioni vengono eseguite assegnando a var ciascun valore in list. #!/bin/bash let sum=0 for num in let sum=$sum+$num echo $sum

39 Costrutti di iterazione: <list>
#!/bin/bash for x in paper pencil pen; do echo “The value of variable x is: $x” sleep 1 done # The value of variable x is paper # The value of variable x is pencil # The value of variable x is pen #!/bin/bash for x in “paper A4” “pencil STADTLER” “pen BIC”; do # The value of variable x is paper A4 # The value of variable x is pencil STADTLER # The value of variable x is pen BIC

40 Costrutti di iterazione: <list>
#!/bin/bash lista=“antonio michele paolo luca” for x in $lista do echo “The value of variable x is: $x” sleep 1 done # The value of variable x is antonio # The value of variable x is michele # The value of variable x is paolo # The value of variable x is luca

41 Costrutti di iterazione: <list>
#!/bin/bash for x in * do ls -l “$x” sleep 1 done # Lists all files in current directory for x in /bin # Lists all files in /bin

42 Costrutti di iterazione: <list>
#!/bin/bash read –p “Insert the name of a directory” directory echo "symbolic links in directory \” $directory \” " for file in $( find $directory -type l ) # -type l = symbolic links do echo "$file" done | sort # Otherwise file list is unsorted

43 Costrutti di iterazione: <list>
Se la parte list viene omessa, a var viene assegnato ciascun parametro passato allo script ( $1, $2, $3,…).

44 Costrutti di iterazione: <list>
Se la parte list viene omessa, a var viene assegnato ciascun parametro passato allo script ( $1, $2, $3,…). $ cat for1.sh ( for1.sh ) #!/bin/bash for x do echo “The value of variable x is: $x” sleep 1 done $ for1.sh alba chiara The value of variable x is: alba The value of variable x is: chiara

45 Esempio 1 #!/bin/bash ( old.sh )
# Move the command line arg files to old directory. if [ $# -eq 0 ] #check for command line arguments then echo “Usage: $0 file …” exit 1 fi if [ ! –d “$HOME/old” ] mkdir “$HOME/old” echo The following files will be saved in the old directory: echo $* for p in $* #loop through all command line arguments do mv $p “$HOME/old/” chmod 400 “$HOME/old/$p” done ls -l “$HOME/old”

46 Esempio 2 #!/bin/bash ( args.sh )
# Invoke this script with several arguments: “one two three“ if [ ! -n “$1” ]; then echo “Usage: $0 arg1 arg2 ..." ; exit 1 fi echo ; index=1 ; echo “Listing args \”\$*\”:” for arg in “$*” ; do echo “Arg $index = $arg” let “index+=1” # increase variable index by one done echo “Entire arg list seen as single word.” echo “Listing args with for arg in ; do let “index+=1” echo “Arg list seen as separate words.”

47 Operazioni sulle variabili
…… let “index += 5” #incrementa la variabile #index di 5 += #incrementa la variabile -= #decrementa la variabile *= #moltiplica la variabile /= #divide la variabile

48 Arrays Nella shell bash, possiamo usare gli arrays. Il modo più semplice per crearne uno è usare uno dei due metodi seguenti: pet[0]=dog pet[1]=cat pet[2]=fish pet[4]=apple pet=( dog cat fish apple ) Si possono inserire fino a 1024 elementi. Per estrarre un valore, digitare ${arrayname[i]}. $ echo ${pet[0]} dog $ echo ${pet[2]} fish

49 Arrays Per estrarre tutti gli elementi, usare un asterisco come segue:
echo ${arraynames[*]} Per vedere quanti elementi ci sono nell’array: echo ${#arraynames[*]} Si possono utilizzare gli arrays nei cicli per realizzare la lista di un ciclo for: for x in ${arrayname[*]} do echo $x done

50 Un “for” alternativo Una forma alternativa per la struttura for è
for (( EXPR1 ; EXPR2 ; EXPR3 )) do istruzioni done Per prima cosa, viene valutata l’espressione aritmetica EXPR1. Quindi EXPR2 viene valutata ripetutamente fino a che non assume risulta falsa. Ogni volta che EXPR2 è vera, le istruzioni vengono eseguite e, in coda, viene eseguita EXPR3.

51 Un “for” alternativo Una forma alternativa per la struttura for è
for (( EXPR1 ; EXPR2 ; EXPR3 )) do istruzioni done Per prima cosa, viene valutata l’espressione aritmetica EXPR1. Quindi EXPR2 viene valutata ripetutamente fino a che non assume risulta falsa. Ogni volta che EXPR2 è vera, le istruzioni vengono eseguite e, in coda, viene eseguita EXPR3. $ cat for2.sh #!/bin/bash echo –n “Enter a number: ”; read x let sum=0 for (( i=1 ; $i<$x ; i=$i+1 )) ; do let “sum = $sum + $i” echo “the sum of the first $x numbers is: $sum”

52 Debugging Bash fornisce due opzioni che danno informazioni utili per il debugging: -v : visualizza ciascuna linea dello script così come era stata digitata prima dell’esecuzione; -x : simile a sopra, ma se c’è un ciclo mostra tutti le iterazioni. Utilizzo: #!/bin/bash –v, o #!/bin/bash –x $ cat for3.sh #!/bin/bash –x echo –n “Enter a number: ”; read x let sum=0 for (( i=0 ; $i<=$x ; i=$i+1 )) ; do let “sum = $sum + $i” done echo “the sum of the first $x numbers is: $sum”

53 Debugging $ ./for3.sh + echo –n ‘Enter a number: ’
Enter a number: + read x 3 + let sum=0 + (( i=0 )) + (( 0<=3 )) + let ‘sum = 0 + 0’ + (( i=0+1 )) + (( 1<=3 )) + let ‘sum = 0 + 1’ + (( i=1+1 )) + (( 2<=3 )) + let ‘sum = 1 + 2’ + (( i=2+1 )) + (( 3<=3 )) + let ‘sum = 3 + 3’ + (( i=3+1 )) + (( 4<=3 )) + echo ‘the sum of the first 3 numbers is: 6’ the sum of the first 3 numbers is: 6

54 Dov’è l’errore? Uno script da correggere #!/bin/bash # ex74.sh a=37
if [$a -gt 27 ] then echo $a fi Output dello script: ./ex74.sh: [37: command not found

55 Dov’è l’errore? Uno script da correggere #!/bin/bash -x # ex74.sh a=37
if [$a -gt 27 ] then echo $a fi exit Output dello script: +a=37 +’[37’ -gt 37 ‘]’ + ./ex74.sh: [37: command not found ….

56 Il costrutto While La struttura while è una struttura di ciclo che viene usata per eseguire un insieme di comandi finchè una certa condizione specificata è vera. Il ciclo termina non appena la condizione diventa falsa. Se la condizione non diventa mai falsa, il ciclo non termina e si entra in loop. while [ espressione ] do istruzioni done

57 Il costrutto While La struttura while è una struttura di ciclo che viene usata per eseguire un insieme di comandi finchè una certa condizione specificata è vera. Il ciclo termina non appena la condizione diventa falsa. Se la condizione non diventa mai falsa, il ciclo non termina e si entra in loop. while [ espressione ] do istruzioni done $ cat while.sh ( while.sh ) #!/bin/bash echo –n “Enter a number: ”; read x let sum=0; let i=1 while [ $i –le $x ]; do let “sum = $sum + $i” let i=$i+1 echo “the sum of the first $x numbers is: $sum”

58 Menu #!/bin/bash # menu.sh clear ; loop=y while [ “$loop” = y ] ; do
echo “Menu”; echo “====” echo “D: print the date” echo “W: print the users who are currently log on.” echo “P: print the working directory” echo “Q: quit.” echo read –s choice case $choice in D | d) date ;; W | w) who ;; P | p) pwd ;; Q | q) loop=n ;; *) echo “Illegal choice.” ;; esac done

59 Trovare un pattern e editarlo
$ cat grep_edit.sh #!/bin/bash # grep_edit.sh # Edit argument files $2 ..., that contain pattern $1 if [ $# -le 1 ] then echo “Usage: $0 pattern file …” ; exit 1 else pattern=$1 # Save original $1 shift # shift the positional parameter to the left by 1 while [ $# -gt 0 ] # New $1 is first filename do grep “$pattern” $1 > /dev/null if [ $? -eq 0 ] ; then # If grep found pattern vi $1 # then vi the file fi shift done $ grep_edit.sh while ~

60 Il costrutto continue Il comando continue genera un salto all’iterazione successiva del ciclo, dimenticando tutti i restanti comandi in quella particolare iterazione. #!/bin/bash LIMIT=19 echo echo “Printing Numbers 1 through 20 (but not 3 and 11)” a=0 while [ $a -le “$LIMIT” ]; do a=$(($a+1)) if [ “$a” -eq 3 ] || [ “$a” -eq 11 ] then continue fi echo -n “$a ” done

61 Il costrutto break Il comando break termina il ciclo (ed esce da esso). #!/bin/bash LIMIT=19 echo “Printing Numbers 1 through 20, but something happens after 2 … ” a=0 while [ $a -le “$LIMIT” ]; do a=$(($a+1)) if [ “$a” -gt 2 ] then break fi echo -n “$a ” done echo; echo; echo

62 Il costrutto until La struttura until è molto simile alla struttura while. La struttura until mantiene il ciclo finchè la condizione è falsa. Quindi, sostanzialmente, il significato è “finchè la condizione è falsa, fai questo”. until [espressione] do istruzioni done $ cat countdown.sh #!/bin/bash #countdown.sh echo “Enter a number: ”; read x echo ; echo Count Down until [ “$x” -le 0 ]; do echo $x x=$(($x–1)) sleep 1 echo ; echo GO !

63 Manipolare le stringhe
Bash supporta un numero impressionante di operazioni per manipolare stringhe. Sfortunatamente, questi strumenti non soddisfano una delle primitive esigenze di Linux, cioè quella dell’economicità dei comandi. ${#string} rende la lunghezza della stringa. ${string:position} estrae da $string la sottostringa che inizia dalla posizione $position. ${string:position:length} estrae $length caratteri della sottostringa di $string che inizia dalla posizione $position. Esempio: $ st= $ echo ${#st} 10 $ echo ${st:6} 6789 $ echo ${st:6:2} 67

64 Sostituzione dei parametri
Manipolare e/o espandere variabili: ${parameter-default}, se “parameter” non è istanziato, usa “default”. $ echo ${username-”lferrari”} lferrari $ username=luca luca ${parameter=default}, se “parameter” non è istanziato, gli attribuisce il valore “default”. $ echo ${username=”lferrari”} $ echo $username ${parameter+value}, se “parameter” è istanziato, usa value, altrimenti usa la stringa vuota. $ echo ${username+andrea} andrea $ echo ${pippo+andrea} # null string

65 Sostituzione dei parametri
${parameter?msg}, Se “parameter” è istanziato, lo usa, altrimenti stampa msg. $ value=${total?’total is not set’} -bash: total: total is not set $ total=10 $ echo $value 10 Esempio: #!/bin/bash OUTFILE=symlinks.list directory=${1-`pwd`} for file in “$( find $directory -name “*.sh” )” do echo “$file” done | sort >> “$HOME/$OUTFILE”

66 Operazioni avanzate sulle stringhe
${string#substring}, elimina la più corta occorrenza corrispondente a substring dall’inizio di string. $ pippo=abbcaabccbcabcdbcdaba $ echo ${pippo#a*c} aabccbcabcdbcdaba $ echo ${pippo##a*c} # strips the longest match daba

67 Operazioni avanzate sulle stringhe
${string/substring/replacement}, elimina la prima occorrenza corrispondente a substring in string, rimpiazzandola con replacement. $ pippo=abbcaabccbcabcdbcdabab $ echo ${pippo/ca/11} abb11abccbcabcdbcdabab $ echo ${pippo//ca/11} abb11abccb11bcdbcdabab # replaces all matches $ echo ${pippo/[ab]?c/000} a000aabccbcabcdbcdabab $ echo ${pippo/c*a/\!} abb!b $ echo ${pippo//b?/00} a00caa00c00a00d00da00b

68 Funzioni Le funzioni rendono gli scripts più facili da mantenere. Sostanzialmente, permettono di suddividere il programma in pezzetti più piccoli. Una funzione esegue un’azione definita dall’utente, e può rendere un valore se l’utente lo desidera. #!/bin/bash hello() { echo “You are in function hello()” } echo “Calling function hello()…” hello echo “You are now out of function hello()” Sopra, abbiamo richiamato la funzione hello() col suo nome usando la linea: hello. Quando questa linea viene eseguita, bash cerca nello script la linea hello(). La trova, e ne esegue i contenuti.

69 Funzioni #!/bin/bash check() { if [ -e "/home/$1" ] then return 0 else
fi } echo “Enter the name of the file: ” ; read x if check $x echo “$x exists !” echo “$x does not exist !” fi.

70 Massimo comun divisore
#!/bin/bash # gcd.sh: massimo comun divisore # Si usa l’algoritmo di Euclide # Il “massimo comun divisore" (gcd) di due interi è il più grande intero # che divide entrambi, senza che ci sia del resto. # L’algoritmo di Euclide utilizza divisioni successive. # Ad ogni passo, dividend <--- divisor, divisor <--- remainder # finchè remainder = 0. Nell’ultimo passo, si ha gcd = dividend. ARGS=2 E_BADARGS=65 if [ $# -ne "$ARGS" ] then echo "Usage: `basename $0` first-number second-number" exit $E_BADARGS fi

71 Massimo comun divisore
gcd () { dividend=$1 divisor=$2 remainder=1 until [ "$remainder" -eq 0 ] do let "remainder = $dividend % $divisor" dividend=$divisor divisor=$remainder done } # Last $dividend is the gcd. gcd $1 $2 echo; echo "GCD of $1 and $2 = $dividend“

72 Script 1: estrarre una carta a caso da un mazzo
#!/bin/bash Suites=“Clubs Diamonds Hearts Spades” Denominations=“ Jack Queen King Ace” # Read into array variable. suite=($Suites) denomination=($Denominations) # Count how many elements. num_suites=${#suite[*]} num_denominations=${#denomination[*]} # Extract echo -n "${denomination[$((RANDOM%num_denominations))]} of " echo ${suite[$((RANDOM%num_suites))]}

73 Script 2: cambiare i nomi di tutti i file mettendoli in lettere minuscole
#!/bin/bash for filename in * # Traverse all files in directory. do fname=`basename $filename` # Change name to lowercase. n=`echo $fname | tr A-Z a-z` if [ “$fname” != “$n” ] # Rename only files not already lowercase. then mv $fname $n fi done

74 Script 3: Confrontare due files con uno script
#!/bin/bash ARGS=2 # Two args to script expected. if [ $# -ne “$ARGS” ]; then echo “Usage: `basename $0` file1 file2” ; exit 1 fi if [ ! -r "$1“ ] || [ ! -r "$2" ] ; then echo “Both files must exist and be readable.” ; exit 2 cmp $1 $2 &> /dev/null # /dev/null buries the output of the “cmp” command. # Also works with 'diff', i.e., diff $1 $2 &> /dev/null if [ $? -eq 0 ] # Test exit status of “cmp” command. then echo “File \“$1\” is identical to file \“$2\”.” else echo “File \“$1\“ differs from file \“$2\”.”

75 Esercizio #!/bin/bash MAX=10000 for((nr=1; nr<$MAX; nr++)) do
let "t1 = nr % 5" if [ "$t1" -ne 3 ] then continue fi let "t2 = nr % 7" if [ "$t2" -ne 4 ] let "t3 = nr % 9" if [ "$t3" -ne 5 ] break # What happens when you comment out this line? Why? done echo "Number = $nr" exit 0