Php стрелочные функции многострочные

Стрелочные функции появились в PHP 7.4, как более лаконичный синтаксис для анонимных функций.

Основной вид записи стрелочных функций: fn (argument_list) => expr .

Стрелочные функции поддерживают те же возможности, что и анонимные функции, за исключением того, что использование переменных из родительской области всегда выполняется автоматически.

Когда переменная, используемая в выражении, определена в родительской области, она будет неявно захвачена по значению. В следующем примере функции $fn1 и $fn2 ведут себя одинаково.

Пример #1 Стрелочные функции захватывают переменные по значению автоматически

$fn1 = fn ( $x ) => $x + $y ;
// эквивалентно использованию $y по значению:
$fn2 = function ( $x ) use ( $y ) return $x + $y ;
>;

Результат выполнения данного примера:

Это также работает во вложенных стрелочных функциях:

Пример #2 Стрелочные функции захватывают переменные по значению автоматически, даже когда они вложены

$z = 1 ;
$fn = fn ( $x ) => fn ( $y ) => $x * $y + $z ;
// Выведет 51
var_export ( $fn ( 5 )( 10 ));
?>

Подобно анонимным функциям, синтаксис стрелочных функций допускает произвольные сигнатуры функций, включая типы параметров и возвращаемых значений, значения по умолчанию, переменные, а также передачу и возврат по ссылке. Ниже приведены корректные примеры стрелочных функций:

Пример #3 Примеры использования стрелочных функций

fn (array $x ) => $x ;
static fn (): int => $x ;
fn ( $x = 42 ) => $x ;
fn (& $x ) => $x ;
fn &( $x ) => $x ;
fn ( $x , . $rest ) => $rest ;

Стрелочные функции используют привязку переменных по значению. Это примерно эквивалентно выполнению use($x) для каждой переменной $x , используемой внутри стрелочной функции. Привязка по значению означает, что невозможно изменить какие-либо значения из внешней области. Вместо этого можно использовать анонимные функции для привязок по ссылкам.

Пример #4 Значения из внешней области видимости не могут быть изменены стрелочными функциями

$x = 1 ;
$fn = fn () => $x ++; // Ничего не изменит
$fn ();
var_export ( $x ); // Выведет 1

Список изменений

Версия	Описание
7.4.0	Стали доступны стрелочные функции.

Примечания

User Contributed Notes 5 notes

Unlike anonymous functions, arrow functions cannot have a void return type declaration.

May seem obvious, but if you thought you could make use of the benefits of arrow functions (using variables from the parent scope) to simplify a function or method call, keep in mind that this is only possible if you do NOT tell PHP that the arrow function does indeed return void.

In example 4 (Values from the outer scope cannot be modified by arrow functions)

$x = 1 ;
$fn = fn () => $x ++; // Has no effect
$fn ();
var_export ( $x ); // Outputs 1

Here we can use reference variable in fn(&$x) and pass the value from function call $fn($x) so that we will get the output as expected with out using Anonymous functions.

$x = 1 ;
$fn = fn (& $x ) => $x ++;
$fn ( $x );
var_export ( $x );

But here it will not take values from parent scope automatically but we have to pass them explicitly.

As you already know, variable bindings occur in arrow functions by «by-value». That means, an arrow function returns a copy of the value of the variable used in it from the outer scope.

Now let us see an example of how a arrow function returns a reference instead of a copy of a value.

$fn = fn &(& $x ) => $x ; // Returns a reference

$y = & $fn ( $x ); // Now $y represents the reference

$y = 3 ; // Changing value of $y affects $x

Beware compact() not being able to access (import) variables from external scope (known in versions: 7.4.0, 7.4.8) (bug: https://bugs.php.net/bug.php?id=78970).

A workaround is available — use the variable directly; this will cause it to be imported into the arrow function’s namespace and make it available to the compact() too.

$aa = 111 ;
$accessing_variable_works = fn ( $bb ) => [ $aa , $bb ];
$compact_is_broken = fn ( $bb ) => compact ( ‘aa’ , ‘bb’ );
$compact_can_work_with_workaround = fn ( $bb ) => compact ( ‘aa’ , ‘bb’ ) + [ ‘workaround’ => $aa ];
var_dump ( $accessing_variable_works ( 333 ));
var_dump ( $compact_is_broken ( 555 ));
var_dump ( $compact_can_work_with_workaround ( 777 ));
?>

result:
array(2) [0]=>
int(111)
[1]=>
int(333)
>
PHP Notice: compact(): Undefined variable: aa in /home/m/vlt/guitar/tlb/s/public_html/index.php on line 9
array(1) [«bb»]=>
int(555)
>
array(3) [«aa»]=>
int(111)
[«bb»]=>
int(777)
[«workaround»]=>
int(111)
>

( fn ( $x ) => print( $x ))( 2 ); // Outputs 2

Источник

Стрелочные функции в PHP

Краткие анонимные функции, они же, стрелочные функции — один простой способ быстрого и простого синтаксиса описания функции в PHP. Запись в таком формате удобна и полезна, когда мы описываем функцию для функций array_map , array_filter , или им подобным.

Вот, как выглядит эта запись:

// массив пользователей $users = [/*. */]; $ids = array_map(fn($user) => $user->id, $users);

Вместо старого синтаксиса:

$users = [/*. */]; $ids = array_map(function($user) < return $user->id; >, $users);

Итого, теперь давайте проясним особенности использования стрелочных функций в PHP:

Они становятся доступными в PHP 7.4
Функции начинаются с ключевого слова fn
Они могут иметь только одно выражение, которое являет собой return выражение
Не нужно указывать ключевое слово return
Функциям могут задаваться возвращаемые типы и типы аргументам

Например, рассмотрим пример описания стрелочной функции с указанием типов аргумента и возврата:

$users = [/*. */]; $ids = array_map(fn(User $user): int => $user->id, $users);

Стоит так же отметить 2 ключевые особенности:

В таких функциях доступен оператор распаковки аргументов (Spread)
Ссылки разрешены как в качестве аргументов, так и в качестве возвращаемых значений

Если вы хотите вернуть значение по ссылке, вы должны использовать синтаксис, показанный ниже:

Если коротко описать их функциональность, то стрелочные функции в PHP имеют те же функциональные возможности, что и обычные анонимные функции, за исключением того, что они описываются только одним выражением.

Скажи нет многострочным функциям

Работая с JavaScript, в ваших глазах может проснуться надежда на то, что в PHP так же можно описать стрелочную функцию указывая несколько выражений. Однако, это не так, и на протяжении всей статья и повторяю одну и ту же идею: стрелочная функция описывается в одну строку, и вы не можете использовать несколько строк для её описания.

Причина кроется в том, что цель коротких замыканий — уменьшить длину синтаксиса их создания. Благодаря ключевому слову fn , и пропуск return , запись функций, однозначно, стала короче. А сам создатель RFC, Никита Попов, говорит, что если вы работаете с многострочными функциями, то с помощью стрелочных функций вы получите меньше выгоды от этого, потому, было принято решение отказаться от этой возможности.

В конце концов, многострочные стрелочные функции, по определению, являются длинными и многословными, что не совсем соответствует концепции короткой анонимной функции. И одно лишь упущение оператора return и замена ключевого слова function на fn , не вносит существенной разницы и профита.

Соглашаться с этим мнение или нет — решать вам. Остаётся только терпеть, использоваться и довольствоваться тем, что имеем ^^. Хотя надежда есть: в будущем, возможно, будет предусмотрена возможность создания многострочных стрелочных функций.

Значения из внешней области

Ещё одно существенное различие между короткими и обычными анонимными функциями заключается в том, что для стрелочных функций не требуется ключевое слово use для доступа к данным из внешней области видимости.

$modifier = 5; array_map(fn($x) => $x * $modifier, $numbers);

Важно отметить, что вы не можете изменять переменные из внешней области видимости. Значения передаются значением, а не ссылкой. Это означает, что вы можете изменить переменную $modifier в пределах заданной функции, однако это не повлияет изменение переменной $modifier во внешней области видимости.

Исключением является ключевое слово $this , которое действует точно так же, как и в обычных анонимных функциях:

array_map(fn($x) => $x * $this->modifier, $numbers);

Будущие возможности

Я уже упоминал о многострочных стрелочных функциях, которые по-прежнему возможны в будущих версиях PHP. Но ещё одна обсуждаемая идея — использование короткого синтаксиса функций в классах, например для методов геттеров и сеттеров:

В общем, стрелочные функции в PHP — желанное и полезное обновление, хотя есть ещё пространство для их улучшения. Самым большим из них, вероятно, являются добавление многостраничных стрелочных функций.

Дополнительные примеры

Вот пример того, как мы делали раньше, и как это выглядит по новому синтаксису:

$extended = function ($c) use ($callable, $factory) < return $callable($factory($c), $c); >; //со стрелочной функцией: $extended = fn($c) => $callable($factory($c), $c);

А в Laravel это выглядит так:

// Сейчас $users->map(function($user) < return $user->first_name.' '.$user->last_name; >); // Со стрелочной функцией $users->map( fn($user) => $user->first_name.' '.$user->last_name );

Резюме

В этой статье вы узнали, какие возможности определения функций были добавлены в PHP 7.4, как работать со стрелочными функциями в PHP, как создать многостраничную стрелочную функцию в PHP, с какой версии они появились, и что нового появится в ближайшем, вероятном будущем. Следите за обновлениями, обновляйте ПО, учите новое и внедряйте новинки.

В серці. Назавжди.

Вчора у мене помер однокласник. А сьогодні бабуся. І хто б міг уявити, що цей рік принесе війну, смерть товариша, та смерть члена сім’ї? Це боляче. Проте це добре нагадування про те, як швидко тече час. І як його ціна збільшується кожної марно витраченої секунди. І я не скажу щось

Ось такий він, руський мир

«Руський мир» — звучить дуже сильно та виправдовуюче. Гарна обгортка виправдання слабкості, аморальності та нікчемності своїх дійсних намірів. Руський мир, який дуже солодко звучить для всіх, хто хоче закрити очі на факт повномасштабної війни. Дуже добре виправдання вбивства для купки звірів. Втім, це ж росія, в якій все виглядає логічно

Перехват запросов и ответов JavaScript Fetch API

Перехватчики — это блоки кода, которые вы можете использовать для предварительной или последующей обработки HTTP-вызовов, помогая в обработке глобальных ошибок, аутентификации, логирования, изменения тела запроса и многом другом. В этой статье вы узнаете, как перехватывать вызовы JavaScript Fetch API. Есть два типа событий, для которых вы можете захотеть перехватить HTTP-вызовы:

Источник