esempi

1. I/O: <STDIN>, <STDOUT>, hex, die, incremento
2. countdown: while, sleep, contatori
3. parametri formali: foreach
4. cat
5. grep
6. find
7. dir
8. count
9. type
10. formattazione di un testo
11. scrittura delle parole
12. operazioni sulle stringhe
13. estrazione parametri a chiave
14. estrazione parametri formali

• indice

print "programma p01: "; 
print "I/O, conversione da esadecimale, incremento\n\n";
#
print "Introduci un numero esadecimale: ";      
$esadec=<STDIN>                                  
print "valore decimale: ",hex($esadec),"\n";                        
$dec=hex($esadec);
print "incremento di 1: ",$dec + 1,"\n";
die "fine";

print "programma p02:\ncoutdown: esempio di while\n";
#
$countdown=10;
while ($countdown !=0) {
        print "$countdown...";
        sleep 1;
        --$countdown;
}
print "BOOM!\n";
die;

print "programma p03:\nparametri formali <ARGV>\n\n";
#
print '@ARGV:        ',"@ARGV\n";
print '$#ARGV:       ',$#ARGV,"\n";
$npar=$#ARGV+1;
print "n. parametri: $npar\n\n";
#
if ($#ARGV < 0) {
die "fine per mancanza di parametri";
}

foreach $i (0 .. $#ARGV) {
        print '$ARGV[',"$i]: $ARGV[$i]\n";
}

print "programma p04cat:\nun esempio di cat utilizzando <ARGV>\n\n";
# controllo parametri
if ($#ARGV < 0) {
print "Uso: perl p04cat nomefile\n";
die "fine per mancanza di parametri";
}
#
while ($_ = <ARGV>) {
        print $_;
}
#
# si puo' abbreviare in:
#
# while (<>) {
#        print;
# }

print "programma p05grep:\nun esempio di grep utilizzando <ARGV>\n\n";
# controllo parametri
if ($#ARGV < 0) {
print "Uso: perl p05grep pattern (tra doppi apici) nomefile\n";
die "fine per mancanza di parametri";
}
#
$pattern=shift(@ARGV);
while (<>) {
        if (/$pattern/) {
        print;
        }
}

print "programma p06find:\nun esempio di find\n";
print "elenca i files presenti nella directory che contengono una parola\n\n";
# controllo parametri
if ($#ARGV < 0) {
print "Uso: perl p05find parola\n";
die "fine per mancanza di parametri";
}
#
print "files che contengono: @ARGV\n\n";
#
open(FIND,"dir /B |") || die "Non riesco a usare dir";
FILE:
while ($filename = <FIND>) {
#        print "---$filename";
        chop $filename;
        next FILE unless -T $filename;
        if (!open(TEXTFILE,$filename)) {
                print STDERR "Non riesco ad aprire $filename --- continuo\n";
                next FILE;
        }
        while (<TEXTFILE>) {
                foreach $word (@ARGV) {
                        if (index($_,$word) >= 0) {
                                print $filename, "\n";
                                next FILE;
                        }
                }
        }
}

print "programma p07dir:\ndir su una riga con sort\nuso di liste\n\n";
#
if ($#ARGV < 0) {
print "Uso: perl p07dir *\n";
die "fine per mancanza di parametri";
}
#
while (@ARGV) {
        $file = shift @ARGV;
        push(@textfiles, $file) if -T $file;
}
@riga=join(' ',@textfiles);
print sort @riga;

print "programma p08count:\nconta le parole di un file\n\n";
#
if ($#ARGV < 0) {
print "Uso: perl p08count file\n";
die "fine per mancanza di parametri";
}
#
print "file: @ARGV\n";
#
# abilita il modo paragrafo e il pattern multiline.
$/ = "";
$* = 1;
#legge i paragrafi, li splitta in parole e le conta nella matrice associativa.
while (<>) {
        s/-\n//g;
        tr/A-Z/a-z/;
# splitta in parole cercando almeno uno spazio (\s+) 
# circondato da zero o + caratteri NON-parola (\W*)
# per non spezzare Job's mentre elimina le virgolette
#
# spesso puo' bastare cercare uno o + spazi: split(/\s+/,$_)
#
        @words = split(/\W*\s+\W*/, $_);
        foreach $word (@words) {
                $wordcount{$word}++;
        }
}
#
# stampa tutta la matrice per prova.
# print "array: ",%wordcount,"\n";

# sort per chiave
print "sort per chiave:\n";
foreach $word (sort keys(%wordcount)) {
        printf "%20s %d\n", $word, $wordcount{$word};
}
# preparazione file per sort per frequenza
# print "preparazione file per sort per frequenza:\n";
# foreach $word (sort keys(%wordcount)) {
#         printf "%10d %s\n",  $wordcount{$word}, $word;
# }

print "\nProva lettura random - \n";
print "dammi una parola e termina con  e : ";
# $word = <STDIN>;
# $ww=substr($word,0,3);
chop($ww = <STDIN>);
print 'parola: ',$ww,"\n";
print '@wordcount: ',@wordcount{$ww},"\n";
print '$wordcount: ',$wordcount{$ww},"\n";

print "programma p09: type (lettura per riga)\n";
print "viene richiesto il file, se non indicato\n\n";
#
$file=$ARGV[0];
if ($#ARGV < 0) {
print "Nome del file: ";
$file=<STDIN>;
}

print "File: ",$file, "\n";
open (FILE,$file) || die "Non posso aprire $file $!";
while (<FILE>) {
print;
}

print "programma p10:\nformattazione di testo\n\n";
#
# configurazione.
$ANNUAL_PAY_RATE=52*5;  # 5 per settimana.
#
# apertura db.
open(STUFF,"animals") || die "Non posso aprire il file: $!\n";
while (<STUFF>) {
        ($nome, $n, $colore, $premium, $resto) = split(/:/,$_);
        $tot=$premium*$n;
        $cost=$tot+$resto*$ANNUAL_PAY_RATE;
        write;
}
exit;
format top =
----------------------------------------------------------------------
bestia          capi colore          tot   costo 
----------------------------------------------------------------------
.
format STDOUT =
@<<<<<<<<< @######## @>>>>>>>>> @####### @###### 
$nome, $n, $colore, $tot, $cost
.

sheep:14023:bianco:0.29:256
camels:5972:beige:3.79:1279
oxen:2016:verde:4.95:1008

print "programma p11write:\nscrive le parole\n\n";
# versione per sort sulla frequenza.
#
if ($#ARGV < 0) {
print "Uso: perl write file\n";
die "fine per mancanza di parametri";
}
#
# abilita il modo paragrafo e il pattern multiline.
$/ = "";
$* = 1;
#legge i paragrafi, li splitta in parole e le conta nella matrice associativa.
while (<>) {
        s/-\n//g;
        tr/A-Z/a-z/;
# splitta in parole cercando almeno uno spazio (\s+) 
# circondato da zero o + caratteri NON-parola (\W*)
# per non spezzare Job's mentre elimina le virgolette
#
# spesso puo' bastare cercare uno o + spazi: split(/\s+/,$_)
#
        @words = split(/\W*\s+\W*/, $_);
        foreach $word (@words) {
                $wordcount{$word}++;
        }
}
#
# preparazione file per sort per frequenza
#
open(OUT,"> out") || die "non riesco a scrivere su file."; 
foreach $word (sort keys(%wordcount)) {
         printf OUT "%10d %s\n",  $wordcount{$word}, $word;
}
close(OUT);
open(OUT,">> out") || die "non riesco a scrivere su file."; 
print OUT "uno\ndue\ntre\nciao!\n";
close(OUT);
print "\nHo scritto il file OUT\n";

print "programma p12string:\noperazioni sulle stringhe\n\n";
print "\nconcatenazione e ricerca-";
print "\nDammi la stringa \$uno: ";
chop($uno=<STDIN>);
print "Dammi la stringa \$due: ";
chop($due=<STDIN>);
print 'concatenazione: $uno . $due ==> ',$uno . $due,"\n";
print 'ricerca: index($uno,$due) ==> ',index($uno,$due),"\n";
#
print "\nripetizione e sottostringa-";
print "\nDammi un numero: ";
$n=<STDIN>;
print 'ripetizione: $due x $n ==> ',$due x $n,"\n";
print 'sottostringa: substr($uno,$n,1) ==> ',substr($uno,$n,1),"\n";
#
print "\nricerca di una chiave-";
print "\nDammi una stringa che contenga chiave= ";
$_=<STDIN>;
print "valore del parametro: ";
if (/chiave=(.*)/) {print $1}

print "programma p13chiavi:\nestrazione parametri a chiave\n\n";
print "=========================================================\n";
#================================================================
# p13chiavi - programma perl
#================================================================
# elabora i dati di documenti formato TXT
# cerca il testo chiave ed estrae le stringhe successive
# scrivendo files a campi fissi
#================================================================
$npar=$#ARGV+1;
if ($#ARGV < 0) {
print "Uso: perl CHIAVI {files}\n\n";
die "fine per mancanza di parametri\n" }
print '$#ARGV: ',$#ARGV," - n. parametri: $npar\n\n";
# ---------------------------------------------------------------
# apertura files di output
# ---------------------------------------------------------------
open (OUT,"> OUT.tx2") || die "Non posso aprire OUT $!";
# ---------------------------------------------------------------
# loop su tutti i files di input
# ---------------------------------------------------------------
$FILES=0;
foreach $i (0 .. $#ARGV) {
        $FILE = $ARGV[$i];
        $NFILES++;
# ---------------------------------------------------------------
# apertura di un file
# ---------------------------------------------------------------
        open (INFILE,$FILE) || die "Non posso aprire $file $!";
        printf "%5d %s %s",$NFILES,$FILE,"\n";
# ---------------------------------------------------------------
# elaborazione di un file
# ---------------------------------------------------------------
        while () {
#              print $_;
# toglie l'EOR
                chop;
# trasforma in tutte maiuscole
                tr/a-z/A-Z/;
# cerca i campi
	if (/^DATA:\t(.*)/) {$DATA = $1}
	if (/^LUOGO:\t(.*)/) {$LUOGO = $1};
	if (/^COGNOME:\t(.*)/) {$COGNOME = $1};
	if (/^NOME:\t(.*)/) {$NOME = $1};
	if (/^DATA DI NASCITA:\t(.*)/) {$DATAN = $1};
	if (/^LUOGO DI NASCITA:\t(.*)/) {$LUOGON = $1};
	if (/^CITTADINANZA:\t(.*)/) {$CITTAD = $1};
	if (/^ATTIVITĄ:\t(.*)/) {$ATTIV = $1};
}
# scrive i campi formattati
write OUT;
close (INFILE);
}
close (OUT);
print "\nn. files letti: $NFILES  - output su OUT.TX2\n\n";
exit;
# ---------------------------------------------------------------
format OUT =
@#### @<<<<<<<<<<@<<<<<<<<@<<<<<<<<<<@<<<<<<<<<<@<<<<<<<<<<<<<<@<<<<<<<<<<@<<<<<<<<<<@<<<<<<<<<< @<<<<<<<<<<<<<<<<<
$NFILES, $FILE, $DATA, $LUOGO, $COGNOME, $NOME, $DATAN, $LUOGON, $CITTAD, $ATTIV
.
# ---------------------------------------------------------------
se si lancia il programma con perl p13chiave *.txt e i files

m1.txt
DATA:	31-12-96
LUOGO:	MODENA
COGNOME:	CIGLIARI
NOME:	GIOVANBATTISTA
DATA DI NASCITA:	19.07.1956
LUOGO DI NASCITA:	STEFANACONI (vv)
CITTADINANZA:	ITALIANA
ATTIVITĄ:	SCONOSCIUTA

m2.txt
DATA:	01-02-1996
LUOGO:	MODENA
COGNOME:	ARLETTI
NOME:	GIORGIO
DATA DI NASCITA:	21.12.1956
LUOGO DI NASCITA:	MODENA
CITTADINANZA:	ITALIANA
ATTIVITĄ:	DISOCCUPATO

m3.txt
DATA:	02-01.96
LUOGO:	Modena
COGNOME:	FARINA
NOME:	Gianluca
DATA DI NASCITA:	15-01-67
LUOGO DI NASCITA:	Modena
CITTADINANZA:	italiana
ATTIVITĄ:	disoccupato

si ottiene il file OUT.TX2

    1 m1.txt     31-12-96 MODENA     CIGLIARI   GIOVANBATTISTA 19.07.1956 STEFANACONIITALIANA    SCONOSCIUTA
    2 m2.txt     01-02-199MODENA     ARLETTI    GIORGIO        21.12.1956 MODENA     ITALIANA    DISOCCUPATO
    3 m3.txt     02-01.96 MODENA     FARINA     GIANLUCA       15-01-67   MODENA     ITALIANA    DISOCCUPATO

print "programma p14par:\nestrazione parametri formali\n\n";
print "\nDammi una stringa di parametri (es.:V1=1&V2=2b2&V4=ZZ): ";
chop($riga=<STDIN>);
#$riga='V1=a11......+++++.&V2=2b2&V4=ZZ&V3=33c';
print $riga,"\n";

# localizzo il nome della variabile 1
$off=index($riga,"V1=");
$V1='';
if ($off >= 0) {        # se ho trovato la variabile, estraggo il resto
        $V1=substr($riga,index($riga,"V1=")+3);
        # localizzo & e tronco la stringa se lo trovo
        $coda=index($V1,'&');
        if ($coda >= 0) {
                $V1=substr($V1,0,$coda);
        }
}
print "V1 >$V1<\n";

# localizzo il nome della variabile 2
$off=index($riga,"V2=");
$V2='';
if ($off >= 0) {        # se ho trovato la variabile, estraggo il resto
        $V2=substr($riga,index($riga,"V2=")+3);
        # localizzo & e tronco la stringa se lo trovo
        $coda=index($V2,'&');
        if ($coda >= 0) {
                $V2=substr($V2,0,$coda);
        }
}
print "V2 >$V2<\n";

# localizzo il nome della variabile
$off=index($riga,"V3=");
$V3='';
if ($off >= 0) {        # se ho trovato la variabile, estraggo il resto
        $V3=substr($riga,index($riga,"V3=")+3);
        # localizzo & e tronco la stringa se lo trovo
        $coda=index($V3,'&');
        if ($coda >= 0) {
                $V1=substr($V3,0,$coda);
        }
}
print "V3 >$V3<\n";
print "------------\n";
print "$V1 $V2 $V3\n";
chdir("D:\\");
open(OUT,">> OUT");
printf OUT "%10s %10s %10s\n",$V1,$V2,$V3,"\n";
close(OUT);