Laravel 11.x

Aparência

Strings ​

Introdução ​

O Laravel inclui uma variedade de funções para manipular valores de string. Muitas destas funções são usadas pelo próprio framework; no entanto, você tem liberdade para utilizá-las em suas aplicações caso ache isso conveniente.

Métodos disponíveis ​

Strings ​

Strings Fluentes ​

Strings ​

__() ​

A função __ traduz a frase ou chave de tradução fornecida, utilizando os seus arquivos de idiomas:

php
    echo __('Welcome to our application');

    echo __('messages.welcome');

Se a chave de tradução ou a string especificada não existirem, a função __ retornará o valor fornecido. Assim, usando o exemplo acima, a função __ retornaria messages.welcome se essa chave de tradução não existir.

class_basename() ​

A função class_basename retorna o nome da classe com o namespace da mesma removido:

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

    // Baz

e() ​

A função e executa a função htmlspecialchars do PHP com a opção double_encode, definida como true por padrão:

php
    echo e('<html>foo</html>');

    // &lt;html&gt;foo&lt;/html&gt;

preg_replace_array() ​

A função preg_replace_array substitui o padrão dado na string seqüencialmente usando um array:

php
    $string = 'The event will take place between :start and :end';

    $replaced = preg_replace_array('/:[a-z_]+/', ['8:30', '9:00'], $string);

    // O evento acontecerá entre 8h30 e 9h00

Str::after() ​

O método Str::after retorna tudo o que está depois do valor especificado numa string. A string inteira será retornada se não existir o valor:

php
    use Illuminate\Support\Str;

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

    // ' my name'

Str::afterLast() ​

O método Str::afterLast retorna tudo após o último caractere que aparece na string. Se o valor não existir, a string inteira será retornada:

php
    use Illuminate\Support\Str;

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

    // 'Controller'

Str::apa() ​

O método Str::apa converte a string dada para maiúsculas, de acordo com as regras do APA:

php
    use Illuminate\Support\Str;

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

    // 'Creating a Project'

Str::ascii() ​

O método Str::ascii tentará traduzir a string em um valor ASCII:

php
    use Illuminate\Support\Str;

    $slice = Str::ascii('û');

    // 'u'

Str::before() ​

O método Str::before retorna tudo que está antes do valor especificado numa string:

php
    use Illuminate\Support\Str;

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

    // 'This is '

Str::beforeLast() ​

O método Str::beforeLast retorna tudo o que aparece antes da última ocorrência do valor indicado numa string.

php
    use Illuminate\Support\Str;

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

    // 'This '

Str::between() ​

O método Str::between retorna o trecho de uma string entre dois valores:

php
    use Illuminate\Support\Str;

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

    // ' is my '

Str::betweenFirst() ​

O método Str::betweenFirst retorna a menor parte possível de uma string entre dois valores:

php
    use Illuminate\Support\Str;

    $slice = Str::betweenFirst('[a] bc [d]', '[', ']');

    // 'a'

Str::camel() ​

O método Str::camel converte a string fornecida para camelCase:

php
    use Illuminate\Support\Str;

    $converted = Str::camel('foo_bar');

    // 'fooBar'

Str::charAt() ​

O método Str::charAt retorna o caractere na posição especificada. Se a posição for inválida, é retornado false:

php
    use Illuminate\Support\Str;

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

    // 's'

Str::contains() ​

O método Str::contains determina se a string fornecida contém o valor fornecido. Esse método é sensível às maiúsculas e minúsculas (case-sensitive):

php
    use Illuminate\Support\Str;

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

    // true

Você também pode passar uma matriz de valores para determinar se a string contém algum dos valores na matriz:

php
    use Illuminate\Support\Str;

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

    // true

Str::containsAll() ​

O método Str::containsAll verifica se a string fornecida contém todos os valores num determinado array:

php
    use Illuminate\Support\Str;

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

    // true

Str::endsWith() ​

O método Str::endsWith determina se a string em questão termina com o valor passado como argumento:

php
    use Illuminate\Support\Str;

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

    // true

Você também pode passar um array de valores para determinar se a string fornecida termina com qualquer valor do array:

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

O método Str::excerpt extrai um trecho de uma determinada string que corresponde à primeira ocorrência de uma frase nessa string:

php
    use Illuminate\Support\Str;

    $excerpt = Str::excerpt('This is my name', 'my', [
        'radius' => 3
    ]);

    // '...is my na...'

A opção radius, com o padrão 100, permite definir o número de caracteres que devem aparecer em cada lado da string truncada.

Você pode usar a opção omission para definir a string que será adicionada e removida da string truncada:

php
    use Illuminate\Support\Str;

    $excerpt = Str::excerpt('This is my name', 'name', [
        'radius' => 3,
        'omission' => '(...) '
    ]);

    // '(...) my name'

Str::finish() ​

O método Str::finish adiciona uma única instância do valor dado a uma string se este já não terminar com esse valor:

php
    use Illuminate\Support\Str;

    $adjusted = Str::finish('this/string', '/');

    // this/string/

    $adjusted = Str::finish('this/string/', '/');

    // this/string/

Str::headline() ​

O método Str::headline converte strings delimitadas por maiúsculas, hifens ou traços de assinatura em uma string com espaçamento entre palavras e a primeira letra de cada palavra em maiúscula:

php
    use Illuminate\Support\Str;

    $headline = Str::headline('steve_jobs');

    // Steve Jobs

    $headline = Str::headline('EmailNotificationSent');

    // Email Notification Sent

Str::inlineMarkdown() ​

O método Str::inlineMarkdown converte o Markdown do GitHub em HTML inline usando CommonMark. No entanto, ao contrário do método markdown, ele não encadeia todo o HTML gerado num elemento de nível de bloco:

php
    use Illuminate\Support\Str;

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

    // <strong>Laravel</strong>

Segurança no Markdown ​

Por padrão, o Markdown suporta HTML bruto, que expõe vulnerabilidades de Cross-Site Scripting (XSS) quando usado com input do usuário bruto. Conforme a documentação de segurança do CommonMark, você pode usar a opção html_input para escapar ou remover o HTML bruto, e a opção allow_unsafe_links para especificar se é permitido links inseguros. Se você precisa permitir um pouco de HTML bruto, deve passar seu Markdown compilado por uma sanitização de HTML:

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

O método Str::is verifrica se uma determinada string corresponde ou não a um determinado padrão. Os asteriscos podem ser utilizados como valores de substituição:

php
    use Illuminate\Support\Str;

    $matches = Str::is('foo*', 'foobar');

    // true

    $matches = Str::is('baz*', 'foobar');

    // false

Str::isAscii() ​

O método Str::isAscii permite verificar se uma determinada string é ASCII de 7 bits:

php
    use Illuminate\Support\Str;

    $isAscii = Str::isAscii('Taylor');

    // true

    $isAscii = Str::isAscii('ü');

    // false

Str::isJson() ​

O método Str::isJson determina se a string fornecida é um código JSON válido:

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

O método Str::isUrl determina se o texto fornecido é uma URL válida:

php
    use Illuminate\Support\Str;

    $isUrl = Str::isUrl('http://example.com');

    // true

    $isUrl = Str::isUrl('laravel');

    // false

O método isUrl considera uma ampla gama de protocolos como válidos. No entanto, você pode especificar os protocolos que devem ser considerados válidos fornecendo-os ao método isUrl:

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

Str::isUlid() ​

O método Str::isUlid determina se uma determinada string é um ULID válido:

php
    use Illuminate\Support\Str;

    $isUlid = Str::isUlid('01gd6r360bp37zj17nxb55yv40');

    // true

    $isUlid = Str::isUlid('laravel');

    // false

Str::isUuid() ​

O método Str::isUuid verifica se uma determinada string é um UUID válido:

php
    use Illuminate\Support\Str;

    $isUuid = Str::isUuid('a0a2a2d2-0b87-4a18-83f2-2529882be2de');

    // true

    $isUuid = Str::isUuid('laravel');

    // false

Str::kebab() ​

O método Str::kebab converte a string dada para o estilo kebab-case:

php
    use Illuminate\Support\Str;

    $converted = Str::kebab('fooBar');

    // foo-bar

Str::lcfirst() ​

O método Str::lcfirst retorna a string dada com o primeiro caractere minúsculo:

php
    use Illuminate\Support\Str;

    $string = Str::lcfirst('Foo Bar');

    // foo Bar

str::length() ​

O método Str::length retorna o comprimento da string indicada:

php
    use Illuminate\Support\Str;

    $length = Str::length('Laravel');

    // 7

Str::limit() ​

O método Str::limit trunca a string dada até um comprimento especificado:

php
    use Illuminate\Support\Str;

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

    // The quick brown fox...

Você pode passar um terceiro argumento para a método para alterar a string que será adicionada ao final da string truncada.

php
    use Illuminate\Support\Str;

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

    // The quick brown fox (...)

Str::lower() ​

O método Str::lower converte uma string para minúsculas:

php
    use Illuminate\Support\Str;

    $converted = Str::lower('LARAVEL');

    // laravel

Str::markdown() ​

O método Str::markdown converte o formato de texto do GitHub para Markdown em HTML usando o CommonMark:

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

Segurança no uso do Markdown ​

Por padrão, o Markdown suporta HTML bruto, o que irá expor vulnerabilidades de Cross-Site Scripting (XSS) quando usado com entrada do utilizador bruta. Conforme a documentação de Segurança CommonMark, você pode usar a opção html_input para esconder ou remover o HTML bruto, e a opção allow_unsafe_links para especificar se permite links inseguros. Se necessário, você deverá passar a sua marcação do Markdown compilada através de um HTML Purifier:

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

O método Str::mask mascara uma parte de uma string com um caractere repetido e pode ser usado para ofuscar segmentos de strings, como endereços de e-mail e números de telefone:

php
    use Illuminate\Support\Str;

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

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

Se necessário, forneça um número negativo como o terceiro argumento para o método mask, que instruirá o método a começar a mascarar na distância fornecida a partir do final da string:

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

    // tay***@example.com

Str::orderedUuid() ​

O método Str::orderedUuid gera um UUID de "timestamps first" que pode ser armazenado de forma eficiente em uma coluna de banco de dados com índice. Cada UUID gerado por este método será ordenado após os UUIDs gerados anteriormente pelo método:

php
    use Illuminate\Support\Str;

    return (string) Str::orderedUuid();

Str::padBoth() ​

O método Str::padBoth encapsula a função str_pad do PHP, preenchendo ambos os lados de uma string com outra string até que a string final atinja o comprimento desejado:

php
    use Illuminate\Support\Str;

    $padded = Str::padBoth('James', 10, '_');

    // '__James___'

    $padded = Str::padBoth('James', 10);

    // '  James   '

Str::padLeft() ​

O método Str::padLeft encapsula a função str_pad do PHP, preenchendo o lado esquerdo de uma string com outra string até que a string final atinja o comprimento desejado:

php
    use Illuminate\Support\Str;

    $padded = Str::padLeft('James', 10, '-=');

    // '-=-=-James'

    $padded = Str::padLeft('James', 10);

    // '     James'

Str::padRight() ​

O método Str::padRight encapsula a função str_pad do PHP, preenchendo o lado direito de uma string com outra string até que a string final atinja o comprimento desejado:

php
    use Illuminate\Support\Str;

    $padded = Str::padRight('James', 10, '-');

    // 'James-----'

    $padded = Str::padRight('James', 10);

    // 'James     '

Str::password() ​

O método Str::password pode ser usado para gerar uma senha segura e aleatória de determinado tamanho. A senha consistirá em combinações de letras, números, símbolos e espaços. As senhas por padrão têm 32 caracteres:

php

    use Illuminate\Support\Str;

    $password = Str::password();

    // 'EbJo2vE-AS:U,$%_gkrV4n,q~1xy/-_4'

    $password = Str::password(12);

    // 'qwuar>#V|i]N'

Str::plural() ​

O método Str::plural converte uma string de palavra singular para sua forma plural. Esta função suporta as línguas que o pluralizador do Laravel suporta:

php
    use Illuminate\Support\Str;

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

    // cars

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

    // children

Você pode fornecer um número inteiro como segundo argumento da função para recuperar a forma singular ou plural da string:

php
    use Illuminate\Support\Str;

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

    // children

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

    // child

Str::pluralStudly() ​

O método Str::pluralStudly converte uma string de palavra singular formatada em studly caps case para sua forma plural. Esta função suporta qualquer uma das linguagens suportadas pelo pluralizador do Laravel:

php
    use Illuminate\Support\Str;

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

    // VerifiedHumans

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

    // UserFeedback

Você pode fornecer um inteiro como segundo argumento à função para recuperar a forma singular ou plural da string.

php
    use Illuminate\Support\Str;

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

    // VerifiedHumans

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

    // VerifiedHuman

Str::position() ​

O método Str::position retorna a posição da primeira ocorrência de uma substrings em uma string. Se a substring não existe na string especificada, false é retornado:

php
    use Illuminate\Support\Str;

    $position = Str::position('Hello, World!', 'Hello');

    // 0

    $position = Str::position('Hello, World!', 'W');

    // 7

Str::random() ​

O método Str::random gera uma string aleatória da extensão especificada. Esta função utiliza a função random_bytes do PHP:

php
    use Illuminate\Support\Str;

    $random = Str::random(40);

Durante os testes, pode ser útil "inventar" o valor retornado pelo método Str::random. Para fazer isso, você pode usar o método createRandomStringsUsing:

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

Para instruir o método random a retornar as gerações de cadeias aleatórias normalmente, você pode invocar o método createRandomStringsNormally:

php
    Str::createRandomStringsNormally();

Str::remover() ​

O método Str::remove remove o valor ou os valores dados da string:

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

Você também pode passar um terceiro argumento false para o método remove, caso queira ignorar os casos ao remover as strings.

Str::repeat() ​

O método Str::repeat repete a string dada:

php
use Illuminate\Support\Str;

$string = 'a';

$repeat = Str::repeat($string, 5);

// aaaaa

Str::replace() ​

O método Str::replace substitui uma determinada string no meio de uma string:

php
    use Illuminate\Support\Str;

    $string = 'Laravel 10.x';

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

    // Laravel 11.x

O método replace também aceita um argumento caseSensitive. Por padrão, o método replace é sensível às maiúsculas e minúsculas.

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

Str::replaceArray() ​

O método Str::replaceArray substitui um determinado valor na string de forma seqüencial usando uma matriz:

php
    use Illuminate\Support\Str;

    $string = 'The event will take place between ? and ?';

    $replaced = Str::replaceArray('?', ['8:30', '9:00'], $string);

    // O evento acontecerá entre 8h30 e 9h00

Str::replaceFirst() ​

O método Str::replaceFirst substitui a primeira ocorrência de um determinado valor em uma string:

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

O método Str::replaceLast substitui a última ocorrência de um determinado valor em uma string:

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

O método Str::replaceMatches substitui todas as partes de uma string que corresponde a um padrão pela string de substituição fornecida:

php
    use Illuminate\Support\Str;

    $replaced = Str::replaceMatches(
        pattern: '/[^A-Za-z0-9]++/',
        replace: '',
        subject: '(+1) 501-555-1000'
    )

    // '15015551000'

O método replaceMatches também aceita um closure que será invocado com cada parte da string correspondente ao padrão fornecido, permitindo que você execute a lógica de substituição dentro do closure e retorne o valor substituído:

php
    use Illuminate\Support\Str;

    $replaced = Str::replaceMatches('/\d/', function (array $matches) {
        return '['.$matches[0].']';
    }, '123');

    // '[1][2][3]'

Str::replaceStart() ​

O método Str::replaceStart substitui a primeira ocorrência do valor especificado apenas se o valor aparecer no início da string:

php
    use Illuminate\Support\Str;

    $replaced = Str::replaceStart('Hello', 'Laravel', 'Hello World');

    // Laravel World

    $replaced = Str::replaceStart('World', 'Laravel', 'Hello World');

    // Hello World

Str::replaceEnd() ​

O método Str::replaceEnd substitui a última ocorrência do valor indicado somente se este estiver no final da string:

php
    use Illuminate\Support\Str;

    $replaced = Str::replaceEnd('World', 'Laravel', 'Hello World');

    // Hello Laravel

    $replaced = Str::replaceEnd('Hello', 'Laravel', 'Hello World');

    // Hello World

Str::reverse() ​

O método Str::reverse inverte a ordem das letras da string passada como parâmetro:

php
    use Illuminate\Support\Str;

    $reversed = Str::reverse('Hello World');

    // dlroW olleH

Str::singular() ​

O método Str::singular converte uma string para sua forma singular. Essa função suporta qualquer uma das linguagens suportadas pelo pluralizador do Laravel:

php
    use Illuminate\Support\Str;

    $singular = Str::singular('cars');

    // car

    $singular = Str::singular('children');

    // child

Str::slug() ​

O método Str::slug gera um "slug" amigável da string fornecida:

php
    use Illuminate\Support\Str;

    $slug = Str::slug('Laravel 5 Framework', '-');

    // laravel-5-framework

Str::snake() ​

O método Str::snake converte a string dada em notação snake_case.

php
    use Illuminate\Support\Str;

    $converted = Str::snake('fooBar');

    // foo_bar

    $converted = Str::snake('fooBar', '-');

    // foo-bar

Str::squish() ​

O método Str::squish remove todos os espaços em branco não necessários de uma string, incluindo os entre palavras:

php
    use Illuminate\Support\Str;

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

    // laravel framework

Str::start() ​

O método Str::start adiciona uma única instância do valor dado a uma string, se não começar com ele.

php
    use Illuminate\Support\Str;

    $adjusted = Str::start('this/string', '/');

    // /this/string

    $adjusted = Str::start('/this/string', '/');

    // /this/string

Str::startsWith() ​

O método Str::startsWith verifica se a string fornecida começa com o valor indicado:

php
    use Illuminate\Support\Str;

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

    // true

Se um array de possíveis valores for passado, o método startsWith retornará true se a string começar com qualquer um dos valores apresentados:

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

    // true

Str::studly() ​

O método Str::studly converte a string em StudlyCase:

php
    use Illuminate\Support\Str;

    $converted = Str::studly('foo_bar');

    // FooBar

Str::substr() ​

O método Str::substr retorna a parte da string especificada pelos parâmetros start e length:

php
    use Illuminate\Support\Str;

    $converted = Str::substr('The Laravel Framework', 4, 7);

    // Laravel

Str::substrCount() ​

O método Str::substrCount retorna o número de ocorrências de um valor especificado numa determinada string:

php
    use Illuminate\Support\Str;

    $count = Str::substrCount('If you like ice cream, you will like snow cones.', 'like');

    // 2

Str::substrReplace() ​

O método Str::substrReplace substitui texto dentro de uma parte de uma string, começando na posição especificada pelo terceiro argumento e substituindo o número de caracteres especificado pelo quarto argumento. Passar 0 para o quarto argumento do método irá inserir a string na posição especificada sem substituir nenhum dos caracteres existentes na string:

php
    use Illuminate\Support\Str;

    $result = Str::substrReplace('1300', ':', 2);
    // 13:

    $result = Str::substrReplace('1300', ':', 2, 0);
    // 13:00

Str::swap() ​

O método Str::swap substitui vários valores na string fornecida utilizando a função strtr do PHP:

php
    use Illuminate\Support\Str;

    $string = Str::swap([
        'Tacos' => 'Burritos',
        'great' => 'fantastic',
    ], 'Tacos are great!');

    // Burritos are fantastic!

Str::take() ​

O método Str::take retorna um número especificado de caracteres do início de uma string:

php
    use Illuminate\Support\Str;

    $taken = Str::take('Build something amazing!', 5);

    // Build

Str::title() ​

O método Str::title converte a string fornecida para Title Case:

php
    use Illuminate\Support\Str;

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

    // A Nice Title Uses The Correct Case

Str::toBase64() ​

O método Str::toBase64 converte a string dada para o formato Base64:

php
    use Illuminate\Support\Str;

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

    // TGFyYXZlbA==

Str::toHtmlString() ​

O método Str::toHtmlString converte a instância da string em uma instância de Illuminate\Support\HtmlString, podendo ser exibida nos modelos Blade:

php
    use Illuminate\Support\Str;

    $htmlString = Str::of('Nuno Maduro')->toHtmlString();

Str::trim() ​

O método Str::trim elimina espaços em branco (ou outros caracteres) no início e no fim da string dada. Diferente da função nativa de PHP, o método Str::trim também remove espaços em branco unicode:

php
    use Illuminate\Support\Str;

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

    // 'foo bar'

Str::ltrim() ​

O método Str::ltrim remove os espaços em branco (ou outros caracteres) que aparecem no início da string fornecida. Diferente da função nativa ltrim do PHP, o método Str::ltrim também remove os espaços reservados Unicode:

php
    use Illuminate\Support\Str;

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

    // 'foo bar  '

Str::rtrim() ​

O método Str::rtrim remove espaços em branco (ou outros caracteres) do final da string fornecida. Diferentemente da função nativa rtrim do PHP, o método Str::rtrim também remove caracteres de espaço em branco unicode:

php
    use Illuminate\Support\Str;

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

    // '  foo bar'

Str::ucfirst() ​

O método Str::ucfirst retorna a string dada com o primeiro caractere maiúsculo:

php
    use Illuminate\Support\Str;

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

    // Foo bar

Str::ucsplit() ​

O método Str::ucsplit divide a string em um array com caracteres maiúsculos:

php
    use Illuminate\Support\Str;

    $segments = Str::ucsplit('FooBar');

    // [0 => 'Foo', 1 => 'Bar']

Str::upper() ​

O método Str::upper converte a string em maiúsculas:

php
    use Illuminate\Support\Str;

    $string = Str::upper('laravel');

    // LARAVEL

Str::ulid() ​

O método Str::ulid gera um identificador único de tempo ordenado e compacto conhecido como ULID:

php
    use Illuminate\Support\Str;

    return (string) Str::ulid();
    
    // 01gd6r360bp37zj17nxb55yv40

Se você quiser recuperar uma instância da classe Illuminate\Support\Carbon, que representa a data e hora em que o ULID especificado foi criado, poderá usar o método createFromId fornecido pela integração do Carbon no Laravel:

php
    use Illuminate\Support\Carbon;
    use Illuminate\Support\Str;

    $date = Carbon::createFromId((string) Str::ulid());

Durante o teste, talvez seja útil "inventar" um valor que será retornado pelo método Str::ulid. Para fazer isso, você pode usar o método createUlidsUsing:

php
    use Symfony\Component\Uid\Ulid;

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

Para instruir o método ulid a retornar normalmente os ULIDs, você pode invocar o método createUlidsNormally:

php
    Str::createUlidsNormally();

Str::unwrap() ​

O método Str::unwrap remove as letras iniciais e finais de uma string dada:

php
    use Illuminate\Support\Str;

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

    // Laravel

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

    // framework: "Laravel"

Str::uuid() ​

O método Str::uuid gera um UUID (versão 4):

php
    use Illuminate\Support\Str;

    return (string) Str::uuid();

Durante o teste, talvez seja útil "inventar" um valor que será retornado pelo método Str::uuid. Para fazer isso, você pode usar o método createUuidsUsing:

php
    use Ramsey\Uuid\Uuid;

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

Para instruir o método uuid a retornar para gerar UUIDs normalmente, você pode invocar o método createUuidsNormally:

php
    Str::createUuidsNormally();

Str::wordCount() ​

O método Str::wordCount retorna o número de palavras que uma string possui:

php
use Illuminate\Support\Str;

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

Str::wordWrap() ​

O método Str::wordWrap envolve uma cadeia para um número dado de caracteres:

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

O método Str::words limita o número de palavras numa string. Pode ser passada uma string adicional a este método através do terceiro argumento para especificar qual string deve ser anexada à extremidade da string truncada:

php
    use Illuminate\Support\Str;

    return Str::words('Perfectly balanced, as all things should be.', 3, ' >>>');

    // Perfectly balanced, as >>>

Str::wrap() ​

O método Str::wrap envolve a string dada em um ou mais pares de strings:

php
    use Illuminate\Support\Str;

    Str::wrap('Laravel', '"');

    // "Laravel"

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

    // This is Laravel!

str() ​

A função str retorna uma nova instância de Illuminate\Support\Stringable da string especificada, que é equivalente ao método Str::of.

php
    $string = str('Taylor')->append(' Otwell');

    // 'Taylor Otwell'

Se nenhum argumento for fornecido à função str, a função retorna uma instância padrão do Illuminate\Support\Str:

php
    $snake = str()->snake('FooBar');

    // 'foo_bar'

trans() ​

A função trans traduz a chave de tradução fornecida usando seus arquivos de idioma:

php
    echo trans('messages.welcome');

Se a chave de tradução especificada não existir, a função trans retornará a chave fornecida. Assim, usando o exemplo acima, a função trans retornaria messages.welcome se a chave de tradução não existir.

trans_choice() ​

A função trans_choice traduz a chave de tradução fornecida com inflexão:

php
    echo trans_choice('messages.notifications', $unreadCount);

Se a chave de tradução especificada não existir, a função trans_choice retornará a chave fornecida. Então, usando o exemplo acima, a função trans_choice retornaria messages.notifications se a chave de tradução não existir.

Strings fluentes ​

As cadeias ativas oferecem uma interface mais fluida e baseada em objetos para o trabalho com valores de cadeia, permitindo que você junte várias operações de cadeia usando uma sintaxe mais legível do que as operações tradicionais.

after ​

O método after retorna tudo o que aparece após o valor indicado numa string. A string inteira será retornada se o valor não estiver presente na string:

php
    use Illuminate\Support\Str;

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

    // ' my name'

afterLast ​

O método afterLast retorna tudo depois da última ocorrência do valor especificado numa string. A cadeia inteira é retornada se o valor não existir na cadeia:

php
    use Illuminate\Support\Str;

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

    // 'Controller'

apa ​

O método apa converte a string fornecida para maiúsculas de acordo com as diretrizes do APA:

php
    use Illuminate\Support\Str;

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

    // A Nice Title Uses the Correct Case

append ​

O método append adiciona os valores dados à string:

php
    use Illuminate\Support\Str;

    $string = Str::of('Taylor')->append(' Otwell');

    // 'Taylor Otwell'

ascii ​

O método ascii irá tentar traduzir a string para um valor ASCII:

php
    use Illuminate\Support\Str;

    $string = Str::of('ü')->ascii();

    // 'u'

basename ​

O método basename retorna o componente do nome seguido da string dada:

php
    use Illuminate\Support\Str;

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

    // 'baz'

Se necessário, você pode fornecer uma "extensão", que será removida do componente posterior:

php
    use Illuminate\Support\Str;

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

    // 'baz'

before ​

O método before retorna tudo antes do valor fornecido em uma string:

php
    use Illuminate\Support\Str;

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

    // 'This is '

beforeLast ​

O método beforeLast retorna tudo antes da última ocorrência do valor especificado em uma string.

php
    use Illuminate\Support\Str;

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

    // 'This '

between ​

O método entre retorna o trecho de uma string entre dois valores:

php
    use Illuminate\Support\Str;

    $converted = Str::of('This is my name')->between('This', 'name');

    // ' is my '

betweenFirst ​

O método betweenFirst retorna a menor porção possível de uma string entre dois valores:

php
    use Illuminate\Support\Str;

    $converted = Str::of('[a] bc [d]')->betweenFirst('[', ']');

    // 'a'

camel ​

O método camel converte a string dada para camelCase:

php
    use Illuminate\Support\Str;

    $converted = Str::of('foo_bar')->camel();

    // 'fooBar'

charAt ​

O método charAt retorna o caractere na posição especificada. Se a posição estiver fora dos limites do array, false é retornado:

php
    use Illuminate\Support\Str;

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

    // 's'

classBasename ​

O método classBasename retorna o nome de classe da classe especificada, com o namespace da classe removido:

php
    use Illuminate\Support\Str;

    $class = Str::of('Foo\Bar\Baz')->classBasename();

    // 'Baz'

contains ​

O método contains determina se a string indicada contém o valor especificado. Esse método é sensível às maiúsculas e minúsculas:

php
    use Illuminate\Support\Str;

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

    // true

Você também pode passar uma matriz de valores para determinar se a string contém algum valor da matriz:

php
    use Illuminate\Support\Str;

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

    // true

containsAll ​

O método containsAll determina se a string fornecida contém todas as valores do array:

php
    use Illuminate\Support\Str;

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

    // true

dirname ​

O método dirname retorna a parte do diretório pai da string fornecida:

php
    use Illuminate\Support\Str;

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

    // '/foo/bar'

Se necessário, você pode especificar quantos níveis de pasta pretende remover da string:

php
    use Illuminate\Support\Str;

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

    // '/foo'

excerpt ​

O método excerpt extrai um trecho da string que corresponde à primeira instância de uma frase nela contida:

php
    use Illuminate\Support\Str;

    $excerpt = Str::of('This is my name')->excerpt('my', [
        'radius' => 3
    ]);

    // '...is my na...'

A opção radius, que tem por padrão o valor 100, permite definir o número de caracteres que devem aparecer a cada lado da string truncado.

Além disso, é possível usar a opção omission para alterar a string que será adicionada antes e depois da string truncada.

php
    use Illuminate\Support\Str;

    $excerpt = Str::of('This is my name')->excerpt('name', [
        'radius' => 3,
        'omission' => '(...) '
    ]);

    // '(...) my name'

endsWith ​

O método endsWith determina se uma string termina com o valor especificado:

php
    use Illuminate\Support\Str;

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

    // true

Você também pode passar uma matriz de valores para determinar se a string fornecida termina com algum dos valores da matriz:

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

O método exactly determina se a string especificada corresponde exatamente à outra string:

php
    use Illuminate\Support\Str;

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

    // true

explode ​

O método explode divide a string pelo delimitador fornecido e retorna uma coleção contendo cada seção da string dividida:

php
    use Illuminate\Support\Str;

    $collection = Str::of('foo bar baz')->explode(' ');

    // collect(['foo', 'bar', 'baz'])

finish ​

O método finish adiciona uma única instância do valor indicado a uma string se esta não terminar com esse valor:

php
    use Illuminate\Support\Str;

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

    // this/string/

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

    // this/string/

headline ​

O método headline converte uma sequência de letras separadas por hifens ou sublinhados para uma sequência espaçada com as primeiras letras maiúsculas das palavras:

php
    use Illuminate\Support\Str;

    $headline = Str::of('taylor_otwell')->headline();

    // Taylor Otwell

    $headline = Str::of('EmailNotificationSent')->headline();

    // Email Notification Sent

inlineMarkdown ​

O método inlineMarkdown converte o Markdown com sabor do GitHub em HTML inline usando CommonMark. No entanto, diferentemente do método markdown, ele não encapsula todo o HTML gerado em um elemento de nível de bloco:

php
    use Illuminate\Support\Str;

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

    // <strong>Laravel</strong>

Segurança no Markdown ​

Por padrão, o Markdown suporta HTML bruto, o que irá expor vulnerabilidades de Cross-Site Scripting (XSS) quando usado com entrada bruta do usuário. Conforme a documentação do CommonMark Security, você pode usar a opção html_input para escapar ou remover HTML bruto, e a opção allow_unsafe_links para especificar se deve permitir links não seguros. Se você precisar permitir algum HTML bruto, você deve passar seu Markdown compilado por um Purificador de HTML:

php
    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” ​

O método is verifica se uma determinada string corresponde a um padrão especificado. Os asteriscos podem ser utilizados como valores de substituição.

php
    use Illuminate\Support\Str;

    $matches = Str::of('foobar')->is('foo*');

    // true

    $matches = Str::of('foobar')->is('baz*');

    // false

isAscii ​

O método isAscii determina se uma determinada string é uma string ASCII.

php
    use Illuminate\Support\Str;

    $result = Str::of('Taylor')->isAscii();

    // true

    $result = Str::of('ü')->isAscii();

    // false

isEmpty ​

O método isEmpty determina se a string fornecida está vazia:

php
    use Illuminate\Support\Str;

    $result = Str::of('  ')->trim()->isEmpty();

    // true

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

    // false

isNotEmpty. ​

O método isNotEmpty determina se a string fornecida não está vazia:

php
    use Illuminate\Support\Str;

    $result = Str::of('  ')->trim()->isNotEmpty();

    // false

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

    // true

isJson ​

O método isJson determina se uma determinada string é um JSON válido:

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

O método isUlid determina se uma string é um ULID:

php
    use Illuminate\Support\Str;

    $result = Str::of('01gd6r360bp37zj17nxb55yv40')->isUlid();

    // true

    $result = Str::of('Taylor')->isUlid();

    // false

isUrl ​

O método isUrl verifica se uma determinada string é um endereço de URL:

php
    use Illuminate\Support\Str;

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

    // true

    $result = Str::of('Taylor')->isUrl();

    // false

O método isUrl considera uma grande variedade de protocolos como válidos. No entanto, você pode especificar os protocolos que devem ser considerados válidos facultando-os ao método isUrl:

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

isUuid ​

O método isUuid verifica se uma determinada string é um GUID (Identificador global único):

php
    use Illuminate\Support\Str;

    $result = Str::of('5ace9ab9-e9cf-4ec6-a19d-5881212a452c')->isUuid();

    // true

    $result = Str::of('Taylor')->isUuid();

    // false

kebab ​

O método kebab converte a string fornecida para kebab-case:

php
    use Illuminate\Support\Str;

    $converted = Str::of('fooBar')->kebab();

    // foo-bar

lcfirst ​

O método lcfirst retorna a string indicada com o primeiro caractere minúscula:

php
    use Illuminate\Support\Str;

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

    // foo Bar

length ​

O método length retorna o comprimento do valor dado:

php
    use Illuminate\Support\Str;

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

    // 7

limit ​

O método limit trunca a string para a comprimento especificado.

php
    use Illuminate\Support\Str;

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

    // The quick brown fox...

Também é possível passar um segundo argumento para mudar a string que será anexada ao final da string truncada.

php
    use Illuminate\Support\Str;

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

    // The quick brown fox (...)

lower ​

O método lower converte a string dada para letras minúsculas:

php
    use Illuminate\Support\Str;

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

    // 'laravel'

markdown ​

O método markdown converte o Markdown com estilo do GitHub em HTML:

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

Sistema de segurança do Markdown ​

Por padrão, o Markdown suporta HTML bruto, o que irá expor vulnerabilidades de Cross-Site Scripting (XSS) quando usado com entrada bruta do usuário. Conforme a documentação do CommonMark Security, você pode usar a opção html_input para escapar ou remover HTML bruto, e a opção allow_unsafe_links para especificar se deve permitir links não seguros. Se você precisar permitir algum HTML bruto, você deve passar seu Markdown compilado por um Purificador de HTML:

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

O método mask mascara uma parte de uma string com um caractere repetido e pode ser usado para ofuscar segmentos de strings, como endereços de e-mail e números de telefone:

php
    use Illuminate\Support\Str;

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

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

Se necessário, você pode fornecer números negativos como o terceiro ou quarto argumento para o método mask, que instruirá o método a começar a mascarar na distância fornecida a partir do final da string:

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

    // tay***@example.com

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

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

match ​

O método match retornará a parte de uma string que corresponde a um determinado padrão de expressão regular:

php
    use Illuminate\Support\Str;

    $result = Str::of('foo bar')->match('/bar/');

    // 'bar'

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

    // 'bar'

matchAll ​

O método matchAll retorna uma coleção que contém as porções de uma string que correspondem a um padrão de expressão regular especificado:

php
    use Illuminate\Support\Str;

    $result = Str::of('bar foo bar')->matchAll('/bar/');

    // collect(['bar', 'bar'])

Se você especificar um grupo correspondente dentro da expressão, o Laravel retornará uma coleção dos primeiros matchs do primeiro grupo correspondente:

php
    use Illuminate\Support\Str;

    $result = Str::of('bar fun bar fly')->matchAll('/f(\w*)/');

    // collect(['un', 'ly']);

Se não forem encontradas correspondências, será devolvido um conjunto vazio.

isMatch ​

O método isMatch retornará true se a string corresponder a uma expressão regular fornecida:

php
    use Illuminate\Support\Str;

    $result = Str::of('foo bar')->isMatch('/foo (.*)/');

    // true

    $result = Str::of('laravel')->isMatch('/foo (.*)/');

    // false

newLine ​

O método newLine adiciona um caractere de "fim da linha" ao final de uma string.

php
    use Illuminate\Support\Str;

    $padded = Str::of('Laravel')->newLine()->append('Framework');

    // 'Laravel
    //  Framework'

padBoth ​

O método padBoth envolve a função PHP str_pad, que alinha os lados de uma string com outra até que o resultado final atinja um comprimento desejado:

php
    use Illuminate\Support\Str;

    $padded = Str::of('James')->padBoth(10, '_');

    // '__James___'

    $padded = Str::of('James')->padBoth(10);

    // '  James   '

padLeft ​

O método padLeft encapsula a função str_pad do PHP, preenchendo o lado esquerdo de uma string com outra string até que a string final atinja o comprimento desejado:

php
    use Illuminate\Support\Str;

    $padded = Str::of('James')->padLeft(10, '-=');

    // '-=-=-James'

    $padded = Str::of('James')->padLeft(10);

    // '     James'

padRight ​

O método padRight envolve a função PHP str_pad, preenchendo o lado direito de uma string com outra string até que a string final atinja o comprimento desejado.

php
    use Illuminate\Support\Str;

    $padded = Str::of('James')->padRight(10, '-');

    // 'James-----'

    $padded = Str::of('James')->padRight(10);

    // 'James     '

pipe ​

O método pipe permite que você transforme a string passando seu valor atual para o callable fornecido:

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

O método plural converte uma string de palavra singular para sua forma plural. Esta função suporta qualquer uma das linguagens suportadas pelo pluralizador do Laravel:

php
    use Illuminate\Support\Str;

    $plural = Str::of('car')->plural();

    // cars

    $plural = Str::of('child')->plural();

    // children

Você pode fornecer um inteiro como segundo parâmetro da função para recuperar a forma singular ou plural da string:

php
    use Illuminate\Support\Str;

    $plural = Str::of('child')->plural(2);

    // children

    $plural = Str::of('child')->plural(1);

    // child

position ​

O método position retorna a posição da primeira ocorrência de uma substring em uma string. Se a substring não existir dentro da string, false será retornado:

php
    use Illuminate\Support\Str;

    $position = Str::of('Hello, World!')->position('Hello');

    // 0

    $position = Str::of('Hello, World!')->position('W');

    // 7

"prepend" ​

O método prepend adiciona os valores dados no início da string:

php
    use Illuminate\Support\Str;

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

    // Laravel Framework

remove ​

O método remove remove o valor ou um array de valores da string:

php
    use Illuminate\Support\Str;

    $string = Str::of('Arkansas is quite beautiful!')->remove('quite');

    // Arkansas is beautiful!

Você também pode passar false como um segundo parâmetro para ignorar maiúsculas e minúsculas ao remover strings.

repetir ​

O método repeat repete a string passada como parâmetro:

php
use Illuminate\Support\Str;

$repeated = Str::of('a')->repeat(5);

// aaaaa

replace ​

O método replace substitui uma string especificada dentro da string:

php
    use Illuminate\Support\Str;

    $replaced = Str::of('Laravel 6.x')->replace('6.x', '7.x');

    // Laravel 7.x

O método replace também aceita um argumento caseSensitive. Por padrão, o método replace é sensível à minúsculas e maiúsculas.

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

replaceArray ​

O método replaceArray substitui um valor especificado na sequência da string utilizando uma matriz.

php
    use Illuminate\Support\Str;

    $string = 'The event will take place between ? and ?';

    $replaced = Str::of($string)->replaceArray('?', ['8:30', '9:00']);

    // O evento acontecerá entre 8h30 e 9h00

replaceFirst ​

O método replaceFirst substitui a primeira ocorrência de um determinado valor numa string:

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

O método replaceLast substitui a última ocorrência de um determinado valor em uma string:

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

O método replaceMatches substitui todas as partes de uma string que correspondam a um padrão com a string de substituição indicada:

php
    use Illuminate\Support\Str;

    $replaced = Str::of('(+1) 501-555-1000')->replaceMatches('/[^A-Za-z0-9]++/', '')

    // '15015551000'

O método replaceMatches também aceita um closure que é invocado com cada parte da string correspondente ao padrão fornecido, permitindo a execução da lógica de substituição dentro do closure e o retorno do valor substituído:

php
    use Illuminate\Support\Str;

    $replaced = Str::of('123')->replaceMatches('/\d/', function (array $matches) {
        return '['.$matches[0].']';
    });

    // '[1][2][3]'

replaceStart ​

O método replaceStart substitui o primeiro valor dado apenas se este aparecer no início da cadeia:

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

O método replaceEnd substitui a última ocorrência do valor fornecido, somente se o valor aparecer no final da string.

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

O método scan analisa o conteúdo de uma string numa coleção, com base em um formato suportado pela função sscanf do PHP:

php
    use Illuminate\Support\Str;

    $collection = Str::of('filename.jpg')->scan('%[^.].%s');

    // collect(['filename', 'jpg'])

singular ​

O método singular converte uma string para sua forma singular. Esta função suporta qualquer um dos idiomas suportados pelo pluralizador do Laravel:

php
    use Illuminate\Support\Str;

    $singular = Str::of('cars')->singular();

    // car

    $singular = Str::of('children')->singular();

    // child

slug ​

O método slug gera um "slug" amigável à URL a partir da string fornecida:

php
    use Illuminate\Support\Str;

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

    // laravel-framework

snake ​

O método snake converte a string dada para o formato "case_sensitive":

php
    use Illuminate\Support\Str;

    $converted = Str::of('fooBar')->snake();

    // foo_bar

split ​

O método split divide uma string em vários elementos, utilizando um padrão regex:

php
    use Illuminate\Support\Str;

    $segments = Str::of('one, two, three')->split('/[\s,]+/');

    // collect(["one", "two", "three"])

squish ​

O método squish remove todos os espaços em branco estranhos de uma string, incluindo espaços em branco estranhos entre palavras:

php
    use Illuminate\Support\Str;

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

    // laravel framework

start ​

O método start adiciona uma única instância do valor fornecido a uma string se ela ainda não começar com esse valor:

php
    use Illuminate\Support\Str;

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

    // /this/string

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

    // /this/string

startsWith ​

O método startsWith determina se a string fornecida começa com o valor especificado:

php
    use Illuminate\Support\Str;

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

    // true

stripTags ​

O método stripTags remove todos os marcadores HTML e PHP de uma string:

php
    use Illuminate\Support\Str;

    $result = Str::of('<a href="https://laravel.com">Taylor <b>Otwell</b></a>')->stripTags();

    // Taylor Otwell

    $result = Str::of('<a href="https://laravel.com">Taylor <b>Otwell</b></a>')->stripTags('<b>');

    // Taylor <b>Otwell</b>

studly ​

O método studly converte a string em um StudlyCase:

php
    use Illuminate\Support\Str;

    $converted = Str::of('foo_bar')->studly();

    // FooBar

substr ​

O método substr retorna a porção da string especificada pelos parâmetros de início e tamanho fornecidos:

php
    use Illuminate\Support\Str;

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

    // Framework

    $string = Str::of('Laravel Framework')->substr(8, 5);

    // Frame

substrReplace ​

O método substrReplace substitui texto dentro de uma parte de uma string, começando na posição especificada pelo segundo argumento e substituindo o número de caracteres especificado pelo terceiro argumento. Passar 0 para o terceiro argumento do método irá inserir a string na posição especificada sem substituir nenhum dos caracteres existentes na string:

php
    use Illuminate\Support\Str;

    $string = Str::of('1300')->substrReplace(':', 2);

    // 13:

    $string = Str::of('The Framework')->substrReplace(' Laravel', 3, 0);

    // The Laravel Framework

swap ​

O método swap substitui múltiplos valores na string utilizando a função strtr do PHP:

php
    use Illuminate\Support\Str;

    $string = Str::of('Tacos are great!')
        ->swap([
            'Tacos' => 'Burritos',
            'great' => 'fantastic',
        ]);

    // Burritos are fantastic!

take ​

O método take retorna um número especificado de caracteres do início da cadeia:

php
    use Illuminate\Support\Str;

    $taken = Str::of('Build something amazing!')->take(5);

    // Build

tap ​

O método tap passa a string para o closure fornecido, permitindo que você examine e interaja com a string sem afetar a string em si. A string original é retornada pelo método tap independentemente do que é retornado pelo closure:

php
    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" ​

O método test determina se uma string corresponde ao padrão de expressão regular indicado:

php
    use Illuminate\Support\Str;

    $result = Str::of('Laravel Framework')->test('/Laravel/');

    // true

"title" ​

O método title converte a frase dada para Title Case:

php
    use Illuminate\Support\Str;

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

    // A Nice Title Uses The Correct Case

toBase64() ​

O método toBase64 converte a string dada para Base64:

php
    use Illuminate\Support\Str;

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

    // TGFyYXZlbA==

trim ​

O método trim corta a string dada. Diferentemente da função nativa trim do PHP, o método trim do Laravel também remove caracteres de espaço em branco unicode:

php
    use Illuminate\Support\Str;

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

    // 'Laravel'

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

    // 'Laravel'

ltrim ​

O método ltrim remove o lado esquerdo da string. Diferente do que acontece com a função nativa de PHP, o ltrim de Laravel remove também os caracteres espaços reservados unicode:

php
    use Illuminate\Support\Str;

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

    // 'Laravel  '

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

    // 'Laravel/'

rtrim ​

O método rtrim corta o lado direito da string fornecida. Diferentemente da função nativa rtrim do PHP, o método rtrim do Laravel também remove caracteres de espaço em branco unicode:

php
    use Illuminate\Support\Str;

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

    // '  Laravel'

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

    // '/Laravel'

ucfirst ​

O método ucfirst retorna a string fornecida com o primeiro caractere em maiúscula:

php
    use Illuminate\Support\Str;

    $string = Str::of('foo bar')->ucfirst();

    // Foo bar

ucsplit ​

O método ucsplit divide a string fornecida em uma coleção por caracteres maiúsculos:

php
    use Illuminate\Support\Str;

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

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

unwrap ​

O método unwrap remove as frases especificadas do começo e do final de uma determinada frase:

php
    use Illuminate\Support\Str;

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

    // Laravel

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

    // framework: "Laravel"

upper ​

O método upper converte a string indicada para letras maiúsculas:

php
    use Illuminate\Support\Str;

    $adjusted = Str::of('laravel')->upper();

    // LARAVEL

when ​

O método when invoca o closure fornecido se uma condição fornecida for true. O closure receberá a instância de string fluent:

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

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

    // 'Taylor Otwell'

Se necessário, você pode passar outro closure como o terceiro parâmetro para o método when. Este closure será executado se o parâmetro de condição for avaliado como false.

whenContains ​

O método whenContains invoca o closure fornecido se a string contiver o valor fornecido. O closure receberá a instância da string fluent:

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

    $string = Str::of('tony stark')
                ->whenContains('tony', function (Stringable $string) {
                    return $string->title();
                });

    // 'Tony Stark'

Se necessário, você pode passar outro closure como o terceiro parâmetro para o método when. Este closure será executado se a string não contiver o valor fornecido.

Você também pode passar um array de valores para determinar se a string fornecida contém algum dos valores no array:

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

O método whenContainsAll invoca o closure fornecido se a string contiver todas as substrings fornecidas. O closure receberá a instância da string fluent:

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

    $string = Str::of('tony stark')
                    ->whenContainsAll(['tony', 'stark'], function (Stringable $string) {
                        return $string->title();
                    });

    // 'Tony Stark'

Se necessário, você pode passar outra função como terceiro parâmetro para o método when. Essa função será executada se o valor da variável condition avaliar como false.

whenEmpty ​

O método whenEmpty chama o closure especificado se a string estiver vazia. Se o closure retornar um valor, esse valor será também retornado pelo método whenEmpty. Se o closure não retornar um valor, será retornada uma string de texto fluent:

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

    $string = Str::of('  ')->whenEmpty(function (Stringable $string) {
        return $string->trim()->prepend('Laravel');
    });

    // 'Laravel'

whenNotEmpty ​

O método whenNotEmpty chama o closure indicado se a string não estiver vazia. Se o closure retornar um valor, esse valor também será retornado pelo método whenNotEmpty. Se o closure não retornar um valor, será retornada uma instância da string fluent:

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

    $string = Str::of('Framework')->whenNotEmpty(function (Stringable $string) {
        return $string->prepend('Laravel ');
    });

    // 'Laravel Framework'

whenStartsWith ​

O método whenStartsWith chama o closure fornecido se a string começar com a substring fornecida. O closure recebe a instância de string fluent:

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

    $string = Str::of('disney world')->whenStartsWith('disney', function (Stringable $string) {
        return $string->title();
    });

    // 'Disney World'

whenEndsWith, ​

O método whenEndsWith invoca o closure fornecido se a string terminar com a substring fornecida. O closure receberá a instância da string fluente:

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

    $string = Str::of('disney world')->whenEndsWith('world', function (Stringable $string) {
        return $string->title();
    });

    // 'Disney World'

whenExactly ​

O método whenExactly invoca o closure fornecido se a string corresponder exatamente à string fornecida. O closure receberá a instância da string fluente:

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

    $string = Str::of('laravel')->whenExactly('laravel', function (Stringable $string) {
        return $string->title();
    });

    // 'Laravel'

whenNotExactly ​

O método whenNotExactly invoca o closure fornecido se a string não corresponder exatamente à string fornecida. O closure receberá a instância de string fluent:

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

    $string = Str::of('framework')->whenNotExactly('laravel', function (Stringable $string) {
        return $string->title();
    });

    // 'Framework'

whenIs ​

O método whenIs invoca o closure fornecido se a string corresponder a um padrão fornecido. Asteriscos podem ser usados ​​como valores curinga. O closure receberá a instância da string fluent:

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

O método whenIsAscii executa o closure indicado se a string for ASCII de 7 bits. O closure recebe uma instância da string fluent:

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

    $string = Str::of('laravel')->whenIsAscii(function (Stringable $string) {
        return $string->title();
    });

    // 'Laravel'

whenIsUlid ​

O método whenIsUlid chama o closure indicado se a string for um ULID válido. O closure receberá a instância de string fluent:

php
    use Illuminate\Support\Str;

    $string = Str::of('01gd6r360bp37zj17nxb55yv40')->whenIsUlid(function (Stringable $string) {
        return $string->substr(0, 8);
    });

    // '01gd6r36'

whenIsUuid ​

O método whenIsUuid chama o closure indicado se a string for um UUID válido. O closure recebe a instância de string fluent:

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

O método whenTest invoca o closure fornecido se a string corresponder à expressão regular fornecida. O closure receberá a instância de string fluente:

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

    $string = Str::of('laravel framework')->whenTest('/laravel/', function (Stringable $string) {
        return $string->title();
    });

    // 'Laravel Framework'

wordCount ​

O método wordCount retorna o número de palavras que uma string contém:

php
use Illuminate\Support\Str;

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

words ​

O método words limita o número de palavras em uma string. Se necessário, você pode especificar uma string adicional que será anexada à string truncada:

php
    use Illuminate\Support\Str;

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

    // Perfectly balanced, as >>>