Der PHP-Kern bietet anonyme Funktionen

Vorgeschlagen

Vor dem Aufkommen anonymer Funktionen mussten alle Funktionen benannt werden, bevor sie verwendet werden konnten

function increment($value)
{
    return $value + 1;
}
array_map('increment', [1, 2, 3]);

Manchmal muss eine Funktion nur verwendet werden Durch die Verwendung anonymer Funktionen wird der Code prägnanter und intuitiver und verhindert auch, dass die Funktion an anderer Stelle verwendet wird Funktionen sind äquivalente Konzepte (in diesem Artikel gemeinsam als anonyme Funktionen bezeichnet) und im Wesentlichen als Funktionen getarnte Objekte.

Die Essenz anonymer Funktionen sind Objekte, daher können anonyme Funktionen genau wie Objekte einer Variablen zugewiesen werden

array_map(function($value){
    return $value + 1;
}, [1, 2, 3]);

Alle anonymen Funktionen sind Instanzen von Closure-Objekten

$greet = function(string $name){
    echo "hello {$name}";
}
$greet("jack") // hello jack

Die Das Objekt hat keinen nennenswerten übergeordneten Bereich, daher müssen Sie use verwenden, um die verwendeten Variablen manuell zu deklarieren.

$greet instanceof Closure // true

Wenn Sie möchten, dass die Variablen in der anonymen Funktion wirksam werden, müssen Sie die Referenzübergabe verwenden -value

$num = 1;
$func = function() use($num){
    $num = $num + 1;
    echo $num;
}
$func();  // 2
echo $num;  // 还是 1

Ab PHP 5.4 wird bei Verwendung einer anonymen Funktion in einer Klasse $this der anonymen Funktion automatisch an die aktuelle Klasse gebunden

$num = 1;
$func = function() use(&$num){
    $num = $num + 1;
    echo $num;
}
$func();  // 2
echo $num;  // 2

Wenn Sie nicht möchten Damit die automatische Bindung wirksam wird, können Sie eine statische anonyme Funktion verwenden

class Foo {
    public function bar()
    {   
        return function() {
            return $this;
        };
    }
}
$foo = new Foo();
$obj = $foo->bar(); // Closure()
$obj();   // Foo

Die Essenz anonymer Funktionen

Die Essenz anonymer Funktionen ist das Closure-Objekt, das Folgendes enthält die folgenden fünf Methoden

class Foo {
    public function bar()
    {   
        return static function() {
            return $this;
        };
    }
}
$foo = new Foo();
$obj = $foo->bar(); // Closure()
$obj();   // Using $this when not in object context

__construct – Verhindern Sie, dass anonyme Funktionen instanziiert werden

Closure {
    private __construct ( void )
    public static bind ( Closure $closure , object $newthis [, mixed $newscope = "static" ] ) : Closure
    public bindTo ( object $newthis [, mixed $newscope = "static" ] ) : Closure
    public call ( object $newthis [, mixed $... ] ) : mixed
    public static fromCallable ( callable $callable ) : Closure
}

Closure::bindTo – Kopiert das aktuelle anonyme Funktionsobjekt und bindet das angegebene $this-Objekt und den angegebenen Klassenbereich . Laienhaft ausgedrückt bedeutet dies, dass Sie eine anonyme Funktion manuell an ein bestimmtes Objekt binden. Auf diese Weise können Sie die Funktionalität des Objekts erweitern.

$closure = new \Closure();
// PHP Error:  Instantiation of 'Closure' is not allowed

Closure::bind – eine statische Version der bindTo-Methode mit zwei Verwendungszwecken:

Verwendung 1: Erzielen Sie den gleichen Effekt wie die bindTo-Methode

// 定义商品类
class Good {
    private $price;
    public function __construct(float $price)
    {
        $this->price = $price;
    }
}
// 定义一个匿名函数，计算商品的促销价
$addDiscount = function(float $discount = 0.8){
    return $this->price * $discount;
}
$good = new Good(100);
// 将匿名函数绑定到 $good 实例，同时指定作用域为 Good
$count = $addDiscount->bindTo($good, Good::class); 
$count(); // 80
// 将匿名函数绑定到 $good 实例，但是不指定作用域，将无法访问 $good 的私有属性
$count = $addDiscount->bindTo($good); 
$count(); // 报错

Verwendung 2: Binden Sie die anonyme Funktion an die Klasse (anstelle des Objekts). Denken Sie daran, den zweiten Parameter auf null zu setzen

$count = \Closure::bind($addDiscount, $good, Good::class);

Aufruf – PHP 7 Neu Die Call-Methode kann anonyme Funktionen binden und aufrufen. Neben einer einfacheren Syntax ist auch die Leistung höher

// 商品库存为 10
class Good {
    static $num = 10;
}
// 每次销售后返回当前库存
$sell = static function() {
    return"当前库存为". --static::$num ;
};
// 将静态匿名函数绑定到 Good 类中
$sold = \Closure::bind($sell, null, Good::class);
$sold(); // 当前库存为 9
$sold(); // 当前库存为 8

fromCallable – Konvertieren Sie die angegebene aufrufbare Funktion in eine anonyme Funktion

// call 版本
$addDiscount->call($good, 0.5);  // 绑定并传入参数 0.5，结果为 50
// bindTo 版本
$count = $addDiscount->bindTo($good, Good::class, 0.5); 
$count(); // 50

fromCallable entspricht

class Good {
    private $price;
    public function __construct(float $price)
    {
        $this->price = $price;
    }
}
function addDiscount(float $discount = 0.8){
    return $this->price * $discount;
}
$closure = \Closure::fromCallable('addDiscount');
$good = new Good(100);
$count = $closure->bindTo($good);  
$count = $closure->bindTo($good, Good::class);   // 报错，不能重复绑定作用域
$count(); // 报错，无法访问私有属性

Eine Sache, die hier besonders beachtet werden muss, ist, ob es sich um den von Callable konvertierten Abschluss oder den durch Reflektion erhaltenen Abschluss handelt, wenn bindTo verwendet wird, wenn der zweite Parameter die Bindungsklasse angibt , es wird ein Fehler gemeldet

$reflexion = new ReflectionFunction('addDiscount');
$closure = $reflexion->getClosure();

Das obige ist der detaillierte Inhalt vonDer PHP-Kern bietet anonyme Funktionen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!