Perl/Funzioni Native su scalari

Wikibooks, manuali e libri di testo liberi.
Jump to navigation Jump to search

Funzioni Native su scalari[modifica]

Informative/ricerca/estrazione[modifica]

length[modifica]

length Ritorna il numero di byte (caratteri) presenti nella stringa.

Sintassi

  1. 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]

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

  1. index STR,SUBSTR,POSITION
  2. 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]

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

  1. rindex STR,SUBSTR,POSITION
  2. 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]

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

  1. substr EXPR,OFFSET
  2. substr EXPR,OFFSET,LENGTH
  3. 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]

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

  1. 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]

chomp[modifica]

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]

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]

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]

crypt[modifica]

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

  1. 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]

hex converte una stringa ( che rappresenta un numero esadecimale ) in un numero

Sintassi

  1. hex EXPR
  2. 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]

oct converte una stringa ( che rappresenta un numero in ottale ) in un numero

Sintassi

  1. oct EXPR
  2. 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]

ord converte il primo carattere di EXPR nella sua rappresentazione numerica (ASCII,EBDIC,Unicode 8Bit)

Sintassi

  1. ord EXPR

Esempi

175
  print ord 'abc'; # scrive '95'

Maiuscole/Minuscole[modifica]

lc[modifica]

lc ritorna una stringa con tutti i caratteri minuscoli

Sintassi:

  1. lc EXPR

Esempio

 print ( lc "AbC" )."\n"; # scrive 'abc'

lcfirst[modifica]

lcfirst ritorna una stringa con la sola prima lettera minuscola

Sintassi:

  1. lcfirst EXPR

Esempio

 print ( lcfirst "AbC" )."\n"; # scrive 'aBC'

uc[modifica]

uc ritorna una stringa con tutti i catatteri maiuscoli

Sintassi:

  1. uc EXPR

Esempio

 print ( lc "AbC" )."\n"; # scrive 'ABC'

ucfirst[modifica]

ucfirst ritorna una stringa con la sola prima lettera maiuscola


Sintassi:

  1. ucfirst EXPR

Esempio

 print ( ucfirst "AbC" )."\n"; # scrive 'Abc'

Particolari[modifica]

pack[modifica]

pack converte la lista in una rappresentazione binaria in base a TEMPLATE

Sintassi:

  1. pack TEMPLATE,LIST

Per maggiori dettagli vedi la documentazione su www.perl.it [1]

sprintf[modifica]

sprintf ritorna una stringa con le formattazioni richieste

Sintassi:

  1. sprintf FORMAT, LIST

Per maggiori dettagli vedere la documentazione su www.perl.it [2]

tr///[modifica]

tr/// - sostituisce i caratteri di una stringa. Al posto di SEARCHLIST mette quelli corrispondenti alla stessa posizione in REPLACEMENTLIST

Sintassi:

  1. 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]

y/// - sostituisce i caratteri di una stringa

Sintassi:

  1. y/SEARCHLIST/REPLACEMENTLIST/cds


NOTA uguale a tr///