> ## Documentation Index
> Fetch the complete documentation index at: https://kawax.biz/llms.txt
> Use this file to discover all available pages before exploring further.

# Strings bewerken (de Str-klasse)

> Uitleg over stringbewerkingen met de Str-klasse en Stringable (Fluent Strings) van Laravel, met praktijkvoorbeelden.

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

```php theme={null}
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'
```

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

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

```php theme={null}
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()`

```php theme={null}
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.

```php theme={null}
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'
```

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

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

```php theme={null}
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.

```php theme={null}
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

```php theme={null}
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

```php theme={null}
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()`

```php theme={null}
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

```php theme={null}
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

```php theme={null}
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

```php theme={null}
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

```php theme={null}
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

```php theme={null}
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

```php theme={null}
use Illuminate\Support\Str;

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

## Bewerkingen op het begin en einde van strings

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

```php theme={null}
use Illuminate\Support\Str;

// Het deel vóór de opgegeven string
Str::before('test@example.com', '@');
// 'test'

// Het deel ná de opgegeven string
Str::after('test@example.com', '@');
// '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

```php theme={null}
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).

```php theme={null}
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

```php theme={null}
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.

```php theme={null}
use Illuminate\Support\Str;

// Vanaf het 4e teken maskeren met '*'
Str::mask('yamada@example.com', '*', 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('yamada@example.com', '*', 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.

```php theme={null}
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.

```php theme={null}
use Illuminate\Support\Str;

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

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

```php theme={null}
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

```php theme={null}
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.

```php theme={null}
use Illuminate\Support\Str;

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

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

Ook in de Fluent-stijl bruikbaar.

```php theme={null}
Str::of('order')->counted(3);
// '3 orders'
```

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

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

```php theme={null}
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**

```php theme={null}
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**

```php theme={null}
use Illuminate\Support\Str;

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

**Gebruikersinvoer opschonen**

```php theme={null}
use Illuminate\Support\Str;

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

**Een bestandspad genereren uit een klassenaam**

```php theme={null}
use Illuminate\Support\Str;

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

### Voorwaardelijk chainen (`when()`)

```php theme={null}
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

```php theme={null}
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.

```php theme={null}
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

<AccordionGroup>
  <Accordion title="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              |
  </Accordion>

  <Accordion title="Statische methoden vs Fluent (Str::of)">
    **Wanneer statische methoden gebruiken**:

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

    ```php theme={null}
    $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

    ```php theme={null}
    $slug = Str::of($title)
        ->trim()
        ->lower()
        ->slug()
        ->limit(50);
    ```
  </Accordion>

  <Accordion title="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
  </Accordion>
</AccordionGroup>


## Related topics

- [Afbeeldingen bewerken](/nl/images.md)
- [InteractsWithData-trait](/nl/advanced/interacts-with-data.md)
- [Laravel AI SDK](/nl/ai-sdk.md)
- [Autorisatie (gates en policies)](/nl/authorization.md)
- [URL's genereren](/nl/urls.md)