ГЛИБШЕ · ПЕРЕКЛАДЕНО оновлено 18 вересня 2026

Хелпери · Laravel

Вступ

Laravel містить набір глобальних «хелперних» PHP-функцій. Багато з них використовує сам фреймворк, але ніщо не заважає застосовувати їх і у власних застосунках, якщо вони вам зручні.

Доступні методи

Масиви й обʼєкти

`Arr::accessible()`

Метод Arr::accessible визначає, чи є передане значення доступним як масив:

use Illuminate\Support\Arr;
use Illuminate\Support\Collection;

$isAccessible = Arr::accessible(['a' => 1, 'b' => 2]);

// true

$isAccessible = Arr::accessible(new Collection);

// true

$isAccessible = Arr::accessible('abc');

// false

$isAccessible = Arr::accessible(new stdClass);

// false

`Arr::add()`

Метод Arr::add додає до масиву задану пару ключ / значення, якщо такого ключа в масиві ще немає або його значення дорівнює null:

use Illuminate\Support\Arr;

$array = Arr::add(['name' => 'Desk'], 'price', 100);

// ['name' => 'Desk', 'price' => 100]

$array = Arr::add(['name' => 'Desk', 'price' => null], 'price', 100);

// ['name' => 'Desk', 'price' => 100]

`Arr::array()`

Метод Arr::array дістає значення з глибоко вкладеного масиву за «крапковою» нотацією (так само, як Arr::get()), але кидає InvalidArgumentException, якщо запитане значення не є array:

use Illuminate\Support\Arr;

$array = ['name' => 'Joe', 'languages' => ['PHP', 'Ruby']];

$value = Arr::array($array, 'languages');

// ['PHP', 'Ruby']

$value = Arr::array($array, 'name');

// throws InvalidArgumentException

`Arr::boolean()`

Метод Arr::boolean дістає значення з глибоко вкладеного масиву за «крапковою» нотацією (так само, як Arr::get()), але кидає InvalidArgumentException, якщо запитане значення не є boolean:

use Illuminate\Support\Arr;

$array = ['name' => 'Joe', 'available' => true];

$value = Arr::boolean($array, 'available');

// true

$value = Arr::boolean($array, 'name');

// throws InvalidArgumentException

`Arr::collapse()`

Метод Arr::collapse згортає масив масивів або колекцій в один масив:

use Illuminate\Support\Arr;

$array = Arr::collapse([[1, 2, 3], [4, 5, 6], [7, 8, 9]]);

// [1, 2, 3, 4, 5, 6, 7, 8, 9]

`Arr::crossJoin()`

Метод Arr::crossJoin перехресно обʼєднує передані масиви, повертаючи декартів добуток з усіма можливими комбінаціями:

use Illuminate\Support\Arr;

$matrix = Arr::crossJoin([1, 2], ['a', 'b']);

/*
    [
        [1, 'a'],
        [1, 'b'],
        [2, 'a'],
        [2, 'b'],
    ]
*/

$matrix = Arr::crossJoin([1, 2], ['a', 'b'], ['I', 'II']);

/*
    [
        [1, 'a', 'I'],
        [1, 'a', 'II'],
        [1, 'b', 'I'],
        [1, 'b', 'II'],
        [2, 'a', 'I'],
        [2, 'a', 'II'],
        [2, 'b', 'I'],
        [2, 'b', 'II'],
    ]
*/

`Arr::divide()`

Метод Arr::divide повертає два масиви: один із ключами, другий зі значеннями переданого масиву:

use Illuminate\Support\Arr;

[$keys, $values] = Arr::divide(['name' => 'Desk']);

// $keys: ['name']

// $values: ['Desk']

`Arr::dot()`

Метод Arr::dot розгортає багатовимірний масив в одновимірний, де глибина позначена «крапковою» нотацією:

use Illuminate\Support\Arr;

$array = ['products' => ['desk' => ['price' => 100]]];

$flattened = Arr::dot($array);

// ['products.desk.price' => 100]

`Arr::every()`

Метод Arr::every перевіряє, що всі значення масиву проходять задану перевірку:

use Illuminate\Support\Arr;

$array = [1, 2, 3];

Arr::every($array, fn ($i) => $i > 0);

// true

Arr::every($array, fn ($i) => $i > 2);

// false

`Arr::except()`

Метод Arr::except видаляє з масиву задані пари ключ / значення:

use Illuminate\Support\Arr;

$array = ['name' => 'Desk', 'price' => 100];

$filtered = Arr::except($array, ['price']);

// ['name' => 'Desk']

`Arr::exceptValues()`

Метод Arr::exceptValues видаляє з масиву вказані значення:

use Illuminate\Support\Arr;

$array = ['foo', 'bar', 'baz', 'qux'];

$filtered = Arr::exceptValues($array, ['foo', 'baz']);

// ['bar', 'qux']

Щоб під час фільтрації використовувалося строге порівняння типів, передайте true в аргумент strict:

use Illuminate\Support\Arr;

$array = [1, '1', 2, '2'];

$filtered = Arr::exceptValues($array, [1, 2], strict: true);

// ['1', '2']

`Arr::exists()`

Метод Arr::exists перевіряє, чи існує заданий ключ у переданому масиві:

use Illuminate\Support\Arr;

$array = ['name' => 'John Doe', 'age' => 17];

$exists = Arr::exists($array, 'name');

// true

$exists = Arr::exists($array, 'salary');

// false

`Arr::first()`

Метод Arr::first повертає перший елемент масиву, який проходить задану перевірку:

use Illuminate\Support\Arr;

$array = [100, 200, 300];

$first = Arr::first($array, function (int $value, int $key) {
    return $value >= 150;
});

// 200

Третім параметром методу можна передати значення за замовчуванням. Воно повернеться, якщо жодне значення не пройде перевірку:

use Illuminate\Support\Arr;

$first = Arr::first($array, $callback, $default);

`Arr::flatten()`

Метод Arr::flatten розгортає багатовимірний масив в одновимірний:

use Illuminate\Support\Arr;

$array = ['name' => 'Joe', 'languages' => ['PHP', 'Ruby']];

$flattened = Arr::flatten($array);

// ['Joe', 'PHP', 'Ruby']

`Arr::float()`

Метод Arr::float дістає значення з глибоко вкладеного масиву за «крапковою» нотацією (так само, як Arr::get()), але кидає InvalidArgumentException, якщо запитане значення не є float:

use Illuminate\Support\Arr;

$array = ['name' => 'Joe', 'balance' => 123.45];

$value = Arr::float($array, 'balance');

// 123.45

$value = Arr::float($array, 'name');

// throws InvalidArgumentException

`Arr::forget()`

Метод Arr::forget видаляє задані пари ключ / значення з глибоко вкладеного масиву за «крапковою» нотацією:

use Illuminate\Support\Arr;

$array = ['products' => ['desk' => ['price' => 100]]];

Arr::forget($array, 'products.desk');

// ['products' => []]

`Arr::from()`

Метод Arr::from перетворює різні типи вхідних даних на звичайний PHP-масив. Він підтримує масиви, обʼєкти та кілька поширених інтерфейсів Laravel, зокрема Arrayable, Enumerable, Jsonable і JsonSerializable. Також він обробляє екземпляри Traversable і WeakMap:

use Illuminate\Support\Arr;

Arr::from((object) ['foo' => 'bar']); // ['foo' => 'bar']

class TestJsonableObject implements Jsonable
{
    public function toJson($options = 0)
    {
        return json_encode(['foo' => 'bar']);
    }
}

Arr::from(new TestJsonableObject); // ['foo' => 'bar']

`Arr::get()`

Метод Arr::get дістає значення з глибоко вкладеного масиву за «крапковою» нотацією:

use Illuminate\Support\Arr;

$array = ['products' => ['desk' => ['price' => 100]]];

$price = Arr::get($array, 'products.desk.price');

// 100

Метод Arr::get також приймає значення за замовчуванням, яке повернеться, якщо вказаного ключа в масиві немає:

use Illuminate\Support\Arr;

$discount = Arr::get($array, 'products.desk.discount', 0);

// 0

`Arr::has()`

Метод Arr::has перевіряє наявність у масиві заданого елемента або елементів за «крапковою» нотацією:

use Illuminate\Support\Arr;

$array = ['product' => ['name' => 'Desk', 'price' => 100]];

$contains = Arr::has($array, 'product.name');

// true

$contains = Arr::has($array, ['product.price', 'product.discount']);

// false

`Arr::hasAll()`

Метод Arr::hasAll визначає, чи існують у переданому масиві всі вказані ключі, використовуючи «крапкову» нотацію:

use Illuminate\Support\Arr;

$array = ['name' => 'Taylor', 'language' => 'PHP'];

Arr::hasAll($array, ['name']); // true
Arr::hasAll($array, ['name', 'language']); // true
Arr::hasAll($array, ['name', 'IDE']); // false

`Arr::hasAny()`

Метод Arr::hasAny перевіряє, чи існує в масиві хоч один елемент із заданого набору, використовуючи «крапкову» нотацію:

use Illuminate\Support\Arr;

$array = ['product' => ['name' => 'Desk', 'price' => 100]];

$contains = Arr::hasAny($array, 'product.name');

// true

$contains = Arr::hasAny($array, ['product.name', 'product.discount']);

// true

$contains = Arr::hasAny($array, ['category', 'product.discount']);

// false

`Arr::integer()`

Метод Arr::integer дістає значення з глибоко вкладеного масиву за «крапковою» нотацією (так само, як Arr::get()), але кидає InvalidArgumentException, якщо запитане значення не є int:

use Illuminate\Support\Arr;

$array = ['name' => 'Joe', 'age' => 42];

$value = Arr::integer($array, 'age');

// 42

$value = Arr::integer($array, 'name');

// throws InvalidArgumentException

`Arr::isAssoc()`

Метод Arr::isAssoc повертає true, якщо переданий масив асоціативний. Масив вважається «асоціативним», якщо він не має послідовних числових ключів, що починаються з нуля:

use Illuminate\Support\Arr;

$isAssoc = Arr::isAssoc(['product' => ['name' => 'Desk', 'price' => 100]]);

// true

$isAssoc = Arr::isAssoc([1, 2, 3]);

// false

`Arr::isList()`

Метод Arr::isList повертає true, якщо ключі переданого масиву є послідовними цілими числами, що починаються з нуля:

use Illuminate\Support\Arr;

$isList = Arr::isList(['foo', 'bar', 'baz']);

// true

$isList = Arr::isList(['product' => ['name' => 'Desk', 'price' => 100]]);

// false

`Arr::join()`

Метод Arr::join обʼєднує елементи масиву рядком. Третім аргументом можна задати окремий розділювач для останнього елемента масиву:

use Illuminate\Support\Arr;

$array = ['Tailwind', 'Alpine', 'Laravel', 'Livewire'];

$joined = Arr::join($array, ', ');

// Tailwind, Alpine, Laravel, Livewire

$joined = Arr::join($array, ', ', ', and ');

// Tailwind, Alpine, Laravel, and Livewire

`Arr::keyBy()`

Метод Arr::keyBy робить ключами масиву значення заданого ключа. Якщо кілька елементів мають однаковий ключ, у новому масиві залишиться тільки останній:

use Illuminate\Support\Arr;

$array = [
    ['product_id' => 'prod-100', 'name' => 'Desk'],
    ['product_id' => 'prod-200', 'name' => 'Chair'],
];

$keyed = Arr::keyBy($array, 'product_id');

/*
    [
        'prod-100' => ['product_id' => 'prod-100', 'name' => 'Desk'],
        'prod-200' => ['product_id' => 'prod-200', 'name' => 'Chair'],
    ]
*/

`Arr::last()`

Метод Arr::last повертає останній елемент масиву, який проходить задану перевірку:

use Illuminate\Support\Arr;

$array = [100, 200, 300, 110];

$last = Arr::last($array, function (int $value, int $key) {
    return $value >= 150;
});

// 300

Третім аргументом методу можна передати значення за замовчуванням. Воно повернеться, якщо жодне значення не пройде перевірку:

use Illuminate\Support\Arr;

$last = Arr::last($array, $callback, $default);

`Arr::map()`

Метод Arr::map проходить масивом і передає кожне значення та ключ у заданий колбек. Значення масиву замінюється тим, що повернув колбек:

use Illuminate\Support\Arr;

$array = ['first' => 'james', 'last' => 'kirk'];

$mapped = Arr::map($array, function (string $value, string $key) {
    return ucfirst($value);
});

// ['first' => 'James', 'last' => 'Kirk']

`Arr::mapSpread()`

Метод Arr::mapSpread проходить масивом і передає значення кожного вкладеного елемента в задане замикання. Замикання може змінити елемент і повернути його, формуючи новий масив змінених елементів:

use Illuminate\Support\Arr;

$array = [
    [0, 1],
    [2, 3],
    [4, 5],
    [6, 7],
    [8, 9],
];

$mapped = Arr::mapSpread($array, function (int $even, int $odd) {
    return $even + $odd;
});

/*
    [1, 5, 9, 13, 17]
*/

`Arr::mapWithKeys()`

Метод Arr::mapWithKeys проходить масивом і передає кожне значення в заданий колбек. Колбек має повернути асоціативний масив з однією парою ключ / значення:

use Illuminate\Support\Arr;

$array = [
    [
        'name' => 'John',
        'department' => 'Sales',
        'email' => '[email protected]',
    ],
    [
        'name' => 'Jane',
        'department' => 'Marketing',
        'email' => '[email protected]',
    ]
];

$mapped = Arr::mapWithKeys($array, function (array $item, int $key) {
    return [$item['email'] => $item['name']];
});

/*
    [
        '[email protected]' => 'John',
        '[email protected]' => 'Jane',
    ]
*/

`Arr::only()`

Метод Arr::only повертає з переданого масиву лише вказані пари ключ / значення:

use Illuminate\Support\Arr;

$array = ['name' => 'Desk', 'price' => 100, 'orders' => 10];

$slice = Arr::only($array, ['name', 'price']);

// ['name' => 'Desk', 'price' => 100]

`Arr::onlyValues()`

Метод Arr::onlyValues повертає з масиву лише вказані значення:

use Illuminate\Support\Arr;

$array = ['foo', 'bar', 'baz', 'qux'];

$filtered = Arr::onlyValues($array, ['foo', 'baz']);

// ['foo', 'baz']

Щоб під час фільтрації використовувалося строге порівняння типів, передайте true в аргумент strict:

use Illuminate\Support\Arr;

$array = [1, '1', 2, '2'];

$filtered = Arr::onlyValues($array, [1, 2], strict: true);

// [1, 2]

`Arr::partition()`

Метод Arr::partition у поєднанні з деструктуризацією масивів PHP розділяє елементи, що проходять задану перевірку, і ті, що її не проходять:

<?php

use Illuminate\Support\Arr;

$numbers = [1, 2, 3, 4, 5, 6];

[$underThree, $equalOrAboveThree] = Arr::partition($numbers, function (int $i) {
    return $i < 3;
});

dump($underThree);

// [1, 2]

dump($equalOrAboveThree);

// [3, 4, 5, 6]

`Arr::pluck()`

Метод Arr::pluck дістає з масиву всі значення за заданим ключем:

use Illuminate\Support\Arr;

$array = [
    ['developer' => ['id' => 1, 'name' => 'Taylor']],
    ['developer' => ['id' => 2, 'name' => 'Abigail']],
];

$names = Arr::pluck($array, 'developer.name');

// ['Taylor', 'Abigail']

Можна також вказати, за яким ключем формувати результат:

use Illuminate\Support\Arr;

$names = Arr::pluck($array, 'developer.name', 'developer.id');

// [1 => 'Taylor', 2 => 'Abigail']

`Arr::prepend()`

Метод Arr::prepend додає елемент на початок масиву:

use Illuminate\Support\Arr;

$array = ['one', 'two', 'three', 'four'];

$array = Arr::prepend($array, 'zero');

// ['zero', 'one', 'two', 'three', 'four']

За потреби можна вказати ключ, який слід використати для значення:

use Illuminate\Support\Arr;

$array = ['price' => 100];

$array = Arr::prepend($array, 'Desk', 'name');

// ['name' => 'Desk', 'price' => 100]

`Arr::prependKeysWith()`

Метод Arr::prependKeysWith додає заданий префікс до всіх імен ключів асоціативного масиву:

use Illuminate\Support\Arr;

$array = [
    'name' => 'Desk',
    'price' => 100,
];

$keyed = Arr::prependKeysWith($array, 'product.');

/*
    [
        'product.name' => 'Desk',
        'product.price' => 100,
    ]
*/

`Arr::pull()`

Метод Arr::pull повертає пару ключ / значення і видаляє її з масиву:

use Illuminate\Support\Arr;

$array = ['name' => 'Desk', 'price' => 100];

$name = Arr::pull($array, 'name');

// $name: Desk

// $array: ['price' => 100]

Третім аргументом методу можна передати значення за замовчуванням. Воно повернеться, якщо ключа не існує:

use Illuminate\Support\Arr;

$value = Arr::pull($array, $key, $default);

`Arr::push()`

Метод Arr::push додає елемент до масиву за «крапковою» нотацією. Якщо за вказаним ключем масиву немає, його буде створено:

use Illuminate\Support\Arr;

$array = [];

Arr::push($array, 'office.furniture', 'Desk');

// $array: ['office' => ['furniture' => ['Desk']]]

`Arr::query()`

Метод Arr::query перетворює масив на рядок запиту:

use Illuminate\Support\Arr;

$array = [
    'name' => 'Taylor',
    'order' => [
        'column' => 'created_at',
        'direction' => 'desc'
    ]
];

Arr::query($array);

// name=Taylor&order[column]=created_at&order[direction]=desc

`Arr::random()`

Метод Arr::random повертає випадкове значення з масиву:

use Illuminate\Support\Arr;

$array = [1, 2, 3, 4, 5];

$random = Arr::random($array);

// 4 - (отримано випадково)

Другим необовʼязковим аргументом можна вказати кількість елементів, які потрібно повернути. Зверніть увагу: з цим аргументом метод поверне масив, навіть якщо потрібен лише один елемент:

use Illuminate\Support\Arr;

$items = Arr::random($array, 2);

// [2, 5] - (отримано випадково)

`Arr::reject()`

Метод Arr::reject видаляє з масиву елементи за допомогою заданого замикання:

use Illuminate\Support\Arr;

$array = [100, '200', 300, '400', 500];

$filtered = Arr::reject($array, function (string|int $value, int $key) {
    return is_string($value);
});

// [0 => 100, 2 => 300, 4 => 500]

`Arr::select()`

Метод Arr::select вибирає з масиву масив значень:

use Illuminate\Support\Arr;

$array = [
    ['id' => 1, 'name' => 'Desk', 'price' => 200],
    ['id' => 2, 'name' => 'Table', 'price' => 150],
    ['id' => 3, 'name' => 'Chair', 'price' => 300],
];

Arr::select($array, ['name', 'price']);

// [['name' => 'Desk', 'price' => 200], ['name' => 'Table', 'price' => 150], ['name' => 'Chair', 'price' => 300]]

`Arr::set()`

Метод Arr::set встановлює значення всередині глибоко вкладеного масиву за «крапковою» нотацією:

use Illuminate\Support\Arr;

$array = ['products' => ['desk' => ['price' => 100]]];

Arr::set($array, 'products.desk.price', 200);

// ['products' => ['desk' => ['price' => 200]]]

`Arr::shuffle()`

Метод Arr::shuffle випадково перемішує елементи масиву:

use Illuminate\Support\Arr;

$array = Arr::shuffle([1, 2, 3, 4, 5]);

// [3, 2, 5, 1, 4] - (згенеровано випадково)

`Arr::sole()`

Метод Arr::sole дістає з масиву одне значення за допомогою заданого замикання. Якщо перевірку проходить більше одного значення масиву, буде кинуто виняток Illuminate\Support\MultipleItemsFoundException. Якщо перевірку не проходить жодне значення, буде кинуто виняток Illuminate\Support\ItemNotFoundException:

use Illuminate\Support\Arr;

$array = ['Desk', 'Table', 'Chair'];

$value = Arr::sole($array, fn (string $value) => $value === 'Desk');

// 'Desk'

`Arr::some()`

Метод Arr::some перевіряє, що принаймні одне значення масиву проходить задану перевірку:

use Illuminate\Support\Arr;

$array = [1, 2, 3];

Arr::some($array, fn ($i) => $i > 2);

// true

`Arr::sort()`

Метод Arr::sort сортує масив за його значеннями:

use Illuminate\Support\Arr;

$array = ['Desk', 'Table', 'Chair'];

$sorted = Arr::sort($array);

// ['Chair', 'Desk', 'Table']

Масив також можна відсортувати за результатами заданого замикання:

use Illuminate\Support\Arr;

$array = [
    ['name' => 'Desk'],
    ['name' => 'Table'],
    ['name' => 'Chair'],
];

$sorted = array_values(Arr::sort($array, function (array $value) {
    return $value['name'];
}));

/*
    [
        ['name' => 'Chair'],
        ['name' => 'Desk'],
        ['name' => 'Table'],
    ]
*/

`Arr::sortDesc()`

Метод Arr::sortDesc сортує масив за його значеннями у спадному порядку:

use Illuminate\Support\Arr;

$array = ['Desk', 'Table', 'Chair'];

$sorted = Arr::sortDesc($array);

// ['Table', 'Desk', 'Chair']

Масив також можна відсортувати за результатами заданого замикання:

use Illuminate\Support\Arr;

$array = [
    ['name' => 'Desk'],
    ['name' => 'Table'],
    ['name' => 'Chair'],
];

$sorted = array_values(Arr::sortDesc($array, function (array $value) {
    return $value['name'];
}));

/*
    [
        ['name' => 'Table'],
        ['name' => 'Desk'],
        ['name' => 'Chair'],
    ]
*/

`Arr::sortRecursive()`

Метод Arr::sortRecursive рекурсивно сортує масив, застосовуючи функцію sort до підмасивів із числовими індексами і функцію ksort до асоціативних підмасивів:

use Illuminate\Support\Arr;

$array = [
    ['Roman', 'Taylor', 'Li'],
    ['PHP', 'Ruby', 'JavaScript'],
    ['one' => 1, 'two' => 2, 'three' => 3],
];

$sorted = Arr::sortRecursive($array);

/*
    [
        ['JavaScript', 'PHP', 'Ruby'],
        ['one' => 1, 'three' => 3, 'two' => 2],
        ['Li', 'Roman', 'Taylor'],
    ]
*/

Якщо потрібен результат у спадному порядку, скористайтеся методом Arr::sortRecursiveDesc.

$sorted = Arr::sortRecursiveDesc($array);

`Arr::string()`

Метод Arr::string дістає значення з глибоко вкладеного масиву за «крапковою» нотацією (так само, як Arr::get()), але кидає InvalidArgumentException, якщо запитане значення не є string:

use Illuminate\Support\Arr;

$array = ['name' => 'Joe', 'languages' => ['PHP', 'Ruby']];

$value = Arr::string($array, 'name');

// Joe

$value = Arr::string($array, 'languages');

// throws InvalidArgumentException

`Arr::take()`

Метод Arr::take повертає новий масив із вказаною кількістю елементів:

use Illuminate\Support\Arr;

$array = [0, 1, 2, 3, 4, 5];

$chunk = Arr::take($array, 3);

// [0, 1, 2]

Можна також передати відʼємне ціле число, щоб узяти вказану кількість елементів з кінця масиву:

$array = [0, 1, 2, 3, 4, 5];

$chunk = Arr::take($array, -2);

// [4, 5]

`Arr::toCssClasses()`

Метод Arr::toCssClasses умовно збирає рядок CSS-класів. Метод приймає масив класів, де ключ масиву містить клас або класи, які потрібно додати, а значення є булевим виразом. Якщо елемент масиву має числовий ключ, він завжди потрапляє до згенерованого списку класів:

use Illuminate\Support\Arr;

$isActive = false;
$hasError = true;

$array = ['p-4', 'font-bold' => $isActive, 'bg-red' => $hasError];

$classes = Arr::toCssClasses($array);

/*
    'p-4 bg-red'
*/

`Arr::toCssStyles()`

Метод Arr::toCssStyles умовно збирає рядок CSS-стилів. Метод приймає масив CSS-декларацій, де ключ масиву містить CSS-декларацію, яку потрібно додати, а значення є булевим виразом. Якщо елемент масиву має числовий ключ, він завжди потрапляє до зібраного рядка CSS-стилів:

use Illuminate\Support\Arr;

$hasColor = true;

$array = ['background-color: blue', 'color: blue' => $hasColor];

$classes = Arr::toCssStyles($array);

/*
    'background-color: blue; color: blue;'
*/

На цьому методі побудована можливість Laravel обʼєднувати класи з мішком атрибутів Blade-компонента, а також Blade-директива @class.

`Arr::undot()`

Метод Arr::undot розгортає одновимірний масив, що використовує «крапкову» нотацію, у багатовимірний:

use Illuminate\Support\Arr;

$array = [
    'user.name' => 'Kevin Malone',
    'user.occupation' => 'Accountant',
];

$array = Arr::undot($array);

// ['user' => ['name' => 'Kevin Malone', 'occupation' => 'Accountant']]

`Arr::where()`

Метод Arr::where фільтрує масив за допомогою заданого замикання:

use Illuminate\Support\Arr;

$array = [100, '200', 300, '400', 500];

$filtered = Arr::where($array, function (string|int $value, int $key) {
    return is_string($value);
});

// [1 => '200', 3 => '400']

`Arr::whereNotNull()`

Метод Arr::whereNotNull видаляє з переданого масиву всі значення null:

use Illuminate\Support\Arr;

$array = [0, null];

$filtered = Arr::whereNotNull($array);

// [0 => 0]

`Arr::wrap()`

Метод Arr::wrap загортає передане значення в масив. Якщо значення вже є масивом, воно повертається без змін:

use Illuminate\Support\Arr;

$string = 'Laravel';

$array = Arr::wrap($string);

// ['Laravel']

Якщо передане значення дорівнює null, повернеться порожній масив:

use Illuminate\Support\Arr;

$array = Arr::wrap(null);

// []

`data_fill()`

Функція data_fill встановлює відсутнє значення всередині вкладеного масиву або обʼєкта за «крапковою» нотацією:

$data = ['products' => ['desk' => ['price' => 100]]];

data_fill($data, 'products.desk.price', 200);

// ['products' => ['desk' => ['price' => 100]]]

data_fill($data, 'products.desk.discount', 10);

// ['products' => ['desk' => ['price' => 100, 'discount' => 10]]]

Ця функція також приймає зірочки як шаблони підстановки і заповнює ціль відповідно:

$data = [
    'products' => [
        ['name' => 'Desk 1', 'price' => 100],
        ['name' => 'Desk 2'],
    ],
];

data_fill($data, 'products.*.price', 200);

/*
    [
        'products' => [
            ['name' => 'Desk 1', 'price' => 100],
            ['name' => 'Desk 2', 'price' => 200],
        ],
    ]
*/

`data_get()`

Функція data_get дістає значення з вкладеного масиву або обʼєкта за «крапковою» нотацією:

$data = ['products' => ['desk' => ['price' => 100]]];

$price = data_get($data, 'products.desk.price');

// 100

Функція data_get також приймає значення за замовчуванням, яке повернеться, якщо вказаний ключ не знайдено:

$discount = data_get($data, 'products.desk.discount', 0);

// 0

Функція приймає й шаблони підстановки із зірочками, які можуть відповідати будь-якому ключу масиву чи обʼєкта:

$data = [
    'product-one' => ['name' => 'Desk 1', 'price' => 100],
    'product-two' => ['name' => 'Desk 2', 'price' => 150],
];

data_get($data, '*.name');

// ['Desk 1', 'Desk 2'];

Плейсхолдери {first} і {last} дають змогу дістати перший або останній елемент масиву:

$flight = [
    'segments' => [
        ['from' => 'LHR', 'departure' => '9:00', 'to' => 'IST', 'arrival' => '15:00'],
        ['from' => 'IST', 'departure' => '16:00', 'to' => 'PKX', 'arrival' => '20:00'],
    ],
];

data_get($flight, 'segments.{first}.arrival');

// 15:00

`data_set()`

Функція data_set встановлює значення всередині вкладеного масиву або обʼєкта за «крапковою» нотацією:

$data = ['products' => ['desk' => ['price' => 100]]];

data_set($data, 'products.desk.price', 200);

// ['products' => ['desk' => ['price' => 200]]]

Ця функція також приймає шаблони підстановки із зірочками і встановлює значення в цілі відповідно:

$data = [
    'products' => [
        ['name' => 'Desk 1', 'price' => 100],
        ['name' => 'Desk 2', 'price' => 150],
    ],
];

data_set($data, 'products.*.price', 200);

/*
    [
        'products' => [
            ['name' => 'Desk 1', 'price' => 200],
            ['name' => 'Desk 2', 'price' => 200],
        ],
    ]
*/

За замовчуванням наявні значення перезаписуються. Якщо потрібно встановити значення лише тоді, коли його ще немає, передайте false четвертим аргументом функції:

$data = ['products' => ['desk' => ['price' => 100]]];

data_set($data, 'products.desk.price', 200, overwrite: false);

// ['products' => ['desk' => ['price' => 100]]]

`data_forget()`

Функція data_forget видаляє значення всередині вкладеного масиву або обʼєкта за «крапковою» нотацією:

$data = ['products' => ['desk' => ['price' => 100]]];

data_forget($data, 'products.desk.price');

// ['products' => ['desk' => []]]

Ця функція також приймає шаблони підстановки із зірочками і видаляє значення в цілі відповідно:

$data = [
    'products' => [
        ['name' => 'Desk 1', 'price' => 100],
        ['name' => 'Desk 2', 'price' => 150],
    ],
];

data_forget($data, 'products.*.price');

/*
    [
        'products' => [
            ['name' => 'Desk 1'],
            ['name' => 'Desk 2'],
        ],
    ]
*/

`head()`

Функція head повертає перший елемент переданого масиву. Якщо масив порожній, повернеться false:

$array = [100, 200, 300];

$first = head($array);

// 100

`last()`

Функція last повертає останній елемент переданого масиву. Якщо масив порожній, повернеться false:

$array = [100, 200, 300];

$last = last($array);

// 300

Числа

`Number::abbreviate()`

Метод Number::abbreviate повертає зручний для читання формат переданого числового значення зі скороченням одиниць:

use Illuminate\Support\Number;

$number = Number::abbreviate(1000);

// 1K

$number = Number::abbreviate(489939);

// 490K

$number = Number::abbreviate(1230000, precision: 2);

// 1.23M

`Number::clamp()`

Метод Number::clamp утримує задане число в межах вказаного діапазону. Якщо число менше за мінімум, повертається мінімальне значення. Якщо число більше за максимум, повертається максимальне:

use Illuminate\Support\Number;

$number = Number::clamp(105, min: 10, max: 100);

// 100

$number = Number::clamp(5, min: 10, max: 100);

// 10

$number = Number::clamp(10, min: 10, max: 100);

// 10

$number = Number::clamp(20, min: 10, max: 100);

// 20

`Number::currency()`

Метод Number::currency повертає валютне представлення переданого значення у вигляді рядка:

use Illuminate\Support\Number;

$currency = Number::currency(1000);

// $1,000.00

$currency = Number::currency(1000, in: 'EUR');

// €1,000.00

$currency = Number::currency(1000, in: 'EUR', locale: 'de');

// 1.000,00 €

$currency = Number::currency(1000, in: 'EUR', locale: 'de', precision: 0);

// 1.000 €

`Number::defaultCurrency()`

Метод Number::defaultCurrency повертає валюту за замовчуванням, яку використовує клас Number:

use Illuminate\Support\Number;

$currency = Number::defaultCurrency();

// USD

`Number::defaultLocale()`

Метод Number::defaultLocale повертає локаль за замовчуванням, яку використовує клас Number:

use Illuminate\Support\Number;

$locale = Number::defaultLocale();

// en

`Number::fileSize()`

Метод Number::fileSize повертає представлення розміру файлу для переданого значення в байтах у вигляді рядка:

use Illuminate\Support\Number;

$size = Number::fileSize(1024);

// 1 KB

$size = Number::fileSize(1024 * 1024);

// 1 MB

$size = Number::fileSize(1024, precision: 2);

// 1.00 KB

`Number::forHumans()`

Метод Number::forHumans повертає зручний для читання формат переданого числового значення:

use Illuminate\Support\Number;

$number = Number::forHumans(1000);

// 1 thousand

$number = Number::forHumans(489939);

// 490 thousand

$number = Number::forHumans(1230000, precision: 2);

// 1.23 million

`Number::format()`

Метод Number::format форматує передане число у рядок відповідно до локалі:

use Illuminate\Support\Number;

$number = Number::format(100000);

// 100,000

$number = Number::format(100000, precision: 2);

// 100,000.00

$number = Number::format(100000.123, maxPrecision: 2);

// 100,000.12

$number = Number::format(100000, locale: 'de');

// 100.000

`Number::ordinal()`

Метод Number::ordinal повертає порядкове представлення числа:

use Illuminate\Support\Number;

$number = Number::ordinal(1);

// 1st

$number = Number::ordinal(2);

// 2nd

$number = Number::ordinal(21);

// 21st

`Number::pairs()`

Метод Number::pairs генерує масив пар чисел (піддіапазонів) на основі вказаного діапазону і кроку. Це стає в пригоді, коли великий діапазон чисел треба розбити на менші, керовані піддіапазони, наприклад для пагінації чи пакетної обробки. Метод pairs повертає масив масивів, де кожен внутрішній масив представляє пару (піддіапазон) чисел:

use Illuminate\Support\Number;

$result = Number::pairs(25, 10);

// [[0, 9], [10, 19], [20, 25]]

$result = Number::pairs(25, 10, offset: 0);

// [[0, 10], [10, 20], [20, 25]]

`Number::parse()`

Метод Number::parse розбирає локалізований числовий рядок за допомогою PHP-класу NumberFormatter:

use Illuminate\Support\Number;

$result = Number::parse('10,123', locale: 'en');

// 10123.0

$result = Number::parse('10,123', locale: 'fr');

// 10.123

`Number::parseInt()`

Метод Number::parseInt розбирає рядок у ціле число відповідно до вказаної локалі:

use Illuminate\Support\Number;

$result = Number::parseInt('10.123');

// (int) 10

$result = Number::parseInt('10,123', locale: 'fr');

// (int) 10

`Number::parseFloat()`

Метод Number::parseFloat розбирає рядок у число з рухомою комою відповідно до вказаної локалі:

use Illuminate\Support\Number;

$result = Number::parseFloat('10');

// (float) 10.0

$result = Number::parseFloat('10', locale: 'fr');

// (float) 10.0

`Number::percentage()`

Метод Number::percentage повертає відсоткове представлення переданого значення у вигляді рядка:

use Illuminate\Support\Number;

$percentage = Number::percentage(10);

// 10%

$percentage = Number::percentage(10, precision: 2);

// 10.00%

$percentage = Number::percentage(10.123, maxPrecision: 2);

// 10.12%

$percentage = Number::percentage(10, precision: 2, locale: 'de');

// 10,00%

`Number::spell()`

Метод Number::spell перетворює передане число на рядок зі слів:

use Illuminate\Support\Number;

$number = Number::spell(102);

// one hundred and two

$number = Number::spell(88, locale: 'fr');

// quatre-vingt-huit

Аргумент after дозволяє вказати значення, після якого всі числа записуються словами:

$number = Number::spell(10, after: 10);

// 10

$number = Number::spell(11, after: 10);

// eleven

Аргумент until дозволяє вказати значення, до якого всі числа записуються словами:

$number = Number::spell(5, until: 10);

// five

$number = Number::spell(10, until: 10);

// 10

`Number::spellOrdinal()` {.collection-method}

Метод Number::spellOrdinal повертає порядкове представлення числа у вигляді рядка зі слів:

use Illuminate\Support\Number;

$number = Number::spellOrdinal(1);

// first

$number = Number::spellOrdinal(2);

// second

$number = Number::spellOrdinal(21);

// twenty-first

`Number::trim()` {.collection-method}

Метод Number::trim прибирає нулі в кінці дробової частини переданого числа:

use Illuminate\Support\Number;

$number = Number::trim(12.0);

// 12

$number = Number::trim(12.30);

// 12.3

`Number::useLocale()` {.collection-method}

Метод Number::useLocale глобально встановлює локаль за замовчуванням для чисел, що впливає на форматування чисел і валюти в подальших викликах методів класу Number:

use Illuminate\Support\Number;

/**
 * Bootstrap any application services.
 */
public function boot(): void
{
    Number::useLocale('de');
}

`Number::withLocale()` {.collection-method}

Метод Number::withLocale виконує передане замикання із зазначеною локаллю, а після виконання колбека повертає початкову локаль:

use Illuminate\Support\Number;

$number = Number::withLocale('de', function () {
    return Number::format(1500);
});

`Number::useCurrency()` {.collection-method}

Метод Number::useCurrency глобально встановлює валюту за замовчуванням, що впливає на форматування валюти в подальших викликах методів класу Number:

use Illuminate\Support\Number;

/**
 * Bootstrap any application services.
 */
public function boot(): void
{
    Number::useCurrency('GBP');
}

`Number::withCurrency()` {.collection-method}

Метод Number::withCurrency виконує передане замикання із зазначеною валютою, а після виконання колбека повертає початкову валюту:

use Illuminate\Support\Number;

$number = Number::withCurrency('GBP', function () {
    // ...
});

Шляхи

`app_path()` {.collection-method}

Функція app_path повертає повний шлях до каталогу app вашого застосунку. Її також можна використати, щоб отримати повний шлях до файлу відносно цього каталогу:

$path = app_path();

$path = app_path('Http/Controllers/Controller.php');

`base_path()` {.collection-method}

Функція base_path повертає повний шлях до кореневого каталогу застосунку. Її також можна використати, щоб отримати повний шлях до заданого файлу відносно кореня проєкту:

$path = base_path();

$path = base_path('vendor/bin');

`config_path()` {.collection-method}

Функція config_path повертає повний шлях до каталогу config вашого застосунку. Її також можна використати, щоб отримати повний шлях до заданого файлу всередині каталогу конфігурації:

$path = config_path();

$path = config_path('app.php');

`database_path()` {.collection-method}

Функція database_path повертає повний шлях до каталогу database вашого застосунку. Її також можна використати, щоб отримати повний шлях до заданого файлу всередині цього каталогу:

$path = database_path();

$path = database_path('factories/UserFactory.php');

`lang_path()` {.collection-method}

Функція lang_path повертає повний шлях до каталогу lang вашого застосунку. Її також можна використати, щоб отримати повний шлях до заданого файлу всередині цього каталогу:

$path = lang_path();

$path = lang_path('en/messages.php');

[!NOTE] За замовчуванням каркас застосунку Laravel не містить каталогу lang. Якщо ви хочете змінити мовні файли Laravel, опублікуйте їх Artisan-командою lang:publish.

`public_path()` {.collection-method}

Функція public_path повертає повний шлях до каталогу public вашого застосунку. Її також можна використати, щоб отримати повний шлях до заданого файлу всередині каталогу public:

$path = public_path();

$path = public_path('css/app.css');

`resource_path()` {.collection-method}

Функція resource_path повертає повний шлях до каталогу resources вашого застосунку. Її також можна використати, щоб отримати повний шлях до заданого файлу всередині каталогу resources:

$path = resource_path();

$path = resource_path('sass/app.scss');

`storage_path()` {.collection-method}

Функція storage_path повертає повний шлях до каталогу storage вашого застосунку. Її також можна використати, щоб отримати повний шлях до заданого файлу всередині каталогу storage:

$path = storage_path();

$path = storage_path('app/file.txt');

URL

`action()` {.collection-method}

Функція action генерує URL для заданої дії контролера:

use App\Http\Controllers\HomeController;

$url = action([HomeController::class, 'index']);

Якщо метод приймає параметри маршруту, передайте їх другим аргументом:

$url = action([UserController::class, 'profile'], ['id' => 1]);

`asset()` {.collection-method}

Функція asset генерує URL для ресурсу, використовуючи поточну схему запиту (HTTP або HTTPS):

$url = asset('img/photo.jpg');

Хост для URL ресурсів налаштовується змінною ASSET_URL у файлі .env. Це стане в пригоді, якщо ви зберігаєте ресурси у зовнішньому сервісі на кшталт Amazon S3 чи іншого CDN:

// ASSET_URL=http://example.com/assets

$url = asset('img/photo.jpg'); // http://example.com/assets/img/photo.jpg

`route()` {.collection-method}

Функція route генерує URL для заданого іменованого маршруту:

$url = route('route.name');

Якщо маршрут приймає параметри, передайте їх другим аргументом функції:

$url = route('route.name', ['id' => 1]);

За замовчуванням функція route генерує абсолютний URL. Якщо потрібен відносний URL, передайте false третім аргументом:

$url = route('route.name', ['id' => 1], false);

`secure_asset()` {.collection-method}

Функція secure_asset генерує URL для ресурсу через HTTPS:

$url = secure_asset('img/photo.jpg');

`secure_url()` {.collection-method}

Функція secure_url генерує повний HTTPS-URL для заданого шляху. Додаткові сегменти URL передаються другим аргументом функції:

$url = secure_url('user/profile');

$url = secure_url('user/profile', [1]);

`to_action()` {.collection-method}

Функція to_action генерує HTTP-відповідь з перенаправленням для заданої дії контролера:

use App\Http\Controllers\UserController;

return to_action([UserController::class, 'show'], ['user' => 1]);

За потреби третім і четвертим аргументами методу to_action можна передати HTTP-код статусу перенаправлення та додаткові заголовки відповіді:

return to_action(
    [UserController::class, 'show'],
    ['user' => 1],
    302,
    ['X-Framework' => 'Laravel']
);

`to_route()` {.collection-method}

Функція to_route генерує HTTP-відповідь з перенаправленням для заданого іменованого маршруту:

return to_route('users.show', ['user' => 1]);

За потреби третім і четвертим аргументами методу to_route можна передати HTTP-код статусу перенаправлення та додаткові заголовки відповіді:

return to_route('users.show', ['user' => 1], 302, ['X-Framework' => 'Laravel']);

`uri()` {.collection-method}

Функція uri генерує текучий екземпляр URI для заданого URI:

$uri = uri('https://example.com')
    ->withPath('/users')
    ->withQuery(['page' => 1]);

Якщо функції uri передано масив із парою «викликуваний контролер і метод», вона створить екземпляр Uri для шляху маршруту цього методу контролера:

use App\Http\Controllers\UserController;

$uri = uri([UserController::class, 'show'], ['user' => $user]);

Якщо контролер викликається як функція (invokable), достатньо передати назву класу контролера:

use App\Http\Controllers\UserIndexController;

$uri = uri(UserIndexController::class);

Якщо передане функції uri значення збігається з назвою іменованого маршруту, екземпляр Uri буде згенеровано для шляху цього маршруту:

$uri = uri('users.show', ['user' => $user]);

`url()` {.collection-method}

Функція url генерує повний URL для заданого шляху:

$url = url('user/profile');

$url = url('user/profile', [1]);

Якщо шлях не вказано, повертається екземпляр Illuminate\Routing\UrlGenerator:

$current = url()->current();

$full = url()->full();

$previous = url()->previous();

Докладніше про роботу з функцією url читайте в документації з генерації URL.

Різне

`abort()` {.collection-method}

Функція abort кидає HTTP-виняток, який буде відрендерено обробником винятків:

abort(403);

Також можна передати повідомлення винятку та власні заголовки HTTP-відповіді, які треба надіслати в браузер:

abort(403, 'Unauthorized.', $headers);

`abort_if()` {.collection-method}

Функція abort_if кидає HTTP-виняток, якщо задане булеве вираження дорівнює true:

abort_if(! Auth::user()->isAdmin(), 403);

Як і в методі abort, третім аргументом можна передати текст відповіді для винятку, а четвертим - масив власних заголовків відповіді.

`abort_unless()` {.collection-method}

Функція abort_unless кидає HTTP-виняток, якщо задане булеве вираження дорівнює false:

abort_unless(Auth::user()->isAdmin(), 403);

`app()` {.collection-method}

Функція app повертає екземпляр контейнера сервісів:

$container = app();

Щоб розвʼязати клас чи інтерфейс із контейнера, передайте його назву:

$api = app('HelpSpot\API');

`auth()` {.collection-method}

Функція auth повертає екземпляр автентифікатора. Її можна використовувати замість фасаду Auth:

$user = auth()->user();

За потреби вкажіть, до якого guard ви хочете звернутися:

$user = auth('admin')->user();

`back()` {.collection-method}

Функція back генерує HTTP-відповідь з перенаправленням на попередню сторінку користувача:

return back($status = 302, $headers = [], $fallback = '/');

return back();

`bcrypt()` {.collection-method}

Функція bcrypt хешує задане значення за допомогою Bcrypt. Її можна використовувати замість фасаду Hash:

$password = bcrypt('my-secret-password');

`blank()` {.collection-method}

Функція blank визначає, чи є задане значення «порожнім»:

blank('');
blank('   ');
blank(null);
blank(collect());

// true

blank(0);
blank(true);
blank(false);

// false

Протилежна до blank - функція filled.

`broadcast()` {.collection-method}

Функція broadcast транслює задану подію її слухачам:

broadcast(new UserRegistered($user));

broadcast(new UserRegistered($user))->toOthers();

`broadcast_if()` {.collection-method}

Функція broadcast_if транслює задану подію її слухачам, якщо задане булеве вираження дорівнює true:

broadcast_if($user->isActive(), new UserRegistered($user));

broadcast_if($user->isActive(), new UserRegistered($user))->toOthers();

`broadcast_unless()` {.collection-method}

Функція broadcast_unless транслює задану подію її слухачам, якщо задане булеве вираження дорівнює false:

broadcast_unless($user->isBanned(), new UserRegistered($user));

broadcast_unless($user->isBanned(), new UserRegistered($user))->toOthers();

`cache()` {.collection-method}

Функцією cache можна отримувати значення з кешу. Якщо заданого ключа в кеші немає, повернеться необовʼязкове значення за замовчуванням:

$value = cache('key');

$value = cache('key', 'default');

Щоб додати елементи в кеш, передайте функції масив пар ключ / значення. Також слід передати кількість секунд або тривалість, протягом якої кешоване значення вважається дійсним:

cache(['key' => 'value'], 300);

cache(['key' => 'value'], now()->plus(seconds: 10));

`class_uses_recursive()` {.collection-method}

Функція class_uses_recursive повертає всі трейти, які використовує клас, включно з трейтами всіх його батьківських класів:

$traits = class_uses_recursive(App\Models\User::class);

`collect()` {.collection-method}

Функція collect створює екземпляр колекції із заданого значення:

$collection = collect(['Taylor', 'Abigail']);

`config()` {.collection-method}

Функція config отримує значення конфігураційної змінної. Доступ до значень конфігурації здійснюється через «крапкову» нотацію, яка містить назву файлу й потрібну опцію. Також можна передати значення за замовчуванням, яке повернеться, якщо опції конфігурації не існує:

$value = config('app.timezone');

$value = config('app.timezone', $default);

Ви можете встановлювати конфігураційні змінні під час виконання, передавши масив пар ключ / значення. Проте памʼятайте, що ця функція впливає на значення конфігурації лише для поточного запиту й не змінює самі конфігураційні файли:

config(['app.debug' => true]);

`context()` {.collection-method}

Функція context отримує значення з поточного контексту. Також можна передати значення за замовчуванням, яке повернеться, якщо такого ключа в контексті немає:

$value = context('trace_id');

$value = context('trace_id', $default);

Щоб задати значення контексту, передайте масив пар ключ / значення:

use Illuminate\Support\Str;

context(['trace_id' => Str::uuid()->toString()]);

`cookie()` {.collection-method}

Функція cookie створює новий екземпляр cookie:

$cookie = cookie('name', 'value', $minutes);

`csrf_field()` {.collection-method}

Функція csrf_field генерує HTML-поле hidden зі значенням CSRF-токена. Наприклад, у синтаксисі Blade:

{{ csrf_field() }}

`csrf_token()` {.collection-method}

Функція csrf_token повертає значення поточного CSRF-токена:

$token = csrf_token();

`decrypt()` {.collection-method}

Функція decrypt розшифровує задане значення. Її можна використовувати замість фасаду Crypt:

$password = decrypt($value);

Протилежна до decrypt - функція encrypt.

`dd()` {.collection-method}

Функція dd виводить задані змінні й зупиняє виконання скрипта:

dd($value);

dd($value1, $value2, $value3, ...);

Якщо зупиняти виконання скрипта не потрібно, скористайтеся функцією dump.

`dispatch()` {.collection-method}

Функція dispatch відправляє задане завдання (job) у чергу завдань Laravel:

dispatch(new App\Jobs\SendEmails);

`dispatch_sync()` {.collection-method}

Функція dispatch_sync відправляє задане завдання (job) у чергу sync, тож воно обробляється негайно:

dispatch_sync(new App\Jobs\SendEmails);

`dump()` {.collection-method}

Функція dump виводить задані змінні:

dump($value);

dump($value1, $value2, $value3, ...);

Якщо після виведення змінних потрібно зупинити виконання скрипта, скористайтеся функцією dd.

`encrypt()` {.collection-method}

Функція encrypt шифрує задане значення. Її можна використовувати замість фасаду Crypt:

$secret = encrypt('my-secret-value');

Протилежна до encrypt - функція decrypt.

`env()` {.collection-method}

Функція env отримує значення змінної середовища або повертає значення за замовчуванням:

$env = env('APP_ENV');

$env = env('APP_ENV', 'production');

[!WARNING] Якщо під час розгортання ви виконуєте команду config:cache, переконайтеся, що викликаєте функцію env лише у конфігураційних файлах. Після кешування конфігурації файл .env не завантажується, і всі виклики функції env повертатимуть зовнішні змінні середовища рівня сервера чи системи або null.

`event()` {.collection-method}

Функція event відправляє задану подію її слухачам:

event(new UserRegistered($user));

`fake()` {.collection-method}

Функція fake розвʼязує з контейнера синглтон Faker, що зручно для створення фейкових даних у фабриках моделей, під час заповнення бази даних, у тестах і під час прототипування представлень (view):

@for ($i = 0; $i < 10; $i++)
    <dl>
        <dt>Name</dt>
        <dd>{{ fake()->name() }}</dd>

        <dt>Email</dt>
        <dd>{{ fake()->unique()->safeEmail() }}</dd>
    </dl>
@endfor

За замовчуванням функція fake використовує опцію конфігурації app.faker_locale з файлу config/app.php. Зазвичай цю опцію задають через змінну середовища APP_FAKER_LOCALE. Локаль також можна передати безпосередньо у функцію fake. Кожна локаль розвʼязується в окремий синглтон:

fake('nl_NL')->name();

`filled()` {.collection-method}

Функція filled визначає, чи задане значення не є «порожнім»:

filled(0);
filled(true);
filled(false);

// true

filled('');
filled('   ');
filled(null);
filled(collect());

// false

Протилежна до filled - функція blank.

`info()` {.collection-method}

Функція info записує інформацію в лог вашого застосунку:

info('Some helpful information!');

Функції також можна передати масив контекстних даних:

info('User login attempt failed.', ['id' => $user->id]);

`literal()` {.collection-method}

Функція literal створює новий екземпляр stdClass, де іменовані аргументи стають властивостями:

$obj = literal(
    name: 'Joe',
    languages: ['PHP', 'Ruby'],
);

$obj->name; // 'Joe'
$obj->languages; // ['PHP', 'Ruby']

`logger()` {.collection-method}

Функцією logger можна записати повідомлення рівня debug в лог:

logger('Debug message');

Функції також можна передати масив контекстних даних:

logger('User has logged in.', ['id' => $user->id]);

Якщо функції не передати значення, повернеться екземпляр логера:

logger()->error('You are not allowed here.');

`method_field()` {.collection-method}

Функція method_field генерує HTML-поле hidden із підробленим значенням HTTP-дієслова форми. Наприклад, у синтаксисі Blade:

<form method="POST">
    {{ method_field('DELETE') }}
</form>

`now()` {.collection-method}

Функція now створює новий екземпляр Illuminate\Support\Carbon для поточного часу:

$now = now();

`old()` {.collection-method}

Функція old отримує значення старого введення, збереженого в сесії:

$value = old('value');

$value = old('value', 'default');

Оскільки «значення за замовчуванням», яке передають другим аргументом функції old, часто є атрибутом моделі Eloquent, Laravel дозволяє передати другим аргументом цілу модель Eloquent. У такому разі Laravel вважатиме перший аргумент функції old назвою атрибута Eloquent, який слід взяти як «значення за замовчуванням»:

{{ old('name', $user->name) }}

// Is equivalent to...

{{ old('name', $user) }}

`once()` {.collection-method}

Функція once виконує заданий колбек і кешує результат у памʼяті на час запиту. Будь-які наступні виклики once з тим самим колбеком повертатимуть раніше закешований результат:

function random(): int
{
    return once(function () {
        return random_int(1, 1000);
    });
}

random(); // 123
random(); // 123 (cached result)
random(); // 123 (cached result)

Коли функцію once викликано всередині екземпляра обʼєкта, закешований результат буде унікальним для цього екземпляра:

<?php

class NumberService
{
    public function all(): array
    {
        return once(fn () => [1, 2, 3]);
    }
}

$service = new NumberService;

$service->all();
$service->all(); // (cached result)

$secondService = new NumberService;

$secondService->all();
$secondService->all(); // (cached result)

`optional()` {.collection-method}

Функція optional приймає будь-який аргумент і дозволяє звертатися до властивостей або викликати методи цього обʼєкта. Якщо заданий обʼєкт дорівнює null, властивості й методи повернуть null замість того, щоб спричинити помилку:

return optional($user->address)->street;

{!! old('name', optional($user)->name) !!}

Функція optional також приймає замикання другим аргументом. Замикання буде викликано, якщо значення, передане першим аргументом, не є null:

return optional(User::find($id), function (User $user) {
    return $user->name;
});

`policy()` {.collection-method}

Метод policy повертає екземпляр політики для заданого класу:

$policy = policy(App\Models\User::class);

`redirect()` {.collection-method}

Функція redirect повертає HTTP-відповідь з перенаправленням або екземпляр редиректора, якщо викликана без аргументів:

return redirect($to = null, $status = 302, $headers = [], $secure = null);

return redirect('/home');

return redirect()->route('route.name');

`report()` {.collection-method}

Функція report повідомляє про виняток через ваш обробник винятків:

report($e);

Функція report також приймає рядок. Коли їй передано рядок, вона створить виняток із цим рядком як повідомленням:

report('Something went wrong.');

`report_if()` {.collection-method}

Функція report_if повідомляє про виняток через ваш обробник винятків, якщо задане булеве вираження дорівнює true:

report_if($shouldReport, $e);

report_if($shouldReport, 'Something went wrong.');

`report_unless()` {.collection-method}

Функція report_unless повідомляє про виняток через ваш обробник винятків, якщо задане булеве вираження дорівнює false:

report_unless($reportingDisabled, $e);

report_unless($reportingDisabled, 'Something went wrong.');

`request()` {.collection-method}

Функція request повертає екземпляр поточного запиту або отримує значення поля введення з поточного запиту:

$request = request();

$value = request('key', $default);

`rescue()` {.collection-method}

Функція rescue виконує задане замикання й перехоплює будь-які винятки, що трапилися під час його виконання. Усі перехоплені винятки надсилаються вашому обробнику винятків, проте обробка запиту триває далі:

return rescue(function () {
    return $this->method();
});

Функції rescue можна передати й другий аргумент. Це буде значення «за замовчуванням», яке повернеться, якщо під час виконання замикання станеться виняток:

return rescue(function () {
    return $this->method();
}, false);

return rescue(function () {
    return $this->method();
}, function () {
    return $this->failure();
});

Аргумент report дозволяє визначити, чи слід повідомляти про виняток через функцію report:

return rescue(function () {
    return $this->method();
}, report: function (Throwable $throwable) {
    return $throwable instanceof InvalidArgumentException;
});

`resolve()` {.collection-method}

Функція resolve розвʼязує задану назву класу чи інтерфейсу в екземпляр за допомогою контейнера сервісів:

$api = resolve('HelpSpot\API');

`response()` {.collection-method}

Функція response створює екземпляр відповіді або повертає екземпляр фабрики відповідей:

return response('Hello World', 200, $headers);

return response()->json(['foo' => 'bar'], 200, $headers);

`retry()` {.collection-method}

Функція retry намагається виконати заданий колбек, доки не буде досягнуто максимальної кількості спроб. Якщо колбек не кидає винятку, повертається його результат. Якщо колбек кидає виняток, спроба автоматично повторюється. Коли максимальну кількість спроб перевищено, виняток буде кинуто:

return retry(5, function () {
    // Attempt 5 times while resting 100ms between attempts...
}, 100);

Тривалість паузи також приймає екземпляр CarbonInterval:

use function Illuminate\Support\seconds;

return retry(5, function () {
    // Attempt 5 times while resting 5 seconds between attempts...
}, seconds(5));

Якщо ви хочете самостійно обчислювати кількість мілісекунд паузи між спробами, передайте замикання третім аргументом функції retry:

use Exception;

return retry(5, function () {
    // ...
}, function (int $attempt, Exception $exception) {
    return $attempt * 100;
});

Для зручності першим аргументом функції retry можна передати масив. За ним визначатиметься, скільки мілісекунд чекати перед кожною наступною спробою:

return retry([100, 200], function () {
    // Sleep for 100ms on first retry, 200ms on second retry...
});

Щоб повторювати спроби лише за певних умов, передайте замикання четвертим аргументом функції retry:

use App\Exceptions\TemporaryException;
use Exception;

return retry(5, function () {
    // ...
}, 100, function (Exception $exception) {
    return $exception instanceof TemporaryException;
});

`session()` {.collection-method}

Функцією session можна отримувати або задавати значення сесії:

$value = session('key');

Щоб задати значення, передайте функції масив пар ключ / значення:

session(['chairs' => 7, 'instruments' => 3]);

Якщо функції не передати значення, повернеться сховище сесії:

$value = session()->get('key');

session()->put('key', $value);

`tap()` {.collection-method}

Функція tap приймає два аргументи: довільне значення $value і замикання. Значення $value буде передано замиканню, а потім повернуто функцією tap. Результат замикання не має значення:

$user = tap(User::first(), function (User $user) {
    $user->name = 'Taylor';

    $user->save();
});

Якщо замикання не передано, ви можете викликати будь-який метод на заданому значенні $value. Результатом виклику завжди буде $value, незалежно від того, що метод насправді повертає у своєму визначенні. Наприклад, метод Eloquent update зазвичай повертає ціле число. Але ми можемо змусити його повернути саму модель, викликавши update через функцію tap:

$user = tap($user)->update([
    'name' => $name,
    'email' => $email,
]);

Щоб додати метод tap до класу, підключіть до нього трейт Illuminate\Support\Traits\Tappable. Метод tap цього трейта приймає єдиний аргумент - Closure. Сам екземпляр обʼєкта буде передано в Closure, а потім повернуто методом tap:

return $user->tap(function (User $user) {
    // ...
});

`throw_if()` {.collection-method}

Функція throw_if кидає заданий виняток, якщо задане булеве вираження дорівнює true:

throw_if(! Auth::user()->isAdmin(), AuthorizationException::class);

throw_if(
    ! Auth::user()->isAdmin(),
    AuthorizationException::class,
    'You are not allowed to access this page.'
);

`throw_unless()` {.collection-method}

Функція throw_unless кидає заданий виняток, якщо задане булеве вираження дорівнює false:

throw_unless(Auth::user()->isAdmin(), AuthorizationException::class);

throw_unless(
    Auth::user()->isAdmin(),
    AuthorizationException::class,
    'You are not allowed to access this page.'
);

`today()` {.collection-method}

Функція today створює новий екземпляр Illuminate\Support\Carbon для поточної дати:

$today = today();

`trait_uses_recursive()` {.collection-method}

Функція trait_uses_recursive повертає всі трейти, які використовує трейт:

$traits = trait_uses_recursive(\Illuminate\Notifications\Notifiable::class);

`transform()` {.collection-method}

Функція transform виконує замикання над заданим значенням, якщо воно не порожнє, і повертає результат замикання:

$callback = function (int $value) {
    return $value * 2;
};

$result = transform(5, $callback);

// 10

Третім аргументом функції можна передати значення за замовчуванням або замикання. Воно повернеться, якщо задане значення порожнє:

$result = transform(null, $callback, 'The value is blank');

// The value is blank

`validator()` {.collection-method}

Функція validator створює новий екземпляр валідатора із заданими аргументами. Її можна використовувати замість фасаду Validator:

$validator = validator($data, $rules, $messages);

`value()` {.collection-method}

Функція value повертає передане їй значення. Але якщо передати функції замикання, воно буде виконане, а повернеться його результат:

$result = value(true);

// true

$result = value(function () {
    return false;
});

// false

Функції value можна передати додаткові аргументи. Якщо перший аргумент - замикання, додаткові параметри буде передано в нього як аргументи, інакше вони ігноруються:

$result = value(function (string $name) {
    return $name;
}, 'Taylor');

// 'Taylor'

`view()` {.collection-method}

Функція view повертає екземпляр представлення (view):

return view('auth.login');

`with()` {.collection-method}

Функція with повертає передане їй значення. Якщо другим аргументом передати замикання, воно буде виконане, а повернеться його результат:

$callback = function (mixed $value) {
    return is_numeric($value) ? $value * 2 : 0;
};

$result = with(5, $callback);

// 10

$result = with(null, $callback);

// 0

$result = with(5, null);

// 5

`when()` {.collection-method}

Функція when повертає передане їй значення, якщо задана умова дорівнює true. Інакше повертається null. Якщо другим аргументом передати замикання, воно буде виконане, а повернеться його результат:

$value = when(true, 'Hello World');

$value = when(true, fn () => 'Hello World');

Функція when найбільш корисна для умовного рендерингу HTML-атрибутів:

<div {!! when($condition, 'wire:poll="calculate"') !!}>
    ...
</div>

Інші утиліти

Бенчмаркінг

Іноді потрібно швидко перевірити продуктивність окремих частин застосунку. Для цього є допоміжний клас Benchmark, який вимірює, скільки мілісекунд виконуються задані колбеки:

<?php

use App\Models\User;
use Illuminate\Support\Benchmark;

Benchmark::dd(fn () => User::find(1)); // 0.1 ms

Benchmark::dd([
    'Scenario 1' => fn () => User::count(), // 0.5 ms
    'Scenario 2' => fn () => User::all()->count(), // 20.0 ms
]);

За замовчуванням задані колбеки виконуються один раз (одна ітерація), а їхня тривалість виводиться в браузер / консоль.

Щоб викликати колбек більше одного разу, передайте кількість ітерацій другим аргументом методу. Коли колбек виконується кілька разів, клас Benchmark поверне середню кількість мілісекунд по всіх ітераціях:

Benchmark::dd(fn () => User::count(), iterations: 10); // 0.5 ms

Іноді потрібно заміряти виконання колбека й водночас отримати значення, яке він повертає. Метод value повертає кортеж зі значенням колбека та кількістю мілісекунд, що пішли на його виконання:

[$count, $duration] = Benchmark::value(fn () => User::count());

Дата й час

До складу Laravel входить Carbon - потужна бібліотека для роботи з датою й часом. Щоб створити новий екземпляр Carbon, викличте функцію now. Вона доступна глобально у вашому застосунку Laravel:

$now = now();

Або ж створіть новий екземпляр Carbon через клас Illuminate\Support\Carbon:

use Illuminate\Support\Carbon;

$now = Carbon::now();

Laravel також розширює екземпляри Carbon методами plus і minus, що спрощує зміну дати й часу:

return now()->plus(minutes: 5);
return now()->plus(hours: 8);
return now()->plus(weeks: 4);

return now()->minus(minutes: 5);
return now()->minus(hours: 8);
return now()->minus(weeks: 4);

Докладний розбір Carbon і його можливостей шукайте в офіційній документації Carbon.

Функції інтервалів

Laravel також пропонує функції milliseconds, seconds, minutes, hours, days, weeks, months і years, які повертають екземпляри CarbonInterval, що розширюють клас PHP DateInterval. Ці функції можна використовувати всюди, де Laravel приймає екземпляр DateInterval:

use Illuminate\Support\Facades\Cache;

use function Illuminate\Support\{minutes};

Cache::put('metrics', $metrics, minutes(10));

Відкладені функції

Завдання в чергах Laravel дозволяють ставити задачі на фонову обробку, але іноді трапляються прості задачі, які хочеться відкласти, не налаштовуючи й не підтримуючи довготривалий обробник черги.

Відкладені функції дозволяють відкласти виконання замикання до моменту, коли HTTP-відповідь уже надіслано користувачеві, завдяки чому застосунок лишається швидким і чуйним. Щоб відкласти виконання замикання, просто передайте його у функцію Illuminate\Support\defer:

use App\Services\Metrics;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Route;
use function Illuminate\Support\defer;

Route::post('/orders', function (Request $request) {
    // Create order...

    defer(fn () => Metrics::reportOrder($order));

    return $order;
});

За замовчуванням відкладені функції виконуються лише тоді, коли HTTP-відповідь, Artisan-команда чи завдання з черги, звідки викликано Illuminate\Support\defer, завершилися успішно. Тобто відкладені функції не виконаються, якщо запит завершився HTTP-відповіддю 4xx або 5xx. Якщо ви хочете, щоб відкладена функція виконувалася завжди, додайте до неї метод always:

defer(fn () => Metrics::reportOrder($order))->always();

[!WARNING] Якщо у вас встановлено розширення PHP Swoole, функція defer Laravel може конфліктувати з власною глобальною функцією defer у Swoole, що призводить до помилок вебсервера. Обовʼязково викликайте хелпер defer Laravel із явним простором імен: use function Illuminate\Support\defer;

Скасування відкладених функцій

Якщо потрібно скасувати відкладену функцію до її виконання, скористайтеся методом forget, передавши їй імʼя функції. Щоб назвати відкладену функцію, передайте другий аргумент у функцію Illuminate\Support\defer:

defer(fn () => Metrics::report(), 'reportMetrics');

defer()->forget('reportMetrics');

Вимкнення відкладених функцій у тестах

Під час написання тестів буває корисно вимкнути відкладені функції. Викличте в тесті withoutDefer, щоб Laravel виконував усі відкладені функції негайно:

test('without defer', function () {
    $this->withoutDefer();

    // ...
});

use Tests\TestCase;

class ExampleTest extends TestCase
{
    public function test_without_defer(): void
    {
        $this->withoutDefer();

        // ...
    }
}

Щоб вимкнути відкладені функції для всіх тестів у тест-кейсі, викличте метод withoutDefer у методі setUp вашого базового класу TestCase:

<?php

namespace Tests;

use Illuminate\Foundation\Testing\TestCase as BaseTestCase;

abstract class TestCase extends BaseTestCase
{
    protected function setUp(): void// [tl! add:start]
    {
        parent::setUp();

        $this->withoutDefer();
    }// [tl! add:end]
}

Лотерея

Клас лотереї в Laravel виконує колбеки на основі заданих шансів. Це зручно, коли потрібно виконувати код лише для певного відсотка вхідних запитів:

use Illuminate\Support\Lottery;

Lottery::odds(1, 20)
    ->winner(fn () => $user->won())
    ->loser(fn () => $user->lost())
    ->choose();

Клас лотереї можна поєднувати з іншими можливостями Laravel. Наприклад, ви можете повідомляти обробнику винятків лише про невеликий відсоток повільних запитів. А оскільки клас лотереї є викликуваним, його екземпляр можна передавати в будь-який метод, що приймає callable:

use Carbon\CarbonInterval;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Lottery;

DB::whenQueryingForLongerThan(
    CarbonInterval::seconds(2),
    Lottery::odds(1, 100)->winner(fn () => report('Querying > 2 seconds.')),
);

Тестування лотерей

Laravel надає кілька простих методів, щоб легко тестувати виклики лотереї у вашому застосунку:

// Lottery will always win...
Lottery::alwaysWin();

// Lottery will always lose...
Lottery::alwaysLose();

// Lottery will win then lose, and finally return to normal behavior...
Lottery::fix([true, false]);

// Lottery will return to normal behavior...
Lottery::determineResultsNormally();

Pipeline

Фасад Pipeline у Laravel дає зручний спосіб «пропустити» заданий вхідний обʼєкт через послідовність invokable-класів, замикань або викликуваних значень: кожен із них може перевірити чи змінити вхідні дані й викликати наступний елемент конвеєра:

use Closure;
use App\Models\User;
use Illuminate\Support\Facades\Pipeline;

$user = Pipeline::send($user)
    ->through([
        function (User $user, Closure $next) {
            // ...

            return $next($user);
        },
        function (User $user, Closure $next) {
            // ...

            return $next($user);
        },
    ])
    ->then(fn (User $user) => $user);

Як бачите, кожен invokable-клас чи замикання в конвеєрі отримує вхідні дані й замикання $next. Виклик $next передає керування наступному елементу конвеєра. Ви, мабуть, помітили, що це дуже схоже на middleware.

Коли останній елемент конвеєра викликає замикання $next, спрацьовує колбек, переданий у метод then. Зазвичай такий колбек просто повертає передані дані. Якщо вам потрібно лише повернути вхідні дані після обробки, скористайтеся методом thenReturn.

Звісно, як уже згадувалося, конвеєр не обмежений замиканнями. Можна передавати й invokable-класи. Якщо передано імʼя класу, він буде створений через контейнер сервісів Laravel, тож у invokable-клас можна впроваджувати залежності:

$user = Pipeline::send($user)
    ->through([
        GenerateProfilePhoto::class,
        ActivateSubscription::class,
        SendWelcomeEmail::class,
    ])
    ->thenReturn();

Метод withinTransaction загортає всі кроки конвеєра в одну транзакцію бази даних:

$user = Pipeline::send($user)
    ->withinTransaction()
    ->through([
        ProcessOrder::class,
        TransferFunds::class,
        UpdateInventory::class,
    ])
    ->thenReturn();

Sleep

Клас Sleep у Laravel - легка обгортка над нативними функціями PHP sleep і usleep. Він дає кращу тестованість і зручний API для роботи з часом:

use Illuminate\Support\Sleep;

$waiting = true;

while ($waiting) {
    Sleep::for(1)->second();

    $waiting = /* ... */;
}

Клас Sleep має набір методів для різних одиниць часу:

// Повернути значення після паузи...
$result = Sleep::for(1)->second()->then(fn () => 1 + 1);

// Спати, поки задане значення істинне...
Sleep::for(1)->second()->while(fn () => shouldKeepSleeping());

// Призупинити виконання на 90 секунд...
Sleep::for(1.5)->minutes();

// Призупинити виконання на 2 секунди...
Sleep::for(2)->seconds();

// Призупинити виконання на 500 мілісекунд...
Sleep::for(500)->milliseconds();

// Призупинити виконання на 5 000 мікросекунд...
Sleep::for(5000)->microseconds();

// Призупинити виконання до заданого моменту...
Sleep::until(now()->plus(minutes: 1));

// Псевдонім нативної функції PHP "sleep"...
Sleep::sleep(2);

// Псевдонім нативної функції PHP "usleep"...
Sleep::usleep(5000);

Щоб зручно комбінувати одиниці часу, скористайтеся методом and:

Sleep::for(1)->second()->and(10)->milliseconds();

Тестування Sleep

Коли ви тестуєте код, який використовує клас Sleep або нативні функції паузи PHP, тест справді зупиняє виконання. Як наслідок, набір тестів стає помітно повільнішим. Наприклад, уявіть, що ви тестуєте такий код:

$waiting = /* ... */;

$seconds = 1;

while ($waiting) {
    Sleep::for($seconds++)->seconds();

    $waiting = /* ... */;
}

Зазвичай тестування цього коду забрало б щонайменше одну секунду. На щастя, клас Sleep дозволяє «підробити» паузу, щоб набір тестів лишався швидким:

it('waits until ready', function () {
    Sleep::fake();

    // ...
});

public function test_it_waits_until_ready()
{
    Sleep::fake();

    // ...
}

Коли клас Sleep підроблено, реальна пауза у виконанні пропускається, і тест відпрацьовує значно швидше.

Після підміни Sleep можна робити перевірки щодо очікуваних «пауз». Скажімо, ми тестуємо код, який тричі призупиняє виконання, і кожна пауза довша на секунду. Метод assertSequence дозволяє перевірити, що код «спав» належний час, і при цьому тест лишається швидким:

it('checks if ready three times', function () {
    Sleep::fake();

    // ...

    Sleep::assertSequence([
        Sleep::for(1)->second(),
        Sleep::for(2)->seconds(),
        Sleep::for(3)->seconds(),
    ]);
}

public function test_it_checks_if_ready_three_times()
{
    Sleep::fake();

    // ...

    Sleep::assertSequence([
        Sleep::for(1)->second(),
        Sleep::for(2)->seconds(),
        Sleep::for(3)->seconds(),
    ]);
}

Звісно, у класі Sleep є й інші перевірки, корисні під час тестування:

use Carbon\CarbonInterval as Duration;
use Illuminate\Support\Sleep;

// Перевірити, що пауза була викликана 3 рази...
Sleep::assertSleptTimes(3);

// Перевірити тривалість паузи...
Sleep::assertSlept(function (Duration $duration): bool {
    return /* ... */;
}, times: 1);

// Перевірити, що клас Sleep жодного разу не викликався...
Sleep::assertNeverSlept();

// Перевірити, що навіть якщо Sleep викликали, реальної паузи не було...
Sleep::assertInsomniac();

Іноді корисно виконувати якусь дію щоразу, коли відбувається підроблена пауза. Для цього передайте колбек у метод whenFakingSleep. У прикладі нижче ми використовуємо хелпери маніпуляції часом Laravel, щоб миттєво просувати час на тривалість кожної паузи:

use Carbon\CarbonInterval as Duration;

$this->freezeTime();

Sleep::fake();

Sleep::whenFakingSleep(function (Duration $duration) {
    // Просуваємо час при підробленій паузі...
    $this->travel($duration->totalMilliseconds)->milliseconds();
});

Оскільки просування часу потрібне часто, метод fake приймає аргумент syncWithCarbon, який тримає Carbon синхронізованим із паузами в тесті:

Sleep::fake(syncWithCarbon: true);

$start = now();

Sleep::for(1)->second();

$start->diffForHumans(); // 1 second ago

Laravel сам використовує клас Sleep скрізь, де призупиняє виконання. Наприклад, хелпер retry спить саме через Sleep, що робить код із ним зручнішим для тестування.

Timebox

Клас Timebox у Laravel гарантує, що переданий колбек завжди виконуватиметься фіксований час, навіть якщо фактично завершиться раніше. Це особливо корисно для криптографічних операцій і перевірок автентифікації користувача, де зловмисники можуть використати різницю в часі виконання, щоб дізнатися чутливу інформацію.

Якщо виконання перевищує фіксовану тривалість, Timebox не має жодного ефекту. Розробник сам має обрати достатньо довгу фіксовану тривалість з урахуванням найгірших сценаріїв.

Метод call приймає замикання і ліміт часу в мікросекундах, виконує замикання й чекає, поки цей ліміт мине:

use Illuminate\Support\Timebox;

(new Timebox)->call(function ($timebox) {
    // ...
}, microseconds: 10000);

Якщо всередині замикання буде кинуто виняток, клас дотримає визначену затримку й перекине виняток після неї.

URI

Клас Uri у Laravel надає зручний плавний інтерфейс для створення й зміни URI. Він огортає функціональність пакета League URI і безшовно інтегрується із системою маршрутизації Laravel.

Створити екземпляр Uri легко за допомогою статичних методів:

use App\Http\Controllers\UserController;
use App\Http\Controllers\InvokableController;
use Illuminate\Support\Uri;

// Створити екземпляр URI із заданого рядка...
$uri = Uri::of('https://example.com/path');

// Створити екземпляри URI для шляхів, іменованих маршрутів або дій контролера...
$uri = Uri::to('/dashboard');
$uri = Uri::route('users.show', ['user' => 1]);
$uri = Uri::signedRoute('users.show', ['user' => 1]);
$uri = Uri::temporarySignedRoute('user.index', now()->plus(minutes: 5));
$uri = Uri::action([UserController::class, 'index']);
$uri = Uri::action(InvokableController::class);

// Створити екземпляр URI з URL поточного запиту...
$uri = $request->uri();

Отримавши екземпляр URI, ви можете плавно його змінювати:

$uri = Uri::of('https://example.com')
    ->withScheme('http')
    ->withHost('test.com')
    ->withPort(8000)
    ->withPath('/users')
    ->withQuery(['page' => 2])
    ->withFragment('section-1');

Перевірка URI

Клас Uri також дозволяє легко перевіряти окремі складові URI:

$scheme = $uri->scheme();
$authority = $uri->authority();
$host = $uri->host();
$port = $uri->port();
$path = $uri->path();
$segments = $uri->pathSegments();
$query = $uri->query();
$fragment = $uri->fragment();

Робота з query-рядком

Клас Uri пропонує кілька методів для роботи з query-рядком URI. Метод withQuery додає (зливає) нові параметри до наявного query-рядка:

$uri = $uri->withQuery(['sort' => 'name']);

Метод withQueryIfMissing додає нові параметри до наявного query-рядка, лише якщо заданих ключів там ще немає:

$uri = $uri->withQueryIfMissing(['page' => 1]);

Метод replaceQuery повністю замінює наявний query-рядок новим:

$uri = $uri->replaceQuery(['page' => 1]);

Метод pushOntoQuery додає значення до параметра query-рядка, який має масив як значення:

$uri = $uri->pushOntoQuery('filter', ['active', 'pending']);

Метод withoutQuery видаляє параметри з query-рядка:

$uri = $uri->withoutQuery(['page']);

Генерація відповідей з URI

Метод redirect створює екземпляр RedirectResponse на заданий URI:

$uri = Uri::of('https://example.com');

return $uri->redirect();

Або ж просто поверніть екземпляр Uri з маршруту чи дії контролера - відповідь-редирект на цей URI згенерується автоматично:

use Illuminate\Support\Facades\Route;
use Illuminate\Support\Uri;

Route::get('/redirect', function () {
    return Uri::to('/index')
        ->withQuery(['sort' => 'name']);
});

Оригінал англійською ↗ Глосарій термінів

переклад: Редакція phpukraine · CC-BY-SA-4.0

← ПОПЕРЕДНЯ Файлове сховище НАСТУПНА → HTTP-клієнт

ХТО НАЙМАЄ Вакансії Laravel в Україні Актуальні позиції за цим стеком /jobs/laravel→

Стан перекладу

Перекладаємо з офіційної документації, розділ за розділом, і не ховаємо недоперекладене. Помітили неточність у терміні чи реченні: напишіть, виправимо.

71%

Готовності

У роботі

Ще не перекладено

Глосарій термінів