#Introducción
Laravel incluye una variedad de funciones para manipular valores de cadenas. Muchas de estas funciones son usadas por el propio framework; sin embargo, usted puede usarlas libremente en sus propias aplicaciones si las encuentra convenientes.
#Métodos disponibles
<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>#Cadenas
__ 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
#Cadenas 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
#Cadenas
#__() {.collection-method}
La función __ traduce la cadena de traducción dada o la clave de traducción usando sus archivos de idioma:
echo __('Welcome to our application');
echo __('messages.welcome');
Si la cadena de traducción o clave especificada no existe, la función __ devolverá el valor dado. Por lo tanto, usando el ejemplo anterior, la función __ devolvería messages.welcome si esa clave de traducción no existe.
#class_basename() {.collection-method}
La función class_basename devuelve el nombre de la clase dada con el espacio de nombres de la clase eliminado:
$class = class_basename('Foo\Bar\Baz');
// Baz
#e() {.collection-method}
La función e ejecuta la función htmlspecialchars de PHP con la opción double_encode establecida en true por defecto:
echo e('<html>foo</html>');
// <html>foo</html>
#preg_replace_array() {.collection-method}
La función preg_replace_array reemplaza un patrón dado en la cadena secuencialmente usando un 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}
El método Str::after devuelve todo lo que está después del valor dado en una cadena. Se devolverá la cadena completa si el valor no existe dentro de la cadena:
use Illuminate\Support\Str;
$slice = Str::after('This is my name', 'This is');
// ' my name'
#Str::afterLast() {.collection-method}
El método Str::afterLast devuelve todo lo que está después de la última aparición del valor dado en una cadena. Se devolverá la cadena completa si el valor no existe dentro de la cadena:
use Illuminate\Support\Str;
$slice = Str::afterLast('App\Http\Controllers\Controller', '\\');
// 'Controller'
#Str::apa() {.collection-method}
El método Str::apa convierte la cadena dada a formato título siguiendo las directrices APA:
use Illuminate\Support\Str;
$title = Str::apa('Creating A Project');
// 'Creating a Project'
#Str::ascii() {.collection-method}
El método Str::ascii intentará transliterar la cadena a un valor ASCII:
use Illuminate\Support\Str;
$slice = Str::ascii('û');
// 'u'
#Str::before() {.collection-method}
El método Str::before devuelve todo lo que está antes del valor dado en una cadena:
use Illuminate\Support\Str;
$slice = Str::before('This is my name', 'my name');
// 'This is '
#Str::beforeLast() {.collection-method}
El método Str::beforeLast devuelve todo lo que está antes de la última aparición del valor dado en una cadena:
use Illuminate\Support\Str;
$slice = Str::beforeLast('This is my name', 'is');
// 'This '
#Str::between() {.collection-method}
El método Str::between devuelve la porción de una cadena entre dos valores:
use Illuminate\Support\Str;
$slice = Str::between('This is my name', 'This', 'name');
// ' is my '
#Str::betweenFirst() {.collection-method}
El método Str::betweenFirst devuelve la porción más pequeña posible de una cadena entre dos valores:
use Illuminate\Support\Str;
$slice = Str::betweenFirst('[a] bc [d]', '[', ']');
// 'a'
#Str::camel() {.collection-method}
El método Str::camel convierte la cadena dada a camelCase:
use Illuminate\Support\Str;
$converted = Str::camel('foo_bar');
// 'fooBar'
#Str::charAt() {.collection-method}
El método Str::charAt devuelve el carácter en el índice especificado. Si el índice está fuera de rango, devuelve false:
use Illuminate\Support\Str;
$character = Str::charAt('This is my name.', 6);
// 's'
#Str::contains() {.collection-method}
El método Str::contains determina si la cadena dada contiene el valor dado. Este método es sensible a mayúsculas y minúsculas:
use Illuminate\Support\Str;
$contains = Str::contains('This is my name', 'my');
// true
También puede pasar un array de valores para determinar si la cadena dada contiene alguno de los valores en el array:
use Illuminate\Support\Str;
$contains = Str::contains('This is my name', ['my', 'foo']);
// true
#Str::containsAll() {.collection-method}
El método Str::containsAll determina si la cadena dada contiene todos los valores en un array dado:
use Illuminate\Support\Str;
$containsAll = Str::containsAll('This is my name', ['my', 'name']);
// true
#Str::endsWith() {.collection-method}
El método Str::endsWith determina si la cadena dada termina con el valor dado:
use Illuminate\Support\Str;
$result = Str::endsWith('This is my name', 'name');
// true
También puede pasar un array de valores para determinar si la cadena dada termina con alguno de los valores en el array:
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}
El método Str::excerpt extrae un extracto de una cadena dada que coincide con la primera instancia de una frase dentro de esa cadena:
use Illuminate\Support\Str;
$excerpt = Str::excerpt('This is my name', 'my', [
'radius' => 3
]);
// '...is my na...'
La opción radius, que por defecto es 100, le permite definir el número de caracteres que deben aparecer a cada lado de la cadena truncada.
Además, puede usar la opción omission para definir la cadena que se añadirá al principio y al final de la cadena truncada:
use Illuminate\Support\Str;
$excerpt = Str::excerpt('This is my name', 'name', [
'radius' => 3,
'omission' => '(...) '
]);
// '(...) my name'
#Str::finish() {.collection-method}
El método Str::finish añade una única instancia del valor dado a una cadena si esta no termina ya con ese valor:
use Illuminate\Support\Str;
$adjusted = Str::finish('this/string', '/');
// this/string/
$adjusted = Str::finish('this/string/', '/');
// this/string/
#Str::headline() {.collection-method}
El método Str::headline convierte cadenas delimitadas por mayúsculas, guiones o guiones bajos en una cadena delimitada por espacios con la primera letra de cada palabra en mayúscula:
use Illuminate\Support\Str;
$headline = Str::headline('steve_jobs');
// Steve Jobs
$headline = Str::headline('EmailNotificationSent');
// Email Notification Sent
#Str::inlineMarkdown() {.collection-method}
El método Str::inlineMarkdown convierte Markdown con formato GitHub en HTML inline usando CommonMark. Sin embargo, a diferencia del método markdown, no envuelve todo el HTML generado en un elemento de bloque:
use Illuminate\Support\Str;
$html = Str::inlineMarkdown('**Laravel**');
// <strong>Laravel</strong>
#Seguridad en Markdown
Por defecto, Markdown soporta HTML crudo, lo que puede exponer vulnerabilidades de Cross-Site Scripting (XSS) cuando se usa con entrada de usuario sin procesar. Según la documentación de seguridad de CommonMark, puede usar la opción html_input para escapar o eliminar HTML crudo, y la opción allow_unsafe_links para especificar si se permiten enlaces inseguros. Si necesita permitir algo de HTML crudo, debe pasar su Markdown compilado a través de un purificador de HTML:
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}
El método Str::is determina si una cadena dada coincide con un patrón dado. Se pueden usar asteriscos como comodines:
use Illuminate\Support\Str;
$matches = Str::is('foo*', 'foobar');
// true
$matches = Str::is('baz*', 'foobar');
// false
#Str::isAscii() {.collection-method}
El método Str::isAscii determina si una cadena dada es ASCII de 7 bits:
use Illuminate\Support\Str;
$isAscii = Str::isAscii('Taylor');
// true
$isAscii = Str::isAscii('ü');
// false
#Str::isJson() {.collection-method}
El método Str::isJson determina si la cadena dada es JSON válido:
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}
El método Str::isUrl determina si la cadena dada es una URL válida:
use Illuminate\Support\Str;
$isUrl = Str::isUrl('http://example.com');
// true
$isUrl = Str::isUrl('laravel');
// false
El método isUrl considera válidos una amplia gama de protocolos. Sin embargo, puede especificar los protocolos que deben considerarse válidos proporcionándolos al método isUrl:
$isUrl = Str::isUrl('http://example.com', ['http', 'https']);
#Str::isUlid() {.collection-method}
El método Str::isUlid determina si la cadena dada es un ULID válido:
use Illuminate\Support\Str;
$isUlid = Str::isUlid('01gd6r360bp37zj17nxb55yv40');
// true
$isUlid = Str::isUlid('laravel');
// false
#Str::isUuid() {.collection-method}
El método Str::isUuid determina si la cadena dada es un UUID válido:
use Illuminate\Support\Str;
$isUuid = Str::isUuid('a0a2a2d2-0b87-4a18-83f2-2529882be2de');
// true
$isUuid = Str::isUuid('laravel');
// false
#Str::kebab() {.collection-method}
El método Str::kebab convierte la cadena dada a kebab-case:
use Illuminate\Support\Str;
$converted = Str::kebab('fooBar');
// foo-bar
#Str::lcfirst() {.collection-method}
El método Str::lcfirst devuelve la cadena dada con el primer carácter en minúscula:
use Illuminate\Support\Str;
$string = Str::lcfirst('Foo Bar');
// foo Bar
#Str::length() {.collection-method}
El método Str::length devuelve la longitud de la cadena dada:
use Illuminate\Support\Str;
$length = Str::length('Laravel');
// 7
#Str::limit() {.collection-method}
El método Str::limit trunca la cadena dada a la longitud especificada:
use Illuminate\Support\Str;
$truncated = Str::limit('The quick brown fox jumps over the lazy dog', 20);
// The quick brown fox...
Puede pasar un tercer argumento al método para cambiar la cadena que se añadirá al final de la cadena truncada:
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}
El método Str::lower convierte la cadena dada a minúsculas:
use Illuminate\Support\Str;
$converted = Str::lower('LARAVEL');
// laravel
#Str::markdown() {.collection-method}
El método Str::markdown convierte Markdown con formato GitHub en HTML usando 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>
#Seguridad en Markdown
Por defecto, Markdown soporta HTML crudo, lo que puede exponer vulnerabilidades de Cross-Site Scripting (XSS) cuando se usa con entrada de usuario sin procesar. Según la documentación de seguridad de CommonMark, puede usar la opción html_input para escapar o eliminar HTML crudo, y la opción allow_unsafe_links para especificar si se permiten enlaces inseguros. Si necesita permitir algo de HTML crudo, debe pasar su Markdown compilado a través de un purificador de HTML:
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}
El método Str::mask enmascara una porción de una cadena con un carácter repetido, y puede usarse para ocultar segmentos de cadenas como direcciones de correo electrónico y números telefónicos:
use Illuminate\Support\Str;
$string = Str::mask('taylor@example.com', '*', 3);
// tay***************
Si es necesario, puede proporcionar un número negativo como tercer argumento al método mask, lo que indicará al método que comience a enmascarar a la distancia dada desde el final de la cadena:
$string = Str::mask('taylor@example.com', '*', -15, 3);
// tay***@example.com
#Str::orderedUuid() {.collection-method}
El método Str::orderedUuid genera un UUID con "timestamp primero" que puede almacenarse eficientemente en una columna indexada de base de datos. Cada UUID generado con este método se ordenará después de los UUIDs generados previamente con el método:
use Illuminate\Support\Str;
return (string) Str::orderedUuid();
#Str::padBoth() {.collection-method}
El método Str::padBoth envuelve la función str_pad de PHP, rellenando ambos lados de una cadena con otra cadena hasta que la cadena final alcance la longitud deseada:
use Illuminate\Support\Str;
$padded = Str::padBoth('James', 10, '_');
// '__James___'
$padded = Str::padBoth('James', 10);
// ' James '
#Str::padLeft() {.collection-method}
El método Str::padLeft envuelve la función str_pad de PHP, rellenando el lado izquierdo de una cadena con otra cadena hasta que la cadena final alcance la longitud deseada:
use Illuminate\Support\Str;
$padded = Str::padLeft('James', 10, '-=');
// '-=-=-James'
$padded = Str::padLeft('James', 10);
// ' James'
#Str::padRight() {.collection-method}
El método Str::padRight envuelve la función str_pad de PHP, rellenando el lado derecho de una cadena con otra cadena hasta que la cadena final alcance la longitud deseada:
use Illuminate\Support\Str;
$padded = Str::padRight('James', 10, '-');
// 'James-----'
$padded = Str::padRight('James', 10);
// 'James '
#Str::password() {.collection-method}
El método Str::password puede usarse para generar una contraseña segura y aleatoria de una longitud dada. La contraseña consistirá en una combinación de letras, números, símbolos y espacios. Por defecto, las contraseñas tienen 32 caracteres:
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}
El método Str::plural convierte una cadena de palabra en singular a su forma plural. Esta función soporta cualquiera de los idiomas soportados por el pluralizador de Laravel:
use Illuminate\Support\Str;
$plural = Str::plural('car');
// cars
$plural = Str::plural('child');
// children
Puede proporcionar un entero como segundo argumento a la función para obtener la forma singular o plural de la cadena:
use Illuminate\Support\Str;
$plural = Str::plural('child', 2);
// children
$singular = Str::plural('child', 1);
// child
#Str::pluralStudly() {.collection-method}
El método Str::pluralStudly convierte una cadena de palabra en singular formateada en studly caps a su forma plural. Esta función soporta cualquiera de los idiomas soportados por el pluralizador de Laravel:
use Illuminate\Support\Str;
$plural = Str::pluralStudly('VerifiedHuman');
// VerifiedHumans
$plural = Str::pluralStudly('UserFeedback');
// UserFeedback
Puede proporcionar un entero como segundo argumento a la función para obtener la forma singular o plural de la cadena:
use Illuminate\Support\Str;
$plural = Str::pluralStudly('VerifiedHuman', 2);
// VerifiedHumans
$singular = Str::pluralStudly('VerifiedHuman', 1);
// VerifiedHuman
#Str::position() {.collection-method}
El método Str::position devuelve la posición de la primera aparición de una subcadena en una cadena. Si la subcadena no existe en la cadena dada, devuelve false:
use Illuminate\Support\Str;
$position = Str::position('Hello, World!', 'Hello');
// 0
$position = Str::position('Hello, World!', 'W');
// 7
#Str::random() {.collection-method}
El método Str::random genera una cadena aleatoria de la longitud especificada. Esta función utiliza la función random_bytes de PHP:
use Illuminate\Support\Str;
$random = Str::random(40);
Durante las pruebas, puede ser útil "simular" el valor que devuelve el método Str::random. Para lograr esto, puede usar el método createRandomStringsUsing:
Str::createRandomStringsUsing(function () {
return 'fake-random-string';
});
Para indicar que el método random vuelva a generar cadenas aleatorias normalmente, puede invocar el método createRandomStringsNormally:
Str::createRandomStringsNormally();
#Str::remove() {.collection-method}
El método Str::remove elimina el valor dado o un array de valores de la cadena:
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.
También puede pasar false como tercer argumento al método remove para ignorar mayúsculas y minúsculas al eliminar cadenas.
#Str::repeat() {.collection-method}
El método Str::repeat repite la cadena dada:
use Illuminate\Support\Str;
$string = 'a';
$repeat = Str::repeat($string, 5);
// aaaaa
#Str::replace() {.collection-method}
El método Str::replace reemplaza una cadena dada dentro de otra cadena:
use Illuminate\Support\Str;
$string = 'Laravel 8.x';
$replaced = Str::replace('8.x', '9.x', $string);
// Laravel 9.x
El método replace también acepta un argumento caseSensitive. Por defecto, el método replace distingue entre mayúsculas y minúsculas:
Str::replace('Framework', 'Laravel', caseSensitive: false);
#Str::replaceArray() {.collection-method}
El método Str::replaceArray reemplaza un valor dado en la cadena secuencialmente usando un array:
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}
El método Str::replaceFirst reemplaza la primera ocurrencia de un valor dado en una cadena:
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}
El método Str::replaceLast reemplaza la última ocurrencia de un valor dado en una cadena:
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}
El método Str::replaceMatches reemplaza todas las partes de una cadena que coinciden con un patrón con la cadena de reemplazo dada:
use Illuminate\Support\Str;
$replaced = Str::replaceMatches(
pattern: '/[^A-Za-z0-9]++/',
replace: '',
subject: '(+1) 501-555-1000'
)
// '15015551000'
El método replaceMatches también acepta un closure que será invocado con cada parte de la cadena que coincida con el patrón dado, permitiéndole realizar la lógica de reemplazo dentro del closure y devolver el valor reemplazado:
use Illuminate\Support\Str;
$replaced = Str::replaceMatches('/\d/', function (array $matches) {
return '['.$matches[0].']';
}, '123');
// '[1][2][3]'
#Str::replaceStart() {.collection-method}
El método Str::replaceStart reemplaza la primera ocurrencia del valor dado solo si el valor aparece al inicio de la cadena:
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}
El método Str::replaceEnd reemplaza la última ocurrencia del valor dado solo si el valor aparece al final de la cadena:
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}
El método Str::reverse invierte la cadena dada:
use Illuminate\Support\Str;
$reversed = Str::reverse('Hello World');
// dlroW olleH
#Str::singular() {.collection-method}
El método Str::singular convierte una cadena a su forma singular. Esta función soporta cualquiera de los idiomas soportados por el pluralizador de Laravel:
use Illuminate\Support\Str;
$singular = Str::singular('cars');
// car
$singular = Str::singular('children');
// child
#Str::slug() {.collection-method}
El método Str::slug genera un "slug" amigable para URL a partir de la cadena dada:
use Illuminate\Support\Str;
$slug = Str::slug('Laravel 5 Framework', '-');
// laravel-5-framework
#Str::snake() {.collection-method}
El método Str::snake convierte la cadena dada a snake_case:
use Illuminate\Support\Str;
$converted = Str::snake('fooBar');
// foo_bar
$converted = Str::snake('fooBar', '-');
// foo-bar
#Str::squish() {.collection-method}
El método Str::squish elimina todos los espacios en blanco innecesarios de una cadena, incluyendo los espacios en blanco entre palabras:
use Illuminate\Support\Str;
$string = Str::squish(' laravel framework ');
// laravel framework
#Str::start() {.collection-method}
El método Str::start añade una instancia única del valor dado a una cadena si esta no comienza ya con ese valor:
use Illuminate\Support\Str;
$adjusted = Str::start('this/string', '/');
// /this/string
$adjusted = Str::start('/this/string', '/');
// /this/string
#Str::startsWith() {.collection-method}
El método Str::startsWith determina si la cadena dada comienza con el valor dado:
use Illuminate\Support\Str;
$result = Str::startsWith('This is my name', 'This');
// true
Si se pasa un array de posibles valores, el método startsWith devolverá true si la cadena comienza con cualquiera de los valores dados:
$result = Str::startsWith('This is my name', ['This', 'That', 'There']);
// true
#Str::studly() {.collection-method}
El método Str::studly convierte la cadena dada a StudlyCase:
use Illuminate\Support\Str;
$converted = Str::studly('foo_bar');
// FooBar
#Str::substr() {.collection-method}
El método Str::substr devuelve la porción de la cadena especificada por los parámetros de inicio y longitud:
use Illuminate\Support\Str;
$converted = Str::substr('The Laravel Framework', 4, 7);
// Laravel
#Str::substrCount() {.collection-method}
El método Str::substrCount devuelve el número de ocurrencias de un valor dado en la cadena dada:
use Illuminate\Support\Str;
$count = Str::substrCount('If you like ice cream, you will like snow cones.', 'like');
// 2
#Str::substrReplace() {.collection-method}
El método Str::substrReplace reemplaza texto dentro de una porción de una cadena, comenzando en la posición especificada por el tercer argumento y reemplazando el número de caracteres especificado por el cuarto argumento. Pasar 0 al cuarto argumento del método insertará la cadena en la posición especificada sin reemplazar ninguno de los caracteres existentes en la cadena:
use Illuminate\Support\Str;
$result = Str::substrReplace('1300', ':', 2);
// 13:
$result = Str::substrReplace('1300', ':', 2, 0);
// 13:00
#Str::swap() {.collection-method}
El método Str::swap reemplaza múltiples valores en la cadena dada usando la función strtr de PHP:
use Illuminate\Support\Str;
$string = Str::swap([
'Tacos' => 'Burritos',
'great' => 'fantastic',
], 'Tacos are great!');
// Burritos are fantastic!
#Str::take() {.collection-method}
El método Str::take devuelve un número especificado de caracteres desde el inicio de una cadena:
use Illuminate\Support\Str;
$taken = Str::take('Build something amazing!', 5);
// Build
#Str::title() {.collection-method}
El método Str::title convierte la cadena dada a 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}
El método Str::toBase64 convierte la cadena dada a Base64:
use Illuminate\Support\Str;
$base64 = Str::toBase64('Laravel');
// TGFyYXZlbA==
#Str::toHtmlString() {.collection-method}
El método Str::toHtmlString convierte la instancia de cadena a una instancia de Illuminate\Support\HtmlString, que puede ser mostrada en plantillas Blade:
use Illuminate\Support\Str;
$htmlString = Str::of('Nuno Maduro')->toHtmlString();
#Str::ucfirst() {.collection-method}
El método Str::ucfirst devuelve la cadena dada con el primer carácter en mayúscula:
use Illuminate\Support\Str;
$string = Str::ucfirst('foo bar');
// Foo bar
#Str::ucsplit() {.collection-method}
El método Str::ucsplit divide la cadena dada en un array por caracteres en mayúscula:
use Illuminate\Support\Str;
$segments = Str::ucsplit('FooBar');
// [0 => 'Foo', 1 => 'Bar']
#Str::upper() {.collection-method}
El método Str::upper convierte la cadena dada a mayúsculas:
use Illuminate\Support\Str;
$string = Str::upper('laravel');
// LARAVEL
#Str::ulid() {.collection-method}
El método Str::ulid genera un ULID, que es un identificador único compacto y ordenado por tiempo:
use Illuminate\Support\Str;
return (string) Str::ulid();
// 01gd6r360bp37zj17nxb55yv40
Si desea obtener una instancia de fecha Illuminate\Support\Carbon que represente la fecha y hora en que se creó un ULID dado, puede usar el método createFromId proporcionado por la integración de Carbon en Laravel:
use Illuminate\Support\Carbon;
use Illuminate\Support\Str;
$date = Carbon::createFromId((string) Str::ulid());
Durante las pruebas, puede ser útil "simular" el valor que devuelve el método Str::ulid. Para lograr esto, puede usar el método createUlidsUsing:
use Symfony\Component\Uid\Ulid;
Str::createUlidsUsing(function () {
return new Ulid('01HRDBNHHCKNW2AK4Z29SN82T9');
});
Para indicar que el método ulid vuelva a generar ULIDs normalmente, puede invocar el método createUlidsNormally:
Str::createUlidsNormally();
#Str::unwrap() {.collection-method}
El método Str::unwrap elimina las cadenas especificadas del inicio y final de una cadena dada:
use Illuminate\Support\Str;
Str::unwrap('-Laravel-', '-');
// Laravel
Str::unwrap('{framework: "Laravel"}', '{', '}');
// framework: "Laravel"
#Str::uuid() {.collection-method}
El método Str::uuid genera un UUID (versión 4):
use Illuminate\Support\Str;
return (string) Str::uuid();
Durante las pruebas, puede ser útil "simular" el valor que devuelve el método Str::uuid. Para lograr esto, puede usar el método createUuidsUsing:
use Ramsey\Uuid\Uuid;
Str::createUuidsUsing(function () {
return Uuid::fromString('eadbfeac-5258-45c2-bab7-ccb9b5ef74f9');
});
Para indicar que el método uuid vuelva a generar UUIDs normalmente, puede invocar el método createUuidsNormally:
Str::createUuidsNormally();
#Str::wordCount() {.collection-method}
El método Str::wordCount devuelve el número de palabras que contiene una cadena:
use Illuminate\Support\Str;
Str::wordCount('Hello, world!'); // 2
#Str::wordWrap() {.collection-method}
El método Str::wordWrap ajusta una cadena a un número dado de caracteres:
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}
El método Str::words limita el número de palabras en una cadena. Se puede pasar una cadena adicional a este método mediante su tercer argumento para especificar qué cadena debe añadirse al final de la cadena truncada:
use Illuminate\Support\Str;
return Str::words('Perfectly balanced, as all things should be.', 3, ' >>>');
// Perfectly balanced, as >>>
#Str::wrap() {.collection-method}
El método Str::wrap envuelve la cadena dada con una cadena adicional o un par de cadenas:
use Illuminate\Support\Str;
Str::wrap('Laravel', '"');
// "Laravel"
Str::wrap('is', before: 'This ', after: ' Laravel!');
// This is Laravel!
#str() {.collection-method}
La función str devuelve una nueva instancia de Illuminate\Support\Stringable de la cadena dada. Esta función es equivalente al método Str::of:
$string = str('Taylor')->append(' Otwell');
// 'Taylor Otwell'
Si no se proporciona ningún argumento a la función str, la función devuelve una instancia de Illuminate\Support\Str:
$snake = str()->snake('FooBar');
// 'foo_bar'
#trans() {.collection-method}
La función trans traduce la clave de traducción dada usando sus archivos de idioma:
echo trans('messages.welcome');
Si la clave de traducción especificada no existe, la función trans devolverá la clave dada. Por lo tanto, usando el ejemplo anterior, la función trans devolvería messages.welcome si la clave de traducción no existe.
#trans_choice() {.collection-method}
La función trans_choice traduce la clave de traducción dada con inflexión:
echo trans_choice('messages.notifications', $unreadCount);
Si la clave de traducción especificada no existe, la función trans_choice devolverá la clave dada. Por lo tanto, usando el ejemplo anterior, la función trans_choice devolvería messages.notifications si la clave de traducción no existe.
#Cadenas fluidas
Las cadenas fluidas proporcionan una interfaz más fluida y orientada a objetos para trabajar con valores de cadena, permitiéndole encadenar múltiples operaciones de cadena usando una sintaxis más legible en comparación con las operaciones tradicionales de cadena.
#after {.collection-method}
El método after devuelve todo lo que está después del valor dado en una cadena. Se devolverá la cadena completa si el valor no existe dentro de la cadena:
use Illuminate\Support\Str;
$slice = Str::of('This is my name')->after('This is');
// ' my name'
#afterLast {.collection-method}
El método afterLast devuelve todo lo que está después de la última ocurrencia del valor dado en una cadena. Se devolverá la cadena completa si el valor no existe dentro de la cadena:
use Illuminate\Support\Str;
$slice = Str::of('App\Http\Controllers\Controller')->afterLast('\\');
// 'Controller'
#apa {.collection-method}
El método apa convierte la cadena dada a mayúsculas de título siguiendo las directrices 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}
El método append añade los valores dados al final de la cadena:
use Illuminate\Support\Str;
$string = Str::of('Taylor')->append(' Otwell');
// 'Taylor Otwell'
#ascii {.collection-method}
El método ascii intentará transliterar la cadena a un valor ASCII:
use Illuminate\Support\Str;
$string = Str::of('ü')->ascii();
// 'u'
#basename {.collection-method}
El método basename devolverá el componente final del nombre de la cadena dada:
use Illuminate\Support\Str;
$string = Str::of('/foo/bar/baz')->basename();
// 'baz'
Si es necesario, puede proporcionar una "extensión" que será eliminada del componente final:
use Illuminate\Support\Str;
$string = Str::of('/foo/bar/baz.jpg')->basename('.jpg');
// 'baz'
#before {.collection-method}
El método before devuelve todo lo que está antes del valor dado en una cadena:
use Illuminate\Support\Str;
$slice = Str::of('This is my name')->before('my name');
// 'This is '
#beforeLast {.collection-method}
El método beforeLast devuelve todo lo que está antes de la última ocurrencia del valor dado en una cadena:
use Illuminate\Support\Str;
$slice = Str::of('This is my name')->beforeLast('is');
// 'This '
#between {.collection-method}
El método between devuelve la porción de una cadena entre dos valores:
use Illuminate\Support\Str;
$converted = Str::of('This is my name')->between('This', 'name');
// ' is my '
#betweenFirst {.collection-method}
El método betweenFirst devuelve la porción más pequeña posible de una cadena entre dos valores:
use Illuminate\Support\Str;
$converted = Str::of('[a] bc [d]')->betweenFirst('[', ']');
// 'a'
#camel {.collection-method}
El método camel convierte la cadena dada a camelCase:
use Illuminate\Support\Str;
$converted = Str::of('foo_bar')->camel();
// 'fooBar'
#charAt {.collection-method}
El método charAt devuelve el carácter en el índice especificado. Si el índice está fuera de rango, devuelve false:
use Illuminate\Support\Str;
$character = Str::of('This is my name.')->charAt(6);
// 's'
#classBasename {.collection-method}
El método classBasename devuelve el nombre de la clase dada con el espacio de nombres de la clase eliminado:
use Illuminate\Support\Str;
$class = Str::of('Foo\Bar\Baz')->classBasename();
// 'Baz'
#contains {.collection-method}
El método contains determina si la cadena dada contiene el valor dado. Este método distingue entre mayúsculas y minúsculas:
use Illuminate\Support\Str;
$contains = Str::of('This is my name')->contains('my');
// true
También puede pasar un array de valores para determinar si la cadena dada contiene alguno de los valores en el array:
use Illuminate\Support\Str;
$contains = Str::of('This is my name')->contains(['my', 'foo']);
// true
#containsAll {.collection-method}
El método containsAll determina si la cadena dada contiene todos los valores en el array dado:
use Illuminate\Support\Str;
$containsAll = Str::of('This is my name')->containsAll(['my', 'name']);
// true
#dirname {.collection-method}
El método dirname devuelve la porción del directorio padre de la cadena dada:
use Illuminate\Support\Str;
$string = Str::of('/foo/bar/baz')->dirname();
// '/foo/bar'
Si es necesario, puede especificar cuántos niveles de directorio desea recortar de la cadena:
use Illuminate\Support\Str;
$string = Str::of('/foo/bar/baz')->dirname(2);
// '/foo'
#excerpt {.collection-method}
El método excerpt extrae un extracto de la cadena que coincide con la primera instancia de una frase dentro de esa cadena:
use Illuminate\Support\Str;
$excerpt = Str::of('This is my name')->excerpt('my', [
'radius' => 3
]);
// '...is my na...'
La opción radius, que por defecto es 100, le permite definir el número de caracteres que deben aparecer a cada lado de la cadena truncada.
Además, puede usar la opción omission para cambiar la cadena que se añadirá al principio y al final de la cadena truncada:
use Illuminate\Support\Str;
$excerpt = Str::of('This is my name')->excerpt('name', [
'radius' => 3,
'omission' => '(...) '
]);
// '(...) my name'
#endsWith {.collection-method}
El método endsWith determina si la cadena dada termina con el valor dado:
use Illuminate\Support\Str;
$result = Str::of('This is my name')->endsWith('name');
// true
También puede pasar un array de valores para determinar si la cadena dada termina con alguno de los valores en el array:
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}
El método exactly determina si la cadena dada coincide exactamente con otra cadena:
use Illuminate\Support\Str;
$result = Str::of('Laravel')->exactly('Laravel');
// true
#explode {.collection-method}
El método explode divide la cadena por el delimitador dado y devuelve una colección que contiene cada sección de la cadena dividida:
use Illuminate\Support\Str;
$collection = Str::of('foo bar baz')->explode(' ');
// collect(['foo', 'bar', 'baz'])
#finish {.collection-method}
El método finish añade una instancia única del valor dado a una cadena si esta no termina ya con ese valor:
use Illuminate\Support\Str;
$adjusted = Str::of('this/string')->finish('/');
// this/string/
$adjusted = Str::of('this/string/')->finish('/');
// this/string/
#headline {.collection-method}
El método headline convierte cadenas delimitadas por mayúsculas, guiones o guiones bajos en una cadena delimitada por espacios con la primera letra de cada palabra en mayúscula:
use Illuminate\Support\Str;
$headline = Str::of('taylor_otwell')->headline();
// Taylor Otwell
$headline = Str::of('EmailNotificationSent')->headline();
// Email Notification Sent
#inlineMarkdown {.collection-method}
El método inlineMarkdown convierte Markdown con formato GitHub en HTML en línea usando CommonMark. Sin embargo, a diferencia del método markdown, no envuelve todo el HTML generado en un elemento de bloque:
use Illuminate\Support\Str;
$html = Str::of('**Laravel**')->inlineMarkdown();
// <strong>Laravel</strong>
#Markdown Security
Por defecto, Markdown soporta HTML sin procesar, lo que puede exponer vulnerabilidades de Cross-Site Scripting (XSS) cuando se usa con entrada de usuario sin procesar. Según la documentación de seguridad de CommonMark, puede usar la opción html_input para escapar o eliminar HTML sin procesar, y la opción allow_unsafe_links para especificar si se permiten enlaces inseguros. Si necesita permitir algo de HTML sin procesar, debe pasar su Markdown compilado a través de un purificador de HTML:
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}
El método is determina si una cadena dada coincide con un patrón dado. Se pueden usar asteriscos como comodines
use Illuminate\Support\Str;
$matches = Str::of('foobar')->is('foo*');
// true
$matches = Str::of('foobar')->is('baz*');
// false
#isAscii {.collection-method}
El método isAscii determina si una cadena dada es una cadena ASCII:
use Illuminate\Support\Str;
$result = Str::of('Taylor')->isAscii();
// true
$result = Str::of('ü')->isAscii();
// false
#isEmpty {.collection-method}
El método isEmpty determina si la cadena dada está vacía:
use Illuminate\Support\Str;
$result = Str::of(' ')->trim()->isEmpty();
// true
$result = Str::of('Laravel')->trim()->isEmpty();
// false
#isNotEmpty {.collection-method}
El método isNotEmpty determina si la cadena dada no está vacía:
use Illuminate\Support\Str;
$result = Str::of(' ')->trim()->isNotEmpty();
// false
$result = Str::of('Laravel')->trim()->isNotEmpty();
// true
#isJson {.collection-method}
El método isJson determina si una cadena dada es JSON válido:
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}
El método isUlid determina si una cadena dada es un ULID:
use Illuminate\Support\Str;
$result = Str::of('01gd6r360bp37zj17nxb55yv40')->isUlid();
// true
$result = Str::of('Taylor')->isUlid();
// false
#isUrl {.collection-method}
El método isUrl determina si una cadena dada es una URL:
use Illuminate\Support\Str;
$result = Str::of('http://example.com')->isUrl();
// true
$result = Str::of('Taylor')->isUrl();
// false
El método isUrl considera una amplia gama de protocolos como válidos. Sin embargo, puede especificar los protocolos que deben considerarse válidos proporcionándolos al método isUrl:
$result = Str::of('http://example.com')->isUrl(['http', 'https']);
#isUuid {.collection-method}
El método isUuid determina si una cadena dada es un UUID:
use Illuminate\Support\Str;
$result = Str::of('5ace9ab9-e9cf-4ec6-a19d-5881212a452c')->isUuid();
// true
$result = Str::of('Taylor')->isUuid();
// false
#kebab {.collection-method}
El método kebab convierte la cadena dada a kebab-case:
use Illuminate\Support\Str;
$converted = Str::of('fooBar')->kebab();
// foo-bar
#lcfirst {.collection-method}
El método lcfirst devuelve la cadena dada con el primer carácter en minúscula:
use Illuminate\Support\Str;
$string = Str::of('Foo Bar')->lcfirst();
// foo Bar
#length {.collection-method}
El método length devuelve la longitud de la cadena dada:
use Illuminate\Support\Str;
$length = Str::of('Laravel')->length();
// 7
#limit {.collection-method}
El método limit trunca la cadena dada a la longitud especificada:
use Illuminate\Support\Str;
$truncated = Str::of('The quick brown fox jumps over the lazy dog')->limit(20);
// The quick brown fox...
También puede pasar un segundo argumento para cambiar la cadena que se añadirá al final de la cadena truncada:
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}
El método lower convierte la cadena dada a minúsculas:
use Illuminate\Support\Str;
$result = Str::of('LARAVEL')->lower();
// 'laravel'
#ltrim {.collection-method}
El método ltrim recorta el lado izquierdo de la cadena:
use Illuminate\Support\Str;
$string = Str::of(' Laravel ')->ltrim();
// 'Laravel '
$string = Str::of('/Laravel/')->ltrim('/');
// 'Laravel/'
#markdown {.collection-method}
El método markdown convierte Markdown con formato GitHub en 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>
#Seguridad en Markdown
Por defecto, Markdown soporta HTML sin procesar, lo que puede exponer vulnerabilidades de Cross-Site Scripting (XSS) cuando se usa con entrada de usuario sin filtrar. Según la documentación de seguridad de CommonMark, puede usar la opción html_input para escapar o eliminar el HTML sin procesar, y la opción allow_unsafe_links para especificar si se permiten enlaces inseguros. Si necesita permitir algo de HTML sin procesar, debe pasar su Markdown compilado a través de un purificador de HTML:
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}
El método mask oculta una porción de una cadena con un carácter repetido, y puede usarse para ofuscar segmentos de cadenas como direcciones de correo electrónico y números telefónicos:
use Illuminate\Support\Str;
$string = Str::of('taylor@example.com')->mask('*', 3);
// tay***************
Si es necesario, puede proporcionar números negativos como tercer o cuarto argumento al método mask, lo que indicará que el enmascaramiento comience a la distancia dada desde el final de la cadena:
$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}
El método match devuelve la porción de una cadena que coincide con un patrón de expresión regular dado:
use Illuminate\Support\Str;
$result = Str::of('foo bar')->match('/bar/');
// 'bar'
$result = Str::of('foo bar')->match('/foo (.*)/');
// 'bar'
#matchAll {.collection-method}
El método matchAll devuelve una colección que contiene las porciones de una cadena que coinciden con un patrón de expresión regular dado:
use Illuminate\Support\Str;
$result = Str::of('bar foo bar')->matchAll('/bar/');
// collect(['bar', 'bar'])
Si especifica un grupo de coincidencia dentro de la expresión, Laravel devolverá una colección con las coincidencias de ese grupo:
use Illuminate\Support\Str;
$result = Str::of('bar fun bar fly')->matchAll('/f(\w*)/');
// collect(['un', 'ly']);
Si no se encuentran coincidencias, se devolverá una colección vacía.
#isMatch {.collection-method}
El método isMatch devolverá true si la cadena coincide con una expresión regular dada:
use Illuminate\Support\Str;
$result = Str::of('foo bar')->isMatch('/foo (.*)/');
// true
$result = Str::of('laravel')->isMatch('/foo (.*)/');
// false
#newLine {.collection-method}
El método newLine añade un carácter de "fin de línea" a una cadena:
use Illuminate\Support\Str;
$padded = Str::of('Laravel')->newLine()->append('Framework');
// 'Laravel
// Framework'
#padBoth {.collection-method}
El método padBoth envuelve la función str_pad de PHP, rellenando ambos lados de una cadena con otra cadena hasta que la cadena final alcance la longitud deseada:
use Illuminate\Support\Str;
$padded = Str::of('James')->padBoth(10, '_');
// '__James___'
$padded = Str::of('James')->padBoth(10);
// ' James '
#padLeft {.collection-method}
El método padLeft envuelve la función str_pad de PHP, rellenando el lado izquierdo de una cadena con otra cadena hasta que la cadena final alcance la longitud deseada:
use Illuminate\Support\Str;
$padded = Str::of('James')->padLeft(10, '-=');
// '-=-=-James'
$padded = Str::of('James')->padLeft(10);
// ' James'
#padRight {.collection-method}
El método padRight envuelve la función str_pad de PHP, rellenando el lado derecho de una cadena con otra cadena hasta que la cadena final alcance la longitud deseada:
use Illuminate\Support\Str;
$padded = Str::of('James')->padRight(10, '-');
// 'James-----'
$padded = Str::of('James')->padRight(10);
// 'James '
#pipe {.collection-method}
El método pipe le permite transformar la cadena pasando su valor actual al callable dado:
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}
El método plural convierte una palabra en singular a su forma plural. Esta función soporta cualquiera de los idiomas soportados por el pluralizador de Laravel:
use Illuminate\Support\Str;
$plural = Str::of('car')->plural();
// cars
$plural = Str::of('child')->plural();
// children
Puede proporcionar un entero como segundo argumento para obtener la forma singular o plural de la cadena:
use Illuminate\Support\Str;
$plural = Str::of('child')->plural(2);
// children
$plural = Str::of('child')->plural(1);
// child
#position {.collection-method}
El método position devuelve la posición de la primera aparición de una subcadena en una cadena. Si la subcadena no existe dentro de la cadena, devuelve false:
use Illuminate\Support\Str;
$position = Str::of('Hello, World!')->position('Hello');
// 0
$position = Str::of('Hello, World!')->position('W');
// 7
#prepend {.collection-method}
El método prepend antepone los valores dados a la cadena:
use Illuminate\Support\Str;
$string = Str::of('Framework')->prepend('Laravel ');
// Laravel Framework
#remove {.collection-method}
El método remove elimina el valor dado o un array de valores de la cadena:
use Illuminate\Support\Str;
$string = Str::of('Arkansas is quite beautiful!')->remove('quite');
// Arkansas is beautiful!
También puede pasar false como segundo parámetro para ignorar mayúsculas y minúsculas al eliminar cadenas.
#repeat {.collection-method}
El método repeat repite la cadena dada:
use Illuminate\Support\Str;
$repeated = Str::of('a')->repeat(5);
// aaaaa
#replace {.collection-method}
El método replace reemplaza una cadena dada dentro de la cadena:
use Illuminate\Support\Str;
$replaced = Str::of('Laravel 6.x')->replace('6.x', '7.x');
// Laravel 7.x
El método replace también acepta un argumento caseSensitive. Por defecto, el método replace es sensible a mayúsculas y minúsculas:
$replaced = Str::of('macOS 13.x')->replace(
'macOS', 'iOS', caseSensitive: false
);
#replaceArray {.collection-method}
El método replaceArray reemplaza un valor dado en la cadena secuencialmente usando un array:
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}
El método replaceFirst reemplaza la primera aparición de un valor dado en una cadena:
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}
El método replaceLast reemplaza la última aparición de un valor dado en una cadena:
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}
El método replaceMatches reemplaza todas las porciones de una cadena que coinciden con un patrón con la cadena de reemplazo dada:
use Illuminate\Support\Str;
$replaced = Str::of('(+1) 501-555-1000')->replaceMatches('/[^A-Za-z0-9]++/', '')
// '15015551000'
El método replaceMatches también acepta un closure que será invocado con cada porción de la cadena que coincida con el patrón dado, permitiéndole realizar la lógica de reemplazo dentro del closure y devolver el valor reemplazado:
use Illuminate\Support\Str;
$replaced = Str::of('123')->replaceMatches('/\d/', function (array $matches) {
return '['.$matches[0].']';
});
// '[1][2][3]'
#replaceStart {.collection-method}
El método replaceStart reemplaza la primera aparición del valor dado solo si el valor aparece al inicio de la cadena:
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}
El método replaceEnd reemplaza la última aparición del valor dado solo si el valor aparece al final de la cadena:
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}
El método rtrim recorta el lado derecho de la cadena dada:
use Illuminate\Support\Str;
$string = Str::of(' Laravel ')->rtrim();
// ' Laravel'
$string = Str::of('/Laravel/')->rtrim('/');
// '/Laravel'
#scan {.collection-method}
El método scan analiza la entrada de una cadena en una colección según un formato soportado por la función sscanf de PHP:
use Illuminate\Support\Str;
$collection = Str::of('filename.jpg')->scan('%[^.].%s');
// collect(['filename', 'jpg'])
#singular {.collection-method}
El método singular convierte una cadena a su forma singular. Esta función soporta cualquiera de los idiomas soportados por el pluralizador de Laravel:
use Illuminate\Support\Str;
$singular = Str::of('cars')->singular();
// car
$singular = Str::of('children')->singular();
// child
#slug {.collection-method}
El método slug genera un "slug" amigable para URL a partir de la cadena dada:
use Illuminate\Support\Str;
$slug = Str::of('Laravel Framework')->slug('-');
// laravel-framework
#snake {.collection-method}
El método snake convierte la cadena dada a snake_case:
use Illuminate\Support\Str;
$converted = Str::of('fooBar')->snake();
// foo_bar
#split {.collection-method}
El método split divide una cadena en una colección usando una expresión regular:
use Illuminate\Support\Str;
$segments = Str::of('one, two, three')->split('/[\s,]+/');
// collect(["one", "two", "three"])
#squish {.collection-method}
El método squish elimina todos los espacios en blanco innecesarios de una cadena, incluyendo los espacios entre palabras:
use Illuminate\Support\Str;
$string = Str::of(' laravel framework ')->squish();
// laravel framework
#start {.collection-method}
El método start añade una instancia única del valor dado a una cadena si esta no comienza ya con ese valor:
use Illuminate\Support\Str;
$adjusted = Str::of('this/string')->start('/');
// /this/string
$adjusted = Str::of('/this/string')->start('/');
// /this/string
#startsWith {.collection-method}
El método startsWith determina si la cadena dada comienza con el valor dado:
use Illuminate\Support\Str;
$result = Str::of('This is my name')->startsWith('This');
// true
#stripTags {.collection-method}
El método stripTags elimina todas las etiquetas HTML y PHP de una cadena:
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}
El método studly convierte la cadena dada a StudlyCase:
use Illuminate\Support\Str;
$converted = Str::of('foo_bar')->studly();
// FooBar
#substr {.collection-method}
El método substr devuelve la porción de la cadena especificada por los parámetros de inicio y longitud dados:
use Illuminate\Support\Str;
$string = Str::of('Laravel Framework')->substr(8);
// Framework
$string = Str::of('Laravel Framework')->substr(8, 5);
// Frame
#substrReplace {.collection-method}
El método substrReplace reemplaza texto dentro de una porción de una cadena, comenzando en la posición especificada por el segundo argumento y reemplazando el número de caracteres especificado por el tercer argumento. Pasar 0 como tercer argumento insertará la cadena en la posición especificada sin reemplazar ningún carácter existente en la cadena:
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}
El método swap reemplaza múltiples valores en la cadena usando la función strtr de PHP:
use Illuminate\Support\Str;
$string = Str::of('Tacos are great!')
->swap([
'Tacos' => 'Burritos',
'great' => 'fantastic',
]);
// Burritos are fantastic!
#take {.collection-method}
El método take devuelve un número especificado de caracteres desde el inicio de la cadena:
use Illuminate\Support\Str;
$taken = Str::of('Build something amazing!')->take(5);
// Build
#tap {.collection-method}
El método tap pasa la cadena al closure dado, permitiéndole examinar e interactuar con la cadena sin afectar la cadena original. La cadena original es devuelta por el método tap independientemente de lo que devuelva el closure:
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}
El método test determina si una cadena coincide con el patrón de expresión regular dado:
use Illuminate\Support\Str;
$result = Str::of('Laravel Framework')->test('/Laravel/');
// true
#title {.collection-method}
El método title convierte la cadena dada a 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}
El método toBase64 convierte la cadena dada a Base64:
use Illuminate\Support\Str;
$base64 = Str::of('Laravel')->toBase64();
// TGFyYXZlbA==
#trim {.collection-method}
El método trim recorta la cadena dada:
use Illuminate\Support\Str;
$string = Str::of(' Laravel ')->trim();
// 'Laravel'
$string = Str::of('/Laravel/')->trim('/');
// 'Laravel'
#ucfirst {.collection-method}
El método ucfirst devuelve la cadena dada con el primer carácter en mayúscula:
use Illuminate\Support\Str;
$string = Str::of('foo bar')->ucfirst();
// Foo bar
#ucsplit {.collection-method}
El método ucsplit divide la cadena dada en una colección por caracteres en mayúscula:
use Illuminate\Support\Str;
$string = Str::of('Foo Bar')->ucsplit();
// collect(['Foo', 'Bar'])
#unwrap {.collection-method}
El método unwrap elimina las cadenas especificadas del inicio y final de una cadena dada:
use Illuminate\Support\Str;
Str::of('-Laravel-')->unwrap('-');
// Laravel
Str::of('{framework: "Laravel"}')->unwrap('{', '}');
// framework: "Laravel"
#upper {.collection-method}
El método upper convierte la cadena dada a mayúsculas:
use Illuminate\Support\Str;
$adjusted = Str::of('laravel')->upper();
// LARAVEL
#when {.collection-method}
El método when invoca el closure dado si una condición dada es true. El closure recibirá la instancia de cadena fluida:
use Illuminate\Support\Str;
use Illuminate\Support\Stringable;
$string = Str::of('Taylor')
->when(true, function (Stringable $string) {
return $string->append(' Otwell');
});
// 'Taylor Otwell'
Si es necesario, puede pasar otro closure como tercer parámetro al método when. Este closure se ejecutará si el parámetro de condición evalúa a false.
#whenContains {.collection-method}
El método whenContains invoca el closure dado si la cadena contiene el valor dado. El closure recibirá la instancia de cadena fluida:
use Illuminate\Support\Str;
use Illuminate\Support\Stringable;
$string = Str::of('tony stark')
->whenContains('tony', function (Stringable $string) {
return $string->title();
});
// 'Tony Stark'
Si es necesario, puede pasar otro closure como tercer parámetro al método when. Este closure se ejecutará si la cadena no contiene el valor dado.
También puede pasar un array de valores para determinar si la cadena dada contiene alguno de los valores en el array:
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}
El método whenContainsAll invoca el closure dado si la cadena contiene todas las subcadenas dadas. El closure recibirá la instancia de cadena fluida:
use Illuminate\Support\Str;
use Illuminate\Support\Stringable;
$string = Str::of('tony stark')
->whenContainsAll(['tony', 'stark'], function (Stringable $string) {
return $string->title();
});
// 'Tony Stark'
Si es necesario, puede pasar otro closure como tercer parámetro al método when. Este closure se ejecutará si el parámetro de condición evalúa a false.
#whenEmpty {.collection-method}
El método whenEmpty invoca el closure dado si la cadena está vacía. Si el closure devuelve un valor, ese valor también será devuelto por el método whenEmpty. Si el closure no devuelve un valor, se devolverá la instancia de cadena fluida:
use Illuminate\Support\Str;
use Illuminate\Support\Stringable;
$string = Str::of(' ')->whenEmpty(function (Stringable $string) {
return $string->trim()->prepend('Laravel');
});
// 'Laravel'
#whenNotEmpty {.collection-method}
El método whenNotEmpty invoca el closure dado si la cadena no está vacía. Si el closure devuelve un valor, ese valor también será devuelto por el método whenNotEmpty. Si el closure no devuelve un valor, se devolverá la instancia de cadena fluida:
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}
El método whenStartsWith invoca el closure dado si la cadena comienza con la subcadena dada. El closure recibirá la instancia de cadena fluida:
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}
El método whenEndsWith invoca el closure dado si la cadena termina con la subcadena dada. El closure recibirá la instancia de cadena fluida:
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}
El método whenExactly invoca el closure dado si la cadena coincide exactamente con la cadena dada. El closure recibirá la instancia de cadena fluida:
use Illuminate\Support\Str;
use Illuminate\Support\Stringable;
$string = Str::of('laravel')->whenExactly('laravel', function (Stringable $string) {
return $string->title();
});
// 'Laravel'
#whenNotExactly {.collection-method}
El método whenNotExactly invoca el closure dado si la cadena no coincide exactamente con la cadena dada. El closure recibirá la instancia de cadena fluida:
use Illuminate\Support\Str;
use Illuminate\Support\Stringable;
$string = Str::of('framework')->whenNotExactly('laravel', function (Stringable $string) {
return $string->title();
});
// 'Framework'
#whenIs {.collection-method}
El método whenIs invoca el closure dado si la cadena coincide con un patrón dado. Se pueden usar asteriscos como comodines. El closure recibirá la instancia de cadena fluida:
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}
El método whenIsAscii invoca el closure dado si la cadena es ASCII de 7 bits. El closure recibirá la instancia de cadena fluida:
use Illuminate\Support\Str;
use Illuminate\Support\Stringable;
$string = Str::of('laravel')->whenIsAscii(function (Stringable $string) {
return $string->title();
});
// 'Laravel'
#whenIsUlid {.collection-method}
El método whenIsUlid invoca el closure dado si la cadena es un ULID válido. El closure recibirá la instancia de cadena fluida:
use Illuminate\Support\Str;
$string = Str::of('01gd6r360bp37zj17nxb55yv40')->whenIsUlid(function (Stringable $string) {
return $string->substr(0, 8);
});
// '01gd6r36'
#whenIsUuid {.collection-method}
El método whenIsUuid invoca el closure dado si la cadena es un UUID válido. El closure recibirá la instancia de cadena fluida:
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}
El método whenTest invoca el closure dado si la cadena coincide con la expresión regular dada. El closure recibirá la instancia de cadena fluida:
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}
El método wordCount devuelve el número de palabras que contiene una cadena:
use Illuminate\Support\Str;
Str::of('Hello, world!')->wordCount(); // 2
#words {.collection-method}
El método words limita el número de palabras en una cadena. Si es necesario, puede especificar una cadena adicional que se añadirá a la cadena truncada:
use Illuminate\Support\Str;
$string = Str::of('Perfectly balanced, as all things should be.')->words(3, ' >>>');
// Perfectly balanced, as >>>