Schedule trong Laravel 13

Giới thiệu

Laravel có chứa nhiều hàm khác nhau để thao tác với các giá trị string. Nhiều hàm trong số này được chính framework sử dụng; tuy nhiên, bạn có thể tự do sử dụng chúng trong ứng dụng của bạn nếu bạn thấy thuận tiện.

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

Strings

__ class_basename e preg_replace_array Str::after Str::afterLast Str::apa Str::ascii Str::before Str::beforeLast Str::between Str::betweenFirst Str::camel Str::charAt Str::chopStart Str::chopEnd Str::contains Str::containsAll Str::doesntContain Str::doesntEndWith Str::doesntStartWith Str::deduplicate Str::endsWith Str::excerpt Str::finish Str::fromBase64 Str::headline Str::initials Str::inlineMarkdown Str::is Str::isAscii Str::isJson Str::isUlid Str::isUrl Str::isUuid Str::kebab Str::lcfirst Str::length Str::limit Str::lower Str::markdown Str::mask Str::match Str::matchAll Str::isMatch Str::orderedUuid Str::padBoth Str::padLeft Str::padRight Str::password Str::plural Str::pluralStudly Str::position Str::random Str::remove Str::repeat Str::replace Str::replaceArray Str::replaceFirst Str::replaceLast Str::replaceMatches Str::replaceStart Str::replaceEnd Str::reverse Str::singular Str::slug Str::snake Str::squish Str::start Str::startsWith Str::studly Str::substr Str::substrCount Str::substrReplace Str::swap Str::take Str::title Str::toBase64 Str::transliterate Str::trim Str::ltrim Str::rtrim Str::ucfirst Str::ucsplit Str::ucwords Str::upper Str::ulid Str::unwrap Str::uuid Str::uuid7 Str::wordCount Str::wordWrap Str::words Str::wrap str trans trans_choice

Fluent Strings

after afterLast apa append ascii basename before beforeLast between betweenFirst camel charAt classBasename chopStart chopEnd contains containsAll decrypt deduplicate dirname doesntContain doesntEndWith doesntStartWith encrypt endsWith exactly excerpt explode finish fromBase64 hash headline initials inlineMarkdown is isAscii isEmpty isNotEmpty isJson isUlid isUrl isUuid kebab lcfirst length limit lower markdown mask match matchAll isMatch newLine padBoth padLeft padRight pipe plural position prepend remove repeat replace replaceArray replaceFirst replaceLast replaceMatches replaceStart replaceEnd scan singular slug snake split squish start startsWith stripTags studly substr substrReplace swap take tap test title toBase64 toHtmlString toUri transliterate trim ltrim rtrim ucfirst ucsplit ucwords unwrap upper when whenContains whenContainsAll whenDoesntEndWith whenDoesntStartWith whenEmpty whenNotEmpty whenStartsWith whenEndsWith whenExactly whenNotExactly whenIs whenIsAscii whenIsUlid whenIsUuid whenTest wordCount words wrap

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

Hàm class_basename sẽ 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 sẽ chạy hàm htmlspecialchars 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::apa()`

Hàm Str::apa sẽ chuyển chuỗi đã cho thành chữ viết hoa đầu dòng theo hướng dẫn của APA:

use Illuminate\Support\Str;

$title = Str::apa('Creating A Project');

// 'Creating a Project'

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

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

use Illuminate\Support\Str;

$slice = Str::betweenFirst('[a] bc [d]', '[', ']');

// 'a'

`Str::camel()`

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

use Illuminate\Support\Str;

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

// 'fooBar'

`Str::charAt()`

Hàm Str::charAt sẽ trả về một ký tự tại vị trí được chỉ định. Nếu vị trí chỉ định nằm ngoài chuỗi, thì false sẽ được trả về:

use Illuminate\Support\Str;

$character = Str::charAt('This is my name.', 6);

// 's'

`Str::chopStart()`

Hàm Str::chopStart sẽ xóa giá trị đã cho chỉ khi giá trị đó xuất hiện ở đầu chuỗi:

use Illuminate\Support\Str;

$url = Str::chopStart('https://laravel.com', 'https://');

// 'laravel.com'

Bạn cũng có thể truyền vào một mảng làm tham số thứ hai. Nếu chuỗi bắt đầu với bất kỳ giá trị nào có trong mảng thì giá trị đó sẽ bị xóa khỏi chuỗi:

use Illuminate\Support\Str;

$url = Str::chopStart('http://laravel.com', ['https://', 'http://']);

// 'laravel.com'

`Str::chopEnd()`

Hàm Str::chopEnd sẽ xóa giá trị đã cho chỉ khi giá trị đó xuất hiện ở cuối chuỗi:

use Illuminate\Support\Str;

$url = Str::chopEnd('app/Models/Photograph.php', '.php');

// 'app/Models/Photograph'

Bạn cũng có thể truyền vào một mảng làm tham số thứ hai. Nếu chuỗi kết thúc với bất kỳ giá trị nào có trong mảng thì giá trị đó sẽ bị xóa khỏi chuỗi:

use Illuminate\Support\Str;

$url = Str::chopEnd('laravel.com/index.php', ['/index.html', '/index.php']);

// 'laravel.com'

`Str::contains()`

Hàm Str::contains sẽ xác định xem chuỗi đã cho có chứa giá trị đã cho hay không. Mặc định, 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

Bạn có thể disable phân biệt chữ hoa và chữ thường bằng cách set tham số ignoreCase thành true:

use Illuminate\Support\Str;

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

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

Bạn có thể disable phân biệt chữ hoa và chữ thường bằng cách set tham số ignoreCase thành true:

use Illuminate\Support\Str;

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

// true

`Str::doesntContain()`

Hàm Str::doesntContain sẽ xác định chuỗi đã cho sẽ không chứa giá trị đã cho. Mặc định, phương thức này phân biệt chữ hoa và chữ thường:

use Illuminate\Support\Str;

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

// true

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

use Illuminate\Support\Str;

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

// true

Bạn có thể disable phân biệt chữ hoa và chữ thường bằng cách set tham số ignoreCase thành true:

use Illuminate\Support\Str;

$doesntContain = Str::doesntContain('This is name', 'MY', ignoreCase: true);

// true

`Str::deduplicate()`

Hàm Str::deduplicate sẽ thay thế các ký tự liên tiếp giống nhau bằng một ký tự duy nhất trong một chuỗi đã cho. Mặc định, phương thức này loại bỏ các khoảng trắng trùng nhau:

use Illuminate\Support\Str;

$result = Str::deduplicate('The   Laravel   Framework');

// The Laravel Framework

Bạn có thể chỉ định một ký tự khác để thay thế bằng cách truyền nó vào làm tham số thứ hai của phương thức:

use Illuminate\Support\Str;

$result = Str::deduplicate('The---Laravel---Framework', '-');

// The-Laravel-Framework

`Str::doesntEndWith()`

Phương thức Str::doesntEndWith sẽ xác định xem chuỗi đã cho không kết thúc bằng giá trị đã cho hay không:

use Illuminate\Support\Str;

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

// true

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

use Illuminate\Support\Str;

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

// true

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

// false

`Str::doesntStartWith()`

Phương thức Str::doesntStartWith sẽ xác định xem chuỗi đã cho không bắt đầu bằng giá trị đã cho hay không:

use Illuminate\Support\Str;

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

// true

Nếu một mảng các giá trị được truyền vào, phương thức doesntStartWith sẽ trả về true nếu chuỗi đó không bắt đầu bằng bất kỳ giá trị nào có trong số các giá trị đã cho:

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

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

Hàm Str::excerpt sẽ lấy ra một đoạn đầu tiên từ một chuỗi mà khớp với chuỗi đã cho:

use Illuminate\Support\Str;

$excerpt = Str::excerpt('This is my name', 'my', [
    'radius' => 3
]);

// '...is my na...'

Tùy chọn radius có giá trị mặc định là 100, cho phép bạn định nghĩa số lượng ký tự sẽ xuất hiện ở mỗi bên của chuỗi đã được lấy ra.

Ngoài ra, bạn có thể sử dụng tùy chọn omission để định nghĩa chuỗi sẽ được thêm vào trước hoặc sau chuỗi đã được lấy ra:

use Illuminate\Support\Str;

$excerpt = Str::excerpt('This is my name', 'name', [
    'radius' => 3,
    'omission' => '(...) '
]);

// '(...) my name'

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

Phương thức Str::fromBase64 sẽ giải mã chuỗi Base64 đã cho:

use Illuminate\Support\Str;

$decoded = Str::fromBase64('TGFyYXZlbA==');

// Laravel

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

Hàm Str::initials sẽ trả về các chữ cái đầu của các từ có trong một chuỗi nhất định, bạn cũng có thể có thêm tùy chọn viết hoa cho chúng:

use Illuminate\Support\Str;

$initials = Str::initials('taylor otwell');

// to

$initials = Str::initials('taylor otwell', capitalize: true);

// TO

`Str::inlineMarkdown()`

Hàm Str::inlineMarkdown sẽ chuyển đổi Markdown định dạng theo chuẩn GitHub thành HTML bằng cách sử dụng CommonMark. Tuy nhiên, không giống như phương thức markdown, nó không wrap tất cả code HTML được tạo vào trong một phần tử ở mức độ block:

use Illuminate\Support\Str;

$html = Str::inlineMarkdown('**Laravel**');

// <strong>Laravel</strong>

Markdown Security

Mặc định, Markdown hỗ trợ HTML raw, điều này sẽ tạo ra lỗ hổng Cross-Site Scripting (XSS) khi sử dụng với dữ liệu input raw của người dùng. Theo tài liệu bảo mật CommonMark, bạn có thể sử dụng tùy chọn html_input để loại bỏ ký tự đặc biệt hoặc loại bỏ thẻ HTML, và tùy chọn allow_unsafe_links để chỉ định có cho phép các unsafe link hay không. Nếu bạn cần cho phép một số HTML raw, bạn nên truyền Markdown đã biên dịch của bạn qua HTML Purifier:

use Illuminate\Support\Str;

Str::inlineMarkdown('Inject: <script>alert("Hello XSS!");</script>', [
    'html_input' => 'strip',
    'allow_unsafe_links' => false,
]);

// Inject: alert(&quot;Hello XSS!&quot;);

`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

Bạn có thể disable phân biệt chữ hoa và chữ thường bằng cách set tham số ignoreCase thành true:

use Illuminate\Support\Str;

$matches = Str::is('*.jpg', 'photo.JPG', ignoreCase: true);

// true

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

Hàm Str::isJson sẽ xác định xem chuỗi đã cho có phải là một định dạng JSON hợp lệ hay không:

use Illuminate\Support\Str;

$result = Str::isJson('[1,2,3]');

// true

$result = Str::isJson('{"first": "John", "last": "Doe"}');

// true

$result = Str::isJson('{first: "John", last: "Doe"}');

// false

`Str::isUrl()`

Hàm Str::isUrl sẽ xác định xem chuỗi đã cho có phải là URL hợp lệ hay không:

use Illuminate\Support\Str;

$isUrl = Str::isUrl('http://example.com');

// true

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

// false

Hàm isUrl chấp nhận nhiều giao thức. Tuy nhiên, bạn có thể chỉ định các giao thức được coi là hợp lệ bằng cách cung cấp chúng cho hàm isUrl:

$isUrl = Str::isUrl('http://example.com', ['http', 'https']);

`Str::isUlid()`

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

use Illuminate\Support\Str;

$isUlid = Str::isUlid('01gd6r360bp37zj17nxb55yv40');

// true

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

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

Bạn cũng có thể xác thực một chuỗi UUID đã cho có giống với đặc tả UUID theo version (1, 3, 4, 5, 6, 7 hoặc 8) hay không:

use Illuminate\Support\Str;

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

// true

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

// false

`Str::kebab()`

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

use Illuminate\Support\Str;

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

// foo-bar

`Str::lcfirst()`

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

use Illuminate\Support\Str;

$string = Str::lcfirst('Foo Bar');

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

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

// The quick brown fox (...)

Nếu bạn muốn giữ nguyên các từ hoàn chỉnh khi cắt ngắn chuỗi, bạn có thể sử dụng tham số preserveWords. Khi tham số này là true, thì chuỗi sẽ được cắt ngắn đến từ hoàn chỉnh gần nhất:

$truncated = Str::limit('The quick brown fox', 12, preserveWords: true);

// The quick...

`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 dùng CommonMark:

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>

Markdown Security

use Illuminate\Support\Str;

Str::markdown('Inject: <script>alert("Hello XSS!");</script>', [
    'html_input' => 'strip',
    'allow_unsafe_links' => false,
]);

// <p>Inject: alert(&quot;Hello XSS!&quot;);</p>

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

Phương thức Str::match sẽ trả về một phần của chuỗi đã cho mà khớp với pattern regular expression:

use Illuminate\Support\Str;

$result = Str::match('/bar/', 'foo bar');

// 'bar'

$result = Str::match('/foo (.*)/', 'foo bar');

// 'bar'

`Str::matchAll()`

Phương thức Str::matchAll sẽ trả về một collection chứa các phần của chuỗi đã cho mà khớp với pattern regular expression:

use Illuminate\Support\Str;

$result = Str::matchAll('/bar/', 'bar foo bar');

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

Nếu bạn chỉ định một matching group bên trong biểu thức, Laravel sẽ trả về một collection của các kết quả khớp với matching group đầu tiên:

use Illuminate\Support\Str;

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

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

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

`Str::isMatch()`

Phương thức Str::isMatch sẽ trả về true nếu chuỗi đã cho khớp với một regular expression:

use Illuminate\Support\Str;

$result = Str::isMatch('/foo (.*)/', 'foo bar');

// true

$result = Str::isMatch('/foo (.*)/', 'laravel');

// false

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

Hàm Str::password sẽ có thể được sử dụng để tạo ra một mật khẩu an toàn với độ dài nhất định. Mật khẩu sẽ chứa một tổ hợp các chữ cái, chữ số, ký hiệu và khoảng trắng. Mặc định, mật khẩu sẽ dài 32 ký tự:

use Illuminate\Support\Str;

$password = Str::password();

// 'EbJo2vE-AS:U,$%_gkrV4n,q~1xy/-_4'

$password = Str::password(12);

// 'qwuar>#V|i]N'

`Str::plural()`

Hàm Str::plural sẽ chuyển một chuỗi đơn thành dạng số nhiều của nó. Chức năng này hỗ trợ bất kỳ ngôn ngữ nào được hỗ trợ bộ quy tắc số nhiều của Laravel:

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

Tham số prependCount có thể được cung cấp để thêm tiền tố cho chuỗi đã được chuyển sang dạng số nhiều bằng giá trị $count:

use Illuminate\Support\Str;

$label = Str::plural('car', 1000, prependCount: true);

// 1,000 cars

`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 hỗ trợ bất kỳ ngôn ngữ nào được hỗ trợ bộ quy tắc số nhiều của Laravel:

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

Hàm Str::position sẽ trả về vị trí xuất hiện đầu tiên của một chuỗi trong một chuỗi khác. Nếu chuỗi cần tìm không tồn tại trong chuỗi đã cho, thì giá trị false sẽ được trả về:

use Illuminate\Support\Str;

$position = Str::position('Hello, World!', 'Hello');

// 0

$position = Str::position('Hello, World!', 'W');

// 7

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

Trong quá trình testing, việc "fake" các giá trị được trả về bởi phương thức Str::random có thể hữu ích. Để thực hiện việc này, bạn có thể sử dụng phương thức createRandomStringsUsing:

Str::createRandomStringsUsing(function () {
    return 'fake-random-string';
});

Để bảo phương thức random quay lại tạo một chuỗi ngẫu nhiên một cách bình thường, bạn có thể gọi phương thức createRandomStringsNormally:

Str::createRandomStringsNormally();

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

Hàm Str::repeat sẽ lặp lại chuỗi đã cho:

use Illuminate\Support\Str;

$string = 'a';

$repeat = Str::repeat($string, 5);

// aaaaa

`Str::replace()`

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

use Illuminate\Support\Str;

$string = 'Laravel 11.x';

$replaced = Str::replace('11.x', '12.x', $string);

// Laravel 12.x

Phương thức replace cũng chấp nhận tham số caseSensitive. Mặc định, phương thức replace sẽ phân biệt chữ hoa và chữ thường:

$replaced = Str::replace(
    'php',
    'Laravel',
    'PHP Framework for Web Artisans',
    caseSensitive: false
);

// Laravel Framework for Web Artisans

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

Hàm Str::replaceMatches sẽ thay thế tất cả các phần của chuỗi mà khớp với pattern bằng một chuỗi thay thế đã cho:

use Illuminate\Support\Str;

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

// '15015551000'

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

use Illuminate\Support\Str;

$replaced = Str::replaceMatches('/\d/', function (array $matches) {
    return '['.$matches[0].']';
}, '123');

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

`Str::replaceStart()`

Hàm Str::replaceStart sẽ chỉ thay thế phần tử đầu tiên của chuỗi được chỉ định nếu giá trị cần thay thế xuất hiện ở đầu chuỗi:

use Illuminate\Support\Str;

$replaced = Str::replaceStart('Hello', 'Laravel', 'Hello World');

// Laravel World

$replaced = Str::replaceStart('World', 'Laravel', 'Hello World');

// Hello World

`Str::replaceEnd()`

Hàm Str::replaceEnd sẽ chỉ thay thế phần tử cuối cùng của chuỗi đã cho nếu giá trị cần thay thế xuất hiện ở cuối chuỗi:

use Illuminate\Support\Str;

$replaced = Str::replaceEnd('World', 'Laravel', 'Hello World');

// Hello Laravel

$replaced = Str::replaceEnd('Hello', 'Laravel', 'Hello World');

// Hello World

`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 một chuỗi thành dạng số ít của nó. Chức năng này hỗ trợ bất kỳ ngôn ngữ nào được hỗ trợ bộ quy tắc số nhiều của Laravel:

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 chuỗi đã cho thành Str::snake:

use Illuminate\Support\Str;

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

// foo_bar

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

// foo-bar

`Str::squish()`

Hàm Str::squish sẽ loại bỏ tất cả các khoảng trắng không cần thiết có trong một chuỗi, bao gồm cả các khoảng trắng không liên quan giữa các từ đó:

use Illuminate\Support\Str;

$string = Str::squish('    laravel    framework    ');

// laravel framework

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

Hàm Str::swap sẽ thay thế nhiều giá trị trong chuỗi đã cho bằng hàm strtr của PHP:

use Illuminate\Support\Str;

$string = Str::swap([
    'Tacos' => 'Burritos',
    'great' => 'fantastic',
], 'Tacos are great!');

// Burritos are fantastic!

`Str::take()`

Hàm Str::take sẽ trả về các ký tự được chỉ định tính từ đầu chuỗi:

use Illuminate\Support\Str;

$taken = Str::take('Build something amazing!', 5);

// Build

`Str::title()`

Hàm Str::title chuyển 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::toBase64()`

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

use Illuminate\Support\Str;

$base64 = Str::toBase64('Laravel');

// TGFyYXZlbA==

`Str::transliterate()`

Hàm Str::transliterate sẽ cố gắng chuyển một chuỗi đã cho thành dạng ASCII gần nhất của nó:

use Illuminate\Support\Str;

$email = Str::transliterate('ⓣⓔⓢⓣ@ⓛⓐⓡⓐⓥⓔⓛ.ⓒⓞⓜ');

// '[email protected]'

`Str::trim()`

Hàm Str::trim sẽ loại bỏ khoảng trắng (hoặc các ký tự khác) ra khỏi đầu và cuối của chuỗi đã cho. Không giống như hàm trim có sẵn của PHP, hàm Str::trim cũng sẽ loại bỏ các ký tự khoảng trắng unicode:

use Illuminate\Support\Str;

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

// 'foo bar'

`Str::ltrim()`

Hàm Str::ltrim sẽ loại bỏ khoảng trắng (hoặc các ký tự khác) ra khỏi đầu của chuỗi đã cho. Không giống như hàm ltrim có sẵn của PHP, hàm Str::ltrim cũng sẽ loại bỏ các ký tự khoảng trắng unicode:

use Illuminate\Support\Str;

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

// 'foo bar  '

`Str::rtrim()`

Hàm Str::rtrim sẽ loại bỏ khoảng trắng (hoặc các ký tự khác) ra khỏi cuối của chuỗi đã cho. Không giống như hàm rtrim có sẵn của PHP, hàm Str::rtrim cũng sẽ loại bỏ các ký tự khoảng trắng unicode:

use Illuminate\Support\Str;

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

// '  foo bar'

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

Hàm Str::ucsplit sẽ chia chuỗi đã cho thành một mảng theo các ký tự được viết hoa:

use Illuminate\Support\Str;

$segments = Str::ucsplit('FooBar');

// [0 => 'Foo', 1 => 'Bar']

`Str::ucwords()`

Hàm Str::ucwords sẽ chuyển ký tự đầu tiên của mỗi từ có trong chuỗi đã cho thành chữ hoa:

use Illuminate\Support\Str;

$string = Str::ucwords('laravel framework');

// Laravel Framework

`Str::upper()`

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

use Illuminate\Support\Str;

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

// LARAVEL

`Str::ulid()`

Hàm Str::ulid sẽ tạo một mã ULID nhỏ gọn kết hợp với thời gian và có thể sắp xếp được:

use Illuminate\Support\Str;

return (string) Str::ulid();

// 01gd6r360bp37zj17nxb55yv40

Nếu bạn muốn lấy ra một instance Illuminate\Support\Carbon theo kiểu ngày và giờ từ một ULID nhất định, bạn có thể sử dụng phương thức createFromId do Laravel cung cấp được tích hợp sẵn trong class Carbon:

use Illuminate\Support\Carbon;
use Illuminate\Support\Str;

$date = Carbon::createFromId((string) Str::ulid());

Trong quá trình testing, việc "fake" các giá trị được trả về bởi phương thức Str::ulid có thể hữu ích. Để thực hiện việc này, bạn có thể sử dụng phương thức createUlidsUsing:

use Symfony\Component\Uid\Ulid;

Str::createUlidsUsing(function () {
    return new Ulid('01HRDBNHHCKNW2AK4Z29SN82T9');
});

Để bảo phương thức ulid quay lại tạo một ULID theo cách bình thường, bạn có thể gọi phương thức createUlidsNormally:

Str::createUlidsNormally();

`Str::unwrap()`

Hàm Str::unwrap sẽ xóa các chuỗi được chỉ định ra khỏi đầu hoặc cuối của một chuỗi nhất định:

use Illuminate\Support\Str;

Str::unwrap('-Laravel-', '-');

// Laravel

Str::unwrap('{framework: "Laravel"}', '{', '}');

// framework: "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();

Trong quá trình testing, việc "fake" các giá trị được trả về bởi phương thức Str::uuid có thể hữu ích. Để thực hiện việc này, bạn có thể sử dụng phương thức createUuidsUsing:

use Ramsey\Uuid\Uuid;

Str::createUuidsUsing(function () {
    return Uuid::fromString('eadbfeac-5258-45c2-bab7-ccb9b5ef74f9');
});

Để bảo phương thức uuid quay lại tạo một UUID theo cách bình thường, bạn có thể gọi phương thức createUuidsNormally:

Str::createUuidsNormally();

`Str::uuid7()`

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

use Illuminate\Support\Str;

return (string) Str::uuid7();

Một DateTimeInterface có thể được truyền vào như một tham số thêm và sẽ được sử dụng để tạo UUID có thể sắp xếp:

return (string) Str::uuid7(time: now());

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

Hàm Str::wordWrap sẽ thêm một chuỗi vào trong một chuỗi khác ở một số vị trí nhất định:

use Illuminate\Support\Str;

$text = "The quick brown fox jumped over the lazy dog."

Str::wordWrap($text, characters: 20, break: "<br />\n");

/*
The quick brown fox<br />
jumped over the lazy<br />
dog.
*/

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

`Str::wrap()`

Hàm Str::wrap sẽ thêm vào một chuỗi đã cho bằng một chuỗi khác hoặc một cặp chuỗi khác:

use Illuminate\Support\Str;

Str::wrap('Laravel', '"');

// "Laravel"

Str::wrap('is', before: 'This ', after: ' Laravel!');

// This is Laravel!

`str()`

Hàm str sẽ trả về một instance Illuminate\Support\Stringable mới của một chuỗi đã cho. Hàm này giống với hàm Str::of:

$string = str('Taylor')->append(' Otwell');

// 'Taylor Otwell'

Nếu không có tham số nào được truyền vào cho hàm str, thì hàm này trả về một instance của Illuminate\Support\Str:

$snake = str()->snake('FooBar');

// 'foo_bar'

`trans()`

Hàm trans sẽ dịch các key cần dịch bằng cách sử dụng language 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'

`apa`

Hàm apa sẽ chuyển chuỗi đã cho thành chữ viết hoa đầu dòng theo hướng dẫn của APA:

use Illuminate\Support\Str;

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

// A Nice Title Uses the Correct Case

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

`betweenFirst`

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

use Illuminate\Support\Str;

$converted = Str::of('[a] bc [d]')->betweenFirst('[', ']');

// 'a'

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

`charAt`

Hàm charAt sẽ trả về một ký tự tại vị trí được chỉ định. Nếu vị trí chỉ định nằm ngoài chuỗi, thì false sẽ được trả về:

use Illuminate\Support\Str;

$character = Str::of('This is my name.')->charAt(6);

// 's'

`classBasename`

Hàm classBasename sẽ trả về tên class của class đã cho mà namespace của class đó đã bị xóa bỏ:

use Illuminate\Support\Str;

$class = Str::of('Foo\Bar\Baz')->classBasename();

// 'Baz'

`chopStart`

Hàm chopStart sẽ xóa đi giá trị đầu tiên chỉ định nếu giá trị đó xuất hiện ở đầu của chuỗi:

use Illuminate\Support\Str;

$url = Str::of('https://laravel.com')->chopStart('https://');

// 'laravel.com'

Bạn cũng có thể truyền vào một mảng. Nếu chuỗi bắt đầu với bất kỳ giá trị nào có trong mảng thì giá trị đó sẽ bị xóa khỏi chuỗi:

use Illuminate\Support\Str;

$url = Str::of('http://laravel.com')->chopStart(['https://', 'http://']);

// 'laravel.com'

`chopEnd`

Hàm chopEnd sẽ xóa đi giá trị cuối cùng chỉ định nếu giá trị đó xuất hiện ở cuối của chuỗi:

use Illuminate\Support\Str;

$url = Str::of('https://laravel.com')->chopEnd('.com');

// 'https://laravel'

Bạn cũng có thể truyền vào một mảng. Nếu chuỗi kết thúc với bất kỳ giá trị nào có trong mảng thì giá trị đó sẽ bị xóa khỏi chuỗi:

use Illuminate\Support\Str;

$url = Str::of('http://laravel.com')->chopEnd(['.com', '.io']);

// 'http://laravel'

`contains`

Hàm contains sẽ xác định xem chuỗi đã cho có chứa giá trị đã cho hay không. Mặc định, 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

Bạn có thể tắt tính phân biệt chữ hoa chữ thường bằng cách đặt tham số ignoreCase thành true:

use Illuminate\Support\Str;

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

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

Bạn có thể tắt tính phân biệt chữ hoa chữ thường bằng cách đặt tham số ignoreCase thành true:

use Illuminate\Support\Str;

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

// true

`decrypt`

Hàm decrypt sẽ giải mã chuỗi đã mã hóa:

use Illuminate\Support\Str;

$decrypted = $encrypted->decrypt();

// 'secret'

Để làm ngược lại với hàm decrypt, hãy xem hàm encrypt.

`deduplicate`

Hàm deduplicate sẽ thay thế các ký tự trùng lặp liên tiếp trong chuỗi đã cho thành một ký tự duy nhất. Mặc định, hàm deduplicate sẽ loại bỏ các khoảng trắng trùng lặp:

use Illuminate\Support\Str;

$result = Str::of('The   Laravel   Framework')->deduplicate();

// The Laravel Framework

Bạn có thể chỉ định một ký tự khác để loại bỏ bằng cách truyền nó vào như tham số thứ hai:

use Illuminate\Support\Str;

$result = Str::of('The---Laravel---Framework')->deduplicate('-');

// The-Laravel-Framework

`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 số level cấp của thư mục mà bạn muốn loại bỏ ra khỏi chuỗi:

use Illuminate\Support\Str;

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

// '/foo'

`doesntContain()`

Hàm doesntContain sẽ xác định xem chuỗi đã cho không chứa giá trị đã cho hay không. Hàm này là hàm ngược lại của hàm contains. Mặc định, hàm này có phân biệt chữ hoa chữ thường:

use Illuminate\Support\Str;

$doesntContain = Str::of('This is name')->doesntContain('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 không chứa bất kỳ giá trị nào có trong mảng này hay không:

use Illuminate\Support\Str;

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

// true

Bạn có thể tắt tính năng phân biệt chữ hoa chữ thường bằng cách set tham số ignoreCase thành true:

use Illuminate\Support\Str;

$doesntContain = Str::of('This is my name')->doesntContain('MY', ignoreCase: true);

// false

`doesntEndWith`

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

use Illuminate\Support\Str;

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

// 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 không kết thúc bằng bất kỳ giá trị nào có trong mảng này hay không:

use Illuminate\Support\Str;

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

// true

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

// false

`doesntStartWith`

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

use Illuminate\Support\Str;

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

// 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 không bắt đầu bằng bất kỳ giá trị nào có trong mảng này hay không:

use Illuminate\Support\Str;

$result = Str::of('This is my name')->doesntStartWith(['What', 'That', 'There']);

// true

`encrypt`

Hàm encrypt sẽ mã hóa chuỗi đã cho:

use Illuminate\Support\Str;

$encrypted = Str::of('secret')->encrypt();

Để làm ngược lại với hàm encrypt, hãy xem hàm decrypt.

`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

`excerpt`

Hàm excerpt sẽ lấy ra một đoạn đầu tiên từ một chuỗi mà khớp với chuỗi đã cho:

use Illuminate\Support\Str;

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

// '...is my na...'

Tùy chọn radius có giá trị mặc định là 100, cho phép bạn định nghĩa số lượng ký tự sẽ xuất hiện ở mỗi bên của chuỗi đã được lấy ra.

Ngoài ra, bạn có thể sử dụng tùy chọn omission để thay đổi chuỗi sẽ được thêm vào trước hoặc sau chuỗi đã được lấy ra:

use Illuminate\Support\Str;

$excerpt = Str::of('This is my name')->excerpt('name', [
    'radius' => 3,
    'omission' => '(...) '
]);

// '(...) my name'

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

`fromBase64`

Hàm fromBase64 sẽ giải mã chuỗi Base64 đã cho:

use Illuminate\Support\Str;

$decoded = Str::of('TGFyYXZlbA==')->fromBase64();

// Laravel

`hash`

Hàm hash sẽ hash chuỗi đã cho bằng một thuật toán đã cho:

use Illuminate\Support\Str;

$hashed = Str::of('secret')->hash(algorithm: 'sha256');

// '2bb80d537b1da3e38bd30361aa855686bde0eacd7162fef6a25fe97bf527a25b'

`headline`

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

use Illuminate\Support\Str;

$headline = Str::of('taylor_otwell')->headline();

// Taylor Otwell

$headline = Str::of('EmailNotificationSent')->headline();

// Email Notification Sent

`initials`

Hàm initials sẽ chuyển đổi chuỗi thành chuỗi gồm có các chữ cái đầu có trong chuỗi đã cho:

use Illuminate\Support\Str;

$initials = Str::of('Taylor Otwell')->initials()->upper();

// TO

`inlineMarkdown`

Hàm inlineMarkdown sẽ chuyển đổi Markdown định dạng theo chuẩn GitHub thành HTML bằng cách sử dụng CommonMark. Tuy nhiên, không giống như phương thức markdown, nó không wrap tất cả code HTML được tạo vào trong một phần tử ở mức độ block:

use Illuminate\Support\Str;

$html = Str::of('**Laravel**')->inlineMarkdown();

// <strong>Laravel</strong>

Markdown Security

use Illuminate\Support\Str;

Str::of('Inject: <script>alert("Hello XSS!");</script>')->inlineMarkdown([
    'html_input' => 'strip',
    'allow_unsafe_links' => false,
]);

// Inject: alert(&quot;Hello XSS!&quot;);

`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

`isJson`

Hàm isJson sẽ xác định xem một chuỗi đã cho có phải là dạng JSON hợp lệ hay không:

use Illuminate\Support\Str;

$result = Str::of('[1,2,3]')->isJson();

// true

$result = Str::of('{"first": "John", "last": "Doe"}')->isJson();

// true

$result = Str::of('{first: "John", last: "Doe"}')->isJson();

// false

`isUlid`

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

use Illuminate\Support\Str;

$result = Str::of('01gd6r360bp37zj17nxb55yv40')->isUlid();

// true

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

// false

`isUrl`

Hàm isUrl sẽ xác định xem một chuỗi nhất định có phải là một URL hay không:

use Illuminate\Support\Str;

$result = Str::of('http://example.com')->isUrl();

// true

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

// false

Hàm isUrl chấp nhận nhiều giao thức. Tuy nhiên, bạn có thể chỉ định các giao thức được coi là hợp lệ bằng cách cung cấp chúng cho hàm isUrl:

$result = Str::of('http://example.com')->isUrl(['http', 'https']);

`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

Bạn cũng có thể kiểm tra xem UUID đã cho có khớp với một phiên bản UUID cụ thể (1, 3, 4, 5, 6, 7, hoặc 8) hay không:

use Illuminate\Support\Str;

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

// true

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

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

`lcfirst`

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

use Illuminate\Support\Str;

$string = Str::of('Foo Bar')->lcfirst();

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

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

// The quick brown fox (...)

Nếu bạn muốn giữ nguyên các từ hoàn chỉnh khi cắt chuỗi, bạn có thể sử dụng tham số preserveWords. Khi tham số này được đặt thành true, chuỗi sẽ được cắt đến vị trí gần nhất của từ hoàn chỉnh:

$truncated = Str::of('The quick brown fox')->limit(12, preserveWords: true);

// The quick...

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

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

Markdown Security

use Illuminate\Support\Str;

Str::of('Inject: <script>alert("Hello XSS!");</script>')->markdown([
    'html_input' => 'strip',
    'allow_unsafe_links' => false,
]);

// <p>Inject: alert(&quot;Hello XSS!&quot;);</p>

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

Nếu cần, bạn cũng có thể cung cấp một số âm làm tham số thứ ba hoặc tham số thứ tư 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::of('[email protected]')->mask('*', -15, 3);

// tay***@example.com

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

// tayl**********.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 đầu tiên phù hợp với 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ề.

`isMatch`

Hàm isMatch sẽ trả về giá trị true nếu chuỗi khớp với một biểu thức chính quy nhất định:

use Illuminate\Support\Str;

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

// true

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

// false

`newLine`

Hàm newLine sẽ thêm một dòng mới vào chuỗi:

use Illuminate\Support\Str;

$padded = Str::of('Laravel')->newLine()->append('Framework');

// 'Laravel
//  Framework'

`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;
use Illuminate\Support\Stringable;

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

// 'Checksum: a5c95b86291ea299fcbe64458ed12702'

$closure = Str::of('foo')->pipe(function (Stringable $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 hỗ trợ bất kỳ ngôn ngữ nào được hỗ trợ bộ quy tắc số nhiều của Laravel:

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

Bạn có thể cung cấp tham số prependCount để thêm prefix cho chuỗi số nhiều bằng một biến $count:

use Illuminate\Support\Str;

$label = Str::of('car')->plural(1000, prependCount: true);

// 1,000 cars

`position`

Hàm position sẽ trả về vị trí xuất hiện đầu tiên của một chuỗi trong một chuỗi khác. Nếu chuỗi cần tìm không tồn tại trong chuỗi đã cho, thì giá trị false sẽ được trả về:

use Illuminate\Support\Str;

$position = Str::of('Hello, World!')->position('Hello');

// 0

$position = Str::of('Hello, World!')->position('W');

// 7

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

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

`repeat`

Hàm repeat sẽ lặp lại chuỗi đã cho:

use Illuminate\Support\Str;

$repeated = Str::of('a')->repeat(5);

// aaaaa

`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

Phương thức replace cũng chấp nhận tham số caseSensitive. Mặc định, phương thức replace sẽ phân biệt chữ hoa và chữ thường:

$replaced = Str::of('macOS 13.x')->replace(
    'macOS', 'iOS', caseSensitive: false
);

`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 (array $matches) {
    return '['.$matches[0].']';
});

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

`replaceStart`

Hàm replaceStart sẽ chỉ thay thế phần tử đầu tiên của chuỗi được chỉ định nếu giá trị cần thay thế xuất hiện ở đầu chuỗi:

use Illuminate\Support\Str;

$replaced = Str::of('Hello World')->replaceStart('Hello', 'Laravel');

// Laravel World

$replaced = Str::of('Hello World')->replaceStart('World', 'Laravel');

// Hello World

`replaceEnd`

Hàm replaceEnd sẽ chỉ thay thế phần tử cuối cùng của chuỗi đã cho nếu giá trị cần thay thế xuất hiện ở cuối chuỗi:

use Illuminate\Support\Str;

$replaced = Str::of('Hello World')->replaceEnd('World', 'Laravel');

// Hello Laravel

$replaced = Str::of('Hello World')->replaceEnd('Hello', 'Laravel');

// Hello World

`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 hỗ trợ bất kỳ ngôn ngữ nào được hỗ trợ bộ quy tắc số nhiều của Laravel:

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

`squish`

Hàm squish sẽ loại bỏ tất cả các khoảng trắng không cần thiết có trong một chuỗi, bao gồm cả các khoảng trắng không liên quan giữa các từ đó:

use Illuminate\Support\Str;

$string = Str::of('    laravel    framework    ')->squish();

// laravel framework

`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

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ó bắt đầu bằng bất kỳ giá trị nào có trong mảng hay không:

use Illuminate\Support\Str;

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

// true

`stripTags`

Hàm stripTags sẽ xóa tất cả các tag HTML và tag PHP ra khỏi một chuỗi:

use Illuminate\Support\Str;

$result = Str::of('<a href="https://laravel.com">Taylor <b>Otwell</b></a>')->stripTags();

// Taylor Otwell

$result = Str::of('<a href="https://laravel.com">Taylor <b>Otwell</b></a>')->stripTags('<b>');

// Taylor <b>Otwell</b>

`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ứ hai và thay thế số ký tự được chỉ định bởi tham số thứ ba. Truyền tham số thứ ba 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

`swap`

Hàm swap sẽ thay thế nhiều giá trị trong chuỗi đã cho bằng hàm strtr của PHP:

use Illuminate\Support\Str;

$string = Str::of('Tacos are great!')
    ->swap([
        'Tacos' => 'Burritos',
        'great' => 'fantastic',
    ]);

// Burritos are fantastic!

`take`

Hàm take sẽ trả về các ký tự được chỉ định tính từ đầu chuỗi:

use Illuminate\Support\Str;

$taken = Str::of('Build something amazing!')->take(5);

// Build

`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;
use Illuminate\Support\Stringable;

$string = Str::of('Laravel')
    ->append(' Framework')
    ->tap(function (Stringable $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

`toBase64`

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

use Illuminate\Support\Str;

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

// TGFyYXZlbA==

`toHtmlString`

Hàm toHtmlString sẽ chuyển chuỗi đã cho thành một instance của Illuminate\Support\HtmlString, chuỗi này sẽ không bị loại bỏ ký tự đặc biệt khi được hiển thị trong các template Blade:

use Illuminate\Support\Str;

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

`toUri`

Hàm toUri sẽ chuyển chuỗi đã cho thành một instance của Illuminate\Support\Uri:

use Illuminate\Support\Str;

$uri = Str::of('https://example.com')->toUri();

`transliterate`

Hàm transliterate sẽ cố gắng chuyển một chuỗi đã cho thành dạng ASCII gần nhất của nó:

use Illuminate\Support\Str;

$email = Str::of('ⓣⓔⓢⓣ@ⓛⓐⓡⓐⓥⓔⓛ.ⓒⓞⓜ')->transliterate()

// '[email protected]'

`trim`

Hàm trim sẽ cắt chuỗi đã cho. Không giống như hàm trim có sẵn của PHP, hàm trim của Laravel cũng sẽ loại bỏ các ký tự khoảng trắng unicode:

use Illuminate\Support\Str;

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

// 'Laravel'

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

// 'Laravel'

`ltrim`

Hàm ltrim cắt chuỗi đã cho từ phía trái. Không giống như hàm ltrim có sẵn của PHP, hàm ltrim của Laravel cũng sẽ loại bỏ các ký tự khoảng trắng unicode:

use Illuminate\Support\Str;

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

// 'Laravel  '

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

// 'Laravel/'

`rtrim`

Hàm rtrim cắt chuỗi đã cho từ phía phải. Không giống như hàm rtrim có sẵn của PHP, hàm rtrim của Laravel cũng sẽ loại bỏ các ký tự khoảng trắng unicode:

use Illuminate\Support\Str;

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

// '  Laravel'

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

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

`ucsplit`

Hàm ucsplit sẽ chia chuỗi đã cho thành một collection theo các ký tự được viết hoa:

use Illuminate\Support\Str;

$string = Str::of('Foo Bar')->ucsplit();

// collect(['Foo', 'Bar'])

`ucwords`

Hàm ucwords sẽ chuyển ký tự đầu tiên của mỗi từ có trong chuỗi đã cho thành chữ hoa:

use Illuminate\Support\Str;

$string = Str::of('laravel framework')->ucwords();

// Laravel Framework

`unwrap`

Hàm unwrap sẽ xóa các chuỗi được chỉ định ra khỏi đầu hoặc cuối của một chuỗi nhất định:

use Illuminate\Support\Str;

Str::of('-Laravel-')->unwrap('-');

// Laravel

Str::of('{framework: "Laravel"}')->unwrap('{', '}');

// framework: "Laravel"

`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;
use Illuminate\Support\Stringable;

$string = Str::of('Taylor')
    ->when(true, function (Stringable $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;
use Illuminate\Support\Stringable;

$string = Str::of('tony stark')
    ->whenContains('tony', function (Stringable $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. Closure sẽ được gọi 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;
use Illuminate\Support\Stringable;

$string = Str::of('tony stark')
    ->whenContains(['tony', 'hulk'], function (Stringable $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;
use Illuminate\Support\Stringable;

$string = Str::of('tony stark')
    ->whenContainsAll(['tony', 'stark'], function (Stringable $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. Closure sẽ được gọi nếu tham số điều kiện là false.

`whenDoesntEndWith`

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

use Illuminate\Support\Str;
use Illuminate\Support\Stringable;

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

// 'Disney World'

`whenDoesntStartWith`

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

use Illuminate\Support\Str;
use Illuminate\Support\Stringable;

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

// 'Disney World'

`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;
use Illuminate\Support\Stringable;

$string = Str::of('  ')->whenEmpty(function (Stringable $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;
use Illuminate\Support\Stringable;

$string = Str::of('Framework')->whenNotEmpty(function (Stringable $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;
use Illuminate\Support\Stringable;

$string = Str::of('disney world')->whenStartsWith('disney', function (Stringable $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;
use Illuminate\Support\Stringable;

$string = Str::of('disney world')->whenEndsWith('world', function (Stringable $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;
use Illuminate\Support\Stringable;

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

// 'Laravel'

`whenNotExactly`

Hàm whenNotExactly sẽ gọi một closure đã cho nếu chuỗi đó không giống với chuỗi đã cho. Closure sẽ nhận vào instance chuỗi:

use Illuminate\Support\Str;
use Illuminate\Support\Stringable;

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

// 'Framework'

`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;
use Illuminate\Support\Stringable;

$string = Str::of('foo/bar')->whenIs('foo/*', function (Stringable $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;
use Illuminate\Support\Stringable;

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

// 'Laravel'

`whenIsUlid`

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

use Illuminate\Support\Str;

$string = Str::of('01gd6r360bp37zj17nxb55yv40')->whenIsUlid(function (Stringable $string) {
    return $string->substr(0, 8);
});

// '01gd6r36'

`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;
use Illuminate\Support\Stringable;

$string = Str::of('a0a2a2d2-0b87-4a18-83f2-2529882be2de')->whenIsUuid(function (Stringable $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;
use Illuminate\Support\Stringable;

$string = Str::of('laravel framework')->whenTest('/laravel/', function (Stringable $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 >>>

`wrap`

Hàm wrap sẽ bao bọc chuỗi đã cho bằng một chuỗi khác hoặc bằng một cặp chuỗi khác:

use Illuminate\Support\Str;

Str::of('Laravel')->wrap('"');

// "Laravel"

Str::of('is')->wrap(before: 'This ', after: ' Laravel!');

// This is Laravel!

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

Strings

Fluent Strings

Strings

__()

class_basename()

e()

preg_replace_array()

Str::after()

Str::afterLast()

Str::apa()

Str::ascii()

Str::before()

Str::beforeLast()

Str::between()

Str::betweenFirst()

Str::camel()

Str::charAt()

Str::chopStart()

Str::chopEnd()

Str::contains()

Str::containsAll()

Str::doesntContain()

Str::deduplicate()

Str::doesntEndWith()

Str::doesntStartWith()

Str::endsWith()

Str::excerpt()

Str::finish()

Str::fromBase64()

Str::headline()

Str::initials()

Str::inlineMarkdown()

Markdown Security

Str::is()

Str::isAscii()

Str::isJson()

Str::isUrl()

Str::isUlid()

Str::isUuid()

Str::kebab()

Str::lcfirst()

Str::length()

Str::limit()

Str::lower()

Str::markdown()

Markdown Security

Str::mask()

Str::match()

Str::matchAll()

Str::isMatch()

Str::orderedUuid()

Str::padBoth()

Str::padLeft()

Str::padRight()

Str::password()

Str::plural()

`__()`

`class_basename()`

`e()`

`preg_replace_array()`

`Str::after()`

`Str::afterLast()`

`Str::apa()`

`Str::ascii()`

`Str::before()`

`Str::beforeLast()`

`Str::between()`

`Str::betweenFirst()`

`Str::camel()`

`Str::charAt()`

`Str::chopStart()`

`Str::chopEnd()`

`Str::contains()`

`Str::containsAll()`

`Str::doesntContain()`

`Str::deduplicate()`

`Str::doesntEndWith()`

`Str::doesntStartWith()`

`Str::endsWith()`

`Str::excerpt()`

`Str::finish()`

`Str::fromBase64()`

`Str::headline()`

`Str::initials()`

`Str::inlineMarkdown()`

`Str::is()`

`Str::isAscii()`

`Str::isJson()`

`Str::isUrl()`

`Str::isUlid()`

`Str::isUuid()`

`Str::kebab()`

`Str::lcfirst()`

`Str::length()`

`Str::limit()`

`Str::lower()`

`Str::markdown()`

`Str::mask()`

`Str::match()`

`Str::matchAll()`

`Str::isMatch()`

`Str::orderedUuid()`

`Str::padBoth()`

`Str::padLeft()`

`Str::padRight()`

`Str::password()`

`Str::plural()`

`Str::pluralStudly()`

`Str::position()`

`Str::random()`

`Str::remove()`

`Str::repeat()`

`Str::replace()`

`Str::replaceArray()`

`Str::replaceFirst()`

`Str::replaceLast()`

`Str::replaceMatches()`

`Str::replaceStart()`

`Str::replaceEnd()`

`Str::reverse()`

`Str::singular()`

`Str::slug()`

`Str::snake()`

`Str::squish()`

`Str::start()`

`Str::startsWith()`

`Str::studly()`

`Str::substr()`

`Str::substrCount()`

`Str::substrReplace()`

`Str::swap()`

`Str::take()`

`Str::title()`

`Str::toBase64()`

`Str::transliterate()`

`Str::trim()`