字串

簡介
可用方法

簡介

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::doesntContain Str::deduplicate 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::transliterate 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 chopStart chopEnd contains containsAll deduplicate dirname endsWith exactly excerpt 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 toHtmlString transliterate trim ltrim rtrim ucfirst ucsplit unwrap upper when whenContains whenContainsAll whenEmpty whenNotEmpty whenStartsWith whenEndsWith whenExactly whenNotExactly whenIs whenIsAscii whenIsUlid whenIsUuid whenTest wordCount words wrap

字串

`__()` {.collection-method}

__ 函數使用您的語言檔案來翻譯給定的翻譯字串或翻譯鍵：

echo __('歡迎來到我們的應用程式');

echo __('messages.welcome');

如果指定的翻譯字串或鍵不存在，__ 函數將返回給定的值。因此，使用上面的例子，如果該翻譯鍵不存在，__ 函數將返回 messages.welcome。

`class_basename()` {.collection-method}

class_basename 函數返回給定類別的類別名稱，並刪除類別的命名空間：

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

// Baz

`e()` {.collection-method}

e 函數使用 PHP 的 htmlspecialchars 函數，預設將 double_encode 選項設置為 true：

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

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

`preg_replace_array()` {.collection-method}

preg_replace_array 函數使用陣列依序替換字串中的給定模式：

$string = '活動將在 :start 和 :end 之間舉行';

$replaced = preg_replace_array('/:[a-z_]+', ['8:30', '9:00'], $string);

// 活動將在 8:30 和 9:00 之間舉行

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

Str::after 方法返回字串中給定值之後的所有內容。如果字串中不存在該值，將返回整個字串：

use Illuminate\Support\Str;

$slice = Str::after('這是我的名字', '這是');

// '我的名字'

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

Str::afterLast 方法返回字串中最後一次出現的給定值之後的所有內容。如果字串中不存在該值，將返回整個字串：

use Illuminate\Support\Str;

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

    // 'Controller'

<a name="method-str-apa"></a>
#### `Str::apa()` {.collection-method}

`Str::apa` 方法將給定的字串轉換為標題大小寫，遵循 [APA 指南](https://apastyle.apa.org/style-grammar-guidelines/capitalization/title-case)：

    use Illuminate\Support\Str;

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

    // 'Creating a Project'

<a name="method-str-ascii"></a>
#### `Str::ascii()` {.collection-method}

`Str::ascii` 方法將嘗試將字串轉譯為 ASCII 值：

    use Illuminate\Support\Str;

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

    // 'u'

<a name="method-str-before"></a>
#### `Str::before()` {.collection-method}

`Str::before` 方法返回字串中給定值之前的所有內容：

    use Illuminate\Support\Str;

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

    // 'This is '

<a name="method-str-before-last"></a>
#### `Str::beforeLast()` {.collection-method}

`Str::beforeLast` 方法返回字串中最後一次出現給定值之前的所有內容：

    use Illuminate\Support\Str;

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

    // 'This '

<a name="method-str-between"></a>
#### `Str::between()` {.collection-method}

`Str::between` 方法返回字串中兩個值之間的部分：

    use Illuminate\Support\Str;

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

    // ' is my '

<a name="method-str-between-first"></a>
#### `Str::betweenFirst()` {.collection-method}

`Str::betweenFirst` 方法返回字串中兩個值之間可能的最小部分：

    use Illuminate\Support\Str;

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

    // 'a'

<a name="method-camel-case"></a>
#### `Str::camel()` {.collection-method}

`Str::camel` 方法將給定的字串轉換為 `camelCase`：

    use Illuminate\Support\Str;

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

    // 'fooBar'

<a name="method-char-at"></a>
#### `Str::charAt()` {.collection-method}

Str::charAt 方法返回指定索引位置的字符。如果索引超出範圍，則返回 false：

use Illuminate\Support\Str;

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

// 's'

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

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

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

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

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

Str::doesntContain 方法確定給定的字串是否不包含給定的值。默認情況下，此方法區分大小寫：

use Illuminate\Support\Str;

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

// true

您還可以傳遞一個值陣列來確定給定的字串是否不包含陣列中的任何值：

use Illuminate\Support\Str;

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

// true

您可以通過將 ignoreCase 引數設置為 true 來禁用大小寫敏感性：

use Illuminate\Support\Str;

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

// true

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

Str::deduplicate 方法將給定字串中連續出現的字符替換為該字符的單個實例。默認情況下，該方法會去除重複的空格：

use Illuminate\Support\Str;

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

// The Laravel Framework

您可以通過將第二個引數作為要去除重複的不同字符傳遞給該方法來指定要去除重複的不同字符：

use Illuminate\Support\Str;

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

// The-Laravel-Framework

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

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

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

Str::finish 方法如果字串尚未以該值結尾，則將給定值的單個實例添加到字串中：

use Illuminate\Support\Str;

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

// this/string/

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

// this/string/

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

Str::headline 方法將由大小寫、連字符或底線分隔的字串轉換為以空格分隔的字串，每個單詞的第一個字母大寫：

use Illuminate\Support\Str;

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

// 史蒂夫·喬布斯

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

// 電子郵件通知已發送

<a name="method-str-inline-markdown"></a>
#### `Str::inlineMarkdown()` {.collection-method}

`Str::inlineMarkdown` 方法使用 [CommonMark](https://commonmark.thephpleague.com/) 將 GitHub 風格的 Markdown 轉換為內嵌 HTML。但與 `markdown` 方法不同的是，它不會將所有生成的 HTML 包裹在區塊級元素中：

    use Illuminate\Support\Str;

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

    // <strong>Laravel</strong>

#### Markdown 安全性

預設情況下，Markdown 支持原始 HTML，這將在與原始用戶輸入一起使用時暴露跨站腳本（XSS）漏洞。根據 [CommonMark 安全性文件](https://commonmark.thephpleague.com/security/)，您可以使用 `html_input` 選項來轉義或刪除原始 HTML，並使用 `allow_unsafe_links` 選項來指定是否允許不安全的鏈接。如果需要允許一些原始 HTML，您應該通過 HTML 淨化器處理編譯後的 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;);

<a name="method-str-is"></a>
#### `Str::is()` {.collection-method}

`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

<a name="method-str-is-ascii"></a>
#### `Str::isAscii()` {.collection-method}

`Str::isAscii` 方法確定給定的字符串是否為 7 位 ASCII：

    use Illuminate\Support\Str;

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

    // true

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

    // false

<a name="method-str-is-json"></a>
#### `Str::isJson()` {.collection-method}

`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

<a name="method-str-is-url"></a>
#### `Str::isUrl()` {.collection-method}

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

<a name="method-str-is-ulid"></a>
#### `Str::isUlid()` {.collection-method}

`Str::isUlid` 方法確定給定的字串是否為有效的 ULID：

    use Illuminate\Support\Str;

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

    // true

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

    // false

<a name="method-str-is-uuid"></a>
#### `Str::isUuid()` {.collection-method}

`Str::isUuid` 方法確定給定的字串是否為有效的 UUID：

    use Illuminate\Support\Str;

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

    // true

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

    // false

<a name="method-kebab-case"></a>
#### `Str::kebab()` {.collection-method}

`Str::kebab` 方法將給定的字串轉換為 `kebab-case`：

    use Illuminate\Support\Str;

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

    // foo-bar

<a name="method-str-lcfirst"></a>
#### `Str::lcfirst()` {.collection-method}

`Str::lcfirst` 方法將給定的字串的第一個字元轉為小寫：

    use Illuminate\Support\Str;

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

// foo Bar

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

Str::length 方法返回給定字符串的長度：

use Illuminate\Support\Str;

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

// 7

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

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

Str::lower 方法將給定字符串轉換為小寫：

use Illuminate\Support\Str;

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

// laravel

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

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 淨化器傳遞編譯後的 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()` {.collection-method}

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

Str::orderedUuid 方法生成一個“時間戳記優先”的 UUID，可有效地存儲在索引資料庫欄位中。使用此方法生成的每個 UUID 將在先前使用該方法生成的 UUID 之後排序：

use Illuminate\Support\Str;

return (string) Str::orderedUuid();

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

Str::padBoth 方法封裝了 PHP 的 str_pad 函式，使用另一個字串在字串的兩側填充，直到最終字串達到所需長度：

use Illuminate\Support\Str;

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

// '__James___'

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

// '  James   '

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

Str::padLeft 方法封裝了 PHP 的 str_pad 函式，使用另一個字串在字串的左側填充，直到最終字串達到所需長度：

use Illuminate\Support\Str;

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

// '-=-=-James'

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

    // '     詹姆斯'

<a name="method-str-padright"></a>
#### `Str::padRight()` {.collection-method}

`Str::padRight` 方法包裹了 PHP 的 `str_pad` 函數，將字串的右側用另一個字串填充，直到最終字串達到所需的長度：

    use Illuminate\Support\Str;

    $padded = Str::padRight('詹姆斯', 10, '-');

    // '詹姆斯-----'

    $padded = Str::padRight('詹姆斯', 10);

    // '詹姆斯     '

<a name="method-str-password"></a>
#### `Str::password()` {.collection-method}

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

<a name="method-str-plural"></a>
#### `Str::plural()` {.collection-method}

`Str::plural` 方法將單詞字符串轉換為其複數形式。此函數支持 [Laravel 複數形式支持的任何語言](/docs/{{version}}/localization#pluralization-language)：

    use Illuminate\Support\Str;

    $plural = Str::plural('汽車');

    // 汽車

    $plural = Str::plural('孩子');

    // 孩子們

您可以將整數作為第二個引數提供給函數，以檢索字符串的單數形式或複數形式：

    use Illuminate\Support\Str;

    $plural = Str::plural('孩子', 2);

    // 孩子們

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

    // 孩子

<a name="method-str-plural-studly"></a>
#### `Str::pluralStudly()` {.collection-method}

`Str::pluralStudly` 方法將以 studly caps case 格式的單詞字符串轉換為其複數形式。此函數支持 [Laravel 複數形式支持的任何語言](/docs/{{version}}/localization#pluralization-language)：

    use Illuminate\Support\Str;

    $plural = Str::pluralStudly('已驗證人');

    // 已驗證人們

    $plural = Str::pluralStudly('用戶反饋');

// UserFeedback

您可以在函數的第二個引數中提供整數，以檢索字符串的單數形式或複數形式：

```php
use Illuminate\Support\Str;

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

// VerifiedHumans

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

// VerifiedHuman

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

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

use Illuminate\Support\Str;

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

// 0

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

// 7

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

Str::random 方法生成指定長度的隨機字符串。此函數使用 PHP 的 random_bytes 函數：

use Illuminate\Support\Str;

$random = Str::random(40);

在測試期間，將 Str::random 方法返回的值“偽造”可能很有用。為此，您可以使用 createRandomStringsUsing 方法：

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

要指示 random 方法恢復正常生成隨機字符串，您可以調用 createRandomStringsNormally 方法：

Str::createRandomStringsNormally();

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

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

Str::repeat 方法重複給定的字符串：

use Illuminate\Support\Str;

$string = 'a';

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

// aaaaa



<a name="method-str-replace"></a>
#### `Str::replace()` {.collection-method}

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

<a name="method-str-replace-array"></a>
#### `Str::replaceArray()` {.collection-method}

`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

<a name="method-str-replace-first"></a>
#### `Str::replaceFirst()` {.collection-method}

`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

<a name="method-str-replace-last"></a>
#### `Str::replaceLast()` {.collection-method}

`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

<a name="method-str-replace-matches"></a>
#### `Str::replaceMatches()` {.collection-method}

`Str::replaceMatches` 方法使用給定的替換字符串替換與模式匹配的字符串的所有部分：

    use Illuminate\Support\Str;

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

    // '15015551000'

`replaceMatches` 方法還接受一個閉包，該閉包將在與給定模式匹配的字符串的每個部分上調用，允許您在閉包內執行替換邏輯並返回替換後的值：

```php
use Illuminate\Support\Str;

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

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

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

Str::replaceStart 方法僅在字符串開頭出現指定值時替換第一次出現的值：

use Illuminate\Support\Str;

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

// Laravel World

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

// Hello World

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

Str::replaceEnd 方法僅在字符串結尾出現指定值時替換最後一次出現的值：

use Illuminate\Support\Str;

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

// Hello Laravel

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

// Hello World

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

Str::reverse 方法將給定的字符串反轉：

use Illuminate\Support\Str;

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

// dlroW olleH

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

Str::singular 方法將字符串轉換為單數形式。此函數支持Laravel的複數形式支持的任何語言：

use Illuminate\Support\Str;

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

// car

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

// child

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

Str::slug 方法從給定的字符串生成友好的 URL "slug"：

use Illuminate\Support\Str;

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

// laravel-5-framework

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

Str::snake 方法將給定的字符串轉換為 snake_case：


```markdown
    use Illuminate\Support\Str;

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

    // foo_bar

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

    // foo-bar

<a name="method-str-squish"></a>
#### `Str::squish()` {.collection-method}

`Str::squish` 方法從字串中刪除所有多餘的空格，包括單詞之間的多餘空格：

    use Illuminate\Support\Str;

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

    // laravel framework

<a name="method-str-start"></a>
#### `Str::start()` {.collection-method}

`Str::start` 方法如果字串尚未以指定值開頭，則將給定值的單個實例添加到字串中：

    use Illuminate\Support\Str;

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

    // /this/string

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

    // /this/string

<a name="method-starts-with"></a>
#### `Str::startsWith()` {.collection-method}

`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

<a name="method-studly-case"></a>
#### `Str::studly()` {.collection-method}

`Str::studly` 方法將給定字串轉換為 `StudlyCase`：

    use Illuminate\Support\Str;

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

    // FooBar

<a name="method-str-substr"></a>
#### `Str::substr()` {.collection-method}

`Str::substr` 方法返回由起始和長度參數指定的字串部分：

    use Illuminate\Support\Str;

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

    // Laravel

<a name="method-str-substrcount"></a>
#### `Str::substrCount()` {.collection-method}

`Str::substrCount` 方法返回給定字串中給定值的出現次數：

use Illuminate\Support\Str;

$count = Str::substrCount('如果你喜歡冰淇淋，你會喜歡雪糕。', '喜歡');

// 2

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

Str::substrReplace 方法會在字串的一部分內替換文字，從第三個引數指定的位置開始，並替換第四個引數指定的字符數。將 0 傳遞給方法的第四個引數將在指定位置插入字符串，而不替換字符串中的任何現有字符：

use Illuminate\Support\Str;

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

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

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

Str::swap 方法使用 PHP 的 strtr 函數在給定字符串中替換多個值：

use Illuminate\Support\Str;

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

// Burritos are fantastic!

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

Str::take 方法從字符串的開頭返回指定數量的字符：

use Illuminate\Support\Str;

$taken = Str::take('打造令人驚嘆的東西！', 5);

// 打造

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

Str::title 方法將給定字符串轉換為 Title Case：

use Illuminate\Support\Str;

$converted = Str::title('一個好標題使用正確的大小寫');

// 一個好標題使用正確的大小寫

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

Str::toBase64 方法將給定字符串轉換為 Base64：

use Illuminate\Support\Str;

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

// TGFyYXZlbA==

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

Str::transliterate 方法將嘗試將給定字符串轉換為最接近的 ASCII 表示形式：

    use Illuminate\Support\Str;

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

    // 'test@laravel.com'

<a name="method-str-trim"></a>
#### `Str::trim()` {.collection-method}

`Str::trim` 方法從給定字串的開頭和結尾刪除空格（或其他字符）。與 PHP 的原生 `trim` 函數不同，`Str::trim` 方法還會刪除 Unicode 空格字符：

    use Illuminate\Support\Str;

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

    // 'foo bar'

<a name="method-str-ltrim"></a>
#### `Str::ltrim()` {.collection-method}

`Str::ltrim` 方法從給定字串的開頭刪除空格（或其他字符）。與 PHP 的原生 `ltrim` 函數不同，`Str::ltrim` 方法還會刪除 Unicode 空格字符：

    use Illuminate\Support\Str;

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

    // 'foo bar  '

<a name="method-str-rtrim"></a>
#### `Str::rtrim()` {.collection-method}

`Str::rtrim` 方法從給定字串的結尾刪除空格（或其他字符）。與 PHP 的原生 `rtrim` 函數不同，`Str::rtrim` 方法還會刪除 Unicode 空格字符：

    use Illuminate\Support\Str;

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

    // '  foo bar'

<a name="method-str-ucfirst"></a>
#### `Str::ucfirst()` {.collection-method}

`Str::ucfirst` 方法返回首字母大寫的給定字串：

    use Illuminate\Support\Str;

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

    // Foo bar

<a name="method-str-ucsplit"></a>
#### `Str::ucsplit()` {.collection-method}

`Str::ucsplit` 方法通過大寫字符將給定字串拆分為數組：

    use Illuminate\Support\Str;

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

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

<a name="method-str-upper"></a>
#### `Str::upper()` {.collection-method}

`Str::upper` 方法將給定字串轉換為大寫：

    use Illuminate\Support\Str;

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

    // LARAVEL

<a name="method-str-ulid"></a>
#### `Str::ulid()` {.collection-method}

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 方法返回正常生成 ULIDs，您可以調用 createUlidsNormally 方法：

Str::createUlidsNormally();

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

Str::unwrap 方法從給定字符串的開頭和結尾移除指定的字符串：

use Illuminate\Support\Str;

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

// Laravel

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

// framework: "Laravel"

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

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 方法返回正常生成 UUIDs，您可以調用 createUuidsNormally 方法：

Str::createUuidsNormally();

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

Str::wordCount 方法返回字符串包含的單詞數量：

use Illuminate\Support\Str;

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

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

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

Str::words 方法限制字符串中的單詞數量。可以通過第三個引數將額外的字符串傳遞給此方法，以指定應附加到截斷字符串末尾的字符串：

use Illuminate\Support\Str;

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

// Perfectly balanced, as >>>

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

Str::wrap 方法使用額外的字符串或一對字符串包裹給定的字符串：

use Illuminate\Support\Str;

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

// "Laravel"

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

// This is Laravel!

`str()` {.collection-method}

str 函數返回給定字符串的新 Illuminate\Support\Stringable 實例。此函數等效於 Str::of 方法：

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

// 'Taylor Otwell'

如果未向 str 函數提供參數，則函數將返回 Illuminate\Support\Str 的實例：

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

// 'foo_bar'

`trans()` {.collection-method}

trans 函數使用您的語言文件翻譯給定的翻譯鍵：

echo trans('messages.welcome');

如果指定的翻譯鍵不存在，trans 函數將返回給定的鍵。因此，使用上面的示例，如果翻譯鍵不存在，trans 函數將返回 messages.welcome。

`trans_choice()` {.collection-method}

trans_choice 函數會根據變化形式翻譯給定的翻譯鍵：

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

如果指定的翻譯鍵不存在，trans_choice 函數將返回給定的鍵。因此，使用上面的例子，如果翻譯鍵不存在，trans_choice 函數將返回 messages.notifications。

流暢字串

流暢字串提供了一個更流暢、面向對象的接口，用於處理字串值，允許您使用更可讀的語法連接多個字串操作，相較於傳統字串操作更易讀。

`after` {.collection-method}

after 方法返回字串中給定值之後的所有內容。如果值不存在於字串中，將返回整個字串：

use Illuminate\Support\Str;

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

// ' my name'

`afterLast` {.collection-method}

afterLast 方法返回字串中最後一次出現的給定值之後的所有內容。如果值不存在於字串中，將返回整個字串：

use Illuminate\Support\Str;

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

// 'Controller'

`apa` {.collection-method}

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

append 方法將給定的值附加到字串：

use Illuminate\Support\Str;

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


// 'Taylor Otwell'

`ascii` {.collection-method}

ascii 方法將嘗試將字串轉換為 ASCII 值：

use Illuminate\Support\Str;

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

// 'u'

`basename` {.collection-method}

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

before 方法返回字串中給定值之前的所有內容：

use Illuminate\Support\Str;

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

// 'This is '

`beforeLast` {.collection-method}

beforeLast 方法返回字串中給定值最後一次出現之前的所有內容：

use Illuminate\Support\Str;

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

// 'This '

`between` {.collection-method}

between 方法返回字串中兩個值之間的部分：

use Illuminate\Support\Str;

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

// ' is my '

`betweenFirst` {.collection-method}

betweenFirst 方法返回字串中兩個值之間可能最小的部分：

use Illuminate\Support\Str;

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

// 'a'

`camel` {.collection-method}

camel 方法將給定的字串轉換為 camelCase：

use Illuminate\Support\Str;

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


// 'fooBar'

`charAt` {.collection-method}

charAt 方法返回指定索引處的字符。如果索引超出範圍，則返回 false：

use Illuminate\Support\Str;

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

// 's'

`classBasename` {.collection-method}

classBasename 方法返回給定類的類名，並刪除類的命名空間：

use Illuminate\Support\Str;

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

// 'Baz'

`chopStart` {.collection-method}

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

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

contains 方法確定給定字符串是否包含給定值。默認情況下，此方法區分大小寫：

use Illuminate\Support\Str;

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

// true

您也可以傳遞一個值陣列來確定給定的字串是否包含陣列中的任何值：

```php
use Illuminate\Support\Str;

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

// true

您可以通過將 ignoreCase 引數設置為 true 來禁用大小寫敏感性：

use Illuminate\Support\Str;

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

// true

`containsAll` {.collection-method}

containsAll 方法確定給定的字串是否包含給定陣列中的所有值：

use Illuminate\Support\Str;

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

// true

您可以通過將 ignoreCase 引數設置為 true 來禁用大小寫敏感性：

use Illuminate\Support\Str;

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

// true

`deduplicate` {.collection-method}

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

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

`endsWith` {.collection-method}

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

exactly 方法確定給定的字串是否與另一個字串完全匹配：

use Illuminate\Support\Str;

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

// true

`excerpt` {.collection-method}

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

explode 方法通過給定的分隔符拆分字串並返回包含拆分字串每個部分的集合：

use Illuminate\Support\Str;

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

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

finish 方法將給定值的單一實例添加到字符串中，如果該字符串尚未以該值結尾：

use Illuminate\Support\Str;

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

// this/string/

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

// this/string/

`headline` {.collection-method}

headline 方法將由大小寫、連字符或底線分隔的字符串轉換為以空格分隔的字符串，每個單詞的第一個字母大寫：

use Illuminate\Support\Str;

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

// Taylor Otwell

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

// Email Notification Sent

`inlineMarkdown` {.collection-method}

inlineMarkdown 方法將 GitHub 風格的 Markdown 轉換為內聯 HTML，使用 CommonMark。但是，與 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，您應該通過 HTML 淨化器處理編譯後的 Markdown：

use Illuminate\Support\Str;

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

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

`is` {.collection-method}

is 方法確定給定字符串是否與給定模式匹配。星號可以用作通配符值。

use Illuminate\Support\Str;

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

// true

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

// false

`isAscii` {.collection-method}

isAscii 方法確定給定的字串是否為 ASCII 字串：

use Illuminate\Support\Str;

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

// true

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

// false

`isEmpty` {.collection-method}

isEmpty 方法確定給定的字串是否為空：

use Illuminate\Support\Str;

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

// true

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

// false

`isNotEmpty` {.collection-method}

isNotEmpty 方法確定給定的字串是否不為空：

use Illuminate\Support\Str;

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

// false

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

// true

`isJson` {.collection-method}

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

isUlid 方法確定給定的字串是否為 ULID：

use Illuminate\Support\Str;

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

// true

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

// false

`isUrl` {.collection-method}

isUrl 方法確定給定的字串是否為 URL：

use Illuminate\Support\Str;

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

// true

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

isUrl 方法考慮了許多協議作為有效。但是，您可以通過將這些協議提供給 isUrl 方法來指定應該被視為有效的協議：

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

`isUuid` {.collection-method}

isUuid 方法確定給定的字符串是否為 UUID：

use Illuminate\Support\Str;

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

// true

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

// false

`kebab` {.collection-method}

kebab 方法將給定的字符串轉換為 kebab-case：

use Illuminate\Support\Str;

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

// foo-bar

`lcfirst` {.collection-method}

lcfirst 方法返回第一個字符小寫的給定字符串：

use Illuminate\Support\Str;

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

// foo Bar

`length` {.collection-method}

length 方法返回給定字符串的長度：

use Illuminate\Support\Str;

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

// 7

`limit` {.collection-method}

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

lower 方法將給定的字串轉換為小寫：

use Illuminate\Support\Str;

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

// 'laravel'

`markdown` {.collection-method}

markdown 方法將 GitHub 風格的 Markdown 轉換為 HTML：

use Illuminate\Support\Str;

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

// <h1>Laravel</h1>

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

// <h1>Taylor Otwell</h1>

Markdown 安全性

預設情況下，Markdown 支援原始 HTML，當與原始使用者輸入一起使用時，將暴露跨站腳本（XSS）漏洞。根據 CommonMark 安全性文件，您可以使用 html_input 選項來進行轉義或剝離原始 HTML，並使用 allow_unsafe_links 選項來指定是否允許不安全的連結。如果需要允許一些原始 HTML，您應該通過 HTML 淨化器處理您編譯的 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` {.collection-method}

mask 方法使用重複的字符遮罩字串的一部分，可用於混淆電子郵件地址和電話號碼等字串的部分：

use Illuminate\Support\Str;

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

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

如果需要，您可以將負數作為 `mask` 方法的第三或第四個引數，該方法將從字串末尾的指定距離開始遮罩：

    // tay***@example.com

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

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

`match` {.collection-method}

match 方法將返回與給定正則表達式模式匹配的字符串部分：

    use Illuminate\Support\Str;

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

    // 'bar'

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

    // 'bar'

`matchAll` {.collection-method}

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

isMatch 方法將在字符串與給定正則表達式匹配時返回 true：

    use Illuminate\Support\Str;

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

    // true

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

    // false

`newLine` {.collection-method}

newLine 方法將在字符串末尾添加一個「換行」字符：

    use Illuminate\Support\Str;

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

    // 'Laravel
    //  Framework'

`padBoth` {.collection-method}

padBoth 方法封裝了 PHP 的 str_pad 函數，使用另一個字符串在字符串的兩側填充，直到最終字符串達到所需的長度：

    use Illuminate\Support\Str;

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

    // '__James___'

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

    // '  James   '

<a name="method-fluent-str-padleft"></a>
#### `padLeft` {.collection-method}

`padLeft` 方法包裹了 PHP 的 `str_pad` 函式，將字串的左側用另一個字串填充，直到最終字串達到所需的長度：

    use Illuminate\Support\Str;

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

    // '-=-=-James'

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

    // '     James'

<a name="method-fluent-str-padright"></a>
#### `padRight` {.collection-method}

`padRight` 方法包裹了 PHP 的 `str_pad` 函式，將字串的右側用另一個字串填充，直到最終字串達到所需的長度：

    use Illuminate\Support\Str;

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

    // 'James-----'

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

    // 'James     '

<a name="method-fluent-str-pipe"></a>
#### `pipe` {.collection-method}

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

<a name="method-fluent-str-plural"></a>
#### `plural` {.collection-method}

`plural` 方法將單數字串轉換為複數形式。此函式支援 [Laravel 複數形式支持的任何語言](/docs/{{version}}/localization#pluralization-language)：

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

    // 子

<a name="method-fluent-str-position"></a>
#### `position` {.collection-method}

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

    use Illuminate\Support\Str;

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

    // 0

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

    // 7

<a name="method-fluent-str-prepend"></a>
#### `prepend` {.collection-method}

`prepend` 方法將給定的值附加到字符串之前：

    use Illuminate\Support\Str;

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

    // Laravel Framework

<a name="method-fluent-str-remove"></a>
#### `remove` {.collection-method}

`remove` 方法從字符串中刪除給定的值或值陣列：

    use Illuminate\Support\Str;

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

    // Arkansas is beautiful!

您也可以將 `false` 作為第二個參數傳遞，以在刪除字符串時忽略大小寫。

<a name="method-fluent-str-repeat"></a>
#### `repeat` {.collection-method}

`repeat` 方法重複給定的字符串：

```php
use Illuminate\Support\Str;

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

// aaaaa

`replace` {.collection-method}

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

replaceArray 方法使用陣列依次替換字符串中的給定值：

use Illuminate\Support\Str;

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

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



    // 活動將在8:30至9:00之間舉行

<a name="method-fluent-str-replace-first"></a>
#### `replaceFirst` {.collection-method}

`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

<a name="method-fluent-str-replace-last"></a>
#### `replaceLast` {.collection-method}

`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

<a name="method-fluent-str-replace-matches"></a>
#### `replaceMatches` {.collection-method}

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

<a name="method-fluent-str-replace-start"></a>
#### `replaceStart` {.collection-method}

`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

<a name="method-fluent-str-replace-end"></a>
#### `replaceEnd` {.collection-method}

`replaceEnd` 方法僅在值出現在字串結尾時才替換最後一次出現的給定值：

```php
use Illuminate\Support\Str;

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

// Hello Laravel

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

// Hello World

`scan` {.collection-method}

scan 方法根據 sscanf PHP 函數支援的格式，將輸入從字串解析為集合：

use Illuminate\Support\Str;

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

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

`singular` {.collection-method}

singular 方法將字串轉換為其單數形式。此函數支援 Laravel 複數形式支援的任何語言：

use Illuminate\Support\Str;

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

// car

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

// child

`slug` {.collection-method}

slug 方法從給定字串生成友好的 URL "slug"：

use Illuminate\Support\Str;

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

// laravel-framework

`snake` {.collection-method}

snake 方法將給定字串轉換為 snake_case：

use Illuminate\Support\Str;

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

// foo_bar

`split` {.collection-method}

split 方法使用正則表達式將字串拆分為集合：

use Illuminate\Support\Str;

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

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

`squish` {.collection-method}

squish 方法從字串中刪除所有多餘的空格，包括單詞之間的多餘空格：

use Illuminate\Support\Str;

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

// laravel framework

`start` {.collection-method}

start 方法將給定值的單個實例添加到字符串中，如果字符串尚未以該值開頭：

use Illuminate\Support\Str;

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

// /this/string

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

// /this/string

`startsWith` {.collection-method}

startsWith 方法確定給定字符串是否以給定值開頭：

use Illuminate\Support\Str;

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

// true

`stripTags` {.collection-method}

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

studly 方法將給定字符串轉換為 StudlyCase：

use Illuminate\Support\Str;

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

// FooBar

`substr` {.collection-method}

substr 方法返回由給定的開始和長度參數指定的字符串部分：

use Illuminate\Support\Str;

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

// Framework

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

// Frame

`substrReplace` {.collection-method}

substrReplace 方法替換字符串的一部分中的文本，從第二個參數指定的位置開始，並替換第三個參數指定的字符數。將 0 傳遞給方法的第三個參數將在指定位置插入字符串，而不替換字符串中的任何現有字符：

use Illuminate\Support\Str;

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

// 13:

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

// The Laravel Framework

`swap` {.collection-method}

swap 方法使用 PHP 的 strtr 函數替換字符串中的多個值：

use Illuminate\Support\Str;

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

// Burritos are fantastic!

`take` {.collection-method}

take 方法從字符串開頭返回指定數量的字符：

use Illuminate\Support\Str;

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

// Build

`tap` {.collection-method}

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

test 方法確定字符串是否與給定的正則表達式模式匹配：

use Illuminate\Support\Str;

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

// true

`title` {.collection-method}

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 方法將給定的字串轉換為 Base64：

use Illuminate\Support\Str;

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

// TGFyYXZlbA==

`toHtmlString` {.collection-method}

toHtmlString 方法將給定的字串轉換為 Illuminate\Support\HtmlString 實例，在 Blade 模板中呈現時不會被轉義：

use Illuminate\Support\Str;

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

`transliterate` {.collection-method}

transliterate 方法將嘗試將給定的字串轉換為最接近的 ASCII 表示：

use Illuminate\Support\Str;

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

// 'test@laravel.com'

`trim` {.collection-method}

trim 方法修剪給定的字串。與 PHP 原生的 trim 函式不同，Laravel 的 trim 方法還會移除 Unicode 空白字元：

use Illuminate\Support\Str;

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

// 'Laravel'

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

// 'Laravel'

`ltrim` {.collection-method}

ltrim 方法修剪字串的左側。與 PHP 原生的 ltrim 函式不同，Laravel 的 ltrim 方法還會移除 Unicode 空白字元：

use Illuminate\Support\Str;

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

// 'Laravel  '

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

// 'Laravel/'

`rtrim` {.collection-method}

rtrim 方法修剪給定字串的右側。與 PHP 原生的 rtrim 函式不同，Laravel 的 rtrim 方法還會移除 Unicode 空白字元：

use Illuminate\Support\Str;

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

// '  Laravel'

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

// '/Laravel'

ucfirst 方法返回首字母大寫的字符串：

use Illuminate\Support\Str;

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

// Foo bar

`ucsplit` {.collection-method}

ucsplit 方法將給定的字符串按大寫字元拆分為集合：

use Illuminate\Support\Str;

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

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

`unwrap` {.collection-method}

unwrap 方法從給定的字符串開頭和結尾移除指定的字符串：

use Illuminate\Support\Str;

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

// Laravel

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

// framework: "Laravel"

`upper` {.collection-method}

upper 方法將給定的字符串轉換為大寫：

use Illuminate\Support\Str;

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

// LARAVEL

`when` {.collection-method}

when 方法在給定條件為 true 時調用給定的閉包。閉包將接收流暢字符串實例：

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

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

// 'Taylor Otwell'

如有必要，您可以將另一個閉包作為 when 方法的第三個參數傳遞。如果條件參數求值為 false，則將執行此閉包。

`whenContains` {.collection-method}

whenContains 方法在字符串包含給定值時調用給定的閉包。閉包將接收流暢字符串實例：

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

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

如有必要，您可以將另一個閉包作為 when 方法的第三個參數傳遞。如果字符串不包含給定值，則將執行此閉包。

您還可以傳遞值陣列以確定給定字符串是否包含陣列中的任何值：

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

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

// Tony Stark

`whenContainsAll` {.collection-method}

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，則將執行此閉包。

`whenEmpty` {.collection-method}

whenEmpty 方法在字符串為空時調用給定的閉包。如果閉包返回一個值，該值也將被 whenEmpty 方法返回。如果閉包沒有返回值，則將返回流暢字符串實例：

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

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

// 'Laravel'

`whenNotEmpty` {.collection-method}

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

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

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

whenExactly 方法會在字串完全符合指定的字串時調用給定的閉包。閉包將接收流暢字串實例：

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

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

// 'Laravel'

`whenNotExactly` {.collection-method}

whenNotExactly 方法會在字串不完全符合指定的字串時調用給定的閉包。閉包將接收流暢字串實例：

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

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

// '框架'

`whenIs` {.collection-method}

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

whenIsAscii 方法如果字符串是 7 位 ASCII，則調用給定的閉包。閉包將接收流暢字符串實例：

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

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

// 'Laravel'

`whenIsUlid` {.collection-method}

whenIsUlid 方法如果字符串是有效的 ULID，則調用給定的閉包。閉包將接收流暢字符串實例：

use Illuminate\Support\Str;

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

// '01gd6r36'

`whenIsUuid` {.collection-method}

whenIsUuid 方法如果字符串是有效的 UUID，則調用給定的閉包。閉包將接收流暢字符串實例：

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

$string = Str::of('a0a2a2d2-0b87-4a18-83f2-2529882be2de')->whenIsUuid(function (Stringable $string) {
    return $string->substr(0, 8);
});

// 'a0a2a2d2'

`whenTest` {.collection-method}

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

wordCount 方法返回字符串包含的單詞數量：

use Illuminate\Support\Str;

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

`words` {.collection-method}

words 方法限制字符串中的單詞數量。如果需要，您可以指定一個附加的字符串，該字符串將附加到截斷的字符串末尾：

use Illuminate\Support\Str;

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

// Perfectly balanced, as >>>

`wrap` {.collection-method}

wrap 方法使用額外的字符串或一對字符串包裹給定的字符串：

use Illuminate\Support\Str;

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

// "Laravel"

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

// This is Laravel!

Files

strings.md

Latest commit

History

strings.md

File metadata and controls

字串

簡介

可用方法

字串

流暢字串

字串

__() {.collection-method}

class_basename() {.collection-method}

e() {.collection-method}

preg_replace_array() {.collection-method}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Markdown 安全性

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Str::words() {.collection-method}

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

str() {.collection-method}

trans() {.collection-method}

trans_choice() {.collection-method}

流暢字串

after {.collection-method}

afterLast {.collection-method}

apa {.collection-method}

append {.collection-method}

ascii {.collection-method}

basename {.collection-method}

before {.collection-method}

beforeLast {.collection-method}

between {.collection-method}

betweenFirst {.collection-method}

camel {.collection-method}

charAt {.collection-method}

classBasename {.collection-method}

chopStart {.collection-method}

chopEnd {.collection-method}

contains {.collection-method}

containsAll {.collection-method}

`__()` {.collection-method}

`class_basename()` {.collection-method}

`e()` {.collection-method}

`preg_replace_array()` {.collection-method}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`str()` {.collection-method}

`trans()` {.collection-method}

`trans_choice()` {.collection-method}

`after` {.collection-method}

`afterLast` {.collection-method}

`apa` {.collection-method}

`append` {.collection-method}

`ascii` {.collection-method}

`basename` {.collection-method}

`before` {.collection-method}

`beforeLast` {.collection-method}

`between` {.collection-method}

`betweenFirst` {.collection-method}

`camel` {.collection-method}

`charAt` {.collection-method}

`classBasename` {.collection-method}

`chopStart` {.collection-method}

`chopEnd` {.collection-method}

`contains` {.collection-method}

`containsAll` {.collection-method}

`deduplicate` {.collection-method}

`dirname` {.collection-method}

`endsWith` {.collection-method}

`exactly` {.collection-method}

`excerpt` {.collection-method}

`explode` {.collection-method}

`headline` {.collection-method}

`inlineMarkdown` {.collection-method}

`is` {.collection-method}

`isAscii` {.collection-method}

`isEmpty` {.collection-method}

`isNotEmpty` {.collection-method}

`isJson` {.collection-method}

`isUlid` {.collection-method}