Prologo

Primi Passi

Architettura

Le Basi

Approfondimenti

Sicurezza

Database

Eloquent ORM

Testing

Package

Stringhe

Introduzione

Laravel offre una varietà di funzioni per gestire le stringhe. Molte di queste sono usate dal framework stesso; tuttavia, puoi usarle nelle tue applicazioni se le trovi utili.

Metodi Disponibili

Stringhe

Stringhe Fluenti

Stringhe

__()

La funzione __ traduce la stringa di traduzione o la chiave di traduzione fornita utilizzando i tuoi file di lingua:

echo __('Welcome to our application');

echo __('messages.welcome');

Se la stringa di traduzione o la chiave specificata non esiste, la funzione __ restituirà il valore fornito. Quindi, nell’esempio sopra, la funzione __ restituirebbe messages.welcome se quella chiave di traduzione non esiste.

class_basename()

La funzione class_basename ritorna il nome della classe specificata senza includere il namespace:

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

// Baz

e()

La funzione e esegue la funzione htmlspecialchars di PHP con l’opzione double_encode impostata su true per impostazione predefinita:

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

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

preg_replace_array()

La funzione preg_replace_array sostituisce un pattern specifico nella stringa in sequenza utilizzando un array:

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

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

// The event will take place between 8:30 and 9:00

Str::after()

Il metodo Str::after restituisce tutto ciò che segue un determinato valore all’interno di una stringa. Se il valore non è presente nella stringa, verrà restituita l’intera stringa:

use Illuminate\Support\Str;

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

// ' my name'

Str::afterLast()

Il metodo Str::afterLast restituisce tutto ciò che si trova dopo l’ultima occorrenza del valore specificato in una stringa. L’intera stringa verrà restituita se il valore non esiste nella stringa:

use Illuminate\Support\Str;

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

// 'Controller'

Str::apa()

Il metodo Str::apa trasforma la stringa fornita in title case seguendo le linee guida APA:

use Illuminate\Support\Str;

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

// 'Creating a Project'

Str::ascii()

Il metodo Str::ascii cerca di traslitterare la stringa in un valore ASCII:

use Illuminate\Support\Str;

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

// 'u'

Str::before()

Il metodo Str::before restituisce tutto ciò che precede il valore dato in una stringa:

use Illuminate\Support\Str;

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

// 'This is '

Str::beforeLast()

Il metodo Str::beforeLast restituisce tutto ciò che c’è prima dell’ultima occorrenza del valore specificato in una stringa:

use Illuminate\Support\Str;

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

// 'This '

Str::between()

Il metodo Str::between restituisce la porzione di una stringa compresa tra due valori:

use Illuminate\Support\Str;

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

// ' is my '

Str::betweenFirst()

Il metodo Str::betweenFirst restituisce la porzione più piccola possibile di una stringa compresa tra due valori:

use Illuminate\Support\Str;

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

// 'a'

Str::camel()

Il metodo Str::camel converte la stringa fornita in camelCase:

use Illuminate\Support\Str;

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

// 'fooBar'

Str::charAt()

Il metodo Str::charAt restituisce il carattere all’indice specificato. Se l’indice è fuori dai limiti, viene restituito false:

use Illuminate\Support\Str;

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

// 's'

Str::chopStart()

Il metodo Str::chopStart rimuove la prima occorrenza del valore specificato solo se appare all’inizio della stringa:

use Illuminate\Support\Str;

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

// 'laravel.com'

Puoi anche passare un array come secondo argomento. Se la stringa inizia con uno dei valori nell’array, quel valore verrà rimosso dalla stringa:

use Illuminate\Support\Str;

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

// 'laravel.com'

Str::chopEnd()

Il metodo Str::chopEnd rimuove l’ultima occorrenza del valore specificato solo se appare alla fine della stringa:

use Illuminate\Support\Str;

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

// 'app/Models/Photograph'

Puoi anche passare un array come secondo argomento. Se la stringa finisce con uno dei valori nell’array, quel valore verrà rimosso dalla stringa:

use Illuminate\Support\Str;

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

// 'laravel.com'

Str::contains()

Il metodo Str::contains determina se la stringa fornita contiene il valore specificato. Per impostazione predefinita questo metodo è sensibile alle maiuscole:

use Illuminate\Support\Str;

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

// true

Puoi anche passare un array di valori per verificare se la stringa contiene uno qualsiasi dei valori nell’array:

use Illuminate\Support\Str;

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

// true

Puoi disabilitare la sensibilità alle maiuscole impostando l’argomento ignoreCase a true:

use Illuminate\Support\Str;

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

// true

Str::containsAll()

Il metodo Str::containsAll determina se la stringa fornita contiene tutti i valori in un array specificato:

use Illuminate\Support\Str;

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

// true

Puoi disabilitare la sensibilità al maiuscolo/minuscolo impostando l’argomento ignoreCase a true:

use Illuminate\Support\Str;

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

// true

Str::doesntContain()

Il metodo Str::doesntContain determina se la stringa fornita non contiene il valore specificato. Per impostazione predefinita, questo metodo distingue tra maiuscole e minuscole:

use Illuminate\Support\Str;

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

// true

Puoi anche passare un array di valori per verificare se la stringa fornita non contiene nessuno dei valori nell’array:

use Illuminate\Support\Str;

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

// true

Puoi disabilitare la distinzione tra maiuscole e minuscole impostando l’argomento ignoreCase a true:

use Illuminate\Support\Str;

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

// true

Str::deduplicate()

Il metodo Str::deduplicate sostituisce le occorrenze consecutive di un carattere con una sola istanza di quel carattere nella stringa fornita. Per impostazione predefinita, il metodo deduplica gli spazi:

use Illuminate\Support\Str;

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

// The Laravel Framework

Puoi specificare un carattere diverso da deduplicare passando come secondo argomento al metodo:

use Illuminate\Support\Str;

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

// The-Laravel-Framework

Str::endsWith()

Il metodo Str::endsWith verifica se la stringa fornita termina con il valore specificato:

use Illuminate\Support\Str;

$result = Str::endsWith('Questo è il mio nome', 'nome');

// true

Puoi anche passare un array di valori per verificare se la stringa termina con uno dei valori nell’array:

use Illuminate\Support\Str;

$result = Str::endsWith('Questo è il mio nome', ['nome', 'foo']);

// true

$result = Str::endsWith('Questo è il mio nome', ['questo', 'foo']);

// false

Str::excerpt()

Il metodo Str::excerpt estrae un estratto da una stringa data che corrisponde alla prima occorrenza di una frase all’interno di quella stringa:

    use Illuminate\Support\Str;

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

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

L’opzione radius, che di default è 100, ti permette di definire il numero di caratteri che devono apparire su ogni lato della stringa troncata.

Inoltre, puoi usare l’opzione omission per definire la stringa che verrà preceduta e seguita alla stringa troncata:

    use Illuminate\Support\Str;

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

    // '(...) my name'

Str::finish()

Il metodo Str::finish aggiunge una singola istanza del valore dato a una stringa se non termina già con quel valore:

use Illuminate\Support\Str;

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

// this/string/

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

// this/string/

Str::headline()

Il metodo Str::headline converte le stringhe separate da maiuscole, trattini o underscore in una stringa separata da spazi, con la prima lettera di ogni parola in maiuscolo:

use Illuminate\Support\Str;

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

// Steve Jobs

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

// Email Notification Sent

Str::inlineMarkdown()

Il metodo Str::inlineMarkdown converte il Markdown di GitHub in HTML inline usando CommonMark. Tuttavia, a differenza del metodo markdown, non avvolge tutto l’HTML generato in un elemento di blocco:

use Illuminate\Support\Str;

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

// <strong>Laravel</strong>

Sicurezza in Markdown

Per impostazione predefinita, Markdown supporta HTML grezzo, il che può esporre a vulnerabilità di Cross-Site Scripting (XSS) quando viene utilizzato con input utente non filtrato. Secondo la documentazione sulla sicurezza di CommonMark, puoi utilizzare l’opzione html_input per sfuggire o rimuovere l’HTML grezzo e l’opzione allow_unsafe_links per specificare se consentire link non sicuri. Se hai bisogno di permettere un po’ di HTML grezzo, dovresti passare il tuo Markdown compilato attraverso un HTML Purifier:

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

Il metodo Str::is determina se una stringa fornita corrisponde a un determinato pattern. Gli asterischi possono essere usati come caratteri jolly:

    use Illuminate\Support\Str;

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

    // true

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

    // false

Puoi disabilitare la sensibilità alle maiuscole impostando l’argomento ignoreCase su true:

    use Illuminate\Support\Str;

    $matches = Str::is('*.jpg', 'photo.JPG', ignoreCase: true);     

    // true

Str::isAscii()

Il metodo Str::isAscii determina se una stringa data è ASCII a 7 bit:

use Illuminate\Support\Str;

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

// true

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

// false

Str::isJson()

Il metodo Str::isJson verifica se la stringa fornita è un JSON valido:

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

Il metodo Str::isUrl determina se la stringa fornita è un URL valido:

    use Illuminate\Support\Str;

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

    // true

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

    // false

Il metodo isUrl considera validi una vasta gamma di protocolli. Tuttavia, puoi specificare i protocolli che devono essere considerati validi fornendoli al metodo isUrl:

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

Str::isUlid()

Il metodo Str::isUlid determina se la stringa fornita è un ULID valido:

use Illuminate\Support\Str;

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

// true

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

// false

Str::isUuid()

Il metodo Str::isUuid determina se la stringa fornita è un UUID valido:

use Illuminate\Support\Str;

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

// true

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

// false

Str::kebab()

Il metodo Str::kebab trasforma una stringa in kebab-case:

use Illuminate\Support\Str;

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

// foo-bar

Str::lcfirst()

Il metodo Str::lcfirst restituisce la stringa fornita con il primo carattere in minuscolo:

use Illuminate\Support\Str;

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

// foo Bar

Str::length()

Il metodo Str::length restituisce la lunghezza della stringa fornita:

use Illuminate\Support\Str;

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

// 7

Str::limit()

Il metodo Str::limit tronca la stringa data alla lunghezza specificata:

    use Illuminate\Support\Str;

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

    // The quick brown fox...

Puoi passare un terzo argomento al metodo per cambiare la stringa che verrà aggiunta alla fine della stringa troncata:

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

    // The quick brown fox (...)

Se desideri preservare le parole complete durante il troncamento della stringa, puoi utilizzare l’argomento preserveWords. Quando questo argomento è true, la stringa verrà troncata al confine della parola completa più vicino:

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

    // The quick...

Str::lower()

Il metodo Str::lower converte la stringa data in minuscolo:

use Illuminate\Support\Str;

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

// laravel

Str::markdown()

Il metodo Str::markdown converte il GitHub flavored Markdown in HTML usando CommonMark:

    use Illuminate\Support\Str;

    $html = Str::markdown('# Laravel');

    // <h1>Laravel</h1>

    $html = Str::markdown('# Taylor <b>Otwell</b>', [
        'html_input' => 'strip',
    ]);

    // <h1>Taylor Otwell</h1>

Sicurezza in Markdown

Per impostazione predefinita, Markdown supporta l’HTML grezzo, il che può esporre a vulnerabilità di Cross-Site Scripting (XSS) quando si utilizza input utente non filtrato. Secondo la documentazione sulla sicurezza di CommonMark, puoi usare l’opzione html_input per sfuggire o rimuovere l’HTML grezzo, e l’opzione allow_unsafe_links per specificare se permettere link non sicuri. Se hai bisogno di consentire un po’ di HTML grezzo, dovresti passare il tuo Markdown compilato attraverso un HTML Purifier:

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

Il metodo Str::mask maschera una parte di una stringa con un carattere ripetuto e può essere usato per offuscare segmenti di stringhe come indirizzi email e numeri di telefono:

use Illuminate\Support\Str;

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

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

Se necessario, puoi fornire un numero negativo come terzo argomento al metodo mask, il che farà sì che il mascheramento inizi a una certa distanza dalla fine della stringa:

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

// tay***@example.com

Str::orderedUuid()

Il metodo Str::orderedUuid genera un UUID "timestamp first" che può essere memorizzato in modo efficiente in una colonna di database indicizzata. Ogni UUID generato usando questo metodo sarà ordinato dopo gli UUID generati precedentemente tramite il metodo:

    use Illuminate\Support\Str;

    return (string) Str::orderedUuid();

Str::padBoth()

Il metodo Str::padBoth incapsula la funzione str_pad di PHP, aggiungendo caratteri su entrambi i lati di una stringa con un’altra stringa fino a quando la stringa finale raggiunge la lunghezza desiderata:

use Illuminate\Support\Str;

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

// '__James___'

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

// '  James   '

Str::padLeft()

Il metodo Str::padLeft utilizza la funzione str_pad di PHP, aggiungendo a sinistra di una stringa un’altra stringa fino a raggiungere la lunghezza desiderata:

use Illuminate\Support\Str;

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

// '-=-=-James'

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

// '     James'

Str::padRight()

Il metodo Str::padRight incapsula la funzione str_pad di PHP, aggiungendo a destra di una stringa un’altra stringa fino a raggiungere la lunghezza desiderata:

use Illuminate\Support\Str;

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

// 'James-----'

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

// 'James     '

Str::password()

Il metodo Str::password può essere usato per generare una password sicura e casuale di una lunghezza specificata. La password sarà composta da una combinazione di lettere, numeri, simboli e spazi. Di default, le password hanno 32 caratteri:

    use Illuminate\Support\Str;

    $password = Str::password();

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

    $password = Str::password(12);

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

Str::plural()

Il metodo Str::plural converte una stringa al singolare nella sua forma plurale. Questa funzione supporta qualsiasi lingua supportata dal pluralizzatore di Laravel:

    use Illuminate\Support\Str;

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

    // cars

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

    // children

Puoi fornire un intero come secondo argomento alla funzione per ottenere la forma singolare o plurale della stringa:

    use Illuminate\Support\Str;

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

    // children

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

    // child

Str::pluralStudly()

Il metodo Str::pluralStudly converte una stringa singolare formattata in studly caps case nella sua forma plurale. Questa funzione supporta qualsiasi delle lingue supportate dal pluralizzatore di Laravel:

use Illuminate\Support\Str;

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

// VerifiedHumans

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

// UserFeedback

Puoi fornire un intero come secondo argomento alla funzione per ottenere la forma singolare o plurale della stringa:

use Illuminate\Support\Str;

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

// VerifiedHumans

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

// VerifiedHuman

Str::position()

Il metodo Str::position restituisce la posizione della prima occorrenza di una sottostringa in una stringa. Se la sottostringa non esiste nella stringa fornita, viene restituito false:

    use Illuminate\Support\Str;

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

    // 0

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

    // 7

Str::random()

Il metodo Str::random genera una stringa casuale della lunghezza specificata. Questa funzione utilizza la funzione random_bytes di PHP:

use Illuminate\Support\Str;

$random = Str::random(40);

Durante i test, potrebbe essere utile "fingere" il valore restituito dal metodo Str::random. Per fare ciò, puoi usare il metodo createRandomStringsUsing:

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

Per far sì che il metodo random torni a generare stringhe casuali normalmente, puoi invocare il metodo createRandomStringsNormally:

Str::createRandomStringsNormally();

Str::remove()

Il metodo Str::remove rimuove il valore fornito o un array di valori dalla stringa:

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.

Puoi anche passare false come terzo argomento al metodo remove per ignorare la distinzione tra maiuscole e minuscole durante la rimozione delle stringhe.

Str::repeat()

Il metodo Str::repeat ripete la stringa fornita:

use Illuminate\Support\Str;

$string = 'a';

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

// aaaaa

Str::replace()

Il metodo Str::replace sostituisce una determinata stringa all’interno della stringa:

    use Illuminate\Support\Str;

    $string = 'Laravel 10.x';

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

    // Laravel 11.x

Il metodo replace accetta anche un argomento caseSensitive. Per impostazione predefinita, il metodo replace è sensibile alle maiuscole:

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

Str::replaceArray()

Il metodo Str::replaceArray sostituisce un valore dato nella stringa in modo sequenziale usando un array:

use Illuminate\Support\Str;

$string = 'L\'evento avrà luogo tra ? e ?';

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

// L'evento avrà luogo tra 8:30 e 9:00

Str::replaceFirst()

Il metodo Str::replaceFirst sostituisce la prima occorrenza di un valore specificato in una stringa:

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

Il metodo Str::replaceLast sostituisce l’ultima occorrenza di un valore dato in una stringa:

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

Il metodo Str::replaceMatches sostituisce tutte le parti di una stringa che corrispondono a un pattern con la stringa di sostituzione fornita:

use Illuminate\Support\Str;

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

// '15015551000'

Il metodo replaceMatches accetta anche una closure che verrà invocata per ogni porzione della stringa che corrisponde al pattern specificato, permettendoti di eseguire la logica di sostituzione all’interno della closure e restituire il valore sostituito:

use Illuminate\Support\Str;

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

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

Str::replaceStart()

Il metodo Str::replaceStart sostituisce la prima occorrenza del valore fornito solo se il valore si trova all’inizio della stringa:

use Illuminate\Support\Str;

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

// Laravel World

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

// Hello World

Str::replaceEnd()

Il metodo Str::replaceEnd sostituisce l’ultima occorrenza del valore specificato solo se appare alla fine della stringa:

    use Illuminate\Support\Str;

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

    // Hello Laravel

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

    // Hello World

Str::reverse()

Il metodo Str::reverse inverte la stringa fornita:

use Illuminate\Support\Str;

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

// dlroW olleH

Str::singular()

Il metodo Str::singular converte una stringa nella sua forma singolare. Questa funzione supporta tutte le lingue supportate dal pluralizzatore di Laravel:

use Illuminate\Support\Str;

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

// car

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

// child

Str::slug()

Il metodo Str::slug genera uno "slug" adatto per URL dalla stringa fornita:

use Illuminate\Support\Str;

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

// laravel-5-framework

Str::snake()

Il metodo Str::snake converte la stringa data in snake_case:

use Illuminate\Support\Str;

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

// foo_bar

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

// foo-bar

Str::squish()

Il metodo Str::squish rimuove tutti gli spazi bianchi in eccesso da una stringa, inclusi quelli tra le parole:

use Illuminate\Support\Str;

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

// laravel framework

Str::start()

Il metodo Str::start aggiunge un’unica occorrenza del valore fornito all’inizio di una stringa se non inizia già con quel valore:

use Illuminate\Support\Str;

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

// /this/string

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

// /this/string

Str::startsWith()

Il metodo Str::startsWith determina se la stringa fornita inizia con il valore specificato:

use Illuminate\Support\Str;

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

// true

Se viene passato un array di possibili valori, il metodo startsWith restituirà true se la stringa inizia con uno dei valori forniti:

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

// true

Str::studly()

Il metodo Str::studly trasforma la stringa fornita in StudlyCase:

use Illuminate\Support\Str;

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

// FooBar

Str::substr()

Il metodo Str::substr restituisce la parte di una stringa indicata dai parametri di inizio e lunghezza:

use Illuminate\Support\Str;

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

// Laravel

Str::substrCount()

Il metodo Str::substrCount restituisce il numero di occorrenze di un valore specificato in una stringa data:

use Illuminate\Support\Str;

$count = Str::substrCount('Se ti piace il gelato, ti piaceranno i coni di neve.', 'like');

// 2

Str::substrReplace()

Il metodo Str::substrReplace sostituisce del testo in una parte di una stringa, a partire dalla posizione indicata dal terzo argomento e sostituendo il numero di caratteri specificato dal quarto argomento. Passare 0 come quarto argomento inserirà la stringa nella posizione specificata senza rimuovere i caratteri esistenti nella stringa:

use Illuminate\Support\Str;

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

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

Str::swap()

Il metodo Str::swap sostituisce più valori nella stringa fornita usando la funzione strtr di PHP:

use Illuminate\Support\Str;

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

// Burritos are fantastic!

Str::take()

Il metodo Str::take restituisce un numero specifico di caratteri dall’inizio di una stringa:

use Illuminate\Support\Str;

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

// Build

Str::title()

Il metodo Str::title converte la stringa fornita in Title Case:

use Illuminate\Support\Str;

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

// A Nice Title Uses The Correct Case

Str::toBase64()

Il metodo Str::toBase64 converte la stringa fornita in Base64:

use Illuminate\Support\Str;

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

// TGFyYXZlbA==

Str::transliterate()

Il metodo Str::transliterate tenterà di convertire una stringa fornita nella sua rappresentazione ASCII più vicina:

use Illuminate\Support\Str;

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

// 'test@laravel.com'

Str::trim()

Il metodo Str::trim rimuove gli spazi bianchi (o altri caratteri) dall’inizio e dalla fine della stringa fornita. A differenza della funzione nativa trim di PHP, il metodo Str::trim elimina anche i caratteri di spazio bianco unicode:

use Illuminate\Support\Str;

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

// 'foo bar'

Str::ltrim()

Il metodo Str::ltrim rimuove gli spazi bianchi (o altri caratteri) dall’inizio della stringa fornita. A differenza della funzione nativa ltrim di PHP, il metodo Str::ltrim elimina anche i caratteri di spazio Unicode:

    use Illuminate\Support\Str;

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

    // 'foo bar  '

Str::rtrim()

Il metodo Str::rtrim rimuove gli spazi (o altri caratteri) dalla fine della stringa fornita. A differenza della funzione nativa di PHP rtrim, il metodo Str::rtrim rimuove anche i caratteri di spazio unicode:

use Illuminate\Support\Str;

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

// '  foo bar'

Str::ucfirst()

Il metodo Str::ucfirst restituisce la stringa fornita con il primo carattere maiuscolo:

use Illuminate\Support\Str;

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

// Foo bar

Str::ucsplit()

Il metodo Str::ucsplit suddivide la stringa fornita in un array utilizzando i caratteri maiuscoli:

use Illuminate\Support\Str;

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

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

Str::upper()

Il metodo Str::upper converte la stringa fornita in maiuscolo:

use Illuminate\Support\Str;

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

// LARAVEL

Str::ulid()

Il metodo Str::ulid genera un ULID, che è un identificatore unico compatto e ordinato nel tempo:

    use Illuminate\Support\Str;

    return (string) Str::ulid();

    // 01gd6r360bp37zj17nxb55yv40

Se vuoi ottenere un’istanza di data Illuminate\Support\Carbon che rappresenta la data e l’ora in cui un determinato ULID è stato creato, puoi usare il metodo createFromId fornito dall’integrazione di Carbon in Laravel:

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

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

Durante i test, potrebbe essere utile "fingere" il valore restituito dal metodo Str::ulid. Per fare ciò, puoi usare il metodo createUlidsUsing:

    use Symfony\Component\Uid\Ulid;

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

Per istenziare al metodo ulid di tornare a generare ULID normalmente, puoi invocare il metodo createUlidsNormally:

    Str::createUlidsNormally();

Str::unwrap()

Il metodo Str::unwrap rimuove le stringhe specificate dall’inizio e dalla fine di una stringa data:

use Illuminate\Support\Str;

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

// Laravel

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

// framework: "Laravel"

Str::uuid()

Il metodo Str::uuid genera un UUID (versione 4):

use Illuminate\Support\Str;

return (string) Str::uuid();

Durante i test, potrebbe essere utile "fingere" il valore restituito dal metodo Str::uuid. Per farlo, puoi usare il metodo createUuidsUsing:

use Ramsey\Uuid\Uuid;

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

Per tornare a generare UUID normalmente, puoi invocare il metodo createUuidsNormally:

Str::createUuidsNormally();

Str::wordCount()

Il metodo Str::wordCount restituisce il numero di parole contenute in una stringa:

use Illuminate\Support\Str;

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

Str::wordWrap()

Il metodo Str::wordWrap divide una stringa in base a un numero di caratteri specificato:

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

Il metodo Str::words limita il numero di parole in una stringa. Una stringa aggiuntiva può essere passata a questo metodo tramite il suo terzo argomento per specificare quale stringa deve essere aggiunta alla fine della stringa troncata:

    use Illuminate\Support\Str;

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

    // Perfectly balanced, as >>>

Str::wrap()

Il metodo Str::wrap racchiude la stringa fornita con una stringa aggiuntiva o con una coppia di stringhe:

use Illuminate\Support\Str;

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

// "Laravel"

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

// This is Laravel!

str()

La funzione str restituisce una nuova istanza di Illuminate\Support\Stringable della stringa fornita. Questa funzione è equivalente al metodo Str::of:

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

    // 'Taylor Otwell'

Se non viene fornito alcun argomento alla funzione str, la funzione restituisce un’istanza di Illuminate\Support\Str:

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

    // 'foo_bar'

trans()

La funzione trans traduce la chiave di traduzione fornita utilizzando i tuoi file di lingua:

echo trans('messages.welcome');

Se la chiave di traduzione specificata non esiste, la funzione trans restituirà la chiave stessa. Quindi, nell’esempio sopra, la funzione trans ritornerà messages.welcome se la chiave di traduzione non esiste.

trans_choice()

La funzione trans_choice traduce la chiave di traduzione fornita con l’inflessione:

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

Se la chiave di traduzione specificata non esiste, la funzione trans_choice restituisce la chiave data. Quindi, nell’esempio sopra, la funzione trans_choice restituirà messages.notifications se la chiave di traduzione non esiste.

Fluent Strings

Le Fluent strings forniscono un’interfaccia più fluida e orientata agli oggetti per lavorare con i valori delle stringhe, permettendoti di concatenare più operazioni sulle stringhe usando una sintassi più leggibile rispetto alle operazioni tradizionali.

after

Il metodo after restituisce tutto ciò che segue il valore specificato in una stringa. Se il valore non esiste nella stringa, viene restituita l’intera stringa:

use Illuminate\Support\Str;

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

// ' my name'

afterLast

Il metodo afterLast restituisce tutto ciò che si trova dopo l’ultima occorrenza del valore specificato in una stringa. L’intera stringa verrà restituita se il valore non esiste all’interno della stringa:

use Illuminate\Support\Str;

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

// 'Controller'

apa

Il metodo apa converte la stringa fornita in title case seguendo le linee guida APA:

use Illuminate\Support\Str;

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

// A Nice Title Uses the Correct Case

append

Il metodo append aggiunge i valori forniti alla stringa:

use Illuminate\Support\Str;

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

// 'Taylor Otwell'

ascii

Il metodo ascii proverà a traslitterare la stringa in un valore ASCII:

use Illuminate\Support\Str;

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

// 'u'

basename

Il metodo basename restituisce il componente finale del nome della stringa fornita:

    use Illuminate\Support\Str;

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

    // 'baz'

Se necessario, puoi specificare un’"estensione" che verrà rimossa dal componente finale:

    use Illuminate\Support\Str;

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

    // 'baz'

before

Il metodo before restituisce tutto ciò che precede il valore specificato in una stringa:

use Illuminate\Support\Str;

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

// 'This is '

beforeLast

Il metodo beforeLast restituisce tutto ciò che precede l’ultima occorrenza del valore specificato in una stringa:

use Illuminate\Support\Str;

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

// 'This '

between

Il metodo between restituisce la porzione di una stringa compresa tra due valori:

use Illuminate\Support\Str;

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

// ' is my '

betweenFirst

Il metodo betweenFirst restituisce la porzione più piccola possibile di una stringa tra due valori:

    use Illuminate\Support\Str;

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

    // 'a'

camel

Il metodo camel trasforma la stringa fornita in camelCase:

use Illuminate\Support\Str;

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

// 'fooBar'

charAt

Il metodo charAt restituisce il carattere all’indice specificato. Se l’indice è fuori dai limiti, restituisce false:

use Illuminate\Support\Str;

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

// 's'

classBasename

Il metodo classBasename restituisce il nome della classe fornita senza il namespace della classe:

use Illuminate\Support\Str;

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

// 'Baz'

chopStart

Il metodo chopStart rimuove la prima occorrenza del valore dato solo se il valore appare all’inizio della stringa:

use Illuminate\Support\Str;

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

// 'laravel.com'

Puoi anche passare un array. Se la stringa inizia con uno dei valori nell’array, quel valore verrà rimosso dalla stringa:

use Illuminate\Support\Str;

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

// 'laravel.com'

chopEnd

Il metodo chopEnd rimuove l’ultima occorrenza del valore dato solo se il valore appare alla fine della stringa:

use Illuminate\Support\Str;

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

// 'https://laravel'

Puoi anche passare un array. Se la stringa termina con uno dei valori nell’array, quel valore verrà rimosso dalla stringa:

use Illuminate\Support\Str;

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

// 'http://laravel'

contains

Il metodo contains determina se la stringa fornita contiene il valore specificato. Di default, questo metodo distingue tra maiuscole e minuscole:

use Illuminate\Support\Str;

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

// true

Puoi anche passare un array di valori per verificare se la stringa contiene uno qualsiasi dei valori nell’array:

use Illuminate\Support\Str;

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

// true

Puoi disabilitare la distinzione tra maiuscole e minuscole impostando l’argomento ignoreCase su true:

use Illuminate\Support\Str;

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

// true

containsAll

Il metodo containsAll verifica se la stringa fornita contiene tutti i valori nell’array specificato:

use Illuminate\Support\Str;

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

// true

Puoi disabilitare la sensibilità alla maiuscola impostando l’argomento ignoreCase su true:

use Illuminate\Support\Str;

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

// true

deduplicate

Il metodo deduplicate sostituisce le istanze consecutive di un carattere con una singola istanza di quel carattere nella stringa fornita. Per default, il metodo deduplica gli spazi:

use Illuminate\Support\Str;

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

// The Laravel Framework

Puoi specificare un carattere diverso da deduplicare passando il carattere come secondo argomento al metodo:

use Illuminate\Support\Str;

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

// The-Laravel-Framework

dirname

Il metodo dirname restituisce la parte della directory padre della stringa fornita:

use Illuminate\Support\Str;

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

// '/foo/bar'

Se necessario, puoi specificare quanti livelli di directory desideri rimuovere dalla stringa:

use Illuminate\Support\Str;

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

// '/foo'

endsWith

Il metodo endsWith determina se la stringa fornita termina con il valore specificato:

    use Illuminate\Support\Str;

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

    // true

Puoi anche passare un array di valori per verificare se la stringa termina con uno dei valori nell’array:

    use Illuminate\Support\Str;

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

    // true

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

    // false

exactly

Il metodo exactly verifica se una stringa corrisponde esattamente a un’altra:

use Illuminate\Support\Str;

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

// true

excerpt

Il metodo excerpt estrae un estratto dalla stringa che corrisponde alla prima occorrenza di una frase all’interno di essa:

use Illuminate\Support\Str;

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

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

L’opzione radius, che di default è 100, permette di definire il numero di caratteri che devono apparire da ciascun lato della stringa troncata.

Inoltre, puoi usare l’opzione omission per cambiare la stringa che verrà aggiunta all’inizio e alla fine della stringa troncata:

use Illuminate\Support\Str;

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

// '(...) my name'

explode

Il metodo explode divide la stringa usando il delimitatore fornito e restituisce una collezione contenente ogni sezione della stringa divisa:

    use Illuminate\Support\Str;

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

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

finish

Il metodo finish aggiunge un’unica istanza del valore dato a una stringa se non termina già con quel valore:

use Illuminate\Support\Str;

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

// this/string/

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

// this/string/

headline

Il metodo headline trasforma stringhe separate da maiuscole, trattini o underscore in una stringa con spazi e la prima lettera di ogni parola maiuscola:

    use Illuminate\Support\Str;
    
    $headline = Str::of('taylor_otwell')->headline();
    
    // Taylor Otwell
    
    $headline = Str::of('EmailNotificationSent')->headline();
    
    // Email Notification Sent

inlineMarkdown

Il metodo inlineMarkdown converte Markdown in stile GitHub in HTML inline usando CommonMark. Tuttavia, a differenza del metodo markdown, non racchiude tutto l’HTML generato in un elemento a livello di blocco:

use Illuminate\Support\Str;

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

// <strong>Laravel</strong>

Sicurezza in Markdown

Per impostazione predefinita, Markdown supporta l’HTML grezzo, il che può esporre a vulnerabilità di Cross-Site Scripting (XSS) quando si utilizzano input utente non filtrati. Secondo la documentazione sulla sicurezza di CommonMark, puoi usare l’opzione html_input per sfuggire o rimuovere l’HTML grezzo e l’opzione allow_unsafe_links per decidere se consentire link non sicuri. Se hai bisogno di permettere qualche HTML grezzo, devi passare il Markdown compilato attraverso un HTML Purifier:

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

Il metodo is verifica se una determinata stringa corrisponde a un pattern specifico. Gli asterischi possono essere usati come caratteri jolly.

use Illuminate\Support\Str;

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

// true

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

// false

isAscii

Il metodo isAscii verifica se una determinata stringa è una stringa ASCII:

use Illuminate\Support\Str;

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

// true

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

// false

isEmpty

Il metodo isEmpty verifica se la stringa fornita è vuota:

use Illuminate\Support\Str;

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

// true

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

// false

isNotEmpty

Il metodo isNotEmpty determina se la stringa fornita non è vuota:

use Illuminate\Support\Str;

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

// falso

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

// vero

isJson

Il metodo isJson determina se una stringa fornita è un JSON valido:

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

Il metodo isUlid determina se una stringa data è un ULID:

use Illuminate\Support\Str;

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

// true

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

// false

isUrl

Il metodo isUrl verifica se una determinata stringa è un URL:

use Illuminate\Support\Str;

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

// true

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

// false

Il metodo isUrl considera un’ampia gamma di protocolli come validi. Tuttavia, puoi specificare i protocolli che devono essere considerati validi fornendoli al metodo isUrl:

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

isUuid

Il metodo isUuid determina se una stringa fornita è un UUID:

use Illuminate\Support\Str;

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

// true

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

// false

kebab

Il metodo kebab converte la stringa fornita in kebab-case:

use Illuminate\Support\Str;

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

// foo-bar

lcfirst

Il metodo lcfirst restituisce la stringa data con il primo carattere in minuscolo:

    use Illuminate\Support\Str;

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

    // foo Bar

length

Il metodo length restituisce la lunghezza della stringa fornita:

use Illuminate\Support\Str;

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

// 7

limit

Il metodo limit tronca la stringa data alla lunghezza specificata:

use Illuminate\Support\Str;

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

// The quick brown fox...

Puoi anche passare un secondo argomento per cambiare la stringa che verrà aggiunta alla fine della stringa troncata:

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

// The quick brown fox (...)

Se desideri preservare parole complete durante il troncamento della stringa, puoi utilizzare l’argomento preserveWords. Quando questo argomento è true, la stringa verrà troncata alla più vicina frontiera di parola completa:

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

// The quick...

lower

Il metodo lower converte la stringa fornita in minuscolo:

    use Illuminate\Support\Str;

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

    // 'laravel'

markdown

Il metodo markdown converte GitHub flavored Markdown in 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>

Sicurezza in Markdown

Per impostazione predefinita, Markdown supporta l’HTML raw, il che può esporre vulnerabilità di Cross-Site Scripting (XSS) quando si utilizza input utente non filtrato. Secondo la documentazione sulla sicurezza di CommonMark, puoi utilizzare l’opzione html_input per eseguire l’escape o rimuovere l’HTML raw, e l’opzione allow_unsafe_links per specificare se permettere link non sicuri. Se hai bisogno di consentire alcuni HTML raw, dovresti passare il Markdown compilato attraverso un HTML Purifier:

    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

Il metodo mask nasconde una parte di una stringa con un carattere ripetuto e può essere usato per offuscare segmenti di stringhe come indirizzi email e numeri di telefono:

use Illuminate\Support\Str;

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

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

Se necessario, puoi fornire numeri negativi come terzo o quarto argomento al metodo mask, che indicherà al metodo di iniziare a mascherare a una certa distanza dalla fine della stringa:

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

// tay***@example.com

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

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

match

Il metodo match restituisce la parte di una stringa che corrisponde a un determinato pattern di espressione regolare:

use Illuminate\Support\Str;

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

// 'bar'

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

// 'bar'

matchAll

Il metodo matchAll restituisce una collezione contenente le parti di una stringa che corrispondono a un determinato pattern di espressione regolare:

use Illuminate\Support\Str;

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

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

Se specifichi un gruppo di corrispondenza all’interno dell’espressione, Laravel restituirà una collezione delle corrispondenze del primo gruppo:

use Illuminate\Support\Str;

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

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

Se non vengono trovate corrispondenze, verrà restituita una collezione vuota.

isMatch

Il metodo isMatch restituisce true se la stringa corrisponde a una determinata espressione regolare:

use Illuminate\Support\Str;

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

// true

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

// false

newLine

Il metodo newLine aggiunge un carattere di fine riga a una stringa:

use Illuminate\Support\Str;

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

// 'Laravel
//  Framework'

padBoth

Il metodo padBoth utilizza la funzione str_pad di PHP, aggiungendo caratteri all’inizio e alla fine di una stringa fino a raggiungere la lunghezza desiderata:

use Illuminate\Support\Str;

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

// '__James___'

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

// '  James   '

padLeft

Il metodo padLeft utilizza la funzione str_pad di PHP, aggiungendo caratteri a sinistra di una stringa fino a raggiungere la lunghezza desiderata:

use Illuminate\Support\Str;

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

// '-=-=-James'

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

// '     James'

padRight

Il metodo padRight utilizza la funzione str_pad di PHP, aggiungendo sul lato destro di una stringa un’altra stringa fino a quando la stringa finale raggiunge la lunghezza desiderata:

use Illuminate\Support\Str;

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

// 'James-----'

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

// 'James     '

pipe

Il metodo pipe ti permette di trasformare la stringa passando il suo valore attuale alla callable fornita:

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

Il metodo plural converte una stringa singolare nella sua forma plurale. Questa funzione supporta qualsiasi delle lingue supportate dal pluralizzatore di Laravel:

use Illuminate\Support\Str;

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

// cars

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

// children

Puoi fornire un numero intero come secondo argomento alla funzione per ottenere la forma singolare o plurale della stringa:

use Illuminate\Support\Str;

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

// children

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

// child

position

Il metodo position restituisce la posizione della prima occorrenza di una sottostringa in una stringa. Se la sottostringa non esiste nella stringa, viene restituito false:

use Illuminate\Support\Str;

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

// 0

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

// 7

prepend

Il metodo prepend aggiunge i valori forniti all’inizio della stringa:

    use Illuminate\Support\Str;

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

    // Laravel Framework

remove

Il metodo remove rimuove il valore specificato o un array di valori dalla stringa:

use Illuminate\Support\Str;

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

// Arkansas is beautiful!

Puoi anche passare false come secondo parametro per ignorare maiuscole e minuscole durante la rimozione delle stringhe.

repeat

Il metodo repeat ripete la stringa fornita:

use Illuminate\Support\Str;

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

// aaaaa

replace

Il metodo replace sostituisce una determinata stringa all’interno di un’altra stringa:

use Illuminate\Support\Str;

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

// Laravel 7.x

Il metodo replace accetta anche un parametro caseSensitive. Per default, replace è sensibile alle maiuscole:

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

replaceArray

Il metodo replaceArray sostituisce un valore dato nella stringa sequenzialmente usando un array:

use Illuminate\Support\Str;

$string = 'L\'evento avrà luogo tra ? e ?';

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

// L'evento avrà luogo tra 8:30 e 9:00

replaceFirst

Il metodo replaceFirst sostituisce la prima occorrenza di un determinato valore in una stringa:

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

Il metodo replaceLast sostituisce l’ultima occorrenza di un determinato valore in una stringa:

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

Il metodo replaceMatches sostituisce tutte le parti di una stringa che corrispondono a un pattern con la stringa di sostituzione fornita:

use Illuminate\Support\Str;

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

// '15015551000'

Il metodo replaceMatches accetta anche una closure che verrà eseguita per ogni parte della stringa che corrisponde al pattern dato, permettendoti di eseguire la logica di sostituzione all’interno della closure e restituire il valore sostituito:

use Illuminate\Support\Str;

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

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

replaceStart

Il metodo replaceStart sostituisce la prima occorrenza del valore specificato solo se appare all’inizio della stringa:

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

Il metodo replaceEnd sostituisce l’ultima occorrenza del valore specificato solo se il valore è alla fine della stringa:

    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

Il metodo scan analizza l’input da una stringa in una collection secondo un formato supportato dalla funzione PHP sscanf:

    use Illuminate\Support\Str;

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

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

singular

Il metodo singular converte una stringa nella sua forma singolare. Questa funzione supporta qualsiasi delle lingue supportate dal pluralizzatore di Laravel:

use Illuminate\Support\Str;

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

// car

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

// child

slug

Il metodo slug genera uno "slug" adatto per URL dalla stringa fornita:

use Illuminate\Support\Str;

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

// laravel-framework

snake

Il metodo snake converte la stringa fornita in snake_case:

use Illuminate\Support\Str;

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

// foo_bar

split

Il metodo split separa una stringa in una collezione usando una espressione regolare:

use Illuminate\Support\Str;

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

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

squish

Il metodo squish rimuove tutti gli spazi bianchi inutili da una stringa, inclusi gli spazi extra tra le parole:

use Illuminate\Support\Str;

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

// laravel framework

start

Il metodo start aggiunge un’unica occorrenza del valore specificato a una stringa se non inizia già con quel valore:

use Illuminate\Support\Str;

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

// /this/string

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

// /this/string

startsWith

Il metodo startsWith verifica se la stringa fornita inizia con il valore dato:

    use Illuminate\Support\Str;

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

    // true

stripTags

Il metodo stripTags rimuove tutti i tag HTML e PHP da una stringa:

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

Il metodo studly converte la stringa fornita in StudlyCase:

use Illuminate\Support\Str;

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

// FooBar

substr

Il metodo substr restituisce la porzione della stringa specificata dai parametri start e length:

use Illuminate\Support\Str;

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

// Framework

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

// Frame

substrReplace

Il metodo substrReplace sostituisce una parte del testo all’interno di una stringa, iniziando dalla posizione specificata dal secondo argomento e sostituendo il numero di caratteri indicato dal terzo argomento. Passare 0 come terzo argomento del metodo inserirà la stringa nella posizione specificata senza sostituire nessuno dei caratteri esistenti nella stringa:

    use Illuminate\Support\Str;

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

    // 13:

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

    // The Laravel Framework

swap

Il metodo swap sostituisce più valori nella stringa utilizzando la funzione strtr di PHP:

use Illuminate\Support\Str;

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

// Burritos sono fantastici!

take

Il metodo take restituisce un numero specificato di caratteri dall’inizio della stringa:

    use Illuminate\Support\Str;

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

    // Build

tap

Il metodo tap passa la stringa alla closure fornita, permettendoti di esaminare e interagire con la stringa senza modificarla. La stringa originale viene restituita dal metodo tap indipendentemente da ciò che viene restituito dalla closure:

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

$string = Str::of('Laravel')
    ->append(' Framework')
    ->tap(function (Stringable $string) {
        dump('String dopo append: '.$string);
    })
    ->upper();

// LARAVEL FRAMEWORK

test

Il metodo test verifica se una stringa corrisponde al pattern dell’espressione regolare fornita:

use Illuminate\Support\Str;

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

// true

title

Il metodo title converte la stringa fornita in Title Case:

use Illuminate\Support\Str;

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

// A Nice Title Uses The Correct Case

toBase64

Il metodo toBase64 converte la stringa fornita in Base64:

use Illuminate\Support\Str;

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

// TGFyYXZlbA==

toHtmlString

Il metodo toHtmlString converte la stringa fornita in un’istanza di Illuminate\Support\HtmlString, che non sarà sottoposta a escape quando viene renderizzata nei template Blade:

use Illuminate\Support\Str;

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

transliterate

Il metodo transliterate cerca di trasformare una stringa in una rappresentazione ASCII simile:

use Illuminate\Support\Str;

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

// 'test@laravel.com'

trim

Il metodo trim elimina gli spazi all’inizio e alla fine della stringa fornita. Diversamente dalla funzione trim nativa di PHP, il metodo trim di Laravel rimuove anche i caratteri di spazio unicode:

use Illuminate\Support\Str;

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

// 'Laravel'

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

// 'Laravel'

ltrim

Il metodo ltrim rimuove il lato sinistro della stringa. A differenza della funzione nativa ltrim di PHP, il metodo ltrim di Laravel rimuove anche i caratteri di spaziatura unicode:

    use Illuminate\Support\Str;

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

    // 'Laravel  '

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

    // 'Laravel/'

rtrim

Il metodo rtrim rimuove gli spazi a destra della stringa fornita. A differenza della funzione nativa di PHP rtrim, il metodo rtrim di Laravel rimuove anche i caratteri di spazio unicode:

use Illuminate\Support\Str;

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

// '  Laravel'

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

// '/Laravel'

ucfirst

Il metodo ucfirst restituisce la stringa fornita con il primo carattere maiuscolo:

    use Illuminate\Support\Str;

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

    // Foo bar

ucsplit

Il metodo ucsplit suddivide la stringa fornita in una collection utilizzando i caratteri maiuscoli:

use Illuminate\Support\Str;

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

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

unwrap

Il metodo unwrap rimuove le stringhe specificate dall’inizio e dalla fine di una stringa data:

use Illuminate\Support\Str;

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

// Laravel

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

// framework: "Laravel"

upper

Il metodo upper converte la stringa fornita in maiuscolo:

use Illuminate\Support\Str;

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

// LARAVEL

when

Il metodo when invoca la closure fornita se una determinata condizione è true. La closure riceverà l’istanza della stringa fluente:

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

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

// 'Taylor Otwell'

Se necessario, puoi passare un’altra closure come terzo parametro al metodo when. Questa closure verrà eseguita se il parametro della condizione valuta a false.

whenContains

Il metodo whenContains esegue la closure fornita se la stringa contiene il valore specificato. La closure riceverà l’istanza fluent della stringa:

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

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

// 'Tony Stark'

Se necessario, puoi passare un’altra closure come terzo parametro al metodo when. Questa closure verrà eseguita se la stringa non contiene il valore specificato.

Puoi anche passare un array di valori per verificare se la stringa contiene uno dei valori presenti nell’array:

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

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

// Tony Stark

whenContainsAll

Il metodo whenContainsAll esegue la closure fornita se la stringa contiene tutte le sottostringhe specificate. La closure riceve l’istanza della stringa 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'

Se necessario, puoi passare un’altra closure come terzo parametro al metodo when. Questa closure verrà eseguita se la condizione risulta false.

whenEmpty

Il metodo whenEmpty esegue la closure fornita se la stringa è vuota. Se la closure restituisce un valore, quel valore sarà anche restituito dal metodo whenEmpty. Se la closure non restituisce un valore, verrà restituita l’istanza della stringa fluente:

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

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

// 'Laravel'

whenNotEmpty

Il metodo whenNotEmpty esegue la closure fornita se la stringa non è vuota. Se la closure restituisce un valore, anche quel valore sarà restituito dal metodo whenNotEmpty. Se la closure non restituisce un valore, verrà restituita l’istanza della stringa fluente:

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

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

// 'Laravel Framework'

whenStartsWith

Il metodo whenStartsWith invoca la closure fornita se la stringa inizia con la sottostringa specificata. La closure riceverà l’istanza della stringa 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

Il metodo whenEndsWith esegue la closure fornita se la stringa termina con la sottostringa specificata. La closure riceverà l’istanza fluent della stringa:

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

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

// 'Disney World'

whenExactly

Il metodo whenExactly esegue la closure fornita se la stringa corrisponde esattamente a quella specificata. La closure riceve l’istanza fluent della stringa:

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

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

// 'Laravel'

whenNotExactly

Il metodo whenNotExactly esegue la closure fornita se la stringa non corrisponde esattamente alla stringa data. La closure riceverà un’istanza di stringa fluente:

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

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

// 'Framework'

whenIs

Il metodo whenIs esegue la closure fornita se la stringa corrisponde a un determinato pattern. Gli asterischi possono essere usati come caratteri jolly. La closure riceverà l’istanza della stringa fluida:

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

$string = Str::of('foo/bar')->whenIs('foo/*', function (Stringable $string) {
    return $string->append('/baz');
});

// 'foo/bar/baz'

whenIsAscii

Il metodo whenIsAscii esegue la closure fornita se la stringa è ASCII a 7 bit. La closure riceverà l’istanza fluent della stringa:

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

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

// 'Laravel'

whenIsUlid

Il metodo whenIsUlid esegue la closure fornita se la stringa è un ULID valido. La closure riceve l’istanza della stringa fluida:

use Illuminate\Support\Str;

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

// '01gd6r36'

whenIsUuid

Il metodo whenIsUuid esegue la closure fornita se la stringa è un UUID valido. La closure riceverà l’istanza della stringa 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

Il metodo whenTest invoca la closure fornita se la stringa corrisponde all’espressione regolare specificata. La closure riceve l’istanza della stringa 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

Il metodo wordCount restituisce il numero di parole presenti in una stringa:

use Illuminate\Support\Str;

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

words

Il metodo words limita il numero di parole in una stringa. Se necessario, puoi specificare una stringa aggiuntiva che verrà aggiunta alla stringa troncata:

use Illuminate\Support\Str;

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

// Perfectly balanced, as >>>

wrap

Il metodo wrap avvolge la stringa fornita con una stringa aggiuntiva o con una coppia di stringhe:

use Illuminate\Support\Str;

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

// "Laravel"

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

// This is Laravel!
Lascia un commento

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *

Laravel-Italia.it è il sito della Community Italiana di Laravel.
2024 — Laravel-Italia