view release on metacpan or  search on metacpan

IT/perlfunc.pod  view on Meta::CPAN

    package main;
    @nuovo = sort altro::alcontrario @vecchio;

    # stabilita` garantita, qualunque sia l'algoritmo
    use sort 'stable';
    @nuovo = sort { substr($a, 3, 5) cmp substr($b, 3, 5) } @vecchio;

    # forza l'uso di mergesort (non portabile al di 
    # fuori della versione 5.8 di Perl)
    use sort '_mergesort';  # notate il _ che ne 
                            # scoraggia l'uso
    @nuovo = sort { substr($a, 3, 5) cmp substr($b, 3, 5) } @vecchio;

Se state usando strict, I<non dovete> dichiarare $a e
$b come lessicali. Sono variabili globali del package.
Questo significa che se siete nel package C<main> e 
scrivete

  @articoli = sort { $b <=> $a } @file;

allora C<$a> e C<$b> sono C<$main::a> e C<$main::b>
(o C<$::a> e C<$::b>), ma se siete nel package 
C<PackagePippo> E<egrave> lo stesso che scrivere

  @articoli = sort { $PackagePippo::b <=> $PackagePippo::a } @file;

Si richiede che la funzione di confronto si comporti
in modo consistente. Se restituisce risultati 
inconsistenti (dicendo a volte che C<$x[1]> E<egrave>
piE<ugrave> piccolo di C<$x[2]> e a volte il contrario,
per esempio) i risultati non sono ben definiti.

PoichE<eacute> C<< <=> >> restituisce C<undef> quando uno degli operandi E<egrave> 
C<NaN> (not-a-number) [non-un-numero, NdT], e poichE<eacute> C<sort> genererE<agrave> 
un errore bloccante a meno che il risultato del confronto sia definito, quando 
effettuate un ordinamento con una funzione di confronto come C<< $a <=> $b >>, 
state attenti alle liste che potrebbero contenere C<NaN>. Il seguente esempio sfrutta 
il fatto che C<NaN != NaN>, per eliminare ogni C<NaN> dall'input.

    @risultati = sort { $a <=> $b } grep { $_ == $_ } @input;

=item splice ARRAY,SCOSTAMENTO,LUNGHEZZA,LISTA
X<splice>

=item splice ARRAY,SCOSTAMENTO,LUNGHEZZA

=item splice ARRAY,SCOSTAMENTO

=item splice ARRAY

Rimuove da un array gli elementi indicati da OFFSET e LUNGHEZZA, e li sostituisce con gli 
elementi di LISTA, se specificata. In contesto di lista, restituisce gli elementi rimossi 
dall'array. In contesto scalare, restituisce l'ultimo elemento rimosso, o C<undef> se nessun 
elemento viene rimosso. L'array si espande o rimpicciolisce come necessario. Se SCOSTAMENTO 
E<egrave> negativo, allora esso viene considerato a partire dalla fine dell'array. Se LUNGHEZZA 
viene omesso, rimuove tutto da SCOSTAMENTO in poi. Se LUNGHEZZA E<egrave> negativo, rimuove 
tutti gli elementi da SCOSTAMENTO in poi, tranne -LUNGHEZZA elementi alla fine dell'array. Se 
sia SCOSTAMENTO che LUNGHEZZA vengono omessi, rimuove tutto. Se SCOSTAMENTO E<egrave> oltre la 
fine dell'array, perl emette un avvertimento, e unisce alla fine dell'array.

Si hanno le seguenti equivalenze (assumendo C<< $[ == 0 e $#a >= $i >>):

    push(@a,$x,$y)	splice(@a,@a,0,$x,$y)
    pop(@a)		splice(@a,-1)
    shift(@a)		splice(@a,0,1)
    unshift(@a,$x,$y)	splice(@a,0,0,$x,$y)
    $a[$x] = $y		splice(@a,$x,1,$y)

Ad esempio, assumendo che le lunghezze degli array siano passate prima degli array:

    sub aeq {	# confronta due liste
	my(@a) = splice(@_,0,shift);
	my(@b) = splice(@_,0,shift);
	return 0 unless @a == @b;	# stessa lunghezza?
	while (@a) {
	    return 0 if pop(@a) ne pop(@b);
	}
	return 1;
    }
    if (&aeq($lungh,@pippo[1..$lungh],0+@pluto,@pluto)) { ... }

=item split /PATTERN/,ESPR,LIMITE
X<split>

=item split /PATTERN/,ESPR

=item split /PATTERN/

=item split

Divide la stringa ESPR in una lista di stringhe e restituisce
tale lista. Di default, i campi vuoti iniziali sono 
mantenuti, mentre quelli in coda vengono cancellati (se tutti i campi sono vuoti, 
vengono considerati essere in coda).

In un contesto scalare, restituisce il numero di campi 
trovati e mette i risultati della divisione nell'array C<@_>.
L'uso di split in un contesto scalare E<egrave> tuttavia
deprecato, poichE<eacute> sovrascrive gli argomenti
della vostra subroutine.

Se ESPR viene omessa, divide la stringa C<$_>. Se
anche PATTERN viene omesso, divide la stringa in base 
agli spazi (dopo aver saltato ciascuno spazio presente in 
testa alla stringa). Qualunque cosa soddisfi PATTERN 
E<egrave> trattato come un delimitatore che separa i campi. 
(Va notato che il delimitatore puE<ograve> essere piE<ugrave> 
lungo di un carattere.)

Se LIMITE viene specificato ed E<egrave> positivo, 
esso rappresenta il massimo numero di campi in cui 
ESPR verrE<agrave> divisa, perE<ograve> il numero
effettivo di campi restituiti dipende da quante volte
PATTERN E<egrave> soddisfatto all'interno di ESPR.
Se LIMITE non viene specificato o vale zero, allora 
i campi nulli in coda vengono omessi (cosa
che i potenziali utilizzatori di C<pop> farebbero bene
a ricordare).
Se LIMITE E<egrave> negativo, allora viene trattato come
se fosse stato specificato un valore di LIMITE
arbitrariamente grande. Va notato che dividere una ESPR