Helper trong Laravel 8

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

Paths

app_path base_path config_path database_path mix public_path resource_path storage_path

Strings

Fluent Strings

URLs

action asset route secure_asset secure_url url

Miscellaneous

Method Listing

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

Hàm Arr::collapse sẽ thu gọn một mảng gồm nhiều mảng 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::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::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 ($value, $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::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::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::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::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::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 ($value, $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::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::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::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::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::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::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 ($value) {
    return $value['name'];
}));

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

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

`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'
*/

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 ($value, $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'];

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

`head()`

Hàm head trả về phần tử đầu tiên trong mảng đã cho:

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

$array = [100, 200, 300];

$last = last($array);

// 300

Paths

`app_path()`

Hàm app_path trả về đường dẫn đến thư mục app của application của bạn. Bạn cũng có thể sử dụng hàm app_path để tạo đường dẫn đến một file có bắt đầu từ thư mục app:

$path = app_path();

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

`base_path()`

Hàm base_path trả về đường dẫn đến thư mục root của application của bạn. Bạn cũng có thể sử dụng hàm base_path để tạo đường dẫn đến một file đã cho có bắt đầu từ thư mục gốc của dự án:

$path = base_path();

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

`config_path()`

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

$path = config_path();

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

`database_path()`

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

$path = database_path();

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

`mix()`

Hàm mix trả về đường dẫn đến file Mix đã được version:

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

`public_path()`

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

$path = public_path();

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

`resource_path()`

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

$path = resource_path();

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

`storage_path()`

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

$path = storage_path();

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

Strings

`__()`

Hàm __ sẽ dịch chuỗi cần được dịch hoặc key cần được dịch đã cho bằng cách sử dụng localization files của bạn:

echo __('Welcome to our application');

echo __('messages.welcome');

Nếu chuỗi hoặc key cần được dịch không tồn tại, hàm __ sẽ trả về giá trị được đưa vào. Vì vậy, nếu sử dụng ví dụ mẫu trên, hàm __ sẽ trả về messages.welcome nếu key cần được dịch đó không tồn tại.

`class_basename()`

class_basename trả về tên class đã cho với namespace của class bị xóa:

$class = class_basename('Foo\Bar\Baz');

// Baz

`e()`

Hàm e chạy hàmhtmlspecialchars của PHP với tùy chọn double_encode được set mặc định thành true:

echo e('<html>foo</html>');

// &lt;html&gt;foo&lt;/html&gt;

`preg_replace_array()`

Hàm preg_replace_array sẽ thay thế một pattern vào trong một chuỗi sequentially bằng cách sử dụng một mảng:

$string = 'The event will take place between :start and :end';

$replaced = preg_replace_array('/:[a-z_]+/', ['8:30', '9:00'], $string);

// The event will take place between 8:30 and 9:00

`Str::after()`

Hàm Str::after sẽ trả về mọi thứ đứng sau giá trị đã cho có trong một chuỗi. Toàn bộ chuỗi sẽ được trả về nếu giá trị đó không tồn tại trong chuỗi:

use Illuminate\Support\Str;

$slice = Str::after('This is my name', 'This is');

// ' my name'

`Str::afterLast()`

Hàm Str::afterLast sẽ trả về mọi thứ đứng đằng sau, sau lần xuất hiện cuối cùng của giá trị đã cho trong một chuỗi. Toàn bộ chuỗi sẽ được trả về nếu giá trị đó không tồn tại trong chuỗi:

use Illuminate\Support\Str;

$slice = Str::afterLast('App\Http\Controllers\Controller', '\\');

// 'Controller'

`Str::ascii()`

Hàm Str::ascii sẽ cố thử chuyển một chuỗi thành một giá trị ASCII:

use Illuminate\Support\Str;

$slice = Str::ascii('û');

// 'u'

`Str::before()`

Hàm Str::before sẽ trả về mọi thứ đứng trước giá trị đã cho có trong một chuỗi:

use Illuminate\Support\Str;

$slice = Str::before('This is my name', 'my name');

// 'This is '

`Str::beforeLast()`

Hàm Str::beforeLast sẽ trả về mọi thứ đứng đằng trước, trước lần xuất hiện cuối cùng của giá trị đã cho trong một chuỗi:

use Illuminate\Support\Str;

$slice = Str::beforeLast('This is my name', 'is');

// 'This '

`Str::between()`

Hàm Str::between sẽ trả về một phần của chuỗi nằm giữa hai giá trị đã cho:

use Illuminate\Support\Str;

$slice = Str::between('This is my name', 'This', 'name');

// ' is my '

`Str::camel()`

Hàm Str::camel chuyển đổi chuỗi đã cho thành camelCase:

use Illuminate\Support\Str;

$converted = Str::camel('foo_bar');

// fooBar

`Str::contains()`

Hàm Str::contains xác định xem chuỗi đã cho có chứa giá trị đã cho hay không. Phương thức này phân biệt chữ hoa và chữ thường:

use Illuminate\Support\Str;

$contains = Str::contains('This is my name', 'my');

// true

Bạn cũng có thể truyền vào một mảng các giá trị để xác định xem chuỗi đã cho có chứa bất kỳ giá trị nào trong mảng không:

use Illuminate\Support\Str;

$contains = Str::contains('This is my name', ['my', 'foo']);

// true

`Str::containsAll()`

Hàm Str::containsAll sẽ xác định xem string đã cho có chứa tất cả các giá trị có trong mảng hay không:

use Illuminate\Support\Str;

$containsAll = Str::containsAll('This is my name', ['my', 'name']);

// true

`Str::endsWith()`

Hàm Str::endsWith sẽ kiểm tra chuỗi đã cho có kết thúc bằng giá trị đã cho hay không:

use Illuminate\Support\Str;

$result = Str::endsWith('This is my name', 'name');

// true

Bạn cũng có thể truyền một mảng các giá trị để kiểm tra xem chuỗi đã cho có kết thúc bằng các giá trị có trong số các giá trị đã cho hay không in the array:

use Illuminate\Support\Str;

$result = Str::endsWith('This is my name', ['name', 'foo']);

// true

$result = Str::endsWith('This is my name', ['this', 'foo']);

// false

`Str::finish()`

Hàm Str::finish sẽ thêm một instance của giá trị đã cho vào một chuỗi nếu nó chưa kết thúc bằng giá trị đó:

use Illuminate\Support\Str;

$adjusted = Str::finish('this/string', '/');

// this/string/

$adjusted = Str::finish('this/string/', '/');

// this/string/

`Str::headline()`

Hàm Str::headline sẽ chuyển các chuỗi được phân tách bằng cách viết hoa chữ cái đầu, dấu gạch ngang hoặc dấu gạch dưới thành một chuỗi được phân cách bằng dấu cách và chữ cái đầu tiên của mỗi từ được viết hoa:

use Illuminate\Support\Str;

$headline = Str::headline('steve_jobs');

// Steve Jobs

$headline = Str::headline('EmailNotificationSent');

// Email Notification Sent

`Str::is()`

Hàm Str::is sẽ xác định xem một chuỗi đã cho có khớp với mẫu đã cho hay không. Dấu hoa thị có thể được sử dụng để làm giá trị đại diện:

use Illuminate\Support\Str;

$matches = Str::is('foo*', 'foobar');

// true

$matches = Str::is('baz*', 'foobar');

// false

`Str::isAscii()`

Hàm Str::isAscii sẽ xác định xem một chuỗi đã cho có phải là dạng ASCII 7 bit hay không:

use Illuminate\Support\Str;

$isAscii = Str::isAscii('Taylor');

// true

$isAscii = Str::isAscii('ü');

// false

`Str::isUuid()`

Hàm Str::isUuid sẽ kiểm tra xem chuỗi đã cho có phải là một UUID hợp lệ hay không:

use Illuminate\Support\Str;

$isUuid = Str::isUuid('a0a2a2d2-0b87-4a18-83f2-2529882be2de');

// true

$isUuid = Str::isUuid('laravel');

// false

`Str::kebab()`

Hàm Str::kebab chuyển đổi chuỗi đã cho thành kebab-case:

use Illuminate\Support\Str;

$converted = Str::kebab('fooBar');

// foo-bar

`Str::length()`

Hàm Str::length sẽ trả về độ dài của chuỗi đã cho:

use Illuminate\Support\Str;

$length = Str::length('Laravel');

// 7

`Str::limit()`

Hàm Str::limit sẽ cắt ngắn chuỗi đã cho đến độ dài nhất định:

use Illuminate\Support\Str;

$truncated = Str::limit('The quick brown fox jumps over the lazy dog', 20);

// The quick brown fox...

Bạn có thể truyền một tham số thứ ba vào phương thức để thay đổi chuỗi sẽ được nối vào cuối chuỗi bị cắt ngắn:

use Illuminate\Support\Str;

$truncated = Str::limit('The quick brown fox jumps over the lazy dog', 20, ' (...)');

// The quick brown fox (...)

`Str::lower()`

Hàm Str::lower sẽ chuyển một chuỗi đã cho thành chữ thường:

use Illuminate\Support\Str;

$converted = Str::lower('LARAVEL');

// laravel

`Str::markdown()`

Hàm Str::markdown sẽ chuyển đổi Markdown định dạng theo chuẩn GitHub thành HTML:

use Illuminate\Support\Str;

$html = Str::markdown('# Laravel');

// <h1>Laravel</h1>

$html = Str::markdown('# Taylor <b>Otwell</b>', [
    'html_input' => 'strip',
]);

// <h1>Taylor Otwell</h1>

`Str::mask()`

Hàm Str::mask sẽ che giấu một phần của chuỗi với một ký tự lặp lại và có thể được sử dụng để làm xáo trộn các phân đoạn của chuỗi như địa chỉ email hoặc các số điện thoại:

use Illuminate\Support\Str;

$string = Str::mask('[email protected]', '*', 3);

// tay***************

Nếu cần, bạn cũng có thể cung cấp một số âm làm tham số thứ ba cho phương thức mask, điều này sẽ hướng dẫn phương thức bắt đầu tạo chuỗi ở khoảng cách nhất định tính từ cuối chuỗi trở về:

$string = Str::mask('[email protected]', '*', -15, 3);

// tay***@example.com

`Str::orderedUuid()`

Hàm Str::orderedUuid sẽ tạo một UUID "timestamp first" có thể được lưu trữ tốt trong một cột được index trong cơ sở dữ liệu. Mỗi UUID được tạo ra bằng phương thức này sẽ được sắp xếp sau các UUID đã được tạo ra trước đó:

use Illuminate\Support\Str;

return (string) Str::orderedUuid();

`Str::padBoth()`

Hàm Str::padBoth sẽ wrap hàm str_pad của PHP, sẽ thêm vào cả hai bên của một chuỗi để thành một chuỗi khác cho đến khi chuỗi cuối cùng đạt đến độ dài mong muốn:

use Illuminate\Support\Str;

$padded = Str::padBoth('James', 10, '_');

// '__James___'

$padded = Str::padBoth('James', 10);

// '  James   '

`Str::padLeft()`

Hàm Str::padLeft sẽ wrap hàm str_pad của PHP, sẽ thêm vào phía bên trái của một chuỗi để thành một chuỗi khác cho đến khi chuỗi cuối cùng đạt đến độ dài mong muốn:

use Illuminate\Support\Str;

$padded = Str::padLeft('James', 10, '-=');

// '-=-=-James'

$padded = Str::padLeft('James', 10);

// '     James'

`Str::padRight()`

Hàm Str::padRight sẽ wrap hàm str_pad của PHP, sẽ thêm vào phía bên phải của một chuỗi để thành một chuỗi khác cho đến khi chuỗi cuối cùng đạt đến độ dài mong muốn:

use Illuminate\Support\Str;

$padded = Str::padRight('James', 10, '-');

// 'James-----'

$padded = Str::padRight('James', 10);

// 'James     '

`Str::plural()`

Hàm Str::plural sẽ chuyển đổi một chuỗi đơn thành dạng số nhiều của nó. Chức năng này hiện tại chỉ hỗ trợ ngôn ngữ tiếng Anh:

use Illuminate\Support\Str;

$plural = Str::plural('car');

// cars

$plural = Str::plural('child');

// children

Bạn có thể cung cấp một số nguyên dưới dạng tham số thứ hai cho hàm để lấy dạng số ít hoặc số nhiều của chuỗi:

use Illuminate\Support\Str;

$plural = Str::plural('child', 2);

// children

$singular = Str::plural('child', 1);

// child

`Str::pluralStudly()`

Hàm Str::pluralStudly sẽ chuyển một chuỗi từ số ít sang số nhiều. Chức năng này hiện chỉ được hỗ trợ trong ngôn ngữ tiếng Anh:

use Illuminate\Support\Str;

$plural = Str::pluralStudly('VerifiedHuman');

// VerifiedHumans

$plural = Str::pluralStudly('UserFeedback');

// UserFeedback

Bạn có thể cung cấp một số nguyên làm tham số thứ hai cho phương thức để trả về dạng số ít hoặc số nhiều của chuỗi:

use Illuminate\Support\Str;

$plural = Str::pluralStudly('VerifiedHuman', 2);

// VerifiedHumans

$singular = Str::pluralStudly('VerifiedHuman', 1);

// VerifiedHuman

`Str::random()`

Hàm Str::random sẽ tạo ra một chuỗi ngẫu nhiên có độ dài được chỉ định. Hàm này sử dụng hàm random_bytes của PHP:

use Illuminate\Support\Str;

$random = Str::random(40);

`Str::remove()`

Hàm Str::remove sẽ xoá các giá trị hoặc một mảng các giá trị ra khỏi chuỗi:

use Illuminate\Support\Str;

$string = 'Peter Piper picked a peck of pickled peppers.';

$removed = Str::remove('e', $string);

// Ptr Pipr pickd a pck of pickld ppprs.

Bạn cũng có thể truyền một tham số false làm tham số thứ ba cho phương thức remove để xoá cả chữ hoa chữ thường.

`Str::replace()`

Hàm Str::replace sẽ thay thế một chuỗi trong chuỗi:

use Illuminate\Support\Str;

$string = 'Laravel 8.x';

$replaced = Str::replace('8.x', '9.x', $string);

// Laravel 9.x

`Str::replaceArray()`

Hàm Str::replaceArray sẽ thay thế một giá trị đã cho vào trong một chuỗi sequentially bằng cách sử dụng một mảng:

use Illuminate\Support\Str;

$string = 'The event will take place between ? and ?';

$replaced = Str::replaceArray('?', ['8:30', '9:00'], $string);

// The event will take place between 8:30 and 9:00

`Str::replaceFirst()`

Hàm Str::replaceFirst sẽ thay thế giá trị đầu tiên có trong chuỗi:

use Illuminate\Support\Str;

$replaced = Str::replaceFirst('the', 'a', 'the quick brown fox jumps over the lazy dog');

// a quick brown fox jumps over the lazy dog

`Str::replaceLast()`

Hàm Str::replaceLast sẽ thay thế giá trị cuối cùng có trong chuỗi:

use Illuminate\Support\Str;

$replaced = Str::replaceLast('the', 'a', 'the quick brown fox jumps over the lazy dog');

// the quick brown fox jumps over a lazy dog

`Str::reverse()`

Hàm Str::reverse sẽ đảo ngược chuỗi đã cho:

use Illuminate\Support\Str;

$reversed = Str::reverse('Hello World');

// dlroW olleH

`Str::singular()`

Hàm Str::singular sẽ chuyển đổi một chuỗi thành dạng số ít của nó. Chức năng này hiện tại chỉ hỗ trợ ngôn ngữ tiếng Anh:

use Illuminate\Support\Str;

$singular = Str::singular('cars');

// car

$singular = Str::singular('children');

// child

`Str::slug()`

Hàm Str::slug sẽ tạo ra một URL "slug" từ chuỗi đã cho:

use Illuminate\Support\Str;

$slug = Str::slug('Laravel 5 Framework', '-');

// laravel-5-framework

`Str::snake()`

Hàm Str::snake sẽ chuyển đổi chuỗi đã cho thành Str::snake:

use Illuminate\Support\Str;

$converted = Str::snake('fooBar');

// foo_bar

$converted = Str::snake('fooBar', '-');

// foo-bar

`Str::start()`

Hàm Str::start sẽ thêm một instance của giá trị đã cho vào một chuỗi nếu nó chưa bắt đầu bằng giá trị đó:

use Illuminate\Support\Str;

$adjusted = Str::start('this/string', '/');

// /this/string

$adjusted = Str::start('/this/string', '/');

// /this/string

`Str::startsWith()`

Hàm started_with sẽ kiểm tra chuỗi đã cho có bắt đầu bằng giá trị đã cho hay không:

use Illuminate\Support\Str;

$result = Str::startsWith('This is my name', 'This');

// true

Nếu một mảng các giá trị được truyền, thì phương thức startsWith sẽ trả về true nếu chuỗi bắt đầu bằng một trong các giá trị đã cho:

$result = Str::startsWith('This is my name', ['This', 'That', 'There']);

// true

`Str::studly()`

Hàm Str::studly chuyển đổi chuỗi đã cho thànhStudlyCase:

use Illuminate\Support\Str;

$converted = Str::studly('foo_bar');

// FooBar

`Str::substr()`

Hàm Str::substr sẽ trả lại phần chuỗi được chỉ định bởi các tham số bắt đầu và độ dài của chuỗi cần lấy:

use Illuminate\Support\Str;

$converted = Str::substr('The Laravel Framework', 4, 7);

// Laravel

`Str::substrCount()`

Hàm Str::substrCount sẽ trả về số lần xuất hiện của một giá trị trong một chuỗi đã cho:

use Illuminate\Support\Str;

$count = Str::substrCount('If you like ice cream, you will like snow cones.', 'like');

// 2

`Str::substrReplace()`

Hàm Str::substrReplace sẽ thay thế text có trong một phần của chuỗi, bắt đầu từ vị trí được chỉ định bởi tham số thứ ba và thay thế số ký tự được chỉ định bởi tham số thứ tư. Truyền tham số thứ tư là 0 nếu muốn chèn chuỗi vào vị trí đã chỉ định mà không thay thế bất kỳ ký tự nào có trong chuỗi:

use Illuminate\Support\Str;

$result = Str::substrReplace('1300', ':', 2);
// 13:

$result = Str::substrReplace('1300', ':', 2, 0);
// 13:00

`Str::title()`

Hàm Str::title chuyển đổi chuỗi đã cho thànhTitle Case:

use Illuminate\Support\Str;

$converted = Str::title('a nice title uses the correct case');

// A Nice Title Uses The Correct Case

`Str::toHtmlString()`

Hàm Str::toHtmlString sẽ chuyển một instance chuỗi thành một instance của Illuminate\Support\HtmlString, để có thể được hiển thị trong các template Blade:

use Illuminate\Support\Str;

$htmlString = Str::of('Nuno Maduro')->toHtmlString();

`Str::ucfirst()`

Hàm Str::ucfirst sẽ trả lại chuỗi đã cho với ký tự đầu tiên được viết hoa:

use Illuminate\Support\Str;

$string = Str::ucfirst('foo bar');

// Foo bar

`Str::upper()`

Hàm Str::upper sẽ chuyển đổi chuỗi đã cho thành chữ hoa toàn bộ chuỗi:

use Illuminate\Support\Str;

$string = Str::upper('laravel');

// LARAVEL

`Str::uuid()`

Hàm Str::uuid sẽ tạo ra một UUID (phiên bản 4):

use Illuminate\Support\Str;

return (string) Str::uuid();

`Str::wordCount()`

Hàm Str::wordCount sẽ trả về số lượng từ mà một chuỗi chứa:

use Illuminate\Support\Str;

Str::wordCount('Hello, world!'); // 2

`Str::words()`

Hàm Str::words sẽ giới hạn số lượng từ có trong một chuỗi. Một chuỗi bổ sung có thể được truyền cho phương thức này thông qua tham số thứ ba của nó để chỉ định chuỗi nào sẽ được thêm vào cuối chuỗi bị cắt ngắn:

use Illuminate\Support\Str;

return Str::words('Perfectly balanced, as all things should be.', 3, ' >>>');

// Perfectly balanced, as >>>

`trans()`

Hàm trans sẽ dịch các key cần dịch bằng cách sử dụng localization files của bạn:

echo trans('messages.welcome');

Nếu key cần dịch mà không tồn tại, hàm trans sẽ trả về key đó. Vì vậy, nếu sử dụng ví dụ trên, hàm trans sẽ trả về message.welcome nếu key cần dịch không tồn tại.

`trans_choice()`

Hàm trans_choice sẽ dịch các key cần dịch đã cho với một biến số nhiều:

echo trans_choice('messages.notifications', $unreadCount);

Nếu key cần dịch mà không tồn tại, hàm trans_choice sẽ trả về key đó. Vì vậy, nếu sử dụng ví dụ trên, hàm trans_choice sẽ trả về messages.notifications nếu key cần dịch không tồn tại.

Fluent Strings

Fluent string cung cấp một interface hướng đối tượng, trôi chảy hơn để làm việc với các giá trị chuỗi, cho phép bạn kết hợp nhiều xử lý chuỗi lại với nhau bằng cách sử dụng cú pháp dễ đọc hơn so với các xử lý chuỗi truyền thống.

`after`

Hàm after sẽ trả về mọi thứ nằm sau giá trị đã cho trong một chuỗi. Toàn bộ chuỗi sẽ được trả về nếu giá trị truyền vào không tồn tại trong chuỗi:

use Illuminate\Support\Str;

$slice = Str::of('This is my name')->after('This is');

// ' my name'

`afterLast`

Hàm afterLast sẽ trả về mọi thứ sau lần xuất hiện cuối cùng của giá trị đã cho trong một chuỗi. Toàn bộ chuỗi sẽ được trả về nếu giá trị truyền vào không tồn tại trong chuỗi:

use Illuminate\Support\Str;

$slice = Str::of('App\Http\Controllers\Controller')->afterLast('\\');

// 'Controller'

`append`

Hàm append sẽ nối các giá trị đã cho vào chuỗi:

use Illuminate\Support\Str;

$string = Str::of('Taylor')->append(' Otwell');

// 'Taylor Otwell'

`ascii`

Hàm ascii sẽ thử chuyển một chuỗi thành giá trị ASCII:

use Illuminate\Support\Str;

$string = Str::of('ü')->ascii();

// 'u'

`basename`

Hàm basename sẽ trả về phần cuối cùng của chuỗi đã cho:

use Illuminate\Support\Str;

$string = Str::of('/foo/bar/baz')->basename();

// 'baz'

Nếu cần, bạn có thể cung cấp một "extension" sẽ bị xóa ra khỏi phần cuối cùng:

use Illuminate\Support\Str;

$string = Str::of('/foo/bar/baz.jpg')->basename('.jpg');

// 'baz'

`before`

Hàm before trả về mọi thứ đứng trước giá trị đã cho trong một chuỗi:

use Illuminate\Support\Str;

$slice = Str::of('This is my name')->before('my name');

// 'This is '

`beforeLast`

Hàm beforeLast trả về mọi thứ đứng trước, trước lần xuất hiện cuối cùng của giá trị đã cho trong một chuỗi:

use Illuminate\Support\Str;

$slice = Str::of('This is my name')->beforeLast('is');

// 'This '

`between`

Hàm between sẽ trả về một phần của chuỗi nằm giữa hai giá trị:

use Illuminate\Support\Str;

$converted = Str::of('This is my name')->between('This', 'name');

// ' is my '

`camel`

Hàm camel sẽ chuyển đổi chuỗi đã cho thành camelCase:

use Illuminate\Support\Str;

$converted = Str::of('foo_bar')->camel();

// fooBar

`contains`

Hàm contains sẽ xác định xem chuỗi đã cho có chứa giá trị đã cho hay không. Phương thức này sẽ phân biệt chữ hoa chữ thường:

use Illuminate\Support\Str;

$contains = Str::of('This is my name')->contains('my');

// true

Bạn cũng có thể truyền một mảng giá trị để xác định xem chuỗi đã cho có chứa bất kỳ giá trị nào trong mảng đó hay không:

use Illuminate\Support\Str;

$contains = Str::of('This is my name')->contains(['my', 'foo']);

// true

`containsAll`

Hàm containsAll sẽ xác định xem chuỗi đã cho có chứa tất cả các giá trị của một mảng đã cho hay không:

use Illuminate\Support\Str;

$containsAll = Str::of('This is my name')->containsAll(['my', 'name']);

// true

`dirname`

Hàm dirname sẽ trả về phần thư mục cha của chuỗi đã cho:

use Illuminate\Support\Str;

$string = Str::of('/foo/bar/baz')->dirname();

// '/foo/bar'

Nếu cần, bạn có thể chỉ định thêm số lượng cấp của thư mục mà bạn muốn cắt ra khỏi chuỗi:

use Illuminate\Support\Str;

$string = Str::of('/foo/bar/baz')->dirname(2);

// '/foo'

`endsWith`

Hàm endsWith sẽ xác định xem chuỗi đã cho có kết thúc bằng giá trị đã cho hay không:

use Illuminate\Support\Str;

$result = Str::of('This is my name')->endsWith('name');

// true

Bạn cũng có thể truyền một mảng giá trị để xác định xem chuỗi đã cho có kết thúc bằng một giá trị trong số các giá trị đã cho hay không:

use Illuminate\Support\Str;

$result = Str::of('This is my name')->endsWith(['name', 'foo']);

// true

$result = Str::of('This is my name')->endsWith(['this', 'foo']);

// false

`exactly`

Hàm exactly sẽ xác định xem chuỗi đã cho có khớp với một chuỗi khác hay không:

use Illuminate\Support\Str;

$result = Str::of('Laravel')->exactly('Laravel');

// true

`explode`

Hàm explode sẽ chia chuỗi ra theo dấu phân cách đã cho và trả về một collection chứa từng chuỗi nhỏ của chuỗi đã cho:

use Illuminate\Support\Str;

$collection = Str::of('foo bar baz')->explode(' ');

// collect(['foo', 'bar', 'baz'])

`finish`

Hàm finish sẽ thêm một giá trị đã cho vào sau một chuỗi nếu nó chưa kết thúc bằng giá trị đó:

use Illuminate\Support\Str;

$adjusted = Str::of('this/string')->finish('/');

// this/string/

$adjusted = Str::of('this/string/')->finish('/');

// this/string/

`is`

Hàm is sẽ xác định xem một chuỗi đã cho có khớp với một pattern nhất định hay không. Dấu hoa thị có thể được sử dụng để biểu thị cho giá trị đại diện:

use Illuminate\Support\Str;

$matches = Str::of('foobar')->is('foo*');

// true

$matches = Str::of('foobar')->is('baz*');

// false

`isAscii`

Hàm isAscii sẽ xác định xem một chuỗi đã cho có phải là chuỗi ASCII hay không:

use Illuminate\Support\Str;

$result = Str::of('Taylor')->isAscii();

// true

$result = Str::of('ü')->isAscii();

// false

`isEmpty`

Hàm isEmpty sẽ xác định xem chuỗi đã cho có trống hay không:

use Illuminate\Support\Str;

$result = Str::of('  ')->trim()->isEmpty();

// true

$result = Str::of('Laravel')->trim()->isEmpty();

// false

`isNotEmpty`

Hàm isNotEmpty sẽ xác định xem chuỗi đã cho không trống đúng không:

use Illuminate\Support\Str;

$result = Str::of('  ')->trim()->isNotEmpty();

// false

$result = Str::of('Laravel')->trim()->isNotEmpty();

// true

`isUuid`

Hàm isUuid sẽ xác định xem một chuỗi đã cho có phải là dạng UUID hay không:

use Illuminate\Support\Str;

$result = Str::of('5ace9ab9-e9cf-4ec6-a19d-5881212a452c')->isUuid();

// true

$result = Str::of('Taylor')->isUuid();

// false

`kebab`

Hàm kebab sẽ chuyển đổi một chuỗi đã cho thành một dạng kebab-case:

use Illuminate\Support\Str;

$converted = Str::of('fooBar')->kebab();

// foo-bar

`length`

Hàm length sẽ trả về độ dài của chuỗi đã cho:

use Illuminate\Support\Str;

$length = Str::of('Laravel')->length();

// 7

`limit`

Hàm limit sẽ cắt chuỗi đã cho đến một độ dài nhất định:

use Illuminate\Support\Str;

$truncated = Str::of('The quick brown fox jumps over the lazy dog')->limit(20);

// The quick brown fox...

Bạn cũng có thể truyền thêm một tham số thứ hai để nối vào cuối chuỗi đã bị cắt:

use Illuminate\Support\Str;

$truncated = Str::of('The quick brown fox jumps over the lazy dog')->limit(20, ' (...)');

// The quick brown fox (...)

`lower`

Hàm lower sẽ chuyển đổi chuỗi đã cho thành chữ thường:

use Illuminate\Support\Str;

$result = Str::of('LARAVEL')->lower();

// 'laravel'

`ltrim`

Hàm ltrim sẽ cắt bên trái của chuỗi đã cho:

use Illuminate\Support\Str;

$string = Str::of('  Laravel  ')->ltrim();

// 'Laravel  '

$string = Str::of('/Laravel/')->ltrim('/');

// 'Laravel/'

`markdown`

Hàm markdown sẽ chuyển đổi Markdown định dạng theo chuẩn GitHub thành HTML:

use Illuminate\Support\Str;

$html = Str::of('# Laravel')->markdown();

// <h1>Laravel</h1>

$html = Str::of('# Taylor <b>Otwell</b>')->markdown([
    'html_input' => 'strip',
]);

// <h1>Taylor Otwell</h1>

`mask`

Hàm mask sẽ che giấu một phần của chuỗi với một ký tự lặp lại và có thể được sử dụng để làm xáo trộn các phân đoạn của chuỗi như địa chỉ email hoặc các số điện thoại:

use Illuminate\Support\Str;

$string = Str::of('[email protected]')->mask('*', 3);

// tay***************

$string = Str::of('[email protected]')->mask('*', -15, 3);

// tay***@example.com

`match`

Hàm match sẽ trả về một phần của chuỗi khớp với một biểu thức chính quy đã cho:

use Illuminate\Support\Str;

$result = Str::of('foo bar')->match('/bar/');

// 'bar'

$result = Str::of('foo bar')->match('/foo (.*)/');

// 'bar'

`matchAll`

Hàm matchAll sẽ trả về một collection chứa các phần của một chuỗi khớp với một biểu thức chính quy đã cho:

use Illuminate\Support\Str;

$result = Str::of('bar foo bar')->matchAll('/bar/');

// collect(['bar', 'bar'])

Nếu bạn chỉ định một nhóm vào trong biểu thức, Laravel sẽ trả về một collection phù hợp của nhóm đó:

use Illuminate\Support\Str;

$result = Str::of('bar fun bar fly')->matchAll('/f(\w*)/');

// collect(['un', 'ly']);

Nếu không tìm thấy kết quả phù hợp, một collection trống sẽ được trả về.

`padBoth`

Hàm padBoth sẽ wrap phương thức str_pad của PHP, sẽ thêm vào cả hai bên của một chuỗi để thành một chuỗi khác cho đến khi chuỗi cuối cùng đạt đến độ dài mong muốn:

use Illuminate\Support\Str;

$padded = Str::of('James')->padBoth(10, '_');

// '__James___'

$padded = Str::of('James')->padBoth(10);

// '  James   '

`padLeft`

Hàm padLeft sẽ wrap phương thức str_pad của PHP, sẽ thêm vào bên trái của một chuỗi để thành một chuỗi khác cho đến khi chuỗi cuối cùng đạt đến độ dài mong muốn:

use Illuminate\Support\Str;

$padded = Str::of('James')->padLeft(10, '-=');

// '-=-=-James'

$padded = Str::of('James')->padLeft(10);

// '     James'

`padRight`

Hàm padRight sẽ wrap phương thức str_pad của PHP, sẽ thêm vào bên phải của một chuỗi để thành một chuỗi khác cho đến khi chuỗi cuối cùng đạt đến độ dài mong muốn:

use Illuminate\Support\Str;

$padded = Str::of('James')->padRight(10, '-');

// 'James-----'

$padded = Str::of('James')->padRight(10);

// 'James     '

`pipe`

Hàm pipe cho phép bạn chuyển đổi chuỗi bằng cách truyền giá trị hiện tại của nó sang một hàm gọi lại:

use Illuminate\Support\Str;

$hash = Str::of('Laravel')->pipe('md5')->prepend('Checksum: ');

// 'Checksum: a5c95b86291ea299fcbe64458ed12702'

$closure = Str::of('foo')->pipe(function ($str) {
    return 'bar';
});

// 'bar'

`plural`

Hàm plural sẽ chuyển một chuỗi từ dạng số ít sang dạng số nhiều của nó. Chức năng này hiện chỉ hỗ trợ ngôn ngữ tiếng Anh:

use Illuminate\Support\Str;

$plural = Str::of('car')->plural();

// cars

$plural = Str::of('child')->plural();

// children

Bạn có thể cung cấp một số nguyên làm tham số thứ hai cho phương thức để lấy ra dạng số ít hoặc số nhiều của chuỗi:

use Illuminate\Support\Str;

$plural = Str::of('child')->plural(2);

// children

$plural = Str::of('child')->plural(1);

// child

`prepend`

Hàm prepend sẽ thêm các giá trị đã cho vào chuỗi:

use Illuminate\Support\Str;

$string = Str::of('Framework')->prepend('Laravel ');

// Laravel Framework

`remove`

Hàm remove sẽ xoá các giá trị hoặc một mảng các giá trị ra khỏi chuỗi:

use Illuminate\Support\Str;

$string = Str::of('Arkansas is quite beautiful!')->remove('quite');

// Arkansas is beautiful!

You may also pass false as a second parameter to ignore case when removing strings.

`replace`

Hàm replace sẽ thay thế một chuỗi đã cho trong chuỗi:

use Illuminate\Support\Str;

$replaced = Str::of('Laravel 6.x')->replace('6.x', '7.x');

// Laravel 7.x

`replaceArray`

Hàm replaceArray sẽ thay thế từng giá trị một vào trong chuỗi bằng cách sử dụng một mảng:

use Illuminate\Support\Str;

$string = 'The event will take place between ? and ?';

$replaced = Str::of($string)->replaceArray('?', ['8:30', '9:00']);

// The event will take place between 8:30 and 9:00

`replaceFirst`

Hàm replaceFirst sẽ thay vào chỗ xuất hiện đầu tiên của một giá trị đã cho vào trong một chuỗi:

use Illuminate\Support\Str;

$replaced = Str::of('the quick brown fox jumps over the lazy dog')->replaceFirst('the', 'a');

// a quick brown fox jumps over the lazy dog

`replaceLast`

Hàm replaceLast sẽ thay vào chỗ xuất hiện cuối cùng của một giá trị đã cho vào trong một chuỗi:

use Illuminate\Support\Str;

$replaced = Str::of('the quick brown fox jumps over the lazy dog')->replaceLast('the', 'a');

// the quick brown fox jumps over a lazy dog

`replaceMatches`

Hàm replaceMatches sẽ thay thế tất cả các phần của một chuỗi mà khớp với một mẫu:

use Illuminate\Support\Str;

$replaced = Str::of('(+1) 501-555-1000')->replaceMatches('/[^A-Za-z0-9]++/', '')

// '15015551000'

Hàm replaceMatches cũng chấp nhận một Closure sẽ được gọi với từng phần của chuỗi mà khớp với mẫu đã cho, cho phép bạn thực hiện các logic chi tiết trong closure và trả về giá trị đã thay thế:

use Illuminate\Support\Str;

$replaced = Str::of('123')->replaceMatches('/\d/', function ($match) {
    return '['.$match[0].']';
});

// '[1][2][3]'

`rtrim`

Hàm rtrim sẽ cắt bên phải của chuỗi đã cho:

use Illuminate\Support\Str;

$string = Str::of('  Laravel  ')->rtrim();

// '  Laravel'

$string = Str::of('/Laravel/')->rtrim('/');

// '/Laravel'

`scan`

Hàm scan sẽ phân tích cú pháp đầu vào của một chuỗi thành một collection theo định dạng được hỗ trợ bởi hàm sscanf của PHP:

use Illuminate\Support\Str;

$collection = Str::of('filename.jpg')->scan('%[^.].%s');

// collect(['filename', 'jpg'])

`singular`

Hàm singular sẽ chuyển một chuỗi thành dạng số ít của nó. Chức năng này hiện chỉ hỗ trợ ngôn ngữ tiếng Anh:

use Illuminate\Support\Str;

$singular = Str::of('cars')->singular();

// car

$singular = Str::of('children')->singular();

// child

`slug`

Hàm slug sẽ tạo ra một "slug" thân thiện với URL từ một chuỗi đã cho:

use Illuminate\Support\Str;

$slug = Str::of('Laravel Framework')->slug('-');

// laravel-framework

`snake`

Hàm snake sẽ chuyển chuỗi đã cho thành snake_case:

use Illuminate\Support\Str;

$converted = Str::of('fooBar')->snake();

// foo_bar

`split`

Hàm split sẽ cắt một chuỗi thành một collection bằng cách sử dụng một biểu thức chính quy:

use Illuminate\Support\Str;

$segments = Str::of('one, two, three')->split('/[\s,]+/');

// collect(["one", "two", "three"])

`start`

Hàm start sẽ thêm một giá trị đã cho vào một chuỗi nếu nó chưa bắt đầu bằng giá trị đó:

use Illuminate\Support\Str;

$adjusted = Str::of('this/string')->start('/');

// /this/string

$adjusted = Str::of('/this/string')->start('/');

// /this/string

`startsWith`

Hàm startsWith sẽ xác định xem chuỗi đã cho có bắt đầu bằng giá trị đã cho hay không:

use Illuminate\Support\Str;

$result = Str::of('This is my name')->startsWith('This');

// true

`studly`

Hàm studly sẽ chuyển chuỗi đã cho thành dạng StudlyCase:

use Illuminate\Support\Str;

$converted = Str::of('foo_bar')->studly();

// FooBar

`substr`

Hàm substr sẽ trả lại phần chuỗi được chỉ định bởi các tham số bắt đầu và độ dài của chuỗi cần lấy:

use Illuminate\Support\Str;

$string = Str::of('Laravel Framework')->substr(8);

// Framework

$string = Str::of('Laravel Framework')->substr(8, 5);

// Frame

`substrReplace`

Hàm substrReplace sẽ thay thế text có trong một phần của chuỗi, bắt đầu từ vị trí được chỉ định bởi tham số thứ ba và thay thế số ký tự được chỉ định bởi tham số thứ tư. Truyền tham số thứ tư là 0 nếu muốn chèn chuỗi vào vị trí đã chỉ định mà không thay thế bất kỳ ký tự nào có trong chuỗi:

use Illuminate\Support\Str;

$string = Str::of('1300')->substrReplace(':', 2);

// 13:

$string = Str::of('The Framework')->substrReplace(' Laravel', 3, 0);

// The Laravel Framework

`tap`

Hàm tap sẽ truyền chuỗi đến một closure đã cho, cho phép bạn kiểm tra và tương tác với chuỗi trong khi không ảnh hưởng đến chính chuỗi đó. Chuỗi ban đầu sẽ được trả về bởi phương thức tap bất kể giá trị trả về của closure là thế nào:

use Illuminate\Support\Str;

$string = Str::of('Laravel')
    ->append(' Framework')
    ->tap(function ($string) {
        dump('String after append: ' . $string);
    })
    ->upper();

// LARAVEL FRAMEWORK

`test`

Hàm test sẽ xác định xem một chuỗi có khớp với một biểu thức chính quy đã cho hay không:

use Illuminate\Support\Str;

$result = Str::of('Laravel Framework')->test('/Laravel/');

// true

`title`

Hàm title sẽ chuyển một chuỗi đã cho thành dạng Title Case:

use Illuminate\Support\Str;

$converted = Str::of('a nice title uses the correct case')->title();

// A Nice Title Uses The Correct Case

`trim`

Hàm trim sẽ cắt chuỗi đã cho:

use Illuminate\Support\Str;

$string = Str::of('  Laravel  ')->trim();

// 'Laravel'

$string = Str::of('/Laravel/')->trim('/');

// 'Laravel'

`ucfirst`

Hàm ucfirst sẽ trả về chuỗi đã cho với ký tự đầu tiên được viết hoa:

use Illuminate\Support\Str;

$string = Str::of('foo bar')->ucfirst();

// Foo bar

`upper`

Hàm upper sẽ chuyển một chuỗi đã cho thành viết chữ hoa toàn bộ chuỗi:

use Illuminate\Support\Str;

$adjusted = Str::of('laravel')->upper();

// LARAVEL

`when`

Hàm when sẽ gọi Closure nếu một điều kiện đã cho là đúng. Closure sẽ nhận vào một instance chuỗi ban đầu:

use Illuminate\Support\Str;

$string = Str::of('Taylor')
                ->when(true, function ($string) {
                    return $string->append(' Otwell');
                });

// 'Taylor Otwell'

Nếu cần thiết, bạn có thể truyền một Closure khác làm tham số thứ ba cho phương thức when. Closure này sẽ được thực thi nếu tham số điều kiện là false.

`whenContains`

Hàm whenContains sẽ gọi closure đã cho nếu chuỗi chứa giá trị đã cho. Closure sẽ nhận vào instance chuỗi:

use Illuminate\Support\Str;

$string = Str::of('tony stark')
            ->whenContains('tony', function ($string) {
                return $string->title();
            });

// 'Tony Stark'

Nếu cần, bạn có thể truyền một closure khác làm tham số thứ ba cho phương thức when. Closure này sẽ thực hiện nếu chuỗi không chứa giá trị đã cho.

Bạn cũng có thể truyền một mảng các giá trị để xác định xem chuỗi đã cho có chứa bất kỳ giá trị nào có trong mảng hay không:

use Illuminate\Support\Str;

$string = Str::of('tony stark')
            ->whenContains(['tony', 'hulk'], function ($string) {
                return $string->title();
            });

// Tony Stark

`whenContainsAll`

Hàm whenContainsAll sẽ gọi closure nếu chuỗi chứa tất cả các chuỗi con đã cho. Closure này sẽ nhận vào instance chuỗi:

use Illuminate\Support\Str;

$string = Str::of('tony stark')
                ->whenContainsAll(['tony', 'stark'], function ($string) {
                    return $string->title();
                });

// 'Tony Stark'

Nếu cần thiết, bạn có thể truyền một closure khác làm tham số thứ ba cho phương thức when. Closure này sẽ được thực thi nếu tham số điều kiện là false.

`whenEmpty`

Hàm whenEmpty sẽ gọi một closure nếu chuỗi là trống. Nếu closure trả về một giá trị, thì giá trị đó cũng sẽ được trả về từ phương thức whenEmpty. Nếu closure không trả về giá trị nào, thì instance string sẽ được trả về:

use Illuminate\Support\Str;

$string = Str::of('  ')->whenEmpty(function ($string) {
    return $string->trim()->prepend('Laravel');
});

// 'Laravel'

`whenNotEmpty`

Hàm whenNotEmpty sẽ gọi closure đã cho nếu chuỗi đã cho có giá trị. Nếu closure trả về một giá trị, thì giá trị đó cũng sẽ được trả về bởi phương thức whenNotEmpty. Nếu closure không trả về giá trị gì, thì instance chuỗi ban đầu sẽ được trả về:

use Illuminate\Support\Str;

$string = Str::of('Framework')->whenNotEmpty(function ($string) {
    return $string->prepend('Laravel ');
});

// 'Laravel Framework'

`whenStartsWith`

Hàm whenStartsWith sẽ gọi closure đã cho nếu chuỗi bắt đầu bằng chuỗi con đã cho. Closure sẽ nhận vào instance chuỗi:

use Illuminate\Support\Str;

$string = Str::of('disney world')->whenStartsWith('disney', function ($string) {
    return $string->title();
});

// 'Disney World'

`whenEndsWith`

Hàm whenEndsWith sẽ gọi closure đã cho nếu chuỗi kết thúc bằng chuỗi con đã cho. Closure sẽ nhận vào instance chuỗi:

use Illuminate\Support\Str;

$string = Str::of('disney world')->whenEndsWith('world', function ($string) {
    return $string->title();
});

// 'Disney World'

`whenExactly`

Hàm whenExactly sẽ gọi closure đã cho nếu chuỗi đúng bằng chuỗi đã cho. Closure sẽ nhận vào instance chuỗi:

use Illuminate\Support\Str;

$string = Str::of('laravel')->whenExactly('laravel', function ($string) {
    return $string->title();
});

// 'Laravel'

`whenIs`

Hàm whenIs sẽ gọi closure đã cho nếu chuỗi khớp với một mẫu nhất định. Dấu hoa thị có thể được sử dụng làm một ký tự đại diện. Closure sẽ nhận vào instance chuỗi:

use Illuminate\Support\Str;

$string = Str::of('foo/bar')->whenIs('foo/*', function ($string) {
    return $string->append('/baz');
});

// 'foo/bar/baz'

`whenIsAscii`

Hàm whenIsAscii sẽ gọi closure đã cho nếu chuỗi là một dạng ASCII 7 bit. Closure sẽ nhận vào instance chuỗi:

use Illuminate\Support\Str;

$string = Str::of('foo/bar')->whenIsAscii('laravel', function ($string) {
    return $string->title();
});

// 'Laravel'

`whenIsUuid`

Hàm whenIsUuid sẽ gọi closure đã cho nếu chuỗi là một UUID hợp lệ. Closure sẽ nhận vào instance chuỗi:

use Illuminate\Support\Str;

$string = Str::of('foo/bar')->whenIsUuid('a0a2a2d2-0b87-4a18-83f2-2529882be2de', function ($string) {
    return $string->substr(0, 8);
});

// 'a0a2a2d2'

`whenTest`

Hàm whenTest sẽ gọi closure đã cho nếu chuỗi khớp với một biểu thức chính quy. Closure sẽ nhận vào instance chuỗi:

use Illuminate\Support\Str;

$string = Str::of('laravel framework')->whenTest('/laravel/', function ($string) {
    return $string->title();
});

// 'Laravel Framework'

`wordCount`

Hàm wordCount trả về số lượng từ mà một chuỗi đó chứa:

use Illuminate\Support\Str;

Str::of('Hello, world!')->wordCount(); // 2

`words`

Hàm words sẽ giới hạn số lượng từ trong một chuỗi. Nếu cần, bạn có thể chỉ định một chuỗi bổ sung sẽ được thêm vào chuỗi bị cắt ngắn:

use Illuminate\Support\Str;

$string = Str::of('Perfectly balanced, as all things should be.')->words(3, ' >>>');

// Perfectly balanced, as >>>

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

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

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

`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()->addSeconds(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. Giá trị mặc định có thể được khai báo và đượ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]);

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

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

`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ế.

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

{note} 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ề null.

`event()`

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

event(new UserRegistered($user));

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

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

`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) {
    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.');

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

`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 in between attempts...
}, 100);

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:

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

Để 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:

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

`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->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) {
    //
});

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

`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 ($value) {
    return is_numeric($value) ? $value * 2 : 0;
};

$result = with(5, $callback);

// 10

$result = with(null, $callback);

// 0

$result = with(5, null);

// 5

Prologue

Getting Started

Architecture Concepts

The Basics

Digging Deeper

Security

Database

Eloquent ORM

Testing

Packages

Prologue

Getting Started

Architecture Concepts

The Basics

Digging Deeper

Security

Database

Eloquent ORM

Testing

Packages

Giới thiệu

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

Arrays & Objects

Paths

Strings

Fluent Strings

URLs

Miscellaneous

Method Listing

Arrays & Objects

Arr::accessible()

Arr::add()

Arr::collapse()

Arr::crossJoin()

Arr::divide()

Arr::dot()

Arr::except()

Arr::exists()

Arr::first()

Arr::flatten()

Arr::forget()

Arr::get()

Arr::has()

Arr::hasAny()

Arr::isAssoc()

Arr::last()

Arr::only()

Arr::pluck()

Arr::prepend()

Arr::pull()

Arr::query()

Arr::random()

Arr::set()

Arr::shuffle()

Arr::sort()

Arr::sortRecursive()

Arr::toCssClasses()

Arr::undot()

Arr::where()

Arr::whereNotNull()

Arr::wrap()

data_fill()

data_get()

data_set()

head()

last()

Paths

app_path()

base_path()

config_path()

database_path()

mix()

public_path()

resource_path()

storage_path()

Strings

__()

class_basename()

e()

preg_replace_array()

`Arr::accessible()`

`Arr::add()`

`Arr::collapse()`

`Arr::crossJoin()`

`Arr::divide()`

`Arr::dot()`

`Arr::except()`

`Arr::exists()`

`Arr::first()`

`Arr::flatten()`

`Arr::forget()`

`Arr::get()`

`Arr::has()`

`Arr::hasAny()`

`Arr::isAssoc()`

`Arr::last()`

`Arr::only()`

`Arr::pluck()`

`Arr::prepend()`

`Arr::pull()`

`Arr::query()`

`Arr::random()`

`Arr::set()`

`Arr::shuffle()`

`Arr::sort()`

`Arr::sortRecursive()`

`Arr::toCssClasses()`

`Arr::undot()`

`Arr::where()`

`Arr::whereNotNull()`

`Arr::wrap()`

`data_fill()`

`data_get()`

`data_set()`

`head()`

`last()`

`app_path()`

`base_path()`

`config_path()`

`database_path()`

`mix()`

`public_path()`

`resource_path()`

`storage_path()`

`__()`

`class_basename()`

`e()`

`preg_replace_array()`

`Str::after()`

`Str::afterLast()`

`Str::ascii()`

`Str::before()`

`Str::beforeLast()`

`Str::between()`

`Str::camel()`

`Str::contains()`

`Str::containsAll()`

`Str::endsWith()`

`Str::finish()`

`Str::headline()`

`Str::is()`

`Str::isAscii()`

`Str::isUuid()`

`Str::kebab()`

`Str::length()`

`Str::limit()`

`Str::lower()`

`Str::markdown()`

`Str::mask()`

`Str::orderedUuid()`

`Str::padBoth()`

`Str::padLeft()`

`Str::padRight()`

`Str::plural()`

`Str::pluralStudly()`

`Str::random()`

`Str::remove()`

`Str::replace()`

`Str::replaceArray()`

`Str::replaceFirst()`