字符串

简介

Laravel 包含了多种用于操作字符串值的函数。许多这些函数是框架本身使用的；然而，如果你觉得它们方便，你也可以在自己的应用程序中使用它们。

可用方法

Strings

__()

__ 函数使用你的【语言文件】翻译给定的翻译字符串或翻译键：

echo __('Welcome to our application');

echo __('messages.welcome');

如果指定的翻译字符串或键不存在，__ 函数将返回给定的值。所以，以上例子中，如果 messages.welcome 的翻译键不存在，__ 函数将返回 messages.welcome。

class_basename()

class_basename 函数返回给定类的类名，并去除类的命名空间：

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

// 'Baz'

e()

e 函数使用 PHP 的 htmlspecialchars 函数，并将 double_encode 选项默认设置为 true：

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

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

preg_replace_array()

preg_replace_array 函数使用数组顺序替换字符串中的给定模式：

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

Str::after 方法返回字符串中给定值后的所有内容。如果该值在字符串中不存在，则返回整个字符串：

use Illuminate\Support\Str;

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

// ' my name'

Str::afterLast()

Str::afterLast 方法返回字符串中最后一次出现的给定值后的所有内容。如果该值在字符串中不存在，则返回整个字符串：

use Illuminate\Support\Str;

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

// 'Controller'

Str::apa()

Str::apa 方法根据 APA 指南将给定的字符串转换为标题大小写：

use Illuminate\Support\Str;

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

// 'Creating a Project'

Str::ascii()

Str::ascii 方法会尝试将字符串转换为 ASCII 值：

use Illuminate\Support\Str;

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

// 'u'

Str::before()

Str::before 方法返回给定值之前的所有内容：

use Illuminate\Support\Str;

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

// 'This is '

Str::beforeLast()

Str::beforeLast 方法返回字符串中最后一次出现的给定值之前的所有内容：

use Illuminate\Support\Str;

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

// 'This '

Str::between()

Str::between 方法返回字符串中两个值之间的部分：

use Illuminate\Support\Str;

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

// ' is my '

Str::betweenFirst()

Str::betweenFirst 方法返回字符串中两个值之间的最小部分：

use Illuminate\Support\Str;

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

// 'a'

Str::camel()

Str::camel 方法将给定的字符串转换为 camelCase：

use Illuminate\Support\Str;

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

// 'fooBar'

Str::charAt()

Str::charAt 方法返回指定索引处的字符。如果索引越界，则返回 false：

use Illuminate\Support\Str;

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

// 's'

Str::chopStart()

Str::chopStart 方法仅在给定的值出现在字符串的开始时，才移除该值的第一次出现：

use Illuminate\Support\Str;

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

// 'laravel.com'

你还可以传递一个数组作为第二个参数。如果字符串以数组中的任何一个值开始，则该值将被从字符串中移除：

use Illuminate\Support\Str;

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

// 'laravel.com'

Str::chopEnd()

Str::chopEnd 方法仅在给定的值出现在字符串的末尾时，才移除该值的最后一次出现：

use Illuminate\Support\Str;

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

// 'app/Models/Photograph'

你还可以传递一个数组作为第二个参数。如果字符串以数组中的任何一个值结束，则该值将被从字符串中移除：

use Illuminate\Support\Str;

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

// 'laravel.com'

Str::contains()

Str::contains 方法用于判断给定的字符串是否包含指定的值。默认情况下，这个方法是区分大小写的：

use Illuminate\Support\Str;

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

// true

你还可以传递一个值数组，判断字符串是否包含数组中的任何一个值：

use Illuminate\Support\Str;

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

// true

通过设置 ignoreCase 参数为 true，你可以禁用区分大小写：

use Illuminate\Support\Str;

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

// true

Str::containsAll()

Str::containsAll 方法用于判断给定字符串是否包含数组中的所有值：

use Illuminate\Support\Str;

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

// true

你也可以通过设置 ignoreCase 参数为 true 来禁用区分大小写：

use Illuminate\Support\Str;

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

// true

Str::doesntContain()

Str::doesntContain 方法用于判断给定的字符串是否不包含指定的值。默认情况下，此方法是区分大小写的：

use Illuminate\Support\Str;

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

// true

你也可以传递一个值数组，判断字符串是否不包含数组中的任何一个值：

use Illuminate\Support\Str;

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

// true

通过设置 ignoreCase 参数为 true，你可以禁用区分大小写：

use Illuminate\Support\Str;

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

// true

Str::deduplicate()

Str::deduplicate 方法替换给定字符串中连续的字符，只保留一个实例。默认情况下，此方法会去重空格：

use Illuminate\Support\Str;

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

// The Laravel Framework

你还可以通过第二个参数指定不同的字符进行去重：

use Illuminate\Support\Str;

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

// The-Laravel-Framework

Str::endsWith()

Str::endsWith 方法判断给定的字符串是否以指定的值结尾：

use Illuminate\Support\Str;

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

// true

你可以传递一个值数组，判断字符串是否以数组中的任何一个值结尾：

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

Str::excerpt 方法从给定的字符串中提取与第一次出现的短语匹配的摘录：

use Illuminate\Support\Str;

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

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

radius 参数（默认为 100）允许你定义截断字符串时，两侧应显示的字符数。

你还可以使用 omission 参数来定义在截断字符串时，前后加上的字符串：

use Illuminate\Support\Str;

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

// '(...) my name'

Str::finish()

Str::finish 方法如果给定的字符串没有以指定的值结尾，则会添加一个值：

use Illuminate\Support\Str;

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

// this/string/

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

// this/string/

Str::headline()

Str::headline 方法将由大小写字母、连字符或下划线分隔的字符串转换为每个单词首字母大写、用空格分隔的字符串：

use Illuminate\Support\Str;

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

// Steve Jobs

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

// Email Notification Sent

Str::inlineMarkdown()

Str::inlineMarkdown 方法将 GitHub 风格的 Markdown 转换为内联 HTML（使用【CommonMark】）。不同于 markdown 方法，它不会将生成的所有 HTML 包装在块级元素中：

use Illuminate\Support\Str;

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

// <strong>Laravel</strong>

Markdown 安全性

默认情况下，Markdown 支持原始 HTML，这在处理来自用户的原始输入时可能会暴露跨站脚本 (XSS) 漏洞。根据 CommonMark 安全性文档，您可以使用 html_input 选项来转义或剥离原始 HTML，并使用 allow_unsafe_links 选项来指定是否允许不安全的链接。如果需要允许一些原始 HTML，您应通过 HTML Purifier 过滤已编译的 Markdown：

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

Str::is 方法用于判断给定的字符串是否匹配指定的模式。可以使用星号作为通配符：

use Illuminate\Support\Str;

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

// true

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

// false

通过设置 ignoreCase 参数为 true，可以禁用区分大小写：

use Illuminate\Support\Str;

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

// true

`Str::isAscii()`

Str::isAscii 方法用于判断给定的字符串是否是 7 位 ASCII 字符：

use Illuminate\Support\Str;

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

// true

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

// false

`Str::isJson()`

Str::isJson 方法用于判断给定的字符串是否是有效的 JSON 格式：

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

Str::isUrl 方法用于判断给定的字符串是否是有效的 URL：

use Illuminate\Support\Str;

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

// true

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

// false

isUrl 方法会考虑多种协议作为有效的 URL。但是，您可以通过提供协议列表来指定有效的协议：

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

`Str::isUlid()`

Str::isUlid 方法用于判断给定的字符串是否是有效的 ULID：

use Illuminate\Support\Str;

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

// true

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

// false

`Str::isUuid()`

Str::isUuid 方法用于判断给定的字符串是否是有效的 UUID：

use Illuminate\Support\Str;

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

// true

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

// false

`Str::kebab()`

Str::kebab 方法将给定的字符串转换为 kebab-case（用连字符分隔的小写字母）：

use Illuminate\Support\Str;

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

// foo-bar

`Str::lcfirst()`

Str::lcfirst 方法返回将第一个字符转为小写的字符串：

use Illuminate\Support\Str;

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

// foo Bar

`Str::length()`

Str::length 方法返回给定字符串的长度：

use Illuminate\Support\Str;

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

// 7

`Str::limit()`

Str::limit 方法将给定字符串截断到指定的长度：

use Illuminate\Support\Str;

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

// The quick brown fox...

您还可以传递第三个参数，来更改截断后附加的字符串：

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

// The quick brown fox (...)

如果您希望在截断字符串时保留完整的单词，可以使用 preserveWords 参数。当该参数为 true 时，字符串会截断到最接近的完整单词边界：

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

// The quick...

`Str::lower()`

Str::lower 方法将给定字符串转换为小写：

use Illuminate\Support\Str;

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

// laravel

`Str::markdown()`

Str::markdown 方法将 GitHub 风格的 Markdown 转换为 HTML（使用 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 安全性

默认情况下，Markdown 支持原始 HTML，这会暴露跨站脚本（XSS）漏洞，尤其是在处理来自用户的原始输入时。根据【CommonMark 安全性文档】，您可以使用 html_input 选项来转义或剥离原始 HTML，并使用 allow_unsafe_links 选项来指定是否允许不安全的链接。如果需要允许一些原始 HTML，您应该通过 HTML Purifier 来处理已编译的 Markdown：

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

Str::mask 方法通过重复字符来掩盖字符串的一部分，可以用于隐藏电子邮件地址或电话号码中的某些部分：

use Illuminate\Support\Str;

$string = Str::mask('taylor@example.com', '*', 3);

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

如果需要，您可以提供负数作为第三个参数，指示从字符串末尾开始掩盖：

$string = Str::mask('taylor@example.com', '*', -15, 3);

// tay***@example.com

`Str::orderedUuid()`

Str::orderedUuid 方法生成一个 "时间戳优先" 的 UUID，适合高效存储在索引数据库列中。每个生成的 UUID 都会按时间顺序排列：

use Illuminate\Support\Str;

return (string) Str::orderedUuid();

`Str::padBoth()`

Str::padBoth 方法将 PHP 的 str_pad 函数进行封装，通过将另一字符串填充到给定字符串的两边，直到最终字符串达到指定的长度：

use Illuminate\Support\Str;

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

// __James___

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

// '  James   '

`Str::padLeft()`

Str::padLeft 方法将 PHP 的 str_pad 函数进行封装，通过将另一字符串填充到给定字符串的左边，直到最终字符串达到指定的长度：

use Illuminate\Support\Str;

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

// -=-=-James

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

// '     James'

`Str::padRight()`

Str::padRight 方法将 PHP 的 str_pad 函数进行封装，通过将另一字符串填充到给定字符串的右边，直到最终字符串达到指定的长度：

use Illuminate\Support\Str;

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

// James-----

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

// James

`Str::password()`

Str::password 方法用于生成一个安全的、随机的密码，密码由字母、数字、符号和空格组成。默认情况下，密码长度为 32 个字符：

use Illuminate\Support\Str;

$password = Str::password();

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

$password = Str::password(12);

// qwuar>#V|i]N

`Str::plural()`

Str::plural 方法将单数形式的字符串转换为复数形式。此函数【支持 Laravel 的所有语言的复数化规则】：

use Illuminate\Support\Str;

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

// cars

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

// children

您可以传递一个整数作为第二个参数，以获取字符串的单数或复数形式：

use Illuminate\Support\Str;

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

// children

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

// child

`Str::pluralStudly()`

Str::pluralStudly 方法将单数形式的字符串转换为大驼峰风格的复数形式。此函数【支持 Laravel 的所有语言的复数化规则】：

use Illuminate\Support\Str;

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

// VerifiedHumans

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

// UserFeedback

您可以传递一个整数作为第二个参数，以获取字符串的单数或复数形式：

use Illuminate\Support\Str;

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

// VerifiedHumans

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

// VerifiedHuman

Str::position()

Str::position 方法返回子字符串在字符串中首次出现的位置。如果子字符串在给定的字符串中不存在，则返回 false：

use Illuminate\Support\Str;

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

// 0

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

// 7

Str::random()

Str::random 方法生成指定长度的随机字符串。此方法使用 PHP 的 random_bytes 函数：

use Illuminate\Support\Str;

$random = Str::random(40);

在测试时，您可能希望 “伪造” 由 Str::random 方法返回的值。为此，您可以使用 createRandomStringsUsing 方法：

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

要恢复正常生成随机字符串，可以调用 createRandomStringsNormally 方法：

Str::createRandomStringsNormally();

Str::remove()

Str::remove 方法从字符串中移除给定的值或值数组：

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.

您还可以将 false 作为第三个参数传递给 remove 方法，以在移除字符串时忽略大小写。

Str::repeat()

Str::repeat 方法重复给定的字符串：

use Illuminate\Support\Str;

$string = 'a';

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

// aaaaa

Str::replace()

Str::replace 方法替换字符串中的指定值：

use Illuminate\Support\Str;

$string = 'Laravel 10.x';

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

// Laravel 11.x

replace 方法也接受一个 caseSensitive 参数。默认情况下，replace 方法是区分大小写的：

Str::replace('Framework', 'Laravel', caseSensitive: false);

Str::replaceArray()

Str::replaceArray 方法使用数组顺序替换字符串中的指定值：

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

Str::replaceFirst 方法替换字符串中第一次出现的指定值：

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

Str::replaceLast 方法替换字符串中最后一次出现的指定值：

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

Str::replaceMatches 方法替换字符串中匹配模式的所有部分：

use Illuminate\Support\Str;

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

// '15015551000'

replaceMatches 方法还接受一个闭包，该闭包会对每个匹配模式的字符串部分进行调用，您可以在闭包中执行替换逻辑并返回替换后的值：

use Illuminate\Support\Str;

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

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

Str::replaceStart()

Str::replaceStart 方法仅在给定值出现在字符串开头时，才替换第一个匹配项：

use Illuminate\Support\Str;

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

// Laravel World

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

// Hello World

Str::replaceEnd()

Str::replaceEnd 方法仅在给定值出现在字符串结尾时，才替换最后一个匹配项：

use Illuminate\Support\Str;

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

// Hello Laravel

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

// Hello World

Str::reverse()

Str::reverse 方法反转给定的字符串：

use Illuminate\Support\Str;

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

// dlroW olleH

Str::singular()

Str::singular 方法将字符串转换为其单数形式。此方法支持 Laravel 的所有语言的复数规则：

use Illuminate\Support\Str;

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

// car

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

// child

Str::slug()

Str::slug 方法从给定的字符串生成一个 URL 友好的“slug”：

use Illuminate\Support\Str;

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

// laravel-5-framework

Str::snake()

Str::snake 方法将给定的字符串转换为 snake_case（蛇形命名法）：

use Illuminate\Support\Str;

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

// foo_bar

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

// foo-bar

Str::squish()

Str::squish 方法去除字符串中的所有多余空格，包括单词之间的多余空格：

use Illuminate\Support\Str;

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

// laravel framework

Str::start()

Str::start 方法如果字符串没有以给定值开始，则向字符串添加该值：

use Illuminate\Support\Str;

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

// /this/string

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

// /this/string

Str::startsWith()

Str::startsWith 方法用于判断给定的字符串是否以指定的值开头：

use Illuminate\Support\Str;

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

// true

如果传入一个可能的值数组，startsWith 方法将在字符串以数组中任意一个值开头时返回 true：

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

// true

Str::studly()

Str::studly 方法将给定的字符串转换为 StudlyCase（大驼峰式命名法）：

use Illuminate\Support\Str;

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

// FooBar

Str::substr()

Str::substr 方法返回由起始位置和长度参数指定的字符串部分：

use Illuminate\Support\Str;

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

// Laravel

Str::substrCount()

Str::substrCount 方法返回给定值在字符串中出现的次数：

use Illuminate\Support\Str;

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

// 2

Str::substrReplace()

Str::substrReplace 方法替换字符串中一部分文本，从第三个参数指定的位置开始，并替换第四个参数指定的字符数。如果传递 0 作为第四个参数，方法将在指定位置插入字符串，而不替换现有字符：

use Illuminate\Support\Str;

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

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

Str::swap()

Str::swap 方法使用 PHP 的 strtr 函数替换字符串中的多个值：

use Illuminate\Support\Str;

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

// Burritos are fantastic!

Str::take()

Str::take 方法从字符串的开头返回指定数量的字符：

use Illuminate\Support\Str;

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

// Build

Str::title()

Str::title 方法将给定的字符串转换为标题大小写（Title Case）：

use Illuminate\Support\Str;

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

// A Nice Title Uses The Correct Case

Str::toBase64()

Str::toBase64 方法将给定的字符串转换为 Base64 编码：

use Illuminate\Support\Str;

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

// TGFyYXZlbA==

Str::transliterate()

Str::transliterate 方法尝试将给定字符串转换为最接近的 ASCII 表示：

use Illuminate\Support\Str;

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

// 'test@laravel.com'

Str::trim()

Str::trim 方法去除字符串开头和结尾的空白（或其他字符）。与 PHP 的原生 trim 函数不同，Str::trim 方法还会移除 Unicode 空白字符：

use Illuminate\Support\Str;

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

// 'foo bar'

Str::ltrim()

Str::ltrim 方法去除字符串开头的空白（或其他字符）。与 PHP 的原生 ltrim 函数不同，Str::ltrim 方法也会移除 Unicode 空白字符：

use Illuminate\Support\Str;

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

// 'foo bar  '

Str::rtrim()

Str::rtrim 方法去除字符串结尾的空白（或其他字符）。与 PHP 的原生 rtrim 函数不同，Str::rtrim 方法也会移除 Unicode 空白字符：

use Illuminate\Support\Str;

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

// '  foo bar'

Str::ucfirst()

Str::ucfirst 方法返回给定字符串的首字母大写形式：

use Illuminate\Support\Str;

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

// Foo bar

Str::ucsplit()

Str::ucsplit 方法根据大写字母将给定字符串拆分为一个数组：

use Illuminate\Support\Str;

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

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

Str::upper()

Str::upper 方法将给定的字符串转换为大写字母：

use Illuminate\Support\Str;

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

// LARAVEL

Str::ulid()

Str::ulid 方法生成一个 ULID（通用唯一标识符），它是一个紧凑的、按时间排序的唯一标识符：

use Illuminate\Support\Str;

return (string) Str::ulid();

// 01gd6r360bp37zj17nxb55yv40

如果要检索由给定 ULID 创建的日期和时间的 Illuminate\Support\Carbon 实例，可以使用 Laravel 的 Carbon 集成功能中的 createFromId 方法：

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

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

在测试期间，您可能希望“伪造”由 Str::ulid 方法返回的值。为此，您可以使用 createUlidsUsing 方法：

use Symfony\Component\Uid\Ulid;

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

要恢复正常生成 ULID，可以调用 createUlidsNormally 方法：

Str::createUlidsNormally();

Str::unwrap()

Str::unwrap 方法从给定字符串的开头和结尾移除指定的字符串：

use Illuminate\Support\Str;

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

// Laravel

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

// framework: "Laravel"

Str::uuid()

Str::uuid 方法生成一个 UUID（版本 4）：

use Illuminate\Support\Str;

return (string) Str::uuid();

在测试期间，您可能希望“伪造”由 Str::uuid 方法返回的值。为此，您可以使用 createUuidsUsing 方法：

use Ramsey\Uuid\Uuid;

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

要恢复正常生成 UUID，可以调用 createUuidsNormally 方法：

Str::createUuidsNormally();

Str::wordCount()

Str::wordCount 方法返回字符串中单词的数量：

use Illuminate\Support\Str;

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

Str::wordWrap()

Str::wordWrap 方法将字符串按指定的字符数进行换行：

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

Str::words 方法限制字符串中的单词数。可以通过第三个参数指定要追加到截断字符串末尾的附加字符串：

use Illuminate\Support\Str;

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

// Perfectly balanced, as >>>

Str::wrap()

Str::wrap 方法将给定的字符串用额外的字符串或一对字符串进行包装：

use Illuminate\Support\Str;

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

// "Laravel"

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

// This is Laravel!

str()

str 函数返回给定字符串的一个新的 Illuminate\Support\Stringable 实例。此函数等价于 Str::of 方法：

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

// 'Taylor Otwell'

如果不提供任何参数，str 函数将返回一个 Illuminate\Support\Str 的实例：

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

// 'foo_bar'

trans()

trans 函数用于通过【语言文件】翻译给定的翻译键：

echo trans('messages.welcome');

如果指定的翻译键不存在，trans 函数将返回给定的键。因此，以上例子中，若翻译键不存在，trans 函数会返回 messages.welcome。

trans_choice()

trans_choice 函数根据词形变化翻译给定的翻译键：

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

如果指定的翻译键不存在，trans_choice 函数也会返回给定的键。因此，以上例子中，若翻译键不存在，trans_choice 函数会返回 messages.notifications。

流式 Strings

Fluent 字符串提供了一种更流畅、面向对象的方式来处理字符串值，使得你可以通过更具可读性的语法链式调用多个字符串操作，相比传统的字符串操作方式更为简洁和易于理解。

after

after 方法返回字符串中指定值之后的所有内容。如果字符串中不存在该值，则返回整个字符串：

use Illuminate\Support\Str;

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

// ' my name'

afterLast

afterLast 方法返回最后一次出现的指定值之后的所有内容。如果字符串中不存在该值，则返回整个字符串：

use Illuminate\Support\Str;

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

// 'Controller'

apa

apa 方法将给定的字符串转换为标题大小写，遵循【APA 标准】：

use Illuminate\Support\Str;

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

// A Nice Title Uses the Correct Case

append

append 方法将给定的值追加到字符串的末尾：

use Illuminate\Support\Str;

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

// 'Taylor Otwell'

ascii

ascii 方法会尝试将字符串转换为 ASCII 字符：

use Illuminate\Support\Str;

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

// 'u'

basename

basename 方法返回给定字符串的最后一个组件（文件名）：

use Illuminate\Support\Str;

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

// 'baz'

如果需要，可以提供一个 “扩展名”，它将从尾部组件中被移除：

use Illuminate\Support\Str;

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

// 'baz'

before

before 方法返回字符串中指定值之前的所有内容：

use Illuminate\Support\Str;

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

// 'This is '

beforeLast

beforeLast 方法返回字符串中最后一次出现的指定值之前的所有内容：

use Illuminate\Support\Str;

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

// 'This '

between

between 方法返回字符串中两个指定值之间的部分：

use Illuminate\Support\Str;

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

// ' is my '

betweenFirst

betweenFirst 方法返回字符串中第一个出现的两个指定值之间的最小部分：

use Illuminate\Support\Str;

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

// 'a'

camel

camel 方法将给定字符串转换为 camelCase（驼峰式命名法）：

use Illuminate\Support\Str;

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

// 'fooBar'

charAt

charAt 方法返回指定索引位置的字符。如果索引越界，则返回 false：

use Illuminate\Support\Str;

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

// 's'

classBasename

classBasename 方法返回给定类名的类名部分，去除命名空间：

use Illuminate\Support\Str;

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

// 'Baz'

chopStart

chopStart 方法仅当给定值出现在字符串的开始时，移除其第一次出现：

use Illuminate\Support\Str;

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

// 'laravel.com'

你还可以传递一个数组。如果字符串以数组中的任何值开头，那么该值将从字符串中移除：

use Illuminate\Support\Str;

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

// 'laravel.com'

chopEnd

chopEnd 方法仅当给定值出现在字符串的末尾时，移除其最后一次出现：

use Illuminate\Support\Str;

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

// 'https://laravel'

你也可以传递一个数组。如果字符串以数组中的任何值结尾，那么该值将从字符串中移除：

use Illuminate\Support\Str;

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

// 'http://laravel'

contains

contains 方法用于判断给定字符串是否包含指定的值。默认情况下，此方法区分大小写：

use Illuminate\Support\Str;

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

// true

你还可以传递一个值数组，判断字符串是否包含数组中的任意一个值：

use Illuminate\Support\Str;

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

// true

你可以通过设置 ignoreCase 参数为 true 来禁用大小写敏感：

use Illuminate\Support\Str;

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

// true

containsAll

containsAll 方法用于判断给定字符串是否包含数组中的所有值：

use Illuminate\Support\Str;

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

// true

你也可以通过设置 ignoreCase 参数为 true 来禁用大小写敏感：

use Illuminate\Support\Str;

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

// true

deduplicate

deduplicate 方法将字符串中的连续相同字符替换为单个字符，默认情况下会去除多余的空格：

use Illuminate\Support\Str;

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

// The Laravel Framework

你也可以传递一个字符，来指定要去重的字符：

use Illuminate\Support\Str;

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

// The-Laravel-Framework

dirname

dirname 方法返回给定路径的父级目录部分：

use Illuminate\Support\Str;

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

// '/foo/bar'

如果需要，你可以指定希望去除的目录层级数：

use Illuminate\Support\Str;

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

// '/foo'

endsWith

endsWith 方法用于判断给定字符串是否以指定值结尾：

use Illuminate\Support\Str;

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

// true

你可以传递一个值数组，判断字符串是否以数组中的任意一个值结尾：

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

exactly 方法用于判断给定字符串是否与另一个字符串完全匹配：

use Illuminate\Support\Str;

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

// true

excerpt

excerpt 方法从字符串中提取与给定短语匹配的片段：

use Illuminate\Support\Str;

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

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

radius 参数（默认为 100）定义了截断字符串时，每边要显示的字符数。你还可以使用 omission 参数来更改截断字符串两侧的文本：

use Illuminate\Support\Str;

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

// '(...) my name'

explode

explode 方法将字符串按给定的分隔符拆分，并返回一个包含每个部分的集合：

use Illuminate\Support\Str;

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

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

finish

finish 方法将给定值添加到字符串的末尾，前提是字符串本身不以该值结尾：

use Illuminate\Support\Str;

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

// this/string/

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

// this/string/

headline

headline 方法将由大小写字母、连

字符或下划线分隔的字符串转换为一个以空格分隔、首字母大写的字符串：

use Illuminate\Support\Str;

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

// Taylor Otwell

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

// Email Notification Sent

inlineMarkdown

inlineMarkdown 方法将 GitHub 风格的 Markdown 转换为内联 HTML（使用 CommonMark）。然而，与 markdown 方法不同，它不会将生成的 HTML 包装在块级元素中：

use Illuminate\Support\Str;

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

// <strong>Laravel</strong>

Markdown 安全性

默认情况下，Markdown 支持原始 HTML，这可能会暴露跨站脚本（XSS）漏洞。如果您需要允许某些原始 HTML，可以使用 html_input 选项来转义或删除原始 HTML，同时使用 allow_unsafe_links 选项来决定是否允许不安全的链接。如果您需要允许某些原始 HTML，应将编译后的 Markdown 通过 HTML 清理工具处理：

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

is 方法用于判断给定字符串是否与给定模式匹配。可以使用星号（*）作为通配符：

use Illuminate\Support\Str;

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

// true

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

// false

isAscii

isAscii 方法判断给定的字符串是否为 ASCII 字符串：

use Illuminate\Support\Str;

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

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

isEmpty

isEmpty 方法判断给定的字符串是否为空：

use Illuminate\Support\Str;

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

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

isNotEmpty

isNotEmpty 方法判断给定的字符串是否非空：

use Illuminate\Support\Str;

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

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

isJson

isJson 方法判断给定的字符串是否是有效的 JSON 字符串：

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

isUlid 方法判断给定的字符串是否是 ULID：

use Illuminate\Support\Str;

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

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

isUrl

isUrl 方法判断给定的字符串是否是 URL：

use Illuminate\Support\Str;

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

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

isUrl 方法认为多种协议都是有效的。然而，您可以通过向 isUrl 方法提供协议列表，来指定应被视为有效的协议。

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

isUuid

isUuid 方法判断给定的字符串是否是 UUID：

use Illuminate\Support\Str;

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

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

kebab

kebab 方法将给定字符串转换为 kebab-case（用连字符分隔的小写字母）：

use Illuminate\Support\Str;

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

lcfirst

lcfirst 方法将给定字符串的首字母转换为小写：

use Illuminate\Support\Str;

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

length

length 方法返回给定字符串的长度：

use Illuminate\Support\Str;

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

limit

limit 方法将字符串截断到指定长度：

use Illuminate\Support\Str;

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

您还可以传递第二个参数，以更改将附加到截断字符串末尾的字符串。

// 也可以传递第二个参数来修改截断后附加的字符串
$truncated = Str::of('The quick brown fox jumps over the lazy dog')->limit(20, ' (...)'); // The quick brown fox (...)

如果您希望在截断字符串时保留完整的单词，可以使用 preserveWords 参数。当该参数为 true 时，字符串将被截断到最近的完整单词边界。

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

lower

lower 方法将给定字符串转换为小写：

use Illuminate\Support\Str;

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

markdown

markdown 方法将 GitHub 风格的 Markdown 转换为 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 安全性

默认情况下，Markdown 支持原始 HTML，这在与用户输入的原始内容一起使用时会暴露跨站脚本（XSS）漏洞。根据 CommonMark 安全性文档，您可以使用 html_input 选项来转义或剥离原始 HTML，并使用 allow_unsafe_links 选项来指定是否允许不安全的链接。如果您需要允许一些原始 HTML，您应该通过 HTML Purifier 处理您的编译 Markdown：

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

mask 方法用重复字符遮掩字符串的某一部分，常用于隐匿邮箱地址、电话号码等敏感信息：

use Illuminate\Support\Str;

$string = Str::of('taylor@example.com')->mask('*', 3); // tay***************

// 可以传递负数作为第三个或第四个参数，从字符串的末尾开始遮掩
$string = Str::of('taylor@example.com')->mask('*', -15, 3); // tay***@example.com

$string = Str::of('taylor@example.com')->mask('*', 4, -4); // tayl**********.com

match

match 方法返回与给定正则表达式模式匹配的字符串部分：

use Illuminate\Support\Str;

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

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

matchAll

matchAll 方法返回一个集合，包含所有匹配给定正则表达式模式的字符串部分：

use Illuminate\Support\Str;

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

$result = Str::of('bar fun bar fly')->matchAll('/f(\w*)/'); // collect(['un', 'ly'])

isMatch

isMatch 方法会在字符串与给定的正则表达式匹配时返回 true。

use Illuminate\Support\Str;

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

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

newLine

newLine 方法向字符串末尾添加换行符：

use Illuminate\Support\Str;

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

padBoth

padBoth 方法使用 PHP 的 str_pad 函数在字符串的两侧添加填充，直到最终字符串达到指定的长度：

use Illuminate\Support\Str;

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

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

padLeft

padLeft 方法使用 PHP 的 str_pad 函数，在字符串左侧添加填充，直到最终字符串达到指定的长度：

use Illuminate\Support\Str;

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

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

padRight

padRight 方法使用 PHP 的 str_pad 函数，在字符串右侧添加填充，直到最终字符串达到指定的长度：

use Illuminate\Support\Str;

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

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

pipe

pipe 方法允许你通过传递当前字符串的值给给定的可调用函数进行转换：

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

plural 方法将单数词字符串转换为其复数形式。此功能支持 Laravel 的复数化器支持的任何语言：

use Illuminate\Support\Str;

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

// cars

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

// children

你可以提供一个整数作为第二个参数来获取字符串的单数或复数形式：

use Illuminate\Support\Str;

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

// children

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

// child

position

position 方法返回子字符串在字符串中的第一次出现位置。如果子字符串在字符串中不存在，则返回 false：

use Illuminate\Support\Str;

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

// 0

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

// 7

prepend

prepend 方法将给定的值添加到字符串前面：

use Illuminate\Support\Str;

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

// Laravel Framework

remove

remove 方法从字符串中移除给定的值或值数组：

use Illuminate\Support\Str;

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

// Arkansas is beautiful!

你也可以通过传递 false 作为第二个参数来忽略大小写进行移除。

repeat

repeat 方法重复给定的字符串：

use Illuminate\Support\Str;

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

// aaaaa

replace

replace 方法将字符串中的给定值替换为另一个字符串：

use Illuminate\Support\Str;

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

// Laravel 7.x

replace 方法还接受一个 caseSensitive 参数。默认情况下，replace 方法区分大小写：

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

replaceArray

replaceArray 方法使用数组中的值按顺序替换字符串中的给定值：

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

replaceFirst 方法替换字符串中第一次出现的给定值：

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

replaceLast 方法替换字符串中最后一次出现的给定值：

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

replaceMatches 方法用给定的替换字符串替换字符串中与模式匹配的所有部分：

use Illuminate\Support\Str;

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

// '15015551000'

replaceMatches 方法还接受一个闭包，该闭包会对匹配给定模式的每一部分进行调用，允许你在闭包内执行替换逻辑并返回替换后的值：

use Illuminate\Support\Str;

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

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

replaceStart

replaceStart 方法仅当给定值出现在字符串开头时，替换第一次出现的给定值：

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

replaceEnd 方法仅当给定值出现在字符串结尾时，替换最后一次出现的给定值：

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

scan 方法根据 PHP sscanf 函数支持的格式，从字符串中解析输入并返回集合：

use Illuminate\Support\Str;

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

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

singular

singular 方法将字符串转换为其单数形式。此功能支持 Laravel 的复数化器支持的任何语言：

use Illuminate\Support\Str;

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

// car

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

// child

slug

slug 方法从给定的字符串生成一个 URL 友好的 “slug”：

use Illuminate\Support\Str;

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

// laravel-framework

snake

snake 方法将给定的字符串转换为 snake_case：

use Illuminate\Support\Str;

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

// foo_bar

split

split 方法使用正则表达式将字符串分割为集合：

use Illuminate\Support\Str;

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

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

squish

squish 方法移除字符串中的所有多余空格，包括单词间的多余空格：

use Illuminate\Support\Str;

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

// laravel framework

start

start 方法在字符串开头添加给定值（如果字符串还没有以该值开头）：

use Illuminate\Support\Str;

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

// /this/string

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

// /this/string

startsWith

startsWith 方法判断给定字符串是否以给定值开头：

use Illuminate\Support\Str;

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

// true

stripTags

stripTags 方法移除字符串中的所有 HTML 和 PHP 标签：

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

studly 方法将给定的字符串转换为 StudlyCase（首字母大写的驼峰式命名）：

use Illuminate\Support\Str;

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

// FooBar

substr

substr 方法返回由给定的开始位置和长度参数指定的字符串部分：

use Illuminate\Support\Str;

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

// Framework

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

// Frame

substrReplace

substrReplace 方法替换字符串中的一部分文本，从第二个参数指定的位置开始，替换第三个参数指定的字符数。将 0 传递给方法的第三个参数将插入字符串，而不替换任何现有字符：

use Illuminate\Support\Str;

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

// 13:

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

// The Laravel Framework

swap

swap 方法使用 PHP 的 strtr 函数替换字符串中的多个值：

use Illuminate\Support\Str;

$string = Str::of('Tacos are great!')


 ->swap([
        'Tacos' => 'Burritos',
        'great' => 'delicious',
    ]);

// Burritos are fantastic!

take

take 方法从字符串的开头返回指定数量的字符：

use Illuminate\Support\Str;

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

// Build

tap

tap 方法将字符串传递给给定的闭包，允许你检查和与字符串交互，同时不会改变字符串本身。无论闭包返回什么，tap 方法都会返回原始字符串：

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

test 方法判断字符串是否与给定的正则表达式模式匹配：

use Illuminate\Support\Str;

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

// true

title

title 方法将字符串转换为标题形式（每个单词的首字母大写）：

use Illuminate\Support\Str;

$converted = Str::of('the quick brown fox')->title();

// The Quick Brown Fox

toBase64

toBase64 方法将给定的字符串转换为 Base64 编码：

use Illuminate\Support\Str;

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

// TGFyYXZlbA==

toHtmlString

toHtmlString 方法将给定的字符串转换为 Illuminate\Support\HtmlString 实例，这样在 Blade 模板中渲染时不会进行转义：

use Illuminate\Support\Str;

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

transliterate

transliterate 方法会尝试将给定的字符串转换为其最接近的 ASCII 表示：

use Illuminate\Support\Str;

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

// 'test@laravel.com'

trim

trim 方法修剪给定字符串的两端。与 PHP 本地的 trim 函数不同，Laravel 的 trim 方法还会移除 Unicode 空白字符：

use Illuminate\Support\Str;

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

// 'Laravel'

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

// 'Laravel'

ltrim

ltrim 方法修剪字符串的左侧。与 PHP 本地的 ltrim 函数不同，Laravel 的 ltrim 方法也会移除 Unicode 空白字符：

use Illuminate\Support\Str;

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

// 'Laravel  '

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

// 'Laravel/'

rtrim

rtrim 方法修剪给定字符串的右侧。与 PHP 本地的 rtrim 函数不同，Laravel 的 rtrim 方法也会移除 Unicode 空白字符：

use Illuminate\Support\Str;

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

// '  Laravel'

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

// '/Laravel'

ucfirst

ucfirst 方法将给定字符串的首字母大写：

use Illuminate\Support\Str;

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

// Foo bar

ucsplit

ucsplit 方法根据大写字符将给定的字符串拆分为集合：

use Illuminate\Support\Str;

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

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

unwrap

unwrap 方法移除给定字符串的开始和结束部分的指定字符串：

use Illuminate\Support\Str;

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

// Laravel

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

// framework: "Laravel"

upper

upper 方法将给定字符串转换为大写：

use Illuminate\Support\Str;

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

// LARAVEL

when

when 方法会在给定条件为 true 时调用指定的闭包。闭包会接收流式字符串实例：

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

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

// 'Taylor Otwell'

如果需要，您可以向 when 方法传递另一个闭包作为第三个参数。当条件为 false 时，第二个闭包将会被执行。

whenContains

whenContains 方法会在字符串包含指定值时调用闭包。闭包会接收流式字符串实例：

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

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

// 'Tony Stark'

如果需要，您可以向 when 方法传递另一个闭包作为第三个参数。当字符串不包含给定值时，这个闭包将会被执行。

您还可以传递一个值的数组，以确定给定的字符串是否包含数组中的任何一个值。

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

whenContainsAll 方法会在字符串包含所有给定子字符串时调用闭包。闭包会接收流式字符串实例：

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

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

// 'Tony Stark'

如果需要，您还可以向 whenContainsAll 传递另一个闭包，在条件不满足时执行。

whenEmpty

whenEmpty 方法会在字符串为空时调用闭包。如果闭包返回一个值，whenEmpty 方法会返回这个值。如果闭包没有返回值，流式字符串实例会被返回：

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

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

// 'Laravel'

whenNotEmpty

whenNotEmpty 方法会在字符串不为空时调用闭包。如果闭包返回一个值，whenNotEmpty 方法会返回这个值。如果闭包没有返回值，流式字符串实例会被返回：

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

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

// 'Laravel Framework'

whenStartsWith

whenStartsWith 方法会在字符串以给定子字符串开始时调用闭包。闭包会接收流式字符串实例：

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

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

// 'Disney World'

whenEndsWith

whenEndsWith 方法会在字符串以给定子字符串结尾时调用闭包。闭包会接收流式字符串实例：

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

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

// 'Disney World'

whenExactly

whenExactly 方法会在字符串完全匹配给定的字符串时调用闭包。闭包会接收流式字符串实例：

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

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

// 'Laravel'

whenNotExactly

whenNotExactly 方法会在字符串不完全匹配给定字符串时调用闭包。闭包会接收流式字符串实例：

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

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

// 'Framework'

whenIs

whenIs 方法会在字符串匹配给定模式时调用闭包。星号可用作通配符。闭包会接收流式字符串实例：

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

whenIsAscii 方法会在字符串是 7 位 ASCII 时调用闭包。闭包会接收流式字符串实例：

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

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

// 'Laravel'

whenIsUlid

whenIsUlid 方法会在字符串是有效的 ULID 时调用闭包。闭包会接收流式字符串实例：

use Illuminate\Support\Str;

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

// '01gd6r36'

whenIsUuid

whenIsUuid 方法会在字符串是有效的 UUID 时调用闭包。闭包会接收流式字符串实例：

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

whenTest 方法会在字符串匹配给定的正则表达式时调用闭包。闭包会接收流式字符串实例：

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

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

// 'Laravel Framework'

wordCount

wordCount 方法返回字符串中包含的单词数量：

use Illuminate\Support\Str;

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

words

words 方法限制字符串中的单词数量。如有需要，您可以指定一个附加的字符串来附加到截断后的字符串：

use Illuminate\Support\Str;

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

// Perfectly balanced, as >>>

wrap

wrap 方法将给定字符串包裹在一个或一对附加字符串中：

use Illuminate\Support\Str;

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

// "Laravel"

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

// This is Laravel!