Ordinare arrays multidimensionali con array_multisort

La funzione PHP per ordinare vettori multidimensionali.

Categoria: PHP | Livello: Beginner | Tags: array, chiavi, foreach, ordinamento. Scritto da il

Abstract

La funzione Array_multisort() di PHP serve a ordinare array multidimensionali o più vettori insieme. Dopo avere introdotto le operazioni di base sugli array, gli array associativi e il ciclo foreach, attraverso cinque esempi di dichiarazione e ordinamento di array vengono mostrate le analogie con i campi di una tabella.

Operazioni di base su array multidimensionali

Un array, detto anche vettore, può essere monodimensionale o multidimensionale: se il primo viene rappresentato con gli elementi in un'unica riga o colonna, la rappresentazione grafica del secondo dipende dal numero di dimensioni; un array bidimensionale si rappresenta agevolmente con una tabella e su esso possono essere eseguite le operazioni di base come quelle di dichiarazione, aggiunta ed eliminazione di un elemento, unione di arrays.

Partiamo dalla definizione di una semplice anagrafica con nome e cognome.


// Dichiarazione e stampa di un array bidimensionale
< ? Php
    $anagrafica = array (array("Mario", "Rossi"),
        array("Giuseppe", "Verdi"),
        array("Veronica", "Bianchi"));
    print_r($anagrafica);
?>

// Stampa del vettore con print_r
            Array
(
    [0] => Array
        (
            [0] => Mario
            [1] => Rossi
        )

    [1] => Array
        (
            [0] => Giuseppe
            [1] => Verdi
        )

    [2] => Array
        (
            [0] => Veronica
            [1] => Bianchi
        )

)

// Accodamento di un elemento
< ? Php
    $anagrafica[] = array("Rosa", "Linda");
    print_r($anagrafica);
?>

// Il nuovo elemento viene accodato con chiave [3]
            Array
(
    [0] => Array
        (
            [0] => Mario
            [1] => Rossi
        )

    [1] => Array
        (
            [0] => Giuseppe
            [1] => Verdi
        )

    [2] => Array
        (
            [0] => Veronica
            [1] => Bianchi
        )

    [3] => Array
        (
            [0] => Rosa
            [1] => Linda
        )

)

// Eliminazione di un elemento
< ? Php
    unset($anagrafica[2]);
    print_r($anagrafica);
?>

// Abbiamo eliminato il terzo elemento nell'ordine ovvero [2]. Attenzione: il costrutto unset() di PHP non reindicizza l'array.
            Array
(
    [0] => Array
        (
            [0] => Mario
            [1] => Rossi
        )

    [1] => Array
        (
            [0] => Giuseppe
            [1] => Verdi
        )

    [3] => Array
        (
            [0] => Rosa
            [1] => Linda
        )

)

// Accodamento di un ulteriore elemento
< ? Php
    $anagrafica[] = array("Paolo", "Paoletti");
    print_r($anagrafica);
?>

// Il nuovo elemento viene accodato con chiave [4]
            Array
(
    [0] => Array
        (
            [0] => Mario
            [1] => Rossi
        )

    [1] => Array
        (
            [0] => Giuseppe
            [1] => Verdi
        )

    [3] => Array
        (
            [0] => Rosa
            [1] => Linda
        )

    [4] => Array
        (
            [0] => Paolo
            [1] => Paoletti
        )

)

// Elminiamo l'elemento con chiave numerica [3]
< ? Php
    unset($anagrafica[3]);
    print_r($anagrafica);
?>

            Array
(
    [0] => Array
        (
            [0] => Mario
            [1] => Rossi
        )

    [1] => Array
        (
            [0] => Giuseppe
            [1] => Verdi
        )

    [4] => Array
        (
            [0] => Paolo
            [1] => Paoletti
        )

)

// Dichiarazione di un secondo array
< ? Php
    $anagrafica2 = array (array("Michele", "Micheletti"),
        array("Giorgio", "Giorgetti"),
        array("Antonio", "Antonelli"));
    print_r($anagrafica2);
?>

// Stampa del secondo vettore
            Array
(
    [0] => Array
        (
            [0] => Michele
            [1] => Micheletti
        )

    [1] => Array
        (
            [0] => Giorgio
            [1] => Giorgetti
        )

    [2] => Array
        (
            [0] => Antonio
            [1] => Antonelli
        )

)

// Unione di vettori
< ? Php
    $anagrafica += $anagrafica2;
    print_r($anagrafica);
?>

// Stampa del vettore unione: l'esempio mostra il funzionamento dell'operatore + il cui risultato è un array i cui elementi appartengono al primo o al secondo array. In caso di elementi identici o con la stessa chiave, ad avere la meglio sono gli elementi del primo array. Gli elementi [0] e [1] di $anagrafica2 non sono infatti presenti dal momento che $anagrafica presenta due elementi con le medesime chiavi.
            Array
(
    [0] => Array
        (
            [0] => Mario
            [1] => Rossi
        )

    [1] => Array
        (
            [0] => Giuseppe
            [1] => Verdi
        )

    [4] => Array
        (
            [0] => Paolo
            [1] => Paoletti
        )

    [2] => Array
        (
            [0] => Antonio
            [1] => Antonelli
        )

)

// Accesso agli elementi di un vettore
< ? Php
    print_r($anagrafica[0]);
    print_r($anagrafica[3]);
?>

// La funzione print_r mostra l'elemento con key [0] ma non mostra l'elemento [3], perché non esiste.
            Array
(
    [0] => Mario
    [1] => Rossi
)

// Numero di elementi
< ? Php
    echo 'In anagrafica sono presenti ' . count($anagrafica) . ' nomi.';
?>

            In anagrafica sono presenti 4 nomi.
// Utilizzo del ciclo for
< ? Php
    for ($i = 0; $i <= count($anagrafica); $i++) {
        echo $anagrafica[$i][0] . ' ' . $anagrafica[$i][1] . '
'; } ?> // Ciclo for per stampare i nomi presenti in anagrafica ciascuno su una riga, vedi risultato che segue.

Risultato:

Mario Rossi
Giuseppe Verdi
Antonio Antonelli

Paolo Paoletti

Notiamo che l'ordinamento non segue la "posizione" ma avviene secondo la chiave; manca inoltre il quarto elemento con chiave [3], che infatti è stato eliminato dall'array.

Nel prossimo paragrafo parleremo di chiavi alfanumeriche e ciclo foreach, ma prima introduciamo proprio il ciclo foreach al fine di mostrarne i vantaggi con gli arrays. Ripetiamo dunque l'operazione di stampa dei nomi per riga appena vista, ma questa volta invece del ciclo for usiamo il foreach.


// Ciclo foreach per stampare i nomi in anagrafica ciascuno su una riga.
< ? Php
    foreach ($anagrafica as $key => $persona) {
        echo $persona[0] . ' ' . $persona[1] . '
'; } ?>

Risultato:

Mario Rossi
Giuseppe Verdi
Paolo Paoletti
Antonio Antonelli

A differenza del ciclo for, foreach non lavora con un indice numerico che viene passato come chiave numerica (vedi l'esempio del ciclo for con $i), con la conseguenza che in questo caso non abbiamo una riga stampata a vuoto. L'altra conseguenza dell'uso di foreach con chiave $key e valore $persona è che l'ordinamento segue la posizione nell'array e non la chiave numerica. Il foreach infine non richiede il calcolo preliminare della dimensione dell'array.

Chiavi alfanumeriche e ciclo foreach

In questo paragrafo introduciamo gli arrays con chiavi alfanumeriche attraverso alcuni esempi e poi mostriamo come sfruttarli insieme al costrutto di controllo foreach. L'obiettivo è fornire le basi per affrontare il problema dell'ordinamento degli array multidimensionali, di cui parleremo nel terzo paragrafo.


// Distruggiamo gli arrays $anagrafica e $anagrafica2
< ? Php
    unset($anagrafica);
    unset($anagrafica2);
    print_r($anagrafica);
    print_r($anagrafica2);
?>

// Nulla viene stampato perché unset() ha distrutto le variabili.
            
// Dichiarazione e stampa di un array monodimensionale con chiave (da adesso in poi ometteremo la parola "alfanumerica")
< ? Php
    $fatturatoTrimestre = array('primo' => '74500', 'secondo' => '81000', 'terzo' => '66500', 'quarto' => '71000');
    print_r($fatturatoTrimestre);
?>

            Array
(
    [primo] => 74500
    [secondo] => 81000
    [terzo] => 66500
    [quarto] => 71000
)

// Ciclo foreach per stampare gli elementi del vettore
< ? Php
    foreach ($fatturatoTrimestre as $trimestre => $fatturato) {
        echo 'Fatturato del ' . $trimestre . ' trimestre: ' . $fatturato . ' euro
'; } ?>

Risultato:

Fatturato del primo trimestre: 74500 euro
Fatturato del secondo trimestre: 81000 euro
Fatturato del terzo trimestre: 66500 euro
Fatturato del quarto trimestre: 71000 euro

L'ultimo esempio mostra i quattro elementi di un ciclo foreach:

  1. Array ovvero $fatturatoTrimestre
  2. Chiave ovvero $trimestre
  3. Valore ovvero $fatturato
  4. Blocco istruzioni ovvero tutto ciò che è compreso tra le parentesi graffe.

Vediamo adesso come fare alcune semplici operazioni su arrays definiti tramite chiavi.


// Accesso agli elementi di un array
< ? Php
    $fatturatoSemestre = array("primo" => $fatturatoTrimestre['primo'] + $fatturatoTrimestre['secondo'], "secondo" => $fatturatoTrimestre['terzo'] + $fatturatoTrimestre['quarto']);
    foreach ($fatturatoSemestre as $semestre => $fatturato) {
        echo 'Fatturato del ' . $semestre . ' semestre: ' . $fatturato . ' euro
'; } ?>

Risultato:

Fatturato del primo semestre: 155500 euro
Fatturato del secondo semestre: 137500 euro

Adesso definiamo un array bidimensionale con il fatturato mensile e i giorni di lavoro effettivi.


// Nuovo array bidimensionale con fatturato e giorni di lavoro per trimestre
< ? Php
    $tabella['primo'] = array('fatturato' => 76500, 'giorni' => 60);
    $tabella['secondo'] = array('fatturato' => 81000, 'giorni' => 58);
    $tabella['terzo'] = array('fatturato' => 64500, 'giorni' => 47);
    $tabella['quarto'] = array('fatturato' => 71000, 'giorni' => 55);
    print_r($tabella);
?>

// Stampa dell'array $tabella
            Array
(
    [primo] => Array
        (
            [fatturato] => 76500
            [giorni] => 60
        )

    [secondo] => Array
        (
            [fatturato] => 81000
            [giorni] => 58
        )

    [terzo] => Array
        (
            [fatturato] => 64500
            [giorni] => 47
        )

    [quarto] => Array
        (
            [fatturato] => 71000
            [giorni] => 55
        )

)

// Calcolo del fatturato totale e del numero di giorni totali lavorati
< ? Php
    foreach ($tabella as $trimestre => $risultati) {
        $fatturatoAnno += $risultati['fatturato'];
        $giorniAnno += $risultati['giorni'];
    }
    echo 'Fatturato anno: ' . $fatturatoAnno . ' euro
'; echo 'Giorni totali lavorati: ' . $giorniAnno . ' giorni
'; echo 'Fatturato giornaliero medio: ' . round($fatturatoAnno/$giorniAnno, 0) . ' euro al giorno
'; ?>

Risultato:

Fatturato anno: 293000 euro
Giorni totali lavorati: 220 giorni
Fatturato giornaliero medio: 1332 euro al giorno

Il fatturato per giorno riferito a ciascun trimestre si può ottenere dagli altri dati e quindi potremmo non avere convenienza ad archiviarlo. Riportiamo tutti i dati in una tabella.



    foreach ($tabella as $trimestre => $risultati) {
        echo '' . $trimestre . '' . $risultati['fatturato'] . '' . $risultati['giorni'] . '' . round($risultati['fatturato']/$risultati['giorni'], 0) . '';
    }

                        

Risultato:

Risultati trimestrali (tabella)
TrimestreFatturatoGiorni lavorativiFatturato giornaliero
primo76500601275
secondo81000581397
terzo64500471372
quarto71000551291

Ordinamento di vettori con array_multisort

La tabella sopra risulta ordinata per trimestre perchè abbiamo inserito i dati dei diversi trimestri in sequenza dal primo al quarto. Si tratta di un caso particolare e quindi ci poniamo il problema di ordinare i dati della nostra tabella con un diverso criterio. In questo paragrafo usiamo la funzione array_multisort di PHP per portare a termine questo compito.

Prima di partire con l'esempio guardiamo di nuovo al modo in cui abbiamo definito l'array $tabella, che non è l'unico modo che abbiamo per definire un array multidimensionale. Nel corso del paragrafo ripeteremo l'operazione di ordinamento lavorando su array con il medesimo scopo ma con struttura diversa e che chiameremo $tabella, $tabella2, $tabella3, $tabella4, $tabella5.

Partiamo da $tabella.

Esempio 1: $tabella


// Ordiniamo l'array $tabella per fatturato
< ? Php
    // Distruggiamo la variabile $fatturato, ci serviremo dello stesso nome per un array
    unset($fatturato);
    foreach ($tabella as $trimestre => $risultati)
        {
            $fatturato[$trimestre]  = $risultati['fatturato'];
        }
    // Abbiamo creato l'array $fatturato con i fatturati dei trimestri: usiamolo nella funzione array_multisort() per ordinare l'array $tabella in senso descrescente
    array_multisort($fatturato, SORT_DESC, SORT_NUMERIC, $tabella);
    // Stampiamo l'array (che adesso è ordinato per fatturato)
    print_r($tabella);
?>
            Array
(
    [secondo] => Array
        (
            [fatturato] => 81000
            [giorni] => 58
        )

    [primo] => Array
        (
            [fatturato] => 76500
            [giorni] => 60
        )

    [quarto] => Array
        (
            [fatturato] => 71000
            [giorni] => 55
        )

    [terzo] => Array
        (
            [fatturato] => 64500
            [giorni] => 47
        )

)

// Stampiamo la tabella (che adesso si basa su un array ordinato per fatturato)
                        

Risultato:

Risultati trimestrali ordinati per fatturato (tabella)
TrimestreFatturatoGiorni lavorativiFatturato giornaliero
secondo81000581397
primo76500601275
quarto71000551291
terzo64500471372

L'array $tabella ha una struttura che ricorda le tabelle dei database, cosa che si nota anche guardando all'ultima table che presenta i dati di ciascun trimestre in ogni riga (record) con i valori di Trimestre, Fatturato, Giorni lavorativi (campi).

Tramite la funzione array_multisort() possiamo ordinare non soltanto arrays con chiavi alfanumeriche, noti anche con il nome di array associativi, ma anche array non associativi, come nell'esempio seguente. Attenzione: l'esempio mostra che in alcuni casi conviene avere arrays associativi.

Esempio 2: $tabella2

L'array $tabella così come è stato definito sopra è un array associativo multidimensionale. Adesso vogliamo creare un analogo array multidimensionale, con gli stessi dati ma senza le chiavi alfanumeriche, per poi ordinarlo in una table. Per distinguerlo dal precedente chiamiamo questo array $tabella2.


// Definizione dell'array multidimensinoale $tabella2
< ? Php
    $tabella2 = array(array(76500, 60),
        array(81000, 58),
        array(64500, 47),
        array(71000, 55));
// In $tabella2 sono stati inseriti fatturato e giorni lavorativi di ciascun trimestre.
//Stampiamo l'array $tabella2
    print_r($tabella2);
?>

            Array
(
    [0] => Array
        (
            [0] => 76500
            [1] => 60
        )

    [1] => Array
        (
            [0] => 81000
            [1] => 58
        )

    [2] => Array
        (
            [0] => 64500
            [1] => 47
        )

    [3] => Array
        (
            [0] => 71000
            [1] => 55
        )

)
                        

Procediamo all'ordinamento dell'array $tabella2 per fatturato.


< ? Php
    // Distruggiamo la variabile $fatturato, ci serviremo dello stesso nome per un array
    unset($fatturato);
    foreach ($tabella2 as $trimestre => $risultati)
        {
            $fatturato[$trimestre]  = $risultati[0];
        }
    // Abbiamo creato l'array $fatturato con i fatturati dei trimestri. $risultati[0] fornisce i fatturati, mentre se avessimo usato la chiave [1] e cioè $risultati[1] avremmo avuto i giorni lavorativi. Adesso usiamo array_multisort() per ordinare l'array $tabella2 in senso crescente con SORT_ASC.
    array_multisort($fatturato, SORT_ASC, SORT_NUMERIC, $tabella2);
    // Stampiamo l'array (che adesso è ordinato per fatturato)
    print_r($tabella);
?>
            Array
(
    [0] => Array
        (
            [0] => 64500
            [1] => 47
        )

    [1] => Array
        (
            [0] => 71000
            [1] => 55
        )

    [2] => Array
        (
            [0] => 76500
            [1] => 60
        )

    [3] => Array
        (
            [0] => 81000
            [1] => 58
        )

)
// Hai notato nulla di strano nell'array ordinato? Continua a leggere e capirai.
// Stampiamo la tabella (che adesso si basa su un array ordinato per fatturato crescente)
                        

Risultato:

Risultati trimestrali ordinati per fatturato crescente (tabella2)
TrimestreFatturatoGiorni lavorativiFatturato giornaliero
064500471372
171000551291
276500601275
381000581397

Questo esempio mostra chiaramente che la struttura di $tabella2 non è idonea in quanto la corrispondenza tra i vettori monodimensionali che rappresentano i dati di ciascun trimestre e il trimestre stesso è implicitamente definita nella chiave numerica: [1] corrisponde al primo trimestre, [2] al secondo, [3] al terzo e [4] al quarto trimestre. Fin qui la cosa sarebbe ancora accettabile, ma i problemi nascono quando si vanno a trattare i dati.

L'ordinamento tramite array_multisort() su un array non associativo, cioè privo di chiavi alfanumeriche, ha causato la reindicizzazione dell'array con la conseguenza che i dati del primo trimestre (fatturato: 76500, giorni lavorativi: 60) prima dell'ordinamento erano associati alla chiave [0] mentre dopo l'ordinamento sono associati alla chiave [2]!

Questo appena visto è un esempio di come NON trattare i dati con gli array. L'alternativa però non è necessariamente la forma di $tabella. Restano da illustrare tre forme alternative per il nostro ipotetico array dei risultati trimestrali, partiamo da $tabella3.

Esempio 3: $tabella3


// Dichiarazione dell'array $tabella3
< ? Php
    $tabella3 = array(array('primo', 76500, 60),
        array('secondo', 81000, 58),
        array('terzo', 64500, 47),
        array('quarto', 71000, 55));
// In $tabella3 sono stati inseriti il trimestre, il fatturato e i giorni lavorativi.
//Stampiamo l'array $tabella3
    print_r($tabella3);
?>

            Array
(
    [0] => Array
        (
            [0] => primo
            [1] => 76500
            [2] => 60
        )

    [1] => Array
        (
            [0] => secondo
            [1] => 81000
            [2] => 58
        )

    [2] => Array
        (
            [0] => terzo
            [1] => 64500
            [2] => 47
        )

    [3] => Array
        (
            [0] => quarto
            [1] => 71000
            [2] => 55
        )

)

< ? Php
    // Distruggiamo la variabile $fatturato, ci serviremo dello stesso nome per un array
    unset($fatturato);
    foreach ($tabella3 as $trimestre => $risultati)
        {
            $fatturato[$trimestre]  = $risultati[1];
        }
    // Abbiamo creato l'array $fatturato con i fatturati dei trimestri. $risultati[1] fornisce i fatturati, mentre se avessimo usato la chiave [2] e cioè $risultati[2] avremmo avuto i giorni lavorativi. Adesso usiamo array_multisort() per ordinare l'array $tabella3 in senso crescente con SORT_ASC.
    array_multisort($fatturato, SORT_ASC, SORT_NUMERIC, $tabella3);
    // Stampiamo l'array (che adesso è ordinato per fatturato crescente)
    print_r($tabella);
?>
            Array
(
    [0] => Array
        (
            [0] => terzo
            [1] => 64500
            [2] => 47
        )

    [1] => Array
        (
            [0] => quarto
            [1] => 71000
            [2] => 55
        )

    [2] => Array
        (
            [0] => primo
            [1] => 76500
            [2] => 60
        )

    [3] => Array
        (
            [0] => secondo
            [1] => 81000
            [2] => 58
        )

)
// Stampiamo la tabella (che adesso si basa su un array ordinato per fatturato crescente)
                        

Risultato:

Risultati trimestrali ordinati per fatturato crescente (tabella3)
Chiave numericaTrimestreFatturatoGiorni lavorativiFatturato giornaliero
0terzo64500471372
1quarto71000551291
2primo76500601275
3secondo81000581397

La prima colonna della tabella include la chiave numerica del trimestre, mentre i valori che identificano i dati del singolo trimestre, cioè primo, secondo, terzo e quarto, sono in seconda colonna.

I vantaggi di questo sistema sono evidenti: mentre nell'esempio precedente con $tabella2 l'ordinamento ha reindicizzato l'array annullando la corrispondenza tra chiave numerica e dati del trimestre, nel caso di $tabella3 la reindicizzazione dell'array avviene comunque ma non ci danneggia in quanto riusciamo a identificare il trimestre dai valori della seconda colonna, che assumono pertanto un ruolo simile a quello della chiave primaria nelle tabelle dei database, quindi permettono di identificare univocamente il record (nel nostro caso i dati trimestrali).

Esempio 4: $tabella4


// Dichiarazione dell'array $tabella4
< ? Php
    $tabella4['primo'] = array(76500, 60);
    $tabella4['secondo'] = array(81000, 58);
    $tabella4['terzo'] = array(64500, 47);
    $tabella4['quarto'] = array(71000, 55);
// L'array $tabella4 in un certo senso è un ibrido tra $tabella e $tabella2.
//Stampiamo l'array $tabella4
    print_r($tabella4);
?>

            Array
(
    [primo] => Array
        (
            [0] => 76500
            [1] => 60
        )

    [secondo] => Array
        (
            [0] => 81000
            [1] => 58
        )

    [terzo] => Array
        (
            [0] => 64500
            [1] => 47
        )

    [quarto] => Array
        (
            [0] => 71000
            [1] => 55
        )

)

< ? Php
    // Distruggiamo la variabile $fatturato, ci serviremo dello stesso nome per un array
    unset($fatturato);
    foreach ($tabella4 as $trimestre => $risultati)
        {
            $fatturato[$trimestre]  = $risultati[0];
        }
    // Ad ogni iterazione del ciclo foreach la variabile $risultato[0] contiene il relativo valore del fatturato trimestrale
    array_multisort($fatturato, SORT_ASC, SORT_NUMERIC, $tabella4);
    // Stampiamo l'array (che adesso è ordinato per fatturato crescente)
    print_r($tabella4);
?>
            Array
(
    [terzo] => Array
        (
            [0] => 64500
            [1] => 47
        )

    [quarto] => Array
        (
            [0] => 71000
            [1] => 55
        )

    [secondo] => Array
        (
            [0] => 81000
            [1] => 58
        )

    [primo] => Array
        (
            [0] => 76500
            [1] => 60
        )

)
// Stampiamo la tabella (che adesso si basa su un array ordinato per fatturato crescente)
                        

Risultato:

Risultati trimestrali ordinati per fatturato crescente (tabella4)
TrimestreFatturatoGiorni lavorativiFatturato giornaliero
terzo64500471372
quarto71000551291
primo76500601275
secondo81000581397

Esempio 5: $tabella5


// Dichiarazione dell'array $tabella5
< ? Php
    $tabella5[] = array('trimestre'=>'primo', 'fatturato' => 76500, 'giorni' => 60);
    $tabella5[] = array('trimestre'=>'secondo', 'fatturato' => 81000, 'giorni' => 58);
    $tabella5[] = array('trimestre'=>'terzo', 'fatturato' => 64500, 'giorni' => 47);
    $tabella5[] = array('trimestre'=>'quarto', 'fatturato' => 71000, 'giorni' => 55);
// Stampa del vettore $tabella5
    print_r($tabella5);
?>

            Array
(
    [0] => Array
        (
            [trimestre] => primo
            [fatturato] => 76500
            [giorni] => 60
        )

    [1] => Array
        (
            [trimestre] => secondo
            [fatturato] => 81000
            [giorni] => 58
        )

    [2] => Array
        (
            [trimestre] => terzo
            [fatturato] => 64500
            [giorni] => 47
        )

    [3] => Array
        (
            [trimestre] => quarto
            [fatturato] => 71000
            [giorni] => 55
        )

)

< ? Php
    // Distruzione della variabile $fatturato, ci serviremo dello stesso nome per un array
    unset($fatturato);
    foreach ($tabella5 as $trimestre => $risultati)
        {
            $fatturato[$trimestre]  = $risultati['fatturato'];
        }
    // Ordinamento di $tabella5
    array_multisort($fatturato, SORT_ASC, SORT_NUMERIC, $tabella5);
    // Stampa dell'array ordinato per fatturato crescente
    print_r($tabella5);
?>
            Array
(
    [0] => Array
        (
            [trimestre] => terzo
            [fatturato] => 64500
            [giorni] => 47
        )

    [1] => Array
        (
            [trimestre] => quarto
            [fatturato] => 71000
            [giorni] => 55
        )

    [2] => Array
        (
            [trimestre] => primo
            [fatturato] => 76500
            [giorni] => 60
        )

    [3] => Array
        (
            [trimestre] => secondo
            [fatturato] => 81000
            [giorni] => 58
        )

)
// Stampiamo la tabella (che adesso si basa su un array ordinato per fatturato crescente)
                        

Risultato:

Risultati trimestrali ordinati per fatturato crescente (tabella5)
TrimestreFatturatoGiorni lavorativiFatturato giornaliero
terzo64500471372
quarto71000551291
primo76500601275
secondo81000581397

Conclusioni

Gli array multidimensionali sono array in cui gli elementi sono a loro volta array e per questo motivo talvolta si parla di array o vettori annidati. Se le dimensioni sono due i dati si prestano ad essere rappresentati in una tabella con righe e colonne. Gli array bidimensionali associativi, cioè che prevedono chiavi alfanumeriche, sono passibili di una rappresentazione che ricorda le tabelle dei database: una dimensione dell'array corrisponde alle righe delle tabelle ovvero ai record, mentre le chiavi della seconda dimensione corrispondono ai campi. La dichiarazione di un array multidimensionale può avvenire in vari modi, con e senza chiavi alfanumeriche, e occorre scegliere il migliore sia in termini di efficenza (sforzo computazionale, memoria occupata) sia di integrtà dei dati: ordinando l'array, infatti, in seguito alla reindicizzazione l'assenza di chiavi potrebbe avere conseguenze negative.