字符串操作

点赞
0

11.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 11 中文文档 /

本文档最新版为 10.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::contains
Str::containsAll
Str::endsWith
Str::excerpt
Str::finish
Str::headline
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::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::toHtmlString
Str::trim
Str::ltrim
Str::rtrim
Str::ucfirst
Str::ucsplit
Str::upper
Str::ulid
Str::unwrap
Str::uuid
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
contains
containsAll
dirname
endsWith
excerpt
exactly
explode
finish
headline
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
trim
ltrim
rtrim
ucfirst
ucsplit
unwrap
upper
when
whenContains
whenContainsAll
whenEmpty
whenNotEmpty
whenStartsWith
whenEndsWith
whenExactly
whenNotExactly
whenIs
whenIsAscii
whenIsUlid
whenIsUuid
whenTest
wordCount
words

字符串

`__()`

__ 函数使用本地化文件来翻译指定的字符串或 Key ：

echo __('Welcome to our application');

echo __('messages.welcome');

如果给定翻译的字符串或者 key 不存在，则 会返回你指定的值。所以上述例子中，如果给定翻译的字符串或者 key 不存在，则 函数会返回 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 格式指南大小写规则的标题格式：
The Str::apa method converts the given string to title case following the APA guidelines:

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 方法将指定字符串转换为 驼峰式 表示方法：

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

`Str::containsAll()`

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

use Illuminate\Support\Str;

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

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

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

use Illuminate\Support\Str;

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

// Steve Jobs

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

// Email Notification Sent

`Str::inlineMarkdown()`

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

use Illuminate\Support\Str;

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

// <strong>Laravel</strong>

Markdown 安全

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

use Illuminate\Support\Str;

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

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

`Str::is()`

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

use Illuminate\Support\Str;

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

// true

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

// false

`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

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

你可以将第三个参数传入到该方法，以修改截断后的字符串末尾要追加的字符串：

use Illuminate\Support\Str;

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

// The quick brown fox (...)

`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，你应该通过 HTML Purifier 传递编译后的 Markdown：

use Illuminate\Support\Str;

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

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

`Str::mask()`

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

    use Illuminate\Support\Str;

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

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

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

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

    // tay***@example.com

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

Str::plural 方法将单数字符串转换为复数形式。此函数支持 Laravel 复数转换器支持的任何语言：

    use Illuminate\Support\Str;

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

    // cars

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

    // children

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

    use Illuminate\Support\Str;

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

    // children

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

    // child

`Str::pluralStudly()`

Str::pluralStudly 方法将以大写字母格式的单数字符串转换为复数形式。此函数支持 Laravel 复数转换器支持的任何语言：

    use Illuminate\Support\Str;

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

    // VerifiedHumans

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

    // UserFeedback

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

    use Illuminate\Support\Str;

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

    // VerifiedHumans

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

    // VerifiedHuman

`Str::position()`

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

    use Illuminate\Support\Str;

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

    // 0

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

    // 7

`Str::random()`

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

    use Illuminate\Support\Str;

    $random = Str::random(40);

在测试期间，「伪造」Str::random 方法返回的值可能会很有用。为此，您可以使用 createRandomStringsUsing 方法：

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

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

    Str::createRandomStringsNormally();

`Str::remove()`

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

    use Illuminate\Support\Str;

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

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

    // Ptr Pipr pickd a pck of pickld ppprs.

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

`Str::repeat()`

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

use Illuminate\Support\Str;

$string = 'a';

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

// aaaaa

`Str::replace()`

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

    use Illuminate\Support\Str;

    $string = 'Laravel 10.x';

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

    // Laravel 11.x

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

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

`Str::replaceArray()`

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

    use Illuminate\Support\Str;

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

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

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

`Str::replaceFirst()`

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

    use Illuminate\Support\Str;

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

    // a quick brown fox jumps over the lazy dog

`Str::replaceLast()`

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

    use Illuminate\Support\Str;

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

    // the quick brown fox jumps over a lazy dog

`Str::replaceMatches()`

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

    use Illuminate\Support\Str;

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

    // '15015551000'

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

    use Illuminate\Support\Str;

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

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

`Str::replaceStart()`

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

    use Illuminate\Support\Str;

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

    // Laravel World

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

    // Hello World

`Str::replaceEnd()`

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

    use Illuminate\Support\Str;

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

    // Hello Laravel

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

    // Hello World

`Str::reverse()`

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

    use Illuminate\Support\Str;

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

    // dlroW olleH

`Str::singular()`

Str::singular 方法将字符串转换为单数形式。此函数支持 Laravel 复数转换器支持的任何语言：

    use Illuminate\Support\Str;

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

    // car

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

    // child

`Str::slug()`

Str::slug 方法根据给定的字符串生成 URL 友好的「slug」：

    use Illuminate\Support\Str;

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

    // laravel-5-framework

`Str::snake()`

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

    use Illuminate\Support\Str;

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

    // foo_bar

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

    // foo-bar

`Str::squish()`

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

    use Illuminate\Support\Str;

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

    // laravel framework

`Str::start()`

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

    use Illuminate\Support\Str;

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

    // /this/string

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

    // /this/string

`Str::startsWith()`

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

    use Illuminate\Support\Str;

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

    // true

如果传递了一个可能值数组，则当字符串以数组中任意给定值开头时 startsWith 方法将返回 true：

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

    // true

`Str::studly()`

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

    use Illuminate\Support\Str;

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

    // FooBar

`Str::substr()`

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

    use Illuminate\Support\Str;

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

    // Laravel

`Str::substrCount()`

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

    use Illuminate\Support\Str;

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

    // 2

`Str::substrReplace()`

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

    use Illuminate\Support\Str;

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

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

`Str::swap()`

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

    use Illuminate\Support\Str;

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

    // Burritos are fantastic!

`Str::take()`

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

    use Illuminate\Support\Str;

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

    // Build

`Str::title()`

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

    use Illuminate\Support\Str;

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

    // A Nice Title Uses The Correct Case

`Str::toBase64()`

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

    use Illuminate\Support\Str;

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

    // TGFyYXZlbA==

`Str::toHtmlString()`

Str::toHtmlString 方法将字符串实例转换为的实例 Illuminate\Support\HtmlString，可以在 Blade 模板中显示：

    use Illuminate\Support\Str;

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

`Str::trim()`

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

    use Illuminate\Support\Str;

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

    // 'foo bar'

`Str::ltrim()`

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

    use Illuminate\Support\Str;

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

    // 'foo bar  '

`Str::rtrim()`

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

    use Illuminate\Support\Str;

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

    // '  foo bar'

`Str::ucfirst()`

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

    use Illuminate\Support\Str;

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

    // Foo bar

`Str::ucsplit()`

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

    use Illuminate\Support\Str;

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

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

`Str::upper()`

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

    use Illuminate\Support\Str;

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

    // LARAVEL

`Str::ulid()`

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

    use Illuminate\Support\Str;

    return (string) Str::ulid();

    // 01gd6r360bp37zj17nxb55yv40

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

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::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 方法按照APA 指南将给定的字符串转换为标题大小写：

    use Illuminate\Support\Str;

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

    // A Nice Title Uses the Correct Case

`append`

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

    use Illuminate\Support\Str;

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

    // 'Taylor Otwell'

`ascii`

ascii 方法将尝试将字符串音译为 ASCII 值：

    use Illuminate\Support\Str;

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

    // 'u'

`basename`

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

    use Illuminate\Support\Str;

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

    // 'baz'

如果需要，你可以提供一个将从尾部删除的「扩展名」：

    use Illuminate\Support\Str;

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

    // 'baz'

`before`

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

    use Illuminate\Support\Str;

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

    // 'This is '

`beforeLast`

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

    use Illuminate\Support\Str;

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

    // 'This '

`between`

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

    use Illuminate\Support\Str;

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

    // ' is my '

`betweenFirst`

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

    use Illuminate\Support\Str;

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

    // 'a'

`camel`

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

    use Illuminate\Support\Str;

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

    // 'fooBar'

`charAt`

charAt 方法返回指定索引处的字符。如果索引超出范围，则返回 false：

    use Illuminate\Support\Str;

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

    // 's'

`classBasename`

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

    use Illuminate\Support\Str;

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

    // 'Baz'

`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

`containsAll`

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

    use Illuminate\Support\Str;

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

    // true

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

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

`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

`explode`

explode 方法根据给定的分隔符拆分字符串，并返回包含拆分字符串各个部分的集合：

    use Illuminate\Support\Str;

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

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

`finish`

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

    use Illuminate\Support\Str;

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

    // this/string/

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

    // this/string/

`headline`

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

    use Illuminate\Support\Str;

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

    // Taylor Otwell

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

    // Email Notification Sent

`inlineMarkdown`

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

    use Illuminate\Support\Str;

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

    // <strong>Laravel</strong>

Markdown 安全

默认情况下，Markdown 支持原始 HTML，当与原始用户输入一起使用时，它将暴露跨站点脚本（XSS）漏洞。根据 CommonMark Security 文档，你可以使用 html_input 选项转义或删除原始 HTML，以及 allow_unsafe_links 选项指定是否允许不安全链接。如果你需要允许某些原始 HTML，你应该将编译后的 Markdown 传递给 HTML 净化器：

    use Illuminate\Support\Str;

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

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

`is`

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

    use Illuminate\Support\Str;

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

    // true

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

    // false

`isAscii`

isAscii 方法检测给定的字符串是否是 ASCII 字符串：

    use Illuminate\Support\Str;

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

    // true

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

    // false

`isEmpty`

isEmpty 方法检测给定的字符串是否为空：

    use Illuminate\Support\Str;

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

    // true

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

    // false

`isNotEmpty`

isNotEmpty 方法检测给定的字符串是否不为空：

    use Illuminate\Support\Str;

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

    // false

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

    // true

`isJson`

isJson 方法检测给定的字符串是否为有效的 JSON：

    use Illuminate\Support\Str;

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

    // true

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

    // true

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

    // false

`isUlid`

isUlid 方法检测给定的字符串是否是 ULID：

    use Illuminate\Support\Str;

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

    // true

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

    // false

`isUrl`

isUrl 方法检测给定的字符串是否是 URL：

    use Illuminate\Support\Str;

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

    // true

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

    // false

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

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

`isUuid`

isUuid 方法检测给定的字符串是否是 UUID：

    use Illuminate\Support\Str;

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

    // true

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

    // false

`kebab`

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

    use Illuminate\Support\Str;

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

    // foo-bar

`lcfirst`

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

    use Illuminate\Support\Str;

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

    // foo Bar

`length`

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

    use Illuminate\Support\Str;

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

    // 7

`limit`

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

    use Illuminate\Support\Str;

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

    // The quick brown fox...

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

    use Illuminate\Support\Str;

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

    // The quick brown fox (...)

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

    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('[email protected]')->mask('*', 3);

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

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

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

    // tay***@example.com

    $string = Str::of('[email protected]')->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 方法允许你通过将其当前值传递给给定的回调函数来转换字符串：

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

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

    // 'Checksum: a5c95b86291ea299fcbe64458ed12702'

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

    // 'bar'

`plural`

plural 方法将单数字符串转换为复数形式。此函数支持 Laravel 复数转换器支持的任何语言)：

    use Illuminate\Support\Str;

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

    // cars

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

    // children

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

    use Illuminate\Support\Str;

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

    // children

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

    // child

`position`

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

    use Illuminate\Support\Str;

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

    // 0

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

    // 7

`prepend`

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

    use Illuminate\Support\Str;

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

    // Laravel Framework

`remove`

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

    use Illuminate\Support\Str;

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

    // Arkansas is beautiful!

您还可以传递 false 给第二个参数来在删除字符串时忽略大小写。

`repeat`

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

use Illuminate\Support\Str;

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

// aaaaa

`replace`

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

    use Illuminate\Support\Str;

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

    // Laravel 7.x

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

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

`replaceArray`

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

    use Illuminate\Support\Str;

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

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

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

`replaceFirst`

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

    use Illuminate\Support\Str;

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

    // a quick brown fox jumps over the lazy dog

`replaceLast`

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

    use Illuminate\Support\Str;

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

    // the quick brown fox jumps over a lazy dog

`replaceMatches`

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

    use Illuminate\Support\Str;

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

    // '15015551000'

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

    use Illuminate\Support\Str;

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

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

`replaceStart`

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

    use Illuminate\Support\Str;

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

    // Laravel World

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

    // Hello World

`replaceEnd`

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

    use Illuminate\Support\Str;

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

    // Hello Laravel

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

    // Hello World

`scan`

scan 方法根据 PHP 函数 sscanf支持的格式将字符串输入解析为集合：

    use Illuminate\Support\Str;

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

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

`singular`

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

    use Illuminate\Support\Str;

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

    // car

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

    // child

`slug`

slug 方法根据给定的字符串生成 URL 友好的「slug」：

    use Illuminate\Support\Str;

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

    // laravel-framework

`snake`

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

    use Illuminate\Support\Str;

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

    // foo_bar

`split`

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

    use Illuminate\Support\Str;

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

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

`squish`

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

    use Illuminate\Support\Str;

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

    // laravel framework

`start`

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

    use Illuminate\Support\Str;

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

    // /this/string

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

    // /this/string

`startsWith`

该startsWith方法检测给定的字符串是否以给定的值开头：

    use Illuminate\Support\Str;

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

    // true

`stripTags`

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

    use Illuminate\Support\Str;

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

    // Taylor Otwell

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

    // Taylor <b>Otwell</b>

`studly`

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

    use Illuminate\Support\Str;

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

    // FooBar

`substr`

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

    use Illuminate\Support\Str;

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

    // Framework

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

    // Frame

`substrReplace`

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

    use Illuminate\Support\Str;

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

    // 13:

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

    // The Laravel Framework

`swap`

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

    use Illuminate\Support\Str;

    $string = Str::of('Tacos are great!')
        ->swap([
            'Tacos' => 'Burritos',
            'great' => '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==

`trim`

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

    use Illuminate\Support\Str;

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

    // 'Laravel'

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

    // 'Laravel'

`ltrim`

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

    use Illuminate\Support\Str;

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

    // 'Laravel  '

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

    // 'Laravel/'

`rtrim`

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

    use Illuminate\Support\Str;

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

    // '  Laravel'

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

    // '/Laravel'

`ucfirst`

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

    use Illuminate\Support\Str;

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

    // Foo bar

`ucsplit`

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

    use Illuminate\Support\Str;

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

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

`unwrap`

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

    use Illuminate\Support\Str;

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

    // Laravel

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

    // framework: "Laravel"

`upper`

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

    use Illuminate\Support\Str;

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

    // LARAVEL

`when`

如果给定条件为 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'

如果需要，你可以将另一个闭包作为第三个参数传递给 when 方法。如果字符串不包含给定值，则执行此闭包。

译者注： 原文在手册中应该是写错了，正确的应该是「你可以将另一个闭包作为第三个参数传递给 whenContains 方法」，待手册更新后更改以上内容。

您还可以传递一个值数组来检测给定的字符串是否包含数组中的任意值：

    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'

如果需要，你可以将另一个闭包作为第三个参数传递给该 when 方法。如果条件参数的结果为 false ，将执行此闭包。

译者注： 原文在手册中应该是写错了，正确的应该是「你可以将另一个闭包作为第三个参数传递给 whenContainsAll 方法。如果字符串不包含所有给定的子字符串，将执行此闭包。」，待手册更新后更改以上内容。

whenEmpty

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

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

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

    // 'Laravel'

`whenNotEmpty`

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

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

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

    // 'Laravel Framework'

`whenStartsWith`

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

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

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

    // 'Disney World'

`whenEndsWith`

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

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

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

    // 'Disney World'

`whenExactly`

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

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

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

    // 'Laravel'

`whenNotExactly`

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

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

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

    // 'Framework'

`whenIs`

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

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

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

    // 'foo/bar/baz'

`whenIsAscii`

如果字符串是 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 >>>

本文章首发在网站上。

原文地址：cndocs/11.x/st...

译文地址：cndocs/11.x/st...

字符串操作 点赞 0 11.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::contains()

Str::containsAll()

Str::endsWith()

Str::excerpt()

Str::finish()

Str::headline()

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

Str::trim()

Str::ltrim()

Str::rtrim()

字符串操作

点赞
0

11.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::contains()`

`Str::containsAll()`

`Str::endsWith()`

`Str::excerpt()`

`Str::finish()`

`Str::headline()`

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

`Str::trim()`

`Str::ltrim()`

`Str::rtrim()`

`Str::ucfirst()`

`Str::ucsplit()`

`Str::upper()`

`Str::ulid()`

`Str::unwrap()`

`Str::uuid()`

`Str::wordCount()`

`Str::wordWrap()`