HTTP Client trong Laravel 13

Giới thiệu

Laravel chứa một loạt các hàm PHP global "helper". Nhiều trong số các hàm này được sử dụng bởi chính framework; tuy nhiên, bạn có thể thoải mái sử dụng chúng trong application của bạn nếu bạn thấy chúng tiện ích.

Các phương thức có sẵn

Arrays & Objects

Numbers

Paths

app_path base_path config_path database_path lang_path public_path resource_path storage_path

URLs

action asset route secure_asset secure_url to_action to_route uri url

Miscellaneous

Arrays & Objects

`Arr::accessible()`

Hàm Arr::accessible sẽ xác định xem giá trị đã cho có phải là mảng có thể truy cập được hay không:

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()`

Hàm Arr::add sẽ thêm một cặp key / giá trị vào một mảng nếu key đó không tồn tại trong mảng hoặc giá trị trong mảng của key đó bằng 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()`

Hàm Arr::array sẽ lấy một giá trị từ một mảng lồng nhau bằng cách sử dụng cú pháp "chấm" (tương tự như hàm Arr::get()), nhưng sẽ đưa ra một InvalidArgumentException nếu giá trị được yêu cầu không phải là một mảng:

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()`

Hàm Arr::boolean sẽ lấy một giá trị từ một mảng lồng nhau bằng cách sử dụng cú pháp "chấm" (tương tự như hàm Arr::get()), nhưng sẽ đưa ra một InvalidArgumentException nếu giá trị được yêu cầu không phải là một 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()`

Hàm Arr::collapse sẽ thu gọn một mảng hoặc một collection gồm nhiều mảng hoặc collection con thành một mảng duy nhất:

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()`

Hàm Arr::crossJoin sẽ join chéo các giá trị của mảng đã cho, và trả về một tích chéo với tất cả các hoán vị có thể có:

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()`

Hàm Arr::divide trả về hai mảng: một mảng chứa các key và một mảng chứa các giá trị của mảng đã cho:

use Illuminate\Support\Arr;

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

// $keys: ['name']

// $values: ['Desk']

`Arr::dot()`

Hàm Arr::dot sẽ làm ngang hàng một mảng nhiều chiều thành một mảng một chiều sử dụng ký hiệu "dot" để biểu thị độ sâu:

use Illuminate\Support\Arr;

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

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

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

`Arr::every()`

Hàm Arr::every sẽ xác định xem tất cả các phần tử có trong mảng có pass qua một số điều kiện hay không:

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()`

Hàm Arr::except loại bỏ các cặp key / giá trị đã cho ra khỏi một mảng:

use Illuminate\Support\Arr;

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

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

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

`Arr::exceptValues()`

Hàm Arr::exceptValues sẽ loại bỏ các giá trị đã được chỉ định ra khỏi một mảng:

use Illuminate\Support\Arr;

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

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

// ['bar', 'qux']

Bạn cũng có thể truyền một giá trị true vào tham số strict để sử dụng so sánh nghiêm ngặt khi lọc:

use Illuminate\Support\Arr;

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

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

// ['1', '2']

`Arr::exists()`

Hàm Arr::exists sẽ kiểm tra xem khóa đã cho có tồn tại trong mảng đã cho hay không:

use Illuminate\Support\Arr;

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

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

// true

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

// false

`Arr::first()`

Hàm Arr::first trả về phần tử đầu tiên của mảng pass qua một số điều kiện đã cho:

use Illuminate\Support\Arr;

$array = [100, 200, 300];

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

// 200

Một giá trị mặc định cũng có thể được truyền làm tham số thứ ba cho phương thức. Giá trị này sẽ được trả về nếu không có giá trị nào được pass qua điều kiện:

use Illuminate\Support\Arr;

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

`Arr::flatten()`

Hàm Arr::flatten làm ngang hàng một mảng nhiều chiều thành một mảng một chiều:

use Illuminate\Support\Arr;

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

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

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

`Arr::float()`

Hàm Arr::float sẽ lấy một giá trị từ một mảng lồng nhau bằng cách sử dụng ký tự "chấm" (giống như hàm Arr::get()), nhưng sẽ đưa ra một InvalidArgumentException nếu giá trị được yêu cầu không phải là một 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()`

Hàm Arr::forget xóa một cặp key / giá trị đã cho ra khỏi một mảng bị lồng vào nhau bằng cách sử dụng ký hiệu "dot":

use Illuminate\Support\Arr;

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

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

// ['products' => []]

`Arr::from()`

Hàm Arr::from sẽ chuyển các kiểu dữ liệu đầu vào input thành một mảng PHP. Nó hỗ trợ nhiều loại input, bao gồm mảng, đối tượng và một số interface phổ biến của Laravel, chẳng hạn như Arrayable, Enumerable, Jsonable và JsonSerializable. Ngoài ra, nó cũng xử lý các instance của Traversable và 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()`

Hàm Arr::get lấy một giá trị từ một mảng bị lồng vào nhau bằng cách sử dụng ký hiệu "dot":

use Illuminate\Support\Arr;

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

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

// 100

Hàm Arr::get cũng chấp nhận một giá trị mặc định, sẽ được trả về nếu khóa được chỉ định không có trong mảng:

use Illuminate\Support\Arr;

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

// 0

`Arr::has()`

Hàm Arr::has sẽ kiểm tra xem một item hoặc các item đã cho có tồn tại trong một mảng hay không bằng cách sử dụng ký hiệu "dot":

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()`

Hàm Arr::hasAll sẽ xác định xem tất cả các key đã cho có tồn tại trong mảng hay không bằng cách sử dụng ký tự "chấm":

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()`

Hàm Arr::hasAny sẽ kiểm tra xem có bất kỳ item nào có trong một mảng hay không bằng cách sử dụng ký tự "chấm":

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()`

Hàm Arr::integer sẽ lấy một giá trị từ một mảng lồng nhau bằng cách sử dụng ký tự "chấm" (giống như hàm Arr::get()), nhưng sẽ đưa ra một InvalidArgumentException nếu giá trị được yêu cầu không phải là một 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()`

Hàm Arr::isAssoc sẽ trả về true nếu mảng đã cho là một mảng associative. Một mảng được coi là "associative" nếu nó không có khóa bắt đầu từ 0:

use Illuminate\Support\Arr;

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

// true

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

// false

`Arr::isList()`

Hàm Arr::isList sẽ trả về true nếu khóa của mảng đã cho là các số nguyên theo thứ tự bắt đầu từ 0:

use Illuminate\Support\Arr;

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

// true

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

// false

`Arr::join()`

Hàm Arr::join sẽ nối các phần tử của mảng vào với nhau bằng một string. Sử dụng tham số thứ ba của phương thức này, bạn cũng có thể chỉ định string mà bạn muốn nối cho phần tử cuối cùng của mảng:

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()`

Hàm Arr::keyBy sẽ tạo khóa cho mảng bằng khóa đã cho. Nếu nhiều item có cùng một khóa, thì item cuối cùng sẽ được cho vào trong mảng mới:

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()`

Hàm Arr::last trả về phần tử cuối cùng của mảng pass qua một số điều kiện đã cho:

use Illuminate\Support\Arr;

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

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

// 300

Một giá trị mặc định có thể được truyền làm tham số thứ ba cho phương thức. Giá trị này sẽ được trả về nếu không có giá trị nào pass qua điều kiện:

use Illuminate\Support\Arr;

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

`Arr::map()`

Hàm Arr::map sẽ lặp từng phần tử của mảng và chuyển từng giá trị cũng như khóa của nó cho một callback đã cho. Giá trị mảng sẽ được thay thế bằng giá trị được trả về bởi callback:

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()`

Hàm Arr::mapSpread sẽ lặp qua mảng và chuyển từng giá trị của item trong mảng vào một closure đã cho. Closure có thể tự do sửa item và trả về giá trị mới và giá trị mới này sẽ tạo thành ra một mảng mới gồm các item đã được sửa:

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()`

Hàm Arr::mapWithKeys sẽ lặp qua mảng và chuyển từng giá trị cho lệnh callback đã cho. Lệnh callback sẽ trả về một mảng kết hợp giữa một khóa và giá trị:

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()`

Hàm Arr::only chỉ trả về các cặp key / giá trị được chỉ định từ mảng đã cho:

use Illuminate\Support\Arr;

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

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

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

`Arr::onlyValues()`

Hàm Arr::onlyValues sẽ chỉ trả về các giá trị đã được chỉ định từ một mảng:

use Illuminate\Support\Arr;

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

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

// ['foo', 'baz']

Bạn cũng có thể truyền giá trị true vào tham số strict để sử dụng so sánh nghiêm ngặt khi lọc:

use Illuminate\Support\Arr;

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

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

// [1, 2]

`Arr::partition()`

Hàm Arr::partition có thể được kết hợp với array destructuring của PHP để tách các phần tử pass qua một bài kiểm tra ra khỏi những phần tử không pass:

<?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()`

Hàm Arr::pluck lấy tất cả các giá trị cho một key đã cho từ một mảng:

use Illuminate\Support\Arr;

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

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

// ['Taylor', 'Abigail']

Bạn cũng có thể khai báo thêm key cho mảng đó:

use Illuminate\Support\Arr;

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

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

`Arr::prepend()`

Hàm Arr::prepend sẽ thêm một item lên đầu của một mảng:

use Illuminate\Support\Arr;

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

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

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

Nếu cần, bạn có thể khai báo key cho giá trị đó:

use Illuminate\Support\Arr;

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

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

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

`Arr::prependKeysWith()`

Hàm Arr::prependKeysWith sẽ nối một tiền tố đã cho vào trước tất cả các khóa của một mảng:

use Illuminate\Support\Arr;

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

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

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

`Arr::pull()`

Hàm Arr::pull trả về và xóa một cặp key / giá trị ra khỏi một mảng:

use Illuminate\Support\Arr;

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

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

// $name: Desk

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

Một giá trị mặc định có thể được truyền làm tham số thứ ba cho phương thức. Giá trị này sẽ được trả về nếu key không tồn tại:

use Illuminate\Support\Arr;

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

`Arr::push()`

Hàm Arr::push sẽ push một item vào một mảng bằng cách sử dụng ký tự "chấm". Nếu mảng không tồn tại tại key đã cho, nó sẽ tạo ra key đó:

use Illuminate\Support\Arr;

$array = [];

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

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

`Arr::query()`

Hàm Arr::query sẽ chuyển đổi một mảng thành một chuỗi 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()`

Hàm Arr::random sẽ trả về một giá trị ngẫu nhiên từ một mảng:

use Illuminate\Support\Arr;

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

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

// 4 - (retrieved randomly)

Bạn cũng có thể chỉ định số lượng item sẽ được trả về làm tham số thứ hai. Lưu ý rằng việc cung cấp tham số này sẽ trả về một mảng ngay cả khi chỉ có một item mong muốn:

use Illuminate\Support\Arr;

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

// [2, 5] - (retrieved randomly)

`Arr::reject()`

Hàm Arr::reject sẽ xoá các phần tử ra khỏi một mảng bằng cách sử dụng closure đã cho:

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()`

Hàm Arr::select sẽ lấy ra một mảng các giá trị từ một mảng:

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()`

Hàm Arr::set sẽ set một giá trị trong một mảng bị lồng nhau bằng cách sử dụng ký hiệu "dot":

use Illuminate\Support\Arr;

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

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

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

`Arr::shuffle()`

Hàm Arr::shuffle sẽ trộn ngẫu nhiên các item có trong mảng:

use Illuminate\Support\Arr;

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

// [3, 2, 5, 1, 4] - (generated randomly)

`Arr::sole()`

Hàm Arr::sole sẽ lấy ra một giá trị từ một mảng bằng closure đã cho. Nếu có nhiều hơn một giá trị trong mảng giống với điều kiện đã cho, thì một ngoại lệ Illuminate\Support\MultipleItemsFoundException sẽ được đưa ra. Nếu không có giá trị nào giống với điều kiện, thì một ngoại lệ Illuminate\Support\ItemNotFoundException cũng sẽ được đưa ra:

use Illuminate\Support\Arr;

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

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

// 'Desk'

`Arr::some()`

Hàm Arr::some sẽ đảm bảo rằng có ít nhất một giá trị trong mảng thỏa mãn một điều kiện cho trước:

use Illuminate\Support\Arr;

$array = [1, 2, 3];

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

// true

`Arr::sort()`

Hàm Arr::sort sẽ sắp xếp một mảng theo các giá trị của nó:

use Illuminate\Support\Arr;

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

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

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

Bạn cũng có thể sắp xếp mảng theo kết quả của closure đã cho:

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()`

Hàm Arr::sortDesc sẽ sắp xếp một mảng theo thứ tự giảm dần bằng các giá trị của chính nó:

use Illuminate\Support\Arr;

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

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

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

Bạn cũng có thể sắp xếp một mảng theo kết quả của một closure đã cho:

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()`

Hàm Arr::sortRecursive sẽ sắp xếp đệ quy một mảng bằng cách sử dụng hàm sort cho mảng không có key, còn nếu mảng đó có key thì sẽ dùng hàm 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'],
    ]
*/

Nếu bạn muốn kết quả được sắp xếp theo thứ tự giảm dần, bạn có thể sử dụng phương thức Arr::sortRecursiveDesc.

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

`Arr::string()`

Hàm Arr::string sẽ lấy một giá trị từ một mảng lồng nhau bằng cách sử dụng ký tự "chấm" (giống như hàm Arr::get()), nhưng sẽ đưa ra một InvalidArgumentException nếu giá trị được yêu cầu không phải là một 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()`

Hàm Arr::take sẽ trả về một mảng mới với số lượng item được chỉ định:

use Illuminate\Support\Arr;

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

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

// [0, 1, 2]

Bạn cũng có thể truyền một số âm để lấy số phần tử được chỉ định từ cuối mảng trở về:

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

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

// [4, 5]

`Arr::toCssClasses()`

Hàm Arr::toCssClasses sẽ compile ra một chuỗi class CSS theo một điều kiện. Phương thức chấp nhận một mảng gồm các class trong đó khóa mảng sẽ chứa class hoặc các class mà bạn muốn thêm vào, trong khi giá trị là một biểu thức boolean. Nếu một phần tử mảng có một khóa là dạng số, thì nó sẽ luôn được đưa vào danh sách class được tạo:

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()`

Hàm Arr::toCssStyles sẽ compile có điều kiện một chuỗi CSS style. Phương thức này chấp nhận một mảng các khai báo CSS trong đó khóa của mảng đó sẽ chứa khai báo CSS mà bạn muốn thêm, trong khi giá trị là một biểu thức boolean. Nếu phần tử của mảng đó có khóa là một số, thì nó sẽ luôn được thêm vào trong chuỗi CSS style đã được compile:

use Illuminate\Support\Arr;

$hasColor = true;

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

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

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

Phương thức này sẽ hỗ trợ chức năng của Laravel cho phép nối các class với các attribute bag của Blade component cũng như lệnh Blade @class.

`Arr::undot()`

Hàm Arr::undot mở rộng một mảng một chiều sử dụng ký tự "chấm" thành một mảng nhiều chiều:

use Illuminate\Support\Arr;

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

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

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

`Arr::where()`

Hàm Arr::where sẽ lọc một mảng bằng cách sử dụng closure:

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()`

Hàm Arr::whereNotNull sẽ loại bỏ tất cả các giá trị null ra khỏi mảng đã cho:

use Illuminate\Support\Arr;

$array = [0, null];

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

// [0 => 0]

`Arr::wrap()`

Hàm Arr::wrap sẽ bao bọc giá trị đã cho vào trong một mảng. Nếu giá trị đã cho là một mảng, nó sẽ được trả về mà không cần sửa đổi gì:

use Illuminate\Support\Arr;

$string = 'Laravel';

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

// ['Laravel']

Nếu giá trị đã cho là null, một mảng trống sẽ được trả về:

use Illuminate\Support\Arr;

$array = Arr::wrap(null);

// []

`data_fill()`

Hàm data_fill sẽ set một giá trị bị thiếu trong một mảng hoặc một đối tượng lồng nhau bằng cách sử dụng ký hiệu "dot":

$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]]]

Hàm này cũng chấp nhận dấu hoa thị dưới dạng như một ký tự đại diện và sẽ điền vào mục tiêu tương ứng:

$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()`

Hàm data_get lấy một giá trị từ một mảng hoặc một đối tượng lồng nhau bằng cách sử dụng ký hiệu "dot":

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

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

// 100

Hàm data_get cũng chấp nhận một giá trị mặc định, sẽ được trả về nếu không tìm thấy key được chỉ định:

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

// 0

Phương thức cũng chấp nhận các ký tự đại diện sử dụng bằng dấu hoa thị để có thể lấy ra bất kỳ khóa nào có trong một mảng hoặc một đối tượng:

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

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

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

Các biến {first} và {last} có thể được sử dụng để lấy ra các item đầu tiên hoặc cuối cùng có trong một mảng:

$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()`

Hàm data_set sẽ set một giá trị trong một mảng hoặc một đối tượng lồng nhau bằng cách sử dụng ký hiệu "dot":

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

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

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

Hàm này cũng chấp nhận ký tự đại diện hoa thị và để set giá trị cho mục tiêu tương ứng:

$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],
        ],
    ]
*/

Mặc định, bất kỳ giá trị hiện có sẽ bị ghi đè. Nếu bạn chỉ muốn set một giá trị nếu nó không tồn tại, bạn có thể truyền false làm tham số thứ tư cho hàm:

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

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

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

`data_forget()`

Hàm data_forget sẽ xóa một giá trị trong một mảng hoặc một đối tượng lồng nhau bằng cách sử dụng ký hiệu "dot":

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

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

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

Hàm này cũng chấp nhận ký tự đại diện sử dụng dấu hoa thị và sẽ xóa các giá trị tương ứng:

$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()`

Hàm head trả về phần tử đầu tiên trong mảng đã cho. Nếu mảng rỗng, giá trị false sẽ được trả về:

$array = [100, 200, 300];

$first = head($array);

// 100

`last()`

Hàm last trả về phần tử cuối cùng trong mảng đã cho. Nếu mảng rỗng, giá trị false sẽ được trả về:

$array = [100, 200, 300];

$last = last($array);

// 300

Numbers

`Number::abbreviate()`

Hàm Number::abbreviate sẽ trả về định dạng dễ đọc hơn cho giá trị số được cung cấp, với hàng đơn vị được viết tắt:

use Illuminate\Support\Number;

$number = Number::abbreviate(1000);

// 1K

$number = Number::abbreviate(489939);

// 490K

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

// 1.23M

`Number::clamp()`

Hàm Number::clamp sẽ đảm bảo là một số nhất định sẽ nằm trong một phạm vi nhất định. Nếu số đó thấp hơn giá trị tối thiểu, thì giá trị tối thiểu sẽ được trả về. Nếu số đó cao hơn giá trị tối đa, thì giá trị tối đa sẽ được trả về:

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()`

Hàm Number::currency sẽ trả về giá trị tiền tệ của giá trị đã cho dưới dạng chuỗi:

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()`

Hàm Number::defaultCurrency sẽ trả về loại tiền tệ mặc định đang được sử dụng bởi class Number:

use Illuminate\Support\Number;

$currency = Number::defaultCurrency();

// USD

`Number::defaultLocale()`

Hàm Number::defaultLocale sẽ trả về ngôn ngữ mặc định đang được sử dụng bởi class Number:

use Illuminate\Support\Number;

$locale = Number::defaultLocale();

// en

`Number::fileSize()`

Hàm Number::fileSize sẽ trả về giá trị kích thước file của một giá trị byte đã cho dưới dạng chuỗi:

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()`

Hàm Number::forHumans sẽ trả về định dạng có thể đọc của một giá trị số được cung cấp:

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()`

Hàm Number::format sẽ định dạng số đã cho thành chuỗi ký tự cụ thể theo ngôn ngữ:

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()`

Hàm Number::ordinal sẽ trả về số thứ tự của một số:

use Illuminate\Support\Number;

$number = Number::ordinal(1);

// 1st

$number = Number::ordinal(2);

// 2nd

$number = Number::ordinal(21);

// 21st

`Number::pairs()`

Phương thức Number::pairs sẽ tạo ra một mảng gồm các cặp số (với phạm vi nằm trong) dựa trên một phạm vi và giá trị tăng được chỉ định. Phương thức này có thể hữu ích để chia nhỏ một phạm vi số lớn hơn thành các phạm vi con nhỏ hơn, để dễ dàng quản lý cho các tác vụ như pagination hoặc xử lý batching. Phương thức pairs sẽ trả về một mảng gồm các mảng, trong đó mỗi mảng con đại diện cho một cặp (phạm vi con) của số:

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::parseInt()`

Phương thức Number::parseInt sẽ phân tích một chuỗi thành một số nguyên dựa trên locale được chỉ định:

use Illuminate\Support\Number;

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

// (int) 10

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

// (int) 10

`Number::parseFloat()`

Phương thức Number::parseFloat sẽ phân tích một chuỗi thành một số thực dựa trên locale được chỉ định:

use Illuminate\Support\Number;

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

// (float) 10.0

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

// (float) 10.0

`Number::percentage()`

Hàm Number::percentage sẽ trả về phần trăm của giá trị đã cho dưới dạng chuỗi:

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()`

Hàm Number::spell sẽ chuyển số đã cho thành một chuỗi các từ:

use Illuminate\Support\Number;

$number = Number::spell(102);

// one hundred and two

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

// quatre-vingt-huit

Tham số after cho phép bạn chỉ định một giá trị mà nhỏ hơn số đã được nhập vào sẽ được viết ra:

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

// 10

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

// eleven

Tham số until cho phép bạn chỉ định một giá trị mà lớn hơn số đã được nhập vào sẽ được viết ra:

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

// five

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

// 10

`Number::spellOrdinal()`

Phương thức Number::spellOrdinal sẽ trả về số thứ tự của chữ số dưới dạng chữ:

use Illuminate\Support\Number;

$number = Number::spellOrdinal(1);

// first

$number = Number::spellOrdinal(2);

// second

$number = Number::spellOrdinal(21);

// twenty-first

`Number::trim()`

Hàm Number::trim sẽ loại bỏ bất kỳ chữ số 0 nào nằm ở cuối sau dấu thập phân của số đã cho:

use Illuminate\Support\Number;

$number = Number::trim(12.0);

// 12

$number = Number::trim(12.30);

// 12.3

`Number::useLocale()`

Hàm Number::useLocale sẽ thiết lập ngôn ngữ global mặc định cho số, điều này sẽ ảnh hưởng đến cách định dạng số và tiền tệ trong các lần gọi tiếp theo tới các phương thức của class Number:

use Illuminate\Support\Number;

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

`Number::withLocale()`

Hàm Number::withLocale sẽ chạy lệnh closure đã cho bằng cách sử dụng ngôn ngữ được truyền vào cho hàm và sau đó khôi phục ngôn ngữ trước đó sau khi lệnh callback đã được chạy xong:

use Illuminate\Support\Number;

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

`Number::useCurrency()`

Hàm Number::useCurrency sẽ set loại tiền tệ global mặc định cho số, điều này sẽ ảnh hưởng đến cách định dạng tiền tệ trong các lần gọi tiếp theo tới các phương thức của class Number:

use Illuminate\Support\Number;

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

`Number::withCurrency()`

Hàm Number::withCurrency sẽ chạy lệnh closure đã cho bằng loại tiền tệ đã được chỉ định và sau đó khôi phục loại tiền tệ trước đó sau khi lệnh callback đã được chạy xong:

use Illuminate\Support\Number;

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

Paths

`app_path()`

Hàm app_path sẽ trả về đường dẫn đến thư mục app của ứng dụng. Bạn cũng có thể sử dụng hàm app_path để tạo đường dẫn đến file trong thư mục app:

$path = app_path();

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

`base_path()`

Hàm base_path sẽ trả về đường dẫn đến thư mục root của ứng dụng. Bạn cũng có thể sử dụng hàm base_path để tạo đường dẫn đến file trong thư mục root của project:

$path = base_path();

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

`config_path()`

Hàm config_path sẽ trả về đường dẫn đến thư mục config của ứng dụng. Bạn cũng có thể sử dụng hàm config_path để tạo đường dẫn đến file trong thư mục config:

$path = config_path();

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

`database_path()`

Hàm database_path sẽ trả về đường dẫn đến thư mục database của ứng dụng. Bạn cũng có thể sử dụng hàm database_path để tạo đường dẫn đến file trong thư mục database:

$path = database_path();

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

`lang_path()`

Hàm lang_path sẽ trả về đường dẫn đến thư mục lang của ứng dụng. Bạn cũng có thể sử dụng hàm lang_path để tạo đường dẫn đến file trong thư mục:

$path = lang_path();

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

[!NOTE] Mặc định, Laravel không chứa thư mục lang. Nếu bạn muốn tùy chỉnh các file ngôn ngữ của Laravel, bạn có thể publish các file đó thông qua lệnh Artisan lang:publish.

`public_path()`

Hàm public_path sẽ trả về đường dẫn đến thư mục public của ứng dụng. Bạn cũng có thể sử dụng hàm public_path để tạo đường dẫn đến file trong thư mục public:

$path = public_path();

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

`resource_path()`

Hàm resource_path sẽ trả về đường dẫn đến thư mục resources của ứng dụng. Bạn cũng có thể sử dụng hàm resource_path để tạo đường dẫn đến file trong thư mục resources:

$path = resource_path();

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

`storage_path()`

Hàm storage_path sẽ trả về đường dẫn đến thư mục storage của ứng dụng. Bạn cũng có thể sử dụng hàm storage_path để tạo đường dẫn đến file trong thư mục storage:

$path = storage_path();

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

URLs

`action()`

Hàm action sẽ tạo ra một URL cho một action của controller đã cho:

use App\Http\Controllers\HomeController;

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

Nếu phương thức chấp nhận tham số cho route, bạn có thể truyền chúng làm tham số thứ hai cho phương thức:

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

`asset()`

Hàm asset sẽ tạo URL cho một asset bằng cách sử dụng scheme hiện tại của request (HTTP hoặc HTTPS):

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

Bạn có thể cấu hình URL host cho asset bằng cách set biến ASSET_URL trong file .env của bạn. Điều này có thể hữu ích nếu bạn đang lưu trữ các asset của bạn trong một dịch vụ bên ngoài như Amazon S3 hoặc một dịch vụ CDN khác:

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

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

`route()`

Hàm route sẽ tạo một URL cho một route đã được đặt tên:

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

Nếu route có chấp nhận tham số, bạn có thể truyền chúng làm tham số thứ hai cho phương thức:

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

Mặc định, hàm route sẽ tạo ra một URL tuyệt đối. Nếu bạn muốn tạo một URL tương đối, bạn có thể truyền false làm tham số thứ ba cho phương thức:

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

`secure_asset()`

Hàm secure_asset sẽ tạo URL cho một asset bằng HTTPS:

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

`secure_url()`

Hàm secure_url sẽ tạo URL HTTPS cho đường dẫn đã cho. Các parameter của URL có thể được truyền vào thông qua tham số thứ hai của phương thức:

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

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

`to_action()`

Hàm to_action sẽ tạo ra một redirect HTTP response cho một action của một controller:

use App\Http\Controllers\UserController;

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

Nếu cần, bạn cũng có thể truyền thêm một HTTP status code sẽ được gán cho redirect và thêm các response headers làm tham số thứ ba và thứ tư của phương thức to_action:

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

`to_route()`

Hàm to_route sẽ tạo ra một redirect HTTP response cho một route đã được đặt tên:

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

Nếu cần, bạn cũng có thể truyền thêm một HTTP status code được gán cho redirect và thêm các response headers làm tham số thứ ba và thứ tư của phương thức to_route:

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

`uri()`

Hàm uri sẽ tạo ra một URI instance cho URI đã cho:

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

Nếu hàm uri được cung cấp một mảng chứa một cặp controller và method, hàm sẽ tạo ra một instance Uri cho đường dẫn route của phương thức controller đó:

use App\Http\Controllers\UserController;

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

Nếu controller là invokable, bạn chỉ cần cung cấp tên class của controller:

use App\Http\Controllers\UserIndexController;

$uri = uri(UserIndexController::class);

Nếu giá trị được cung cấp cho hàm uri giống với tên của một route đã được đặt tên, một instance Uri sẽ được tạo ra cho đường dẫn của route đó:

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

`url()`

Hàm url tạo ra một URL cho đường dẫn đã cho:

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

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

Nếu không có đường dẫn nào được cung cấp, một instance Illuminate\Routing\UrlGenerator sẽ được trả về:

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

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

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

Để biết thêm thông tin về cách làm việc với hàm url, hãy tham khảo tài liệu tạo URL.

Miscellaneous

`abort()`

Hàm abort sẽ đưa ra một exception HTTP được tạo bởi exception handler:

abort(403);

Bạn cũng có thể cung cấp message và response header tùy biến của exception mà sẽ được gửi về trình duyệt:

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

`abort_if()`

Hàm abort_if sẽ đưa ra một exception HTTP nếu một biểu thức boolean đã cho là true:

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

Giống như phương thức abort, bạn cũng có thể cung cấp response text cho exception làm tham số thứ ba và một mảng các response header tùy biến làm tham số thứ tư cho phương thức.

`abort_unless()`

Hàm abort_unless sẽ đưa ra một exception HTTP nếu một biểu thức boolean đã cho là false:

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

`app()`

Hàm app trả về instance service container:

$container = app();

Bạn có thể truyền một tên class hoặc một tên interface để resolve nó từ container:

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

`auth()`

Hàm auth sẽ trả về một instance authenticator. Bạn có thể sử dụng nó như là một thay thế cho facade Auth:

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

Nếu cần, bạn có thể khai báo loại instance guard mà bạn muốn truy cập:

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

`back()`

Hàm back sẽ tạo ra một response HTTP chuyển hướng đến vị trí trước đó của người dùng:

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

return back();

`bcrypt()`

Hàm bcrypt sẽ hashes giá trị đã cho bằng Bcrypt. Bạn có thể sử dụng phương thức này như là một thay thế cho facade Hash:

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

`blank()`

Hàm blank sẽ xác định xem giá trị đã cho là "blank" hay không:

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

// true

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

// false

Để tìm trái ngược của blank, hãy xem phương thức filled.

`broadcast()`

Hàm broadcast sẽ broadcasts một event cho listener của nó:

broadcast(new UserRegistered($user));

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

`broadcast_if()`

Hàm broadcast_if sẽ broadcasts một event cho listener của nó nếu một biểu thức boolean đã cho trả về true:

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

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

`broadcast_unless()`

Hàm broadcast_unless sẽ broadcasts một event cho listener của nó nếu một biểu thức boolean đã cho trả về false:

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

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

`cache()`

Hàm cache có thể được sử dụng để lấy các giá trị từ cache. Nếu key đã cho không tồn tại trong cache, giá trị mặc định sẽ được trả về:

$value = cache('key');

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

Bạn có thể thêm các item vào cache bằng cách truyền một mảng các cặp key / giá trị cho hàm. Bạn cũng nên truyền thêm số giây hoặc thời gian mà giá trị được lưu trong bộ nhớ cache sẽ được coi là hợp lệ:

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

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

`class_uses_recursive()`

Hàm class_uses_recursive sẽ trả về tất cả các trait được sử dụng bởi một class, bao gồm cả các trait được sử dụng bởi tất cả các class cha của nó:

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

`collect()`

Hàm collect tạo ra một instance collection từ giá trị đã cho:

$collection = collect(['taylor', 'abigail']);

`config()`

Hàm config sẽ lấy giá trị của biến configuration. Các giá trị cấu hình có thể được truy cập bằng cú pháp "dot", bao gồm tên của file và option bạn muốn truy cập. Bạn cũng có thể cung cấp một giá trị mặc định sẽ được trả về nếu tùy chọn cấu hình không tồn tại:

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

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

Bạn có thể set các biến cấu hình trong thời gian chạy bằng cách truyền một mảng các cặp key / giá trị. Tuy nhiên, lưu ý rằng chức năng này chỉ ảnh hưởng đến các giá trị cấu hình cho request hiện tại và không cập nhật giá trị cấu hình thực tế của bạn:

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

`context()`

Hàm context sẽ lấy giá trị từ context hiện tại. Bạn cũng có thể cung cấp một giá trị mặc định sẽ được trả về nếu khóa của context đó không tồn tại:

$value = context('trace_id');

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

Bạn có thể set giá trị của context bằng cách truyền vào một mảng gồm các cặp key và value:

use Illuminate\Support\Str;

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

`cookie()`

Hàm cookie tạo một instance cookie mới:

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

`csrf_field()`

Hàm csrf_field sẽ tạo ra một thẻ input hidden HTML chứa giá trị của CSRF token. Ví dụ: sử dụng Blade syntax:

{{ csrf_field() }}

`csrf_token()`

Hàm csrf_token sẽ lấy ra giá trị của CSRF token hiện tại:

$token = csrf_token();

`decrypt()`

Hàm decrypt sẽ giải mã giá trị đã cho. Bạn có thể sử dụng hàm này thay cho facade Crypt:

$password = decrypt($value);

Để xem ngược của hàm decrypt, hãy xem hàm encrypt.

`dd()`

Hàm dd sẽ dump các biến đã cho và dừng thực thi lệnh:

dd($value);

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

Nếu bạn không muốn dừng việc thực thi lệnh của bạn, hãy sử dụng hàm dump để thay thế.

`dispatch()`

Hàm dispatch sẽ tạo job vào Laravel job queue:

dispatch(new App\Jobs\SendEmails);

`dispatch_sync()`

Hàm dispatch_sync sẽ gửi job đã cho vào sync queue để job đó được xử lý ngay lập tức:

dispatch_sync(new App\Jobs\SendEmails);

`dump()`

Hàm dump sẽ dump các biến đã cho:

dump($value);

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

Nếu bạn muốn dừng thực thi lệnh sau khi dump các biến, hãy sử dụng hàm dd để thay thế.

`encrypt()`

Hàm encrypt sẽ mã hóa giá trị đã cho. Bạn có thể sử dụng hàm này thay cho facade Crypt:

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

Để xem ngược của hàm encrypt, hãy xem hàm decrypt.

`env()`

Hàm env sẽ lấy ra giá trị của environment variable hoặc trả về giá trị mặc định:

$env = env('APP_ENV');

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

[!WARNING] Nếu bạn chạy lệnh config:cache trong quá trình deploy của bạn, bạn nên chắc chắn rằng bạn chỉ gọi hàm env từ các file cấu hình của bạn. Khi các option cấu hình đã được lưu vào cached, file .env sẽ không được load và tất cả các lệnh gọi đến hàm env sẽ trả về các biến môi trường bên ngoài, chẳng hạn như các biến môi trường cấp server hoặc cấp system, hoặc là null.

`event()`

Hàm event sẽ dispatch event đến listener:

event(new UserRegistered($user));

`fake()`

Hàm fake sẽ resolve một Faker từ container, và có thể hữu ích khi tạo dữ liệu giả trong các model factory, database seeding, test và xem thử 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

Mặc định, hàm fake sẽ sử dụng tùy chọn cấu hình app.faker_locale trong file cấu hình config/app.php của bạn. Thông thường, tùy chọn cấu hình này sẽ được set thông qua biến môi trường APP_FAKER_LOCALE. Bạn cũng có thể chỉ định ngôn ngữ này bằng cách truyền nó tới hàm fake. Mỗi ngôn ngữ sẽ được resolve ra một instance riêng biệt:

fake('nl_NL')->name()

`filled()`

Hàm filled sẽ xác định xem giá trị đã cho không là "blank" hay không:

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

// true

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

// false

Để tìm trái ngược của filled, hãy xem phương thức blank.

`info()`

Hàm info sẽ ghi thông tin vào log của application của bạn:

info('Some helpful information!');

Một mảng dữ liệu theo ngữ cảnh cũng có thể được truyền cho hàm:

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

`literal()`

Hàm literal sẽ tạo ra một instance stdClass mới với các tham số đã cho là các thuộc tính của instance mới được tạo ra:

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

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

`logger()`

Hàm logger có thể được sử dụng để viết một thông báo ở mức debug vào log:

logger('Debug message');

Một mảng dữ liệu theo ngữ cảnh cũng có thể được truyền cho hàm:

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

Một instance logger sẽ được trả về nếu không có giá trị nào được truyền vào cho hàm:

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

`method_field()`

Hàm method_field tạo ra thẻ input hidden HTML chứa giá trị HTTP action của form. Ví dụ: sử dụng Blade syntax:

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

`now()`

Hàm now sẽ tạo ra một instance Illuminate\Support\Carbon mới cho thời điểm hiện tại:

$now = now();

`old()`

Hàm old sẽ lấy ra một giá trị old input được flash trong session :

$value = old('value');

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

Vì "giá trị mặc định" được cung cấp làm tham số thứ hai cho hàm old thường là một thuộc tính của model Eloquent, nên Laravel cho phép bạn chỉ cần truyền toàn bộ model Eloquent làm tham số thứ hai cho hàm old. Khi làm như vậy, Laravel sẽ coi tham số đầu tiên được cung cấp cho hàm old là tên của thuộc tính của Eloquent và cũng coi giá trị của thuộc tính đó trong Eloquent là "giá trị mặc định" nếu không tìm thấy giá trị đó trong session:

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

// Is equivalent to...

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

`once()`

Hàm once sẽ chạy một callback đã cho và lưu kết quả vào bộ nhớ cache trong suốt thời gian của request. Bất kỳ lời gọi tiếp theo nào đến hàm once với cùng một callback sẽ trả về kết quả đã được lưu trong bộ nhớ cache trước đó:

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

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

Khi hàm once được chạy bên trong một instance đối tượng, thì kết quả được cache sẽ là instance của đối tượng đó:

<?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()`

Hàm optional nhận vào bất kỳ tham số nào và cho phép bạn truy cập vào các thuộc tính hoặc các phương thức trên đối tượng đó. Nếu đối tượng đã cho là null, thì các thuộc tính hoặc các phương thức đó sẽ trả về null thay vì gây ra lỗi:

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

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

Hàm optional cũng chấp nhận một closure làm tham số thứ hai của nó. Closure sẽ được gọi nếu giá trị tham số đầu tiên không phải là một giá trị null:

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

`policy()`

Hàm policy sẽ lấy ra một instance policy cho một class nhất định:

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

`redirect()`

Hàm redirect sẽ trả về một response HTTP chuyển hướng hoặc trả về instance chuyển hướng nếu không có tham số được truyền vào:

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

return redirect('/home');

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

`report()`

Hàm report sẽ report một exception bằng cách sử dụng exception handler của bạn:

report($e);

Hàm report cũng sẽ chấp nhận một chuỗi làm tham số đầu vào. Khi một chuỗi được cấp cho hàm, hàm sẽ tạo ra một ngoại lệ với chuỗi đã cho dưới dạng một thông báo của nó:

report('Something went wrong.');

`report_if()`

Hàm report_if sẽ report ra một ngoại lệ bằng cách sử dụng exception handler của bạn nếu một biểu thức boolean trả về giá trị true:

report_if($shouldReport, $e);

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

`report_unless()`

Hàm report_unless sẽ report ra một ngoại lệ bằng cách sử dụng exception handler của bạn nếu một biểu thức boolean trả về giá trị false:

report_unless($reportingDisabled, $e);

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

`request()`

Hàm request trả về instance request hiện tại hoặc lấy ra một giá trị của trường input từ request hiện tại:

$request = request();

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

`rescue()`

Hàm rescue sẽ thực thi closure đã cho và catch bất kỳ exception nào xảy ra trong quá trình thực thi. Tất cả các exception bị catch sẽ được gửi đến exception handler của bạn; tuy nhiên, request sẽ tiếp tục xử lý:

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

Bạn cũng có thể truyền tham số thứ hai cho hàm rescue. Tham số này sẽ là giá trị "default" cần được trả về nếu có exception xảy ra trong khi thực hiện closure:

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

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

Có thể cung cấp tham số report cho hàm rescue để xác định xem ngoại lệ có được report thông qua hàm report hay không:

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

`resolve()`

Hàm resolve sẽ resolve một tên class hoặc một interface đã cho thành một instance bằng cách sử dụng service container:

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

`response()`

Hàm response tạo ra một instance response hoặc lấy ra một instance của response factory:

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

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

`retry()`

Hàm retry sẽ thử thực hiện callback đã cho, cho đến khi đạt được ngưỡng thử tối đa nào đó. Nếu callback không đưa ra exception, chính giá trị trả về của nó sẽ được trả về. Nếu callback đưa ra một exception, nó sẽ tự động được thử lại. Nếu vượt quá số lần thử tối đa, exception sẽ bị đưa ra:

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

Thời gian nghỉ cũng chấp nhận một instance CarbonInterval:

use function Illuminate\Support\seconds;

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

Nếu bạn muốn đưa vào một số lượng mili giây để ngủ giữa các lần thử, bạn có thể truyền một closure làm tham số thứ ba cho hàm retry:

use Exception;

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

Để thuận tiện, bạn cũng có thể cung cấp một mảng làm tham số đầu tiên cho hàm retry. Mảng này sẽ được sử dụng để xác định số mili giây sẽ ngủ giữa các lần thử tiếp theo:

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

Để chỉ thử lại trong một điều kiện cụ thể, bạn có thể truyền một closure làm tham số thứ tư cho hàm retry:

use App\Exceptions\TemporaryException;
use Exception;

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

`session()`

Hàm session có thể được sử dụng để lấy hoặc set các giá trị session values:

$value = session('key');

Bạn có thể set giá trị bằng cách truyền một mảng các cặp key / giá trị cho hàm:

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

Session store sẽ được trả về nếu không có giá trị nào được truyền cho hàm:

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

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

`tap()`

Hàm tap sẽ nhận vào hai tham số: một là $value và một closure. $value sẽ được truyền đến phần closure và sau đó được trả về bởi hàm tap. Giá trị trả về của closure sẽ không liên quan:

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

    $user->save();
});

Nếu không có closure nào được truyền đến hàm tap, bạn có thể gọi bất kỳ phương thức nào trên $value đã cho. Giá trị trả về của phương thức bạn gọi sẽ luôn là $value, bất kể phương thức đó thực sự trả về định nghĩa gì đi chăng nữa. Ví dụ, phương thức update Eloquent thường trả về một số nguyên. Tuy nhiên, chúng ta có thể buộc phương thức này trả về chính model đó bằng cách gọi phương thức update thông qua hàm tap:

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

Để thêm một phương thức tap vào một class, bạn có thể thêm trait Illuminate\Support\Traits\Tappable vào class. Hàm tap của trait này sẽ chấp nhận một Closure làm tham số duy nhất của nó. Chính instance đối tượng sẽ được truyền đến Closure và sau đó được trả về bởi phương thức tap:

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

`throw_if()`

Hàm throw_if sẽ đưa ra exception đã cho nếu một biểu thức boolean đã cho là 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()`

Hàm throw_unless sẽ đưa ra exception đã cho nếu một biểu thức boolean đã cho là false:

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

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

`today()`

Hàm today sẽ tạo ra một instance Illuminate\Support\Carbon mới cho ngày hiện tại:

$today = today();

`trait_uses_recursive()`

Hàm trait_uses_recursive trả về tất cả các trait được sử dụng bởi một trait:

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

`transform()`

Hàm transform sẽ thực thi một closure trên một giá trị đã cho nếu giá trị không blank và sau đó trả về giá trị trả về của một closure:

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

$result = transform(5, $callback);

// 10

Một giá trị mặc định hoặc một closure có thể được truyền làm tham số thứ ba cho phương thức. Giá trị này sẽ được trả về nếu giá trị đã cho là blank:

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

// The value is blank

`validator()`

Hàm validator sẽ tạo ra một instance validator mới với các tham số đã cho. Bạn có thể sử dụng nó như là một thay thế cho facade Auth:

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

`value()`

Hàm value sẽ trả về giá trị được cho. Tuy nhiên, nếu bạn truyền một closure cho hàm, thì closure sẽ được thực thi và giá trị trả về của nó sẽ được trả về:

$result = value(true);

// true

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

// false

Các tham số bổ sung khác cũng có thể được truyền đến hàm value. Nếu tham số đầu tiên là một closure thì các tham số bổ sung tiếp theo sẽ được truyền đến closure dưới dạng các tham số, nếu không chúng sẽ bị bỏ qua:

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

// 'Taylor'

`view()`

Hàm view sẽ lấy ra một instance view:

return view('auth.login');

`with()`

Hàm with sẽ trả về giá trị được cho. Nếu một closure được truyền làm tham số thứ hai cho hàm, thì closure đó sẽ được thực thi và giá trị trả về của nó sẽ được trả về:

$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()`

Hàm when sẽ trả về giá trị đã cho nếu một điều kiện được xác định là true. Và ngược lại nếu là false, thì giá trị null sẽ được trả về. Nếu một closure được truyền vào làm tham số thứ hai của hàm, thì closure đó sẽ được thực thi và giá trị trả về của closure đó sẽ được trả về:

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

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

Hàm when sẽ chủ yếu hữu dụng cho việc hiển thị có điều kiện các thuộc tính HTML:

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

Các class hữu ích khác

Benchmarking

Thỉnh thoảng bạn có thể muốn kiểm tra nhanh hiệu suất của một số phần nhất định trong ứng dụng của bạn. Trong những trường hợp đó, bạn có thể sử dụng class hỗ trợ Benchmark để đo số mili giây cần thiết để hoàn thành các callback nhất định:

<?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
]);

Mặc định, các callback đã cho sẽ được thực hiện một lần và thời gian thực hiện của chúng sẽ được hiển thị trong trình duyệt hoặc console.

Để gọi một callback nhiều lần, bạn có thể chỉ định số lần lặp mà callback sẽ được gọi làm tham số thứ hai cho phương thức. Khi thực hiện callback nhiều lần, class Benchmark sẽ trả về số mili giây trung bình cần thiết để thực hiện callback trên tất cả các lần lặp:

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

Thỉnh thoảng, bạn có thể muốn đánh giá việc thực hiện lệnh callback trong khi vẫn lấy ra giá trị trả về của lệnh callback. Phương thức value sẽ trả về một giá trị trả về của lệnh callback và số mili giây cần thiết để thực hiện lệnh callback:

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

Date và Time

Laravel có chứa Carbon, một thư viện xử lý ngày và giờ mạnh mẽ. Để tạo một instance Carbon mới, bạn có thể gọi hàm now. Hàm này có sẵn trong toàn bộ ứng dụng Laravel của bạn:

$now = now();

Hoặc, bạn có thể tạo một instance Carbon mới bằng cách sử dụng class Illuminate\Support\Carbon:

use Illuminate\Support\Carbon;

$now = Carbon::now();

Laravel cũng bổ sung cho các instance Carbon các phương thức plus và minus, cho phép dễ dàng thao tác với ngày và giờ của instance đó:

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);

Để thảo luận kỹ hơn về Carbon và các tính năng của nó, vui lòng tham khảo tài liệu chính thức của Carbon.

Interval Functions

Laravel cũng cung cấp các hàm milliseconds, seconds, minutes, hours, days, weeks, months, và years trả về các instance CarbonInterval, các instance này extend từ PHP's DateInterval class. Các hàm này có thể được sử dụng ở bất cứ đâu mà Laravel chấp nhận một instance DateInterval:

use Illuminate\Support\Facades\Cache;

use function Illuminate\Support\{minutes};

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

Phương thức chạy sau

Trong khi queued jobs của Laravel cho phép bạn đưa queue các task để xử lý background, thỉnh thoảng bạn có thể có những tác vụ đơn giản mà bạn muốn trì hoãn mà không cần cấu hình hoặc duy trì một queue worker chạy dài hạn.

Các phương thức chạy sau cho phép bạn trì hoãn việc chạy một closure cho đến sau khi response HTTP đã được gửi đến người dùng, giúp ứng dụng của bạn luôn nhanh và phản hồi tốt. Để trì hoãn việc chạy một closure, bạn chỉ cần truyền closure đó vào hàm 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;
});

Mặc định, các phương thức chạy sau này sẽ chỉ được thực hiện nếu response HTTP, lệnh Artisan hoặc job trong queue trả về thành công. Điều này có nghĩa là các phương thức này sẽ không được chạy nếu một request mà có response HTTP là 4xx hoặc 5xx. Nếu bạn muốn một phương thức này luôn được thực hiện, thì bạn có thể nối thêm phương thức always vào sau phương thức chạy sau của bạn:

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

[!WARNING] Nếu bạn đã cài đặt extension Swoole PHP, hàm defer của Laravel có thể bị xung đột với hàm defer global của chính Swoole, dẫn đến lỗi web server. Hãy đảm bảo bạn gọi helper defer của Laravel bằng cách sử dụng namespace: use function Illuminate\Support\defer;

Cancelling Deferred Functions

Nếu bạn cần hủy một phương thức chạy sau trước khi nó được thực hiện, thì bạn có thể sử dụng phương thức forget để hủy phương thức đó bằng tên của nó. Để đặt tên cho một phương thức chạy sau, hãy cung cấp tham số thứ hai cho hàm Illuminate\Support\defer:

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

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

Disabling Deferred Functions in Tests

Khi viết các bài test, bạn có thể cần vô hiệu hóa các phương thức chạy sau. Bạn có thể gọi withoutDefer trong bài test của bạn để hướng dẫn Laravel chạy ngay tất cả các phương thức chạy sau mà không cần đợi khi response gửi về người dùng:

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

    // ...
});

use Tests\TestCase;

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

        // ...
    }
}

Nếu bạn muốn vô hiệu hóa các phương thức chạy sau cho tất cả các bài test trong một test case, bạn có thể gọi phương thức withoutDefer từ phương thức setUp trên base class TestCase của bạn:

<?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]
}

Lottery

Class lottery của Laravel có thể được sử dụng để thực hiện lệnh callback dựa trên một tập hợp tỷ lệ nhất định. Điều này có thể đặc biệt hữu ích khi bạn chỉ muốn thực hiện code trên một tỷ lệ phần trăm các request được gửi đến của bạn:

use Illuminate\Support\Lottery;

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

Bạn có thể kết hợp class lottery của Laravel với các tính năng khác của Laravel. Ví dụ: bạn có thể chỉ muốn report một tỷ lệ nhỏ các truy vấn chậm trong exception handler của bạn. Và, vì class lottery là một callable được nên chúng ta có thể truyền một instance của class đó vào bất kỳ phương thức nào mà chấp nhận một 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.')),
);

Testing Lotteries

Laravel cung cấp một số phương thức đơn giản để cho phép bạn dễ dàng kiểm tra các lottery trong ứng dụng của bạn:

// 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

Facade Pipeline của Laravel cung cấp một cách thuận tiện để "dẫn" một input nhất định qua một loạt các invokable class, closure hoặc callable, cung cấp cho mỗi invokable class cơ hội kiểm tra hoặc sửa input và gọi callable tiếp theo trong pipeline:

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);

Như bạn có thể thấy, mỗi invokable class hoặc closure có thể được gọi trong pipeline cùng với việc được cung cấp input cho các invokable class hoặc closure đó và cuối cùng là closure $next. Việc gọi closure $next sẽ gọi callable tiếp theo trong pipeline. Như bạn có thể thấy, điều này rất giống với middleware.

Khi callable cuối cùng trong pipeline gọi closure $next, callable được cung cấp cho phương thức then sẽ được gọi. Thông thường, callable này sẽ chỉ trả về input đã cho. Để thuận tiện, nếu bạn chỉ muốn trả về input sau khi nó đã được xử lý, bạn có thể sử dụng phương thức thenReturn:

Tất nhiên, như đã thảo luận trước đó, bạn không bị giới hạn trong việc cung cấp closure cho pipeline của bạn. Bạn cũng có thể cung cấp các invokable class. Nếu tên class được truyền vào, thì class đó sẽ được khởi tạo thông qua service container của Laravel, cho phép các dependency được inject vào invokable class:

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

Phương thức withinTransaction có thể được gọi trên pipeline để tự động chạy tất cả các bước của pipeline trong một database transaction duy nhất:

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

Sleep

Class Sleep của Laravel là một class wrapper nhẹ cho các hàm sleep và usleep của PHP, cung cấp khả năng kiểm tra tốt hơn đồng thời cung cấp API thân thiện hơn cho nhà phát triển để làm việc với thời gian:

use Illuminate\Support\Sleep;

$waiting = true;

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

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

Class Sleep cung cấp nhiều phương thức khác nhau cho phép bạn làm việc với các đơn vị thời gian khác nhau:

// Return a value after sleeping...
$result = Sleep::for(1)->second()->then(fn () => 1 + 1);

// Sleep while a given value is true...
Sleep::for(1)->second()->while(fn () => shouldKeepSleeping());

// Pause execution for 90 seconds...
Sleep::for(1.5)->minutes();

// Pause execution for 2 seconds...
Sleep::for(2)->seconds();

// Pause execution for 500 milliseconds...
Sleep::for(500)->milliseconds();

// Pause execution for 5,000 microseconds...
Sleep::for(5000)->microseconds();

// Pause execution until a given time...
Sleep::until(now()->plus(minutes: 1));

// Alias of PHP's native "sleep" function...
Sleep::sleep(2);

// Alias of PHP's native "usleep" function...
Sleep::usleep(5000);

Để dễ dàng kết hợp với các đơn vị thời gian khác, bạn có thể sử dụng phương thức and:

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

Testing Sleep

Khi kiểm tra các code mà sử dụng class Sleep hoặc các hàm sleep gốc của PHP, bài kiểm tra của bạn sẽ phải tạm dừng thực hiện khi chạy vào hàm sleep. Như bạn có thể thấy, điều này làm cho bài kiểm tra của bạn chậm hơn đáng kể. Ví dụ, hãy tưởng tượng bạn đang kiểm tra code sau:

$waiting = /* ... */;

$seconds = 1;

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

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

Thông thường, việc kiểm tra code này sẽ mất ít nhất một giây để chờ sleep. May mắn thay, class Sleep cho phép chúng ta "fake" thời gian sleep để bài kiểm tra của bạn vẫn chạy được nhanh:

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

    // ...
});

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

    // ...
}

Khi fake class Sleep, việc tạm dừng để sleep thực tế sẽ bị bỏ qua, dẫn đến bài kiểm tra của chúng ta nhanh hơn đáng kể.

Sau khi class Sleep đã được fake, bạn có thể đưa ra các kiểm tra cho các "sleep" dự kiến đáng lẽ phải xảy ra. Để minh họa điều này, hãy tưởng tượng chúng ta đang thử nghiệm code tạm dừng thực thi ba lần, với mỗi lần tạm dừng tăng thêm một giây. Sử dụng phương thức assertSequence, chúng ta có thể kiểm tra code của chúng ta đã "sleep" trong khoảng thời gian thích hợp trong khi vẫn giữ cho bài kiểm tra của chúng ta được nhanh:

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(),
    ]);
}

Tất nhiên, class Sleep cung cấp nhiều kiểm tra khác mà bạn có thể sử dụng khi testing:

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

// Assert that sleep was called 3 times...
Sleep::assertSleptTimes(3);

// Assert against the duration of sleep...
Sleep::assertSlept(function (Duration $duration): bool {
    return /* ... */;
}, times: 1);

// Assert that the Sleep class was never invoked...
Sleep::assertNeverSlept();

// Assert that, even if Sleep was called, no execution paused occurred...
Sleep::assertInsomniac();

Thỉnh thoảng, có thể hữu ích khi thực hiện một hành động nào đó khi một fake sleep xảy ra. Để đạt được điều này, bạn có thể cung cấp một lệnh callback cho phương thức whenFakingSleep. Trong ví dụ sau, chúng ta sử dụng helper tương tác với time của Laravel để đưa thời gian hiện tại đến luôn thời gian sau mỗi lần sleep:

use Carbon\CarbonInterval as Duration;

$this->freezeTime();

Sleep::fake();

Sleep::whenFakingSleep(function (Duration $duration) {
    // Progress time when faking sleep...
    $this->travel($duration->totalMilliseconds)->milliseconds();
});

Việc di chuyển thời gian là một yêu cầu rất phổ biến trong các bài test, nên phương thức fake chấp nhận một tham số syncWithCarbon để giữ cho Carbon được đồng bộ khi sleep trong bài test:

Sleep::fake(syncWithCarbon: true);

$start = now();

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

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

Laravel sử dụng class Sleep ở bên trong bất cứ khi nào code cần tạm dừng thực thi. Ví dụ, helper retry sử dụng class Sleep để chờ cho đến khi một hành động nào đó được thực hiện lại, cho phép cải thiện khả năng kiểm tra khi sử dụng helper này.

Timebox

Class Timebox của Laravel sẽ đảm bảo rằng các callback được cung cấp sẽ luôn mất một khoảng thời gian cố định để thực thi, ngay cả khi trong quá trình thực thi thực tế của nó được hoàn thành sớm hơn. Điều này đặc biệt hữu ích cho các hoạt động mã hóa và kiểm tra xác thực người dùng, nơi mà kẻ tấn công có thể khai thác sự khác biệt về thời gian thực thi để suy ra thông tin nhạy cảm.

Nếu quá trình thực thi vượt quá thời gian cố định, thì Timebox sẽ không còn tác dụng. Tùy thuộc vào nhà phát triển mà có thể chọn ra một khoảng thời gian đủ dài làm thời gian cố định trong đó có tính cả đến các trường hợp xấu nhất.

Phương thức call sẽ chấp nhận một closure và giới hạn thời gian tính bằng micro giây, sau khi thực thi closure thì nó sẽ chờ cho đến khi đạt đến giới hạn thời gian:

use Illuminate\Support\Timebox;

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

Nếu một exception được đưa ra trong closure, thì class này sẽ tuân theo độ trễ đã định và đưa ra exception sau độ trễ đó.

URI

Class Uri của Laravel cung cấp một giao diện thuận tiện và linh hoạt để tạo và thao tác với các URI. Class này bao bọc các chức năng được cung cấp bởi package League URI và được tích hợp liền mạch với hệ thống routing của Laravel.

Bạn có thể tạo một instance của Uri dễ dàng bằng cách sử dụng các phương thức tĩnh:

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

// Generate a URI instance from the given string...
$uri = Uri::of('https://example.com/path');

// Generate URI instances to paths, named routes, or controller actions...
$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);

// Generate a URI instance from the current request URL...
$uri = $request->uri();

Khi bạn đã có một instance của Uri, bạn có thể thao tác với nó một cách linh hoạt:

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

Inspecting URIs

Class Uri cũng cho phép bạn dễ dàng kiểm tra các thành phần khác nhau của 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();

Manipulating Query Strings

Class Uri cung cấp một số phương thức có thể được sử dụng để thao tác với query string của URI. Phương thức withQuery có thể được sử dụng để merge thêm các tham số query string vào các query string hiện có:

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

Phương thức withQueryIfMissing có thể được sử dụng để merge thêm các tham số query string vào các query string hiện có nếu các key được cung cấp chưa tồn tại trong query string:

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

Phương thức replaceQuery có thể được sử dụng để thay thế hoàn toàn query string hiện có bằng một query string khác:

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

Phương thức pushOntoQuery có thể được sử dụng để thêm các tham số vào một tham số query string nếu giá trị là một mảng:

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

Phương thức withoutQuery có thể được sử dụng để xóa các tham số ra khỏi query string:

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

Generating Responses From URIs

Phương thức redirect có thể được sử dụng để tạo một instance RedirectResponse tới URI đã cho:

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

return $uri->redirect();

Hoặc, bạn chỉ cần trả về instance Uri từ một route hoặc một controller action, nó sẽ tự động tạo ra một redirect response đến URI được trả về:

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

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

Prologue

Getting Started

Architecture Concepts

The Basics

Digging Deeper

Security

Database

Eloquent ORM

AI

Testing

Packages

Prologue

Getting Started

Architecture Concepts

The Basics

Digging Deeper

Security

Database

Eloquent ORM

AI

Testing

Packages

Giới thiệu

Các phương thức có sẵn

Arrays & Objects

Numbers

Paths

URLs

Miscellaneous

Arrays & Objects

Arr::accessible()

Arr::add()

Arr::array()

Arr::boolean()

Arr::collapse()

Arr::crossJoin()

Arr::divide()

Arr::dot()

Arr::every()

Arr::except()

Arr::exceptValues()

Arr::exists()

Arr::first()

Arr::flatten()

Arr::float()

Arr::forget()

Arr::from()

Arr::get()

Arr::has()

Arr::hasAll()

Arr::hasAny()

Arr::integer()

Arr::isAssoc()

Arr::isList()

Arr::join()

Arr::keyBy()

Arr::last()

Arr::map()

Arr::mapSpread()

Arr::mapWithKeys()

Arr::only()

Arr::onlyValues()

Arr::partition()

Arr::pluck()

Arr::prepend()

Arr::prependKeysWith()

Arr::pull()

Arr::push()

Arr::query()

Arr::random()

Arr::reject()

Arr::select()

Arr::set()

Arr::shuffle()

Arr::sole()

Arr::some()

Arr::sort()

Arr::sortDesc()

Arr::sortRecursive()

Arr::string()

`Arr::accessible()`

`Arr::add()`

`Arr::array()`

`Arr::boolean()`

`Arr::collapse()`

`Arr::crossJoin()`

`Arr::divide()`

`Arr::dot()`

`Arr::every()`

`Arr::except()`

`Arr::exceptValues()`

`Arr::exists()`

`Arr::first()`

`Arr::flatten()`

`Arr::float()`

`Arr::forget()`

`Arr::from()`

`Arr::get()`

`Arr::has()`

`Arr::hasAll()`

`Arr::hasAny()`

`Arr::integer()`

`Arr::isAssoc()`

`Arr::isList()`

`Arr::join()`

`Arr::keyBy()`

`Arr::last()`

`Arr::map()`

`Arr::mapSpread()`

`Arr::mapWithKeys()`

`Arr::only()`

`Arr::onlyValues()`

`Arr::partition()`

`Arr::pluck()`

`Arr::prepend()`

`Arr::prependKeysWith()`

`Arr::pull()`

`Arr::push()`

`Arr::query()`

`Arr::random()`

`Arr::reject()`

`Arr::select()`

`Arr::set()`

`Arr::shuffle()`

`Arr::sole()`

`Arr::some()`

`Arr::sort()`

`Arr::sortDesc()`

`Arr::sortRecursive()`

`Arr::string()`

`Arr::take()`

`Arr::toCssClasses()`

`Arr::toCssStyles()`

`Arr::undot()`

`Arr::where()`

`Arr::whereNotNull()`

`Arr::wrap()`

`data_fill()`

`data_get()`

`data_set()`

`data_forget()`

`head()`

`last()`

`Number::abbreviate()`

`Number::clamp()`

`Number::currency()`

`Number::defaultCurrency()`

`Number::defaultLocale()`

`Number::fileSize()`

`Number::forHumans()`

`Number::format()`

`Number::ordinal()`

`Number::pairs()`

`Number::parseInt()`

`Number::parseFloat()`

`Number::percentage()`

`Number::spell()`

`Number::spellOrdinal()`

`Number::trim()`

`Number::useLocale()`