Perl/Funzioni Native su vettori

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

Funzioni Native su vettori[modifica]

su vettori fisici[modifica]

pop[modifica]

pop Toglie l'ultimo elemento di un vettore.Se usato senza argomenti utilizza :

  1. @ARGV nel caso si è nel corpo principale
  2. @_ nel caso di soubrutine

Sintassi:

  • pop ARRAY
  • pop

NOTA: se non ci sono elementi torna undef


push[modifica]

push Aggiunge a ARRAY gli elementi di LIST, torna il numero di elementi complessivi

Sintassi:

  • push ARRAY,LIST


shift[modifica]

shift Ritorna il primo elemento di ARRAY in modo che, quello che prima era il secondo, ora è il primo. Se usato senza argomenti utilizza :

  1. @ARGV nel caso si è nel corpo principale
  2. @_ nel caso di soubrutine

Sintassi:

  • shift ARRAY
  • shift

NOTA: se non ci sono elementi torna undef

splice[modifica]

splice è una funzione che consente di aggiungere/togliere elementi da un ARRAY. Dato che può aggiungere o togliere uno o più elementi, occorre tenere presente che:

  1. OFFSET stabilisce la posizione dove aggiungere/togliere (se negativo parte dal fondo). Se OFFSET è superiore al numero di elementi che compongono l'ARRAY, verranno aggiunti/rimossi a partire dal fondo (ma prima di questo viene mandato un messaggio di avviso)
  2. LENGTH indica quanti elementi togliere. Se LENGTH=0 non ne viene tolto nessuno.

Se LENGTH è omesso rimuove tutti i valori:

  • se OFFSET è positivo da OFFSET fino alla fine dell ARRAY
  • se OFFSET è negativo, a partire dall'inizio fino a OFFSET ( quindi l'elemento che era alla posizione di OFFSET sarà il primo)
  1. LIST sono gli elementi da aggiungere

In un contesto scalare ritorna :

  1. se aggiunge : undef.
  2. se toglie : l'ultimo elemento estratto.

In un contesto lista ritorna:

  1. se aggiunge : undef.
  2. se toglie : tutti gli elementi estratti.

Sintassi:

  • splice ARRAY,OFFSET,LENGTH,LIST
  • splice ARRAY,OFFSET,LENGTH
  • splice ARRAY,OFFSET
  • splice ARRAY

unshift[modifica]

unshift mette in ARRAY, a partire dall'inizio, LIST.

Sintassi:

  • unshift ARRAY,LIST

Funzioni per liste di dati[modifica]

grep[modifica]

grep filtra gli elementi di una lista, tornando solo quelli che corrispondono all'elemento di selezione (BLOCK o EXPR)

Sintassi:

  • grep BLOCK LIST
  • grep EXPR, LIST

Esempi:

 my @el = ( 1, 2, 3, 4, 5, a, b, c, d, e);

 my @num0 = grep ( /\d/ , @el );  # @num0 contiene ( 1, 2, 3, 4, 5 )
 # oppure ...
 my @num1 = grep { /\d/ } @el ;   # @num1 contiene ( 1, 2, 3, 4, 5 )

 my @let0 = grep ( /\w/ , @el );  # @let0 contiene ( a, b, c, d, e )
 # oppure ...
 my @let1 = grep { /\w/ } @el ;   # @let1 contiene ( a, b, c, d, e )

join[modifica]

join ritorna una stringa composta da tutti gli elementi della lista "uniti" da STR

Sintassi:

  • join STR, LIST

map[modifica]

map ritorna una lista ottenuta dal risultato di BLOCK o EXPR ai quali viene passato singolarmente ogni elemento di LIST. In BLOCK o EXPR l'elemento è nella variabile $_.

NOTA: BLOCK o EXPR possono tornare zero, uno, due o più elementi pertanto si possono avere più valori da un elemento della LIST

Sintassi:

  • map BLOCK LIST
  • map EXPR, LIST

Esempi:

 my @el = ( 1, 2, 3, 4, 5, a, b, c, d, e);

 my @num0 = map ( ord , @el );  # @num0 contiene ( 49 , 50 , 51 , 52 , 53 , 97 , 98 , 99 , 100 , 101 )
 # oppure ...
 my @num1 = map { if ( $_ =~ /\d/) { $_; } else { ; } } @el ; # @num1 contiene ( 1, 2, 3, 4, 5 )

qw/STRING/[modifica]

qw consente di ottenere un array da ogni elemento separato da spazio contenuto in una stringa.

Esempi:

 my @el = qw( 1 2 3 4 5 a b c d e); # contiene 1, 2, 3, 4, 5, a, b, c, d, e


reverse[modifica]

reverse ritorna gli elementi in ordine inverso

Sintassi:

  • reverse LIST

sort[modifica]

sort ordina gli elementi in forma alfanumerica (in base al codice ascii). Per l'ordinamento numerico vedi esempi

Sintassi:

  • sort SUBNAME LIST
  • sort BLOCK LIST
  • sort LIST

Esempi: Esempi:

 my @el = qw( 1 2 3 4 5 a b c d e); # contiene 1, 2, 3, 4, 5, a, b, c, d, e

 my @el_sort0 = sort @el ;  #        

    @el_sort0 = sort {$a cmp $b} @el ; # Stessa cosa di prima ma con BLOCK esplicito         

 # ordinamento numerico ascendente
 my @el_sort1 = sort {$a <=> $b} @el;
    
    # ordinamento numerico discendente
 my @el_sort2 = sort {$b <=> $a} @el;
 
 # ordinamento : 1 , a , 2 , b , 3 , c , 4 , d , 5 , e 
 my @el_sort3 = sort { my %C = ( a => 1.001 
                               , b => 2.001
                               , c => 3.001
                               , d => 4.001
                               , e => 5.001 );
                       $Ca = $a; $Cb = $b;        
                       $Ca = $C{$a} if ( exists $C{$a} );
                       $Cb = $C{$b} if ( exists $C{$b} );
                       $Ca <=> $Cb;
                     } @el;

unpack[modifica]

unpack È l'azione contraria a pack. Si veda documentazione

Sintassi:

  • unpack TEMPLATE,EXPR
  • unpack TEMPLATE