ESEMPIO FOR 3

L'insieme analizzato dal for può essere generato con l'output di un comando. Nell'esempio successivo vengono rielaborati (in sh) tutti i files che iniziano per L della cartella di sistema /bin.

for c in `ls /bin/l*`; do echo $c; done

Ecco due esempi in csh che svolgono la stessa funzione di File_L.sh. Nelle parentesi del foreach di csh è possibile scrivere o il comando (delimitato dal backquote) oppure il solo argomento utilizzato nel comando ls. Il batch file_L.sh con csh diventano:
 

#!/bin/csh -f
foreach c (/bin/l*)
   echo $c
end

#!/bin/csh -f
foreach c (`ls /bin/l*`)
   echo $c
end

Potendo inserire come generatore di insieme un qualsiasi comando UNIX potremo anche analizzare ricorsivamente il contenuto di una directory (esempio con ls -R).

ESEMPIO FOR 4

Nel prossimo esempio vengono conteggiati:
- tutti i files con estensione .txt presenti nel nostro sistema (il $ in fondo all'argomento del comando grep indica che l'estensione va cercata in fondo al nome!)
- i files che non risultano accessibili dall'utente corrente.

Relativamente alla seconda statistica si osservi che la risposta del comando ls relativa ad un file non accessibile ha una struttura simile a questo esempio:

ls: /var/log/samba: Permission denied

Tale messaggio di errore viene inviato allo standard error. Per evitare che la variabile $i, utilizzata dal for/foreach, assuma, per ogni riga di output, 4 valori distinti ed esattamente: ls:, /var/log/samba:, Permission, denied è necessario ridirigere l'output, tramite una pipe, verso il comando cut -c 1. In questo modo si estrae, relativamente ad ogni file non accessibile, solo il primo carattere e quindi una sola valorizzazione di $i per ogni riga.
 

let N=0
for i in `ls -R / 2>/dev/null | grep .txt$`; do let N=N+1; done
echo $N Files di testo
let N=0
for i in `((ls -R / 3>&2 2>&1 >&3) 2>/dev/null)|cut -c 1`
do
   let N=N+1
done
echo $N Files non accessibili

#!/bin/csh -f
@ N=0
foreach i (`(((ls -R / > pippo) >& /dev/null); grep .txt$ pippo)`)
  @ N++
end
echo $N Files di testo
@ N=0
foreach i (`(ls -R / >/dev/null) |& cut -c 1`)
   @ N++
end
echo $N Files non accessibili

sh-2.05$ whoami
studente
sh-2.05$ ./ContaFile.sh
542 Files di testo
76 Files non accessibili
sh-2.05$ su -s /bin/sh root
Password:
sh-2.05# ./ContaFile.sh
542 Files di testo
0 Files non accessibili
sh-2.05#

[studente@localhost ~]$ whoami
studente
[studente@localhost ~]$ ./ContaFile.csh
542 Files di testo
76 Files non accessibili
[studente@localhost ~]$ su -s /bin/csh root
Password:
[studente@localhost studente]# ./ContaFile.csh
542 Files di testo
0 Files non accessibili
[studente@localhost studente]#

let N=0
let F=0
for i in `find / -type d 2>/dev/null|cut -c 1`; do let N=N+1; done
for i in `find / -type f 2>/dev/null|cut -c 1`; do let F=F+1; done
echo $N Cartelle - $F Files

#!/bin/csh -f
@ N=0
@ F=0
foreach i (`(find / -type d) |& grep -v "Permission denied" | cut -c 1`)
 @ N++
end
foreach i (`(find / -type f) |& grep -v "Permission denied" | cut -c 1`)
 @ F++
end
echo $N Cartelle - $F Files

let N=10
for ((a=1; a <= N ; a++))
do
   if [ $(($a%2)) -eq 0 ]; then
      continue
   fi
   echo -n "$a "
done
echo;

for ((a=1; ; a++))
do
   if [ $(($a%2)) -eq 0 ]; then continue ; fi
   if [ $a -gt 10 ]; then break ; fi
   echo -n "$a "
done
echo;

La sintassi del comando While è la seguente:

while [CondizioneVera]
do
   IstruzioneWHILE
   [break]
   [continue]
done

while (CondizioneVera)
   IstruzioneWHILE
   [break]
   [continue]
end

FUNCTION

Nella shell sh è possibile definire delle funzioni. La sintassi per le funzioni è la seguente (si noti l'assenza della dichiarazione degli argomenti):

function NomeFunzione {
    IstruzioneFUNZIONE
}

oppure

NomeFunzione() {
    IstruzioneFUNZIONE
}

Nella csh non esistono le funzioni ma è possibile costruire qualcosa di simile con il comando alias
 

# La dichiarazione della funzione deve essere 
# fatta prima della sua chiamata
Scrivi ()
{
   echo "Scrivo qualcosa"
   echo "Ora esco da \"Scrivi()\"."
}
# Esempio di chiamata funzione.
# Scrivi

[root@localhost ~]# alias Scrivi 'echo "Scrivo qualcosa";echo "Ora esco da "\""Scrivi"\""."'
[root@localhost ~]# Scrivi
Scrivo qualcosa
Ora esco da "Scrivi".
[root@localhost ~]# alias calcola '@ z = (\!*) ; echo $z'
[root@localhost ~]# calcola 1 + 2 * 7
15
[root@localhost ~]# 

Le funzioni sono come dei mini-scripts: possono accettare dei parametri, usano delle variabili locali e restituiscono dei valori agli script chiamanti.
Le funzioni interpretano i parametri in modo posizionale. Il nome dei parametri posizionali è lo stesso visto per quelli usati negli script batch ovvero $#, $*, $0, $1... .
Nel comando alias (csh) le seguenti stringhe indicano:
- \!* : l'elenco dei parametri passati (corrisponde alla variabile sh $*),
- \!$ : l'ultimo parametro (corrisponde alla variabile sh ${!#}),
- \!:1 o \!^ : il primo parametro (corrisponde a $1),
- \!! : l'intero comando,
- \!:<n>* : elenco dei parametri a partire dall'n-esimo (compreso),
- \!:<n>-<m> : elenco dei parametri a partire dall'n-esimo (compreso) fino all'm-esimo(compreso),
- \!:<n> : l'n-esimo argomento.

Ecco un esempio di utilizzo dei parametri con le funzioni (sh) e con l'alias (csh)

TestParametri ()
{
   let i=1
   echo "Nr. argomenti: $#"
   echo "Elenco argomenti: $*"
   for a
   do
       echo "$i Parametro: $a"
       let i=i+1
   done
}
TestParametri a b c d

[root@localhost ~]# alias TestParametri 'set s="\!*" ; set y=(\!*) ; \
                    echo Nr. argomenti: ${#y} ; \
	            echo "Elenco argomenti: $s" ; \
                    @ i = 1 ; \
	            foreach a ( $s ) \
       			echo "$i Parametro: $a" ; \
   		        @ i++ ; \
	            end'
[root@localhost ~]# TestParametri a b c
Nr. argomenti: 3
Elenco argomenti: a b c
1 Parametro: a
2 Parametro: b
3 Parametro: c

SCRITTURA SU FILE:

Alla base di questo esempio abbiamo i simboli di ridirezione > e >>. L'esempio, funzionante sia in csh che sh, crea un file Testo.txt di 4 righe
 

echo Prima riga   > TESTO.TXT
echo Seconda riga >>TESTO.TXT
echo Terza riga   >>TESTO.TXT
echo -- Creato il `date +%d/%m/%Y` alle `date +%H.%M.%S`  >>TESTO.TXT
echo Visualizza il FILE
echo ------------------------
cat TESTO.TXT
echo ------------------------

read -t3 -dX -s -p "Attendere 3 secondi (premi X per terminare) ..." ; echo

#!/bin/csh -f
sh -c 'read -t3 -dX -s -p "Attendere 3 secondi (premi X per terminare) ... " ; echo'

let MAX_N=10
let N=$RANDOM
let N=$(($N%$MAX_N))+1
echo N=$N

#!/bin/csh -f
@ MAX_N=10
@ N=`awk 'BEGIN {srand();x=sprintf("%d",rand()*100); print x}'`
@ N = $N % $MAX_N + 1
echo N=$N

Pasqua ()
{
   local a
   let year=$1
   Mesi=(Gennaio Febbraio Marzo Aprile Maggio Giugno
         Luglio Agosto Settembre Ottobre Novembre Dicembre)
   if [ $year -ge 1583 ]; then
      # Calendario gregoriano
      a=$((year % 19))
      b=$((year / 100))
      c=$((year % 100))
      d=$((b / 4))
      e=$((b % 4))
      f=$(( (b + 8)/ 25))
      g=$(( (b - f + 1) / 3))
      h=$(( (19 * a + b - d - g + 15) % 30))
      a=$((year % 19))
      b=$((year / 100))
      c=$((year % 100))
      i=$(( c / 4))
      k=$(( c % 4))
      l=$(( (32 + 2 * e + 2 * i - h - k) % 7))
      m=$(( (a + 11 * h + 22 * l) / 451))
      n=$(( h + l - 7 * m + 114))
      mese=${Mesi[$((n / 31 -1))]}
      giorno=$(( n % 31 + 1))
   else
      # Calendario Giuliano
      a=$((year % 4))
      b=$((year % 7))
      c=$((year % 19))
      d=$(( (19 * c + 15) % 30))
      e=$(((2 * a + 4 * b - d + 34) % 7))
      f=$((d + e + 114))
      mese=${Mesi[$((f / 31 - 1))]}
      giorno=$((f % 31 + 1))
   fi
   echo "$giorno $mese $year"
}
# uso:
# ./GiorniPasquali.sh 2000 2010
for ((a=$1; a <= $2 ; a++))
do
   Pasqua $a
done
echo;

CONTA=""
while :
do
   clear
   echo "---------------------------------------"
   echo "ESEMPIO MENU $CONTA"
   echo "---------------------------------------"
   echo "1 - Menu A : Visualizza Ora"
   echo "2 - Menu B : Visualizza Data"
   echo "3 - Menu C : Azzera conteggio"
   echo "4 - Exit"
   echo "---------------------------------------"
   echo;
   opt=""
   read -t2 -n1 -s -p "digita un'opzione: [1-4]: " opt
   if [ -n $opt ]; then
      echo;
   fi
   case "$opt" in
      ""  ) CONTA="$CONTA*";;
      "1" ) echo "Ora corrente `date +%H.%M.%S`";
            echo -n "Premi un tasto per continuare ...";
            read -n1 enterKey;;
      "2" ) echo "Data corrente: `date +%d/%m/%Y`";
            echo -n "Premi un tasto per continuare ...";
            read -n1 enterKey;;
      "3" ) CONTA="";;
      "4" ) echo "Bye Bye $USER";
            break;;
      * ) echo "$opt: opzione errata! Digita un numero tra 1 e 4";
          echo -n "Premi un tasto per continuare ...";
          read -n1 enterKey;;
   esac
   if [ "$CONTA" == "******" ]; then
      CONTA=""
   fi
done

---------------------------------------
ESEMPIO MENU ***
---------------------------------------
1 - Menu A : Visualizza Ora
2 - Menu B : Visualizza Data
3 - Menu C : Azzera conteggio
4 - Exit
---------------------------------------

digita un'opzione: [1-4]:

L'utility awk (acronimo di Aho Weinberger Kerningan) richiede:
- un programma (nel linguaggio di awk),
- un'espressione regolare (pattern) 
- un testo da esaminare (che può arrivare anche tramite una pipe).
Il testo analizzato da awk viene visto come una sequenza di linee contenenti dei valori separati da opportuni separatori. Il sorgente del programma in awk può essere digitato direttamente sulla linea di comando oppure scritto in un file esterno. Ogni istruzione di awk ha una sintassi di questo tipo:

pattern {comandi in linguaggio awk}

b) L’opzione -F permette di specificare un separatore per le colonne/campi diverso da quelli predefiniti (spazio e tabulazione). In questo esempio il comando awk (privo del  pattern) utilizza come separatore i due punti :

awk -F: '{print $5,$1}' /etc/passwd

le variabili $5 e $1 si riferiscono rispettivamente al quinto e al primo campo/colonna di ogni linea del file /etc/passwd; il carattere , inserisce uno spazio fra le due colonne/campi visualizzati; 

c) Ogni linea presente nel file analizzato  viene verificata con i pattern proposti e se c’è corrispondenza viene intrapresa l’azione racchiusa tra {} altrimenti niente. Quindi con il comando:

awk '/sechi/{print $0}' srcfile  

verranno visualizzate tutte le righe contenenti la parola "sechi" (attenzione è case sensitive!). La variabile $0 si riferisce all’intera linea.

d) Nell'esempio successivo non è indicata alcuna azione da eseguire (quella che è solitamente racchiusa tra {}). In questo caso l'azione di default intrapresa  è print $0 ovvero la stampa, sullo standard output, delle linee che hanno soddisfatto i vincoli imposti dal pattern. Il comando seguente:

awk '/^da_qui/,/^a_qui/' srcfile

stampa tutte le linee di srcfile che risultano delimitate dalla linea che inizia con la sequenza "da_qui" fino a quella che inizia per "a_qui".

e) Un pattern può essere una espressione regolare (molto usate con il comando grep) o una condizione. Il comando awk converte automaticamente, quando il contesto lo richiede, un campo in numero. Nell'esempio successivo:

awk ‘$1 > 18{print $2}’ srcfile

verrà visualizzata la 2° colonna delle righe che hanno il primo campo maggiore di 18. Le espressioni regolari usano alcuni dei metacaratteri che vengono utilizzati anche dalla shell. Per questo motivo è necessario racchiuderle fra singolo apice.

f) Vediamo ora una serie di esempi. Tutti gli esempi analizzano il seguente file di testo (si noti la presenza di una linea vuota [contenente solo un invio]):

m.1) Sechi Paolo
f.2) Rosi Bruna
m.3) Bianchi Pierpaolo
m.4) Sechi Giulio^

m.5) Paolotto Mario*
f.6) Bronchi Rosa-
f.7) Fiini Marcella*
m.8) Fabiana GianPaolo

Analizziamo ora alcune regole nella costruzione delle espressioni regolari
- l'uso delle [] indica un elenco di alternative (ad esempio con [az] verifico che contenga la lettera a oppure z)
- se all'interno delle [] la sequenza di lettere inizia per ^ allora viene verificata la negazione (ad esempio con [^az] verifico che non contenga la lettera a o z)
- se all'interno delle [] il carattere ^ non è all'inizio allora l'accento circonflesso ^ viene interpretato come semplice carattere. (ad esempio con [az^] verifico che contenga la lettera a oppure z oppure ^)
- il carattere ^ all'inizio dell'espressione regolare indica che il controllo va fatto all'inizio della linea (ad esempio ^[az] controlla che la linea inizi per a o z)
- il . (punto) indica un qualsiasi carattere ad esclusione dell'invio (newline). Se l'epressione regolare è composta dal solo . allora escludo dall'analisi le righe vuote
- il carattere $ in fondo all'espressione regolare indica che il controllo va fatto alla fine della linea (ad esempio [az]$ verifica che la linea finisca con a oppure z)
- il carattere * indica che il carattere che lo precede può apparire zero o più volte
- il carattere + indica che il carattere che lo precede può apparire una o più volte
- il carattere ? indica che il carattere che lo precede può apparire zero o una volta
- il carattere \ serve ad indicare che il carattere successivo  non va interpretato come un metacarattere
- la sequenza \< verifica la corrispondenza all’inizio di una parola
- la sequenza \> verifica la corrispondenza alla fine di una parola
- \<espressione_regolare\>" verifica la corrispondenza esatta su almeno una delle parole contenute nella linea (la stringa "espressione_irregolare" non verrà quindi riconosciuta)
- ^regolare$" verifica la corrispondenza esatta sul contenuto dell'intera linea
- un'espressione regolare, composta da "sottoespressioni regolari" collegate tra loro dalla | (pipe), risulta verificata se almeno una delle sottoespressioni risulta verificata (ad esempio: [iu|ie] estrae le righe che contengono la sottosequenza ie oppure iu)
- Sequenze combinate di caratteri racchiusi tra parentesi quadre verificano le possibili modalità di scrittura di una parola. Ad esempio "[Ss][Ii]" controlla che si sia scritta una delle seguenti sequenze: si, SI, Si, sI. L'espressione regolare "[0-9][0-9][0-9][0-9][0-9]" verifica la "compatibilità" di una stringa  con le modalità di scrittura di un codice di avviamento postale.

Ed ora ecco gli esempi:

sh-2.05$ awk '{print}' elenco
m.1) Sechi Paolo
f.2) Rosi Bruna
m.3) Bianchi Pierpaolo
m.4) Sechi Giulio^

m.5) Paolotto Mario*
f.6) Bronchi Rosa-
f.7) Fiini Marcella*
m.8) Fabiana GianPaolo

sh-2.05$ awk '/Paolo/{print}' elenco
m.1) Sechi Paolo
m.5) Paolotto Mario*
m.8) Fabiana GianPaolo
sh-2.05$ awk '/paolo/{print}' elenco
m.3) Bianchi Pierpaolo

sh-2.05$ awk '/a$/{print}' elenco
f.2) Rosi Bruna
sh-2.05$ awk '/[a-]$/{print}' elenco
f.2) Rosi Bruna
f.6) Bronchi Rosa-
sh-2.05$ awk '/^f.2) Rosi Bruna$/' elenco
f.2) Rosi Bruna
sh-2.05$ awk '/^$/{print}' elenco
riga vuota
sh-2.05$ awk '/iu|ie/{print}' elenco
m.3) Bianchi Pierpaolo
m.4) Sechi Giulio^

sh-2.05$ awk '/./{print $0}' elenco
m.1) Sechi Paolo
f.2) Rosi Bruna
m.3) Bianchi Pierpaolo
m.4) Sechi Giulio^
m.5) Paolotto Mario*
f.6) Bronchi Rosa-
f.7) Fiini Marcella*
m.8) Fabiana GianPaolo
sh-2.05$ awk '/lo./{print}' elenco
m.5) Paolotto Mario*
sh-2.05$ awk '/iu*l*i/{print}' elenco
m.4) Sechi Giulio^
f.7) Fiini Marcella*
sh-2.05$ awk '/iu+l+i/{print}' elenco
m.4) Sechi Giulio^
sh-2.05$ awk '/ab?r?i/{print}' elenco
m.5) Paolotto Mario*
m.8) Fabiana GianPaolo

sh-2.05$ awk '/[uSG^-]/{print}' elenco
m.1) Sechi Paolo
f.2) Rosi Bruna
m.4) Sechi Giulio^
f.6) Bronchi Rosa-
m.8) Fabiana GianPaolo
sh-2.05$ awk '/[$]$/{print}' elenco
f.2) Rosi Bruna$

sh-2.05$ awk -F\) '{print $2}' elenco
 Sechi Paolo
 Rosi Bruna
 Bianchi Pierpaolo
 Sechi Giulio^

 Paolotto Mario*
 Bronchi Rosa-
 Fiini Marcella*
 Fabiana GianPaolo

sh-2.05$ awk '/\<Paolo/{print}' elenco
m.1) Sechi Paolo
m.5) Paolotto Mario*
sh-2.05$ awk '/Paolo\>/{print}' elenco
m.1) Sechi Paolo
m.8) Fabiana GianPaolo
sh-2.05$ awk '/\<Paolo\>/' elenco
m.1) Sechi Paolo

sh-2.05$ awk '/^[fm]/{print}' elenco
m.1) Sechi Paolo
f.2) Rosi Bruna
m.3) Bianchi Raffaello
m.4) Sechi Giulio^
m.5) Paolotto Mario*
f.6) Bronchi Rosa-
f.7) Fiini Marcella*
m.8) Fabiana GianPaolo
sh-2.05$ awk '/^f.2/' elenco
f.2) Rosi Bruna

g) Concludiamo con ulteriori esempi:

sh-2.05$  awk '( $2~/^B/ && $3~/[o-]$/ ) { print }' elenco
m.3) Bianchi Pierpaolo
f.6) Bronchi Rosa-
sh-2.05$ awk '( $2~/^B/ && ($3~/o$/ || $3~/-$/ ) ) { print }' elenco
m.3) Bianchi Pierpaolo
f.6) Bronchi Rosa-

Si osservi che la ~ (tilde) consente di verificare se se un campo "rispetta" l'espressione regolare scritta dopo la tilde. La sequenza !~  equivale a "non rispetta"

sh-2.05$  awk '( $2!~/^B/ && $3~/[o-]$/ ) { print }' elenco
m.1) Sechi Paolo
m.8) Fabiana GianPaolo
sh-2.05$ awk '( $2!~/^B/ && ($3~/o$/ || $3~/-$/ ) ) { print }' elenco
m.1) Sechi Paolo
m.8) Fabiana GianPaolo

sh-2.05$ awk '( length($2)>=8 ) { print "Cognome: " $2 "\n" "Nome: " $3 }' elenco
Cognome: Paolotto
Nome: Mario*

E' possibile digitare direttamente sia il testo da analizzare che lo script in awk . Nel caso sia necessario scrivere il programma awk su più linee basta inserire in fondo ad ogni linea il carattere \.  Quando ho, nella stessa sezione (porzione di programma delimitato da {}), più istruzioni le devo separare con ;.
Usando infine la funzione di ridirezione "here document" così caratterizzata <<marcatore (tipicamente si usa come marcatore il nome EOF)  posso ridirigere verso lo standard input di un comando del testo digitato direttamente su più righe semplicemente scrivendolo  tra due occorrenze di marcatore (l'ultima occorrenza deve apparire su una linea da sola).

sh-2.05$ awk 'BEGIN { f=0;m=0;n=0 } \
{ n++;if (/^f./) { f++;print n"/"f " - (F) " $2 " " $3 } \
else if (/^m./) {m++ ; print n"/"m " - (M) " $3 " " $2 } } \
END {print "------ Fine" }' << EOF
m.1) Sechi Paolo
f.2) Rosi Bruna$
m.3) Bianchi Pierpaolo
m.4) Sechi Giulio^

m.5) Paolotto Mario*
f.6) Bronchi Rosa-
f.7) Fiini Marcella*
m.8) Fabiana GianPaolo
EOF
1/1 - (M) Paolo Sechi
2/1 - (F) Rosi Bruna$
3/2 - (M) Pierpaolo Bianchi
4/3 - (M) Giulio^ Sechi
6/4 - (M) Mario* Paolotto
7/2 - (F) Bronchi Rosa-
8/3 - (F) Fiini Marcella*
9/5 - (M) GianPaolo Fabiana
------ Fine