Introduzione a PERL E.Mumolo mumolo@units.it

1. Introduzione a PERLE.Mumolomumolo@units.it

2. Prima parte.Introduzione al linguaggioPractical Extraction and Report LanguageorPathological Eclectic Rubbish Lister?

3. Introduzione a PERL • Nato per assistere l’utente Unix per le comuni operazioni, troppo pesanti, troppo dipendenti dalla shell ma troppo complesse da codificare in C ... • Compattezza (sinteticità) e potenza • Ambiente più naturale: Unix. Integra comandi sed awk grep mail IPC … • Finalizzato principalmente per elaborare stringhe e file di testo • Correntemente molto usato per operazioni di amministrazione di sistema e per CGI/HTTP • Linguaggio Interpretato • Riferimenti classici: - Programming PERL, L.Wall. R.L.Schwartz - Learning PERL, R.L.Schwartz

4. Istruzioni di base • Come si presenta uno script PERL (primo.pl) #!/user/bin/perl #esempio iniziale print “scrivi una stringa terminata da return”; $nome=<STDIN>; print “ciao $nome\n”; • Esplicitamente: prompt> perl primo.pl • Simboli: {}  rappresenta un blocco di istruzioni #  commenti $ precede nomi variabili e elementi scalari di array @ precede nomi di array normali o di raggruppamenti di elementi di array % precede i nomi di array associativi & precede i nomi delle funzioni <STDIN>, <STDOUT>  descrittori di standard input, output • Redirezione: prompt> primo.pl < filein > fileout

5. Tipi di dati in PERL • Stringhe – Numeri – Riferimenti - Liste. Non esiste il tipo logico, ma solo condizioni. Oppure: variabili non dichiarate, stringhe nulle, stringa “0” e il numero 0  Falso • Tipo definito con l’inizializzazione. Es: $a=“stringa di prova”; $a=‘0xFF’, $a=‘037’ • Numeri : rappresentazione interna solo doppia precisione • Delimitatori delle stringhe : • accento singolo : tutti i caratteri tranne tranne ‘ e \ (usare ‘\ e \\) • accento doppio : interpolazione e caratteri di controllo • Caratteri di controllo : \n newline \cC un carattere di controllo (qui: control-C) \r return \\ backslash \t tab \” doppio accento \f linefeed \l il prossimo carattere e’ minuscolo \b backspace \L tutte i prossimi caratteri sono minuscoli \v tab verticale \u il prox carattere e’ maiuscolo \a bell \U tutti I prox caratteri sono maiuscoli \e esc \E termina \L o \U \007 il valore ottale 07 \x7f il valore hex 7f

6. Operatori • Operatori aritmetici : + - * / ** % post/pre-decremento, incremento NB:Calcoli internamente in virgola mobile • Operatori logici  : • AND (&&) Se il primo e’ falso, non valuta il secondo Es. $a>10&&print “$a maggiore di 10” • OR (||) Se il primo è vero non valuta il secondo. Es. $a>10||print “$a minore di 10” • NOT (!) Inverte il risultato logico • di confronto tra numeri: < <= > >= == != • di confronto tra stringhe: lt le gt ge eq ne • NB : il confronto tra stringhe e’ diverso dal confronto tra numeri • Operatori per stringhe : • concatenazione: .(es. “aaa”.”bbb” = aaabbb  $a . $b) • ripetizione: x (es. ‘a’x3 = aaa  $a x $b) • sottostringa substr($a,$n,%m) a partire da n per m caratteri • Indice index($a,$b) posizione del primo carattere di $b • Casting delle variabili a seconda dell’operatore Esempio: “F” . (“ 43” + 6) = “F49” “Y“ . (4*5) = “Y20“

7. Variabili scalari • Case sensitive • Il valore di una variabile ‘nomevar’ e’ sempre identificato con $nomevar • Operatori di assegnazione binaria : += *= .= • Autoincremento, autodecremento: ++$a $a++ • Operatore chomp(argomento): trasforma stringhe DOS in Unix • Operatore chop(argomento) : elimina l’ultimo carattere dell’argomento. Ritorna il carattere eliminato Es. chop($a=<STDIN>) ; • Interpolazione di variabili scalari in stringhe delimitate da “” Es. $a=”bla bla $b bla bla” ; • Se la variabile inserita viene seguita subito da testo, si puo’ usare il delimitatore {} Es. $a=”blabla${b}bla” ; stesso risultato di $a=”blabla$b”.”bla” ;

8. Variabili predefinite • $$  PID del programma • $<  UID reale dell’utente che esegue il programma • $>  UID effettivo dell’utente • $?  stato dell’ultima chiamata • $_  argomento predefinito • $0  nome del programma • $”  separatore di lista • $/ separatore di righe per l’input

9. Array e liste in PERL • Liste: sequenze di scalari separati da virgole tra parentesi tonde. Usate per inizializzare array. • Variabili di tipo Array : individuate con il carattere @ @a=(1,2,3) ; @a=1 ; # array di un solo elemento @b=@a ; @a=(“uno”, “due”, “tre”) ; @b=(1,2,@a,3) ; # @b contiene (1,2,”uno”,”due”,”tre”,3) • Uso di variabili nell’array. ($a, $b, $c) = (1,2,3) ; #inizializza le variabili $a $b $c ($a, $b) = ($b, $a) ; #inverte ($d, @z) = ($a, $b, $c) ; #risultato : $d=$a, @z=($b, $c) ($e, @z)=@z ; #risultato : $e=$b, @z=($c) • Assegnazione scalare=array : la var scalare contiene il numero di elementi @a=(1,2,3) ; $b=@a ; #risultato : la var b contiene 3 ($b) = @a ; # la var b contiene il primo elemento di @a • Accedere ad un elemento non definito ritorna undef ; assegnare un elemento non definito estende l’array

10. Accesso agli elementi di un array • Array predefinito @ARGV  argomenti dello script PERL • Gli elementi di un array sono indicizzati da 0 @a=(1, 2, 3) ; $b=$a[0] ; # $b contiene 1 $a[0]=4 ; # @a = (4,2,3) $a[1]++; $a[2] += 4; • L’array puo’ essere raggruppato in parti: @b=@a[0,1] ; # equivale a @b=($a[0], $a[1]) ; @a[0,1]=(x,y) ; # come @a=(x,y) @b=(1,2,3)[2,3]; # come @c=(1,2,3) @b=@c[2,3] $x=0 ; $y=1 ; @b=(1,2,3)[$x,$y] ; @z=($x,$y) ; @b=(1,2,3)[@z] ; • Interpolazione di elementi di array in variabili: @a=(1,2,3) ; $b=”bla bla $a[1] bla” ; $b=”bla bla @a bla” ; $b=”blabla @a[1,2] bla” ;

11. Operatori per array • Minimo e Massimo indice di un array : $[a $#a • push() e pop() :aggiungono e tolgono elementi dal lato destro dell’array. push(@a,$x) ; # come @a = (@a, $x) $old=pop(@a) ; push(@a,$x,$y,$z) ; • shift() e unshift() : tolgono e aggiungono elementi dal lato sinistro dell’array unshift(@a, $x) ; #come @a=($x,@a) $x=shift(@a) ; #come ($x,@a)=@a • reverse() : inverte l’ordine degli elemeti di un array • sort() : ordina un array in senso ascendente. @a=sort(@a) ; • Accesso ad un elemento: $a[$b] • chop() : se applicato ad un array, elimina l’ultimo elemento.  • Lettura da tastiera con <STDIN> @a=<STDIN> ; #legge dallo standard input ogni riga in un elemento dell’array. 

12. Il ciclo for • Sintassi:  for(condizione iniziale; condizione finale; incremento) { istruzioni; } • Esempio : stampa di un array #!/user/local/bin/perl @v = (“lun”, “mar”, “mer”, “gio”, “ven”, “sab”); for($i=0; $i<=$#v; $i++){ print “$v[$i]\n”; } • Struttura foreach $varloop: la variabile di loop e’ un riferimento ad ogni elemento dell’array. L’array puo’ essere modificato. Se non indico la variabile  variabile implicita $_ Esempio : stampa di un array #!/user/local/bin/perl @v = (“lun”, “mar”, “mer”, “gio”, “ven”, “sab”); foreach $a(@v){ print “$a\n”; }

13. Array associativi • Collezione di dati scalari, individuati dal valore delle chiavi. Coppie (chiave-dato) indirizzata per chiave %a=(“a”, dato_a, “b”, dato_b, “c”, dato_c); •  Accesso agli elementi di %a: $b=$a{$chiave}; print $a{“a”}; print $a{“b”}; •  Inizializzazione elemento per elemento: $a{“a”} = “dato_a”; $a{“b”} = “dato_b”; •  Principali operatori per gli array associativi • keys() ritorna la lista di tutte le chiavi @lista = keys(%a); # ritorna (“a”, “b”, “c”); foreach $key (keys(%a)){ print “alla chiave $key corrisponde $a{$key}” # stampa la coppia chiave/valore } •  each() ritorna la coppia (chiave, dato) while( ($x,$y) = each(%a)) { print “$x $y”; } • delete cancella un elemento dell’array associativo tramite la chiave delete $a{“a”};

14. Struttura condizionata • Struttura if-else if(condizione){ if(condizione) { primo blocco di istruzioni ; istruzioni ; }else { } elsif (condizione) { secondo blocco di istruzioni ; istruzioni ; } } elsif(condizione) { ….. } • Struttura postfissa (singola istruzione): istruzione if condizione; • Se l’espressione e’ una stringa di singoli caratteri, l’espressione e’ valutata così : se “0” => falso . Se non “0” => vero. 0, “0” falso “0” falso 1-1 falso 0 “0” falso “00” vero 1 vero “” falso • unless : realizza la parte else dell’if :  unless(condizione){ secondo blocco di istruzioni ; }

15. Struttura condizionata • Le istruzioni ritornano un valore vero se sono andati a buon fine  istruzioni come condizioni. • Struttura if(PrimaIstruzione) {SecondaIstruzione;} • Realizzazione in PERL PrimaIstruzione && SecondaIstruzione; • Struttura if( ! PrimaIstruzione) {SecondaIstruzione;} • Realizzazione in PERL PrimaIstruzione || SecondaIstruzione; • Precedenze degli operatori • Uso di ‘die’: istruzione || die “errore”

16. Strutture while/until • Sintassi while(espression){ until(espressione){ istruzioni ; istruzioni ; } } • Esempi: lettura di un file. #!/user/local/bin/perl open(f, “< nomefile”) || die “errore di apertura file”; while($r = <f>) { print $r; } close(f); • Stampa di un array. #!/user/local/bin/perl @v = (“lun”, “mar”, “mer”, “gio”, “ven”, “sab”); while(@v) { $giorno = shift @v; print “$giorno\n”; }

17. Input/Output • Lettura da <STDIN> $a = <STDIN> #legge una linea @a = <STDIN> #legge tutte le linee fino a ^d while(<STDIN>){ #legge in $_ chop; #agisce su $_ print “$_” # … elabora $_ } • Operatore diamante < > : legge una riga alla volta dai file forniti come argomenti dello script. NB: i nomi vengono prelevati dall’array @ARGV script ‘prova’ #!/usr/local/bin/perl while(<>) { print $_ }   prova file1 file2 … • Uscita su STDOUT con print. $a = print(“blabla \n ») ; #ritorna vero o falso print(“%s %d %f\n”, $a, $b, $c); #print formattato

18. Gestione dei file in PERL • Gestione dei file attraverso i file handle • Apertura di un file handle: open(nome file handle, “nome file”); • open ritorna vero o falso • per aprire in scrittura: open(OUT, “>nome file”); • aggiungere al file: open(OUT,”>>nome file”); • apertura in lettura: open(IN,”nome file”); • Spostamento del puntatore al file: seek(puntatore, posizione, partenza) • Operatore die(“…”): scrive il messaggio e poi esce dal processo unless(open(OUT,”>file”)){ die(“errore\n”); } else{ print(“ok\n”); #resto del programma; } oppure: open(OUT,”>file”) || die(“errore\n”);

19. Gestione dei file in PERL • Lettura file: open(IN, “file”); while(<IN>){ chop; print “linea letta= $_ \n”: } close(IN); • Copia file: open(IN, “file_in”); open(OUT, “>file_out”); while(<IN>){ chop; print(OUT, $_); } close(IN); close(OUT); • Test sui file: -r file leggibile -w file eseguibile -x file o directory eseguibile -o appartiene all’utente -R leggibile dall’utente reale, non effettivo -W scrivibile dall’utente reale -X eseguibile dall’utente reale -O appartiene all’utente reale -e il file esiste

20. Gestione dei file in PERL • Test sui file -z il file esiste ma ha dimensione nulla -s esiste ed ha dimensione non nulla -f file regolare -d direttorio -l link simbolico -s socket -p pipe con nome (fifo) -b file speciale a blocchi -c file speciale a caratteri -uil file o directory ha setuid settato -g bit setgid settato -k sticky bit settato -T file testo -B file binario -M tempo dall’ultima modifica in giorni -A tempo dall’ultimo accesso in giorni -C tempo dall’ultima modifica dell’inode in giorni • Operatore stat(file name) : ritorna informazioni dettagliate sui file. ($dev, $ino, $mode, $nlink, $UID, $gid, $rdev, $size, $atime, $mtime, $ctime, $blksize, $blocks) = stat(“nome”); • Per selezionare le informazioni: ($uid, $gid) = (stat(“nome”))[4,5]; • Operatore lstat(nome): ritorna informazioni dettagliate su un link simbolico (stat su un link simbolico fornisce informazioni sul file puntato)

21. Gestione delle directories • Operatore chdir: chdir(“directory”) || die • Espansione degli argomenti (globbing): lista dei file corrispondenti alla espansione di *: @a = <*>; @a = <path*>; while($b = <*>) { print “$b”; } • Operatori opendir/closedir: gestione delle directory handle: opendir(ETC,”/etc”) || die(“errore\n”); • Operatore readdir(handle) : ritorna un nome file ($a=readdir) o tutti i nomi file (@a=readdir) contenuti nella directory opendir(ETC,”/etc”) || die; #nomi in ordine alfabetico. foreach $a (sort readdir(ETC)){ print “$a\n”; } closedir(ETC);

22. Gestione file in PERL • Cancellazione: unlink(nome). Ritorna il nr di file cancellati unlink(“nomefile”); unlink(“file1”, “file2”, “file3”); unlink(<*.txt>);   foreach $a (<*.txt>) { unlink($a) || die; }   foreach (<*.txt>){ unlink || die(“errore $_ \n”); } • Operatore rename($old, $new); rinomina file. • Operatore link, symlink: introduce un link ad un file Link(“old”,”new”)||die; #hard link Symlink(“old”, “new”) || die; #link simbolico • Operatore mkdir(): crea subdirectories Mkdir(“nomedir”, 0777); • Operatore rmdir: cancella subdirectories Rmdir(“nomedir”);

23. Gestione file in PERL • Operatore chmod() modifica i permessi del file; ritorna il nr di file modificati con successo $a=chmod(0666,”nomefile”); Foreach $file (“nome1”, “nome2”){ Unless (chmod(0666, $file)) { Print “errore nella modifica dei permessi!!\n” } } • Operatore chown: modifica proprietario/gruppo chown(UID, GID, “file”); • Operatore utime(ultimo accesso, ultima modifica, files): modifica I tempi Tempi associati ad un file: data ultimo accesso, data ultima modifica, data ultima modifica dell’inode • Operatore time (ritorna il tempo corrente): $a=time - 20*60; # 20 minuti da ora utime($a, $a, “nome_file1”, “nome_file2”, …); # i file indicati sono aggiornati a 20 minuti fa

24. Gestione processi in PERL • Creazione processi con istruzioni fork/exec/wait: crea un clone del processo corrente. Fork ritorna 0 al figlio !0 al padre If(fork){ Print “sono il padre”; } else{ print “sono il figlio”; exec(“date”); } unless (fork) { exec(“date”); # sono qui perche’ fork ritorna 0 } wait; • Exi : uscita da un processo • Variabile d’ambiente: l’ambiente viene messo nell’array associativo %ENV forach $a (sort keys %ENV){ # elenca le variabili d’ambiente Print “$a = $ENV{$a}\n”; } $oldpath=$ENV(“PATH”); # modifica le variabili d’ambiente $ENV(“PATH”) = “ bla nuovo PATH bla”; … $ENV(“PATH”) = $oldpath;

25. Espressioni regolari in PERL • ER: espressione costruita secondo una sintassi che ci permette di descrivere una stringa • Pattern matching: verifica se una stringa o una sua sottostringa corrisponde ad una ER. • In PERL con variabile implicita: m/ER/ (m può essere omesso.) • Esempio: funzione grep  #!/usr/local/bin/perl while(<>){ if(/er/){ Print”$_”; } } • In PERL con variabile esplicita: operatore di match =~ Applica una espressione regolare ad una variabile che non sia $_ $a=”blablabla”; if($a =~ /^b/){ print $a #stampa $a se la stringa inizia con b } print “continuare? (S/s o N/n)” if(<STDIN> =~ /^[Ss]/) { print “hai risposto si!” } • Caratteri maiuscoli o minuscoli (ignora il case) con l’opzione i: /er/i

26. Espressioni regolari in PERL • Esempio: stampare tutte le righe di un file che contengono una stringa fornita dall’utente. #!/user/local/bin/perl print “dare il nome del file: “; $nome=<STDIN>; chop/$nome); -e $nome || die “file non esistente\n”; -T $nome || die “file non e’ di testo\n”; print “dare la stringa: “; $str = <STDIN>; chop($str); open(f, “< $nome”) || “impossibile aprire il file\n”; while ($r = <f>){ $r = ~/$str/ && print$r; } close(f):

27. Espressioni regolari in PERL • Una ER puo’ contenere variabili. Le variabili vengono espanse prima di considerare eventuali caratteri speciali. $a=”abc def ghi”; print “scrivi una parola di 3 caratteri”; $b=<STDIN>; chop($b); if($a =~ /z$b/){ print “trovato z$b in $a\n”; } else { print “non trovato\n”; } • Sostituzione in PERL: s/old-ER/new-ER/ $_=”abc def ghi”; s/abc/xyz/g; #tutte le stringhe /abc/ vengono sostituite $a=”abc def ghi”; #caso in cui ho una variabile esplicita $a =~ s/abc/xyz/g;

28. Espressioni regolari in PERL • Operatore split(espressione regolare , stringa) : ritorna un vettore formato dalle parti della stringa che NON corrispondono alla ER $a=”a:b:c:d”; @b=split(/:/, $a);# @b contiene (a, b, c ,d) @b=split(/er/);# in questo caso la stringa e’ $_ • Operatore join($glue, @lista): riunisce gli elementi della lista attraverso $glue in una stringa $a = join(“:”, @b); #ricostruisce la stringa precedente

29. Funzioni in PERL • Il programmatore puo’ definire delle subroutine nella forma sub nome{ #i parametri passati si trovano in @_, quindi $_[0], $_[1] … istruzioni; return (valore); } • Chiamata della subroutine: &nome • Visibilità: • Le variabili locali definite con local(lista_variabili)  le variabili sono visibili nella subroutine e nelle subroutine chiamate • Le variabili definite con my(lista variabili) sono visibili solo dove sono dichiarate. • Le funzioni sono ricorsive: #!/user/local/bin/perl #script fattoriale.pl Sub fattoriale{ local($n) = shift(@_); ($n==1) && return (1); return($n * &fattoriale($n-1); } $n=<STDIN>; $r=&fattoriale($n); Print “fattoriale di $n = $r\n”;

30. Funzioni in PERL • Uno script PERL può richiamare programmi esterni o comandi Unix. • Mediante apici inversi @r=`cat $file | grep $s | sort` • Mediante system o exec system()  lo script aspetta la terminazione del programma esterno system(“comando di shell”) && die; system(“comando1; comando2 > filek&”) && die; system(“comando > file”) && die; exec()  lo script termina e continua il programma esterno • Mediante apertura di canali di pipe: open(OUT, “| more”) || die “errore\n”; foreach $r(@array) { print OUT $r; } close(OUT); …… open(HANDLE, “who|”); #lettura @a = <HANDLE>; close(HANDLE);  ........ open(HANDLE, “|cat”); #scrittura print(HANDLE,”stringa da stampare con cat”); close(HANDLE);

31. Funzioni in PERL • Attenzione: oltre a return, esiste un altro metodo di passaggio parametri: il/i valori di ritorno sono gli ultimi valutati! • Lista di tutti gli elementi maggiori di A: sub somma{ local($n,@a); ($n,@a) = @_; local(@b); for($i=1;$i<$n; $i++){ if($a[$i]> A) push(@b, $a[$i]); } @b; } @a=&somma(100,@lista); • Lista di tutti gli elementi maggiori di A: sub somma{ local($n,@a); ($n,@a) = @_; local(@b); foreach $_ (@a){ if($_ > A) push(@b, $_); } @b; } @a=&somma(100,@lista);

32. Seconda parte.Esempi di programmazione

33. #!/usr/local/bin/perl # # legge dallo standard input delle parole e conta le occorrenze @words = <STDIN>; # leggi le parole dallo standard in foreach $word (@words) { chop($word); # rimuove il newline $count{$word}++ ; } foreach $word (keys %count) { print "$word appare $count{$word} volte\n"; }

34. #!/usr/local/bin/perl # conta le occorrenze dallo standard in while(<STDIN>){ chop; $a{$_}++; } foreach $b (keys(%a)){ print "La parola $b appare $a{$b} volte\n"}; #!/usr/local/bin/perl # legge parole da file while(<>){ chop; $a{$_}++; } foreach $b (keys(%a)){ print "La parola $b \t appare $a{$b}\t volte\n"}; #!/usr/local/bin/perl #Legge una lista di stringhe e le stampa con formato desiderato print "Field width: "; chop($width = <STDIN>); print "List of strings:\n"; chop(@strings = <STDIN>); foreach (@strings) { printf "%${width}s\n", $_; }

35. #!/usr/local/bin/perl # while (<STDIN>) { ($user, $pass, $uid, $gid, $gcos) = split(/:/); ($real) = split(/,/, $gcos); ($first) = split(/\s+/, $real); $seen{$first}++; } foreach (keys %seen) { if ($seen{$_} > 1) { print "$_ visto $seen{$_} volte\n"; } }

36. #!/usr/local/bin/perl # questo script sostituisce stringhe in un file # print "Input file name: "; chop($infilename = <STDIN>); print "Output file name: "; chop($outfilename = <STDIN>); print “Stringa da cercare: "; chop($search = <STDIN>); print “Stringa da rimpiazzare: "; chop($replace = <STDIN>); open(IN,$infilename) || die “non posso aprire $infilename in lettura"; ## test opzionale per sovrascrivere... die “non sovrascrivo $outfilename" if -e $outfilename; open(OUT,">$outfilename") || die “non posso creare $outfilename"; while (<IN>) { # leggi una linea dal file $a in $_ s/$search/$replace/g; # cambia le linee print OUT $_; # scrivi quella linea nel file $b } close(IN); close(OUT);

37. #!/usr/local/bin/perl # while (<>) { chop; ($age) = (stat("$_"))[8]; # $age= -M; # l'operatore -M ritorna la data dell'ultima modifica print "file $_ age $age\n"; if ($newest_age < $age) { $newest_name = $_; $newest_age = $age; } } print “Il file piu’ recente e’$newest_name ", “e ha $newest_age giorni.\n";

38. #!/usr/local/bin/perl # print “quale directory? "; chop($newdir = <STDIN>); chdir($newdir) || die “Non posso spostarmi in $newdir"; opendir(DOT,".") || die “non posso aprire la directory"; foreach (sort readdir(DOT)) { print "$_\n"; } closedir(DOT); #!/usr/local/bin/perl @a = <*>; foreach $nomefile(sort(@a)){ print "$nomefile\n"; }

39. #!/usr/local/bin/perl # open(PW,"/etc/passwd"); while (<PW>) { chop; ($user,$pw,$uid,$gid,$gcos) = split(/:/); ($real) = split(/,/, $gcos); $real{$user} = $real; } close(PW); open(WHO,"who|") || die “non posso aprire la pipe"; while (<WHO>) { ($login, $rest) = /^(\S+)\s+(.*)/; $login = $real{$login} if $real{$login}; printf "%-30s %s\n",$login,$rest; }

40. #!/usr/local/bin/perl &init; print “Nome utente? "; $name = <STDIN>; chop($name); print "Password? "; $pass = <STDIN>; chop($pass); while ($pass ne $words{$name}) { print "password errata! riprova: "; $pass=<STDIN>; chop($pass); } print "ok\n"; exit; sub init{ open(WORDLIST, "wordlist"); while($name=<WORDLIST>){ chop($name); $word= <WORDLIST>; chop($word); $words{$name} = $word; } close(WORDLIST); }

41. #!/usr/local/bin/perl sub test { if ($#ARGV<0) { print "Specifica il file... \n"; exit; } } &test; print "N. parametri: ", $#ARGV+1," Pid:$$ \n"; $i=1; foreach $a (@ARGV) { print "parametro n. $i:$a \n"; $i++; } open (IN,"$ARGV[0]"); print "Contenuto del file:\n"; while ($a=<IN>) { print $a; }; close (IN);

42. #!/usr/local/bin/perl sub test { if ($#ARGV<0) { print "Manca il nome del file. \n"; exit; } } &test; print "N. parametri: ",$#ARGV+1," Pid:$$ \n"; for ($i=0;$i<=$#ARGV;$i++) { print "parametro n. ",$i+1,": $ARGV[$i] \n"; } open (IN,"$ARGV[0]"); print "Contenuto del file:\n"; while (@a=<IN>) { foreach $b(@a) { print $b; } }; close (IN);

43. #!/usr/local/bin/perl sub test { if ($#ARGV<0) { print "Inserisci il nome del file... \n"; exit; } } &test; open (IN,"$ARGV[0]"); while ($a=<IN>) { chop($a); @b=split(/,?\s+/,$a); foreach $c (@b) { $occor{$c}++; }; }; close (IN); foreach $a (keys (%occor)) { print "Parola [$a] -> occorrenze: $occor{$a}\n"; };

44. #!/usr/local/bin/perl sub test { if ($#ARGV<0) { print "Inserire il nome del file. \n"; exit; } } &test; while (<>) { chop; @b=split(/,?\s+/); foreach $c (@b) { $occor{$c}++; }; }; foreach $a (keys (%occor)) { print "Parola [$a] -> occorrenze: $occor{$a}\n"; };

45. #!/usr/local/bin/perl sub test { if ($#ARGV<0) { print "Inserire il nome del file... \n"; exit; } } &test; open (IN,"$ARGV[0]"); while (@a=<IN>) { foreach $b (@a) { chop($b); @c=split(/,?\s+/,$b); foreach $d (@c) { $occor{$d}++; }; }; }; close (IN); foreach $a (keys (%occor)) { print "Parola [$a] -> occorrenze: $occor{$a}\n"; };

46. #!/usr/local/bin/perl sub test{ if($#ARGV<2){ print"Errore! \n"; print"Sintassi : perlex3 file vecchia_stringa nuova_stringa\n"; exit; } } &test; unless(open(FILE,"$ARGV[0]")){ print"errore nell'apertura del file\n"; exit; } @testo=<FILE>; close(FILE); $i=0; @temp; foreach $riga(@testo){ $riga =~ s/$ARGV[1]/$ARGV[2]/g; $temp[$i]=$riga; $i++; } print "Risultato:\n"; print @temp; print "\n";

47. #!/usr/local/bin/perl print "Nome file di input: "; $file = <STDIN>; chop($file); -e $file || die "Il file non esiste!\n\n"; -T $file || die "Il file non e' un file di testo!\n\n"; print "Stringa da cercare: "; $stringa = <STDIN>; chop($stringa); print "Stringa da sostituire: "; $sost = <STDIN>; chop($sost); open (IN, "< $file") || die "Impossibile aprire $file.\n\n"; $i=0; @temp; while ($r = <IN>) { $r =~ s/$stringa/$sost/g; $temp[$i]=$r; $i++; } close(IN); print "Risultato: \n"; print "@temp";

48. #!/usr/local/bin/perl sub test{ if($#ARGV<1){ print"Mancano parametri\n"; exit; } } &test; unless(open(FILE,"$ARGV[0]")){ print"Errore in apertura di $ARGV[0]\n"; exit; } @testo=<FILE>; close(FILE); $i=0; foreach $riga(@testo){ chop($riga); @campo=split(/\s+/,$riga); if($campo[0]=~/$ARGV[1]/) { $i++ }; } print "Righe di $ARGV[0] contenenti nel primo campo $ARGV[1] : $i\n";

49. #!/usr/local/bin/perl sub load { open (F,"PASS"); while (<F>) { chop; @a = split(/\s/); $PASS{$a[1]} = $a[0]; } } &load; print "username: "; $user = <STDIN>; chop ($user); print "chiave: "; $chiave = <STDIN>; chop ($chiave); # cancello eco????????????? if ($PASS{$chiave} eq $user) { print "\nChiave esatta!"; print "\nOra puoi accedere alle risorse protette!\n"; } else {print "\nSpiacente: non puoi entrare!\n"};

50. #!/usr/local/bin/perl @d = <*>; foreach $nomefile(@d){ $size = (stat($nomefile))[7]; $dim{$size} = $nomefile; #print "$nomefile -> $size\n"; } @s = sort(keys(%dim)); $numtot = @s; $medium=int(${numtot}/2); $medio = @s[$medium]; $grande = pop(@s); $piccolo = shift(@s); print "\nIl file piu' grande e': $dim{$grande} ($grande bytes)"; print "\nIl file piu' piccolo e': $dim{$piccolo} ($piccolo bytes)"; print "\nIl file medio e': $dim{$medio} ($medio bytes)\n";