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::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 dirname endsWith excerpt exactly 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
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'); // Baze()
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>'); // <html>foo</html>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:00Str::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'); // trueuse Illuminate\Support\Str; $contains = Str::contains('This is my name', ['my', 'foo']); // trueuse Illuminate\Support\Str; $contains = Str::contains('This is my name', 'MY', ignoreCase: true); // trueStr::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']); // truePuedes desactivar la sensibilidad a mayúsculas y minúsculas configurando el argumento ignoreCase en true:
use Illuminate\Support\Str; $containsAll = Str::containsAll('This is my name', ['MY', 'NAME'], ignoreCase: true); // trueStr::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'); // trueuse Illuminate\Support\Str; $result = Str::endsWith('This is my name', ['name', 'foo']); // true $result = Str::endsWith('This is my name', ['this', 'foo']); // falseStr::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 SentStr::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("Hello XSS!");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'); // falseStr::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('ü'); // falseStr::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"}'); // falseStr::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'); // falseStr::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'); // falseStr::kebab()
El método Str::kebab convierte la cadena dada a kebab-case:
use Illuminate\Support\Str; $converted = Str::kebab('fooBar'); // foo-barStr::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 BarStr::length()
El método Str::length devuelve la longitud de la cadena dada:
use Illuminate\Support\Str; $length = Str::length('Laravel'); // 7Str::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'); // laravelStr::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("Hello XSS!");</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.comStr::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'); // childrenuse Illuminate\Support\Str; $plural = Str::plural('child', 2); // children $singular = Str::plural('child', 1); // childStr::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'); // UserFeedbackuse Illuminate\Support\Str; $plural = Str::pluralStudly('VerifiedHuman', 2); // VerifiedHumans $singular = Str::pluralStudly('VerifiedHuman', 1); // VerifiedHumanStr::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'); // 7Str::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); // aaaaaStr::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.xStr::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:00Str::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 dogStr::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 dogStr::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 WorldStr::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 WorldStr::reverse()
El método Str::reverse invierte la cadena dada:
use Illuminate\Support\Str; $reversed = Str::reverse('Hello World'); // dlroW olleHStr::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'); // childStr::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-frameworkStr::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-barStr::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 frameworkStr::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/stringStr::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'); // trueSi 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']); // trueStr::studly()
El método Str::studly convierte la cadena dada a StudlyCase:
use Illuminate\Support\Str; $converted = Str::studly('foo_bar'); // FooBarStr::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); // LaravelStr::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'); // 2Str::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:00Str::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); // BuildStr::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 CaseStr::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 barStr::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'); // LARAVELStr::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(); // 01gd6r360bp37zj17nxb55yv40Si 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!'); // 2Str::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 Caseappend
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'); // trueuse Illuminate\Support\Str; $contains = Str::of('This is my name')->contains(['my', 'foo']); // trueuse Illuminate\Support\Str; $contains = Str::of('This is my name')->contains('MY', ignoreCase: true); // truecontainsAll
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']); // truePuedes 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); // truedirname
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'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'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'); // trueTambié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']); // falseexactly
El método exactly determina si la cadena dada coincide exactamente con otra cadena:
use Illuminate\Support\Str; $result = Str::of('Laravel')->exactly('Laravel'); // trueexplode
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 SentinlineMarkdown
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("Hello XSS!");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*'); // falseisAscii
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(); // falseisEmpty
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(); // falseisNotEmpty
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(); // trueisJson
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(); // falseisUlid
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(); // falseisUrl
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(); // falseEl 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(); // falsekebab
El método kebab convierte la cadena dada a kebab-case:
use Illuminate\Support\Str; $converted = Str::of('fooBar')->kebab(); // foo-barlcfirst
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 Barlength
El método length devuelve la longitud de la cadena dada:
use Illuminate\Support\Str; $length = Str::of('Laravel')->length(); // 7limit
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("Hello XSS!");</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**********.commatch
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 (.*)/'); // falsenewLine
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(); // childrenPuedes 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); // childposition
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'); // 7prepend
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 Frameworkremove
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); // aaaaareplace
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.xEl 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:00replaceFirst
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 dogreplaceLast
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 dogreplaceMatches
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 WorldreplaceEnd
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 Worldscan
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(); // childslug
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-frameworksnake
El método snake convierte la cadena dada a snake_case:
use Illuminate\Support\Str; $converted = Str::of('fooBar')->snake(); // foo_barsplit
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 frameworkstart
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/stringstartsWith
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'); // truestripTags
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(); // FooBarsubstr
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); // FramesubstrReplace
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 Frameworkswap
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); // Buildtap
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 FRAMEWORKtest
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/'); // truetitle
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 CasetoBase64()
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 barucsplit
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(); // LARAVELwhen
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 StarkwhenContainsAll
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(); // 2words
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 >>>