Perl/Funzioni Native su scalari
Funzioni Native su scalari
[modifica | modifica sorgente]Informative/ricerca/estrazione
[modifica | modifica sorgente]length
[modifica | modifica sorgente]length Ritorna il numero di byte (caratteri) presenti nella stringa.
Sintassi
- length EXPR
Esempio d'uso
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";
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
[modifica | modifica sorgente]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
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";
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:
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++;
}
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
[modifica | modifica sorgente]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
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";
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:
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--;
}
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
[modifica | modifica sorgente]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
# 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";
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
[modifica | modifica sorgente]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
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";
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
[modifica | modifica sorgente]chomp
[modifica | modifica sorgente]toglie (se c'è) l'ultimo "ritorno a capo" da una stringa.
NOTA: Quando si sono fatti i primi esempi in fondo alla stringhe usate si è sempre messo il carattere speciale "\n" . Questo carattere consente, quando si fanno successive print, che le nuove stringhe da scrivere inizino "a capo" e non continuino sulla stessa riga.
Vediamone un'applicazione:
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 riga 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";
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
[modifica | modifica sorgente]Toglie l'ultimo carattere di una stringa modificandola.
Vediamo questo esempio:
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";
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
[modifica | modifica sorgente]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 (codice) 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 30h al 39h) ed anche le lettere alfabetiche (dal 41h al 5Ah, maiuscole, 71h al 7Ah, minuscole).
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
che produce
carattere corrispondente a 64:@ questa è una riga
Conversione
[modifica | modifica sorgente]crypt
[modifica | modifica sorgente]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
$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 $pwd1)
{
print "Sorry...\n";
}
else
{
print "ok\n";
}
hex
[modifica | modifica sorgente]hex converte una stringa ( che rappresenta un numero esadecimale ) in un numero
Sintassi
- hex EXPR
- hex
NOTA: senza parametri viene utilizzata la variabile implicita $_
Esempi
print hex '0xAf'; # scrive '175'
print hex 'aF'; # scrive '175'!
NOTA:per la sola stampa/conversione si vedano anche sprintf, printf, unpack
oct
[modifica | modifica sorgente]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
print oct '0257'; # scrive '175'
NOTA:per la sola stampa/conversione si vedano anche sprintf , printf , unpack
ord
[modifica | modifica sorgente]ord converte il primo carattere di EXPR nella sua rappresentazione numerica (ASCII,EBDIC,Unicode 8Bit)
Sintassi
- ord EXPR
Esempi
175
print ord 'abc'; # scrive '95'
Maiuscole/Minuscole
[modifica | modifica sorgente]lc
[modifica | modifica sorgente]lc ritorna una stringa con tutti i caratteri minuscoli
Sintassi:
- lc EXPR
Esempio
print ( lc "AbC" )."\n"; # scrive 'abc'
lcfirst
[modifica | modifica sorgente]lcfirst ritorna una stringa con la sola prima lettera minuscola
Sintassi:
- lcfirst EXPR
Esempio
print ( lcfirst "AbC" )."\n"; # scrive 'aBC'
uc
[modifica | modifica sorgente]uc ritorna una stringa con tutti i catatteri maiuscoli
Sintassi:
- uc EXPR
Esempio
print ( lc "AbC" )."\n"; # scrive 'ABC'
ucfirst
[modifica | modifica sorgente]ucfirst ritorna una stringa con la sola prima lettera maiuscola
Sintassi:
- ucfirst EXPR
Esempio
print ( ucfirst "AbC" )."\n"; # scrive 'Abc'
Particolari
[modifica | modifica sorgente]pack
[modifica | modifica sorgente]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 [1]
sprintf
[modifica | modifica sorgente]sprintf ritorna una stringa con le formattazioni richieste
Sintassi:
- sprintf FORMAT, LIST
Per maggiori dettagli vedere la documentazione su www.perl.it [2]
tr///
[modifica | modifica sorgente]tr/// - sostituisce i caratteri di una stringa. Al posto di SEARCHLIST mette quelli corrispondenti alla stessa posizione in REPLACEMENTLIST
Sintassi:
- tr/SEARCHLIST/REPLACEMENTLIST/cds
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 123312
my $d = "ABCCAB";
my $cnt = $d =~ tr/A/A/; # $cnt ci sono quante A (sostituzioni) sono presenti in $d (2)
NOTA: per le opzioni "c" ,"d" ,"s" vedere la documentazione su www.perl.it [3]
NOTA1 uguale a y///
y///
[modifica | modifica sorgente]y/// - sostituisce i caratteri di una stringa
Sintassi:
- y/SEARCHLIST/REPLACEMENTLIST/cds
NOTA uguale a tr///