PHP 8.1 introduces a new feature - a level-one callable syntax, allowing developers to refer to functions or methods as closures more concisely. 1. Through the fn() syntax or... operator, developers can directly convert existing functions or methods into real Closure objects without manually encapsulating or using Closure::fromCallable(); 2. This feature is suitable for advanced function scenarios such as array_map, policy mode, etc. that require callbacks to be passed; 3. Notes include: slight performance overhead, no automatic inheritance of parent variable scope, and only support PHP 8.1 and above. This feature improves the readability and maintenance of the code.

In PHP 8.1, a first-class callable syntax is a new feature that allows developers to reference functions or methods as closings without having to manually wrap them in a closure or use Closure::fromCallable() . This makes it easier and cleaner to pass functions around as values.

How First-Class Callable Syntax Works

Prior to PHP 8.1, if you wanted to pass a function as a callback, you had to either define it inline or use an array syntax like [SomeClass::class, 'someMethod'] , which wasn't actually a closure until invoked. Now, with the fn() syntax, you can directly convert any callable into a closure instance:

 $callable = fn($x) => $x * 2;

This creates a closure from an anonymous function immediately. But more importantly for first-class calls, you can now reference existing functions and methods using this same syntax in a slightly different way.

Cleaner Way to Reference Existing Functions

One of the most useful aspects of this feature is referencing existing named functions or object methods without needing to write extra code.

For example:

 function greet($name) {
    echo "Hello, $name";
}

$greetFunction = greet(...); // This creates a closure from the greet function
$greetFunction('John'); // Outputs: Hello, John

Here, greet(...) is shortand syntax that tells PHP to take the greet function and turn it into a proper closure. This works with static methods, instance methods, and even namespaced functions.

Some key points about this syntax:

• It's concise and avoids boilerplate.
• The resulting value is a true Closure object.
• You can pass these closings around just like any other variable.

Use Cases and Practical Benefits

This feature becomes especially handy when working with higher-order functions — functions that accept other functions as arguments or return them.

Common scenarios include:

• Passing callsbacks to array functions like array_map , array_filter , etc.
• Implementing strategies or command patterns where behavior needs to be swapped dynamically.
• Creating decorator-like wrappers around functions or methods.

Let's say you're mapping over an array:

 $numbers = [1, 2, 3];
$squared = array_map(fn($n) => $n ** 2, $numbers);

Or if you have a predefined function:

 function formatName($name) {
    return ucfirst(strtolower($name));
}

$names = ['ALICE', 'BOB'];
$formattedNames = array_map(formatName(...), $names);

Now $formattedNames will contain ['Alice', 'Bob'] .

Before PHP 8.1, you would have needed to pass 'formatName' as a string or use Closure::fromCallable() , both of which were less expressive or more verbose.

Things to Watch Out For

While this feature simplifies many patterns, there are a few caveats to keep in mind:

• Performance considerations : There might be a tiny overhead compared to direct inline closings, but it's negligible for most applications.
• Variable scope : Unlike traditional anonymous functions, first-class callable syntax doesn't import variables from the parent scope automatically. If you need access to external variables, you'll still need to use the full fn($x) => ... form.
• Backward compatibility : Since this is only available in PHP 8.1 , make sure your project supports that version before adopting it widely.

So while it looks simple on the surface, the first-class callable syntax brings real improvements to how readable and maintainable PHP code can be.

Basically that's it.

The above is the detailed content of What is a first-class callable syntax in PHP 8.1?. For more information, please follow other related articles on the PHP Chinese website!