Perl/Funzioni Native su scalari: differenze tra le versioni
Nuova pagina: =Funzioni su stringhe:= {{Perl}} ==Informative/ricerca/estrazione== ===length=== '''length''' Ritorna il numero di byte (caratteri) presenti nella stringa. Sintassi # length EXPR ... |
(Nessuna differenza)
|
Versione delle 14:22, 25 ago 2009
Funzioni su stringhe:
Informative/ricerca/estrazione
length
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
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
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
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
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
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:
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";
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:
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
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
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
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
$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";
}
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
print hex '0xAf'; # scrive '175'
print hex 'aF'; # scrive '175'!
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
print oct '0257'; # scrive '175'
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
175
print ord 'abc'; # scrive '95'
Maiuscole/Minuscole
lc
lc ritorna una stringa con tutti i caratteri minuscoli
Sintassi:
- lc EXPR
Esempio
print ( lc "AbC" )."\n"; # scrive 'abc'
lcfirst
lcfirst ritorna una stringa con la sola prima lettera minuscola
Sintassi:
- lcfirst EXPR
Esempio
print ( lcfirst "AbC" )."\n"; # scrive 'aBC'
uc
uc ritorna una stringa con tutti i catatteri maiuscoli
Sintassi:
- uc EXPR
Esempio
print ( lc "AbC" )."\n"; # scrive 'ABC'
ucfirst
ucfirst ritorna una stringa con la sola prima lettera maiuscola
Sintassi:
- ucfirst EXPR
Esempio
print ( ucfirst "AbC" )."\n"; # scrive 'Abc'
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
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)
NOTAper le opzioni "c" ,"d" ,"s" vedere la documentazione su www.perl.it
NOTA1 uguale a y///
y///
y/// - sostituisce i caratteri di una stringa
Sintassi:
- y/SEARCHLIST/REPLACEMENTLIST/cds
NOTA uguale a tr///