字符串操作

13.x

13.x 12.x 11.x 10.x 9.x 8.5 8.x 7.x 6.x 5.8 5.7 5.6 5.5 5.4 5.3 5.2 5.1

Laravel 13 中文文档 /

本文档最新版为 12.x，旧版本可能放弃维护，推荐阅读最新版！

字符串

介绍
可用方法

介绍

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

字符串

`__()`

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

echo __('Welcome to our application');

echo __('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', 'framework']);

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

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

use Illuminate\Support\Str;

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

// true

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

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

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

use Illuminate\Support\Str;

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

// true

如果传入一个可能值数组，当字符串不以其中任何值开头时，doesntStartWith 方法会返回 true：

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

// true

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

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

use Illuminate\Support\Str;

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

// Laravel

`Str::headline()`

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

use Illuminate\Support\Str;

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

// Steve Jobs

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

// Email Notification Sent

`Str::initials()`

Str::initials 方法返回给定字符串中各单词的首字母，并可选择将其转换为大写：

use Illuminate\Support\Str;

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

// to

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

// TO

`Str::inlineMarkdown()`

Str::inlineMarkdown 方法使用 CommonMark 将 GitHub 风格的 Markdown 转换为行内 HTML。不过，与 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，应当在编译后的 Markdown 上再使用 HTML Purifier 进行过滤：

use Illuminate\Support\Str;

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

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

`Str::is()`

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 方法默认会将多种协议视为合法。不过，你可以通过向 isUrl 方法传递协议数组来指定哪些协议是合法的：

$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

你还可以按版本（1、3、4、5、6、7 或 8）验证给定 UUID 是否符合相应的 UUID 规范：

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

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 方法使用 CommonMark 将 GitHub 风格的 Markdown 转换为 HTML：

use Illuminate\Support\Str;

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

// <h1>Laravel</h1>

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

// <h1>Taylor Otwell</h1>

Markdown 安全性

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

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

如果需要，你可以将一个负数作为第三个参数传给 mask 方法，这会指示该方法从字符串末尾给定的距离处开始掩盖：

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

// tay***@example.com

`Str::match()`

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

use Illuminate\Support\Str;

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

// 'bar'

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

// 'bar'

`Str::matchAll()`

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

use Illuminate\Support\Str;

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

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

如果在表达式中指定了捕获组，Laravel 会返回一个集合，其中包含第一个捕获组的所有匹配结果：

use Illuminate\Support\Str;

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

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

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

`Str::isMatch()`

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

use Illuminate\Support\Str;

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

// true

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

// false

`Str::orderedUuid()`

Str::orderedUuid 方法生成一个“时间戳优先”的 UUID，它可以高效地存储在一个有索引的数据库列中。使用此方法生成的每个 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::counted()`

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

use Illuminate\Support\Str;

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

// 1 order

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

// 1,000 orders

`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

你可以传入 prependCount 参数，在转换后的字符串前加上格式化后的 $count：

use Illuminate\Support\Str;

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

// 1,000 cars

`Str::pluralStudly()`

Str::pluralStudly 方法将采用大驼峰格式（Studly Caps Case）的单数单词字符串转换为复数形式。此函数支持 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 方法来让 random 方法恢复正常生成随机字符串：

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.

你也可以向 remove 方法传递第三个参数 false，在移除字符串时忽略大小写。

`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 11.x';

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

// Laravel 12.x

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

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

// Laravel Framework for Web Artisans

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

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

use Illuminate\Support\Str;

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

// Laravel Framework

`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 方法恢复正常生成 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 方法恢复正常生成 UUID，你可以调用 createUuidsNormally 方法：

Str::createUuidsNormally();

`Str::uuid7()`

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

use Illuminate\Support\Str;

return (string) Str::uuid7();

可以传入一个可选参数 DateTimeInterface，用于生成有序的 UUID：

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

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

链式字符串

链式字符串提供了更流畅的面向对象接口来操作字符串值。与传统字符串操作相比，你可以使用更易读的语法将多个字符串操作串联起来。

`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 方法将给定字符串转换为标题大小写（Title Case），遵循 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 方法会尝试将字符串音译（transliterate）为 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

`decrypt`

decrypt 方法对已加密的字符串进行解密：

use Illuminate\Support\Str;

$decrypted = $encrypted->decrypt();

// 'secret'

关于 decrypt 的逆操作，请参阅 encrypt 方法。

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

`doesntContain()`

doesntContain 方法判断给定字符串是否不包含指定值，其作用与 contains 方法相反。此方法默认区分大小写：

use Illuminate\Support\Str;

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

// true

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

use Illuminate\Support\Str;

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

// true

将 ignoreCase 参数设置为 true 可以忽略大小写：

use Illuminate\Support\Str;

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

// false

`doesntEndWith`

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

use Illuminate\Support\Str;

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

// true

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

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`

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

use Illuminate\Support\Str;

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

// true

你也可以传入一个值数组，判断给定字符串是否不以数组中的任何值开头：

use Illuminate\Support\Str;

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

// true

`encrypt`

encrypt 方法对字符串进行加密：

use Illuminate\Support\Str;

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

关于 encrypt 的逆操作，请参阅 decrypt 方法。

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

`fromBase64`

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

use Illuminate\Support\Str;

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

// Laravel

`hash`

hash 方法使用给定的算法对字符串进行哈希运算：

use Illuminate\Support\Str;

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

// '2bb80d537b1da3e38bd30361aa855686bde0eacd7162fef6a25fe97bf527a25b'

`headline`

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

use Illuminate\Support\Str;

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

// Taylor Otwell

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

// Email Notification Sent

`initials`

initials 方法将字符串转换为其中各单词的首字母组合：

use Illuminate\Support\Str;

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

// TO

`inlineMarkdown`

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

use Illuminate\Support\Str;

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

// <strong>Laravel</strong>

Markdown 安全性

默认情况下，Markdown 支持原始 HTML，这在与原始用户输入一起使用时会暴露跨站脚本（XSS）漏洞。根据 CommonMark 安全文档的说明，你可以使用 html_input 选项来转义或移除原始 HTML，并使用 allow_unsafe_links 选项来指定是否允许不安全的链接。如果你需要允许部分原始 HTML，应当将已编译的 Markdown 通过 HTML Purifier 进行处理：

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

你还可以按版本（1、3、4、5、6、7 或 8）验证给定 UUID 是否符合相应的 UUID 规范：

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`

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，应当将已编译的 Markdown 通过 HTML Purifier 进行处理：

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

如有需要，你可以将负数作为 mask 方法的第二个或第三个参数传入，让该方法从距离字符串末尾指定的位置开始遮蔽：

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

如果在表达式中指定了捕获组，Laravel 会返回一个集合，其中包含第一个捕获组的所有匹配结果：

use Illuminate\Support\Str;

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

`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 方法允许你通过将字符串的当前值传递给指定的可调用对象（callable）来对字符串进行转换：

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`

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

use Illuminate\Support\Str;

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

// 1 order

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

// 1,000 orders

`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

你可以传入 prependCount 参数，在转换后的字符串前加上格式化后的 $count：

use Illuminate\Support\Str;

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

// 1,000 cars

`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 方法会根据 sscanf PHP 函数所支持的格式，从字符串中解析输入并返回一个集合：

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

你也可以传入一个值数组，判断给定字符串是否以数组中的任意值开头：

use Illuminate\Support\Str;

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

// 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' => 'fantastic',
    ]);

// 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 方法将给定字符串转换为标题大小写格式（Title Case）：

use Illuminate\Support\Str;

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

// A Nice Title Uses The Correct Case

`toBase64`

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

`toUri`

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

use Illuminate\Support\Str;

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

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

`ucwords`

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

use Illuminate\Support\Str;

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

// Laravel Framework

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

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

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'

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

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

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'

如有需要，你可以将另一个闭包作为第三个参数传入。当条件参数求值为 false 时，会调用此闭包。

`whenDoesntEndWith`

如果字符串不以给定子字符串结尾，whenDoesntEndWith 方法会调用给定闭包。闭包将接收链式字符串实例：

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

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

// 'Disney World'

`whenDoesntStartWith`

如果字符串不以给定子字符串开头，whenDoesntStartWith 方法会调用给定闭包。闭包将接收链式字符串实例：

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

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

// 'Disney World'

`whenEmpty`

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

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

$string = Str::of('  ')->trim()->whenEmpty(function (Stringable $string) {
    return $string->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`

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

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

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

// 'Laravel'

`whenIsUlid`

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

use Illuminate\Support\Str;

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

// '01gd6r36'

`whenIsUuid`

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

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::of('is')->wrap(before: 'This ', after: ' Laravel!');

// This is Laravel!

本文章首发在 LearnKu.com 网站上。

本译文仅用于学习和交流目的，转载请务必注明文章译者、出处、和本文链接
我们的翻译工作遵照 CC 协议，如果我们的工作有侵犯到您的权益，请及时联系我们。

原文地址：https://learnku.com/docs/laravel/13.x/st...

译文地址：https://learnku.com/docs/laravel/13.x/st...

Markdown 文本

从零开发一个电商项目，功能包括电商后台、商品 & SKU 管理、购物车、订单管理、支付宝支付、微信支付、订单退款流程、优惠券等

以构建论坛项目 LaraBBS 为线索，展开对 Laravel 框架的全面学习。应用程序架构思路贴近 Laravel 框架的设计哲学。

贡献者：1

字符串操作 13.x 13.x 12.x 11.x 10.x 9.x 8.5 8.x 7.x 6.x 5.8 5.7 5.6 5.5 5.4 5.3 5.2 5.1

字符串

介绍

可用方法

字符串

链式字符串

字符串

__()

class_basename()

e()

preg_replace_array()

Str::after()

Str::afterLast()

Str::apa()

Str::ascii()

Str::before()

Str::beforeLast()

Str::between()

Str::betweenFirst()

Str::camel()

Str::charAt()

Str::chopStart()

Str::chopEnd()

Str::contains()

Str::containsAll()

Str::doesntContain()

Str::deduplicate()

Str::doesntEndWith()

Str::doesntStartWith()

Str::endsWith()

Str::excerpt()

Str::finish()

Str::fromBase64()

Str::headline()

Str::initials()

Str::inlineMarkdown()

Markdown 安全性

Str::is()

Str::isAscii()

Str::isJson()

Str::isUrl()

Str::isUlid()

Str::isUuid()

Str::kebab()

Str::lcfirst()

Str::length()

Str::limit()

Str::lower()

Str::markdown()

Markdown 安全性

Str::mask()

Str::match()

Str::matchAll()

Str::isMatch()

Str::orderedUuid()

Str::padBoth()

Str::padLeft()

Str::padRight()

Str::password()

Str::counted()

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

字符串操作

13.x

13.x 12.x 11.x 10.x 9.x 8.5 8.x 7.x 6.x 5.8 5.7 5.6 5.5 5.4 5.3 5.2 5.1

`__()`

`class_basename()`

`e()`

`preg_replace_array()`

`Str::after()`

`Str::afterLast()`

`Str::apa()`

`Str::ascii()`

`Str::before()`

`Str::beforeLast()`

`Str::between()`

`Str::betweenFirst()`

`Str::camel()`

`Str::charAt()`

`Str::chopStart()`

`Str::chopEnd()`

`Str::contains()`

`Str::containsAll()`

`Str::doesntContain()`

`Str::deduplicate()`

`Str::doesntEndWith()`

`Str::doesntStartWith()`

`Str::endsWith()`

`Str::excerpt()`

`Str::finish()`

`Str::fromBase64()`

`Str::headline()`

`Str::initials()`

`Str::inlineMarkdown()`

`Str::is()`

`Str::isAscii()`

`Str::isJson()`

`Str::isUrl()`

`Str::isUlid()`

`Str::isUuid()`

`Str::kebab()`

`Str::lcfirst()`

`Str::length()`

`Str::limit()`

`Str::lower()`

`Str::markdown()`

`Str::mask()`

`Str::match()`

`Str::matchAll()`

`Str::isMatch()`

`Str::orderedUuid()`

`Str::padBoth()`

`Str::padLeft()`

`Str::padRight()`

`Str::password()`

`Str::counted()`

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