#Введение
Laravel включает множество функций для работы со строками. Многие из них используются самим фреймворком, но вы можете применять их и в своих приложениях, если они вам удобны.
#Доступные методы
<style> .collection-method-list > p { columns: 10.8em 3; -moz-columns: 10.8em 3; -webkit-columns: 10.8em 3; } .collection-method-list a { display: block; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; } </style>#Строки
__ class_basename e preg_replace_array Str::after Str::afterLast Str::apa Str::ascii Str::before Str::beforeLast Str::between Str::betweenFirst Str::camel Str::charAt Str::contains Str::containsAll Str::endsWith Str::excerpt Str::finish Str::headline Str::inlineMarkdown Str::is Str::isAscii Str::isJson Str::isUlid Str::isUrl Str::isUuid Str::kebab Str::lcfirst Str::length Str::limit Str::lower Str::markdown Str::mask Str::orderedUuid Str::padBoth Str::padLeft Str::padRight Str::password Str::plural Str::pluralStudly Str::position Str::random Str::remove Str::repeat Str::replace Str::replaceArray Str::replaceFirst Str::replaceLast Str::replaceMatches Str::replaceStart Str::replaceEnd Str::reverse Str::singular Str::slug Str::snake Str::squish Str::start Str::startsWith Str::studly Str::substr Str::substrCount Str::substrReplace Str::swap Str::take Str::title Str::toBase64 Str::toHtmlString Str::ucfirst Str::ucsplit Str::upper Str::ulid Str::unwrap Str::uuid Str::wordCount Str::wordWrap Str::words Str::wrap str trans trans_choice
#Fluent строки
after afterLast apa append ascii basename before beforeLast between betweenFirst camel charAt classBasename contains containsAll dirname endsWith excerpt exactly explode finish headline inlineMarkdown is isAscii isEmpty isNotEmpty isJson isUlid isUrl isUuid kebab lcfirst length limit lower ltrim markdown mask match matchAll isMatch newLine padBoth padLeft padRight pipe plural position prepend remove repeat replace replaceArray replaceFirst replaceLast replaceMatches replaceStart replaceEnd rtrim scan singular slug snake split squish start startsWith stripTags studly substr substrReplace swap take tap test title toBase64 trim ucfirst ucsplit unwrap upper when whenContains whenContainsAll whenEmpty whenNotEmpty whenStartsWith whenEndsWith whenExactly whenNotExactly whenIs whenIsAscii whenIsUlid whenIsUuid whenTest wordCount words
#Строки
#__() {.collection-method}
Функция __ переводит заданную строку или ключ перевода, используя ваши языковые файлы:
echo __('Welcome to our application');
echo __('messages.welcome');
Если указанная строка или ключ перевода отсутствует, функция __ вернёт переданное значение. Например, в приведённом выше случае, если ключ 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>');
// <html>foo</html>
#preg_replace_array() {.collection-method}
Функция preg_replace_array последовательно заменяет заданный шаблон в строке, используя массив значений:
$string = 'The event will take place between :start and :end';
$replaced = preg_replace_array('/:[a-z_]+/', ['8:30', '9:00'], $string);
// The event will take place between 8:30 and 9:00
#Str::after() {.collection-method}
Метод Str::after возвращает всё, что находится после заданного значения в строке. Если значение отсутствует, возвращается вся строка:
use Illuminate\Support\Str;
$slice = Str::after('This is my name', 'This is');
// ' my name'
#Str::afterLast() {.collection-method}
Метод Str::afterLast возвращает всё, что находится после последнего вхождения заданного значения в строке. Если значение отсутствует, возвращается вся строка:
use Illuminate\Support\Str;
$slice = Str::afterLast('App\Http\Controllers\Controller', '\\');
// 'Controller'
#Str::apa() {.collection-method}
Метод Str::apa преобразует строку в заголовочный регистр согласно правилам APA:
use Illuminate\Support\Str;
$title = Str::apa('Creating A Project');
// 'Creating a Project'
#Str::ascii() {.collection-method}
Метод Str::ascii пытается транслитерировать строку в ASCII:
use Illuminate\Support\Str;
$slice = Str::ascii('û');
// 'u'
#Str::before() {.collection-method}
Метод Str::before возвращает всё, что находится перед заданным значением в строке:
use Illuminate\Support\Str;
$slice = Str::before('This is my name', 'my name');
// 'This is '
#Str::beforeLast() {.collection-method}
Метод Str::beforeLast возвращает всё, что находится перед последним вхождением заданного значения в строке:
use Illuminate\Support\Str;
$slice = Str::beforeLast('This is my name', 'is');
// 'This '
#Str::between() {.collection-method}
Метод Str::between возвращает часть строки между двумя значениями:
use Illuminate\Support\Str;
$slice = Str::between('This is my name', 'This', 'name');
// ' is my '
#Str::betweenFirst() {.collection-method}
Метод Str::betweenFirst возвращает наименьшую возможную часть строки между двумя значениями:
use Illuminate\Support\Str;
$slice = Str::betweenFirst('[a] bc [d]', '[', ']');
// 'a'
#Str::camel() {.collection-method}
Метод Str::camel преобразует строку в camelCase:
use Illuminate\Support\Str;
$converted = Str::camel('foo_bar');
// 'fooBar'
#Str::charAt() {.collection-method}
Метод Str::charAt возвращает символ по указанному индексу. Если индекс выходит за пределы, возвращается false:
use Illuminate\Support\Str;
$character = Str::charAt('This is my name.', 6);
// 's'
#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
#Str::containsAll() {.collection-method}
Метод Str::containsAll проверяет, содержит ли строка все значения из заданного массива:
use Illuminate\Support\Str;
$containsAll = Str::containsAll('This is my name', ['my', 'name']);
// true
#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');
// Steve Jobs
$headline = Str::headline('EmailNotificationSent');
// Email Notification Sent
#Str::inlineMarkdown() {.collection-method}
Метод Str::inlineMarkdown преобразует Markdown с поддержкой GitHub в встроенный HTML с помощью CommonMark. В отличие от метода markdown, он не оборачивает весь сгенерированный HTML в блочный элемент:
use Illuminate\Support\Str;
$html = Str::inlineMarkdown('**Laravel**');
// <strong>Laravel</strong>
#Безопасность Markdown
По умолчанию Markdown поддерживает вставку сырого HTML, что может привести к уязвимостям Cross-Site Scripting (XSS) при использовании с необработанным пользовательским вводом. Согласно документации CommonMark по безопасности, вы можете использовать опцию html_input для экранирования или удаления сырого HTML, а опцию allow_unsafe_links — для разрешения или запрета небезопасных ссылок. Если необходимо разрешить некоторый сырой HTML, следует пропускать скомпилированный Markdown через HTML Purifier:
use Illuminate\Support\Str;
Str::inlineMarkdown('Inject: <script>alert("Hello XSS!");</script>', [
'html_input' => 'strip',
'allow_unsafe_links' => false,
]);
// Inject: alert("Hello XSS!");
#Str::is() {.collection-method}
Метод Str::is определяет, соответствует ли строка заданному шаблону. В шаблонах можно использовать звёздочки как подстановочные символы:
use Illuminate\Support\Str;
$matches = Str::is('foo*', 'foobar');
// true
$matches = Str::is('baz*', 'foobar');
// false
#Str::isAscii() {.collection-method}
Метод Str::isAscii проверяет, состоит ли строка из 7-битных ASCII символов:
use Illuminate\Support\Str;
$isAscii = Str::isAscii('Taylor');
// true
$isAscii = Str::isAscii('ü');
// false
#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
#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']);
#Str::isUlid() {.collection-method}
Метод Str::isUlid проверяет, является ли строка валидным ULID:
use Illuminate\Support\Str;
$isUlid = Str::isUlid('01gd6r360bp37zj17nxb55yv40');
// true
$isUlid = Str::isUlid('laravel');
// false
#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
#Str::kebab() {.collection-method}
Метод Str::kebab преобразует строку в kebab-case:
use Illuminate\Support\Str;
$converted = Str::kebab('fooBar');
// foo-bar
#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...
Вы можете передать третий аргумент, чтобы изменить строку, добавляемую в конце усечённой строки:
use Illuminate\Support\Str;
$truncated = Str::limit('The quick brown fox jumps over the lazy dog', 20, ' (...)');
// The quick brown fox (...)
#Str::lower() {.collection-method}
Метод Str::lower преобразует строку в нижний регистр:
use Illuminate\Support\Str;
$converted = Str::lower('LARAVEL');
// laravel
#Str::markdown() {.collection-method}
Метод Str::markdown преобразует Markdown с поддержкой GitHub в HTML с помощью CommonMark:
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, что может привести к уязвимостям Cross-Site Scripting (XSS) при использовании с необработанным пользовательским вводом. Согласно документации CommonMark по безопасности, вы можете использовать опцию html_input для экранирования или удаления сырого HTML, а опцию allow_unsafe_links — для разрешения или запрета небезопасных ссылок. Если необходимо разрешить некоторый сырой HTML, следует пропускать скомпилированный Markdown через HTML Purifier:
use Illuminate\Support\Str;
Str::markdown('Inject: <script>alert("Hello XSS!");</script>', [
'html_input' => 'strip',
'allow_unsafe_links' => false,
]);
// <p>Inject: alert("Hello XSS!");</p>
#Str::mask() {.collection-method}
Метод Str::mask заменяет часть строки повторяющимся символом, что может использоваться для маскировки сегментов, например, email или телефонных номеров:
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 будет отсортирован после ранее созданных:
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);
// ' James'
#Str::padRight() {.collection-method}
Метод Str::padRight оборачивает PHP-функцию str_pad, добавляя символы справа до достижения заданной длины:
use Illuminate\Support\Str;
$padded = Str::padRight('James', 10, '-');
// 'James-----'
$padded = Str::padRight('James', 10);
// 'James '
#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'
#Str::plural() {.collection-method}
Метод Str::plural преобразует слово из единственного числа во множественное. Функция поддерживает все языки, поддерживаемые pluralizer Laravel:
use Illuminate\Support\Str;
$plural = Str::plural('car');
// cars
$plural = Str::plural('child');
// children
Вы можете передать целое число вторым аргументом, чтобы получить форму в единственном или множественном числе:
use Illuminate\Support\Str;
$plural = Str::plural('child', 2);
// children
$singular = Str::plural('child', 1);
// child
#Str::pluralStudly() {.collection-method}
Метод Str::pluralStudly преобразует слово в формате studly caps из единственного числа во множественное. Функция поддерживает все языки, поддерживаемые pluralizer Laravel:
use Illuminate\Support\Str;
$plural = Str::pluralStudly('VerifiedHuman');
// VerifiedHumans
$plural = Str::pluralStudly('UserFeedback');
// UserFeedback
Вы можете передать целое число вторым аргументом, чтобы получить форму в единственном или множественном числе:
use Illuminate\Support\Str;
$plural = Str::pluralStudly('VerifiedHuman', 2);
// VerifiedHumans
$singular = Str::pluralStudly('VerifiedHuman', 1);
// VerifiedHuman
#Str::position() {.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
#Str::replace() {.collection-method}
Метод Str::replace заменяет заданную подстроку в строке:
use Illuminate\Support\Str;
$string = 'Laravel 8.x';
$replaced = Str::replace('8.x', '9.x', $string);
// Laravel 9.x
Метод replace также принимает аргумент caseSensitive. По умолчанию метод replace чувствителен к регистру:
Str::replace('Framework', 'Laravel', caseSensitive: false);
#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
#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
#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
#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 также принимает замыкание, которое вызывается для каждой части строки, соответствующей заданному шаблону, позволяя выполнить логику замены внутри замыкания и вернуть заменённое значение:
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 преобразует строку в единственное число. Эта функция поддерживает все языки, поддерживаемые pluralizer в 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:
use Illuminate\Support\Str;
$converted = Str::snake('fooBar');
// foo_bar
$converted = Str::snake('fooBar', '-');
// foo-bar
#Str::squish() {.collection-method}
Метод Str::squish удаляет все лишние пробелы из строки, включая лишние пробелы между словами:
use Illuminate\Support\Str;
$string = Str::squish(' laravel framework ');
// laravel framework
#Str::start() {.collection-method}
Метод Str::start добавляет один экземпляр заданного значения к строке, если она ещё не начинается с этого значения:
use Illuminate\Support\Str;
$adjusted = Str::start('this/string', '/');
// /this/string
$adjusted = Str::start('/this/string', '/');
// /this/string
#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
#Str::studly() {.collection-method}
Метод Str::studly преобразует заданную строку в StudlyCase:
use Illuminate\Support\Str;
$converted = Str::studly('foo_bar');
// FooBar
#Str::substr() {.collection-method}
Метод Str::substr возвращает часть строки, указанную параметрами начала и длины:
use Illuminate\Support\Str;
$converted = Str::substr('The Laravel Framework', 4, 7);
// Laravel
#Str::substrCount() {.collection-method}
Метод Str::substrCount возвращает количество вхождений заданного значения в строку:
use Illuminate\Support\Str;
$count = Str::substrCount('If you like ice cream, you will like snow cones.', 'like');
// 2
#Str::substrReplace() {.collection-method}
Метод Str::substrReplace заменяет текст в части строки, начиная с позиции, указанной третьим аргументом, и заменяя количество символов, указанное четвёртым аргументом. Передача 0 в четвёртый аргумент вставит строку в указанную позицию без замены существующих символов:
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('Build something amazing!', 5);
// Build
#Str::title() {.collection-method}
Метод Str::title преобразует заданную строку в Title Case:
use Illuminate\Support\Str;
$converted = Str::title('a nice title uses the correct case');
// A Nice Title Uses The Correct Case
#Str::toBase64() {.collection-method}
Метод Str::toBase64 преобразует заданную строку в Base64:
use Illuminate\Support\Str;
$base64 = Str::toBase64('Laravel');
// TGFyYXZlbA==
#Str::toHtmlString() {.collection-method}
Метод Str::toHtmlString преобразует экземпляр строки в экземпляр Illuminate\Support\HtmlString, который может быть отображён в шаблонах Blade:
use Illuminate\Support\Str;
$htmlString = Str::of('Nuno Maduro')->toHtmlString();
#Str::ucfirst() {.collection-method}
Метод Str::ucfirst возвращает заданную строку с заглавной первой буквой:
use Illuminate\Support\Str;
$string = Str::ucfirst('foo bar');
// Foo bar
#Str::ucsplit() {.collection-method}
Метод Str::ucsplit разбивает заданную строку на массив по заглавным буквам:
use Illuminate\Support\Str;
$segments = Str::ucsplit('FooBar');
// [0 => 'Foo', 1 => 'Bar']
#Str::upper() {.collection-method}
Метод Str::upper преобразует заданную строку в верхний регистр:
use Illuminate\Support\Str;
$string = Str::upper('laravel');
// LARAVEL
#Str::ulid() {.collection-method}
Метод Str::ulid генерирует ULID — компактный, упорядоченный по времени уникальный идентификатор:
use Illuminate\Support\Str;
return (string) Str::ulid();
// 01gd6r360bp37zj17nxb55yv40
Если вы хотите получить экземпляр даты Illuminate\Support\Carbon, представляющий дату и время создания данного ULID, вы можете использовать метод createFromId, предоставляемый интеграцией Carbon в Laravel:
use Illuminate\Support\Carbon;
use Illuminate\Support\Str;
$date = Carbon::createFromId((string) Str::ulid());
Во время тестирования может быть полезно "подделать" значение, возвращаемое методом Str::ulid. Для этого можно использовать метод createUlidsUsing:
use Symfony\Component\Uid\Ulid;
Str::createUlidsUsing(function () {
return new Ulid('01HRDBNHHCKNW2AK4Z29SN82T9');
});
Чтобы вернуть метод ulid к обычной генерации ULID, можно вызвать метод createUlidsNormally:
Str::createUlidsNormally();
#Str::unwrap() {.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 к обычной генерации UUID, можно вызвать метод 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, если ключ перевода отсутствует.
#Fluent строки
Fluent strings предоставляют более удобный, объектно-ориентированный интерфейс для работы со строковыми значениями, позволяя объединять несколько операций со строками в цепочку с более читаемым синтаксисом по сравнению с традиционными операциями со строками.
#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'
#contains {.collection-method}
Метод contains определяет, содержит ли заданная строка указанное значение. Метод чувствителен к регистру:
use Illuminate\Support\Str;
$contains = Str::of('This is my name')->contains('my');
// true
Вы также можете передать массив значений, чтобы проверить, содержит ли строка любое из значений массива:
use Illuminate\Support\Str;
$contains = Str::of('This is my name')->contains(['my', 'foo']);
// true
#containsAll {.collection-method}
Метод containsAll определяет, содержит ли заданная строка все значения из переданного массива:
use Illuminate\Support\Str;
$containsAll = Str::of('This is my name')->containsAll(['my', 'name']);
// true
#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);
// '/foo'
#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'
#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
#explode {.collection-method}
Метод explode разбивает строку по заданному разделителю и возвращает коллекцию, содержащую каждую часть разделённой строки:
use Illuminate\Support\Str;
$collection = Str::of('foo bar baz')->explode(' ');
// collect(['foo', 'bar', 'baz'])
#finish {.collection-method}
Метод 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 преобразует Markdown с поддержкой GitHub в встроенный HTML с использованием CommonMark. Однако, в отличие от метода markdown, он не оборачивает весь сгенерированный HTML в блочный элемент:
use Illuminate\Support\Str;
$html = Str::of('**Laravel**')->inlineMarkdown();
// <strong>Laravel</strong>
#Markdown Security
По умолчанию Markdown поддерживает необработанный HTML, что может привести к уязвимостям Cross-Site Scripting (XSS) при использовании с необработанным пользовательским вводом. Согласно документации CommonMark по безопасности, вы можете использовать опцию html_input для экранирования или удаления необработанного HTML, а опцию allow_unsafe_links для указания, разрешать ли небезопасные ссылки. Если нужно разрешить некоторый необработанный HTML, следует пропустить скомпилированный Markdown через HTML Purifier:
use Illuminate\Support\Str;
Str::of('Inject: <script>alert("Hello XSS!");</script>')->inlineMarkdown([
'html_input' => 'strip',
'allow_unsafe_links' => false,
]);
// Inject: alert("Hello XSS!");
#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();
// false
Метод isUrl считает допустимыми URL с широким набором протоколов. Однако вы можете указать, какие протоколы считать допустимыми, передав их в метод 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...
Вы также можете передать второй аргумент, чтобы изменить строку, которая будет добавлена в конце усечённой строки:
use Illuminate\Support\Str;
$truncated = Str::of('The quick brown fox jumps over the lazy dog')->limit(20, ' (...)');
// The quick brown fox (...)
#lower {.collection-method}
Метод lower преобразует строку в нижний регистр:
use Illuminate\Support\Str;
$result = Str::of('LARAVEL')->lower();
// 'laravel'
#ltrim {.collection-method}
Метод ltrim обрезает пробелы слева в строке:
use Illuminate\Support\Str;
$string = Str::of(' Laravel ')->ltrim();
// 'Laravel '
$string = Str::of('/Laravel/')->ltrim('/');
// 'Laravel/'
#markdown {.collection-method}
Метод markdown преобразует Markdown с поддержкой GitHub в 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, что может привести к уязвимостям Cross-Site Scripting (XSS) при использовании с необработанным пользовательским вводом. Согласно документации CommonMark по безопасности, вы можете использовать опцию html_input для экранирования или удаления сырого HTML, а опцию allow_unsafe_links для указания, разрешать ли небезопасные ссылки. Если необходимо разрешить некоторый сырой HTML, следует пропустить скомпилированный Markdown через HTML Purifier:
use Illuminate\Support\Str;
Str::of('Inject: <script>alert("Hello XSS!");</script>')->markdown([
'html_input' => 'strip',
'allow_unsafe_links' => false,
]);
// <p>Inject: alert("Hello XSS!");</p>
#mask {.collection-method}
Метод mask маскирует часть строки повторяющимся символом и может использоваться для сокрытия сегментов строк, таких как адреса электронной почты и номера телефонов:
use Illuminate\Support\Str;
$string = Str::of('taylor@example.com')->mask('*', 3);
// tay***************
При необходимости вы можете передать отрицательные числа в качестве третьего или четвёртого аргумента метода mask, чтобы начать маскировку с указанного расстояния от конца строки:
$string = Str::of('taylor@example.com')->mask('*', -15, 3);
// tay***@example.com
$string = Str::of('taylor@example.com')->mask('*', 4, -4);
// tayl**********.com
#match {.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 '
#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'
#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 '
#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'
#plural {.collection-method}
Метод plural преобразует слово в единственном числе в форму множественного числа. Функция поддерживает все языки, поддерживаемые pluralizer в Laravel:
use Illuminate\Support\Str;
$plural = Str::of('car')->plural();
// cars
$plural = Str::of('child')->plural();
// children
Вы можете передать целое число вторым аргументом, чтобы получить форму единственного или множественного числа:
use Illuminate\Support\Str;
$plural = Str::of('child')->plural(2);
// children
$plural = Str::of('child')->plural(1);
// child
#position {.collection-method}
Метод position возвращает позицию первого вхождения подстроки в строку. Если подстрока не найдена, возвращается false:
use Illuminate\Support\Str;
$position = Str::of('Hello, World!')->position('Hello');
// 0
$position = Str::of('Hello, World!')->position('W');
// 7
#prepend {.collection-method}
Метод prepend добавляет заданное значение в начало строки:
use Illuminate\Support\Str;
$string = Str::of('Framework')->prepend('Laravel ');
// Laravel Framework
#remove {.collection-method}
Метод remove удаляет заданное значение или массив значений из строки:
use Illuminate\Support\Str;
$string = Str::of('Arkansas is quite beautiful!')->remove('quite');
// Arkansas is beautiful!
Вы также можете передать false вторым параметром, чтобы игнорировать регистр при удалении строк.
#repeat {.collection-method}
Метод repeat повторяет заданную строку:
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']);
// The event will take place between 8:30 and 9:00
#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
#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
#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]'
#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
#replaceEnd {.collection-method}
Метод replaceEnd заменяет последнее вхождение заданного значения только если оно находится в конце строки:
use Illuminate\Support\Str;
$replaced = Str::of('Hello World')->replaceEnd('World', 'Laravel');
// Hello Laravel
$replaced = Str::of('Hello World')->replaceEnd('Hello', 'Laravel');
// Hello World
#rtrim {.collection-method}
Метод rtrim обрезает пробелы справа в строке:
use Illuminate\Support\Str;
$string = Str::of(' Laravel ')->rtrim();
// ' Laravel'
$string = Str::of('/Laravel/')->rtrim('/');
// '/Laravel'
#scan {.collection-method}
Метод scan разбирает входную строку в коллекцию согласно формату, поддерживаемому функцией PHP sscanf:
use Illuminate\Support\Str;
$collection = Str::of('filename.jpg')->scan('%[^.].%s');
// collect(['filename', 'jpg'])
#singular {.collection-method}
Метод singular преобразует строку в форму единственного числа. Функция поддерживает все языки, поддерживаемые pluralizer в 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() {.collection-method}
Метод toBase64 преобразует строку в Base64:
use Illuminate\Support\Str;
$base64 = Str::of('Laravel')->toBase64();
// TGFyYXZlbA==
#trim {.collection-method}
Метод trim обрезает пробелы с обеих сторон строки:
use Illuminate\Support\Str;
$string = Str::of(' Laravel ')->trim();
// 'Laravel'
$string = Str::of('/Laravel/')->trim('/');
// 'Laravel'
#ucfirst {.collection-method}
Метод 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. Замыкание получит экземпляр fluent строки:
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 вызывает заданное замыкание, если строка содержит заданное значение. Замыкание получит экземпляр fluent строки:
use Illuminate\Support\Str;
use Illuminate\Support\Stringable;
$string = Str::of('tony stark')
->whenContains('tony', function (Stringable $string) {
return $string->title();
});
// 'Tony Stark'
При необходимости вы можете передать другое замыкание третьим параметром методу 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 вызывает заданное замыкание, если строка содержит все указанные подстроки. Замыкание получит экземпляр fluent строки:
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. Если замыкание не возвращает значение, будет возвращён экземпляр fluent строки:
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. Если замыкание не возвращает значение, будет возвращён экземпляр fluent строки:
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 вызывает заданное замыкание, если строка начинается с указанной подстроки. Замыкание получит экземпляр fluent строки:
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 вызывает заданное замыкание, если строка заканчивается указанной подстрокой. Замыкание получит экземпляр fluent строки:
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 вызывает заданное замыкание, если строка точно совпадает с заданной строкой. Замыкание получит экземпляр fluent строки:
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 вызывает заданное замыкание, если строка не совпадает точно с заданной строкой. Замыкание получит экземпляр fluent строки:
use Illuminate\Support\Str;
use Illuminate\Support\Stringable;
$string = Str::of('framework')->whenNotExactly('laravel', function (Stringable $string) {
return $string->title();
});
// 'Framework'
#whenIs {.collection-method}
Метод whenIs вызывает заданное замыкание, если строка соответствует заданному шаблону. В шаблоне можно использовать символы подстановки (*). Замыкание получит экземпляр fluent строки:
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 символов. Замыкание получит экземпляр fluent-строки:
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. Замыкание получит экземпляр fluent-строки:
use Illuminate\Support\Str;
$string = Str::of('01gd6r360bp37zj17nxb55yv40')->whenIsUlid(function (Stringable $string) {
return $string->substr(0, 8);
});
// '01gd6r36'
#whenIsUuid {.collection-method}
Метод whenIsUuid вызывает переданный замыкание, если строка является валидным UUID. Замыкание получит экземпляр fluent-строки:
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 вызывает переданный замыкание, если строка соответствует заданному регулярному выражению. Замыкание получит экземпляр fluent-строки:
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 >>>