Funzioni per gestire array

Funzioni PHP per gestire array

PHP mette a disposizione numerose funzioni per lavorare con gli array. Non è necessario installare estensioni per poterle utilizzare, in quanto le funzioni sono già integrate nel core di PHP.

Di seguito alcune funzioni per creare, manipolare, filtrare, confrontare e ordinare array. Per la lista completa consulta la documentazione

array_change_key_case

array_change_key_case ( array $array [, int $case = CASE_LOWER ] ) : array

La funzione array_change_key_case() ritorna una array con le chiavi convertite in minuscolo o maiuscolo. Se l'array ha indici numerici, questi non vengono convertiti.

Oltre all'array di partenza, la funzione prende una costante come parametro che di default è CASE_LOWER, per la conversione in minuscolo. L'altra costante è CASE_UPPER, per la conversione in maiuscole.

<?php
$colors = ['rosso' => 'red', 'giallo' => 'yellow'];
print_r(array_change_key_case($colors, CASE_UPPER));

/* Output
Array
(
    [ROSSO] => red
    [GIALLO] => yellow
)
*/

array_chunk

array_chunk ( array $array , int $size [, bool $preserve_keys = FALSE ] ) : array

La funzione array_chunk() divide un array in array di dimensione uguale al parametro $size. L'ultimo array può contenere meno di elementi di $size. Con il parametro $preserve_key impostato a true, le chiavi vengono mantenute, altrimenti vengono reindicizzate nei vari array.

<?php
$array = ['a', 'b', 'c', 'd', 'e'];
print_r(array_chunk($array, 2));

/* Output
Array
(
    [0] => Array
        (
            [0] => a
            [1] => b
        )

    [1] => Array
        (
            [0] => c
            [1] => d
        )

    [2] => Array
        (
            [0] => e
        )

)
*/

array_column

array_column ( array $input , mixed $column_key [, mixed $index_key = NULL ] ) : array

La funzione array_column() viene utilizzata con gli array multidimensionali e ritorna un array coi valori presi da una singola chiave dell'input, identificata da $column_key.

L'array ritornato viene reindicizzato numericamente, ma è possibile specificare una chiave dell'array di partenza, fornita tramite il parametro $index_key.

<?php
// $list rappresenta un possibile array di utenti presi da un database
$list = [
    [
        'id' => 2135,
        'name' => 'John',
        'surname' => 'Doe',
    ],
    [
        'id' => 3245,
        'name' => 'Sally',
        'surname' => 'Smith',
    ],
    [
        'id' => 5342,
        'name' => 'Jane',
        'surname' => 'Jones',
    ]
];
 
$name = array_column($list, 'name');
print_r($name);
$name = array_column($list, 'name', 'id');
print_r($name);

/* Output
Array
(
    [0] => John
    [1] => Sally
    [2] => Jane
)
Array
(
    [2135] => John
    [3245] => Sally
    [5342] => Jane
)
*/

array_combine

array_combine ( array $keys , array $values ) : array

La funzione array_combine() restituisce un array creato utilizzando come chiavi, i valori dell'array $keys e, come valori, i valori dell'array $values.

<?php
$colors = ['verde', 'rosso', 'giallo'];
$fruits = ['avocado', 'mela', 'banana'];
$array = array_combine($colors, $fruits);

print_r($array);

/* Output
Array
(
    [verde] => avocado
    [rosso] => mela
    [giallo] => banana
)
*/

array_count_values

array_count_values ( array $array ) : array

La funzione array_count_values() ritorna un array che ha come chiavi i valori dell'array di input, e come valori, il numero di ripetizioni dei vecchi valori.

<?php
$array = [1, 'hello', 1, 'world', 'hello'];
print_r(array_count_values($array));

/* Output
Array
(
    [1] => 2
    [hello] => 2
    [world] => 1
)
*/

array_diff

array_diff ( array $array1 , array $array2 [, array $... ] ) : array

La funzione array_diff() confronta $array1 con uno o più array e ritorna i valori di $array1 che non sono presenti in nessuno degli altri array.

<?php
$array1 = ["Paolo", "Andrea", "Flavio"];
$array2 = ["Andrea", "Agnese", "Paola", "Alessandra"];
$result = array_diff($array1, $array2);

print_r($result);

/* Output
Array
(
    [0] => Paolo
    [2] => Flavio
)
*/

array_fill

array_fill ( int $start_index , int $num , mixed $value ) : array

La funzione array_fill() crea un array di $num elementi con valore uguale al parametro $value, e le cui chiavi cominciano dal parametro $start_index.

<?php
$a = array_fill(2, 4, 'html');

print_r($a);

/* Output
Array
(
    [2] => html
    [3] => html
    [4] => html
    [5] => html
)
*/

array_filter

array_filter ( array $array [, callable $callback [, int $flag = 0 ]] ) : array

La funzione array_filter() filtra gli elementi di un array usando la funzione $callback. Le chiavi dell'array vengono mantenute.

<?php
// Calcolo anno bisestile
function lapYear($array) 
{
    if($array % 4 == 0) {
       return true;
    }
    return false;
}
  
$array = [2014, 2015, 2016, 2020, 2010, 2008];
print_r(array_filter($array, "lapYear"));

/* Output
Array
(
    [2] => 2016
    [3] => 2020
    [5] => 2008
)
*/

array_flip

array_flip ( array $array ) : array

La funzione array_flip() inverte chiavi e valori dell'array di input e ritorna un array.

I valori dell'array di input devono essere di tipo intero o stringa. Se viene specificato un tipo diverso, la funzione genera un avviso e quel valore non verrà incluso nell'array risultante.

Se un valore compare più volte nell'array iniziale, solamente l'ultimo verrà convertito in chiave nel nuovo array, tutti gli altri andranno persi.

<?php
$array = ["pere", "mele", "banane"];
$flipped = array_flip($array);

print_r($flipped);

/* Output
Array
(
    [pere] => 0
    [mele] => 1
    [banane] => 2
)
*/

array_intersect

array_intersect ( array $array1 , array $array2 [, array $... ] ) : array

La funzione array_intersect() confronta $array1 con uno o più array e ritorna i valori di $array1 che sono presenti negli altri array.

<?php
$array1 = ["Paolo", "Andrea", "Flavio"];
$array2 = ["Andrea", "Agnese", "Paola", "Alessandra"];
$result = array_intersect($array1, $array2);

print_r($result);

/* Output
Array
(
    [1] => Andrea
)
*/

array_key_exists

array_key_exists ( mixed $key , array $array ) : bool

La funzione array_key_exists() ritorna true se la chiave $key viene trovata nell'array $array, false altrimenti.

<?php
$array = ['lun' => 'Lunedì', 'mar' => 'Martedì', 'ven' => 'Venerdì', 'sab' => 'Sabato'];

if (array_key_exists('lun', $array)) {
    echo "Trovata";
} else {
    echo "Non trovata";
}

// Output: Trovata

array_map

array_map ( callable $callback , array $array1 [, array $... ] ) : array

La funzione array_map() ritorna un array contenente il risultato dell'applicazione della funzione $callback all'array $array1 (ed altri array eventualmente forniti) usato come argomento per chiamare la funzione. Il numero di parametri accettati dalla funzione di callback deve corrispondere al numero di array passati ad array_map().

<?php
function cube($n)
{
    return ($n * $n * $n);
}

$a = [1, 2, 3, 4, 5];
$b = array_map('cube', $a);
print_r($b);

/* Output
Array
(
    [0] => 1
    [1] => 8
    [2] => 27
    [3] => 64
    [4] => 125
)
*/

array_merge

array_merge ([ array $... ] ) : array

La funzione array_merge() ritorna un array composto dall'unione degli elementi di uno o più array presi in input.

Se gli array di input hanno chiavi di tipo stringa uguali, il valore successivo per quella chiave sovrascriverà quello precedente. Se invece gli array contengono chiavi numeriche, il valore successivo non sovrascriverà quello precedente, ma verrà aggiunto.

I valori degli array di input con chiavi numeriche, saranno reindicizzati nell'array di output partendo da zero.

<?php
$array1 = array("color" => "red", 2, 4);
$array2 = array("a", "b", "color" => "green", "shape" => "trapezoid", 4);
$result = array_merge($array1, $array2);

print_r($result);
/* Output
Array
(
    [color] => green
    [0] => 2
    [1] => 4
    [2] => a
    [3] => b
    [shape] => trapezoid
    [4] => 4
)
*/

array_pop

array_pop ( array &$array ) : mixed

La funzione array_pop() rimuove e restituisce il valore dell'ultimo elemento dell'array.

<?php
$stack = ["arancia", "banana", "mela", "lampone"];
$fruit = array_pop($stack);
print_r($stack);

/* Output
Array
(
    [0] => arancia
    [1] => banana
    [2] => mela
)
*/

array_push

array_push ( array &$array [, mixed $... ] ) : int

La funzione array_push()tratta l'array come una pila e inserisce i nuovi valori alla fine dell'array. La lunghezza dell'array aumenta in base al numero di valori inseriti. È equivalente all'istruzione seguente:

<?php
$array[] = $var;

Di seguito un esempio di utilizzo di array_push()

<?php
$stack = ['orange', 'banana'];
array_push($stack, 'apple', 'raspberry');
print_r($stack);

/* Output
Array
(
    [0] => orange
    [1] => banana
    [2] => apple
    [3] => raspberry
)
*/

array_search ( mixed $needle , array $haystack [, bool $strict = FALSE ] ) : mixed

La funzione array_search() effettua la ricerca del valore del parametro $needle nell'array $haystack, ritornando la prima chiave corrispondente se la ricerca ha esito positivo, false altrimenti.

Se il parametro $strict è impostato su true, la funzione array_search() farà un confronto "stretto" nell'array. Ciò significa che verranno confrontati sia il valore che il tipo di dato.

Nota: Questa funzione può restituire il valore booleano false, ma può anche restituire un valore non booleano interpretato da PHP come false (ad esempio 0). Perciò è necessario utilizzare l'operatore di confronto === per verificare il valore restituito da questa funzione.

array_sum

array_sum ( array $array ) : number

La funzione array_sum() calcola la somma degli elementi di un array e ritorna il risultato.

<?php
$a = [2, 4, 6, 8];
echo "sum(a) = " . array_sum($a) . "\n"; // Output: 20

$b = ["a" => 1.2, "b" => 2.3, "c" => 3.4];
echo "sum(b) = " . array_sum($b) . "\n"; // Output: 6.9

array

array ([ mixed $... ] ) : array

La funzione array() crea un array di elementi. Gli elementi possono essere di qualunque tipo. Da PHP 5.4, per creare array è preferibile utilizzare la sintassi con le parentesi quadre ([]).

Di seguito le regole di sintassi per gli elementi:

  • La sintassi degli elementi è "indice => valori", separati da virgole, che definiscono indici e valori.
  • L'indice può essere sia di tipo stringa che intero.
  • Quando l'indice viene omesso, un indice di tipo intero viene generato automaticamente, partendo da 0.
  • Se l'indice è un numero intero, l'indice generato successivo sarà l'indice intero più grande incrementato di 1.
  • Quando vengono definiti due indici identici, l'ultimo sovrascrive il primo. È possibile inserire una virgola finale dopo l'ultimo elemento dell'array.
<?php
$array = array (
    "frutti"  => array("a" => "orange", "b" => "banana", "c" => "mela"),
    "numeri" => array(1, 2, 3, 4, 5, 6)
);

count

count ( mixed $array_or_countable [, int $mode = COUNT_NORMAL ] ) : int

La funzione count() calcola la dimensione di un array, ritornando un valore di tipo intero.

Se il parametro opzionale è impostato su COUNT_RECURSIVE (o 1), la funzione conterà l'array ricorsivamente. Ciò è particolarmente utile per contare tutti gli elementi di un array multidimensionale.

<?php
$food = [
    'fruits' => ['orange', 'banana', 'apple'],
    'veggie' => ['carrot', 'collard', 'pea']
];

// conteggio ricorsivo
echo count($food, COUNT_RECURSIVE); // Output: 8

// conteggio normale
echo count($food); // Output: 2

in_array

in_array ( mixed $needle , array $haystack [, bool $strict = FALSE ] ) : bool

La funzione in_array() ritorna true se il valore di $needle viene trovata nell'array $haystack, false altrimenti. Se $needle è una stringa, il confronto viene fatto in maniera case-sensitive.

Se il parametro opzionale $strict è impostato su true, la funzione fa un controllo anche per il tipo di dato.

<?php
$os = ["Mac", "Microsoft", "Solaris", "Linux"];

if (in_array("Linux", $os)) {
    echo "Sistema operativo in uso: Linux";
}
if (in_array("mac", $os)) {
    echo "Sistema operativo in uso: mac";
}

Funzioni per accedere agli elementi

Le funzioni current(), end(), key(), netx(), prev(), reset() consentono l'accesso agli elementi di un array. Per approfondire consulta il paragrafo relativo a come accedere agli elementi, nella guida dedicata agli array.

Funzioni di ordinamento

Le funzioni arsort(), asort(), krsort(), ksort(), natsort(), sort(), rsort() sono state analizzate nella guida delle funzioni di ordinamento array.

Guida successiva: Funzioni per gestire stringhe