Skip to content

Documentación Laravel

Cadenas

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, puedes usarlas en tus propias aplicaciones si te resultan convenientes.

Métodos Disponibles

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::chopStart Str::chopEnd Str::contains Str::containsAll Str::doesntContain Str::deduplicate Str::endsWith Str::excerpt Str::finish Str::headline Str::inlineMarkdown Str::is Str::isAscii Str::isJson Str::isUlid Str::isUrl Str::isUuid Str::kebab Str::lcfirst Str::length Str::limit Str::lower Str::markdown Str::mask Str::orderedUuid Str::padBoth Str::padLeft Str::padRight Str::password Str::plural Str::pluralStudly Str::position Str::random Str::remove Str::repeat Str::replace Str::replaceArray Str::replaceFirst Str::replaceLast Str::replaceMatches Str::replaceStart Str::replaceEnd Str::reverse Str::singular Str::slug Str::snake Str::squish Str::start Str::startsWith Str::studly Str::substr Str::substrCount Str::substrReplace Str::swap Str::take Str::title Str::toBase64 Str::toHtmlString Str::transliterate Str::trim Str::ltrim Str::rtrim Str::ucfirst Str::ucsplit Str::upper Str::ulid Str::unwrap Str::uuid Str::wordCount Str::wordWrap Str::words Str::wrap str trans trans_choice

Cadenas Fluentes

after afterLast apa append ascii basename before beforeLast between betweenFirst camel charAt classBasename chopStart chopEnd contains containsAll deduplicate dirname endsWith exactly excerpt explode finish headline inlineMarkdown is isAscii isEmpty isNotEmpty isJson isUlid isUrl isUuid kebab lcfirst length limit lower markdown mask match matchAll isMatch newLine padBoth padLeft padRight pipe plural position prepend remove repeat replace replaceArray replaceFirst replaceLast replaceMatches replaceStart replaceEnd scan singular slug snake split squish start startsWith stripTags studly substr substrReplace swap take tap test title toBase64 transliterate trim ltrim rtrim ucfirst ucsplit unwrap upper when whenContains whenContainsAll whenEmpty whenNotEmpty whenStartsWith whenEndsWith whenExactly whenNotExactly whenIs whenIsAscii whenIsUlid whenIsUuid whenTest wordCount words wrap

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 existen, la función __ devolverá el valor dado. Así que, 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 configurada 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 de forma secuencial utilizando 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 lo que sigue 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()

El método Str::afterLast devuelve todo lo que sigue 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::afterLast('App\Http\Controllers\Controller', '\\');

// 'Controller'

Str::apa()

El método Str::apa convierte la cadena dada a mayúsculas de título siguiendo las directrices de la APA:

use Illuminate\Support\Str;

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

// 'Creating a Project'

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

El método Str::beforeLast devuelve todo lo que está 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::charAt()

El método Str::charAt devuelve el carácter en el índice especificado. Si el índice está fuera de límites, se devuelve false:

use Illuminate\Support\Str;

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

// 's'

Str::chopStart()

El método Str::chopStart elimina la primera ocurrencia del valor dado solo si el valor aparece al inicio de la cadena:

use Illuminate\Support\Str;

$url = Str::chopStart('https://laravel.com', 'https://');

// 'laravel.com'

También puedes pasar un array como segundo argumento. Si la cadena comienza con cualquiera de los valores del array, entonces ese valor será eliminado de la cadena:

use Illuminate\Support\Str;

$url = Str::chopStart('http://laravel.com', ['https://', 'http://']);

// 'laravel.com'

Str::chopEnd()

El método Str::chopEnd elimina la última ocurrencia del valor dado solo si el valor aparece al final de la cadena:

use Illuminate\Support\Str;

$url = Str::chopEnd('app/Models/Photograph.php', '.php');

// 'app/Models/Photograph'

También puedes pasar un array como segundo argumento. Si la cadena termina con cualquiera de los valores del array, entonces ese valor será eliminado de la cadena:

use Illuminate\Support\Str;

$url = Str::chopEnd('laravel.com/index.php', ['/index.html', '/index.php']);

// 'laravel.com'

Str::contains()

El método Str::contains determina si la cadena dada contiene el valor dado. Por defecto, este método es sensible a mayúsculas y minúsculas:

use Illuminate\Support\Str;

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

// true

use Illuminate\Support\Str;

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

// true

use Illuminate\Support\Str;

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

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

use Illuminate\Support\Str;

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

// true

Str::doesntContain()

El método Str::doesntContain determina si la cadena dada no contiene el valor dado. Por defecto, este método es sensible a mayúsculas y minúsculas:

use Illuminate\Support\Str;

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

// true

También puedes pasar un array de valores para determinar si la cadena dada no contiene ninguno de los valores del array:

use Illuminate\Support\Str;

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

// true

Puedes desactivar la sensibilidad a mayúsculas y minúsculas configurando el argumento ignoreCase en true:

use Illuminate\Support\Str;

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

// true

Str::deduplicate()

El método Str::deduplicate reemplaza las instancias consecutivas de un carácter por una sola instancia de ese carácter en la cadena dada. Por defecto, el método deduplica espacios:

use Illuminate\Support\Str;

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

// The Laravel Framework

use Illuminate\Support\Str;

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

// The-Laravel-Framework

Str::endsWith()

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

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

Además, puedes usar la opción omission para definir la cadena que se añadirá al inicio 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 añade una sola instancia del valor dado a una cadena si 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()

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 Markdown al estilo de 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 bloque:

use Illuminate\Support\Str;

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

// <strong>Laravel</strong>

use Illuminate\Support\Str;

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

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

Str::is()

El método Str::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::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

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

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:

$truncated = Str::limit('The quick brown fox jumps over the lazy dog', 20, ' (...)');

// The quick brown fox (...)

$truncated = Str::limit('The quick brown fox', 12, preserveWords: true);

// The quick...

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 Markdown al estilo de GitHub en HTML utilizando 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>

use Illuminate\Support\Str;

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

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

Str::mask()

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

use Illuminate\Support\Str;

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

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

Si es necesario, puedes proporcionar un número negativo como el 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()

El método Str::orderedUuid genera un UUID "con marca de tiempo primero" que se puede almacenar de manera eficiente en una columna de base de datos indexada. Cada UUID que se genera utilizando este método se ordenará después de los UUID generados previamente con 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 alcance 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 alcance 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 alcance 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 utilizar para generar una contraseña aleatoria y segura 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 en singular a su forma plural. Esta función admite cualquiera de los idiomas soportados por el pluralizador de Laravel:

use Illuminate\Support\Str;

$plural = Str::plural('car');

// cars

$plural = Str::plural('child');

// children

use Illuminate\Support\Str;

$plural = Str::plural('child', 2);

// children

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

// child

Str::pluralStudly()

El método Str::pluralStudly convierte una cadena de palabra en singular formateada en mayúsculas estilizadas a su forma plural. Esta función admite cualquiera de los idiomas soportados por el pluralizador de Laravel:

use Illuminate\Support\Str;

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

// VerifiedHumans

$plural = Str::pluralStudly('UserFeedback');

// UserFeedback

use Illuminate\Support\Str;

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

// VerifiedHumans

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

// VerifiedHuman

Str::position()

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

Durante las pruebas, puede ser útil "simular" el valor que devuelve el método Str::random. Para lograr esto, puedes usar el método createRandomStringsUsing:

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

Para instruir al método random a que comience a generar cadenas aleatorias de forma normal, puedes invocar el método createRandomStringsNormally:

Str::createRandomStringsNormally();

Str::remove()

El método Str::remove elimina el valor dado o el 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 10.x';

$replaced = Str::replace('10.x', '11.x', $string);

// Laravel 11.x

Str::replace('Framework', 'Laravel', caseSensitive: false);

Str::replaceArray()

El método Str::replaceArray reemplaza un valor dado en la cadena de forma secuencial utilizando 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()

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

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

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'

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

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 soportados 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 con las 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 todo el espacio en blanco innecesario de una cadena, incluyendo el espacio en blanco adicional entre palabras:

use Illuminate\Support\Str;

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

// laravel framework

Str::start()

El método Str::start añade una sola instancia del valor dado a una cadena si 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()

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

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

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 especificados por el cuarto argumento. Pasar 0 al cuarto argumento del método insertará la cadena en la posición especificada sin reemplazar ningún carácter existente 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 inicio 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::toBase64()

El método Str::toBase64 convierte la cadena dada a Base64:

use Illuminate\Support\Str;

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

// TGFyYXZlbA==

Str::toHtmlString()

El método Str::toHtmlString convierte la instancia de la 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::transliterate()

El método Str::transliterate intentará convertir una cadena dada en su representación ASCII más cercana:

use Illuminate\Support\Str;

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

// 'test@laravel.com'

Str::trim()

El método Str::trim elimina el espacio en blanco (u otros caracteres) del principio y del final de la cadena dada. A diferencia de la función trim nativa de PHP, el método Str::trim también elimina caracteres de espacio en blanco unicode:

use Illuminate\Support\Str;

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

// 'foo bar'

Str::ltrim()

El método Str::ltrim elimina el espacio en blanco (u otros caracteres) del principio de la cadena dada. A diferencia de la función ltrim nativa de PHP, el método Str::ltrim también elimina caracteres de espacio en blanco unicode:

use Illuminate\Support\Str;

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

// 'foo bar  '

Str::rtrim()

El método Str::rtrim elimina el espacio en blanco (u otros caracteres) del final de la cadena dada. A diferencia de la función rtrim nativa de PHP, el método Str::rtrim también elimina caracteres de espacio en blanco unicode:

use Illuminate\Support\Str;

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

// '  foo bar'

Str::ucfirst()

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

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

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 deseas obtener una instancia de fecha Illuminate\Support\Carbon que represente la fecha y hora en la que se creó un ULID dado, puedes 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());

Durante las pruebas, puede ser útil "simular" el valor que devuelve el método Str::ulid. Para lograr esto, puedes usar el método createUlidsUsing:

use Symfony\Component\Uid\Ulid;

Str::createUlidsUsing(function () {
    return new Ulid('01HRDBNHHCKNW2AK4Z29SN82T9');
});

Para instruir al método ulid a que comience a generar ULIDs de forma normal, puedes invocar el método createUlidsNormally:

Str::createUlidsNormally();

Str::unwrap()

El método Str::unwrap elimina las cadenas especificadas del principio y del final de una cadena dada:

use Illuminate\Support\Str;

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

// Laravel

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

// framework: "Laravel"

Str::uuid()

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, puedes usar el método createUuidsUsing:

use Ramsey\Uuid\Uuid;

Str::createUuidsUsing(function () {
    return Uuid::fromString('eadbfeac-5258-45c2-bab7-ccb9b5ef74f9');
});

Para instruir al método uuid a que comience a generar UUIDs de forma normal, puedes invocar el método createUuidsNormally:

Str::createUuidsNormally();

Str::wordCount()

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

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 el número de palabras en una cadena. Se puede pasar una cadena adicional a este método a través de su tercer argumento para especificar qué cadena se debe añadir 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 de Illuminate\Support\Stringable de la cadena dada. Esta función equivale 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 tus 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í que, utilizando 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í que, utilizando el ejemplo anterior, la función trans_choice devolvería messages.notifications si la clave de traducción no existe.

Cadenas Fluentes

Las cadenas fluentes proporcionan una interfaz más fluida y orientada a objetos para trabajar con valores de cadena, lo que te 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 lo que sigue 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

El método afterLast devuelve todo lo que sigue 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

El método apa convierte la cadena dada a mayúsculas de título siguiendo las directrices de la APA:

use Illuminate\Support\Str;

$converted = Str::of('a nice title uses the correct case')->apa();

// A Nice Title Uses the Correct Case

append

El método append agrega los valores dados al final de 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, puedes 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

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

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

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'

charAt

El método charAt devuelve el carácter en el índice especificado. Si el índice está fuera de límites, se devuelve false:

use Illuminate\Support\Str;

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

// 's'

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'

chopStart

El método chopStart elimina la primera ocurrencia del valor dado solo si el valor aparece al inicio de la cadena:

use Illuminate\Support\Str;

$url = Str::of('https://laravel.com')->chopStart('https://');

// 'laravel.com'

También puedes pasar un array. Si la cadena comienza con cualquiera de los valores del array, entonces ese valor será eliminado de la cadena:

use Illuminate\Support\Str;

$url = Str::of('http://laravel.com')->chopStart(['https://', 'http://']);

// 'laravel.com'

chopEnd

El método chopEnd elimina la última ocurrencia del valor dado solo si el valor aparece al final de la cadena:

use Illuminate\Support\Str;

$url = Str::of('https://laravel.com')->chopEnd('.com');

// 'https://laravel'

También puedes pasar un array. Si la cadena termina con cualquiera de los valores del array, entonces ese valor será eliminado de la cadena:

use Illuminate\Support\Str;

$url = Str::of('http://laravel.com')->chopEnd(['.com', '.io']);

// 'http://laravel'

contains

El método contains determina si la cadena dada contiene el valor dado. Por defecto, este método es sensible a mayúsculas y minúsculas:

use Illuminate\Support\Str;

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

// true

use Illuminate\Support\Str;

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

// true

use Illuminate\Support\Str;

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

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

Puedes desactivar la sensibilidad a mayúsculas y minúsculas configurando el argumento ignoreCase en true:

use Illuminate\Support\Str;

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

// true

deduplicate

El método deduplicate reemplaza las instancias consecutivas de un carácter por una sola instancia de ese carácter en la cadena dada. Por defecto, el método deduplica espacios:

use Illuminate\Support\Str;

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

// The Laravel Framework

Puedes especificar un carácter diferente para la desduplicación pasándolo como segundo argumento al método:

use Illuminate\Support\Str;

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

// The-Laravel-Framework

dirname

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, puedes especificar cuántos niveles de directorio deseas eliminar de la cadena:

use Illuminate\Support\Str;

$string = Str::of('/foo/bar/baz')->dirname(2);

// '/foo'

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 puedes pasar un array de valores para determinar si la cadena dada termina con cualquiera de los valores del 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 coincide exactamente con otra cadena:

use Illuminate\Support\Str;

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

// true

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, te permite definir la cantidad de caracteres que deben aparecer en cada lado de la cadena truncada. Además, puedes utilizar la opción omission para cambiar la cadena que se añadirá al inicio 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'

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 añade una sola instancia del valor dado a una cadena si 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

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

// Email Notification Sent

inlineMarkdown

El método inlineMarkdown convierte Markdown al estilo de 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 bloque:

use Illuminate\Support\Str;

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

// <strong>Laravel</strong>

use Illuminate\Support\Str;

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

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

is

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 la 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 la 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 la 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, puedes especificar los protocolos que deben considerarse válidos proporcionándolos al método isUrl:

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

isUuid

El método isUuid determina si la 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 el primer carácter 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 añadirá al final de la cadena truncada:

$truncated = Str::of('The quick brown fox jumps over the lazy dog')->limit(20, ' (...)');

// The quick brown fox (...)

Si deseas preservar palabras completas al truncar la cadena, puedes utilizar el argumento preserveWords. Cuando este argumento es true, la cadena se truncará hasta el límite de la palabra completa más cercana:

$truncated = Str::of('The quick brown fox')->limit(12, preserveWords: true);

// The quick...

lower

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

use Illuminate\Support\Str;

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

// 'laravel'

markdown

El método markdown convierte Markdown al estilo de 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 de Markdown

Por defecto, Markdown admite HTML en bruto, lo que expondrá vulnerabilidades de Cross-Site Scripting (XSS) cuando se utilice con entradas de usuario en bruto. Según la documentación de seguridad de CommonMark, puedes usar la opción html_input para escapar o eliminar HTML en bruto, y la opción allow_unsafe_links para especificar si se deben permitir enlaces inseguros. Si necesitas permitir algo de HTML en bruto, deberías pasar tu 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(&quot;Hello XSS!&quot;);</p>

mask

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

use Illuminate\Support\Str;

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

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

Si es necesario, puedes proporcionar números negativos como el tercer o cuarto 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::of('taylor@example.com')->mask('*', -15, 3);

// tay***@example.com

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

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

match

El método match devolverá 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

El método matchAll devolverá 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 especificas un grupo de coincidencia dentro de la expresión, Laravel devolverá una colección con las coincidencias del primer grupo de coincidencia:

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

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

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

El método plural convierte una cadena de palabra en singular a su forma plural. Esta función admite 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

Puedes proporcionar un número 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 ocurrencia 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 añade los valores dados al inicio de la cadena:

use Illuminate\Support\Str;

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

// Laravel Framework

remove

El método remove elimina el valor dado o el 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 y minú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 es sensible a 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 de forma secuencial utilizando 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

El método replaceFirst reemplaza la primera ocurrencia 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

El método replaceLast reemplaza la última ocurrencia 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

El método replaceMatches reemplaza todas las partes de una cadena que coinciden con un patrón por 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 una función anónima que se invocará con cada parte de la cadena que coincida con el patrón dado, lo que te permite realizar la lógica de reemplazo dentro de la función anónima y retornar 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 ocurrencia 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

El método replaceEnd reemplaza la última ocurrencia 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

scan

El método scan analiza la entrada de una cadena en una colección según un formato que es compatible con 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 admite 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

El método slug genera un "slug" amigable con las 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 utilizando 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 innecesario de una cadena, incluyendo el espacio en blanco adicional entre palabras:

use Illuminate\Support\Str;

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

// laravel framework

start

El método start añade una sola instancia del valor dado a una cadena si 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

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

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

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 el número de caracteres especificados 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 múltiples valores en la cadena utilizando 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 inicio 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 anónima dada, lo que te permite examinar e interactuar con la cadena sin afectar la cadena misma. La cadena original es devuelta por el método tap sin importar lo que devuelva la función anónima:

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

toBase64()

El método toBase64 convierte la cadena dada a Base64:

use Illuminate\Support\Str;

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

// TGFyYXZlbA==

transliterate

El método transliterate intentará convertir una cadena dada en su representación ASCII más cercana:

use Illuminate\Support\Str;

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

// 'test@laravel.com'

trim

El método trim recorta la cadena dada. A diferencia de la función trim nativa de PHP, el método trim de Laravel también elimina caracteres de espacio en blanco unicode:

use Illuminate\Support\Str;

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

// 'Laravel'

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

// 'Laravel'

ltrim

El método ltrim recorta el lado izquierdo de la cadena. A diferencia de la función ltrim nativa de PHP, el método ltrim de Laravel también elimina caracteres de espacio en blanco unicode:

use Illuminate\Support\Str;

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

// 'Laravel  '

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

// 'Laravel/'

rtrim

El método rtrim recorta el lado derecho de la cadena dada. A diferencia de la función rtrim nativa de PHP, el método rtrim de Laravel también elimina caracteres de espacio en blanco unicode:

use Illuminate\Support\Str;

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

// '  Laravel'

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

// '/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 los caracteres en mayúscula:

use Illuminate\Support\Str;

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

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

unwrap

El método unwrap elimina las cadenas especificadas del principio y del final de una cadena dada:

use Illuminate\Support\Str;

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

// Laravel

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

// framework: "Laravel"

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 anónima dada si una condición dada es true. La función anónima recibirá la instancia de la cadena fluente:

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

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

// 'Taylor Otwell'

whenContains

El método whenContains invoca la función anónima dada si la cadena contiene el valor dado. La función anónima recibirá la instancia de la cadena fluente:

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 anónima como tercer parámetro al método when. Esta función anónima 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 cualquiera de los valores del 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 anónima dada si la cadena contiene todas las subcadenas dadas. La función anónima recibirá la instancia de la cadena fluente:

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 anónima como tercer parámetro al método when. Esta función anónima se ejecutará si el parámetro de condición evalúa a false.

whenEmpty

El método whenEmpty invoca la función anónima dada si la cadena está vacía. Si la función anónima devuelve un valor, ese valor también será devuelto por el método whenEmpty. Si la función anónima no devuelve un valor, se devolverá la instancia de la cadena fluente:

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 anónima dada si la cadena no está vacía. Si la función anónima devuelve un valor, ese valor también será devuelto por el método whenNotEmpty. Si la función anónima no devuelve un valor, se devolverá la instancia de la cadena fluente:

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 anónima dada si la cadena comienza con la subcadena dada. La función anónima recibirá la instancia de la cadena fluente:

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 anónima dada si la cadena termina con la subcadena dada. La función anónima recibirá la instancia de la cadena fluente:

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 anónima dada si la cadena coincide exactamente con la cadena dada. La función anónima recibirá la instancia de la cadena fluente:

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 anónima dada si la cadena no coincide exactamente con la cadena dada. La función anónima recibirá la instancia de la cadena fluente:

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 anónima dada si la cadena coincide con un patrón dado. Se pueden usar asteriscos como valores comodín. La función anónima recibirá la instancia de la cadena fluente:

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 anónima dada si la cadena es ASCII de 7 bits. La función anónima recibirá la instancia de la cadena fluente:

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 anónima dada si la cadena es un ULID válido. La función anónima recibirá la instancia de la cadena fluente:

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 anónima dada si la cadena es un UUID válido. La función anónima recibirá la instancia de la cadena fluente:

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 anónima dada si la cadena coincide con la expresión regular dada. La función anónima recibirá la instancia de la cadena fluente:

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 el número de palabras que contiene una cadena:

use Illuminate\Support\Str;

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

words

El método words limita el número de palabras en una cadena. Si es necesario, puedes especificar una cadena adicional que se añadirá al final de la cadena truncada:

use Illuminate\Support\Str;

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

// Perfectly balanced, as >>>

wrap

El método wrap envuelve la cadena dada con una cadena adicional o un par de cadenas:

use Illuminate\Support\Str;

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

// "Laravel"

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

// This is Laravel!