Cadenas en Laravel 10.x: Guía y Ejemplos

Introducción
Métodos disponibles

Introducción

Laravel incluye una variedad de funciones para manipular valores de cadena. Muchas de estas funciones son utilizadas por el propio framework; sin embargo, eres libre de usarlas en tus propias aplicaciones si las encuentras convenientes.

Métodos disponibles

Cadenas

__ class_basename e preg_replace_array Str::after Str::afterLast Str::ascii Str::before Str::beforeLast Str::between Str::betweenFirst Str::camel 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::toHtmlString Str::ucfirst Str::ucsplit Str::upper Str::ulid Str::uuid Str::wordCount Str::wordWrap Str::words Str::wrap str trans trans_choice

Cadenas fluidas

Cadenas

`__()`

La función __ traduce la cadena de traducción o la clave de traducción dada utilizando tus archivos de idioma:

echo __('Welcome to our application');
echo __('messages.welcome');

Si la cadena de traducción o la clave especificada no existe, la función __ devolverá el valor dado. Así, utilizando el ejemplo anterior, la función __ devolvería messages.welcome si esa clave de traducción no existe.

`class_basename()`

La función class_basename devuelve el nombre de la clase de la clase dada con el espacio de nombres de la clase eliminado:

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

`e()`

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>');
// &lt;html&gt;foo&lt;/html&gt;

`preg_replace_array()`

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

El método Str::after devuelve todo después del valor dado en una cadena. Se devolverá toda la cadena 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()`

El método Str::afterLast devuelve todo después de la última ocurrencia del valor dado en una cadena. Se devolverá toda la cadena si el valor no existe dentro de la cadena:

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

`Str::ascii()`

El método Str::ascii intentará transliterar la cadena a un valor ASCII:

use Illuminate\Support\Str;
$slice = Str::ascii('û');
// 'u'

`Str::before()`

El método Str::before devuelve todo antes del valor dado en una cadena:

use Illuminate\Support\Str;
$slice = Str::before('This is my name', 'my name');
// 'This is '

`Str::beforeLast()`

El método Str::beforeLast devuelve todo antes de la última ocurrencia del valor dado en una cadena:

use Illuminate\Support\Str;
$slice = Str::beforeLast('This is my name', 'is');
// 'This '

`Str::between()`

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

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

El método Str::camel convierte la cadena dada a camelCase:

use Illuminate\Support\Str;
$converted = Str::camel('foo_bar');
// fooBar

`Str::contains()`

El método Str::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::contains('This is my name', 'my');
// true

También puedes 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()`

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

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 puedes 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()`

El método Str::excerpt extrae un fragmento 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 tiene un valor predeterminado de 100, te permite definir la cantidad de caracteres que deben aparecer en cada lado de la cadena truncada.

Además, puedes 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()`

El método Str::finish agrega una sola instancia del valor dado a una cadena si aún no termina con ese valor:

use Illuminate\Support\Str;
$adjusted = Str::finish('this/string', '/');
// this/string/
$adjusted = Str::finish('this/string/', '/');
// this/string/

`Str::headline()`

El método Str::headline convertirá 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()`

El método Str::inlineMarkdown convierte el Markdown con formato de 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::inlineMarkdown('**Laravel**');
// <strong>Laravel</strong>

`Str::is()`

El método Str::is determina si una cadena dada coincide con un patrón dado. Los asteriscos se pueden utilizar como valores comodín:

use Illuminate\Support\Str;
$matches = Str::is('foo*', 'foobar');
// true
$matches = Str::is('baz*', 'foobar');
// false

`Str::isAscii()`

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

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

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

`Str::isUlid()`

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

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

El método Str::kebab convierte la cadena dada a kebab-case:

use Illuminate\Support\Str;
$converted = Str::kebab('fooBar');
// foo-bar

`Str::lcfirst()`

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

El método Str::length devuelve la longitud de la cadena dada:

use Illuminate\Support\Str;
$length = Str::length('Laravel');
// 7

`Str::limit()`

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

Puedes 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()`

El método Str::lower convierte la cadena dada a minúsculas:

use Illuminate\Support\Str;
$converted = Str::lower('LARAVEL');
// laravel

`Str::markdown()`

El método Str::markdown convierte el Markdown con formato de 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>

`Str::mask()`

El método Str::mask enmascara una porción de una cadena con un carácter repetido, y se puede utilizar para ocultar segmentos de cadenas como direcciones de correo electrónico y números de teléfono:

use Illuminate\Support\Str;
$string = Str::mask('[email protected]', '*', 3);
// tay***************

Si es necesario, puedes 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('[email protected]', '*', -15, 3);
// tay***@example.com

`Str::orderedUuid()`

El método Str::orderedUuid genera un UUID de "timestamp first" que se puede almacenar de manera eficiente en una columna de base de datos indexada. Cada UUID generado mediante este método se ordenará después de los UUID generados previamente mediante el método:

use Illuminate\Support\Str;
return (string) Str::orderedUuid();

`Str::padBoth()`

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 alcanza una longitud deseada:

use Illuminate\Support\Str;
$padded = Str::padBoth('James', 10, '_');
// '__James___'
$padded = Str::padBoth('James', 10);
// '  James   '

`Str::padLeft()`

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 alcanza una longitud deseada:

use Illuminate\Support\Str;
$padded = Str::padLeft('James', 10, '-=');
// '-=-=-James'
$padded = Str::padLeft('James', 10);
// '     James'

`Str::padRight()`

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 alcanza una longitud deseada:

use Illuminate\Support\Str;
$padded = Str::padRight('James', 10, '-');
// 'James-----'
$padded = Str::padRight('James', 10);
// 'James     '

`Str::password()`

El método Str::password se puede usar 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 de longitud:

use Illuminate\Support\Str;
$password = Str::password();
// 'EbJo2vE-AS:U,$%_gkrV4n,q~1xy/-_4'
$password = Str::password(12);
// 'qwuar>#V|i]N'

`Str::plural()`

El método Str::plural convierte una cadena de palabra singular a su forma plural. Esta función admite cualquiera de los idiomas admitidos por el pluralizador de Laravel:

use Illuminate\Support\Str;
$plural = Str::plural('car');
// cars
$plural = Str::plural('child');
// children

Puedes 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()`

El método Str::pluralStudly convierte una cadena de palabra singular formateada en studly caps case a su forma plural. Esta función admite cualquiera de los idiomas admitidos por el pluralizador de Laravel:

use Illuminate\Support\Str;
$plural = Str::pluralStudly('VerifiedHuman');
// VerifiedHumans
$plural = Str::pluralStudly('UserFeedback');
// UserFeedback

Puedes 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()`

El método Str::position devuelve la posición de la primera ocurrencia de una subcadena en una cadena. Si la subcadena no existe en la cadena dada, se devuelve false:

use Illuminate\Support\Str;
$position = Str::position('Hello, World!', 'Hello');
// 0
$position = Str::position('Hello, World!', 'W');
// 7

`Str::random()`

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

`Str::remove()`

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 puedes pasar false como tercer argumento al método remove para ignorar mayúsculas y minúsculas al eliminar cadenas.

`Str::repeat()`

El método Str::repeat repite la cadena dada:

use Illuminate\Support\Str;
$string = 'a';
$repeat = Str::repeat($string, 5);
// aaaaa

`Str::replace()`

El método Str::replace reemplaza una cadena dada dentro de la 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()`

El método Str::replaceArray reemplaza un valor dado en la cadena secuencialmente utilizando un array:

use Illuminate\Support\Str;
$string = 'The event will take place between ? and ?';
$replaced = Str::replaceArray('?', ['8:30', '9:00'], $string);
// El evento tendrá lugar entre las 8:30 y las 9:00

`Str::replaceFirst()`

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');
// un rápido zorro marrón salta sobre el perro perezoso

`Str::replaceLast()`

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');
// el rápido zorro marrón salta sobre un perro perezoso

`Str::replaceMatches()`

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 cierre que se invocará con cada parte de la cadena que coincida con el patrón dado, permitiéndote realizar la lógica de reemplazo dentro del cierre 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()`

El método Str::replaceStart reemplaza la primera ocurrencia del valor dado solo si el valor aparece al principio 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()`

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

El método Str::reverse invierte la cadena dada:

use Illuminate\Support\Str;
$reversed = Str::reverse('Hello World');
// dlroW olleH

`Str::singular()`

El método Str::singular convierte una cadena a su forma singular. Esta función admite cualquiera de los idiomas admitidos por el pluralizador de Laravel:

use Illuminate\Support\Str;
$singular = Str::singular('cars');
// car
$singular = Str::singular('children');
// child

`Str::slug()`

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

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

El método Str::squish elimina todos los espacios en blanco superfluos de una cadena, incluidos los espacios en blanco superfluos entre palabras:

use Illuminate\Support\Str;
$string = Str::squish('    laravel    framework    ');
// laravel framework

`Str::start()`

El método Str::start agrega una única instancia del valor dado a una cadena si aún no comienza con ese valor:

use Illuminate\Support\Str;
$adjusted = Str::start('this/string', '/');
// /this/string
$adjusted = Str::start('/this/string', '/');
// /this/string

`Str::startsWith()`

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 valores posibles, el método startsWith devolverá true si la cadena comienza con alguno de los valores dados:

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

`Str::studly()`

El método Str::studly convierte la cadena dada a StudlyCase:

use Illuminate\Support\Str;
$converted = Str::studly('foo_bar');
// FooBar

`Str::substr()`

El método Str::substr devuelve la porción de 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()`

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

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

El método Str::swap reemplaza múltiples valores en la cadena dada utilizando 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()`

El método Str::take devuelve un número especificado de caracteres desde el principio de una cadena:

use Illuminate\Support\Str;
$taken = Str::take('Build something amazing!', 5);
// Build

`Str::title()`

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

El método Str::toHtmlString convierte la instancia de cadena en una instancia de Illuminate\Support\HtmlString, que se puede mostrar en plantillas de Blade:

use Illuminate\Support\Str;
$htmlString = Str::of('Nuno Maduro')->toHtmlString();

`Str::ucfirst()`

El método Str::ucfirst devuelve la cadena dada con la primera letra en mayúscula:

use Illuminate\Support\Str;
$string = Str::ucfirst('foo bar');
// Foo bar

`Str::ucsplit()`

El método Str::ucsplit divide la cadena dada en un array por caracteres en mayúsculas:

use Illuminate\Support\Str;
$segments = Str::ucsplit('FooBar');
// [0 => 'Foo', 1 => 'Bar']

`Str::upper()`

El método Str::upper convierte la cadena dada a mayúsculas:

use Illuminate\Support\Str;
$string = Str::upper('laravel');
// LARAVEL

`Str::ulid()`

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 recuperar 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 de Laravel:

use Illuminate\Support\Carbon;
use Illuminate\Support\Str;
$date = Carbon::createFromId((string) Str::ulid());

`Str::uuid()`

El método Str::uuid genera un UUID (versión 4):

use Illuminate\Support\Str;
return (string) Str::uuid();

`Str::wordCount()`

El método Str::wordCount devuelve la cantidad de palabras que contiene una cadena:

use Illuminate\Support\Str;
Str::wordCount('Hello, world!'); // 2

`Str::wordWrap()`

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

El método Str::words limita la cantidad de palabras en una cadena. Se puede pasar una cadena adicional a este método mediante su tercer argumento para especificar qué cadena se debe agregar 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()`

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

La función str devuelve una nueva instancia 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()`

La función trans traduce la clave de traducción dada utilizando 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. Así, usando el ejemplo anterior, la función trans devolvería messages.welcome si la clave de traducción no existe.

`trans_choice()`

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. Así, 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, lo que le permite encadenar múltiples operaciones de cadena utilizando una sintaxis más legible en comparación con las operaciones de cadena tradicionales.

`after`

El método after devuelve todo después del valor dado en una cadena. Se devolverá toda la cadena 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`

El método afterLast devuelve todo después de la última ocurrencia del valor dado en una cadena. Se devolverá toda la cadena si el valor no existe dentro de la cadena:

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

`append`

El método append agrega los valores dados a la cadena:

use Illuminate\Support\Str;
$string = Str::of('Taylor')->append(' Otwell');
// 'Taylor Otwell'

`ascii`

El método ascii intentará transliterar la cadena a un valor ASCII:

use Illuminate\Support\Str;
$string = Str::of('ü')->ascii();
// 'u'

`basename`

El método basename devolverá el componente de nombre final 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 se eliminará del componente final:

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

`before`

El método before devuelve todo antes del valor dado en una cadena:

use Illuminate\Support\Str;
$slice = Str::of('This is my name')->before('my name');
// 'This is '

`beforeLast`

El método beforeLast devuelve todo 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`

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`

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`

El método camel convierte la cadena dada a camelCase:

use Illuminate\Support\Str;
$converted = Str::of('foo_bar')->camel();
// fooBar

`classBasename`

El método classBasename devuelve el nombre de la clase 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`

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`

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`

El método dirname devuelve la parte del directorio principal 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`

El método excerpt extrae un fragmento 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 la cantidad de caracteres que deben aparecer en cada lado de la cadena truncada.

Además, puede usar la opción omission para cambiar la cadena que se agregará 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`

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`

El método exactly determina si la cadena dada es una coincidencia exacta con otra cadena:

use Illuminate\Support\Str;
$result = Str::of('Laravel')->exactly('Laravel');
// true

`explode`

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`

El método finish agrega una única instancia del valor dado a una cadena si aún no termina con ese valor:

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

`headline`

El método headline convertirá 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();
// Notificación de correo electrónico enviada

`inlineMarkdown`

El método inlineMarkdown convierte el Markdown con formato GitHub en HTML en línea utilizando CommonMark. Sin embargo, a diferencia del método markdown, no envuelve todo el HTML generado en un elemento de nivel de bloque:

use Illuminate\Support\Str;
$html = Str::of('**Laravel**')->inlineMarkdown();
// <strong>Laravel</strong>

`is`

El método is determina si una cadena dada coincide con un patrón dado. Se pueden usar asteriscos como valores comodín

use Illuminate\Support\Str;
$matches = Str::of('foobar')->is('foo*');
// true
$matches = Str::of('foobar')->is('baz*');
// false

`isAscii`

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`

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`

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`

El método isJson determina si una cadena dada es un 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`

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`

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

`isUuid`

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`

El método kebab convierte la cadena dada a kebab-case:

use Illuminate\Support\Str;
$converted = Str::of('fooBar')->kebab();
// foo-bar

`lcfirst`

El método lcfirst devuelve la cadena dada con la primera letra en minúscula:

use Illuminate\Support\Str;
$string = Str::of('Foo Bar')->lcfirst();
// foo Bar

`length`

El método length devuelve la longitud de la cadena dada:

use Illuminate\Support\Str;
$length = Str::of('Laravel')->length();
// 7

`limit`

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 puedes pasar un segundo argumento para cambiar la cadena que se agregará 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`

El método lower convierte la cadena dada a minúsculas:

use Illuminate\Support\Str;
$result = Str::of('LARAVEL')->lower();
// 'laravel'

`ltrim`

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`

El método markdown convierte el 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>

`mask`

El método mask enmascara una porción de una cadena con un carácter repetido, y se puede usar para ocultar segmentos de cadenas como direcciones de correo electrónico y números de teléfono:

use Illuminate\Support\Str;
$string = Str::of('[email protected]')->mask('*', 3);
// tay***************

Si es necesario, puedes proporcionar números negativos como tercer o cuarto argumento al método mask, lo que indicará al método que comience a enmascarar en la distancia dada desde el final de la cadena:

$string = Str::of('[email protected]')->mask('*', -15, 3);
// tay***@example.com
$string = Str::of('[email protected]')->mask('*', 4, -4);
// tayl**********.com

`match`

El método match devolverá la porción de una cadena que coincide con un patrón dado de expresión regular:

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

`matchAll`

El método matchAll devolverá una colección que contiene las porciones de una cadena que coinciden con un patrón dado de expresión regular:

use Illuminate\Support\Str;
$result = Str::of('bar foo bar')->matchAll('/bar/');
// collect(['bar', 'bar'])

Si especificas un grupo de coincidencia dentro de la expresión, Laravel devolverá una colección de 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`

El método isMatch devolverá true si la cadena coincide con un patrón de expresión regular dado:

use Illuminate\Support\Str;
$result = Str::of('foo bar')->isMatch('/foo (.*)/');
// true
$result = Str::of('laravel')->isMatch('/foo (.*)/');
// false

`newLine`

El método newLine agrega 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`

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`

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`

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`

El método pipe te permite transformar la cadena pasando su valor actual a la función de devolución de llamada dada:

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`

El método plural convierte una cadena de palabra singular a su forma plural. Esta función es compatible con cualquiera de los idiomas admitidos por el pluralizador de Laravel:

use Illuminate\Support\Str;
$plural = Str::of('car')->plural();
// cars
$plural = Str::of('child')->plural();
// children

Puedes proporcionar un entero como segundo argumento a la función para recuperar 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`

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, se devuelve false:

use Illuminate\Support\Str;
$position = Str::of('Hello, World!')->position('Hello');
// 0
$position = Str::of('Hello, World!')->position('W');
// 7

`prepend`

El método prepend agrega los valores dados a la cadena:

use Illuminate\Support\Str;
$string = Str::of('Framework')->prepend('Laravel ');
// Laravel Framework

`remove`

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 puedes pasar false como segundo parámetro para ignorar mayúsculas al eliminar cadenas.

`repeat`

El método repeat repite la cadena dada:

use Illuminate\Support\Str;
$repeated = Str::of('a')->repeat(5);
// aaaaa

`replace`

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 distingue entre mayúsculas y minúsculas:

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

`replaceArray`

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']);
// El evento tendrá lugar entre las 8:30 y las 9:00

`replaceFirst`

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');
// un rápido zorro marrón salta sobre el perro perezoso

`replaceLast`

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');
// el rápido zorro marrón salta sobre un perro perezoso

`replaceMatches`

El método replaceMatches reemplaza todas las porciones de una cadena que coinciden con un patrón dado 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 cierre que se invocará con cada porción de la cadena que coincida con el patrón dado, lo que te permite realizar la lógica de reemplazo dentro del cierre 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`

El método replaceStart reemplaza la primera aparición del valor dado solo si el valor aparece al principio 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`

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`

El método rtrim recorta el lado derecho de la cadena:

use Illuminate\Support\Str;
$string = Str::of('  Laravel  ')->rtrim();
// '  Laravel'
$string = Str::of('/Laravel/')->rtrim('/');
// '/Laravel'

`scan`

El método scan analiza la entrada desde una cadena en una colección según un formato admitido por la función sscanf de PHP:

use Illuminate\Support\Str;
$collection = Str::of('filename.jpg')->scan('%[^.].%s');
// collect(['filename', 'jpg'])

`singular`

El método singular convierte una cadena a su forma singular. Esta función es compatible con cualquiera de los idiomas admitidos por el pluralizador de Laravel:

use Illuminate\Support\Str;
$singular = Str::of('cars')->singular();
// car
$singular = Str::of('children')->singular();
// child

`slug`

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`

El método snake convierte la cadena dada a snake_case:

use Illuminate\Support\Str;
$converted = Str::of('fooBar')->snake();
// foo_bar

`split`

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`

El método squish elimina todo el espacio en blanco superfluo de una cadena, incluido el espacio en blanco superfluo entre palabras:

use Illuminate\Support\Str;
$string = Str::of('    laravel    framework    ')->squish();
// laravel framework

`start`

El método start agrega una única instancia del valor dado a una cadena si aún no comienza con ese valor:

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

`startsWith`

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

`studly`

El método studly convierte la cadena dada a StudlyCase:

use Illuminate\Support\Str;
$converted = Str::of('foo_bar')->studly();
// FooBar

`substr`

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`

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 la cantidad de caracteres especificada por el tercer argumento. Pasar 0 al tercer 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;
$string = Str::of('1300')->substrReplace(':', 2);
// 13:
$string = Str::of('The Framework')->substrReplace(' Laravel', 3, 0);
// The Laravel Framework

`swap`

El método swap reemplaza varios 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`

El método take devuelve un número especificado de caracteres desde el principio de la cadena:

use Illuminate\Support\Str;
$taken = Str::of('Build something amazing!')->take(5);
// Build

`tap`

El método tap pasa la cadena a la función de cierre dada, permitiéndote examinar e interactuar con la cadena sin afectar la cadena en sí. La cadena original es devuelta por el método tap independientemente de lo que devuelva la función de cierre:

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`

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`

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

`trim`

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`

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`

El método ucsplit divide la cadena dada en una colección por caracteres en mayúsculas:

use Illuminate\Support\Str;
$string = Str::of('Foo Bar')->ucsplit();
// collect(['Foo', 'Bar'])

`upper`

El método upper convierte la cadena dada a mayúsculas:

use Illuminate\Support\Str;
$adjusted = Str::of('laravel')->upper();
// LARAVEL

`when`

El método when invoca la función de cierre dada si se cumple una condición dada. La función de cierre 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, puedes pasar otra función de cierre como tercer parámetro al método when. Esta función de cierre se ejecutará si el parámetro de condición se evalúa como false.

`whenContains`

El método whenContains invoca la función de cierre dada si la cadena contiene el valor dado. La función de cierre 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, puedes pasar otra función de cierre como tercer parámetro al método when. Esta función de cierre se ejecutará si la cadena no contiene el valor dado.

También puedes 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`

El método whenContainsAll invoca la función de cierre dada si la cadena contiene todos los subcadenas dadas. La función de cierre 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, puedes pasar otra función de cierre como tercer parámetro al método when. Esta función de cierre se ejecutará si el parámetro de condición se evalúa como false.

`whenEmpty`

El método whenEmpty invoca la función de cierre dada si la cadena está vacía. Si la función de cierre devuelve un valor, ese valor también se devolverá mediante el método whenEmpty. Si la función de cierre 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`

El método whenNotEmpty invoca la función de cierre dada si la cadena no está vacía. Si la función de cierre devuelve un valor, ese valor también se devolverá mediante el método whenNotEmpty. Si la función de cierre 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`

El método whenStartsWith invoca la función de cierre dada si la cadena comienza con la subcadena dada. La función de cierre 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`

El método whenEndsWith invoca la función de cierre dada si la cadena termina con la subcadena dada. La función de cierre 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`

El método whenExactly invoca la función de cierre dada si la cadena coincide exactamente con la cadena dada. La función de cierre 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`

El método whenNotExactly invoca la función de cierre dada si la cadena no coincide exactamente con la cadena dada. La función de cierre 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`

El método whenIs invoca la función de cierre dada si la cadena coincide con un patrón dado. Se pueden usar asteriscos como valores comodín. La función de cierre 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`

El método whenIsAscii invoca la función de cierre dada si la cadena es ASCII de 7 bits. La función de cierre 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`

El método whenIsUlid invoca la función de cierre dada si la cadena es un ULID válido. La función de cierre 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`

El método whenIsUuid invoca la función de cierre dada si la cadena es un UUID válido. La función de cierre 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`

El método whenTest invoca la función de cierre dada si la cadena coincide con el patrón de expresión regular dado. La función de cierre 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`

El método wordCount devuelve la cantidad de palabras que contiene una cadena:

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

`words`

El método words limita la cantidad de palabras en una cadena. Si es necesario, puedes especificar una cadena adicional que se agregará a la cadena truncada:

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

Únete a nuestra comunidad de Telegram @webblend!

Introducción

Métodos disponibles

Cadenas

Cadenas fluidas

Cadenas

__()

class_basename()

e()

preg_replace_array()

Str::after()

Str::afterLast()

Str::ascii()

Str::before()

Str::beforeLast()

Str::between()

Str::betweenFirst()

Str::camel()

Str::contains()

Str::containsAll()

Str::endsWith()

Str::excerpt()

Str::finish()

Str::headline()

Str::inlineMarkdown()

Str::is()

Str::isAscii()

Str::isJson()

Str::isUrl()

Str::isUlid()

Str::isUuid()

Str::kebab()

Str::lcfirst()

Str::length()

Str::limit()

Str::lower()

Str::markdown()

Str::mask()

Str::orderedUuid()

Str::padBoth()

Str::padLeft()

Str::padRight()

Str::password()

Str::plural()

Str::pluralStudly()

Str::position()

Str::random()

Str::remove()

Str::repeat()

Str::replace()

Str::replaceArray()

Str::replaceFirst()

Str::replaceLast()

Str::replaceMatches()

Str::replaceStart()

Str::replaceEnd()

Str::reverse()

Str::singular()

Str::slug()

Str::snake()

Str::squish()

Str::start()

Str::startsWith()

Str::studly()

Str::substr()

Str::substrCount()

Str::substrReplace()

Str::swap()

Str::take()

Str::title()

Str::toHtmlString()

Str::ucfirst()

Str::ucsplit()

Str::upper()

Str::ulid()

Str::uuid()

Str::wordCount()

Str::wordWrap()

Str::words()

Str::wrap()

`__()`

`class_basename()`

`e()`

`preg_replace_array()`

`Str::after()`

`Str::afterLast()`

`Str::ascii()`

`Str::before()`

`Str::beforeLast()`

`Str::between()`

`Str::betweenFirst()`

`Str::camel()`

`Str::contains()`

`Str::containsAll()`

`Str::endsWith()`

`Str::excerpt()`

`Str::finish()`

`Str::headline()`

`Str::inlineMarkdown()`

`Str::is()`

`Str::isAscii()`

`Str::isJson()`

`Str::isUrl()`

`Str::isUlid()`

`Str::isUuid()`

`Str::kebab()`

`Str::lcfirst()`

`Str::length()`

`Str::limit()`

`Str::lower()`

`Str::markdown()`

`Str::mask()`

`Str::orderedUuid()`

`Str::padBoth()`

`Str::padLeft()`

`Str::padRight()`

`Str::password()`

`Str::plural()`

`Str::pluralStudly()`

`Str::position()`

`Str::random()`

`Str::remove()`

`Str::repeat()`

`Str::replace()`

`Str::replaceArray()`

`Str::replaceFirst()`

`Str::replaceLast()`

`Str::replaceMatches()`

`Str::replaceStart()`

`Str::replaceEnd()`

`Str::reverse()`

`Str::singular()`

`Str::slug()`

`Str::snake()`

`Str::squish()`

`Str::start()`

`Str::startsWith()`

`Str::studly()`

`Str::substr()`

`Str::substrCount()`

`Str::substrReplace()`

`Str::swap()`

`Str::take()`

`Str::title()`

`Str::toHtmlString()`

`Str::ucfirst()`

`Str::ucsplit()`

`Str::upper()`

`Str::ulid()`

`Str::uuid()`

`Str::wordCount()`

`Str::wordWrap()`

`Str::words()`

`Str::wrap()`

`str()`

`trans()`

`trans_choice()`

`after`

`afterLast`

`append`