En PHP, qu'est-ce qu'une fermeture et pourquoi utilise-t-elle l'identifiant «use»?

Je vérifie certaines PHP 5.3.0fonctionnalités et j'ai parcouru du code sur le site qui a l'air assez drôle:

public function getTotal($tax)
{
    $total = 0.00;

    $callback =
        /* This line here: */
        function ($quantity, $product) use ($tax, &$total)
        {
            $pricePerItem = constant(__CLASS__ . "::PRICE_" .
                strtoupper($product));
            $total += ($pricePerItem * $quantity) * ($tax + 1.0);
        };

    array_walk($this->products, $callback);
    return round($total, 2);
}

comme l'un des exemples de fonctions anonymes .

Quelqu'un le sait-il? Une documentation? Et il a l'air mauvais, devrait-il jamais être utilisé?

C'est ainsi que PHP exprime une fermeture . Ce n'est pas mal du tout et en fait c'est assez puissant et utile.

Fondamentalement, cela signifie que vous autorisez la fonction anonyme à "capturer" des variables locales (dans ce cas, $taxet une référence à $total) en dehors de sa portée et à conserver leurs valeurs (ou dans le cas de $totalla référence à $totalelle-même) comme état dans la fonction anonyme elle-même.

Une réponse plus simple.

function ($quantity) use ($tax, &$total) { .. };

1. La fermeture est une fonction affectée à une variable, vous pouvez donc la faire circuler
2. Une fermeture est un espace de noms distinct, normalement, vous ne pouvez pas accéder aux variables définies en dehors de cet espace de noms. Voici le mot-clé use :
3. use vous permet d'accéder (utiliser) aux variables suivantes à l'intérieur de la fermeture.
4. l'utilisation est une liaison anticipée. Cela signifie que les valeurs variables sont COPIÉES lors de la DÉFINITION de la fermeture. Ainsi, la modification$taxà l'intérieur de la fermeture n'a aucun effet externe, sauf s'il s'agit d'un pointeur, comme un objet.
5. Vous pouvez passer des variables comme pointeurs comme dans le cas de &$total. De cette façon, en modifiant la valeur de $totalDOES ONT un effet externe, la valeur de la variable d'origine change.
6. Les variables définies à l'intérieur de la fermeture ne sont pas non plus accessibles depuis l'extérieur de la fermeture.
7. Les fermetures et les fonctions ont la même vitesse. Oui, vous pouvez les utiliser partout dans vos scripts.

Comme l'a souligné @Mytskine , la meilleure explication approfondie est probablement le RFC pour les fermetures . (Le voter pour cela.)

le function () use () {} comme la fermeture de PHP.

Sans use, la fonction ne peut pas accéder à la variable de portée parent

$s = "hello";
$f = function () {
    echo $s;
};

$f(); // Notice: Undefined variable: s

$s = "hello";
$f = function () use ($s) {
    echo $s;
};

$f(); // hello

La usevaleur de la variable est à partir du moment où la fonction est définie, pas lorsqu'elle est appelée

$s = "hello";
$f = function () use ($s) {
    echo $s;
};

$s = "how are you?";
$f(); // hello

use référence par variable avec &

$s = "hello";
$f = function () use (&$s) {
    echo $s;
};

$s = "how are you?";
$f(); // how are you?

les fermetures sont belles! ils résolvent beaucoup de problèmes qui viennent avec des fonctions anonymes et rendent possible un code vraiment élégant (au moins aussi longtemps que nous parlons de php).

les programmeurs javascript utilisent des fermetures tout le temps, parfois même sans le savoir, car les variables liées ne sont pas explicitement définies - c'est à cela que sert "utilisation" en php.

il y a de meilleurs exemples du monde réel que celui ci-dessus. disons que vous devez trier un tableau multidimensionnel par une sous-valeur, mais la clé change.

<?php
    function generateComparisonFunctionForKey($key) {
        return function ($left, $right) use ($key) {
            if ($left[$key] == $right[$key])
                return 0;
            else
                return ($left[$key] < $right[$key]) ? -1 : 1;
        };
    }

    $myArray = array(
        array('name' => 'Alex', 'age' => 70),
        array('name' => 'Enrico', 'age' => 25)
    );

    $sortByName = generateComparisonFunctionForKey('name');
    $sortByAge  = generateComparisonFunctionForKey('age');

    usort($myArray, $sortByName);

    usort($myArray, $sortByAge);
?>

avertissement: code non testé (je n'ai pas php5.3 installé atm), mais il devrait ressembler à quelque chose comme ça.

il y a un inconvénient: beaucoup de développeurs php peuvent être un peu impuissants si vous les confrontez à des fermetures.

pour mieux comprendre la beauté des fermetures, je vais vous donner un autre exemple - cette fois en javascript. l'un des problèmes est la portée et l'asynchronité inhérente au navigateur. surtout s'il s'agit de window.setTimeout();(ou -interval). vous passez donc une fonction à setTimeout, mais vous ne pouvez pas vraiment donner de paramètres, car fournir des paramètres exécute le code!

function getFunctionTextInASecond(value) {
    return function () {
        document.getElementsByName('body')[0].innerHTML = value; // "value" is the bound variable!
    }
}

var textToDisplay = prompt('text to show in a second', 'foo bar');

// this returns a function that sets the bodys innerHTML to the prompted value
var myFunction = getFunctionTextInASecond(textToDisplay);

window.setTimeout(myFunction, 1000);

myFunction renvoie une fonction avec une sorte de paramètre prédéfini!

pour être honnête, j'aime beaucoup plus PHP depuis 5.3 et les fonctions / fermetures anonymes. les espaces de noms peuvent être plus importants, mais ils sont beaucoup moins sexy .

Zupa a fait un excellent travail en expliquant les fermetures avec «utilisation» et la différence entre EarlyBinding et référencement des variables qui sont «utilisées».

J'ai donc fait un exemple de code avec liaison anticipée d'une variable (= copie):

<?php

$a = 1;
$b = 2;

$closureExampleEarlyBinding = function() use ($a, $b){
    $a++;
    $b++;
    echo "Inside \$closureExampleEarlyBinding() \$a = ".$a."<br />";
    echo "Inside \$closureExampleEarlyBinding() \$b = ".$b."<br />";    
};

echo "Before executing \$closureExampleEarlyBinding() \$a = ".$a."<br />";
echo "Before executing \$closureExampleEarlyBinding() \$b = ".$b."<br />";  

$closureExampleEarlyBinding();

echo "After executing \$closureExampleEarlyBinding() \$a = ".$a."<br />";
echo "After executing \$closureExampleEarlyBinding() \$b = ".$b."<br />";

/* this will output:
Before executing $closureExampleEarlyBinding() $a = 1
Before executing $closureExampleEarlyBinding() $b = 2
Inside $closureExampleEarlyBinding() $a = 2
Inside $closureExampleEarlyBinding() $b = 3
After executing $closureExampleEarlyBinding() $a = 1
After executing $closureExampleEarlyBinding() $b = 2
*/

?>

Exemple de référencement d'une variable (notez le caractère '&' avant la variable);

<?php

$a = 1;
$b = 2;

$closureExampleReferencing = function() use (&$a, &$b){
    $a++;
    $b++;
    echo "Inside \$closureExampleReferencing() \$a = ".$a."<br />";
    echo "Inside \$closureExampleReferencing() \$b = ".$b."<br />"; 
};

echo "Before executing \$closureExampleReferencing() \$a = ".$a."<br />";
echo "Before executing \$closureExampleReferencing() \$b = ".$b."<br />";   

$closureExampleReferencing();

echo "After executing \$closureExampleReferencing() \$a = ".$a."<br />";
echo "After executing \$closureExampleReferencing() \$b = ".$b."<br />";    

/* this will output:
Before executing $closureExampleReferencing() $a = 1
Before executing $closureExampleReferencing() $b = 2
Inside $closureExampleReferencing() $a = 2
Inside $closureExampleReferencing() $b = 3
After executing $closureExampleReferencing() $a = 2
After executing $closureExampleReferencing() $b = 3
*/

?>

Jusqu'à très récemment, PHP a défini son AST et l'interpréteur PHP a isolé l'analyseur de la partie évaluation. Pendant le temps où la fermeture est introduite, l'analyseur PHP est fortement couplé avec l'évaluation.

Par conséquent, lorsque la fermeture a été introduite pour la première fois en PHP, l'interpréteur n'a aucune méthode pour savoir quelles variables seront utilisées dans la fermeture, car elle n'est pas encore analysée. L'utilisateur doit donc satisfaire le moteur zend par importation explicite, en faisant les devoirs que devrait faire zend.

Il s'agit de la méthode dite simple en PHP.