Introduzione a PERL E.Mumolo Prima parte. Introduzione al linguaggio Practical Extraction and Report Language or Pathological Eclectic.

Presentazione sul tema: "Introduzione a PERL E.Mumolo Prima parte. Introduzione al linguaggio Practical Extraction and Report Language or Pathological Eclectic."— Transcript della presentazione:

1 Introduzione a PERL E.Mumolo mumolo@units.it

2 Prima parte. Introduzione al linguaggio Practical Extraction and Report Language or Pathological Eclectic Rubbish Lister ?

3 Introduzione a PERL Nato per assistere lutente 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= ; 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, descrittori di standard input, output Redirezione: prompt> primo.pl 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 linizializzazione. 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 valoreottale07 \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. ax3 = aaa $a x $b) –sottostringasubstr($a,$n,%m)a partire da n per m caratteri –Indiceindex($a,$b)posizione del primo carattere di $b Casting delle variabili a seconda delloperatore Esempio: F. ( 43 + 6) = F49Y. (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 lultimo carattere dellargomento. Ritorna il carattere eliminatoEs.chop($a= ) ; 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 dellutente che esegue il programma $> UID effettivo dellutente $? stato dellultima chiamata $_ argomento predefinito $0 nome del programma $ separatore di lista $/ separatore di righe per linput

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 nellarray. ($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 larray

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; Larray 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 dellarray. 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 dellarray unshift(@a, $x) ;#come @a=($x,@a) $x=shift(@a) ;#come ($x,@a)=@a reverse() :inverte lordine degli elemeti di un array sort() :ordina un array in senso ascendente. @a=sort(@a) ; chop() :se applicato ad un array, elimina lultimo elemento. Lettura da tastiera con @a= ;#legge dallo standard input ogni riga in un elemento dellarray. #Termina allEOF (ctrl-D)

12 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; } – deletecancella un elemento dellarray associativo tramite la chiave delete $a(a);

13 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 lespressione e una stringa di singoli caratteri, lespressione e valutata così : se 0 => falso. Se non 0 =>vero. 0, 0 falso 0falso 1-100 falso 00vero falso unless : realizza la parte else dellif : unless(condizione){ secondo blocco di istruzioni ; }

14 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

15 Strutture while/until Sintassi while(espression){until(espressione){istruzioni ;} Esempi: lettura di un file. #!/user/local/bin/perl open(f, < nomefile) || die errore di apertura file; while($r = ) { 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; }

16 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 dellarray. Larray 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; }

17 Input/Output Lettura da $a = #legge una linea @a = #legge tutte le linee fino a ^d while( ){#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 dallarray @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( ){ chop; print linea letta= $_ \n: } close(IN); Copia file: open(IN, file_in); open(OUT, >file_out); while( ){ chop; print(OUT, $_); } close(IN); close(OUT); Test sui file: -rfile leggibile-wfile eseguibile -xfile o directory eseguibile-oappartiene allutente -Rleggibile dallutente reale, non effettivo-Wscrivibile dallutente reale -Xeseguibile dallutente reale-Oappartiene allutente reale -eil file esiste

20 Gestione dei file in PERL Test sui file -zil file esiste ma ha dimensione nulla-s esiste ed ha dimensione non nulla -ffile regolare-d direttorio -llink simbolico-s socket -ppipe con nome (fifo)-b file speciale a blocchi -cfile speciale a caratteri-uil file o directory ha setuid settato -gbit setgid settato-k sticky bit settato -t-T file testo -Bfile binario-M tempo dallultima modifica in giorni -Atempo dallultimo accesso in giorni -C tempo dallultima modifica dellinode in giorni Operatore stat(file handle) :ritorna informazioni dettagliate sui file. ($dev, $ino, $mode, $nlink, $UID, $gid, $rdev, $size, $atime, $mtime, $ctime, $blksize, $blocks) = stat(handle); Per selezionare le informazioni:($uid, $gid) = (stat(handle))[4,5]; Operatore lstat(handle):ritorna informazioni dettagliate su un link simbolico

21 Gestione delle directories Operatore chdir: chdir(directory) || die Espansione degli argomenti (globbing): lista dei file corrispondenti alla espansione di *: @a = ; 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( ); foreach $a ( ) { unlink($a) || die; } foreach ( ){ 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 dellinode 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 dambiente: lambiente viene messo nellarray associativo %ENV for $a (sort keys %ENV){# elenca le variabili dambiente Print $a = $ENV{$a}\n; } $oldpath=$ENV(PATH); # modifica le variabili dambiente $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( =~ /^[Ss]/) { print hai risposto si! } Caratteri maiuscoli o minuscoli (ignora il case) con lopzione i: /er/i

26 Espressioni regolari in PERL Esempio: stampare tutte le righe di un file che contengono una stringa fornita dallutente. #!/user/local/bin/perl print dare il nome del file: ; $nome= ; chop/$nome); -e $nome || die file non esistente\n; -T $nome || die file non e di testo\n; print dare la stringa: ; $str = ; chop($str); open(f, < $nome) || impossibile aprire il file\n; while ($r = ){ $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= ; 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 @_ istruzioni; return (valore); } Chiamata della subroutine:&nome Le variabili locali definite con local(lista_variabili) 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= ; $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 = ;close(HANDLE);........ open(HANDLE, |cat);#scrittura print(HANDLE,stringa da stampare con cat);close(HANDLE);

31 Funzioni in PERL 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 = ; # 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( ){ 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 = ); print "List of strings:\n"; chop(@strings = ); foreach (@strings) { printf "%${width}s\n", $_; }

35 #!/usr/local/bin/perl # while ( ) { ($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 = ); print "Output file name: "; chop($outfilename = ); print Stringa da cercare: "; chop($search = ); print Stringa da rimpiazzare: "; chop($replace = ); 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 ( ) { # 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 = ); 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 ( ) { 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 ( ) { ($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 = ; chop($name); print "Password? "; $pass = ; chop($pass); while ($pass ne $words{$name}) { print "password errata! riprova: "; $pass= ; chop($pass); } print "ok\n"; exit; sub init{ open(WORDLIST, "wordlist"); while($name= ){ chop($name); $word= ; 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= ) { 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= ) { 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= ) { 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= ) { 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= ; 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 = ; 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 = ; chop($stringa); print "Stringa da sostituire: "; $sost = ; chop($sost); open (IN, "< $file") || die "Impossibile aprire $file.\n\n"; $i=0; @temp; while ($r = ) { $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= ; 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 ( ) { chop; @a = split(/\s/); $PASS{$a[1]} = $a[0]; } &load; print "username: "; $user = ; chop ($user); print "chiave: "; $chiave = ; 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";

51 #!/usr/local/bin/perl @d = ; print "\n # = 100 bytes\n"; foreach $nomefile(@d){ @a = stat ($nomefile); $size = $a[7]; $quad = $size/100; printf("%-15s %+10s ", $nomefile, $size); for($i=0;$i<$quad;$i++) { printf( "#"); } printf("\n"); }

52 #!/usr/bin/perl #argomento: nomefile -opzione sub test{ if ($#ARGV < 1) {print "errore\n"; exit 1;} } &test; foreach $a(@ARGV){print "parametri: $a\n";} print "Il PID del processo e' $$\n"; open(FILE, "$ARGV[0]"); while ($a= ) { chop ($a) ; print "$a\n"; } close(FILE);

53 #!/usr/bin/perl # argomento: nomefile -opzione sub test{ if ($#ARGV < 1) {print "errore\n"; exit 1;} } &test; for ($i=0;$i<=$#ARGV;$i++){print "parametri: $ARGV[$i]\n";} print "Il PID del processo e' $$\n"; open(FILE, "$ARGV[0]"); while ($a= ) { chop ($a) ; print "$a\n"; } close(FILE);

54 #!/usr/bin/perl # argomento: nomefile -opzione sub test{ if ($#ARGV < 1) {print "errore\n"; exit 1;} } &test; foreach $a(@ARGV){print "parametri: $a\n";} print "Il PID del processo e' $$\n"; open(FILE, "$ARGV[0]"); @a= ; foreach $b(@a) { chop ($b) ; print "$b\n"; } close(FILE);

55 #!/usr/bin/perl #argomento: nomefile sub test{ if ($#ARGV !=0) { print "errore\n"; exit 1;} } &test; print "Nome File: $ARGV[0]\n"; open(FILE, "$ARGV[0]"); while ($a= ) { chop ($a) ; @b=split(/,?\s+/,$a); foreach $c(@b){ $occor{$c}++; } foreach $c(keys %occor){ print "$c $occor{$c}\n"; } close(FILE);

56 #!/usr/bin/perl # argomento: nomefile sub test{ if ($#ARGV !=0) {print "errore\n"; exit 1;} } &test; print "Nome File: $ARGV[0]\n"; open("$ARGV[0]"); while (<>) { chop ; @b=split(/,?\s+/); foreach $c(@b){ $occor{$c}++; } } foreach $c(keys %occor){ print "$c $occor{$c}\n"; } close(FILE);

57 #!/usr/bin/perl # argomento: nomefile sub test{ if ($#ARGV !=0) {print "errore\n"; exit 1;} } &test; print "Nome File: $ARGV[0]\n"; open(FILE, "$ARGV[0]"); @a= ; foreach $d(@a){ chop ($d) ; @b=split(/,?\s+/,$d); foreach $c(@b){ $occor{$c}++; } foreach $c(keys %occor){ print "$c $occor{$c}\n"; } close(FILE);

58 #!/usr/bin/perl #argomento: nomefile "er_old" "er_new" sub test{ if ($#ARGV <2) {print "errore\n"; exit 1;} } &test; print "Nome File: $ARGV[0]\n"; open(IN,"$ARGV[0]"); open(OUT, ">$ARGV[0]new"); while ( ) { s/$er_old/$er_new/g; print OUT $_; } close(IN); close(OUT);

59 #!/usr/bin/perl # print "Nome File Input:\n"; chop ($infile= ); print "Nome file Output:\n"; chop ($outfile= ); print "Espressione Regolare da sostituire:\n"; chop ($er_old= ); print "Espressione Regolare sostituta:\n"; chop ($er_new= ); open (IN, $infile) || die "Non posso aprire il File $infile\n"; open (OUT, ">$outfile") || die "Non posso creare il File $outfile\n"; while ( ){ s/$er_old/$er_new/g; print OUT $_; } close(IN); close(OUT);

60 #!/usr/bin/perl #argomenti: nomefile "separatore_campi" "primo_campo" sub test{ if ($#ARGV < 2) {print "errore\n"; exit 1;} } &test; print "nome file: $ARGV[0]\n"; print "numero di righe in cui il primo campo è $ARGV[2] :\n"; open (FILE, $ARGV[0]) || die "Non posso aprire il file\n"; $i=0; while ( ){ chop; @b=split(/$ARGV[1]/); if ($b[0] eq $ARGV[2]){ $i=$i+1} } print "$i\n";

61 #!/usr/bin/perl # open (F, "passwd"); while ($l= ) { chop($l); @a=split(/\s+/,"$l"); $pass{$a[1]}=$a[0]; } print "User Name:\n"; chop($user= ); print "Password:\n"; chop($p= ); if ($pass{$p} eq $user) { print "Utente autorizzato\n"; #lista istruzioni } else { print "Utente non autorizzato\n"; }

62 #!/usr/bin/perl # #elenca in ordine alfabetico i file regolari contenuti nella directory @a= ; @a=sort(@a); foreach $b(@a){ if ( -f "$b"){ print "$b\n"} }

63 #!/usr/local/bin/perl $i=0; while ($b= ){ if ( -f "$b" ){ @a=stat($b); $elenco{$b}=$a[7]; $dim[$i]=$a[7]; $i++; } @dim=sort {$a $b} @dim; $m=($#dim/2); foreach $b(keys(%elenco)){ if($elenco{$b}==$dim[-1]) {push(@max,$b)} if($elenco{$b}==$dim[0]) {push(@min,$b)} if($elenco{$b}==$dim[$m]) {push(@med,$b)} } if ($#max==0) { print "Il File piu'grande e': $max[0] $dim[-1] bytes\n"} else { print "I Files piu' grandi sono :\n"; foreach $b(@max){ print "$b $dim[-1] bytes\n"} } if ($#med==0) { print "Il File mediano e': $med[0] $dim[$m] bytes\n"} else{ print "I Files mediani sono :\n"; foreach $b(@med){ print "$b $dim[$m] bytes\n"} } if ($#min==0){print "Il File piu' piccolo e': $min[0] $dim[0] bytes\n"} else{ print "I Files piu' piccoli sono :\n"; foreach $b(@min){ print "$b $dim[0] bytes\n"} }

64 #!/usr/bin/perl #visualizza un istogramma delle dimensioni dei file regolari $i=0; $max=0; while ($b= ) { if ( -f "$b"){ @a=stat($b); $size=$a[7]; $nomi[$i]=$b; $dim[$i]=$size; $i=$i+1; if($size>$max){ $max=$size } } $scala=($max/60); print "ISTOGRAMMA DIMENSIONE FILES\n"; print "Ogni \"o\" corrisponde a $scala bytes\n"; $i=0; foreach $n(@nomi){ $simboli[$i]=("o"x($dim[$i]/$scala)); $spazio="-"x(15-length($n)); print "$n $spazio |$simboli[$i]\n"; $i=$i+1; }