Ana səhifə

Programmazione in korn shell


Yüklə 156.66 Kb.
tarix22.06.2016
ölçüsü156.66 Kb.
PROGRAMMAZIONE IN KORN SHELL

E.M.



  • DAVID KORN, BELL LABS, "THE KORN SHELL COMMAND AND PROGRAMMING LANGUAGE", 89, PRENTICE HALL

PRIMO ESEMPIO: SCRIPT FILE "primo" -> ECHO $random




  • ESECUZIONE:

- DALLA SHELL (PROMPT $)  $primo


IL FILE DEVE AVERE LE PROTEZIONI DI LETTURA ED ESECUZIONE. ALTRIMENTI: $chmod +rx primo
OPPURE, CHIAMANDO LA SHELL ESPLICITAMENTE: $ksh primo

BASTA IL PERMESSO DI LETTURA




  • COMMENTI NELLO SCRIPT: CARATTERE #

SI POSSONO METTERE ANCHE RIGHE VUOTE.


  • NOME DELLO SCRIPT: PUO' ESSERE UN NOME RISERVATO (SHELL STATEMENT O COMANDO UNIX).

  • script.ksh




  • DEBUG

  • DEBUG TOTALE:

$ksh –x scriptfile


  • DEBUG PARZIALE

NELLO SCRIPT : …

set –x # START DEBUG

set +x # STOP DEBUG




  • LINEA USAGE:

USAGE = “usage: script parameteri”


NON VIENE ESEGUITA, MA PUO’ ESSERE STAMPATA CON

grep USAGE nome_script




  • SCRITTURE DA SCRIPT




  • echo

  • print (PIU’ USATA IN KORN)

ESEMPI DI PRINT


$print ciao a tutti
$print “ciao a tutti”
$print –n “ciao”  INIBISCE EOL

$print –n “a tuttti”

$print
$print “\nciao \na tutti”  \n introduce una newline

$print “\t ciao a tutti”  \t e’ un TAB




  • USO DEGLI APOSTROFI

GLI APOSTROFI SONO: ‘ “


CARATTERI CON SIGNIFICATO PARTICOLARE: $\#?[]*{}|();”’


  • APOSTROFO SINGOLO: QUELLO CHE E’ RACCHIUSO TRA APOSTROFI PERDE IL SUO SIGNIFICATO PARTICOLARE

ESEMPIO

$print ‘$x’  SCRIVE $x

$print “$x”  SCRIVE IL VALORE DI x
OPPURE: NELLA CANCELLAZIONE:

$rm nome SE nome HA CARATTERI SPECIALI, P.ES. $, ALLORA: $rm ‘$nome’





  • BACKSLASH: QUELLO CHE SEGUE IMMEDIATAMENTE PERDE IL SUO SIGNIFICATO PARTICOLARE

ESEMPIO:


$rm \$nome

$rm ‘$’nome


COME SI STAMPANO?
$print ‘ciao ‘a’ tutti’  SCRIVE ciao ‘a’ tutti

$print ciao \’a\’ tutti  SCRIVE ciao ‘a’ tutti

$print ‘ciao “a” tutti’  SCRIVE ciao “a” tutti


  • VARIABILI



  • NOMI: COMBINAZIONI DI LETTERE, NUMERI E _ MA NON POSSONO COMINCIARE CON UN NUMERO

  • LUNGHEZZA: NESSUN LIMITE

  • QUANTITA’ DI VARIABILI: ILLIMITATE

  • LISTA DELLE VARIABILI: $set

  • CASE SENSITIVE




  • INPUT DA SCRIPT

CON L’ISTRUZIONE read:


$read nome

$read uno due tre



IL VALORE DELLA VAR nome SI RECUPERA CON LA SCRITTURA $nome


ESEMPIO:

$print “x”  scrive x

$print “$y”

$print “$x”  scrive il valore

$print “y=$x”

$print “$y”




  • ASSEGNAZIONE

1 - n=100 (SENZA SPAZI AI LATI DI = !!)

2 - let n=100

3 – let “n = 100”

4 – ((n = 100))
ASSEGNAZIONE DI TRA DUE VARIABILI:

x=$n
SCRITTURA DI UNA VARIABILE:

print “$x”
print “$USAGE=”
ATTENZIONE AGLI SPAZI!
y = 100  errore
y = “nome”  errore
USO IMPROPRIO DEL SEGNO $:
y=50  ok

x=y  assegna il nome y ad x

x=$y  assegna 50 ad x

$x=$y errore




  • TIPI DI DATI




  • COSTANTI

  • STRINGHE (DEFAULT)

  • INTERI

  • ARRAY

  • GLOBALI (DEFAULT)

  • STATEMENT typeset PER DEFINIRE I TIPI DI VARIABILI

  • DIMENSIONE ARRAY: DIPENDE DALLA VERSIONE DELLA SHELL, MA TIPICAMENTE 512 O 1024

  • ARRAY: SOLO AD UNA DIMENSIONE



DICHIARAZIONE DI STRINGHE





SCRITTO IL NOME DELLA VARIABILE


  • ALTRIMENTI, SI PUO' USARE LO STATEMENT

typeset

ESEMPIO:
typeset lettera, stringa_numerica, messaggio


lettera="a"

stringa_numerica="12345"

messaggio="chiamami al 3861"

print "ecco qualche stringa"

print "$lettera, $stringa_numerica, $messaggio"


DICHIARAZIONE DI VARIABILI INTERE





  • SI PUO' USARE LO STATEMENT typeset -i OPPURE integer :

typeset -i variabile

integer variabile
ESEMPIO:
integer a

a=100


print "a = $a"


  • INIZIALIZZAZIONE DI VARIABILI:

integer b=100




  • DICHIARAZIONE DI COSTANTI

typeset -r nome_della_costante=valore




  • DICHIARAZIONE DI ARRAY: GLI ARRAY VENGONO DEFINITI APPENA VIENE ASSEGNATO UN VALORE ALL'ARRAY.

ESEMPIO DI ARRAY DI STRINGHE:


a[0]="primo"

a[1]="secondo"

a[10]="decimo"
QUESTO E' UN ARRAY DI STRINGHE PERCHE' NON E' DICHIARATO DIVERSAMENTE. GLI ELEMENTI NON DICHIARATI SONO STRINGHE NULLE.
ESEMPIO DI ARRAY DI INTERI:
integer b

b[1]=1


b[2]=2
read b[10]


  • INIZIALIZZAZIONE:

set -A a primo secondo terzo



STAMPA DI UN ARRAY





  • VALORI INDIVIDUALI

print "elemento 0 = ${vettore[0]}

indice=2

print "elemento $indice = ${vettore[$indice]}

print


  • TUTTO L'ARRAY

print "array intero = ${vettore[*]}

print


  • L'USO DELLE {} VA FATTO SOLO QUANDO SI PRELEVA UN

VALORE. ESEMPIO:
a[1]="primo"

print ${a[1]}

v[0]=${a[1]}


OPERAZIONI MATEMATICHE





  • SOLO NUMERI INTERI (32 BIT) CON SEGNO. NON SEGNALA

ERRORE SE SI USANO VARIABILI FLOATING POINT MA ESEGUE OPERAZIONI INTERE!


  • OPERAZIONI AMMESSE:

+ - * / % << >> & ^(or esc.) |




  • SINTASSI CON DOPPIE PARENTESI! ESEMPIO:

integer x

integer y

integer z


((z=x+y))

((z=x-y))

((z=x*y))

print " numero complessivo = $((x+y+z))"




  • OPERAZIONI MATEMATICHE ANCHE SU VARIABILI DI TIPO

STRINGA!


  • STAMPA DI NUMERI NEGATIVI: OPZIONE -R (ALTRIMENTI IL

SEGNO MENO (-) E' CONSIDERATO UNA OPZIONE!)


  • PRIORITA' DELLE OPERAZIONI:

1) MOLTIPLICAZIONI

2) DIVISIONI

3) SOMME E SOTTRAZIONI




  • NUMERI IN BASE 2, 8, 16

typeset -i x=123

typeset -i2 y

typeset -i8 z

typeset -i16 h
h=z=y=x ( CONVERSIONE AUTOMATICA )


  • LETTURA DA TASTIERA:

SCRIVERE 2#1000 O 8#12 O 16#56


  • NUMERO DI CIFRE:

typeset -Zn variabile ( USA n CIFRE. SOLO CON STRINGHE )


ESEMPIO:

typeset -Z4 numero

numero=12345

print $numero ( 2345 )

numero=123

print $numero ( 0123 )



PATTERN MATCHING IN KORN SHELL




  • USO DI ‘WILDECARDS’. DOVE SI POSSONO USARE LE

WILDECARDS?
1) IN ALCUNI COMANDI UNIX

2) NELLO STATEMENT CASE

3) NELLO STATEMENT FOR

4) NELLO STATEMENT SET

5) NELLE ISTRUZIONI DI MANIPOLAZIONE STRINGHE


  • WILDECARDS:

1) ?  MATCHING CON 1 SOLO CARATTERE


2) [c1c2...cn]  1 carattere di quelli specificati
ESEMPIO:

ca[abz]  caa, cab, caz

ca[a-z][a-z]

ca[0-9]


ca[!abz]

ca[\-\]\!\\]  ca-, ca], ca! ca\


3) *  CORRISPONDE CON TUTTE LE STRINGHE
4) ?(stringa1| stringa2| … | stringan)  CORRISPONDE CON NESSUNA O CON UNA DELLE STRINGHE SPECIFICATE. ESEMPIO:

care?(ful|less|free)  care, careful, careless, carefree

care?([a-z]|less)  care, caret, careless

care?(?|??)  care, carez, careto


5) @(stringa1|stringa1|stringa3)  SOLO UNA DELLE STRINGHE.

ESEMPIO:
care@(a|b|c)  carea, careb, carec


6) *(stringa1|...|stringan)  QUALSIASI STRINGA

INCLUSA LA STRINGA NULLA. ESEMPIO:


P*(A|B)  P, PA, PB, PAB, PAA, ...
7) +( stringa1|...|stringan)  COME *, MA SENZA LA

STRINGA NULLA.


8) !( stringa1|...|stringan )  CORRISPONDE A TUTTE LE

STRINGHE FUORCHE' QUELLE SPECIFICATE

ESEMPIO:
care!(*.bak|*.out)  TUTTE LE STRINGHE

TRANNE I NOMI CHE FINISCONO IN .bak O .out



CONDIZIONI E CONFRONTI





  • TRA NUMERI  (( ))




  • TRA STRINGHE  [[ ]]

  • DUE PUNTI (:)  CONDIZIONE TRUE




  • TEST SU NUMERI: == != < > <= >=




  • TEST SU STRINGHE: = != > < -z (stringa nulla)




  • STATEMENT if-then-else .

1° ESEMPIO :

read n1 n2

if ((n1

then


print “$n1 minore di $n2”

else


print “$n2 minore di $n1”

fi
2° ESEMPIO:

read n1 n2

if ((n1

then

print “$n1 minore di $n2”



elif ((n1==n2))

then


print “$n1 uguale a $n2”

else


print “$n1 maggiore di $n2”

fi

CONFRONTO TRA STRINGHE





  • ATTENZIONE: NON METTERE SPAZI!

ESEMPIO:
if [[$x=$y]]

then






  • USO DEL PATTERN MATCHING

ESEMPIO:
print –n “scrivi una stringa”

read nome

if [[$nome=c*]]

then


print “$nome comincia con c”

fi
if [[$nome!=*c]]

then

print “$nome non finisce con c”



fi
if [[$nome=@[nome1|nome2|…|nomen]]]

then


print “$nome e’ uno dei nomi dati”

fi


  • OPERATORI LOGICI AND, OR: || &&

ESEMPIO:
if ((x

then

print “$x e’ minore di $y e $z”



fi


  • STATEMENT case-esac

SINTASSI:
case $nome in
“nome1”) print “primo caso”

print ;;
“nome2”) print “secondo caso”

print ;;
[a-z][a-z]) print “coppia di caratteri”

print ;;
str1@[str2|str3) print “str1str2 oppure str1str3

print ;;
str1|str2|str3) print “str1 oppure str2 oppure str3”

print;;
*) print “caso inatteso” ;;


esac


TEST SUI FILE




  • ELENCO DELLE OPZIONI (FILE MODE) :

-a nome  esiste?

-f nome  e’ un file regolare?

-d nome  e’ un direttorio?

-c nome  e’ un file di caratteri?

-b nome  e’ un file a blocchi?

-p nome  e’ una pipe?

-S nome  e’ un socket?

-L nome  e’ un link ad un altro oggetto?

-s nome  e’ non vuoto?




  • ELENCO DELLE OPZIONI (PROTEZIONI):

-r nome  posso leggere?

-w nome  posso modificarlo?

-x nome  posso esguirlo?

-O nome  ne sono proprietario?

-G nome  e’ il mio gruppo?




  • CONFRONTO SULLE DATE:

nome1 -nt nome2  nome1 piu’ nuovo di (newer than) nome2

nome1 -ot nome2  nome1 piu’ vecchio di (older than) nome2
NB:


ESISTENTE PIU’ NUOVO

  • SE NESSUN FILE ESISTE, IL RISULTATO E’ FALSO



CICLI IN KORN SHELL





  • STATEMENT while

ESEMPIO:
integer n=0

while ((n<4))

do

((n=n+1))



done


  • STATEMENT until

ESEMPIO:
integer n=0

until((n>4))

do

((n=n+1))



done


  • STATEMENT for

ESEMPIO:
for n in 1 2 3 4

do

print “valore di n = $n”



done
integer ris=5

for n in 10 100 1000

do

((ris=ris*n))



done

print “ris=$ris”


for nome in mario giuseppe vittorio

do


print “$nome”

done



  • STATEMENTS break E continue: ANALOGO AL LINGUAGGIO C. break ESCE DAL CICLO E continue LO RIPRENDE




  • ALTRI ESEMPI: PARSING DI UNA STRINGA IN PAROLE:

for parola in $linea

do

print “$parola”



done


  • LISTA DEI FILE CON PERMESSO DI LETTURA

for nome in *  tutti gli oggetti nella directory

do

if [[-f $nome]] && [[-r $nome]] && [[-w $nome]]



then

print “ il file regolare $nome puo’ essere letto e scritto”

fi

done



PARAMETRI DI LINEA AD UNO SCRIPT





  • POSSONO ESSERE:




  • ARGOMENTI SEMPLICI (NUMERI STRINGHE PATHNAME)

  • OPZIONI (PER ES. –x O +x )

  • REDIREZIONI (> O <)




  • PARAMETRI POSIZIONALI:

$$  PID

$#  NUMERO DEI PARAMETRI

$*  STRINGA FORMATA DA TUTTI I PARAMETRI

$@  ESPANDE GLI ARGOMENTI

$0  NOME DELLO SCRIPT, DELLA FUNZIONE

$1…$9,${10}…  PARAMETRI




  • ESEMPIO D’USO DI $#

USAGE=“usage: $0 parametri”

if (($# > 4))

then


print “troppi parametri”

elif (($# == 4))

then

print “ok”



for i in $@

do

print “$i”



done

else


print “$USAGE”

fi


  • STATEMENTS set, shift

set par 1 par2 par3 …  assegna valori ai parametri posizionali

set –s  ordina i parametri

set --  cancella i parametri

shift n (es. shift 1 shift 2 … )  shift a sinistra la lista dei parametri


  • STATEMENT getopts  analizza una lista di switch (opzioni), uno alla volta.

CONCETTO:

while getopts ab var

do

case $var in



  1. …;

  2. …;

esac

done
USO DEL CARATTERE DUE PUNTI ( : )  se messo prima della opzione,

invia il carattere ? se lo switch e’ invalido

 se messo dopo l’opzione,

mette l’argomento in OPTARG

ESEMPIO:


while getopts :x:y: var

do

case $var in



x) print “$OPTARG”;; # opzione –x

+x) print “$OPTARG”;; # opzione +x



  1. print “$OPTARG”;;

-y) print “$OPTARG”;;

\?) print “$OPTARG invalido”

print “$USAGE”;;

esac


done

  • STATEMENT select

Viene usata per realizzare Menu’. E’ un ciclo: ad ogni iterazione legge una variabile.


Per uscire dal ciclo usare break o exit
Per continuare il ciclo, usare continue
La var. d’ambiente PS3 e’ usata per il prompt.

Esempio:
PS3=“scrivere un comando:”

select var in stringa1 stringa2 esci

do

case $var in



stringa1) print “hai battuto stringa1”;;

stringa2) print “hai battuto stringa2”;;

esci) print “hai optato per l’uscita”

exit;; # si poteva mettere anche break

esac

done


FUNZIONI IN KORN





  • VARIABILI GLOBALI: DICHIARATE IMPLICITAMENTE (STRINGHE) O DICHIARATE FUORI DA UNA FUNZIONE




  • VARIABILI LOCALI: DEFINITE ALL’INTERNO DI UNA FUNZIONE CON typedef O integer




  • LE VARIABILI RISERVATE SONO GLOBALI




  • E’ AMMESSA LA RICORSIONE




  • I PARAMETRI PASSATI AD UNA FUNZIONE SONO RECUPERATI CON IL MECCANISMO DEGLI SCRIPT




  • UNO SCRIPT PUO’ CHIAMARE UN ALTRO SCRIPT: IL PASSAGGIO PARAMETRI E’ LO STESSO DELLE FUNZIONI




  • RITORNO PARAMETRI:

  • CON RETURN: RITORNO UN VALORE INTERO DI 8 BYTE NELLA VARIABILE $? ATTENZIONE: SALVARE SUBITO $? PERCHE’ E’ USATA DA TUTTI I PROCESSI (COMANDI, SCRIPT …) PER IL VALORE DI RITORNO

  • TRAMITE VARIABILI GLOBALI

  • TRAMITE FILE

  • CON LA SCRITTURA a=$(nome_funzione param)

ESEMPI
function sqr

{

((s=$1*$1))



print “quadrato di $1 = $s”

}
function sqr

{

((s=$1*$1))



return $s

}
n=5

sqr $n

p=$? # da salvare perche’ print modifica la $?



print “quadrato di $n = $p”



  • PASSAGGIO DI UN ARRAY AD UNA FUNZIONE:

funct ${array[*]}
ESEMPIO:
function minimo

{

set –s



print “minimo = $1”

}

a[0]=50



a[1]=1

a[100]=33



minimo ${a[*]}

ELABORAZIONE DI STRINGHE





  • LUNGHEZZA DI UNA STRINGA: length=$(#stringa)







  • CONFRONTO DI UNA STRINGA ED UN PATTERN




  • ASSEGNAZIONE DI UN VALORE AD UNA STRINGA




  • CONVERSIONE DI UNA STRINGA IN UPPER O LOWER CASE:

typeset –u stringa  converte in upper

typeset –l stringa  converte in lower




  • GIUSTIFICAZIONE A SINISTRA:

typeset –Ln stringa


  • CONCATENAZIONE




  • RIMOZIONE DEI CARATTERI IN UNA STRINGA :

  • A SINISTRA:  USO #

  • A DESTRA  USO %

Esempio: rimuovo due caratteri a sx e dx: ${stringa#??} ${stringa%??}


INPUT/OUTPUT





  • STATEMENT DI BASE:

  • read

  • print

  • exec  apre e chiude streams

  • operatori per la redirezione




  • READ VAR

REPLY


  • PROMPT: read nome?“scrivi il nome”

  • IL TERMINATORE DELL’INGRESSO E’ DATO DALLA VARIABILE

IFS

  • DI DEFAULT, IFS=spazio|tab|return

  • ESEMPIO DI RIDEFINIZIONE DI IFS: IFS= “.|”


  • LETTURA DI UN INGRESSO PIU’ LUNGO DI UNA LINEA  \

ESEMPIO:

read var


questa\

e’\


una\

stringa


  • LETTURA ALL’INTERNO DI UN CICLO:

while read var # continua a leggere fino a quando scrivo ^d

do

((tot=tot+var))



done

print “totale = $tot”



  • REDIREZIONE DELL’INPUT

TOTALE: $script < file

PARZIALE: while read var

do

((tot=tot+var))



done < file

  • PRINT

  • OPZIONI:

\a  bell

\b  sovrascrive

-r  inibisce il significato del carattere backslash

--  come –R


- REDIREZIONI:
#parsing di un file

read inp?“input file”

read out?“output file”

while read stringa

do

for word in $stringa



do

print “$word”

done

done < $inp > $out




  • EXEC

APRE UN FILE PER LETTURA E SCRITTURA
- APERTURA PER READ: exec 8< file # 8 e’ il descrittore del file

- APERTURA PER PRINT: exec 8> file # idem

- CHIUSURA DEL FILE: exec 8<&-

- LETTURA/SCRITTURA: read –u8 var / print –u8 $var

- CATTURA DELL’OUTPUT ASCII DI UN COMANDO:
var=$(comando-Unix)

ESEMPIO: var=$(ls –l)

var=$(sort filename)


  • LETTURA DI UN TEXT FILE IN UNA VARIABILE STRINGA

ESEMPIO: var=$(< filename)

FOREGROUND, BACKGROUND





  • BACKGROUND PROCESS: NON RICHIEDE DATI INTERATTIVAMENTE MA SOLO TRAMITE FILE

ESEMPIO: $comando < filein > fileout&


  • OPERATORE DI BACKGROUND  &




  • CONTROLLO DEI PROCESSI IN BACKGROUND:

$bg  porta un processo da foreground a background

$fg  porta un processo da background a foreground

$kill –STOP processo  ferma un processo

$kill –CONT processo  riavvia il processo

$kill 0  manda il segnale 15 a tutti i processi in background

$jobs  lista i numeri e gli identificatori dei processi in background




SEGNALI





  • SEGNALI DA TASTIERA:

control-c  INT (segnale nr.2)

control-\  QUIT (segnale nr. 3)

control-s  STOP (segnale nr. 17)

control-q  CONT (segnale nr. 19)




  • SEGNALE DA PROCESSO: comando kill

$kill [-nomesegnale| -numerosegnale] PID

  • TUTTI I SEGNALI ECCETTO STOP E CONT POSSONO TERMINARE UN PROCESSO (SCRIPT)

  • PER CATTURARE UN SEGNALE: STATEMENT TRAP

  • SI POSSONO CATTURARE DIVERSI SEGNALI

  • NON SI PUO’ CATTURARE IL SEGNALE KILL

  • SINTASSI:

trap ‘uno o piu’ comandi Unix separati da ;’ evento


  • ERRORE DI SCRIPT:

trap ‘print “c’e’ stato un errore”’ ERR


  • FILE TEMPORANEI:

trap ‘rm /tmp/* > /dev/null ; exit’ EXIT
NB: EXIT E’ IL SEGNALE 0, CHE UN PROCESSO INVIA AL KERNEL QUANDO TERMINA


  • PER EVITARE CHE UN PROCESSO SIA BLOCCATO DA TASTIERA:

trap ‘’ INT QUIT

AMBIENTE





  • ALL’AVVIO, SI RICHIAMANO ALCUNI SCRIPT:

/etc/password

/etc/profile  comune a tutti

$HOME/.profile  del singolo utente


  • AMBIENTE: INSIEME DI CARATTERISTICHE, PRIVILEGI, RISORSE

  • EREDITARIETA’: ALCUNE CARATTERISTICHE VENGONO ESPORATE DAL PADRE AL FIGLIO, MAI VICEVERSA. ESEMPIO:

SCRIPT cd.ksh: cd $1

print $PWD

 NON MODIFICA LA DIRECTORY DELLA SHELL


  • DOT-SCRIPTS: GIRANO NELL’AMBIENTE DEL PADRE! CIOE’ PUO’ CAMBIARE L’AMBIENTE!!

  • NB: LE VAR. RISERVATE, LE VARIABILI E FUNZIONI DEFINITE DAL PADRE NON SONO VISIBILI AL FIGLIO. DEVONO ESSERE ESPORTATE CON $export var

  • PER VEDERE LE VAR E FUNZIONI ESPORTATE:

$typeset –x  variabili esportate

$typeset –fx  funzioni esportate



  • ALIAS:

$alias a=’ls –l’


  • STORIA DELLA SHELL

$history  mostra i 15 ultimi comandi di shell (compreso l’attuale)
$history n1 n2  mostra i comandi da n1 a n2
$history –r n1 n2  in ordine inverso
$history –n  ultimi n


$r  riesegue l’ultimo comando

$r cc  riesegue l’ultimo

$r 98  riesegue il comando nr. 98


  • EDITING DEL COMANDO PRECEDENTE:

FCEDIT=vi



export FCEDIT
$fc 98  chiama l’editor vi per correggere la linea 98
$fc  stessa cosa con l’ultimo comando






Verilənlər bazası müəlliflik hüququ ilə müdafiə olunur ©kagiz.org 2016
rəhbərliyinə müraciət