Perl/Funzioni: differenze tra le versioni

Contenuto cancellato Contenuto aggiunto
Nessun oggetto della modifica
Nessun oggetto della modifica
Riga 21:
miafunzione();
 
nell'esempio indicato la funzione "miafunzione" non usa parametri.
 
I parametri passati ad una funzione sono variabili.
Occorre però prestare particolare attenzione al fenomeno della "linearizzazione" nel caso di array e hash. <-- riferimento a linearizzazione -->
Riga 174:
a=3
b:3 , 5 , 7 , 9
 
== Identificare una funzione ==
 
Il Perl ha un simbolo per identificare una funzione ed è il "&".Questo simbolo alla versione 5.6.xx non è più utilizzato per le chiamate dirette ma è rimasto per compatibilità con il passato.
Quindi si può trovare la chiamata a funzione anche come:
 
my $a = &estrazione();
my @b = &estrazione();
 
L'uso di questo simbolo è obbligatorio per far comprendere al linguaggio come utilizzare una variabile quando si vuole che questa si comporti come una funzione.
Per chiarimenti proseguire con la lettura.
 
== Funzione anonima ==
 
Precedentemente alle variabili si è visto come è possibile assegnare diverse cose.Fra queste ci sono anche le funzioni:
 
my $fun = sub
{
if ( wantarray )
{
return 3 , 5, 7, 9;
}
else
{
return 3;
}
}
 
my $f = &$fun();
my @fun = &$fun();
 
print "f=$f\n";
print "array fun:".join(" , ",@fun)."\n";
 
Da notare che non c'è il nome dopo sub e che il nome "nell'uso" è stato sostituito dal nome della variabile (con il $ davanti !)
 
== Una Funzione puntando al nome ==
 
Guardiamo ora questo codice:
 
sub estrazione
{
if ( wantarray )
{
return 3 , 5, 7, 9;
}
else
{
return 3;
}
}
 
my $f = \&estrazione;
 
my $a = &$f();
my @b = &$f();
 
Quindi in questo modo si è sostituito il "nome" della funzione con la variabile $f.
Prestate molta attenzione alla sintassi.
Infatti $f viene assegnato un reference "\" alla funzione "&" chiamata "estrazione".
Ben diverso è una chiamata a così fatta:
 
my $f = \&estrazione();
 
Infatti in questo caso verrà interpretato come:
$f viene assegnato un reference "\" al valore di ritorno della funzione "&" chiamata "estrazione" con parametri nulli.
Infatti &estrazione() da luogo alla chiamata della funzione così come &$f(). Mentre \&estrazione fa solo un riferimento ma non invoca la funzione.
 
 
print "a=$a\n";
print "b:".join(" , ",@b)."\n";
 
Dato che $f è una varibile è possibile usarla come un reference (infatti lo è) pertanto è possibile usare la sintassi -> :
 
my $a = $f->();
my @b = $f->();
== Funzioni con ritorno a funzione (nome o anonima) ==
 
Questo caso è alquanto raro tuttavia è interessante per capire cosa avviene , dato che possibile.
Se si torna una funzione poi questa deve essere lanciata per poter ottenere un risultato.
Vediamo ora questo codice:
 
sub estrazione
{
my $num = shift;
$num1 = int ( ( $num * 13 ) / 7 ) % 9 ;
$num2 = int ( ( $num * 3 ) / 7 ) % 9 ;
my @n = ( 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 );
if ( wantarray )
{
return $n[$num1], $n[$num2];
}
else
{
return $n[$num1];
}
}
sub controlla
{
my $n;
foreach $n ( @v )
{
print "con $num vinto!\n" if ( $n == 0 );
}
}
 
sub estrai
{
my $num = shift;
@v = estrazione($num);
return sub
{
my @altrinum=@_;
my $n;
my $cong="";
foreach $n ( @v )
{
$cong = " anche" , print "con $num vinto!\n" if ( $n == 0 );
}
foreach $n ( @altrinum )
{
print "con $n vinto".$cong." il premio di consolazione!\n" if ( $n == 0 );
}
};
}
 
$a = estrazione (5);
@a = estrazione (5);
print "a singolo:$a\n";
controlla(5,$a);
print "a array:".join(" , " , @a )."\n";
controlla(5,@a);
$a = estrai(5);
print "a singolo:$a\n";
# chiamo la funzione con altri numeri
&$a(7,8,0);
$f = \&estrai;
print "---\n";
$f ->(6)->(3,0,2);
 
che produce :
 
a singolo:0
a array:0 , 2
a singolo:CODE(0x140380)
con 5 vinto!
con 0 vinto anche il premio di consolazione!
---
con 0 vinto il premio di consolazione!
 
Da notare che nella funzione estrai nel ritorno di funzione ci sono dei dati passati alla prima.Questo è possibile perchè la funzione viene "cablata" con il valore della variabile nel codice della funzione ritornata.
Come detto all'inizio è preferibile usare ,per la manutenzione, le chiamate a funzioni esplicite che nella forma anonima/nominale.