Introduzione a PERL E.Mumolo

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

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

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 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

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

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. ( ) = F49Y. (4*5) = Y20

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 ;

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

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 ;# array di un solo elemento due, tre) ; 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 = ($a, $b, $c) ;#risultato : $c) ($e, ;#risultato : Assegnazione scalare=array : la var scalare contiene il numero di ; ;#risultato : la var b contiene 3 ($b) ;# la var b contiene il primo elemento Accedere ad un elemento non definito ritorna undef ; assegnare un elemento non definito estende larray

Accesso agli elementi di un array Array argomenti dello script PERL Gli elementi di un array sono indicizzati da 2, 3) ; $b=$a[0] ;# $b contiene 1 $a[0]=4 = (4,2,3) $a[1]++;$a[2] += 4; Larray puo essere raggruppato in parti: ;# equivale $a[1]) $x=0 ; $y=1 ; Interpolazione di elementi di array in ; $b=bla bla $a[1] bla ; $b=bla bla ; bla ;

Operatori per array Minimo e Massimo indice di un array :$[a$#a push() e pop():aggiungono e tolgono elementi dal lato destro dellarray. ;# = $x) ; ; shift() e unshift() : tolgono e aggiungono elementi dal lato sinistro dellarray $x) ;#come ;#come reverse() :inverte lordine degli elemeti di un array sort() :ordina un array in senso ascendente. ; chop() :se applicato ad un array, elimina lultimo elemento. Lettura da tastiera ;#legge dallo standard input ogni riga in un elemento dellarray. #Termina allEOF (ctrl-D)

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 = 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);

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 falso 00vero falso unless : realizza la parte else dellif : unless(condizione){ secondo blocco di istruzioni ; }

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

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. = (lun, mar, mer, gio, ven, sab); { $giorno = print $giorno\n; }

Il ciclo for Sintassi: for(condizione iniziale; condizione finale; incremento) { istruzioni; } Esempio : stampa di un array = (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 = (lun, mar, mer, gio, ven, sab); foreach print $a\n; }

Input/Output Lettura da $a = #legge una = #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 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

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);

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

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

Gestione delle directories Operatore chdir: chdir(directory) || die Espansione degli argomenti (globbing): lista dei file corrispondenti alla espansione di = ; 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 contenuti nella directory opendir(ETC,/etc) || die;#nomi in ordine alfabetico. foreach $a (sort readdir(ETC)){ print $a\n; } closedir(ETC);

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);

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

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;

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

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):

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;

Espressioni regolari in PERL Operatore split(espressione regolare, stringa) : ritorna un vettore formato dalle parti della stringa che NON corrispondono alla ER contiene (a, b, in questo caso la stringa e $_ Operatore riunisce gli elementi della lista attraverso $glue in una stringa $a = la stringa precedente

Funzioni in PERL Il programmatore puo definire delle subroutine nella forma sub nome{#i parametri passati si trovano 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) = (&n==1) && return (1); return($n * &fattoriale($n-1); } $n= ; $r=fattoriale($n); Print fattoriale di $n = $r\n;

Funzioni in PERL Uno script PERL può richiamare programmi esterni o comandi Unix. –Mediante apici $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 { print OUT $r; } close(OUT); ……. Open(HANDLE, = ;close(HANDLE); open(HANDLE, |cat);#scrittura print(HANDLE,stringa da stampare con cat);close(HANDLE);

Funzioni in PERL Lista di tutti gli elementi maggiori di A: sub somma{ for($i=1;$i<$n; $i++){ if($a[$i]> A) $a[$i]); } Lista di tutti gli elementi maggiori di A: sub somma{ foreach $_ if($_ > A) $_); }

Seconda parte. Esempi di programmazione

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

#!/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"; = ); foreach { printf "%${width}s\n", $_; }

#!/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"; }

#!/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);

#!/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";

#!/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); = ; foreach print "$nomefile\n"; }

#!/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; }

#!/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); }

#!/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 { print "parametro n. $i:$a \n"; $i++; } open (IN,"$ARGV[0]"); print "Contenuto del file:\n"; while ($a= ) { print $a; }; close (IN);

#!/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 ) { foreach { print $b; } }; close (IN);

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

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

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

#!/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; ; close(FILE); foreach $riga =~ s/$ARGV[1]/$ARGV[2]/g; $temp[$i]=$riga; $i++; } print "Risultato:\n"; print "\n";

#!/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"; while ($r = ) { $r =~ s/$stringa/$sost/g; $temp[$i]=$r; $i++; } close(IN); print "Risultato: \n"; print

#!/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; ; close(FILE); $i=0; foreach if($campo[0]=~/$ARGV[1]/) { $i++ }; } print "Righe di $ARGV[0] contenenti nel primo campo $ARGV[1] : $i\n";

#!/usr/local/bin/perl sub load { open (F,"PASS"); while ( ) { = 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"};

= ; foreach $size = (stat($nomefile))[7]; $dim{$size} = $nomefile; #print "$nomefile -> $size\n"; = sort(keys(%dim)); $numtot $medium=int(${numtot}/2); $medio $grande = $piccolo = 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";

= ; print "\n # = 100 bytes\n"; = stat ($nomefile); $size = $a[7]; $quad = $size/100; printf("%-15s %+10s ", $nomefile, $size); for($i=0;$i<$quad;$i++) { printf( "#"); } printf("\n"); }

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

#!/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);

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

#!/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) foreach $occor{$c}++; } foreach $c(keys %occor){ print "$c $occor{$c}\n"; } close(FILE);

#!/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 foreach $occor{$c}++; } } foreach $c(keys %occor){ print "$c $occor{$c}\n"; } close(FILE);

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

#!/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);

#!/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);

#!/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 ( ){ if ($b[0] eq $ARGV[2]){ $i=$i+1} } print "$i\n";

#!/usr/bin/perl # open (F, "passwd"); while ($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"; }

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

#!/usr/local/bin/perl $i=0; while ($b= ){ if ( -f "$b" $elenco{$b}=$a[7]; $dim[$i]=$a[7]; $i++; {$a $m=($#dim/2); foreach $b(keys(%elenco)){ if($elenco{$b}==$dim[-1]) if($elenco{$b}==$dim[0]) if($elenco{$b}==$dim[$m]) } if ($#max==0) { print "Il File piu'grande e': $max[0] $dim[-1] bytes\n"} else { print "I Files piu' grandi sono :\n"; foreach 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 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 print "$b $dim[0] bytes\n"} }

#!/usr/bin/perl #visualizza un istogramma delle dimensioni dei file regolari $i=0; $max=0; while ($b= ) { if ( -f $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 $simboli[$i]=("o"x($dim[$i]/$scala)); $spazio="-"x(15-length($n)); print "$n $spazio |$simboli[$i]\n"; $i=$i+1; }