Come gestire i valori di ritorno multipli in PHP: Array, Tuple e List Destructuring

Introduzione alla gestione dei ritorni multipli in PHP

Nel corso della tua esperienza come sviluppatore PHP, ti troverai spesso in una situazione comune: hai bisogno che una funzione calcoli o recuperi più di un dato. Per esempio, potresti avere una funzione che deve restituire sia il risultato di un'operazione matematica che un messaggio di stato, oppure una funzione che interroga un database e deve restituire sia l'oggetto utente che un codice di errore.

Per definizione, una funzione in PHP può restituire un solo valore tramite l'istruzione return. Tuttavia, questo non significa che siamo limitati a un singolo dato. Il segreto sta nell'utilizzare strutture dati che possano "impacchettare" più valori in un unico contenitore. In questo articolo esploreremo le strategie più efficaci per gestire i ritorni multipli, partendo dagli approcci classici fino alle funzionalità introdotte nelle versioni più recenti di PHP (7.x e 8.x).

L'approccio classico: Gli Array indicizzati

Il modo più semplice e immediato per restituire più valori è l'utilizzo di un array. Invece di restituire un singolo valore, la funzione crea un array che contiene tutti gli elementi necessari e lo restituisce come un unico blocco.

Perché usare gli array indicizzati?

Gli array indicizzati sono rapidi da implementare e non richiedono la definizione di classi o strutture complesse. Sono ideali per piccoli set di dati dove l'ordine dei valori è chiaro e intuitivo.

Ecco un esempio pratico di una funzione che calcola l'area e il perimetro di un rettangolo:

<?php

function calcolaRettangolo($base, $altezza) {
    $area = $base * $altezza;
    $perimetro = 2 * ($base + $altezza);

    // Restituiamo i due valori all'interno di un array indicizzato
    return [$area, $perimetro];
}

// Chiamata alla funzione
$risultati = calcolaRettangolo(10, 5);

echo "Area: " . $risultati[0] . "\
";
echo "Perimetro: " . $risultati[1] . "\
";

?>

In questo esempio, la funzione calcolaRettangolo restituisce un array. Per accedere ai valori, dobbiamo usare gli indici 0 e 1. Sebbene efficace, questo metodo presenta un problema di leggibilità: chi legge il codice non sa immediatamente cosa rappresenti $risultati[0] senza tornare a guardare la definizione della funzione.

Migliorare la leggibilità con gli Array Associativi

Per risolvere il problema della "mancanza di significato" degli indici numerici, PHP offre gli array associativi. Invece di usare numeri, assegniamo a ogni valore una chiave testuale (una stringa) che ne descriva il contenuto.

Vantaggi degli array associativi

L'uso delle chiavi rende il codice auto-documentato. Non importa se l'ordine dei valori cambia; finché la chiave rimane la stessa, il codice che riceve il dato continuerà a funzionare correttamente.

Vediamo come trasformare l'esempio precedente:

<?php

function calcolaRettangoloDettagliato($base, $altezza) {
    return [
        'area' => $base * $altezza,
        'perimetro' => 2 * ($base + $altezza),
        'status' => 'success'
    ];
}

$risultato = calcolaRettangoloDettagliato(10, 5);

// Ora l'accesso è molto più chiaro
echo "L'area calcolata è: " . $risultato['area'] . "\
";
echo "Il perimetro è: " . $risultato['perimetro'] . "\
";

?>

Ora, chiunque legga $risultato['area'] capisce immediatamente cosa stia manipolando. Questo approccio è lo standard per molte API interne in PHP.

La tecnica del Destructuring (List e Square Brackets)

Una delle funzionalità più potenti introdotte per gestire i ritorni multipli è il cosiddetto "destructuring". Questa tecnica permette di "spacchettare" l'array restituito direttamente in variabili separate nel momento stesso in cui viene chiamata la funzione.

Come funziona il destructuring

In passato si usava la funzione list(), ma a partire da PHP 7.1 è possibile utilizzare la sintassi a parentesi quadre [], che è più concisa e simile a quella di JavaScript.

<?php

function ottieniCoordinate() {
    return [45.4642, 9.1900]; // Coordinate di Milano
}

// Destructuring: assegniamo i valori dell'array a due variabili diverse in una riga
[$latitudine, $longitudine] = ottieniCoordinate();

echo "Latitudine: $latitudine, Longitudine: $longitudine";

?>

Questa tecnica è estremamente elegante perché elimina la necessità di accedere agli indici dell'array (come [0] o [1]) nel corpo principale del programma, rendendo il flusso di dati molto più lineare.

Oltre gli array: Oggetti e Data Transfer Objects (DTO)

Quando l'applicazione cresce, affidarsi esclusivamente agli array può diventare rischioso. Gli array non hanno un "tipo" forte: non puoi essere sicuro che una funzione restituisca sempre le chiavi area e perimetro a meno di non scrivere molti controlli manuali.

L'introduzione dei DTO

Un Data Transfer Object (DTO) è una semplice classe utilizzata esclusivamente per trasportare dati tra diverse parti di un sistema. Invece di restituire un array, la funzione restituisce un'istanza di una classe.

<?php

class RettangoloRisultato {
    public float $area;
    public float $perimetro;

    public function __construct(float $area, float $perimetro) {
        $this->area = $area;
        $this->perimetro = $perimetro;
    }
}

function calcolaRettangoloOggetto($base, $altezza): RettangoloRisultato {
    $area = $base * $altezza;
    $perimetro = 2 * ($base + $altezza);

    return new RettangoloRisultato($area, $perimetro);
}

$risultato = calcolaRettangoloOggetto(10, 5);
echo "Area: " . $risultato->area;

?>

Perché usare gli oggetti?

1. Type Hinting: Puoi dichiarare che la funzione restituisce un oggetto di tipo RettangoloRisultato. Se per errore restituisci altro, PHP genererà un errore immediato (TypeError).
2. Auto-completamento: Gli IDE (come VS Code o PhpStorm) sapranno esattamente quali proprietà sono disponibili nell'oggetto, suggerendotele mentre scrivi.
3. Manutenibilità: Se devi aggiungere un terzo valore (es. l'ipotenusa), puoi farlo nella classe senza rompere la logica di chi riceve l'oggetto.

Esempi pratici: Casi d'uso reali

Caso 1: Gestione di Errori e Risultati

Spesso vogliamo che una funzione restituisca il risultato di un'operazione, ma anche un booleano che indichi se l'operazione è riuscita.

function salvaUtente($dati) {
    if (empty($dati['email'])) {
        return ['success' => false, 'message' => 'Email mancante'];
    }
    // Logica di salvataggio...
    return ['success' => true, 'message' => 'Utente salvato con successo', 'id' => 123];
}

[$success, $msg] = salvaUtente(['nome' => 'Mario']); // Esempio di errore

Caso 2: Parsing di stringhe complesse

Immagina di dover dividere una stringa che contiene nome e cognome in due variabili separate.

function separaNomeCognome($stringa) {
    $parti = explode(' ', $stringa, 2);
    return $parti[0] ?? '', $parti[1] ?? '';
}
// Nota: In PHP non puoi fare return a, b; devi usare l'array come visto sopra

Errori comuni e FAQ

1. Dimenticare di inizializzare le variabili nel destructuring

Se una funzione restituisce un array con 2 elementi, ma tu provi a spacchettarne 3, PHP genererà un avviso (Notice: Undefined offset). Assicurati che il numero di variabili a sinistra del = corrisponda a quello di elementi restituiti.

2. Confondere Array e Oggetti

Un errore comune per i principianti è provare ad accedere a un array usando la freccia ($array->chiave) o a un oggetto usando le parentesi quadre ($oggetto['chiave']). Ricorda:

• Array $ ightarrow$ ['chiave']
• Oggetti $ ightarrow$ ->proprietà

3. Usare troppi ritorni multipli

Se una funzione restituisce 5 o 6 valori diversi, probabilmente quella funzione sta facendo troppe cose. In programmazione, questo viola il "Single Responsibility Principle" (Principio di Singola Responsabilità). Se i ritorni sono troppi, considera di dividere la funzione in due o più funzioni più piccole.

Conclusioni e Prossimi Passi

Gestire i valori di ritorno multipli in PHP è un'abilità fondamentale per scrivere codice pulito e professionale. Abbiamo visto che:

• Gli array indicizzati sono rapidi ma poco leggibili.
• Gli array associativi migliorano la chiarezza grazie alle chiavi.
• Il destructuring ([]) rende l'assegnazione delle variabili estremamente fluida.
• I DTO (Oggetti) sono la soluzione migliore per progetti di medie e grandi dimensioni grazie alla tipizzazione forte.

Cosa studiare ora? Per approfondire ulteriormente la gestione dei dati in PHP, ti consiglio di esplorare i seguenti argomenti:

1. Le Eccezioni (Try-Catch): Invece di restituire un array con ['success' => false], impara a "lanciare" un'eccezione quando qualcosa va storto.
2. Le Proprietà Promosse (PHP 8.0): Scopri come rendere i tuoi DTO ancora più sintetici utilizzando la promozione delle proprietà nel costruttore.
3. I Tipi di Unione (Union Types): Impara a definire funzioni che possono restituire tipi diversi (es. int|string).

Pratica questi concetti creando un piccolo progetto, come un calcolatore di tasse o un sistema di gestione utenti, dove ogni funzione restituisce un oggetto di risultato strutturato. Buon coding!