Admin: Skapade sidan med '== First class callable syntax == Den nya first class callable-syntaxen introducerades i PHP 8.1.0 som ett sätt att skapa anonyma funktioner från callable. Den ersätter den befintliga callable-syntaxen som använder strängar och arrayer. Fördelen med denna syntax är att den är tillgänglig för statisk analys och använder omfånget vid den tidpunkt då callable skapas. Syntaxen `CallableExpr(...)` används för att skapa ett Closure-objekt från callable. `Calla...'

2024-08-18T18:31:16Z

Skapade sidan med '== First class callable syntax == Den nya first class callable-syntaxen introducerades i PHP 8.1.0 som ett sätt att skapa anonyma funktioner från callable. Den ersätter den befintliga callable-syntaxen som använder strängar och arrayer. Fördelen med denna syntax är att den är tillgänglig för statisk analys och använder omfånget vid den tidpunkt då callable skapas. Syntaxen `CallableExpr(...)` används för att skapa ett Closure-objekt från callable. `Calla...'

Ny sida

== First class callable syntax ==
Den nya first class callable-syntaxen introducerades i PHP 8.1.0 som ett sätt att skapa anonyma funktioner från callable. Den ersätter den befintliga callable-syntaxen som använder strängar och arrayer. Fördelen med denna syntax är att den är tillgänglig för statisk analys och använder omfånget vid den tidpunkt då callable skapas.

Syntaxen `CallableExpr(...)` används för att skapa ett Closure-objekt från callable. `CallableExpr` accepterar alla uttryck som kan anropas direkt i PHP-syntaxen:

=== Exempel #1 Enkel first class callable syntax ===
<pre>
<?php

class Foo {
public function method() {}
public static function staticmethod() {}
public function __invoke() {}
}

$obj = new Foo();
$classStr = 'Foo';
$methodStr = 'method';
$staticmethodStr = 'staticmethod';

$f1 = strlen(...);
$f2 = $obj(...); // invokerbart objekt
$f3 = $obj->method(...);
$f4 = $obj->$methodStr(...);
$f5 = Foo::staticmethod(...);
$f6 = $classStr::$staticmethodStr(...);

// traditionell callable som använder sträng, array
$f7 = 'strlen'(...);
$f8 = [$obj, 'method'](...);
$f9 = [Foo::class, 'staticmethod'](...);
?>
</pre>
'''Notera:'''

'''...''' är en del av syntaxen, och inte en utelämning.

`CallableExpr(...)` har samma semantik som `Closure::fromCallable()`. Det vill säga, till skillnad från callable som använder strängar och arrayer, respekterar `CallableExpr(...)` omfånget vid den tidpunkt då det skapas:

=== Exempel #2 Jämförelse av omfång mellan `CallableExpr(...)` och traditionell callable ===
<pre>
<?php

class Foo {
public function getPrivateMethod() {
return [$this, 'privateMethod'];
}

private function privateMethod() {
echo __METHOD__, "\n";
}
}

$foo = new Foo;
$privateMethod = $foo->getPrivateMethod();
$privateMethod();
// Fatal error: Anrop till privat metod Foo::privateMethod() från globalt omfång
// Detta beror på att anropet utförs utanför Foo och synligheten kommer att kontrolleras från denna punkt.

class Foo1 {
public function getPrivateMethod() {
// Använder omfånget där callable skapas.
return $this->privateMethod(...); // identiskt med Closure::fromCallable([$this, 'privateMethod']);
}

private function privateMethod() {
echo __METHOD__, "\n";
}
}

$foo1 = new Foo1;
$privateMethod = $foo1->getPrivateMethod();
$privateMethod(); // Foo1::privateMethod
?>
</pre>

'''Notera:'''

Objektskapande med denna syntax (t.ex. `new Foo(...)`) stöds inte, eftersom `new Foo()`-syntaxen inte betraktas som ett anrop.

'''Notera:'''

Den first-class callable-syntaxen kan inte kombineras med nullsafe-operatorn. Båda följande exempel resulterar i ett kompileringsfel:

<pre>
<?php
$obj?->method(...);
$obj?->prop->method(...);
?>
</pre>
= Sidslut =
Orginalhemsidan på Engelska :
<BR>[[PHP]]
<BR>[[Språkreferens]]
<BR>[[Språkreferens#Funktioner]]
[[Kategori:Php]]

Första klassens kallbara syntax - Versionshistorik