Lezione19: Le funzioni in PHP: gestire gli array

Vediamo ora alcune funzioni che operano sugli array:

count(array)

conta il numero di elementi dell'array. Restituisce un intero.

array_reverse(array [, booleano])

inverte l'ordine degli elementi dell'array. Se vogliamo mantenere le chiavi dell'array di input, dobbiamo passare il secondo parametro con valore TRUE. Restituisce l'array di input con gli elementi invertiti.

sort(array)

ordina gli elementi dell'array. Bisogna fare attenzione, perchè questa funzione, contrariamente a molte altre, modifica direttamente l'array che le viene passato in input, che quindi andrà perso nella sua composizione originale. I valori vengono disposti in ordine crescente secondo i criteri che abbiamo visto nella lezione 10. Le chiavi vanno perse: dopo il sort, l'array avrà chiavi numeriche a partire da 0 secondo il nuovo ordinamento. Non restituisce nulla.

rsort(array)

ordina gli elementi dell'array in ordine decrescente. Anche questa funzione modifica direttamente l'array passato in input e riassegna le chiavi numeriche a partire da 0. Non restituisce nulla.

asort(array)

funziona come sort(), con la differenza che vengono mantenute le chiavi originarie degli elementi. Non restituisce nulla.

arsort(array)

come rsort(), ordina in modo decrescente; mantiene però le chiavi originarie. Non restituisce nulla.

in_array(valore, array)

cerca il valore all'interno dell'array. Restituisce un valore booleano: vero o falso a seconda che il valore cercato sia presente o meno nell'array.

array_key_exists(valore, array)

cerca il valore fra le chiavi (e non fra i valori) dell'array. Restituisce un valore booleano.

array_search(valore, array)

cerca il valore nell'array e ne indica la chiave. Restituisce la chiave del valore trovato o, se la ricerca non va a buon fine, il valore FALSE.

array_merge(array, array [, array...])

fonde gli elementi di due o più array. Gli elementi con chiavi numeriche vengono accodati l'uno all'altro e le chiavi rinumerate. Le chiavi associative invece vengono mantenute, e nel caso vi siano più elementi nei diversi array con le stesse chiavi associative, l'ultimo sovrascrive i precedenti. Restituisce l'array risultante dalla fusione.

array_pop(array)

estrae l'ultimo elemento dell'array, che viene 'accorciato'. Restituisce l'elemento in fondo all'array e, contemporaneamente, modifica l'array in input togliendogli lo stesso elemento.

array_push(array, valore [,valore...])

accoda i valori indicati all'array. Equivale all'uso dell'istruzione di accodamento $array[]=$valore , con il vantaggio che ci permette di accodare più valori tutti in una volta. Restituisce il numero degli elementi dell'array dopo l'accodamento.

array_shift(array)

estrae un elemento come array_pop(), ma in questo caso si tratta del primo. Anche in questo caso l'array viene 'accorciato', ed inoltre gli indici numerici vengono rinumerati. Rimangono invece invariati quelli associativi. Restituisce l'elemento estratto dall'array.

array_unshift(array, valore [,valore...])

inserisce i valori indicati in testa all'array. Restituisce il numero degli elementi dell'array dopo l'inserimento.

implode(stringa, array)

è la funzione opposta di explode(), e serve a riunire in un'unica stringa i valori dell'array. La stringa indicata come primo parametro viene interposta fra tutti gli elementi dell'array. Restituisce la stringa risultato dell'aggregazione. Suo sinonimo è join().

Ecco qualche esempio sull'uso di queste funzioni:

$arr = array('Luca', 'Giovanni', 'Matteo', 'Paolo', 'Antonio', 'Marco', 'Giuseppe');

$n = count($arr);            // $n vale 7
$arr1 = array_reverse($arr); // $arr1 avrà gli elementi invertiti, da 'Giuseppe' a 'Luca'
echo $arr[1], '
';        // 'Giovanni'
echo $arr1[1], '
';       // 'Marco'

/* ora $arr sarà: 
 * 'Antonio', 'Giovanni', 'Giuseppe', 'Luca', 'Marco', ' Matteo', 'Paolo' 
 */
sort($arr); 

$a = in_array('Giovanni', $arr);  // $a è vero (TRUE)
$a = in_array('Francesco', $arr); // $a è falso (FALSE)
$ultimo = array_pop($arr);        // $ultimo è 'Paolo' (li avevamo ordinati!)
$ultimo = array_pop($arr);        // ora $ultimo è 'Matteo', e in $arr sono rimasti 5 elementi
$primo = array_shift($arr);       // primo è 'Antonio'

/* 'Matteo' e 'Antonio' vengono reinseriti in testa all'array; 
 * $a riceve il valore 6
 */
$a = array_unshift($arr, $ultimo, $primo);  

$stringa = implode(' ', $arr); // $stringa diventa 'Matteo Antonio Giovanni Giuseppe Luca Marco' */

/* $new_arr conterrà 13 elementi:
 * 'Matteo', 'Antonio', 'Giovanni', 
 * 'Giuseppe', 'Luca', 'Marco' (questi sono i 6 provenienti da $arr),
 * 'Giuseppe', 'Marco',' Antonio', 'Paolo', 
 * 'Matteo', 'Giovanni', 'Luca' (questi sono i 7 di $arr1). Gli indici andranno da 0 a 12. 
 */
$new_arr = array_merge($arr, $arr1); 

// Impostiamo ora un array con chiavi associative:
$famiglia = array('padre' => 'Claudio', 'madre' => 'Paola', 'figlio' => 'Marco', 'figlia' => 'Elisa');
// creiamo una copia del nostro array per poter fare esperimenti 
$fam1 = $famiglia; 
// ora $fam1 sarà 'Paola', 'Marco', 'Elisa', 'Claudio', con chiavi da 0 a 3 
rsort($fam1);

$fam1 = $famiglia; // ripristiniamo l'array originale

/* di nuovo $fam1 sarà 'Paola', 'Marco', 'Elisa', 'Claudio', 
 * ma ciascuno con la sua chiave originale 
 * ('madre', 'figlio', 'figlia', 'padre') 
 */
arsort($fam1); 

$a = array_key_exists('figlia', $fam1); // $a è TRUE
$a = array_key_exists('zio', $fam1);    // $a è FALSE
$a = array_search('Claudio', $fam1);    // $a è 'padre'
$a = array_search('Matteo', $fam1);     // $a è FALSE

Postato sotto: Lezioni PHP