String-Operationen (Str-Klasse) - Knowledge of Laravel

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.

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'

Die globale Hilfsfunktion str() entspricht Str::of(). Sie können also str('hello')->upper() schreiben.

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

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

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.

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'

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.

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

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.

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

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

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

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

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

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

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

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

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

use Illuminate\Support\Str;

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

Anfang und Ende bearbeiten

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

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

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

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

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.

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.

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.

use Illuminate\Support\Str;

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

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

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

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.

use Illuminate\Support\Str;

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

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

Im Fluent-Stil funktioniert dies genauso:

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

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.

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.

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

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

use Illuminate\Support\Str;

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

Benutzereingaben bereinigen

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

use Illuminate\Support\Str;

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

Bedingte Verkettung (`when()`)

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

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:

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

Ü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

Statische Methode vs. Fluent (Str::of)

Statische Methode verwenden:

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

$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

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

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

Zuletzt geändert am 13. Juli 2026

Verwandte Themen

Macroable-Trait Lottery-Klasse Autorisierung (Gates und Policies)Queues und Jobs FAQ zur neuen App-Struktur ab Laravel 11

⌘I

​Was ist die Str-Klasse

​Groß-/Kleinschreibung und Notation umwandeln

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

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

​Slugs und URLs

​Str::slug() — URL-freundlichen Slug erzeugen

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

​Strings kürzen

​Str::limit() — nach Zeichenanzahl kürzen

​Str::words() — nach Wortanzahl kürzen

​Strings suchen und prüfen

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

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

​Str::is() — Pattern-Matching mit Wildcards

​Strings umwandeln und ersetzen

​Str::replace() — Strings ersetzen

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

​Str::replaceMatches() — per Regex ersetzen

​Str::remove() — Strings entfernen

​Str::squish() — überflüssige Leerzeichen entfernen

​Anfang und Ende bearbeiten

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

​Str::between() — Text zwischen zwei Strings extrahieren

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

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

​Maskierung und Sicherheit

​Str::mask() — Strings maskieren

​Str::excerpt() — Textausschnitt mit Kontext

​Zufällige Strings und Identifier

​Str::random() — zufälligen String erzeugen

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

​Str::password() — sicheres Passwort erzeugen

​Str::counted() — Singular/Plural mit Anzahl

​Fluent Strings (Method Chaining)

​Praktische Beispiele für Method Chaining

​Bedingte Verkettung (when())

​pipe() — beliebige Callbacks einschieben

​Übersicht wichtiger Methoden von Str::of()

​Zusammenfassung

Was ist die Str-Klasse

Groß-/Kleinschreibung und Notation umwandeln

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

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

Slugs und URLs

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

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

Strings kürzen

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

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

Strings suchen und prüfen

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

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

`Str::is()` — Pattern-Matching mit Wildcards

Strings umwandeln und ersetzen

`Str::replace()` — Strings ersetzen

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

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

`Str::remove()` — Strings entfernen

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

Anfang und Ende bearbeiten

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

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

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

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

Maskierung und Sicherheit

`Str::mask()` — Strings maskieren

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

Zufällige Strings und Identifier

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

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

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

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

Fluent Strings (Method Chaining)

Praktische Beispiele für Method Chaining

Bedingte Verkettung (`when()`)

`pipe()` — beliebige Callbacks einschieben

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

Zusammenfassung