PHP Academy · Lezione

Funzioni anonime e closure

Scrivere funzioni inline e catturare variabili con use.

Funzioni anonime e closure è una lezione PHP Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento PHP Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso PHP Academy include 4 lezioni in totale.

Che cosa sono le funzioni anonime?

Una funzione anonima (lambda) è una funzione senza nome. In PHP è un'istanza della classe integrata Closure e può essere memorizzata in una variabile, passata come argomento o restituita da un'altra funzione.

Funzione anonima di base

Assegni una funzione a una variabile e la chiami:

<?php
$double = function(int $n): int {
    return $n * 2;
};

echo $double(5);   // 10
echo $double(21);  // 42

Passare funzioni anonime

Passi una closure come argomento a funzioni come array_map, usort o ai propri callback:

<?php
$nums = [3, 1, 4, 1, 5, 9];

$squared = array_map(function(int $n): int {
    return $n ** 2;
}, $nums);

print_r($squared); // [9, 1, 16, 1, 25, 81]

Restituire funzioni

Una funzione può creare e restituire una closure: questo è il pattern factory:

<?php
function makeMultiplier(int $factor): Closure {
    return function(int $n) use ($factor): int {
        return $n * $factor;
    };
}

$triple  = makeMultiplier(3);
$tenX    = makeMultiplier(10);

echo $triple(5);   // 15
echo $tenX(5);     // 50

Closure e use

Le closure possono acquisire variabili dall'ambito esterno con use. L'acquisizione avviene per valore (copia), a meno che non si aggiunga &:

<?php
$taxRate = 0.18;

$addTax = function(float $price) use ($taxRate): float {
    return $price * (1 + $taxRate);
};

$taxRate = 0.20;  // change outer variable
echo $addTax(100); // 118 — captured value at creation time

Acquisizione per riferimento con use(&)

Per consentire alla closure di vedere i valori esterni aggiornati, acquisisca la variabile per riferimento:

<?php
$count = 0;

$increment = function() use (&$count): void {
    $count++;
};

$increment();
$increment();
echo $count;  // 2

Funzioni freccia (PHP 7.4)

Le funzioni freccia sono closure compatte a espressione singola che acquisiscono automaticamente l'ambito esterno per valore:

<?php
$rate = 1.18;
$prices = [10, 20, 30];

// Arrow function — no 'use' needed
$withTax = array_map(fn($p) => $p * $rate, $prices);

print_r($withTax); // [11.8, 23.6, 35.4]

Le funzioni freccia non possono modificare l'ambito esterno

Le funzioni freccia acquisiscono solo per valore: non possono modificare le variabili esterne:

<?php
$total = 0;
$nums  = [1, 2, 3];

// This does NOT modify $total!
array_walk($nums, fn($n) => $total += $n);

echo $total;  // 0

// Use a reference closure for mutation:
array_walk($nums, function($n) use (&$total) { $total += $n; });
echo $total;  // 6

Closure come callback

Molte funzioni PHP accettano un callable: è possibile passare una closure, un array [$obj, 'method'] o il nome di una funzione sotto forma di stringa:

<?php
$words = ['banana', 'apple', 'cherry'];

usort($words, fn($a, $b) => strcmp($a, $b));

print_r($words); // ['apple', 'banana', 'cherry']

Closure invocata immediatamente

È possibile definire e chiamare una closure sulla stessa riga, una soluzione utile per creare un ambito isolato:

<?php
$result = (function(): int {
    $x = 10;
    $y = 20;
    return $x + $y;
})();

echo $result; // 30
// $x and $y are not in outer scope

Closure::bind e bindTo

È possibile ricollegare una closure al contesto di un altro oggetto usando Closure::bind():

<?php
class Counter {
    private int $value = 0;
}

$increment = Closure::bind(function(int $by): void {
    $this->value += $by;
}, new Counter(), Counter::class);

// Now $increment has access to private $value

Verifica rapida

Qual è la differenza principale tra una closure normale con use e una funzione freccia in PHP?

Riepilogo: funzioni anonime e closure

Riepilogo:

Le funzioni anonime vengono memorizzate nelle variabili e passate ad altre parti del programma
Le closure acquisiscono le variabili esterne con use($var) (per valore) o use(&$var) (per riferimento)
Le funzioni freccia (PHP 7.4) acquisiscono automaticamente l'ambito esterno per valore
Sono utili per i callback: array_map, usort, array_filter…
Possono essere restituite dalle funzioni factory

Domande Frequenti

La lezione «Funzioni anonime e closure» è gratuita?

Sì — il testo completo di «Funzioni anonime e closure» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso PHP Academy, passa a CoddyKit PRO. Il corso PHP Academy include 4 lezioni in totale.

Cosa imparerò in «Funzioni anonime e closure»?

Scrivere funzioni inline e catturare variabili con use. Eserciti PHP Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare PHP Academy?

Non è richiesta alcuna esperienza precedente. PHP Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Funzioni anonime e closure»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione PHP Academy?

Sì. Ogni lezione PHP Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

Definire e chiamare funzioni
Parametri predefiniti e variadici
Ambito delle variabili: locale e globale
Funzioni anonime e closure

← Torna a PHP Academy