No PHP, o que é um fechamento e por que ele usa o identificador "use"?

Estou verificando alguns PHP 5.3.0recursos e deparei com um código no site que parece bem engraçado:

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);
}

como um dos exemplos de funções anônimas .

Alguém sabe sobre isso? Alguma documentação? E parece mal, deveria ser usado?

É assim que o PHP expressa um fechamento . Isso não é nada mau e, de fato, é bastante poderoso e útil.

Basicamente, o que isso significa é que você está permitindo que a função anônima "capture" variáveis ​​locais (neste caso, $taxe uma referência a $total) fora do escopo e preserve seus valores (ou no caso da $totalreferência a $totalsi mesma) como estado dentro a própria função anônima.

Uma resposta mais simples.

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

1. O fechamento é uma função atribuída a uma variável, para que você possa passá-lo
2. Um fechamento é um espaço para nome separado; normalmente, você não pode acessar variáveis ​​definidas fora deste espaço para nome. Aí vem opalavra-chave use :
3. usar permite acessar (usar) as variáveis ​​seguintes dentro do fechamento.
4. usar é obrigatório. Isso significa que os valores das variáveis ​​são COPIADOS após DEFINIR o fechamento. Portanto, modificar $taxdentro do fechamento não tem efeito externo, a menos que seja um ponteiro, como um objeto.
5. Você pode passar variáveis ​​como ponteiros, como no caso de &$total . Dessa forma, modificando o valor de $totalTEM UM efeito externo, o valor da variável original muda.
6. As variáveis ​​definidas dentro do fechamento também não são acessíveis de fora do fechamento.
7. Fechamentos e funções têm a mesma velocidade. Sim, você pode usá-los em todos os seus scripts.

Como o @Mytskine apontou, provavelmente a melhor explicação detalhada é a RFC para fechamentos . (Vote nele por isso.)

o function () use () {} fechamento é semelhante ao PHP.

Sem use, a função não pode acessar a variável de escopo pai

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

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

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

$f(); // hello

O usevalor da variável é de quando a função é definida, não quando chamada

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

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

use variável por referência com &

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

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

fechamentos são lindos! eles resolvem muitos problemas que vêm com funções anônimas e tornam possíveis códigos realmente elegantes (pelo menos enquanto falamos sobre php).

programadores javascript usam fechamentos o tempo todo, às vezes até sem saber, porque as variáveis ​​vinculadas não são explicitamente definidas - é para isso que serve o "uso" no php.

existem melhores exemplos do mundo real do que o anterior. digamos que você precise classificar uma matriz multidimensional por um subvalor, mas a chave muda.

<?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);
?>

aviso: código não testado (eu não tenho o php5.3 instalado no atm), mas deve se parecer com algo assim.

há uma desvantagem: muitos desenvolvedores de php podem ficar um pouco impotentes se você os confrontar com fechamentos.

para entender melhor a boa aparência dos fechamentos, darei outro exemplo - desta vez em javascript. um dos problemas é o escopo e a assincronia inerente ao navegador. especialmente, se for window.setTimeout();(ou -interval). então, você passa uma função para setTimeout, mas não pode realmente fornecer nenhum parâmetro, porque fornecer parâmetros executa o código!

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 retorna uma função com um tipo de parâmetro predefinido!

para ser sincero, eu gosto muito mais de php desde 5.3 e funções / fechamentos anônimos. os namespaces podem ser mais importantes, mas são muito menos sexy .

O Zupa fez um ótimo trabalho explicando fechamentos com 'use' e a diferença entre EarlyBinding e Referencing as variáveis ​​que são 'usadas'.

Então, eu fiz um exemplo de código com ligação antecipada de uma variável (= cópia):

<?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
*/

?>

Exemplo com referência a uma variável (observe o caractere '&' antes da variável);

<?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
*/

?>

Até anos muito recentes, o PHP definiu seu interpretador AST e PHP isolou o analisador da parte da avaliação. Durante o tempo em que o fechamento é introduzido, o analisador do PHP é altamente associado à avaliação.

Portanto, quando o fechamento foi introduzido pela primeira vez no PHP, o intérprete não tem método para saber quais variáveis ​​serão usadas no fechamento, porque ele ainda não foi analisado. Portanto, o usuário precisa agradar o mecanismo do zend por importação explícita, fazendo o dever de casa que o zend deve fazer.

Essa é a chamada maneira simples em PHP.