字符串

简介

Laravel 包含多种用于操作字符串值的函数。其中许多由框架自身使用；不过，如果你觉得方便，也可以在自己的应用中自由使用。

可用方法

字符串

__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::counted 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

流畅字符串

after afterLast apa append ascii basename before beforeLast between betweenFirst camel charAt classBasename chopStart chopEnd contains containsAll counted 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

字符串

`__()` {.collection-method}

__ 函数使用你的 language files 翻译给定的翻译字符串或翻译键：

php

echo __('Welcome to our application');

echo __('messages.welcome');

如果指定的翻译字符串或键不存在，__ 函数将返回给定值。因此，使用上面的示例，如果该翻译键不存在，__ 函数将返回 messages.welcome。

`class_basename()` {.collection-method}

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

php

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

// Baz

`e()` {.collection-method}

e 函数运行 PHP 的 htmlspecialchars 函数，默认情况下，double_encode 选项设置为 true：

php

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

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

`preg_replace_array()` {.collection-method}

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

php

$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()` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// ' my name'

`Str::afterLast()` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// 'Controller'

`Str::apa()` {.collection-method}

Str::apa 方法将给定字符串转换为APA guidelines之后的标题大小写：

php

use Illuminate\Support\Str;

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

// 'Creating a Project'

`Str::ascii()` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// 'u'

`Str::before()` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// 'This is '

`Str::beforeLast()` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// 'This '

`Str::between()` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// ' is my '

`Str::betweenFirst()` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// 'a'

`Str::camel()` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// 'fooBar'

`Str::charAt()` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// 's'

`Str::chopStart()` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// 'laravel.com'

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

php

use Illuminate\Support\Str;

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

// 'laravel.com'

`Str::chopEnd()` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// 'app/Models/Photograph'

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

php

use Illuminate\Support\Str;

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

// 'laravel.com'

`Str::contains()` {.collection-method}

Str::contains 方法确定给定字符串是否包含给定值。默认情况下，此方法区分大小写：

php

use Illuminate\Support\Str;

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

// true

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

php

use Illuminate\Support\Str;

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

// true

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

php

use Illuminate\Support\Str;

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

// true

`Str::containsAll()` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// true

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

php

use Illuminate\Support\Str;

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

// true

`Str::doesntContain()` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// true

你还可以传递一个值数组来确定给定字符串是否不包含数组中的任何值：

php

use Illuminate\Support\Str;

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

// true

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

php

use Illuminate\Support\Str;

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

// true

`Str::deduplicate()` {.collection-method}

Str::deduplicate 方法将给定字符串中字符的连续实例替换为该字符的单个实例。默认情况下，该方法会删除重复空格：

php

use Illuminate\Support\Str;

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

// The Laravel Framework

你可以通过将其作为第二个参数传递给该方法来指定要消除重复的不同字符：

php

use Illuminate\Support\Str;

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

// The-Laravel-Framework

`Str::doesntEndWith()` {.collection-method}

Str::doesntEndWith 方法确定给定字符串是否不以给定值结尾：

php

use Illuminate\Support\Str;

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

// true

你还可以传递一个值数组来确定给定字符串是否不以数组中的任何值结尾：

php

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()` {.collection-method}

Str::doesntStartWith 方法确定给定字符串是否不以给定值开头：

php

use Illuminate\Support\Str;

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

// true

如果传递可能值的数组，并且字符串不以任何给定值开头，则 doesntStartWith 方法将返回 true：

php

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

// true

`Str::endsWith()` {.collection-method}

Str::endsWith 方法确定给定字符串是否以给定值结尾：

php

use Illuminate\Support\Str;

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

// true

你还可以传递一个值数组来确定给定字符串是否以数组中的任何值结尾：

php

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()` {.collection-method}

Str::excerpt 方法从给定字符串中提取与该字符串中短语的第一个实例匹配的摘录：

php

use Illuminate\Support\Str;

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

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

radius 选项（默认为 100）允许你定义应出现在截断字符串每一侧的字符数。

此外，你可以使用 omission 选项来定义将前置和附加到截断字符串的字符串：

php

use Illuminate\Support\Str;

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

// '(...) my name'

`Str::finish()` {.collection-method}

如果给定值尚未以该值结尾，则 Str::finish 方法将给定值的单个实例添加到字符串中：

php

use Illuminate\Support\Str;

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

// this/string/

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

// this/string/

`Str::fromBase64()` {.collection-method}

Str::fromBase64 方法解码给定的 Base64 字符串：

php

use Illuminate\Support\Str;

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

// Laravel

`Str::headline()` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// Steve Jobs

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

// Email Notification Sent

`Str::initials()` {.collection-method}

Str::initials 方法将返回给定字符串的首字母缩写，可以选择将它们大写：

php

use Illuminate\Support\Str;

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

// to

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

// TO

`Str::inlineMarkdown()` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// <strong>Laravel</strong>

Markdown 安全

默认情况下，Markdown 支持原始 HTML，这在与原始用户输入一起使用时会暴露跨站点脚本 (XSS) 漏洞。根据 CommonMark Security documentation，你可以使用 html_input 选项转义或剥离原始 HTML，并使用 allow_unsafe_links 选项指定是否允许不安全链接。如果你需要允许一些原始 HTML，你应该通过 HTML Purifier 传递编译后的 Markdown：

php

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()` {.collection-method}

Str::is 方法确定给定字符串是否与给定模式匹配。星号可以用作通配符值：

php

use Illuminate\Support\Str;

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

// true

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

// false

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

php

use Illuminate\Support\Str;

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

// true

`Str::isAscii()` {.collection-method}

Str::isAscii 方法确定给定字符串是否为 7 位 ASCII：

php

use Illuminate\Support\Str;

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

// true

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

// false

`Str::isJson()` {.collection-method}

Str::isJson 方法确定给定字符串是否是有效的 JSON：

php

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()` {.collection-method}

Str::isUrl 方法确定给定的字符串是否是有效的 URL：

php

use Illuminate\Support\Str;

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

// true

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

// false

isUrl 方法认为多种协议都是有效的。不过，你可以通过将协议提供给 isUrl 方法来指定应被视为有效的协议：

php

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

`Str::isUlid()` {.collection-method}

Str::isUlid 方法确定给定字符串是否是有效的 ULID：

php

use Illuminate\Support\Str;

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

// true

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

// false

`Str::isUuid()` {.collection-method}

Str::isUuid 方法确定给定字符串是否是有效的 UUID：

php

use Illuminate\Support\Str;

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

// true

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

// false

你还可以验证给定的 UUID 是否与版本（1、3、4、5、6、7 或 8）的 UUID 规范匹配：

php

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()` {.collection-method}

Str::kebab 方法将给定字符串转换为 kebab-case：

php

use Illuminate\Support\Str;

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

// foo-bar

`Str::lcfirst()` {.collection-method}

Str::lcfirst 方法返回给定字符串，其中第一个字符小写：

php

use Illuminate\Support\Str;

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

// foo Bar

`Str::length()` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// 7

`Str::limit()` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// The quick brown fox...

你可以将第三个参数传递给该方法来更改将附加到截断字符串末尾的字符串：

php

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

// The quick brown fox (...)

如果你想在截断字符串时保留完整的单词，你可以使用 preserveWords 参数。当此参数为 true 时，字符串将被截断到最接近的完整单词边界：

php

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

// The quick...

`Str::lower()` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// laravel

`Str::markdown()` {.collection-method}

Str::markdown 方法使用 CommonMark 将 GitHub 风味的 Markdown 转换为 HTML：

php

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 安全

php

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()` {.collection-method}

Str::mask 方法用重复字符屏蔽字符串的一部分，可用于混淆字符串片段，例如电子邮件地址和电话号码：

php

use Illuminate\Support\Str;

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

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

如果需要，你可以提供一个负数作为 mask 方法的第三个参数，这将指示该方法在距字符串末尾的给定距离处开始屏蔽：

php

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

// tay***@example.com

`Str::match()` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// 'bar'

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

// 'bar'

`Str::matchAll()` {.collection-method}

Str::matchAll 方法将返回一个集合，其中包含与给定正则表达式模式匹配的字符串部分：

php

use Illuminate\Support\Str;

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

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

如果你在表达式中指定匹配组，Laravel 将返回第一个匹配组的匹配项的集合：

php

use Illuminate\Support\Str;

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

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

如果没有找到匹配项，将返回一个空集合。

`Str::isMatch()` {.collection-method}

如果字符串与给定的正则表达式匹配，则 Str::isMatch 方法将返回 true：

php

use Illuminate\Support\Str;

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

// true

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

// false

`Str::orderedUuid()` {.collection-method}

Str::orderedUuid 方法生成一个“时间戳优先”的 UUID，可以有效地存储在索引数据库列中。使用此方法生成的每个 UUID 将排序在之前使用该方法生成的 UUID 之后：

php

use Illuminate\Support\Str;

return (string) Str::orderedUuid();

`Str::padBoth()` {.collection-method}

Str::padBoth 方法包装了 PHP 的 str_pad 函数，用另一个字符串填充字符串的两侧，直到最终字符串达到所需的长度：

php

use Illuminate\Support\Str;

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

// '__James___'

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

// '  James   '

`Str::padLeft()` {.collection-method}

Str::padLeft 方法包装了 PHP 的 str_pad 函数，用另一个字符串填充字符串的左侧，直到最终字符串达到所需的长度：

php

use Illuminate\Support\Str;

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

// '-=-=-James'

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

// '     James'

`Str::padRight()` {.collection-method}

Str::padRight 方法包装了 PHP 的 str_pad 函数，用另一个字符串填充字符串的右侧，直到最终字符串达到所需的长度：

php

use Illuminate\Support\Str;

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

// 'James-----'

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

// 'James     '

`Str::password()` {.collection-method}

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

php

use Illuminate\Support\Str;

$password = Str::password();

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

$password = Str::password(12);

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

`Str::counted()` {.collection-method}

Str::counted 方法根据给定的计数将单数单词字符串转换为其单数或复数形式，并在结果前面加上格式化的计数：

php

use Illuminate\Support\Str;

$label = Str::counted('order', 1);

// 1 order

$label = Str::counted('order', 1000);

// 1,000 orders

`Str::plural()` {.collection-method}

Str::plural 方法将单数字符串转换为其复数形式。该函数支持any of the languages supported by Laravel's pluralizer：

php

use Illuminate\Support\Str;

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

// cars

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

// children

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

php

use Illuminate\Support\Str;

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

// children

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

// child

可以提供 prependCount 参数，以使用格式化的 $count 作为复数字符串的前缀：

php

use Illuminate\Support\Str;

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

// 1,000 cars

`Str::pluralStudly()` {.collection-method}

Str::pluralStudly 方法将采用大写字母格式的单数字符串转换为其复数形式。该函数支持any of the languages supported by Laravel's pluralizer：

php

use Illuminate\Support\Str;

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

// VerifiedHumans

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

// UserFeedback

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

php

use Illuminate\Support\Str;

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

// VerifiedHumans

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

// VerifiedHuman

`Str::position()` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// 0

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

// 7

`Str::random()` {.collection-method}

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

php

use Illuminate\Support\Str;

$random = Str::random(40);

在测试过程中，“伪造” Str::random 方法返回的值可能很有用。为此，你可以使用 createRandomStringsUsing 方法：

php

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

要指示 random 方法返回正常生成随机字符串，你可以调用 createRandomStringsNormally 方法：

php

Str::createRandomStringsNormally();

`Str::remove()` {.collection-method}

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

php

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()` {.collection-method}

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

php

use Illuminate\Support\Str;

$string = 'a';

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

// aaaaa

`Str::replace()` {.collection-method}

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

php

use Illuminate\Support\Str;

$string = 'Laravel 11.x';

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

// Laravel 12.x

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

php

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

// Laravel Framework for Web Artisans

`Str::replaceArray()` {.collection-method}

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

php

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()` {.collection-method}

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

php

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()` {.collection-method}

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

php

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()` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// '15015551000'

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

php

use Illuminate\Support\Str;

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

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

`Str::replaceStart()` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// Laravel World

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

// Hello World

`Str::replaceEnd()` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// Hello Laravel

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

// Hello World

`Str::reverse()` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// dlroW olleH

`Str::singular()` {.collection-method}

Str::singular 方法将字符串转换为其单数形式。该函数支持any of the languages supported by Laravel's pluralizer：

php

use Illuminate\Support\Str;

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

// car

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

// child

`Str::slug()` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// laravel-5-framework

`Str::snake()` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// foo_bar

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

// foo-bar

`Str::squish()` {.collection-method}

Str::squish 方法从字符串中删除所有无关的空格，包括单词之间的无关空格：

php

use Illuminate\Support\Str;

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

// laravel framework

`Str::start()` {.collection-method}

如果给定值尚未以该值开头，则 Str::start 方法会将给定值的单个实例添加到字符串中：

php

use Illuminate\Support\Str;

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

// /this/string

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

// /this/string

`Str::startsWith()` {.collection-method}

Str::startsWith 方法确定给定字符串是否以给定值开头：

php

use Illuminate\Support\Str;

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

// true

如果传递可能值的数组，并且字符串以任何给定值开头，则 startsWith 方法将返回 true：

php

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

// true

`Str::studly()` {.collection-method}

Str::studly 方法将给定字符串转换为 StudlyCase：

php

use Illuminate\Support\Str;

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

// FooBar

`Str::substr()` {.collection-method}

Str::substr 方法返回由 start 和 length 参数指定的字符串部分：

php

use Illuminate\Support\Str;

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

// Laravel

`Str::substrCount()` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// 2

`Str::substrReplace()` {.collection-method}

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

php

use Illuminate\Support\Str;

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

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

`Str::swap()` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// Burritos are fantastic!

`Str::take()` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// Build

`Str::title()` {.collection-method}

Str::title 方法将给定字符串转换为 Title Case：

php

use Illuminate\Support\Str;

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

// A Nice Title Uses The Correct Case

`Str::toBase64()` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// TGFyYXZlbA==

`Str::transliterate()` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// 'test@laravel.com'

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

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

php

use Illuminate\Support\Str;

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

// 'foo bar'

`Str::ltrim()` {.collection-method}

Str::ltrim 方法从给定字符串的开头去除空格（或其他字符）。与 PHP 原生 ltrim 函数不同，Str::ltrim 方法还会删除 unicode 空白字符：

php

use Illuminate\Support\Str;

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

// 'foo bar  '

`Str::rtrim()` {.collection-method}

Str::rtrim 方法从给定字符串的末尾去除空格（或其他字符）。与 PHP 原生 rtrim 函数不同，Str::rtrim 方法还会删除 unicode 空白字符：

php

use Illuminate\Support\Str;

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

// '  foo bar'

`Str::ucfirst()` {.collection-method}

Str::ucfirst 方法返回给定字符串，其中第一个字符大写：

php

use Illuminate\Support\Str;

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

// Foo bar

`Str::ucsplit()` {.collection-method}

Str::ucsplit 方法将给定字符串按大写字符拆分为数组：

php

use Illuminate\Support\Str;

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

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

`Str::ucwords()` {.collection-method}

Str::ucwords 方法将给定字符串中每个单词的第一个字符转换为大写：

php

use Illuminate\Support\Str;

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

// Laravel Framework

`Str::upper()` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// LARAVEL

`Str::ulid()` {.collection-method}

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

php

use Illuminate\Support\Str;

return (string) Str::ulid();

// 01gd6r360bp37zj17nxb55yv40

如果你想检索表示给定 ULID 创建的日期和时间的 Illuminate\Support\Carbon 日期实例，你可以使用 Laravel 的 Carbon 集成提供的 createFromId 方法：

php

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

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

在测试过程中，“伪造” Str::ulid 方法返回的值可能很有用。为此，你可以使用 createUlidsUsing 方法：

php

use Symfony\Component\Uid\Ulid;

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

要指示 ulid 方法返回正常生成 ULID，你可以调用 createUlidsNormally 方法：

php

Str::createUlidsNormally();

`Str::unwrap()` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// Laravel

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

// framework: "Laravel"

`Str::uuid()` {.collection-method}

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

php

use Illuminate\Support\Str;

return (string) Str::uuid();

在测试过程中，“伪造” Str::uuid 方法返回的值可能很有用。为此，你可以使用 createUuidsUsing 方法：

php

use Ramsey\Uuid\Uuid;

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

要指示 uuid 方法返回正常生成 UUID，你可以调用 createUuidsNormally 方法：

php

Str::createUuidsNormally();

`Str::uuid7()` {.collection-method}

Str::uuid7 方法生成一个UUID（版本7）：

php

use Illuminate\Support\Str;

return (string) Str::uuid7();

DateTimeInterface 可以作为可选参数传递，该参数将用于生成有序的 UUID：

php

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

`Str::wordCount()` {.collection-method}

Str::wordCount 方法返回字符串包含的单词数：

php

use Illuminate\Support\Str;

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

`Str::wordWrap()` {.collection-method}

Str::wordWrap 方法将字符串包装为给定数量的字符：

php

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()` {.collection-method}

Str::words 方法限制字符串中的单词数。可以通过其第三个参数将附加字符串传递给此方法，以指定应将哪个字符串附加到截断字符串的末尾：

php

use Illuminate\Support\Str;

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

// Perfectly balanced, as >>>

`Str::wrap()` {.collection-method}

Str::wrap 方法用一个附加字符串或一对字符串包装给定的字符串：

php

use Illuminate\Support\Str;

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

// "Laravel"

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

// This is Laravel!

`str()` {.collection-method}

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

php

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

// 'Taylor Otwell'

如果没有向 str 函数提供参数，则该函数返回 Illuminate\Support\Str 的实例：

php

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

// 'foo_bar'

`trans()` {.collection-method}

trans 函数使用你的 language files 翻译给定的翻译键：

php

echo trans('messages.welcome');

如果指定的翻译键不存在，trans 函数将返回给定的键。因此，使用上面的示例，如果翻译键不存在，trans 函数将返回 messages.welcome。

`trans_choice()` {.collection-method}

trans_choice 函数通过变形来翻译给定的翻译键：

php

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

如果指定的翻译键不存在，trans_choice 函数将返回给定的键。因此，使用上面的示例，如果翻译键不存在，trans_choice 函数将返回 messages.notifications。

流畅字符串

Fluent 字符串提供了更流畅、面向对象的接口来处理字符串值，允许你使用比传统字符串操作更可读的语法将多个字符串操作链接在一起。

`after` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// ' my name'

`afterLast` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// 'Controller'

`apa` {.collection-method}

apa 方法将给定字符串转换为APA guidelines之后的标题大小写：

php

use Illuminate\Support\Str;

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

// A Nice Title Uses the Correct Case

`append` {.collection-method}

append 方法将给定值附加到字符串中：

php

use Illuminate\Support\Str;

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

// 'Taylor Otwell'

`ascii` {.collection-method}

ascii 方法将尝试将字符串转写为 ASCII 值：

php

use Illuminate\Support\Str;

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

// 'u'

`basename` {.collection-method}

basename 方法将返回给定字符串的尾随名称部分：

php

use Illuminate\Support\Str;

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

// 'baz'

如果需要，你可以提供一个将从尾随组件中删除的“扩展”：

php

use Illuminate\Support\Str;

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

// 'baz'

`before` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// 'This is '

`beforeLast` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// 'This '

`between` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// ' is my '

`betweenFirst` {.collection-method}

betweenFirst 方法返回两个值之间字符串的最小可能部分：

php

use Illuminate\Support\Str;

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

// 'a'

`camel` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// 'fooBar'

`charAt` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// 's'

`classBasename` {.collection-method}

classBasename 方法返回给定类的类名，并删除该类的命名空间：

php

use Illuminate\Support\Str;

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

// 'Baz'

`chopStart` {.collection-method}

仅当给定值出现在字符串开头时，chopStart 方法才会删除该值的第一次出现：

php

use Illuminate\Support\Str;

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

// 'laravel.com'

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

php

use Illuminate\Support\Str;

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

// 'laravel.com'

`chopEnd` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// 'https://laravel'

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

php

use Illuminate\Support\Str;

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

// 'http://laravel'

`contains` {.collection-method}

contains 方法确定给定字符串是否包含给定值。默认情况下，此方法区分大小写：

php

use Illuminate\Support\Str;

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

// true

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

php

use Illuminate\Support\Str;

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

// true

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

php

use Illuminate\Support\Str;

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

// true

`containsAll` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// true

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

php

use Illuminate\Support\Str;

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

// true

`decrypt` {.collection-method}

decrypt 方法decrypts加密字符串：

php

use Illuminate\Support\Str;

$decrypted = $encrypted->decrypt();

// 'secret'

对于 decrypt 的逆，参见encrypt方法。

`deduplicate` {.collection-method}

deduplicate 方法将给定字符串中字符的连续实例替换为该字符的单个实例。默认情况下，该方法会删除重复空格：

php

use Illuminate\Support\Str;

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

// The Laravel Framework

你可以通过将其作为第二个参数传递给该方法来指定要消除重复的不同字符：

php

use Illuminate\Support\Str;

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

// The-Laravel-Framework

`dirname` {.collection-method}

dirname 方法返回给定字符串的父目录部分：

php

use Illuminate\Support\Str;

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

// '/foo/bar'

如有必要，你可以指定要从字符串中删除的目录级别：

php

use Illuminate\Support\Str;

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

// '/foo'

`doesntContain()` {.collection-method}

doesntContain 方法确定给定字符串是否不包含给定值。该方法是contains方法的逆方法。默认情况下，此方法区分大小写：

php

use Illuminate\Support\Str;

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

// true

你还可以传递一个值数组来确定给定字符串是否不包含数组中的任何值：

php

use Illuminate\Support\Str;

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

// true

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

php

use Illuminate\Support\Str;

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

// false

`doesntEndWith` {.collection-method}

doesntEndWith 方法确定给定字符串是否不以给定值结尾：

php

use Illuminate\Support\Str;

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

// true

你还可以传递一个值数组来确定给定字符串是否不以数组中的任何值结尾：

php

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` {.collection-method}

doesntStartWith 方法确定给定字符串是否不以给定值开头：

php

use Illuminate\Support\Str;

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

// true

你还可以传递一个值数组来确定给定字符串是否不以数组中的任何值开头：

php

use Illuminate\Support\Str;

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

// true

`encrypt` {.collection-method}

encrypt 方法encrypts字符串：

php

use Illuminate\Support\Str;

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

对于 encrypt 的逆，参见decrypt方法。

`endsWith` {.collection-method}

endsWith 方法确定给定字符串是否以给定值结尾：

php

use Illuminate\Support\Str;

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

// true

你还可以传递一个值数组来确定给定字符串是否以数组中的任何值结尾：

php

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` {.collection-method}

exactly 方法确定给定字符串是否与另一个字符串完全匹配：

php

use Illuminate\Support\Str;

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

// true

`excerpt` {.collection-method}

excerpt 方法从字符串中提取与该字符串中短语的第一个实例匹配的摘录：

php

use Illuminate\Support\Str;

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

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

radius 选项（默认为 100）允许你定义应出现在截断字符串每一侧的字符数。

此外，你可以使用 omission 选项来更改将前置和附加到截断字符串的字符串：

php

use Illuminate\Support\Str;

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

// '(...) my name'

`explode` {.collection-method}

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

php

use Illuminate\Support\Str;

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

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

`finish` {.collection-method}

如果给定值尚未以该值结尾，则 finish 方法将给定值的单个实例添加到字符串中：

php

use Illuminate\Support\Str;

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

// this/string/

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

// this/string/

`fromBase64` {.collection-method}

fromBase64 方法解码给定的 Base64 字符串：

php

use Illuminate\Support\Str;

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

// Laravel

`hash` {.collection-method}

hash 方法使用给定的 algorithm 对字符串进行哈希处理：

php

use Illuminate\Support\Str;

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

// '2bb80d537b1da3e38bd30361aa855686bde0eacd7162fef6a25fe97bf527a25b'

`headline` {.collection-method}

headline 方法会将由大小写、连字符或下划线分隔的字符串转换为空格分隔的字符串，每个单词的第一个字母大写：

php

use Illuminate\Support\Str;

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

// Taylor Otwell

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

// Email Notification Sent

`initials` {.collection-method}

initials 方法会将字符串转换为其首字母：

php

use Illuminate\Support\Str;

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

// TO

`inlineMarkdown` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// <strong>Laravel</strong>

Markdown 安全

php

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` {.collection-method}

is 方法确定给定字符串是否与给定模式匹配。星号可以用作通配符值

php

use Illuminate\Support\Str;

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

// true

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

// false

`isAscii` {.collection-method}

isAscii 方法确定给定字符串是否为 ASCII 字符串：

php

use Illuminate\Support\Str;

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

// true

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

// false

`isEmpty` {.collection-method}

isEmpty 方法确定给定字符串是否为空：

php

use Illuminate\Support\Str;

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

// true

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

// false

`isNotEmpty` {.collection-method}

isNotEmpty 方法确定给定字符串是否不为空：

php

use Illuminate\Support\Str;

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

// false

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

// true

`isJson` {.collection-method}

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

php

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` {.collection-method}

isUlid 方法确定给定字符串是否为 ULID：

php

use Illuminate\Support\Str;

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

// true

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

// false

`isUrl` {.collection-method}

isUrl 方法确定给定字符串是否为 URL：

php

use Illuminate\Support\Str;

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

// true

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

// false

isUrl 方法认为多种协议都是有效的。不过，你可以通过将协议提供给 isUrl 方法来指定应被视为有效的协议：

php

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

`isUuid` {.collection-method}

isUuid 方法确定给定字符串是否为 UUID：

php

use Illuminate\Support\Str;

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

// true

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

// false

你还可以验证给定的 UUID 是否与版本（1、3、4、5、6、7 或 8）的 UUID 规范匹配：

php

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` {.collection-method}

kebab 方法将给定字符串转换为 kebab-case：

php

use Illuminate\Support\Str;

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

// foo-bar

`lcfirst` {.collection-method}

lcfirst 方法返回给定字符串，其中第一个字符小写：

php

use Illuminate\Support\Str;

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

// foo Bar

`length` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// 7

`limit` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// The quick brown fox...

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

php

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

// The quick brown fox (...)

如果你想在截断字符串时保留完整的单词，你可以使用 preserveWords 参数。当此参数为 true 时，字符串将被截断到最接近的完整单词边界：

php

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

// The quick...

`lower` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// 'laravel'

`markdown` {.collection-method}

markdown 方法将 GitHub 风味的 Markdown 转换为 HTML：

php

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 安全

php

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` {.collection-method}

mask 方法用重复字符屏蔽字符串的一部分，可用于混淆字符串片段，例如电子邮件地址和电话号码：

php

use Illuminate\Support\Str;

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

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

如果需要，你可以提供负数作为 mask 方法的第三个或第四个参数，这将指示该方法在距字符串末尾的给定距离处开始屏蔽：

php

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

// tay***@example.com

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

// tayl**********.com

`match` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// 'bar'

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

// 'bar'

`matchAll` {.collection-method}

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

php

use Illuminate\Support\Str;

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

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

如果你在表达式中指定匹配组，Laravel 将返回第一个匹配组的匹配项的集合：

php

use Illuminate\Support\Str;

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

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

如果没有找到匹配项，将返回一个空集合。

`isMatch` {.collection-method}

如果字符串与给定的正则表达式匹配，则 isMatch 方法将返回 true：

php

use Illuminate\Support\Str;

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

// true

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

// false

`newLine` {.collection-method}

newLine 方法将“行尾”字符附加到字符串：

php

use Illuminate\Support\Str;

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

// 'Laravel
//  Framework'

`padBoth` {.collection-method}

padBoth 方法包装了 PHP 的 str_pad 函数，用另一个字符串填充字符串的两侧，直到最终字符串达到所需的长度：

php

use Illuminate\Support\Str;

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

// '__James___'

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

// '  James   '

`padLeft` {.collection-method}

padLeft 方法包装了 PHP 的 str_pad 函数，用另一个字符串填充字符串的左侧，直到最终字符串达到所需的长度：

php

use Illuminate\Support\Str;

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

// '-=-=-James'

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

// '     James'

`padRight` {.collection-method}

padRight 方法包装了 PHP 的 str_pad 函数，用另一个字符串填充字符串的右侧，直到最终字符串达到所需的长度：

php

use Illuminate\Support\Str;

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

// 'James-----'

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

// 'James     '

`pipe` {.collection-method}

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

php

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'

`counted` {.collection-method}

counted 方法根据给定的计数将单数单词字符串转换为其单数或复数形式，并在结果前面加上格式化的计数：

php

use Illuminate\Support\Str;

$label = Str::of('order')->counted(1);

// 1 order

$label = Str::of('order')->counted(1000);

// 1,000 orders

`plural` {.collection-method}

plural 方法将单数字符串转换为其复数形式。该函数支持any of the languages supported by Laravel's pluralizer：

php

use Illuminate\Support\Str;

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

// cars

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

// children

你可以向函数提供一个整数参数来检索字符串的单数或复数形式：

php

use Illuminate\Support\Str;

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

// children

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

// child

你可以提供 prependCount 参数，以使用格式化的 $count 作为复数字符串的前缀：

php

use Illuminate\Support\Str;

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

// 1,000 cars

`position` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// 0

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

// 7

`prepend` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// Laravel Framework

`remove` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// Arkansas is beautiful!

你还可以传递 false 作为第二个参数，以在删除字符串时忽略大小写。

`repeat` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// aaaaa

`replace` {.collection-method}

replace 方法替换字符串中的给定字符串：

php

use Illuminate\Support\Str;

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

// Laravel 7.x

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

php

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

`replaceArray` {.collection-method}

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

php

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` {.collection-method}

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

php

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` {.collection-method}

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

php

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` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// '15015551000'

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

php

use Illuminate\Support\Str;

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

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

`replaceStart` {.collection-method}

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

php

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` {.collection-method}

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

php

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` {.collection-method}

scan 方法根据 ⟦1⟧ PHP function 支持的格式将字符串输入解析为集合：

php

use Illuminate\Support\Str;

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

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

`singular` {.collection-method}

singular 方法将字符串转换为其单数形式。该函数支持any of the languages supported by Laravel's pluralizer：

php

use Illuminate\Support\Str;

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

// car

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

// child

`slug` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// laravel-framework

`snake` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// foo_bar

`split` {.collection-method}

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

php

use Illuminate\Support\Str;

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

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

`squish` {.collection-method}

squish 方法从字符串中删除所有无关的空格，包括单词之间的无关空格：

php

use Illuminate\Support\Str;

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

// laravel framework

`start` {.collection-method}

如果给定值尚未以该值开头，则 start 方法会将给定值的单个实例添加到字符串中：

php

use Illuminate\Support\Str;

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

// /this/string

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

// /this/string

`startsWith` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// true

你还可以传递一个值数组来确定给定字符串是否以数组中的任何值开头：

php

use Illuminate\Support\Str;

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

// true

`stripTags` {.collection-method}

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

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` {.collection-method}

studly 方法将给定字符串转换为 StudlyCase：

php

use Illuminate\Support\Str;

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

// FooBar

`substr` {.collection-method}

substr 方法返回由给定 start 和 length 参数指定的字符串部分：

php

use Illuminate\Support\Str;

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

// Framework

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

// Frame

`substrReplace` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// 13:

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

// The Laravel Framework

`swap` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// Burritos are fantastic!

`take` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// Build

`tap` {.collection-method}

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

php

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` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// true

`title` {.collection-method}

title 方法将给定字符串转换为 Title Case：

php

use Illuminate\Support\Str;

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

// A Nice Title Uses The Correct Case

`toBase64` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// TGFyYXZlbA==

`toHtmlString` {.collection-method}

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

php

use Illuminate\Support\Str;

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

`toUri` {.collection-method}

toUri 方法将给定字符串转换为 Illuminate\Support\Uri 的实例：

php

use Illuminate\Support\Str;

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

`transliterate` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// 'test@laravel.com'

`trim` {.collection-method}

trim 方法修剪给定的字符串。与 PHP 原生的 trim 函数不同，Laravel 的 trim 方法也会删除 unicode 空白字符：

php

use Illuminate\Support\Str;

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

// 'Laravel'

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

// 'Laravel'

`ltrim` {.collection-method}

ltrim 方法修剪字符串的左侧。与 PHP 原生的 ltrim 函数不同，Laravel 的 ltrim 方法也会删除 unicode 空白字符：

php

use Illuminate\Support\Str;

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

// 'Laravel  '

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

// 'Laravel/'

`rtrim` {.collection-method}

rtrim 方法修剪给定字符串的右侧。与 PHP 原生的 rtrim 函数不同，Laravel 的 rtrim 方法也会删除 unicode 空白字符：

php

use Illuminate\Support\Str;

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

// '  Laravel'

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

// '/Laravel'

`ucfirst` {.collection-method}

ucfirst 方法返回给定字符串，其中第一个字符大写：

php

use Illuminate\Support\Str;

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

// Foo bar

`ucsplit` {.collection-method}

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

php

use Illuminate\Support\Str;

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

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

`ucwords` {.collection-method}

ucwords 方法将给定字符串中每个单词的第一个字符转换为大写：

php

use Illuminate\Support\Str;

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

// Laravel Framework

`unwrap` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// Laravel

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

// framework: "Laravel"

`upper` {.collection-method}

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

php

use Illuminate\Support\Str;

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

// LARAVEL

`when` {.collection-method}

如果给定条件为 true，则 when 方法将调用给定闭包。闭包将接收流利的字符串实例：

php

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` {.collection-method}

如果字符串包含给定值，则 whenContains 方法将调用给定闭包。闭包将接收流利的字符串实例：

php

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

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

// 'Tony Stark'

如有必要，你可以传递另一个闭包作为第三个参数。如果字符串不包含给定值，则将调用闭包。

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

php

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` {.collection-method}

如果字符串包含所有给定的子字符串，则 whenContainsAll 方法将调用给定的闭包。闭包将接收流利的字符串实例：

php

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

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

// 'Tony Stark'

如有必要，你可以传递另一个闭包作为第三个参数。如果条件参数的计算结果为 false，则将调用闭包。

`whenDoesntEndWith` {.collection-method}

如果字符串不以给定的子字符串结尾，则 whenDoesntEndWith 方法将调用给定的闭包。闭包将接收流利的字符串实例：

php

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

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

// 'Disney World'

`whenDoesntStartWith` {.collection-method}

如果字符串不以给定的子字符串开头，则 whenDoesntStartWith 方法将调用给定的闭包。闭包将接收流利的字符串实例：

php

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

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

// 'Disney World'

`whenEmpty` {.collection-method}

如果字符串为空，则 whenEmpty 方法将调用给定的闭包。如果闭包返回一个值，则该值也将由 whenEmpty 方法返回。如果闭包不返回值，则将返回连贯的字符串实例：

php

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

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

// 'Laravel'

`whenNotEmpty` {.collection-method}

如果字符串不为空，则 whenNotEmpty 方法将调用给定的闭包。如果闭包返回一个值，则该值也将由 whenNotEmpty 方法返回。如果闭包不返回值，则将返回连贯的字符串实例：

php

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

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

// 'Laravel Framework'

`whenStartsWith` {.collection-method}

如果字符串以给定的子字符串开头，则 whenStartsWith 方法将调用给定的闭包。闭包将接收流利的字符串实例：

php

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

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

// 'Disney World'

`whenEndsWith` {.collection-method}

如果字符串以给定的子字符串结尾，则 whenEndsWith 方法将调用给定的闭包。闭包将接收流利的字符串实例：

php

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

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

// 'Disney World'

`whenExactly` {.collection-method}

如果字符串与给定字符串完全匹配，则 whenExactly 方法将调用给定闭包。闭包将接收流利的字符串实例：

php

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

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

// 'Laravel'

`whenNotExactly` {.collection-method}

如果字符串与给定字符串不完全匹配，则 whenNotExactly 方法将调用给定闭包。闭包将接收流利的字符串实例：

php

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

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

// 'Framework'

`whenIs` {.collection-method}

如果字符串与给定模式匹配，则 whenIs 方法将调用给定闭包。星号可以用作通配符值。闭包将接收流利的字符串实例：

php

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` {.collection-method}

如果字符串是 7 位 ASCII，则 whenIsAscii 方法将调用给定的闭包。闭包将接收流利的字符串实例：

php

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

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

// 'Laravel'

`whenIsUlid` {.collection-method}

如果字符串是有效的 ULID，则 whenIsUlid 方法将调用给定的闭包。闭包将接收流利的字符串实例：

php

use Illuminate\Support\Str;

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

// '01gd6r36'

`whenIsUuid` {.collection-method}

如果字符串是有效的 UUID，则 whenIsUuid 方法将调用给定的闭包。闭包将接收流利的字符串实例：

php

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` {.collection-method}

如果字符串与给定的正则表达式匹配，则 whenTest 方法将调用给定的闭包。闭包将接收流利的字符串实例：

php

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

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

// 'Laravel Framework'

`wordCount` {.collection-method}

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

php

use Illuminate\Support\Str;

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

`words` {.collection-method}

words 方法限制字符串中的单词数。如有必要，你可以指定一个附加字符串，该字符串将附加到截断的字符串中：

php

use Illuminate\Support\Str;

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

// Perfectly balanced, as >>>

`wrap` {.collection-method}

wrap 方法用一个附加字符串或一对字符串包装给定的字符串：

php

use Illuminate\Support\Str;

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

// "Laravel"

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

// This is Laravel!

字符串 ​

简介 ​

可用方法 ​

字符串 ​

流畅字符串 ​

字符串 ​

__() {.collection-method} ​

class_basename() {.collection-method} ​

e() {.collection-method} ​

preg_replace_array() {.collection-method} ​

Str::after() {.collection-method} ​

Str::afterLast() {.collection-method} ​

Str::apa() {.collection-method} ​

Str::ascii() {.collection-method} ​

Str::before() {.collection-method} ​

Str::beforeLast() {.collection-method} ​

Str::between() {.collection-method} ​

Str::betweenFirst() {.collection-method} ​

Str::camel() {.collection-method} ​

Str::charAt() {.collection-method} ​

Str::chopStart() {.collection-method} ​

Str::chopEnd() {.collection-method} ​

Str::contains() {.collection-method} ​

Str::containsAll() {.collection-method} ​

Str::doesntContain() {.collection-method} ​

Str::deduplicate() {.collection-method} ​

Str::doesntEndWith() {.collection-method} ​

Str::doesntStartWith() {.collection-method} ​

Str::endsWith() {.collection-method} ​

Str::excerpt() {.collection-method} ​

Str::finish() {.collection-method} ​

Str::fromBase64() {.collection-method} ​

Str::headline() {.collection-method} ​

Str::initials() {.collection-method} ​

Str::inlineMarkdown() {.collection-method} ​

Markdown 安全 ​

Str::is() {.collection-method} ​

Str::isAscii() {.collection-method} ​

Str::isJson() {.collection-method} ​

Str::isUrl() {.collection-method} ​

Str::isUlid() {.collection-method} ​

Str::isUuid() {.collection-method} ​

Str::kebab() {.collection-method} ​

Str::lcfirst() {.collection-method} ​

Str::length() {.collection-method} ​

Str::limit() {.collection-method} ​

Str::lower() {.collection-method} ​

Str::markdown() {.collection-method} ​

Markdown 安全 ​

Str::mask() {.collection-method} ​

Str::match() {.collection-method} ​

Str::matchAll() {.collection-method} ​

Str::isMatch() {.collection-method} ​

Str::orderedUuid() {.collection-method} ​

Str::padBoth() {.collection-method} ​

Str::padLeft() {.collection-method} ​

Str::padRight() {.collection-method} ​

Str::password() {.collection-method} ​

Str::counted() {.collection-method} ​

Str::plural() {.collection-method} ​

Str::pluralStudly() {.collection-method} ​

Str::position() {.collection-method} ​

Str::random() {.collection-method} ​

Str::remove() {.collection-method} ​

Str::repeat() {.collection-method} ​

Str::replace() {.collection-method} ​

Str::replaceArray() {.collection-method} ​

Str::replaceFirst() {.collection-method} ​

Str::replaceLast() {.collection-method} ​

Str::replaceMatches() {.collection-method} ​

Str::replaceStart() {.collection-method} ​

Str::replaceEnd() {.collection-method} ​

Str::reverse() {.collection-method} ​

Str::singular() {.collection-method} ​

Str::slug() {.collection-method} ​

Str::snake() {.collection-method} ​

Str::squish() {.collection-method} ​

Str::start() {.collection-method} ​

Str::startsWith() {.collection-method} ​

Str::studly() {.collection-method} ​

字符串

简介

可用方法

字符串

流畅字符串

字符串

`__()` {.collection-method}

`class_basename()` {.collection-method}

`e()` {.collection-method}

`preg_replace_array()` {.collection-method}

`Str::after()` {.collection-method}

`Str::afterLast()` {.collection-method}

`Str::apa()` {.collection-method}

`Str::ascii()` {.collection-method}

`Str::before()` {.collection-method}

`Str::beforeLast()` {.collection-method}

`Str::between()` {.collection-method}

`Str::betweenFirst()` {.collection-method}

`Str::camel()` {.collection-method}

`Str::charAt()` {.collection-method}

`Str::chopStart()` {.collection-method}

`Str::chopEnd()` {.collection-method}

`Str::contains()` {.collection-method}

`Str::containsAll()` {.collection-method}

`Str::doesntContain()` {.collection-method}

`Str::deduplicate()` {.collection-method}

`Str::doesntEndWith()` {.collection-method}

`Str::doesntStartWith()` {.collection-method}

`Str::endsWith()` {.collection-method}

`Str::excerpt()` {.collection-method}

`Str::finish()` {.collection-method}

`Str::fromBase64()` {.collection-method}

`Str::headline()` {.collection-method}

`Str::initials()` {.collection-method}

`Str::inlineMarkdown()` {.collection-method}

Markdown 安全

`Str::is()` {.collection-method}

`Str::isAscii()` {.collection-method}

`Str::isJson()` {.collection-method}

`Str::isUrl()` {.collection-method}

`Str::isUlid()` {.collection-method}

`Str::isUuid()` {.collection-method}

`Str::kebab()` {.collection-method}

`Str::lcfirst()` {.collection-method}

`Str::length()` {.collection-method}

`Str::limit()` {.collection-method}

`Str::lower()` {.collection-method}

`Str::markdown()` {.collection-method}

Markdown 安全

`Str::mask()` {.collection-method}

`Str::match()` {.collection-method}

`Str::matchAll()` {.collection-method}

`Str::isMatch()` {.collection-method}

`Str::orderedUuid()` {.collection-method}

`Str::padBoth()` {.collection-method}

`Str::padLeft()` {.collection-method}

`Str::padRight()` {.collection-method}

`Str::password()` {.collection-method}

`Str::counted()` {.collection-method}

`Str::plural()` {.collection-method}

`Str::pluralStudly()` {.collection-method}

`Str::position()` {.collection-method}

`Str::random()` {.collection-method}

`Str::remove()` {.collection-method}

`Str::repeat()` {.collection-method}

`Str::replace()` {.collection-method}

`Str::replaceArray()` {.collection-method}

`Str::replaceFirst()` {.collection-method}

`Str::replaceLast()` {.collection-method}

`Str::replaceMatches()` {.collection-method}

`Str::replaceStart()` {.collection-method}

`Str::replaceEnd()` {.collection-method}

`Str::reverse()` {.collection-method}

`Str::singular()` {.collection-method}

`Str::slug()` {.collection-method}

`Str::snake()` {.collection-method}

`Str::squish()` {.collection-method}

`Str::start()` {.collection-method}

`Str::startsWith()` {.collection-method}

`Str::studly()` {.collection-method}