Perl/Funzioni Native sulle variabili: differenze tra le versioni

Contenuto cancellato Contenuto aggiunto
Pagina sostituita con '{{perl}} Il linguaggio mette a disposizione diverse funzioni per le operazioni base. Alcune di queste sono state già menzionate (es. print) per consentire di poter fare del...'
Riga 3:
Il linguaggio mette a disposizione diverse funzioni per le operazioni base.
Alcune di queste sono state già menzionate (es. print) per consentire di poter fare delle piccole prove.
 
=Funzioni su stringhe:=
 
 
==Informative/ricerca/estrazione==
===length===
'''length''' Ritorna il numero di byte (caratteri) presenti nella stringa.
 
Sintassi
# length EXPR
 
Esempio d'uso
<source lang="perl">
my $a = 'questa è una stringa di caratteri 36';
print '$a è lunga: '.( length $a )."\n";
print '$a è lunga: '.length($a)."\n";
my $b = 1;
print '$b è lungo: '.( length $b )."\n";
print '$b è lungo: '.length($b)."\n";
</source>
che produrrà :
 
$a è lunga: 36
$a è lunga: 36
$b è lungo: 1
$b è lungo: 1
 
'''NOTA:''' length è relativa alle SOLE stringhe. (se si vuole il numero di un array usare @<nome> in ambito scalare o $#<nome> vedi Array)
 
===index===
'''index''' Trova la prima ricorrenza di una stringa (SUBSTR) all'interno di un'altra stringa (STR) ritornandone la posizione.
 
'''NOTA''' non vengono usate le regular expression pertanto è un confronto fra semplici stringhe.
 
Sintassi
#index STR,SUBSTR,POSITION
#index STR,SUBSTR
 
'''NOTA''' Se si indica una POSITION la ricerca parte al carattere indicato.
Questo può essere comodo per cercare una ricorrenza successiva senza alterare la stringa originale.
Da notare che occorrerà incrementare di uno il valore ritornato dalla funzione index per poter cercare l'elemento successivo.
POSITION è utile solo fra i valori 0 e length(STR)-1 (il carattere prima della fine della stringa).
Valori al di fuori di questi valori saranno ignorati.
Se la index non trova un valore torna -1.
Esempio d'uso
<source lang="perl">
my $a = 'questa è una stringa di caratteri 36';
#cerco "una" in $a
my $p_una = index $a , "una";
print '"una" si trova alla posizione '.$p_una.' in $a'."\n";
my $una = 'una';
my $p_una = index( $a , $una );
print '"una" si trova alla posizione '.$p_una.' in $a'."\n";
#cerco "t" in $a
my $b = index $a , "t";
print '"t" si trova alla posizione '.$b.' in $a'."\n";
my $b = index( $a , "t" );
print '"t" si trova alla posizione '.$b.' in $a'."\n";
#cerco "mela" in $a
my $b = index $a , "mela";
print '"mela" si trova alla posizione '.$b.' in $a'."\n"; # NON SI TROVA !
 
#cerco "t" dopo la posizione di "una" in $a
my $c = index $a , "t" , $p_una;
print '"t" dopo "una" si trova alla posizione '.$c.' in $a'."\n";
my $c = index( $a , "t" , $p_una );
print '"t" dopo "una" si trova alla posizione '.$c.' in $a'."\n";
 
</source>
che produrrà :
 
"una" si trova alla posizione 9 in $a
"una" si trova alla posizione 9 in $a
"t" si trova alla posizione 4 in $a
"t" si trova alla posizione 4 in $a
"mela" si trova alla posizione -1 in $a
"t" dopo "una" si trova alla posizione 14 in $a
"t" dopo "una" si trova alla posizione 14 in $a
 
Vediamo ora un modo di cercare ogni SUB presente in una stringa usando index:
<source lang="perl">
my $a = 'questa è una stringa di caratteri 36';
print "cerco 't' in '$a'\n";
#cerco "t" in $a
my $p = 0;
while ( ($p = index $a , "t" , $p ) != -1 )
{
print "trovata 't' alla posizione $p \n";
$p++;
}
</source>
 
che produrrà :
 
cerco 't' in 'questa è una stringa di caratteri 36'
trovata 't' alla posizione 4
trovata 't' alla posizione 14
trovata 't' alla posizione 28
trovata 't' alla posizione 29
 
===rindex===
'''rindex''' Trova l'ultima ricorrenza di una stringa (SUBSTR) all'interno di un'altra stringa (STR) ritornandone la posizione.
 
'''NOTA1''' fa lo stesso tipo di ricerca di index ma a partire dal fondo.
 
'''NOTA2''' non vengono usate le regular expression pertanto è un confronto fra semplici stringhe.
 
Sintassi
#rindex STR,SUBSTR,POSITION
#rindex STR,SUBSTR
 
'''NOTA''' Se si indica una POSITION la ricerca parte al carattere indicato.
Questo può essere comodo per cercare una ricorrenza precedente senza alterare la stringa originale.
Da notare che occorrerà decrementare di uno il valore ritornato dalla funzione rindex per poter cercare l'elemento successivo.
POSITION è utile solo fra i valori 0 e length(STR)-1 (il carattere prima della fine della stringa).
Valori al di fuori di questi valori saranno ignorati.
Se la rindex non trova un valore torna -1.
 
Esempio d'uso
<source lang="perl">
my $a = 'questa è una stringa di caratteri 36';
#cerco dal fondo "una" in $a
my $p_una = rindex $a , "una";
print '"una" si trova alla posizione '.$p_una.' in $a'."\n";
my $una = 'una';
my $p_una = rindex( $a , $una );
print '"una" si trova alla posizione '.$p_una.' in $a'."\n";
#cerco dal fondo "t" in $a
my $b = rindex $a , "t";
print '"t" si trova alla posizione '.$b.' in $a'."\n";
my $b = rindex( $a , "t" );
print '"t" si trova alla posizione '.$b.' in $a'."\n";
#cerco "mela" in $a
my $b = rindex $a , "mela";
print '"mela" si trova alla posizione '.$b.' in $a'."\n"; # NON SI TROVA !
 
#cerco dal fondo "t" dopo la posizione di "una" in $a
my $c = rindex $a , "t" , $p_una;
print '"t" prima "una" si trova alla posizione '.$c.' in $a'."\n";
my $c = rindex( $a , "t" , $p_una );
print '"t" prima "una" si trova alla posizione '.$c.' in $a'."\n";
 
</source>
che produrrà :
 
"una" si trova alla posizione 9 in $a
"una" si trova alla posizione 9 in $a
"t" si trova alla posizione 29 in $a
"t" si trova alla posizione 29 in $a
"mela" si trova alla posizione -1 in $a
"t" prima "una" si trova alla posizione 4 in $a
"t" prima "una" si trova alla posizione 4 in $a
 
Vediamo ora un modo di cercare ogni SUB presente in una stringa usando index:
<source lang="perl">
my $a = 'questa è una stringa di caratteri 36';
print "cerco dal fondo 't' in '$a'\n";
#cerco "t" in $a
my $p =( length $a ) - 1;
while ( ($p = rindex $a , "t" , $p ) != -1 )
{
print "trovata 't' alla posizione $p \n";
$p--;
}
</source>
 
che produrrà:
 
cerco dal fondo 't' in 'questa è una stringa di caratteri 36'
trovata 't' alla posizione 29
trovata 't' alla posizione 28
trovata 't' alla posizione 14
trovata 't' alla posizione 4
 
 
===substr===
'''substr''' Estrae (e sostituisce[REPLACEMENT]) una porzione di stringa(EXPR) in base alla posizione(OFFSET) della lunghezza passata(LENGTH).
 
'''NOTA:''' attenzione che substr può essere usato anche a sinistra di un assegnamento !.
 
Sintassi
#substr EXPR,OFFSET
#substr EXPR,OFFSET,LENGTH
#substr EXPR,OFFSET,LENGTH,REPLACEMENT
 
 
Esempio d'uso
<source lang="perl">
# 1 2 3 4 5
# 012345678901234567890123456789012345678901234567890123
my $a = 'il mio nome è james bond ed ho una vita movimentata';
print "\$a originale: $a\n";
my $da_20_in_poi = substr $a , 20; #contiene 'bond ed ho una vita movimentata'
my $da_20_a_34 = substr $a , 20 , 15; #contiene 'bond ed ho una '
my $da_20_a_23 = substr $a , 20 , 4; #contiene 'bond'
my $b = substr $a , 20 , 4 , 'TonT'; #contiene $b = 'bond' , $a = 'il mio nome è james TonT ed ho una vita movimentata'
my $c = substr ( $a , 20 , 4 ) = 'Smith';
print "da_20_in_poi:$da_20_in_poi\n";
print "da_20_a_34 :$da_20_a_34\n";
print "da_20_a_23 :$da_20_a_23\n";
print "\$a = $a\n";
print "\$b = $b\n";
print "\$c = $c\n";
</source>
 
'''NOTA:''' $da_20_a_34 contiene 15 caratteri , $da_20_a_23 contiene 4 caratteri , 'Smith' è più lungo di TonT
 
che produrrà:
 
$a originale: il mio nome è james bond ed ho una vita movimentata
da_20_in_poi: bond ed ho una vita movimentata
da_20_a_34 : bond ed ho una
da_20_a_23 : bond
$a = il mio nome è james Smith ed ho una vita movimentata
$b = bond
$c = Smit
 
 
'''NOTA:''' $c è il valore di substr ( $a , 20 , 4 ) dopo che è stato assegnato substr ( $a , 20 , 4 ) = 'Smith' ecco perchè manca la 'h'
 
===reverse===
'''scalar reverse''' inverte i caratteri di una stringa (leggere la NOTA).
 
'''NOTA:''' reverse funziona in modo lista, ma in contesto scalare (forzato con 'scalar') inverte le stringhe
 
 
Sintassi
#scalar reverse EXPR
 
 
Esempio d'uso
<source lang="perl">
 
my $a = "pippo corre nel prato";
my $b = reverse $a; # qui scalar non serve perchè è nel contesto
print "$b\n";
print ( scalar reverse $b ). "\n";
 
</source>
 
 
che produce:
otarp len erroc oppip
pippo corre nel prato
 
'''NOTA:''' se alla print si togliesse scalar, reverse lavorerebbe in modo lista e quindi non invertirebbe la stringa
 
==Su un carattere==
 
===chomp===
 
toglie (se c'è) l'ultimo "ritorno a capo" da una stringa.
 
===NOTA:=== Quando si è fatto i primi esempi in fondo alla stringhe usate si è sempre messo il carattere speciale "\n" ===TODO link ai caratteri speciali===.Questo carattere consente ,quando si fanno successive print che la nuove stringhe da scrivere inizino "a capo" e non continuino sulla stessa riga.
 
vediamone una applicazione:
 
<source lang="perl">
 
my $a = "questa è una riga con più ritorni a capo\n\n";
my $b = "-" x 10; #questo è una serie di 10 "-" che uso come separatore
print "Originale: \n";
print "$b\n";
print "$a\n"; # nota due righe di spazio
print "$b\n";
print "\n"; #spazio le scritte
 
print "primo chomp \n";
chomp ($a);
 
print "$b\n";
print "$a\n"; # nota una righe di spazio
print "$b\n";
print "\n"; #spazio le scritte
 
print "secondo chomp \n";
chomp ($a);
 
print "$b\n";
print "$a\n"; # nota nessuna riga di spazio
print "$b\n";
print "\n"; #spazio le scritte
 
print "terzo chomp \n";
chomp ($a);
 
print "$b\n";
print "$a\n"; # nota nessuna riga di spazio
print "$b\n";
 
</source>
 
che produce il seguente output
Originale:
----------
questa è una riga con più ritorni a capo
----------
primo chomp
----------
questa è una riga con più ritorni a capo
----------
secondo chomp
----------
questa è una riga con più ritorni a capo
----------
terzo chomp
----------
questa è una riga con più ritorni a capo
----------
 
=== chop ===
 
Toglie l'ultimo carattere di una stringa modificandola.
 
Vediamo questo esempio:
 
<source lang="perl">
 
my $a = "questa è una riga\n";
my $b = "-" x 10; #questo è una serie di 10 "-" che uso come separatore
print "Originale: \n";
print "$b\n";
print "$a\n"; # nota una righe di spazio
print "$b\n";
print "\n"; #spazio le scritte
 
print "primo chop \n";
my $c = chop ($a);
 
print "$b\n";
print "$a\n"; # nota nessuna riga di spazio
print "$b\n";
print "carattere estratto:$c\n"; #mica vorrai vedere un ritorno a capo !!!!
print "$b\n";
print "\n"; #spazio le scritte
 
print "secondo chop \n";
$c = chop ($a);
 
print "$b\n";
print "$a\n"; # nota alla riga manca l'ultimo carattere ...
print "$b\n";
print "carattere estratto:$c\n"; # $c = 'a'
print "$b\n";
print "\n"; #spazio le scritte
 
print "terzo chop \n";
$c = chop ($a);
 
print "$b\n";
print "$a\n"; # nota alla riga mancano ora due caratteri
print "$b\n";
print "carattere estratto:$c\n"; # $c = 'g'
print "$b\n";
 
</source>
 
che produce il seguente output
 
Originale:
----------
questa è una riga
----------
primo chop
----------
questa è una riga
----------
carattere estratto:
----------
secondo chop
----------
questa è una rig
----------
carattere estratto:a
----------
terzo chop
----------
questa è una ri
----------
carattere estratto:g
----------
 
===chr===
 
questa funzione converte un numero in un carattere in base alla codifica ASCII.
Ogni carattere che vediamo sullo schermo (ma anche quelli che non vediamo come i ritorni a capo ed altri ) ha un numero corrispondente.Questi numeri vengono "inviati allo schermo" e vengono convertiti nei simboli (caratteri) che vediamo sullo schermo.
Per ovvie ragioni di comodità i simboli che rappresentano i numeri sono contigui (dal??? al ??) ed anche le lettere alfabetiche (dal xxx al yyy minuscole - maiuscole)
===TODO link alla tabella ascii===
 
<source lang="perl">
 
my $a = chr(64); # corrisponde al carattere @
print "carattere corrispondente a 64:$a\n";
 
foreach $a (qw (113 117 101 115 116 97 32 232 32 117 110 97 32 114 105 103 97) )
{
print chr($a); #NOTA: qui non c'è il ritorno a capo !!!
# altrimenti scriverebbe le lettere in verticale !
}
print "\n"; #qui si torna a capo ma potrebbe essere nei numeri sopra
 
</source>
 
che produce
 
carattere corrispondente a 64:@
questa è una riga
 
==Conversione==
 
===crypt===
'''crypt''' cripta un testo (PLAINTEXT) e lo ritorna criptato. il parametro SALT influisce sulla codifica.
Non esiste modo di avere il testo decriptato.
 
Per sapere se una "password" è corretta si confronta la parte criptata.
 
'''NOTA:''' la stringa ritornata da crypt dipende dal sistema operativo
 
Sintassi
#crypt PLAINTEXT,SALT
 
Esempi
<source lang="perl">
 
$word = "pippo";
$pwd = crypt($word,$word); #Uso la stessa parola come SALT !
print "pwd:$pwd\n";
 
if (crypt($word, $pwd) ne $pwd) #Uso la stessa pwd come SALT !
{
print "Sorry...\n";
}
else
{
print "ok\n";
}
$pwd1 = crypt($word,"banana"); #Uso un altro SALT
print "pwd1:$pwd1\n"; #Ottengo un altra password
if (crypt($word, "banana") ne $pwd)
{
print "Sorry...\n";
}
else
{
print "ok\n";
}
 
</source>
 
 
 
===hex===
'''hex''' converte una stringa ( che rappresenta un numero esadecimale ) in un numero
 
Sintassi
#hex EXPR
#hex
 
'''NOTA:'''Senza parametri utilizza la variabile implicita $_
 
Esempi
<source lang="perl">
 
print hex '0xAf'; # scrive '175'
print hex 'aF'; # scrive '175'!
 
</source>
 
'''NOTA:'''per la sola stampa/conversione si vedano anche sprintf , printf , unpack
 
===oct===
'''oct''' converte una stringa ( che rappresenta un numero in ottale ) in un numero
 
Sintassi
#oct EXPR
#oct
 
'''NOTA:'''Senza parametri utilizza la variabile implicita $_
 
Esempi
<source lang="perl">
 
print oct '0257'; # scrive '175'
 
</source>
 
'''NOTA:'''per la sola stampa/conversione si vedano anche sprintf , printf , unpack
 
===ord===
'''ord''' converte il primo carattere di EXPR nella sua rappresentazione numerica (ASCII,EBDIC,Unicode 8Bit)
 
Sintassi
#ord EXPR
 
Esempi
<source lang="perl">
175
print ord 'abc'; # scrive '95'
 
</source>
 
==Maiuscole/Minuscole==
===lc===
'''lc''' ritorna una stringa con tutti i caratteri minuscoli
 
Sintassi:
#lc EXPR
 
Esempio
<source lang="perl">
print ( lc "AbC" )."\n"; # scrive 'abc'
</source>
 
===lcfirst===
'''lcfirst''' ritorna una stringa con la sola prima lettera minuscola
 
Sintassi:
#lcfirst EXPR
 
Esempio
<source lang="perl">
print ( lcfirst "AbC" )."\n"; # scrive 'aBC'
</source>
 
===uc===
'''uc''' ritorna una stringa con tutti i catatteri maiuscoli
 
Sintassi:
#uc EXPR
 
Esempio
<source lang="perl">
print ( lc "AbC" )."\n"; # scrive 'ABC'
</source>
 
 
===ucfirst===
'''ucfirst''' ritorna una stringa con la sola prima lettera maiuscola
 
 
Sintassi:
#ucfirst EXPR
 
Esempio
<source lang="perl">
print ( ucfirst "AbC" )."\n"; # scrive 'Abc'
</source>
 
==Particolari==
 
===pack===
'''pack''' converte la lista in una rappresentazione binaria in base a TEMPLATE
 
Sintassi:
#pack TEMPLATE,LIST
 
Per maggiori dettagli vedi la documentazione su www.perl.it
 
===sprintf===
'''sprintf''' ritorna una stringa con le formattazioni richieste
 
Sintassi:
#sprintf FORMAT, LIST
 
Per maggiori dettagli vedere la documentazione su www.perl.it
 
 
===tr///===
'''tr///''' - sostituisce i caratteri di una stringa.Al posto di SEARCHLIST mette quelli corrispondenti alla stessa posizione in REPLACEMENTLIST
 
Sintassi:
#tr/SEARCHLIST/REPLACEMENTLIST/cds
 
<source lang="perl">
 
my $a = "ABCCAB";
$a =~ tr/ABC/abc/; # equivale all'istruzione lc $a ma solo per le lettere abc
 
my $b = "ABCCAB";
$b =~ tr/A-Z/a-z/; # equivale all'istruzione lc $a ma vale su tutte le lettere
 
my $c = "ABCCAB";
$c =~ tr/ABC/123/; # $c vale 123321
 
my $d = "ABCCAB";
my $cnt = $d =~ tr/A/A/; # $cnt ci sono quante A (sostituzioni) sono presenti in $d (2)
 
</source>
 
 
'''NOTA'''per le opzioni "c" ,"d" ,"s" vedere la documentazione su www.perl.it
 
'''NOTA<sup>1</sup>''' uguale a y///
 
===y///===
'''y///''' - sostituisce i caratteri di una stringa
 
Sintassi:
#y/SEARCHLIST/REPLACEMENTLIST/cds
 
 
'''NOTA''' uguale a tr///