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

# String-Operationen (Str-Klasse)

> String-Verarbeitung mit der Str-Klasse und Stringable (Fluent Strings) von Laravel – erläutert anhand praxisnaher Beispiele.

## Was ist die Str-Klasse

Die Klasse `Illuminate\Support\Str` bietet eine umfangreiche Sammlung von Methoden zur String-Verarbeitung. Statt die einzelnen PHP-Standardfunktionen zu verwenden, arbeiten Sie mit einer einheitlichen, intuitiven Schnittstelle.

Laravel unterstützt zwei Stile der String-Verarbeitung:

* **Statischer Stil**: `Str::slug($title, '-')` — geeignet für einzelne Operationen.
* **Fluent-Stil (Method Chaining)**: `Str::of($title)->slug('-')->limit(50)` — mehrere Operationen lassen sich verketten.

```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>
  Die globale Hilfsfunktion `str()` entspricht `Str::of()`. Sie können also `str('hello')->upper()` schreiben.
</Info>

## Groß-/Kleinschreibung und Notation umwandeln

Methoden zum Umwandeln der Schreibweise von Strings (Groß-/Kleinschreibung, Notation). Häufig verwendet, um Datenbankspalten oder Schlüssel in API-Antworten umzubenennen.

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

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

// camelCase (mit Kleinbuchstaben am Anfang)
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 und URLs

### `Str::slug()` — URL-freundlichen Slug erzeugen

Unverzichtbar, wenn Sie URLs für Artikel oder Seiten erzeugen möchten. Leerzeichen und Sonderzeichen werden umgewandelt, sodass ein URL-sicherer String entsteht.

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

Str::slug('Laravel フレームワーク', '-');
// 'laravel' (Japanisch wird nicht nach ASCII konvertiert und entfällt)

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

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

<Tip>
  Bei Texten mit Zeichen wie Japanisch kann der Slug leer werden. Wenn Sie Slugs mit japanischen Zeichen verwenden möchten, ziehen Sie eine zusätzliche Bibliothek zur Romaji-Konvertierung oder die Verwendung von IDs bzw. Zeitstempeln in URLs in Betracht.
</Tip>

### Mit `Str::of()` Slug-Erzeugung und Bereinigung in einem Rutsch

```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 kürzen

### `Str::limit()` — nach Zeichenanzahl kürzen

Ideal, um Vorschautexte für Artikelinhalte oder Kommentare in Listen zu erzeugen.

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

$text = 'Laravel ist ein PHP-Framework für den Bau schöner Webanwendungen.';

// Auf 20 Zeichen kürzen (standardmäßig wird "..." angehängt)
Str::limit($text, 20);
// 'Laravel ist ein PHP-...'

// Angehängten Text anpassen
Str::limit($text, 20, ' → weiterlesen');
// 'Laravel ist ein PHP- → weiterlesen'

// Nicht mitten in Wörtern abschneiden (für englische Texte)
Str::limit('The quick brown fox jumps over the lazy dog', 20, preserveWords: true);
// 'The quick brown fox...'
```

### `Str::words()` — nach Wortanzahl kürzen

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

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

## Strings suchen und prüfen

### `Str::contains()` — prüfen, ob ein String enthalten ist

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

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

// Mehrere Kandidaten per Array prüfen (mindestens einer enthalten)
Str::contains('This is my name', ['my', 'your']);
// true

// Groß-/Kleinschreibung ignorieren
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()` — Pattern-Matching mit Wildcards

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

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

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

// Groß-/Kleinschreibung ignorieren
Str::is('F*', 'foo', ignoreCase: true);
// true
```

## Strings umwandeln und ersetzen

### `Str::replace()` — Strings ersetzen

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

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

// Ohne Beachtung der Groß-/Kleinschreibung ersetzen
Str::replace('laravel', 'Symphony', 'I love Laravel', caseSensitive: false);
// 'I love Symphony'
```

### `Str::replaceArray()` — der Reihe nach aus einem Array ersetzen

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

$string = 'Termin ist von ? bis ?';

$result = Str::replaceArray('?', ['9:00 Uhr', '17:00 Uhr'], $string);
// 'Termin ist von 9:00 Uhr bis 17:00 Uhr'
```

### `Str::replaceMatches()` — per Regex ersetzen

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

// Nicht-Ziffern aus einer Telefonnummer entfernen
Str::replaceMatches('/[^0-9]/', '', '(03) 1234-5678');
// '0312345678'

// Ersatzwert per Closure dynamisch erzeugen
Str::replaceMatches('/\d+/', fn ($matches) => '[' . $matches[0] . ']', '1 Stück 2 Kisten 3 Flaschen');
// '[1] Stück [2] Kisten [3] Flaschen'
```

### `Str::remove()` — Strings entfernen

```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.'

// Mehrere Zeichenketten per Array entfernen
Str::remove(['foo', 'bar'], 'foo and bar and baz');
// ' and  and baz'
```

### `Str::squish()` — überflüssige Leerzeichen entfernen

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

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

## Anfang und Ende bearbeiten

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

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

// Teil vor dem angegebenen String
Str::before('test@example.com', '@');
// 'test'

// Teil nach dem angegebenen String
Str::after('test@example.com', '@');
// 'example.com'

// Am letzten Vorkommen ausrichten
Str::afterLast('App\Http\Controllers\UserController', '\\');
// 'UserController'

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

### `Str::between()` — Text zwischen zwei Strings extrahieren

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

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

### `Str::start()` / `Str::finish()` — mit bestimmtem Zeichen beginnen/enden lassen

Beginnt der String bereits mit dem Zeichen, wird nichts hinzugefügt (keine doppelten Zeichen).

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

// Mit '/' beginnen lassen
Str::start('users/profile', '/');
// '/users/profile'

Str::start('/users/profile', '/');
// '/users/profile' (wird nicht verdoppelt)

// Mit '/' enden lassen
Str::finish('https://example.com', '/');
// 'https://example.com/'
```

### `Str::chopStart()` / `Str::chopEnd()` — bestimmten Präfix/Suffix entfernen

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

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

// Mehrere Muster per Array unterstützen
Str::chopStart('http://laravel.com', ['https://', 'http://']);
// 'laravel.com'

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

## Maskierung und Sicherheit

### `Str::mask()` — Strings maskieren

Nützlich, um Teile von E-Mail-Adressen oder Telefonnummern zu verbergen.

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

// Ab dem 4. Zeichen mit '*' maskieren
Str::mask('yamada@example.com', '*', 4);
// 'yama**************'

// Nur die letzten 4 Zeichen anzeigen (Offset als negativer Wert)
Str::mask('1234-5678-9012-3456', '*', -4);
// '***************3456'

// Bereich zum Maskieren angeben
Str::mask('yamada@example.com', '*', 3, 5);
// 'yam*****example.com'
```

### `Str::excerpt()` — Textausschnitt mit Kontext

Praktisch für Snippet-Darstellungen in Suchergebnissen.

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

$text = 'Laravel ist ein PHP-Framework zum Bauen schöner Webanwendungen.';

Str::excerpt($text, 'PHP', ['radius' => 10]);
// '...ein PHP-Framework...'
```

## Zufällige Strings und Identifier

### `Str::random()` — zufälligen String erzeugen

Wird häufig zum Erzeugen von Tokens oder Schlüsseln für Passwort-Resets verwendet.

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

Str::random(32);
// 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx' (32 alphanumerische Zeichen)
```

### `Str::uuid()` / `Str::ulid()` — UUIDs und ULIDs erzeugen

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

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

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

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

### `Str::password()` — sicheres Passwort erzeugen

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

Str::password(12);
// 12 Zeichen lange Zufallsfolge aus Groß-/Kleinbuchstaben, Ziffern und Sonderzeichen
```

### `Str::counted()` — Singular/Plural mit Anzahl

Wandelt einen Begriff je nach Zahl in Singular oder Plural um und gibt ihn zusammen mit der formatierten Zahl zurück.

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

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

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

Im Fluent-Stil funktioniert dies genauso:

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

<Tip>
  Praktisch für die Darstellung von Mengenangaben in englischsprachigen UIs (z. B. die Unterscheidung zwischen „1 item" und „2 items"). Die Formatierung mit Tausendertrennzeichen erfolgt automatisch.
</Tip>

## Fluent Strings (Method Chaining)

Beginnen Sie mit `Str::of()` oder `str()`, erhalten Sie eine `Stringable`-Instanz und können Methoden verketten. Um das Ergebnis final als String zu verwenden, casten Sie mit `(string)` oder nutzen es in einem String-Kontext.

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

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

### Praktische Beispiele für Method Chaining

**Slug für einen Blogbeitrag erzeugen**

```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'
```

**Domain aus einer URL extrahieren**

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

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

**Benutzereingaben bereinigen**

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

$clean = Str::of($userInput)
    ->squish()          // Überflüssige Leerzeichen entfernen
    ->limit(255)        // Länge begrenzen
    ->toString();
```

**Aus einem Klassennamen einen Dateipfad erzeugen**

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

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

### Bedingte Verkettung (`when()`)

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

$result = Str::of('Laravel')
    ->when($isUppercase, fn ($str) => $str->upper())
    ->append(' Framework');
// Bei $isUppercase === true: 'LARAVEL Framework'
// Bei false: 'Laravel Framework'
```

### `pipe()` — beliebige Callbacks einschieben

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

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

## Übersicht wichtiger Methoden von `Str::of()`

Fluent Strings bieten weitgehend dieselben Methoden wie die statische API. Eine Auswahl:

```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!' (keine Zeichenbereinigung)
$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
```

## Zusammenfassung

<AccordionGroup>
  <Accordion title="Übersicht häufig verwendeter Str-Methoden">
    | Methode                                 | Verwendung                              |
    | --------------------------------------- | --------------------------------------- |
    | `Str::slug($str)`                       | URL-freundlichen Slug erzeugen          |
    | `Str::limit($str, $n)`                  | Nach Zeichen kürzen                     |
    | `Str::contains($str, $needle)`          | Prüfen, ob String enthalten ist         |
    | `Str::startsWith($str, $needle)`        | Prüfen, ob mit angegebenem Text beginnt |
    | `Str::endsWith($str, $needle)`          | Prüfen, ob mit angegebenem Text endet   |
    | `Str::replace($search, $replace, $str)` | String ersetzen                         |
    | `Str::camel($str)`                      | In camelCase umwandeln                  |
    | `Str::snake($str)`                      | In snake\_case umwandeln                |
    | `Str::kebab($str)`                      | In kebab-case umwandeln                 |
    | `Str::studly($str)`                     | In StudlyCase umwandeln                 |
    | `Str::upper($str)`                      | In Großbuchstaben umwandeln             |
    | `Str::lower($str)`                      | In Kleinbuchstaben umwandeln            |
    | `Str::squish($str)`                     | Überflüssige Leerzeichen entfernen      |
    | `Str::after($str, $search)`             | Text nach angegebenem String            |
    | `Str::before($str, $search)`            | Text vor angegebenem String             |
    | `Str::between($str, $from, $to)`        | Text zwischen zwei Strings              |
    | `Str::mask($str, '*', $index)`          | String maskieren                        |
    | `Str::random($length)`                  | Zufälligen String erzeugen              |
    | `Str::uuid()`                           | UUID erzeugen                           |
    | `Str::of($str)`                         | Fluent-Stil starten                     |
  </Accordion>

  <Accordion title="Statische Methode vs. Fluent (Str::of)">
    **Statische Methode verwenden**:

    * Wenn nur ein oder zwei Umwandlungen nötig sind
    * Für einfachen, gut lesbaren Code

    ```php theme={null}
    $slug = Str::slug($title);
    ```

    **Fluent (Str::of) verwenden**:

    * Wenn drei oder mehr Umwandlungen zusammengefasst werden
    * Bei bedingten Verzweigungen (`when()`)
    * Wenn der Ablauf von oben nach unten lesbar sein soll

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

  <Accordion title="Str-Klasse vs. PHP-Standardfunktionen">
    Wenn Sie statt PHP-Standardfunktionen wie `strtolower()`, `substr()` oder `str_replace()` die `Str`-Klasse verwenden:

    * Sie können Multibyte-Zeichen (z. B. Japanisch) sicher verarbeiten (intern kommen `mb_*`-Funktionen zum Einsatz)
    * Sie können Operationen per Method Chaining kompakt schreiben
    * Sie müssen sich keine Argument-Reihenfolgen merken (konsistente Schnittstelle)
    * Ihr Code entspricht dem Code-Stil von Laravel
  </Accordion>
</AccordionGroup>


## Related topics

- [Macroable-Trait](/de/advanced/macroable.md)
- [Lottery-Klasse](/de/advanced/lottery.md)
- [Autorisierung (Gates und Policies)](/de/authorization.md)
- [Queues und Jobs](/de/queues.md)
- [FAQ zur neuen App-Struktur ab Laravel 11](/de/advanced/app-structure-faq.md)