Strings bewerken (de Str-klasse) - Knowledge of Laravel

Wat is de Str-klasse

De klasse Illuminate\Support\Str biedt een rijke set methoden voor stringbewerkingen. In plaats van de standaard stringfuncties van PHP los aan te roepen, verwerk je strings intuïtief via een uniforme interface. Er zijn twee stijlen voor stringbewerkingen in Laravel:

Statische-methodenstijl: Str::slug($title, '-') — geschikt voor losse bewerkingen
Fluent-stijl (method chaining): Str::of($title)->slug('-')->limit(50) — hiermee koppel je meerdere bewerkingen aan elkaar

use Illuminate\Support\Str;

// Statische methode
$slug = Str::slug('My New Blog Post', '-');
// 'my-new-blog-post'

// Fluent (Str::of)
$result = Str::of('  My New Blog Post: Part 1  ')
    ->trim()
    ->slug('-')
    ->limit(30);
// 'my-new-blog-post-part-1'

De globale helperfunctie str() is gelijkwaardig aan Str::of(). Je kunt dus schrijven als str('hello')->upper().

Case-conversie

Methoden om de case (hoofdletters, kleine letters, notatie) van een string te converteren. Vaak gebruikt voor databasekolomnamen en het converteren van sleutels in API-responses.

`Str::camel()` / `Str::snake()` / `Str::kebab()` / `Str::studly()`

use Illuminate\Support\Str;

// camelCase (eerste letter klein)
Str::camel('foo_bar');        // 'fooBar'
Str::camel('user_profile_id'); // 'userProfileId'

// snake_case
Str::snake('fooBar');         // 'foo_bar'
Str::snake('UserProfile');    // 'user_profile'

// kebab-case
Str::kebab('fooBar');         // 'foo-bar'

// StudlyCase (PascalCase)
Str::studly('foo_bar');       // 'FooBar'
Str::studly('user-profile');  // 'UserProfile'

`Str::lower()` / `Str::upper()` / `Str::title()`

use Illuminate\Support\Str;

Str::lower('LARAVEL');         // 'laravel'
Str::upper('laravel');         // 'LARAVEL'
Str::title('hello world');     // 'Hello World'

Slugs en URL’s

`Str::slug()` — een URL-vriendelijke slug genereren

Een onmisbare methode bij het genereren van URL’s voor artikelen en pagina’s. Zet spaties en speciale tekens om en produceert een string die veilig is voor URL’s.

use Illuminate\Support\Str;

Str::slug('Laravel フレームワーク', '-');
// 'laravel' (Japans wordt niet naar ASCII geconverteerd en dus verwijderd)

Str::slug('My New Blog Post', '-');
// 'my-new-blog-post'

Str::slug('Hello World!', '_');
// 'hello_world'

Bevat de string Japans, dan kan de slug leeg uitvallen. Wil je Japanse slugs gebruiken, overweeg dan een aparte romaji-conversiebibliotheek of gebruik een ID of timestamp in de URL.

Van sluggeneratie tot validatie in één keer met `Str::of()`

use Illuminate\Support\Str;

$title = '  My New Blog Post: Part 1!  ';

$slug = Str::of($title)
    ->trim()
    ->slug('-')
    ->limit(50);
// 'my-new-blog-post-part-1'

Strings afkappen

`Str::limit()` — afkappen op aantal tekens

Een methode om previewtekst te genereren bij het tonen van een overzicht van artikelen of reacties.

use Illuminate\Support\Str;

$text = 'Laravel is een PHP-framework om mooie webapplicaties te bouwen.';

// Afkappen op 20 tekens (standaard wordt "..." toegevoegd)
Str::limit($text, 20);
// 'Laravel is een PHP-f...'

// Het achtervoegsel aanpassen
Str::limit($text, 20, ' → lees verder');
// 'Laravel is een PHP-f → lees verder'

// Niet midden in een woord afkappen (voor Engelse tekst)
Str::limit('The quick brown fox jumps over the lazy dog', 20, preserveWords: true);
// 'The quick brown fox...'

`Str::words()` — afkappen op aantal woorden

use Illuminate\Support\Str;

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

Strings zoeken en controleren

`Str::contains()` — controleren of een string iets bevat

use Illuminate\Support\Str;

Str::contains('This is my name', 'my');
// true

// Meerdere kandidaten controleren met een array (bevat er minstens één)
Str::contains('This is my name', ['my', 'your']);
// true

// Hoofdletterongevoelig
Str::contains('This is my name', 'MY', ignoreCase: true);
// true

`Str::startsWith()` / `Str::endsWith()`

use Illuminate\Support\Str;

Str::startsWith('https://laravel.com', 'https://');
// true

Str::startsWith('https://laravel.com', ['https://', 'http://']);
// true

Str::endsWith('photo.jpg', '.jpg');
// true

Str::endsWith('photo.jpg', ['.jpg', '.png', '.gif']);
// true

`Str::is()` — matchen met wildcardpatronen

use Illuminate\Support\Str;

Str::is('foo*', 'foobar');
// true

Str::is('*/user/*', '/admin/user/profile');
// true

// Hoofdletterongevoelig
Str::is('F*', 'foo', ignoreCase: true);
// true

Strings converteren en vervangen

`Str::replace()` — een string vervangen

use Illuminate\Support\Str;

Str::replace('8.x', '13.x', 'Laravel 8.x');
// 'Laravel 13.x'

// Hoofdletterongevoelig vervangen
Str::replace('laravel', 'Symphony', 'I love Laravel', caseSensitive: false);
// 'I love Symphony'

`Str::replaceArray()` — op volgorde vervangen met een array

use Illuminate\Support\Str;

$string = 'De afspraak is van ? tot ?';

$result = Str::replaceArray('?', ['9:00 uur', '17:00 uur'], $string);
// 'De afspraak is van 9:00 uur tot 17:00 uur'

`Str::replaceMatches()` — vervangen met reguliere expressies

use Illuminate\Support\Str;

// Alles behalve cijfers uit een telefoonnummer verwijderen
Str::replaceMatches('/[^0-9]/', '', '(03) 1234-5678');
// '0312345678'

// De vervanging dynamisch genereren met een closure
Str::replaceMatches('/\d+/', fn ($matches) => '[' . $matches[0] . ']', '1 stuk 2 dozen 3 flessen');
// '[1] stuk [2] dozen [3] flessen'

`Str::remove()` — een string verwijderen

use Illuminate\Support\Str;

Str::remove('e', 'Peter Piper picked a peck of pickled peppers.');
// 'Ptr Pipr pickd a pck of pickld ppprs.'

// Meerdere strings verwijderen met een array
Str::remove(['foo', 'bar'], 'foo and bar and baz');
// ' and  and baz'

`Str::squish()` — overtollige witruimte verwijderen

use Illuminate\Support\Str;

Str::squish('  Laravel   Framework  ');
// 'Laravel Framework'

Bewerkingen op het begin en einde van strings

`Str::before()` / `Str::after()`

use Illuminate\Support\Str;

// Het deel vóór de opgegeven string
Str::before('[email protected]', '@');
// 'test'

// Het deel ná de opgegeven string
Str::after('[email protected]', '@');
// 'example.com'

// De laatste voorkomen als referentiepunt
Str::afterLast('App\Http\Controllers\UserController', '\\');
// 'UserController'

Str::beforeLast('App\Http\Controllers\UserController', '\\');
// 'App\Http\Controllers'

`Str::between()` — het deel tussen twee strings ophalen

use Illuminate\Support\Str;

Str::between('[debug] Error occurred in module', '[', ']');
// 'debug'

`Str::start()` / `Str::finish()` — laten beginnen/eindigen met een bepaald teken

Begint de string al met dat teken, dan wordt er niets toegevoegd (geen verdubbeling).

use Illuminate\Support\Str;

// Laten beginnen met '/'
Str::start('users/profile', '/');
// '/users/profile'

Str::start('/users/profile', '/');
// '/users/profile' (geen verdubbeling)

// Laten eindigen op '/'
Str::finish('https://example.com', '/');
// 'https://example.com/'

`Str::chopStart()` / `Str::chopEnd()` — een specifiek voor- of achtervoegsel verwijderen

use Illuminate\Support\Str;

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

// Meerdere patronen ondersteunen met een array
Str::chopStart('http://laravel.com', ['https://', 'http://']);
// 'laravel.com'

Str::chopEnd('UserController.php', '.php');
// 'UserController'

Maskeren en beveiliging

`Str::mask()` — een string maskeren

Gebruik je om delen van e-mailadressen of telefoonnummers te verbergen.

use Illuminate\Support\Str;

// Vanaf het 4e teken maskeren met '*'
Str::mask('[email protected]', '*', 4);
// 'yama**************'

// Alleen de laatste 4 tekens tonen (negatieve waarde als offset)
Str::mask('1234-5678-9012-3456', '*', -4);
// '***************3456'

// Maskeren met een opgegeven bereik
Str::mask('[email protected]', '*', 3, 5);
// 'yam*****example.com'

`Str::excerpt()` — een fragment met context uit een string halen

Gebruik je bijvoorbeeld voor het tonen van snippets bij zoekresultaten.

use Illuminate\Support\Str;

$text = 'Laravel is een PHP-framework om mooie webapplicaties te bouwen.';

Str::excerpt($text, 'PHP', ['radius' => 10]);
// '...is een PHP-framework...'

Willekeurige strings en identifiers

`Str::random()` — een willekeurige string genereren

Gebruik je voor het genereren van tokens of sleutels voor wachtwoordresets.

use Illuminate\Support\Str;

Str::random(32);
// 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx' (32 alfanumerieke tekens)

`Str::uuid()` / `Str::ulid()` — UUID’s en ULID’s genereren

use Illuminate\Support\Str;

(string) Str::uuid();
// '550e8400-e29b-41d4-a716-446655440000'

// Chronologisch sorteerbare UUID (UUIDv7)
(string) Str::uuid7();

// ULID (sorteerbare ID)
(string) Str::ulid();
// '01ARZ3NDEKTSV4RRFFQ69G5FAV'

`Str::password()` — een veilig wachtwoord genereren

use Illuminate\Support\Str;

Str::password(12);
// Een willekeurige string van 12 tekens met hoofdletters, kleine letters, cijfers en symbolen

`Str::counted()` — enkelvoud/meervoud met aantal

Zet om naar enkelvoud of meervoud op basis van het getal en geeft dit samen met het geformatteerde getal terug.

use Illuminate\Support\Str;

Str::counted('order', 1);
// '1 order'

Str::counted('order', 1000);
// '1,000 orders'

Ook in de Fluent-stijl bruikbaar.

Str::of('order')->counted(3);
// '3 orders'

Handig voor het tonen van aantallen in de UI in het Engels (het onderscheid tussen “1 item” en “meerdere items”). De opmaak met duizendtalscheiding wordt automatisch toegepast.

Fluent Strings (method chaining)

Begin met Str::of() of str() en je krijgt een Stringable-instantie terug waarop je methoden kunt chainen. Wil je het eindresultaat als string gebruiken, cast dan met (string) of gebruik het in een stringcontext.

use Illuminate\Support\Str;

$result = Str::of('  hello world  ')
    ->trim()
    ->title()
    ->append('!')
    ->toString();
// 'Hello World!'

Praktische voorbeelden van method chaining

Een slug genereren voor een blogartikel

use Illuminate\Support\Str;

$slug = Str::of('  My New Blog Post: Part 1  ')
    ->trim()
    ->lower()
    ->slug('-')
    ->limit(50);
// 'my-new-blog-post-part-1'

Het domein uit een URL halen

use Illuminate\Support\Str;

$domain = Str::of('https://www.example.com/path/to/page')
    ->after('//')
    ->before('/')
    ->chopStart('www.');
// 'example.com'

Gebruikersinvoer opschonen

use Illuminate\Support\Str;

$clean = Str::of($userInput)
    ->squish()          // Overtollige witruimte verwijderen
    ->limit(255)        // Lengte beperken
    ->toString();

Een bestandspad genereren uit een klassenaam

use Illuminate\Support\Str;

$path = Str::of('App\Http\Controllers\UserController')
    ->replace('\\', '/')
    ->append('.php')
    ->toString();
// 'App/Http/Controllers/UserController.php'

Voorwaardelijk chainen (`when()`)

use Illuminate\Support\Str;

$result = Str::of('Laravel')
    ->when($isUppercase, fn ($str) => $str->upper())
    ->append(' Framework');
// Als $isUppercase true is: 'LARAVEL Framework'
// Zo niet: 'Laravel Framework'

`pipe()` — een willekeurige callback tussenvoegen

use Illuminate\Support\Str;

$result = Str::of('my-slug')
    ->pipe(fn ($str) => $str->replace('-', '_'))
    ->upper()
    ->toString();
// 'MY_SLUG'

Overzicht van de belangrijkste methoden bij `Str::of()`

De methoden bij Fluent Strings zijn vrijwel dezelfde set als de statische methoden. Hieronder de meest representatieve.

use Illuminate\Support\Str;

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

$str->length();           // 13
$str->upper();            // 'HELLO, WORLD!'
$str->lower();            // 'hello, world!'
$str->trim();             // 'Hello, World!'
$str->slug();             // 'hello-world'
$str->camel();            // 'hello,World!' (symbolen worden niet verwijderd)
$str->contains('World'); // true
$str->startsWith('Hello'); // true
$str->endsWith('!');      // true
$str->replace(',', '');   // 'Hello World!'
$str->prepend('>>> ');    // '>>> Hello, World!'
$str->append(' <<<');     // 'Hello, World! <<<'
$str->reverse();          // '!dlroW ,olleH'
$str->wordCount();        // 2

Samenvatting

Overzicht van veelgebruikte Str-methoden

Methode	Toepassing
`Str::slug($str)`	Een URL-vriendelijke slug genereren
`Str::limit($str, $n)`	Afkappen op aantal tekens
`Str::contains($str, $needle)`	Controleren of de string iets bevat
`Str::startsWith($str, $needle)`	Controleren of de string begint met een waarde
`Str::endsWith($str, $needle)`	Controleren of de string eindigt op een waarde
`Str::replace($search, $replace, $str)`	Een string vervangen
`Str::camel($str)`	Converteren naar camelCase
`Str::snake($str)`	Converteren naar snake_case
`Str::kebab($str)`	Converteren naar kebab-case
`Str::studly($str)`	Converteren naar StudlyCase
`Str::upper($str)`	Converteren naar hoofdletters
`Str::lower($str)`	Converteren naar kleine letters
`Str::squish($str)`	Overtollige witruimte verwijderen
`Str::after($str, $search)`	Het deel na de opgegeven string ophalen
`Str::before($str, $search)`	Het deel vóór de opgegeven string ophalen
`Str::between($str, $from, $to)`	Het deel tussen twee strings ophalen
`Str::mask($str, '*', $index)`	Een string maskeren
`Str::random($length)`	Een willekeurige string genereren
`Str::uuid()`	Een UUID genereren
`Str::of($str)`	Het startpunt van de Fluent-stijl

Statische methoden vs Fluent (Str::of)

Wanneer statische methoden gebruiken:

Als één of twee conversies volstaan
Voor eenvoudige, leesbare code

$slug = Str::slug($title);

Wanneer Fluent (Str::of) gebruiken:

Als je drie of meer conversies achter elkaar uitvoert
Als er voorwaardelijke logica (when()) bij zit
Als je de verwerkingsflow van boven naar beneden leesbaar wilt houden

$slug = Str::of($title)
    ->trim()
    ->lower()
    ->slug()
    ->limit(50);

De Str-klasse vs de standaardfuncties van PHP

Door de Str-klasse te gebruiken in plaats van standaardfuncties zoals strtolower(), substr() en str_replace():

Ga je veilig om met multibyte-tekens (Japans) (intern worden mb_*-functies gebruikt)
Kun je bewerkingen bundelen met method chaining
Hoef je de volgorde van argumenten niet te onthouden (consistente interface)
Blijft je code in de Laravel-codestijl

Laatst gewijzigd op 6 september 2026

Gerelateerde onderwerpen

Afbeeldingen bewerken InteractsWithData-trait Laravel AI SDK Autorisatie (gates en policies)URL's genereren

​Wat is de Str-klasse

​Case-conversie

​Str::camel() / Str::snake() / Str::kebab() / Str::studly()

​Str::lower() / Str::upper() / Str::title()

​Slugs en URL’s

​Str::slug() — een URL-vriendelijke slug genereren

​Van sluggeneratie tot validatie in één keer met Str::of()

​Strings afkappen

​Str::limit() — afkappen op aantal tekens

​Str::words() — afkappen op aantal woorden

​Strings zoeken en controleren

​Str::contains() — controleren of een string iets bevat

​Str::startsWith() / Str::endsWith()

​Str::is() — matchen met wildcardpatronen

​Strings converteren en vervangen

​Str::replace() — een string vervangen

​Str::replaceArray() — op volgorde vervangen met een array

​Str::replaceMatches() — vervangen met reguliere expressies

​Str::remove() — een string verwijderen

​Str::squish() — overtollige witruimte verwijderen

​Bewerkingen op het begin en einde van strings

​Str::before() / Str::after()

​Str::between() — het deel tussen twee strings ophalen

​Str::start() / Str::finish() — laten beginnen/eindigen met een bepaald teken

​Str::chopStart() / Str::chopEnd() — een specifiek voor- of achtervoegsel verwijderen

​Maskeren en beveiliging

​Str::mask() — een string maskeren

​Str::excerpt() — een fragment met context uit een string halen

​Willekeurige strings en identifiers

​Str::random() — een willekeurige string genereren

​Str::uuid() / Str::ulid() — UUID’s en ULID’s genereren

​Str::password() — een veilig wachtwoord genereren

​Str::counted() — enkelvoud/meervoud met aantal

​Fluent Strings (method chaining)

​Praktische voorbeelden van method chaining

​Voorwaardelijk chainen (when())

​pipe() — een willekeurige callback tussenvoegen

​Overzicht van de belangrijkste methoden bij Str::of()

​Samenvatting

Wat is de Str-klasse

Case-conversie

`Str::camel()` / `Str::snake()` / `Str::kebab()` / `Str::studly()`

`Str::lower()` / `Str::upper()` / `Str::title()`

Slugs en URL’s

`Str::slug()` — een URL-vriendelijke slug genereren

Van sluggeneratie tot validatie in één keer met `Str::of()`

Strings afkappen

`Str::limit()` — afkappen op aantal tekens

`Str::words()` — afkappen op aantal woorden

Strings zoeken en controleren

`Str::contains()` — controleren of een string iets bevat

`Str::startsWith()` / `Str::endsWith()`

`Str::is()` — matchen met wildcardpatronen

Strings converteren en vervangen

`Str::replace()` — een string vervangen

`Str::replaceArray()` — op volgorde vervangen met een array

`Str::replaceMatches()` — vervangen met reguliere expressies

`Str::remove()` — een string verwijderen

`Str::squish()` — overtollige witruimte verwijderen

Bewerkingen op het begin en einde van strings

`Str::before()` / `Str::after()`

`Str::between()` — het deel tussen twee strings ophalen

`Str::start()` / `Str::finish()` — laten beginnen/eindigen met een bepaald teken

`Str::chopStart()` / `Str::chopEnd()` — een specifiek voor- of achtervoegsel verwijderen

Maskeren en beveiliging

`Str::mask()` — een string maskeren

`Str::excerpt()` — een fragment met context uit een string halen

Willekeurige strings en identifiers

`Str::random()` — een willekeurige string genereren

`Str::uuid()` / `Str::ulid()` — UUID’s en ULID’s genereren

`Str::password()` — een veilig wachtwoord genereren

`Str::counted()` — enkelvoud/meervoud met aantal

Fluent Strings (method chaining)

Praktische voorbeelden van method chaining

Voorwaardelijk chainen (`when()`)

`pipe()` — een willekeurige callback tussenvoegen

Overzicht van de belangrijkste methoden bij `Str::of()`

Samenvatting