Inject: alert("Hello XSS!");
+//Inject: alert("Hello XSS!");
+``` #### `Str::mask()` Метод `Str::mask` маскирует часть строки повторяющимся символом и может использоваться для обфускации сегментов строк, таких как адреса электронной почты и номера телефонов: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $string = Str::mask('taylor@example.com', '*', 3); +$string = Str::mask('taylor@example.com', '*', 3); - // tay*************** +// tay*************** +``` При необходимости вы можете указать отрицательное число в качестве третьего аргумента метода `mask`, который даст указание методу начать маскировку на заданном расстоянии от конца строки: - $string = Str::mask('taylor@example.com', '*', -15, 3); +```php +$string = Str::mask('taylor@example.com', '*', -15, 3); + +// tay***@example.com +``` + + +#### `Str::match()` + +Метод `Str::match` вернет часть строки, соответствующую заданному шаблону регулярного выражения: + +```php +use Illuminate\Support\Str; + +$result = Str::match('/bar/', 'foo bar'); + +// 'bar' - // tay***@example.com +$result = Str::match('/foo (.*)/', 'foo bar'); + +// 'bar' +``` + + +#### `Str::matchAll()` + +Метод `Str::matchAll` вернет коллекцию, содержащую части строки, соответствующие заданному шаблону регулярного выражения: + +```php +use Illuminate\Support\Str; + +$result = Str::matchAll('/bar/', 'bar foo bar'); + +// collect(['bar', 'bar']) +``` + +Если указать соответствующую группу в выражении, Laravel вернет коллекцию совпадений первой совпадающей группы: + +```php +use Illuminate\Support\Str; + +$result = Str::matchAll('/f(\w*)/', 'bar fun bar fly'); + +// collect(['un', 'ly']); +``` + +Если совпадений не найдено, будет возвращена пустая коллекция. #### `Str::orderedUuid()` Метод `Str::orderedUuid` генерирует UUID с «префиксом временной метки», который может быть эффективно сохранен в индексированном столбце базы данных. Каждый UUID, созданный с помощью этого метода, будет отсортирован после UUID, ранее созданных с помощью этого метода: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - return (string) Str::orderedUuid(); +return (string) Str::orderedUuid(); +``` #### `Str::padBoth()` Метод `Str::padBoth` оборачивает функцию `str_pad` PHP, заполняя обе стороны строки другой строкой, пока конечная строка не достигнет желаемой длины: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $padded = Str::padBoth('James', 10, '_'); +$padded = Str::padBoth('James', 10, '_'); - // '__James___' +// '__James___' - $padded = Str::padBoth('James', 10); +$padded = Str::padBoth('James', 10); - // ' James ' +// ' James ' +``` #### `Str::padLeft()` Метод `Str::padLeft` оборачивает функцию `str_pad` PHP, заполняя левую часть строки другой строкой, пока конечная строка не достигнет желаемой длины: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $padded = Str::padLeft('James', 10, '-='); +$padded = Str::padLeft('James', 10, '-='); - // '-=-=-James' +// '-=-=-James' - $padded = Str::padLeft('James', 10); +$padded = Str::padLeft('James', 10); - // ' James' +// ' James' +``` #### `Str::padRight()` Метод `Str::padRight` оборачивает функцию `str_pad` PHP, заполняя правую часть строки другой строкой, пока конечная строка не достигнет желаемой длины: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $padded = Str::padRight('James', 10, '-'); +$padded = Str::padRight('James', 10, '-'); - // 'James-----' +// 'James-----' - $padded = Str::padRight('James', 10); +$padded = Str::padRight('James', 10); - // 'James ' +// 'James ' +``` #### `Str::password()` Метод `Str::password` можно использовать для генерации безопасного, случайного пароля заданной длины. Пароль будет состоять из комбинации букв, цифр, символов и пробелов. По умолчанию пароли имеют длину 32 символа: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $password = Str::password(); +$password = Str::password(); - // 'EbJo2vE-AS:U,$%_gkrV4n,q~1xy/-_4' +// 'EbJo2vE-AS:U,$%_gkrV4n,q~1xy/-_4' - $password = Str::password(12); +$password = Str::password(12); - // 'qwuar>#V|i]N' +// 'qwuar>#V|i]N' +``` #### `Str::plural()` Метод `Str::plural` преобразует строку единственного числа в ее форму множественного числа. Эта функция поддерживает [любые из языков, поддерживаемых плюрализатором Laravel](/docs/{{version}}/localization#pluralization-language): - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $plural = Str::plural('car'); +$plural = Str::plural('car'); - // cars +// cars - $plural = Str::plural('child'); +$plural = Str::plural('child'); - // children +// children +``` Вы можете передать целое число в качестве второго аргумента метода для получения строки в единственном или множественном числе: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $plural = Str::plural('child', 2); +$plural = Str::plural('child', 2); - // children +// children - $singular = Str::plural('child', 1); +$singular = Str::plural('child', 1); - // child +// child +``` #### `Str::pluralStudly()` Метод `Str::pluralStudly` преобразует строку единственного слова, отформатированную в заглавном регистре studly, в форму множественного числа. Эта функция поддерживает [любой из языков, поддерживаемых плюрализатором Laravel](/docs/{{version}}/localization#pluralization-language): - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $plural = Str::pluralStudly('VerifiedHuman'); +$plural = Str::pluralStudly('VerifiedHuman'); - // VerifiedHumans +// VerifiedHumans - $plural = Str::pluralStudly('UserFeedback'); +$plural = Str::pluralStudly('UserFeedback'); - // UserFeedback +// UserFeedback +``` Вы можете передать целое число в качестве второго аргумента метода для получения строки в единственном или множественном числе: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $plural = Str::pluralStudly('VerifiedHuman', 2); +$plural = Str::pluralStudly('VerifiedHuman', 2); - // VerifiedHumans +// VerifiedHumans - $singular = Str::pluralStudly('VerifiedHuman', 1); +$singular = Str::pluralStudly('VerifiedHuman', 1); - // VerifiedHuman +// VerifiedHuman +``` #### `Str::position()` Метод `Str::position` возвращает позицию первого вхождения подстроки в строке. Если подстрока не существует в данной строке, возвращается значение `false`: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $position = Str::position('Hello, World!', 'Hello'); +$position = Str::position('Hello, World!', 'Hello'); - // 0 +// 0 - $position = Str::position('Hello, World!', 'W'); +$position = Str::position('Hello, World!', 'W'); - // 7 +// 7 +``` #### `Str::random()` Метод `Str::random` генерирует случайную строку указанной длины. Этот метод использует функцию `random_bytes` PHP: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $random = Str::random(40); +$random = Str::random(40); +``` Во время тестирования может быть полезно «подделать» значение, возвращаемое методом `Str::random`. Для этого вы можете использовать метод `createRandomStringsUsing`: - Str::createRandomStringsUsing(function () { - return 'fake-random-string'; - }); +```php +Str::createRandomStringsUsing(function () { + return 'fake-random-string'; +}); +``` Чтобы дать указание методу `random` вернуться к нормальной генерации случайных строк, вы можете вызвать метод `createRandomStringsNormally`: - Str::createRandomStringsNormally(); +```php +Str::createRandomStringsNormally(); +``` #### `Str::remove()` Метод `Str::remove` удаляет указанную подстроку или массив подстрок в строке: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $string = 'Peter Piper picked a peck of pickled peppers.'; +$string = 'Peter Piper picked a peck of pickled peppers.'; - $removed = Str::remove('e', $string); +$removed = Str::remove('e', $string); - // Ptr Pipr pickd a pck of pickld ppprs. +// Ptr Pipr pickd a pck of pickld ppprs. +``` Вы можете передать `false` в качестве третьего аргумента для игнорирования регистра удаляемых подстрок. @@ -1019,383 +1275,456 @@ $repeat = Str::repeat($string, 5); Метод `Str::replace` заменяет в строке одну подстроку другой: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $string = 'Laravel 10.x'; +$string = 'Laravel 11.x'; - $replaced = Str::replace('10.x', '11.x', $string); +$replaced = Str::replace('11.x', '12.x', $string); - // Laravel 11.x +// Laravel 12.x +``` Метод `replace` также принимает аргумент `caseSensitive`. По умолчанию метод `replace` чувствителен к регистру: - Str::replace('Framework', 'Laravel', caseSensitive: false); +```php +$replaced = Str::replace( + 'php', + 'Laravel', + 'PHP Framework for Web Artisans', + caseSensitive: false +); + +// Laravel Framework for Web Artisans +``` #### `Str::replaceArray()` Метод `Str::replaceArray` последовательно заменяет указанное значение в строке, используя массив: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $string = 'The event will take place between ? and ?'; +$string = 'The event will take place between ? and ?'; - $replaced = Str::replaceArray('?', ['8:30', '9:00'], $string); +$replaced = Str::replaceArray('?', ['8:30', '9:00'], $string); - // The event will take place between 8:30 and 9:00 +// The event will take place between 8:30 and 9:00 +``` #### `Str::replaceFirst()` Метод `Str::replaceFirst` заменяет первое вхождение переданного значения в строке: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $replaced = Str::replaceFirst('the', 'a', 'the quick brown fox jumps over the lazy dog'); +$replaced = Str::replaceFirst('the', 'a', 'the quick brown fox jumps over the lazy dog'); - // a 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; +```php +use Illuminate\Support\Str; - $replaced = Str::replaceLast('the', 'a', 'the quick brown fox jumps over the lazy dog'); +$replaced = Str::replaceLast('the', 'a', 'the quick brown fox jumps over the lazy dog'); - // the quick brown fox jumps over a lazy dog +// the quick brown fox jumps over a lazy dog +``` #### `Str::replaceMatches()` Метод `Str::replaceMatches` заменяет все части строки, соответствующие шаблону, заданной строкой замены: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $replaced = Str::replaceMatches( - pattern: '/[^A-Za-z0-9]++/', - replace: '', - subject: '(+1) 501-555-1000' - ) +$replaced = Str::replaceMatches( + pattern: '/[^A-Za-z0-9]++/', + replace: '', + subject: '(+1) 501-555-1000' +) - // '15015551000' +// '15015551000' +``` Метод `replaceMatches` также принимает замыкание, которое будет вызвано для каждой части строки, соответствующей заданному шаблону, что позволяет вам выполнять логику замены внутри замыкания и возвращать замененное значение: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $replaced = Str::replaceMatches('/\d/', function (array $matches) { - return '['.$matches[0].']'; - }, '123'); +$replaced = Str::replaceMatches('/\d/', function (array $matches) { + return '['.$matches[0].']'; +}, '123'); - // '[1][2][3]' +// '[1][2][3]' +``` #### `Str::replaceStart()` Метод `Str::replaceStart` заменяет только первое вхождение заданного значения, если значение появляется в начале строки: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $replaced = Str::replaceStart('Hello', 'Laravel', 'Hello World'); +$replaced = Str::replaceStart('Hello', 'Laravel', 'Hello World'); - // Laravel World +// Laravel World - $replaced = Str::replaceStart('World', 'Laravel', 'Hello World'); +$replaced = Str::replaceStart('World', 'Laravel', 'Hello World'); - // Hello World +// Hello World +``` #### `Str::replaceEnd()` Метод `Str::replaceEnd` заменяет только последнее вхождение заданного значения, если значение появляется в конце строки: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $replaced = Str::replaceEnd('World', 'Laravel', 'Hello World'); +$replaced = Str::replaceEnd('World', 'Laravel', 'Hello World'); - // Hello Laravel +// Hello Laravel - $replaced = Str::replaceEnd('Hello', 'Laravel', 'Hello World'); +$replaced = Str::replaceEnd('Hello', 'Laravel', 'Hello World'); - // Hello World +// Hello World +``` #### `Str::reverse()` Метод `Str::reverse` переворачивает данную строку: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $reversed = Str::reverse('Hello World'); +$reversed = Str::reverse('Hello World'); - // dlroW olleH +// dlroW olleH +``` #### `Str::singular()` Метод `Str::singular` преобразует строку в ее форму единственного числа. Эта функция поддерживает [любые из языков, поддерживаемых плюрализатором Laravel](/docs/{{version}}/localization#pluralization-language): - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $singular = Str::singular('cars'); +$singular = Str::singular('cars'); - // car +// car - $singular = Str::singular('children'); +$singular = Str::singular('children'); - // child +// child +``` #### `Str::slug()` Метод `Str::slug` создает «дружественный фрагмент» URL-адреса из переданной строки: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $slug = Str::slug('Laravel 5 Framework', '-'); +$slug = Str::slug('Laravel 5 Framework', '-'); - // laravel-5-framework +// laravel-5-framework +``` #### `Str::snake()` Метод `Str::snake` преобразует переданную строку в `snake_case`: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $converted = Str::snake('fooBar'); +$converted = Str::snake('fooBar'); - // foo_bar +// foo_bar - $converted = Str::snake('fooBar', '-'); +$converted = Str::snake('fooBar', '-'); - // foo-bar +// foo-bar +``` #### `Str::squish()` Метод `Str::squish` удаляет все лишние пробелы из строки, включая лишние пробелы между словами: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $string = Str::squish(' laravel framework '); +$string = Str::squish(' laravel framework '); - // laravel framework +// laravel framework +``` #### `Str::start()` Метод `Str::start` добавляет один экземпляр указанного значения в переданную строку, если она еще не начинается этим значением: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $adjusted = Str::start('this/string', '/'); +$adjusted = Str::start('this/string', '/'); - // /this/string +// /this/string - $adjusted = Str::start('/this/string', '/'); +$adjusted = Str::start('/this/string', '/'); - // /this/string +// /this/string +``` #### `Str::startsWith()` Метод `Str::startsWith` определяет, начинается ли переданная строка с указанного значения: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $result = Str::startsWith('This is my name', 'This'); +$result = Str::startsWith('This is my name', 'This'); - // true +// true +``` Если передан массив возможных значений, метод `startsWith` вернет `true`, если строка начинается с любого из заданных значений: - $result = Str::startsWith('This is my name', ['This', 'That', 'There']); +```php +$result = Str::startsWith('This is my name', ['This', 'That', 'There']); - // true +// true +``` #### `Str::studly()` Метод `Str::studly` преобразует переданную строку в `StudlyCase`: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $converted = Str::studly('foo_bar'); +$converted = Str::studly('foo_bar'); - // FooBar +// FooBar +``` #### `Str::substr()` Метод `Str::substr` возвращает часть строки, заданную параметрами «начало» и «длина»: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $converted = Str::substr('The Laravel Framework', 4, 7); +$converted = Str::substr('The Laravel Framework', 4, 7); - // Laravel +// Laravel +``` #### `Str::substrCount()` Метод `Str::substrCount` возвращает число вхождений подстроки в строку: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $count = Str::substrCount('If you like ice cream, you will like snow cones.', 'like'); +$count = Str::substrCount('If you like ice cream, you will like snow cones.', 'like'); - // 2 +// 2 +``` #### `Str::substrReplace()` Метод `Str::substrReplace` заменяет текст в части строки, начиная с позиции, указанной третьим аргументом, и заменяет число символов, указанное четвертым аргументом. Передав `0` четвертым аргументом в метод, строка будет вставлена в указанную позицию без замены каких-либо существующих символов в строке: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $result = Str::substrReplace('1300', ':', 2); - // 13: +$result = Str::substrReplace('1300', ':', 2); +// 13: - $result = Str::substrReplace('1300', ':', 2, 0); - // 13:00 +$result = Str::substrReplace('1300', ':', 2, 0); +// 13:00 +``` #### `Str::swap()` Метод `Str::swap` заменяет несколько значений в заданной строке, используя функцию `strtr` PHP: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $string = Str::swap([ - 'Tacos' => 'Burritos', - 'great' => 'fantastic', - ], 'Tacos are great!'); +$string = Str::swap([ + 'Tacos' => 'Burritos', + 'great' => 'fantastic', +], 'Tacos are great!'); - // Burritos are fantastic! +// Burritos are fantastic! +``` #### `Str::take()` Метод `Str::take` возвращает указанное количество символов из начала строки: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $taken = Str::take('Build something amazing!', 5); +$taken = Str::take('Build something amazing!', 5); - // Build +// Build +``` #### `Str::title()` Метод `Str::title` преобразует переданную строку в `Title Case`: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $converted = Str::title('a nice title uses the correct case'); +$converted = Str::title('a nice title uses the correct case'); - // A Nice Title Uses The Correct Case +// A Nice Title Uses The Correct Case +``` #### `Str::toBase64()` {.collection-method} Метод `Str::toBase64` преобразует переданную строку в Base64: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $base64 = Str::toBase64('Laravel'); +$base64 = Str::toBase64('Laravel'); - // TGFyYXZlbA== +// TGFyYXZlbA== +``` #### `Str::transliterate()` Метод `Str::transliterate` попытается преобразовать данную строку в ее ближайшее представление ASCII: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $email = Str::transliterate('ⓣⓔⓢⓣ@ⓛⓐⓡⓐⓥⓔⓛ.ⓒⓞⓜ'); +$email = Str::transliterate('ⓣⓔⓢⓣ@ⓛⓐⓡⓐⓥⓔⓛ.ⓒⓞⓜ'); - // 'test@laravel.com' +// 'test@laravel.com' +``` #### `Str::trim()` {.collection-method} Метод `Str::trim` удаляет пробелы (или другие символы) из начала и конца заданной строки. В отличие от встроенной функции PHP `trim`, метод `Str::trim` также удаляет пробельные символы Юникода: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $string = Str::trim(' foo bar '); +$string = Str::trim(' foo bar '); - // 'foo bar' +// 'foo bar' +``` #### `Str::ltrim()` {.collection-method} Метод Str::ltrim удаляет пробелы (или другие символы) с начала заданной строки. В отличие от встроенной функции PHP `ltrim`, метод `Str::ltrim` также удаляет пробельные символы Юникода: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $string = Str::ltrim(' foo bar '); +$string = Str::ltrim(' foo bar '); - // 'foo bar ' +// 'foo bar ' +``` #### `Str::rtrim()` {.collection-method} Метод `Str::rtrim` удаляет пробелы (или другие символы) с конца заданной строки. В отличие от встроенной функции PHP `rtrim`, метод `Str::rtrim` также удаляет пробельные символы Юникода: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $string = Str::rtrim(' foo bar '); +$string = Str::rtrim(' foo bar '); - // ' foo bar' +// ' foo bar' +``` #### `Str::ucfirst()` Метод `Str::ucfirst` возвращает переданную строку с первой заглавной буквой: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $string = Str::ucfirst('foo bar'); +$string = Str::ucfirst('foo bar'); - // Foo bar +// Foo bar +``` #### `Str::ucsplit()` Метод `Str::ucsplit` разделяет заданную строку на массив по символам в верхнем регистре: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $segments = Str::ucsplit('FooBar'); +$segments = Str::ucsplit('FooBar'); - // [0 => 'Foo', 1 => 'Bar'] +// [0 => 'Foo', 1 => 'Bar'] +``` #### `Str::upper()` Метод `Str::upper` преобразует переданную строку в верхний регистр: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $string = Str::upper('laravel'); +$string = Str::upper('laravel'); - // LARAVEL +// LARAVEL +``` #### `Str::ulid()` Метод `Str::ulid` генерирует ULID, который является компактным, уникальным и упорядоченным по времени идентификатором: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - return (string) Str::ulid(); +return (string) Str::ulid(); - // 01gd6r360bp37zj17nxb55yv40 +// 01gd6r360bp37zj17nxb55yv40 +``` Если вы хотите получить экземпляр даты `Illuminate\Support\Carbon`, представляющий дату и время создания заданного ULID, вы можете использовать метод `createFromId`, предоставленный интеграцией Carbon в Laravel: @@ -1408,51 +1737,80 @@ $date = Carbon::createFromId((string) Str::ulid()); Во время тестирования может оказаться полезным «подделать» значение, возвращаемое методом `Str::ulid`. Для этого вы можете использовать метод `createUlidsUsing`: - use Symfony\Component\Uid\Ulid; +```php +use Symfony\Component\Uid\Ulid; - Str::createUlidsUsing(function () { - return new Ulid('01HRDBNHHCKNW2AK4Z29SN82T9'); - }); +Str::createUlidsUsing(function () { + return new Ulid('01HRDBNHHCKNW2AK4Z29SN82T9'); +}); +``` Чтобы дать указание методу `ulid` вернуться к нормальной генерации ULID, вы можете вызвать метод `createUlidsNormally`: - Str::createUlidsNormally(); +```php +Str::createUlidsNormally(); +``` #### `Str::unwrap()` Метод `Str::unwrap` удаляет указанные строки из начала и конца заданной строки: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - Str::unwrap('-Laravel-', '-'); +Str::unwrap('-Laravel-', '-'); - // Laravel +// Laravel - Str::unwrap('{framework: "Laravel"}', '{', '}'); +Str::unwrap('{framework: "Laravel"}', '{', '}'); - // framework: "Laravel" +// framework: "Laravel" +``` #### `Str::uuid()` Метод `Str::uuid` генерирует UUID (версия 4): - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - return (string) Str::uuid(); +return (string) Str::uuid(); +``` Во время тестирования может оказаться полезным «подделать» значение, возвращаемое методом `Str::uuid`. Для этого вы можете использовать метод `createUuidsUsing`: - use Ramsey\Uuid\Uuid; +```php +use Ramsey\Uuid\Uuid; + +Str::createUuidsUsing(function () { + return Uuid::fromString('eadbfeac-5258-45c2-bab7-ccb9b5ef74f9'); +}); +``` + +Чтобы дать указание методу `uuid` вернуться к обычному генерированию UUID, вы можете вызвать метод `createUuidsNormally`: + +```php +Str::createUuidsNormally(); +``` + + +#### `Str::uuid7()` + +Метод `Str::uuid7` генерирует UUID (версия 7): + +```php +use Illuminate\Support\Str; - Str::createUuidsUsing(function () { - return Uuid::fromString('eadbfeac-5258-45c2-bab7-ccb9b5ef74f9'); - }); +return (string) Str::uuid7(); +``` -Чтобы дать указание методу `uuid` вернуться к обычному генерированию UUID, вы можете вызвать метод `createUuidsNormally`: +`DateTimeInterface` может быть передан как необязательный параметр, который будет использоваться для генерации упорядоченного UUID: - Str::createUuidsNormally(); +```php +return (string) Str::uuid7(time: now()); +``` #### `Str::wordCount()` @@ -1470,65 +1828,77 @@ Str::wordCount('Hello, world!'); // 2 Метод `Str::wordWrap` переносит строку по заданному количеству символов: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $text = "The quick brown fox jumped over the lazy dog." +$text = "The quick brown fox jumped over the lazy dog." - Str::wordWrap($text, characters: 20, break: "Inject: alert("Hello XSS!");
+//Inject: alert("Hello XSS!");
+``` #### `mask` Метод `mask` маскирует часть строки повторяющимся символом и может использоваться для обфускации сегментов строк, таких как адреса электронной почты и номера телефонов: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $string = Str::of('taylor@example.com')->mask('*', 3); +$string = Str::of('taylor@example.com')->mask('*', 3); - // tay*************** +// tay*************** +``` При необходимости вы указываете отрицательное число в качестве третьего аргумента метода `mask`, который даст указание методу начать маскировку на заданном расстоянии от конца строки: - $string = Str::of('taylor@example.com')->mask('*', -15, 3); +```php +$string = Str::of('taylor@example.com')->mask('*', -15, 3); - // tay***@example.com +// tay***@example.com - $string = Str::of('taylor@example.com')->mask('*', 4, -4); +$string = Str::of('taylor@example.com')->mask('*', 4, -4); - // tayl**********.com +// tayl**********.com +``` #### `match` Метод `match` вернет часть строки, которая соответствует указанному шаблону регулярного выражения: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $result = Str::of('foo bar')->match('/bar/'); +$result = Str::of('foo bar')->match('/bar/'); - // 'bar' +// 'bar' - $result = Str::of('foo bar')->match('/foo (.*)/'); +$result = Str::of('foo bar')->match('/foo (.*)/'); - // 'bar' +// 'bar' +``` #### `matchAll` Метод `matchAll` вернет коллекцию, содержащую части строки, которые соответствуют указанному шаблону регулярного выражения: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $result = Str::of('bar foo bar')->matchAll('/bar/'); +$result = Str::of('bar foo bar')->matchAll('/bar/'); - // collect(['bar', 'bar']) +// collect(['bar', 'bar']) +``` Если вы укажете группировку в выражении, то Laravel вернет коллекцию совпадений первой группы соответствия: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $result = Str::of('bar fun bar fly')->matchAll('/f(\w*)/'); +$result = Str::of('bar fun bar fly')->matchAll('/f(\w*)/'); - // collect(['un', 'ly']); +// collect(['un', 'ly']); +``` Если совпадений не найдено, будет возвращена пустая коллекция. @@ -2231,154 +2827,176 @@ Str::wordCount('Hello, world!'); // 2 Метод `isMatch` вернет `true`, если строка соответствует заданному регулярному выражению: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $result = Str::of('foo bar')->isMatch('/foo (.*)/'); +$result = Str::of('foo bar')->isMatch('/foo (.*)/'); - // true +// true - $result = Str::of('laravel')->isMatch('/foo (.*)/'); +$result = Str::of('laravel')->isMatch('/foo (.*)/'); - // false +// false +``` #### `newLine` Метод `newLine` добавляет символ "конец строки" к строке: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $padded = Str::of('Laravel')->newLine()->append('Framework'); +$padded = Str::of('Laravel')->newLine()->append('Framework'); - // 'Laravel - // Framework' +// 'Laravel +// Framework' +``` #### `padBoth` Метод `padBoth` оборачивает функцию `str_pad` PHP, заполняя обе стороны строки другой строкой, пока конечная строка не достигнет желаемой длины: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $padded = Str::of('James')->padBoth(10, '_'); +$padded = Str::of('James')->padBoth(10, '_'); - // '__James___' +// '__James___' - $padded = Str::of('James')->padBoth(10); +$padded = Str::of('James')->padBoth(10); - // ' James ' +// ' James ' +``` #### `padLeft` Метод `padLeft` оборачивает функцию `str_pad` PHP, заполняя левую часть строки другой строкой, пока конечная строка не достигнет желаемой длины: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $padded = Str::of('James')->padLeft(10, '-='); +$padded = Str::of('James')->padLeft(10, '-='); - // '-=-=-James' +// '-=-=-James' - $padded = Str::of('James')->padLeft(10); +$padded = Str::of('James')->padLeft(10); - // ' James' +// ' James' +``` #### `padRight` Метод `padRight` оборачивает функцию `str_pad` PHP, заполняя правую часть строки другой строкой, пока конечная строка не достигнет желаемой длины: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $padded = Str::of('James')->padRight(10, '-'); +$padded = Str::of('James')->padRight(10, '-'); - // 'James-----' +// 'James-----' - $padded = Str::of('James')->padRight(10); +$padded = Str::of('James')->padRight(10); - // 'James ' +// 'James ' +``` #### `pipe` Метод `pipe` позволяет вам преобразовать строку, передав ее текущее значение указанной функции обратного вызова: - use Illuminate\Support\Str; - use Illuminate\Support\Stringable; +```php +use Illuminate\Support\Str; +use Illuminate\Support\Stringable; - $hash = Str::of('Laravel')->pipe('md5')->prepend('Checksum: '); +$hash = Str::of('Laravel')->pipe('md5')->prepend('Checksum: '); - // 'Checksum: a5c95b86291ea299fcbe64458ed12702' +// 'Checksum: a5c95b86291ea299fcbe64458ed12702' - $closure = Str::of('foo')->pipe(function (Stringable $str) { - return 'bar'; - }); +$closure = Str::of('foo')->pipe(function (Stringable $str) { + return 'bar'; +}); - // 'bar' +// 'bar' +``` #### `plural` Метод `plural` преобразует строку в единственном числе во множественное число. Эта функция поддерживает [любые из языков, поддерживаемых плюрализатором Laravel](/docs/{{version}}/localization#pluralization-language): - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $plural = Str::of('car')->plural(); +$plural = Str::of('car')->plural(); - // cars +// cars - $plural = Str::of('child')->plural(); +$plural = Str::of('child')->plural(); - // children +// children +``` Вы можете передать целое число в качестве второго аргумента метода для получения строки в единственном или множественном числе: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $plural = Str::of('child')->plural(2); +$plural = Str::of('child')->plural(2); - // children +// children - $plural = Str::of('child')->plural(1); +$plural = Str::of('child')->plural(1); - // child +// child +``` #### `position` Метод `position` возвращает позицию первого вхождения подстроки в строку. Если подстрока не существует внутри строки, возвращается значение `false`: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $position = Str::of('Hello, World!')->position('Hello'); +$position = Str::of('Hello, World!')->position('Hello'); - // 0 +// 0 - $position = Str::of('Hello, World!')->position('W'); +$position = Str::of('Hello, World!')->position('W'); - // 7 +// 7 +``` #### `prepend` Метод `prepend` добавляет указанные значения в начало строки: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $string = Str::of('Framework')->prepend('Laravel '); +$string = Str::of('Framework')->prepend('Laravel '); - // Laravel Framework +// Laravel Framework +``` #### `remove` Метод `remove` удаляет указанную подстроку или массив подстрок в строке: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $string = Str::of('Arkansas is quite beautiful!')->remove('quite'); +$string = Str::of('Arkansas is quite beautiful!')->remove('quite'); - // Arkansas is beautiful! +// Arkansas is beautiful! +``` Вы можете передать `false` в качестве второго аргумента для игнорирования регистра удаляемых строк. @@ -2400,459 +3018,544 @@ $repeated = Str::of('a')->repeat(5); Метод `replace` заменяет указанную строку внутри строки: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $replaced = Str::of('Laravel 6.x')->replace('6.x', '7.x'); +$replaced = Str::of('Laravel 6.x')->replace('6.x', '7.x'); - // Laravel 7.x +// Laravel 7.x +``` Метод `replace` также принимает аргумент `caseSensitive`. По умолчанию метод `replace` чувствителен к регистру: - $replaced = Str::of('macOS 13.x')->replace( - 'macOS', 'iOS', caseSensitive: false - ); +```php +$replaced = Str::of('macOS 13.x')->replace( + 'macOS', 'iOS', caseSensitive: false +); +``` #### `replaceArray` Метод `replaceArray` последовательно заменяет указанное значение в строке, используя массив: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $string = 'The event will take place between ? and ?'; +$string = 'The event will take place between ? and ?'; - $replaced = Str::of($string)->replaceArray('?', ['8:30', '9:00']); +$replaced = Str::of($string)->replaceArray('?', ['8:30', '9:00']); - // The event will take place between 8:30 and 9:00 +// The event will take place between 8:30 and 9:00 +``` #### `replaceFirst` Метод `replaceFirst` заменяет первое вхождение указанного значения в строке: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $replaced = Str::of('the quick brown fox jumps over the lazy dog')->replaceFirst('the', 'a'); +$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 quick brown fox jumps over the lazy dog +``` #### `replaceLast` Метод `replaceLast` заменяет последнее вхождение указанного значения в строке: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $replaced = Str::of('the quick brown fox jumps over the lazy dog')->replaceLast('the', 'a'); +$replaced = Str::of('the quick brown fox jumps over the lazy dog')->replaceLast('the', 'a'); - // the quick brown fox jumps over a lazy dog +// the quick brown fox jumps over a lazy dog +``` #### `replaceMatches` Метод `replaceMatches` заменяет все части строки, соответствующие указанному шаблону, переданной строки: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $replaced = Str::of('(+1) 501-555-1000')->replaceMatches('/[^A-Za-z0-9]++/', '') +$replaced = Str::of('(+1) 501-555-1000')->replaceMatches('/[^A-Za-z0-9]++/', '') - // '15015551000' +// '15015551000' +``` Метод `replaceMatches` также принимает замыкание, которое будет вызвано для каждой части строки, соответствующей шаблону, что позволяет вам выполнять логику замены в замыкании и возвращать замененное значение: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $replaced = Str::of('123')->replaceMatches('/\d/', function (array $matches) { - return '['.$matches[0].']'; - }); +$replaced = Str::of('123')->replaceMatches('/\d/', function (array $matches) { + return '['.$matches[0].']'; +}); - // '[1][2][3]' +// '[1][2][3]' +``` #### `replaceStart` Метод `replaceStart` заменяет только первое вхождение заданного значения, если значение появляется в начале строки: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $replaced = Str::of('Hello World')->replaceStart('Hello', 'Laravel'); +$replaced = Str::of('Hello World')->replaceStart('Hello', 'Laravel'); - // Laravel World +// Laravel World - $replaced = Str::of('Hello World')->replaceStart('World', 'Laravel'); +$replaced = Str::of('Hello World')->replaceStart('World', 'Laravel'); - // Hello World +// Hello World +``` #### `replaceEnd` Метод `replaceEnd` заменяет только последнее вхождение заданного значения, если значение появляется в конце строки: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $replaced = Str::of('Hello World')->replaceEnd('World', 'Laravel'); +$replaced = Str::of('Hello World')->replaceEnd('World', 'Laravel'); - // Hello Laravel +// Hello Laravel - $replaced = Str::of('Hello World')->replaceEnd('Hello', 'Laravel'); +$replaced = Str::of('Hello World')->replaceEnd('Hello', 'Laravel'); - // Hello World +// Hello World +``` #### `scan` Метод `scan` анализирует входные данные из строки в коллекцию в соответствии с форматом, поддерживаемым [`sscanf` функцией PHP](https://www.php.net/manual/ru/function.sscanf.php): - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $collection = Str::of('filename.jpg')->scan('%[^.].%s'); +$collection = Str::of('filename.jpg')->scan('%[^.].%s'); - // collect(['filename', 'jpg']) +// collect(['filename', 'jpg']) +``` #### `singular` Метод `singular` преобразует строку в ее форму единственного числа. Эта функция поддерживает [любые из языков, поддерживаемых плюрализатором Laravel](/docs/{{version}}/localization#pluralization-language): - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $singular = Str::of('cars')->singular(); +$singular = Str::of('cars')->singular(); - // car +// car - $singular = Str::of('children')->singular(); +$singular = Str::of('children')->singular(); - // child +// child +``` #### `slug` Метод `slug` создает «дружественный фрагмент» URL-адреса из переданной строки: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $slug = Str::of('Laravel Framework')->slug('-'); +$slug = Str::of('Laravel Framework')->slug('-'); - // laravel-framework +// laravel-framework +``` #### `snake` Метод `snake` преобразует переданную строку в `snake_case`: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $converted = Str::of('fooBar')->snake(); +$converted = Str::of('fooBar')->snake(); - // foo_bar +// foo_bar +``` #### `split` Метод `split` разбивает строку на коллекцию с помощью регулярного выражения: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $segments = Str::of('one, two, three')->split('/[\s,]+/'); +$segments = Str::of('one, two, three')->split('/[\s,]+/'); - // collect(["one", "two", "three"]) +// collect(["one", "two", "three"]) +``` #### `squish` Метод `squish` удаляет все лишние пробелы из строки, включая лишние пробелы между словами: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $string = Str::of(' laravel framework ')->squish(); +$string = Str::of(' laravel framework ')->squish(); - // laravel framework +// laravel framework +``` #### `start` Метод `start` добавляет один экземпляр указанного значения в переданную строку, если она еще не начинается этим значением: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $adjusted = Str::of('this/string')->start('/'); +$adjusted = Str::of('this/string')->start('/'); - // /this/string +// /this/string - $adjusted = Str::of('/this/string')->start('/'); +$adjusted = Str::of('/this/string')->start('/'); - // /this/string +// /this/string +``` #### `startsWith` Метод `startsWith` определяет, начинается ли переданная строка с указанного значения: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $result = Str::of('This is my name')->startsWith('This'); +$result = Str::of('This is my name')->startsWith('This'); - // true +// true +``` #### `stripTags` Метод `stripTags` удаляет все HTML- и PHP-теги из строки: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $result = Str::of('Taylor Otwell')->stripTags(); +$result = Str::of('Taylor Otwell')->stripTags(); - // Taylor Otwell +// Taylor Otwell - $result = Str::of('Taylor Otwell')->stripTags(''); +$result = Str::of('Taylor Otwell')->stripTags(''); - // Taylor Otwell +// Taylor Otwell +``` #### `studly` Метод `studly` преобразует переданную строку в `StudlyCase`: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $converted = Str::of('foo_bar')->studly(); +$converted = Str::of('foo_bar')->studly(); - // FooBar +// FooBar +``` #### `substr` Метод `substr` возвращает часть строки, заданную параметрами «начало» и «длина»: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $string = Str::of('Laravel Framework')->substr(8); +$string = Str::of('Laravel Framework')->substr(8); - // Framework +// Framework - $string = Str::of('Laravel Framework')->substr(8, 5); +$string = Str::of('Laravel Framework')->substr(8, 5); - // Frame +// Frame +``` #### `substrReplace` Метод `substrReplace` заменяет текст в части строки, начиная с позиции, указанной третьим аргументом, и заменяет число символов, указанное четвертым аргументом. Передав 0 четвертым аргументом в метод, строка будет вставлена в указанную позицию без замены каких-либо существующих символов в строке: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $string = Str::of('1300')->substrReplace(':', 2); +$string = Str::of('1300')->substrReplace(':', 2); - // 13: +// 13: - $string = Str::of('The Framework')->substrReplace(' Laravel', 3, 0); +$string = Str::of('The Framework')->substrReplace(' Laravel', 3, 0); - // The Laravel Framework +// The Laravel Framework +``` #### `swap` Метод `swap` заменяет несколько значений в строке с использованием функции `strtr` PHP: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $string = Str::of('Tacos are great!') - ->swap([ - 'Tacos' => 'Burritos', - 'great' => 'fantastic', - ]); +$string = Str::of('Tacos are great!') + ->swap([ + 'Tacos' => 'Burritos', + 'great' => 'fantastic', + ]); - // Burritos are fantastic! +// Burritos are fantastic! +``` #### `take` Метод `take` возвращает указанное количество символов из начала строки: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $taken = Str::of('Build something amazing!')->take(5); +$taken = Str::of('Build something amazing!')->take(5); - // Build +// Build +``` #### `tap` Метод `tap` передает строку заданному замыканию, позволяя вам взаимодействовать с ней, не затрагивая при этом саму строку. Исходная строка возвращается методом `tap` независимо от того, что возвращает замыкание: - use Illuminate\Support\Str; - use Illuminate\Support\Stringable; +```php +use Illuminate\Support\Str; +use Illuminate\Support\Stringable; - $string = Str::of('Laravel') - ->append(' Framework') - ->tap(function (Stringable $string) { - dump('String after append: '.$string); - }) - ->upper(); +$string = Str::of('Laravel') + ->append(' Framework') + ->tap(function (Stringable $string) { + dump('String after append: '.$string); + }) + ->upper(); - // LARAVEL FRAMEWORK +// LARAVEL FRAMEWORK +``` #### `test` Метод `test` определяет, соответствует ли строка переданному шаблону регулярного выражения: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $result = Str::of('Laravel Framework')->test('/Laravel/'); +$result = Str::of('Laravel Framework')->test('/Laravel/'); - // true +// true +``` #### `title` Метод `title` преобразует переданную строку в `Title Case`: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $converted = Str::of('a nice title uses the correct case')->title(); +$converted = Str::of('a nice title uses the correct case')->title(); - // A Nice Title Uses The Correct Case +// A Nice Title Uses The Correct Case +``` #### `toBase64` Метод `toBase64` преобразует переданную строку в Base64: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $base64 = Str::of('Laravel')->toBase64(); +$base64 = Str::of('Laravel')->toBase64(); - // TGFyYXZlbA== +// TGFyYXZlbA== +``` #### `toHtmlString` Метод `toHtmlString` преобразует заданную строку в экземпляр `Illuminate\Support\HtmlString`, который не будет экранирован при визуализации в шаблонах Blade: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; + +$htmlString = Str::of('Nuno Maduro')->toHtmlString(); +``` + + +#### `toUri` - $htmlString = Str::of('Nuno Maduro')->toHtmlString(); +Метод `toUri` преобразует заданную строку в экземпляр [Illuminate\Support\Uri](/docs/{{version}}/helpers#uri): + +```php +use Illuminate\Support\Str; + +$uri = Str::of('https://example.com')->toUri(); +``` #### `transliterate` Метод `transliterate` попытается преобразовать данную строку в ее ближайшее представление ASCII: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $email = Str::of('ⓣⓔⓢⓣ@ⓛⓐⓡⓐⓥⓔⓛ.ⓒⓞⓜ')->transliterate() +$email = Str::of('ⓣⓔⓢⓣ@ⓛⓐⓡⓐⓥⓔⓛ.ⓒⓞⓜ')->transliterate() - // 'test@laravel.com' +// 'test@laravel.com' +``` #### `trim` Метод `trim` обрезает переданную строку. В отличие от встроенной функции PHP `trim`, метод `trim` в Laravel также удаляет пробельные символы Юникода: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $string = Str::of(' Laravel ')->trim(); +$string = Str::of(' Laravel ')->trim(); - // 'Laravel' +// 'Laravel' - $string = Str::of('/Laravel/')->trim('/'); +$string = Str::of('/Laravel/')->trim('/'); - // 'Laravel' +// 'Laravel' +``` #### `ltrim` Метод `ltrim` обрезает левую часть строки. В отличие от встроенной функции PHP `ltrim`, метод `ltrim` в Laravel также удаляет пробельные символы Юникода: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $string = Str::of(' Laravel ')->ltrim(); +$string = Str::of(' Laravel ')->ltrim(); - // 'Laravel ' +// 'Laravel ' - $string = Str::of('/Laravel/')->ltrim('/'); +$string = Str::of('/Laravel/')->ltrim('/'); - // 'Laravel/' +// 'Laravel/' +``` #### `rtrim` {.collection-method} Метод `rtrim` обрезает правую часть заданной строки. В отличие от встроенной функции PHP `rtrim`, метод Laravel `rtrim` также удаляет пробельные символы Юникода: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $string = Str::of(' Laravel ')->rtrim(); +$string = Str::of(' Laravel ')->rtrim(); - // ' Laravel' +// ' Laravel' - $string = Str::of('/Laravel/')->rtrim('/'); +$string = Str::of('/Laravel/')->rtrim('/'); - // '/Laravel' +// '/Laravel' +``` #### `ucfirst` Метод `ucfirst` возвращает переданную строку с первой заглавной буквой: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $string = Str::of('foo bar')->ucfirst(); +$string = Str::of('foo bar')->ucfirst(); - // Foo bar +// Foo bar +``` #### `ucsplit` Метод `upper` преобразует переданную строку в верхний регистр: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $string = Str::of('Foo Bar')->ucsplit(); +$string = Str::of('Foo Bar')->ucsplit(); - // collect(['Foo', 'Bar']) +// collect(['Foo', 'Bar']) +``` #### `unwrap` Метод `unwrap` удаляет указанные строки из начала и конца заданной строки: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - Str::of('-Laravel-')->unwrap('-'); +Str::of('-Laravel-')->unwrap('-'); - // Laravel +// Laravel - Str::of('{framework: "Laravel"}')->unwrap('{', '}'); +Str::of('{framework: "Laravel"}')->unwrap('{', '}'); - // framework: "Laravel" +// framework: "Laravel" +``` #### `upper` Метод `upper` преобразует заданную строку в верхний регистр: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $adjusted = Str::of('laravel')->upper(); +$adjusted = Str::of('laravel')->upper(); - // LARAVEL +// LARAVEL +``` #### `when` Метод `when` вызывает указанное замыкание, если переданное условие истинно. Замыкание получит экземпляр Fluent: - use Illuminate\Support\Str; - use Illuminate\Support\Stringable; +```php +use Illuminate\Support\Str; +use Illuminate\Support\Stringable; - $string = Str::of('Taylor') - ->when(true, function (Stringable $string) { - return $string->append(' Otwell'); - }); +$string = Str::of('Taylor') + ->when(true, function (Stringable $string) { + return $string->append(' Otwell'); + }); - // 'Taylor Otwell' +// 'Taylor Otwell' +``` При необходимости вы можете передать другое замыкание в качестве третьего параметра методу `when`. Это замыкание будет выполнено, если параметр условия оценивается как `false`. @@ -2861,199 +3564,259 @@ $repeated = Str::of('a')->repeat(5); Метод `whenContains` вызывает данное замыкание, если строка содержит заданное значение. Замыкание получит экземпляр класса `Stringable` в качестве аргумента: - use Illuminate\Support\Str; - use Illuminate\Support\Stringable; +```php +use Illuminate\Support\Str; +use Illuminate\Support\Stringable; - $string = Str::of('tony stark') - ->whenContains('tony', function (Stringable $string) { - return $string->title(); - }); +$string = Str::of('tony stark') + ->whenContains('tony', function (Stringable $string) { + return $string->title(); + }); - // 'Tony Stark' +// 'Tony Stark' +``` При необходимости вы можете передать другое замыкание в качестве третьего параметра метода `when`. Это замыкание будет выполнено, если строка не содержит заданного значения. Вы также можете передать массив значений, чтобы определить, содержит ли данная строка какие-либо значения в массиве: - use Illuminate\Support\Str; - use Illuminate\Support\Stringable; +```php +use Illuminate\Support\Str; +use Illuminate\Support\Stringable; - $string = Str::of('tony stark') - ->whenContains(['tony', 'hulk'], function (Stringable $string) { - return $string->title(); - }); +$string = Str::of('tony stark') + ->whenContains(['tony', 'hulk'], function (Stringable $string) { + return $string->title(); + }); - // Tony Stark +// Tony Stark +``` #### `whenContainsAll` Метод `whenContainsAll` вызывает данное замыкание, если строка содержит все заданные подстроки. Замыкание получит экземпляр класса `Stringable` в качестве аргумента: - use Illuminate\Support\Str; - use Illuminate\Support\Stringable; +```php +use Illuminate\Support\Str; +use Illuminate\Support\Stringable; - $string = Str::of('tony stark') - ->whenContainsAll(['tony', 'stark'], function (Stringable $string) { - return $string->title(); - }); +$string = Str::of('tony stark') + ->whenContainsAll(['tony', 'stark'], function (Stringable $string) { + return $string->title(); + }); - // 'Tony Stark' +// 'Tony Stark' +``` При необходимости вы можете передать другое замыкание в качестве третьего параметра метода `when`. Это замыкание будет выполнено, если параметр условия оценивается как `false`. + +#### `whenDoesntEndWith` + +Метод `whenDoesntEndWith` вызывает заданное замыкание, если строка не заканчивается заданной подстрокой. Замыкание получит экземпляр текущей строки: + +```php +use Illuminate\Support\Str; +use Illuminate\Support\Stringable; + +$string = Str::of('disney world')->whenDoesntEndWith('land', function (Stringable $string) { + return $string->title(); +}); + +// 'Disney World' +``` + + +#### `whenDoesntStartWith` + +Метод `whenDoesntStartWith` вызывает заданное замыкание, если строка не начинается с заданной подстроки. Замыкание получит экземпляр текущей строки: + +```php +use Illuminate\Support\Str; +use Illuminate\Support\Stringable; + +$string = Str::of('disney world')->whenDoesntStartWith('sea', function (Stringable $string) { + return $string->title(); +}); + +// 'Disney World' +``` + #### `whenEmpty` Метод `whenEmpty` вызывает переданное замыкание, если строка пуста. Если замыкание возвращает значение, то это значение будет возвращено методом `whenEmpty`. Если замыкание не возвращает значение, будет возвращен экземпляр Fluent: - use Illuminate\Support\Str; - use Illuminate\Support\Stringable; +```php +use Illuminate\Support\Str; +use Illuminate\Support\Stringable; - $string = Str::of(' ')->whenEmpty(function (Stringable $string) { - return $string->trim()->prepend('Laravel'); - }); +$string = Str::of(' ')->trim()->whenEmpty(function (Stringable $string) { + return $string->prepend('Laravel'); +}); - // 'Laravel' +// 'Laravel' +``` #### `whenNotEmpty` Метод `whenNotEmpty` вызывает данное замыкание, если строка не пуста. Если замыкание возвращает значение, это значение также будет возвращено методом `whenNotEmpty`. Если замыкание не возвращает значение, будет возвращен экземпляр класса `Stringable`: - use Illuminate\Support\Str; - use Illuminate\Support\Stringable; +```php +use Illuminate\Support\Str; +use Illuminate\Support\Stringable; - $string = Str::of('Framework')->whenNotEmpty(function (Stringable $string) { - return $string->prepend('Laravel '); - }); +$string = Str::of('Framework')->whenNotEmpty(function (Stringable $string) { + return $string->prepend('Laravel '); +}); - // 'Laravel Framework' +// 'Laravel Framework' +``` #### `whenStartsWith` Метод `whenStartsWith` вызывает данное замыкание, если строка начинается с данной подстроки. Замыкание получит свободный экземпляр класса `Stringable` в качестве аргумента: - use Illuminate\Support\Str; - use Illuminate\Support\Stringable; +```php +use Illuminate\Support\Str; +use Illuminate\Support\Stringable; - $string = Str::of('disney world')->whenStartsWith('disney', function (Stringable $string) { - return $string->title(); - }); +$string = Str::of('disney world')->whenStartsWith('disney', function (Stringable $string) { + return $string->title(); +}); - // 'Disney World' +// 'Disney World' +``` #### `whenEndsWith` Метод `whenEndsWith` вызывает данное замыкание, если строка заканчивается заданной подстрокой. Замыкание получит свободный экземпляр строки: - use Illuminate\Support\Str; - use Illuminate\Support\Stringable; +```php +use Illuminate\Support\Str; +use Illuminate\Support\Stringable; - $string = Str::of('disney world')->whenEndsWith('world', function (Stringable $string) { - return $string->title(); - }); +$string = Str::of('disney world')->whenEndsWith('world', function (Stringable $string) { + return $string->title(); +}); - // 'Disney World' +// 'Disney World' +``` #### `whenExactly` Метод `whenExactly` вызывает данное замыкание, если строка точно соответствует заданной строке. Закрытие получит свободный экземпляр строки: - use Illuminate\Support\Str; - use Illuminate\Support\Stringable; +```php +use Illuminate\Support\Str; +use Illuminate\Support\Stringable; - $string = Str::of('laravel')->whenExactly('laravel', function (Stringable $string) { - return $string->title(); - }); +$string = Str::of('laravel')->whenExactly('laravel', function (Stringable $string) { + return $string->title(); +}); - // 'Laravel' +// 'Laravel' +``` #### `whenNotExactly` Метод `whenExactly` вызывает данное замыкание, если строка не соответствует заданной строке. Закрытие получит свободный экземпляр строки: - use Illuminate\Support\Str; - use Illuminate\Support\Stringable; +```php +use Illuminate\Support\Str; +use Illuminate\Support\Stringable; - $string = Str::of('framework')->whenNotExactly('laravel', function (Stringable $string) { - return $string->title(); - }); +$string = Str::of('framework')->whenNotExactly('laravel', function (Stringable $string) { + return $string->title(); +}); - // 'Framework' +// 'Framework' +``` #### `whenIs` Метод `whenIs` вызывает данное замыкание, если строка соответствует заданному шаблону. Звездочки могут использоваться в качестве подстановочных знаков. Замыкание получит экземпляр класса `Stringable` в качестве аргумента: - use Illuminate\Support\Str; - use Illuminate\Support\Stringable; +```php +use Illuminate\Support\Str; +use Illuminate\Support\Stringable; - $string = Str::of('foo/bar')->whenIs('foo/*', function (Stringable $string) { - return $string->append('/baz'); - }); +$string = Str::of('foo/bar')->whenIs('foo/*', function (Stringable $string) { + return $string->append('/baz'); +}); - // 'foo/bar/baz' +// 'foo/bar/baz' +``` #### `whenIsAscii` Метод `whenIsAscii` вызывает данное замыкание, если строка представляет собой 7-битный ASCII. Замыкание получит экземпляр класса `Stringable` в качестве аргумента: - use Illuminate\Support\Str; - use Illuminate\Support\Stringable; +```php +use Illuminate\Support\Str; +use Illuminate\Support\Stringable; - $string = Str::of('laravel')->whenIsAscii(function (Stringable $string) { - return $string->title(); - }); +$string = Str::of('laravel')->whenIsAscii(function (Stringable $string) { + return $string->title(); +}); - // 'Laravel' +// 'Laravel' +``` #### `whenIsUlid` Метод `whenIsUlid` вызывает заданное замыкание, если строка является допустимым ULID. Замыкание получит экземпляр класса `Stringable` в качестве аргумента: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $string = Str::of('01gd6r360bp37zj17nxb55yv40')->whenIsUlid(function (Stringable $string) { - return $string->substr(0, 8); - }); +$string = Str::of('01gd6r360bp37zj17nxb55yv40')->whenIsUlid(function (Stringable $string) { + return $string->substr(0, 8); +}); - // '01gd6r36' +// '01gd6r36' +``` #### `whenIsUuid` Метод `whenIsUuid` вызывает данное замыкание, если строка является допустимым UUID. Замыкание получит экземпляр класса `Stringable` в качестве аргумента: - use Illuminate\Support\Str; - use Illuminate\Support\Stringable; +```php +use Illuminate\Support\Str; +use Illuminate\Support\Stringable; - $string = Str::of('a0a2a2d2-0b87-4a18-83f2-2529882be2de')->whenIsUuid(function (Stringable $string) { - return $string->substr(0, 8); - }); +$string = Str::of('a0a2a2d2-0b87-4a18-83f2-2529882be2de')->whenIsUuid(function (Stringable $string) { + return $string->substr(0, 8); +}); - // 'a0a2a2d2' +// 'a0a2a2d2' +``` #### `whenTest` Метод `whenTest` вызывает данное замыкание, если строка соответствует заданному регулярному выражению. Замыкание получит экземпляр класса `Stringable` в качестве аргумента: - use Illuminate\Support\Str; - use Illuminate\Support\Stringable; +```php +use Illuminate\Support\Str; +use Illuminate\Support\Stringable; - $string = Str::of('laravel framework')->whenTest('/laravel/', function (Stringable $string) { - return $string->title(); - }); +$string = Str::of('laravel framework')->whenTest('/laravel/', function (Stringable $string) { + return $string->title(); +}); - // 'Laravel Framework' +// 'Laravel Framework' +``` #### `wordCount` @@ -3071,23 +3834,27 @@ Str::of('Hello, world!')->wordCount(); // 2 Метод `words` ограничивает количество слов в строке. Дополнительная строка может быть передана этому методу, чтобы указать, какая строка должна быть добавлена в конец усеченной строки: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - $string = Str::of('Perfectly balanced, as all things should be.')->words(3, ' >>>'); +$string = Str::of('Perfectly balanced, as all things should be.')->words(3, ' >>>'); - // Perfectly balanced, as >>> +// Perfectly balanced, as >>> +``` #### `wrap` Метод `wrap` оборачивает данную строку дополнительной строкой или парой строк: - use Illuminate\Support\Str; +```php +use Illuminate\Support\Str; - Str::of('Laravel')->wrap('"'); +Str::of('Laravel')->wrap('"'); - // "Laravel" +// "Laravel" - Str::is('is')->wrap(before: 'This ', after: ' Laravel!'); +Str::is('is')->wrap(before: 'This ', after: ' Laravel!'); - // This is Laravel! +// This is Laravel! +```