Arbeiten mit Zeichenketten

Nette\Utils\Strings ist eine statische Klasse mit nützlichen Funktionen für die Arbeit mit Zeichenketten, hauptsächlich in UTF-8-Kodierung.

Installation:

composer require nette/utils

Alle Beispiele setzen voraus, dass ein Alias erstellt wurde:

use Nette\Utils\Strings;

Änderung der Groß-/Kleinschreibung

Diese Funktionen erfordern die PHP-Erweiterung mbstring.

lower (string $s): string

Konvertiert einen UTF-8-String in Kleinbuchstaben.

Strings::lower('Guten Tag'); // 'guten tag'

upper (string $s): string

Konvertiert einen UTF-8-String in Großbuchstaben.

Strings::upper('Guten Tag'); // 'GUTEN TAG'

firstUpper (string $s): string

Konvertiert den ersten Buchstaben eines UTF-8-Strings in einen Großbuchstaben, die anderen bleiben unverändert.

Strings::firstUpper('guten tag'); // 'Guten tag'

firstLower (string $s): string

Konvertiert den ersten Buchstaben eines UTF-8-Strings in einen Kleinbuchstaben, die anderen bleiben unverändert.

Strings::firstLower('Guten Tag'); // 'guten Tag'

capitalize (string $s): string

Konvertiert den ersten Buchstaben jedes Wortes in einem UTF-8-String in einen Großbuchstaben, die anderen in Kleinbuchstaben.

Strings::capitalize('Guten Tag'); // 'Guten Tag'

Bearbeitung von Zeichenketten

normalize (string $s): string

Entfernt Steuerzeichen, normalisiert Zeilenenden auf \n, entfernt führende und nachfolgende leere Zeilen, entfernt nachfolgende Leerzeichen in Zeilen, normalisiert UTF-8 auf die Normalform NFC.

unixNewLines (string $s): string

Konvertiert Zeilenenden in \n, die in Unix-Systemen verwendet werden. Zeilenenden sind: \n, \r, \r\n, U+2028 line separator, U+2029 paragraph separator.

$unixLikeLines = Strings::unixNewLines($string);

platformNewLines (string $s): string

Konvertiert Zeilenenden in die für die aktuelle Plattform spezifischen Zeichen, d.h. \r\n unter Windows und \n anderswo. Zeilenenden sind: \n, \r, \r\n, U+2028 line separator, U+2029 paragraph separator.

$platformLines = Strings::platformNewLines($string);

webalize (string $s, ?string $charlist=null, bool $lower=true): string

Modifiziert einen UTF-8-String in eine Form, die in URLs verwendet wird, d.h. entfernt Diakritika und ersetzt alle Zeichen außer Buchstaben des englischen Alphabets und Ziffern durch Bindestriche.

Strings::webalize('unser produkt'); // 'unser-produkt'

Sollen auch andere Zeichen beibehalten werden, können diese im zweiten Parameter der Funktion angegeben werden.

Strings::webalize('10. bild_id', '._'); // '10.-bild_id'

Mit dem dritten Parameter kann die Konvertierung in Kleinbuchstaben unterdrückt werden.

Strings::webalize('Guten Tag', null, false); // 'Guten-Tag'

Erfordert die PHP-Erweiterung intl.

trim (string $s, ?string $charlist=null): string

Entfernt Leerzeichen (oder andere im zweiten Parameter angegebene Zeichen) vom Anfang und Ende eines UTF-8-Strings.

Strings::trim('  Hello  '); // 'Hello'

truncate (string $s, int $maxLen, string $append=`'…'`): string

Kürzt einen UTF-8-String auf die angegebene maximale Länge, wobei versucht wird, ganze Wörter beizubehalten. Wenn der String gekürzt wird, wird am Ende ein Dreipunkt hinzugefügt (kann durch den dritten Parameter geändert werden).

$text = 'Sagen Sie, wie geht es Ihnen?';
Strings::truncate($text, 5);       // 'Sagen…'
Strings::truncate($text, 20);      // 'Sagen Sie, wie geht…'
Strings::truncate($text, 30);      // 'Sagen Sie, wie geht es Ihnen?'
Strings::truncate($text, 20, '~'); // 'Sagen Sie, wie geht~'

indent (string $s, int $level=1, string $indentationChar=`"\t"`): string

Rückt einen mehrzeiligen Text von links ein. Die Anzahl der Einrückungen wird durch den zweiten Parameter bestimmt, womit eingerückt wird, durch den dritten Parameter (Standardwert ist Tabulator).

Strings::indent('Nette');         // "\tNette"
Strings::indent('Nette', 2, '+'); // '++Nette'

padLeft (string $s, int $length, string $pad=`' '`): string

Füllt einen UTF-8-String auf die angegebene Länge auf, indem der String $pad von links wiederholt wird.

Strings::padLeft('Nette', 6);        // ' Nette'
Strings::padLeft('Nette', 8, '+*');  // '+*+Nette'

padRight (string $s, int $length, string $pad=`' '`): string

Füllt einen UTF-8-String auf die angegebene Länge auf, indem der String $pad von rechts wiederholt wird.

Strings::padRight('Nette', 6);       // 'Nette '
Strings::padRight('Nette', 8, '+*'); // 'Nette+*+'

substring (string $s, int $start, ?int $length=null): string

Gibt einen Teil des UTF-8-Strings $s zurück, der durch die Startposition $start und die Länge $length angegeben wird. Wenn $start negativ ist, beginnt der zurückgegebene String beim -$start`-ten Zeichen vom Ende.

Strings::substring('Nette Framework', 0, 5); // 'Nette'
Strings::substring('Nette Framework', 6);    // 'Framework'
Strings::substring('Nette Framework', -4);   // 'work'

reverse (string $s): string

Kehrt einen UTF-8-String um.

Strings::reverse('Nette'); // 'etteN'

length (string $s): int

Gibt die Anzahl der Zeichen (nicht Bytes) in einem UTF-8-String zurück.

Dies ist die Anzahl der Unicode-Codepunkte, die sich von der Anzahl der Grapheme unterscheiden kann.

Strings::length('Nette');   // 5
Strings::length('červená'); // 7

startsWith (string $haystack, string $needle): bool

Stellt fest, ob der String $haystack mit dem String $needle beginnt.

$haystack = 'Beginnt';
$needle = 'Be';
Strings::startsWith($haystack, $needle); // true

Verwenden Sie die native Funktion str_starts_with().

endsWith (string $haystack, string $needle): bool

Stellt fest, ob der String $haystack mit dem String $needle endet.

$haystack = 'Endet';
$needle = 'det';
Strings::endsWith($haystack, $needle); // true

Verwenden Sie die native Funktion str_ends_with().

contains (string $haystack, string $needle): bool

Stellt fest, ob der String $haystack $needle enthält.

$haystack = 'Hörsaal';
$needle = 'saal';
Strings::contains($haystack, $needle); // true

Verwenden Sie die native Funktion str_contains().

compare (string $left, string $right, ?int $length=null): bool

Vergleicht zwei UTF-8-Strings oder Teile davon ohne Berücksichtigung der Groß-/Kleinschreibung. Wenn $length null enthält, werden die gesamten Strings verglichen, wenn es negativ ist, wird die entsprechende Anzahl von Zeichen vom Ende der Strings verglichen, andernfalls wird die entsprechende Anzahl von Zeichen vom Anfang verglichen.

Strings::compare('Nette', 'nette');     // true
Strings::compare('Nette', 'next', 2);   // true - Übereinstimmung der ersten 2 Zeichen
Strings::compare('Nette', 'Latte', -2); // true - Übereinstimmung der letzten 2 Zeichen

findPrefix (…$strings): string

Findet den gemeinsamen Anfang von Strings. Oder gibt einen leeren String zurück, wenn kein gemeinsames Präfix gefunden wurde.

Strings::findPrefix('prefix-a', 'prefix-bb', 'prefix-c');   // 'prefix-'
Strings::findPrefix(['prefix-a', 'prefix-bb', 'prefix-c']); // 'prefix-'
Strings::findPrefix('Nette', 'is', 'great');                // ''

before (string $haystack, string $needle, int $nth=1): ?string

Gibt den Teil des Strings $haystack vor dem n-ten $nth Vorkommen des Strings $needle zurück. Oder null, wenn $needle nicht gefunden wurde. Bei einem negativen Wert von $nth wird vom Ende des Strings gesucht.

Strings::before('Nette_ist_großartig', '_', 1);  // 'Nette'
Strings::before('Nette_ist_großartig', '_', -2); // 'Nette'
Strings::before('Nette_ist_großartig', ' ');     // null
Strings::before('Nette_ist_großartig', '_', 3);  // null

after (string $haystack, string $needle, int $nth=1): ?string

Gibt den Teil des Strings $haystack nach dem n-ten $nth Vorkommen des Strings $needle zurück. Oder null, wenn $needle nicht gefunden wurde. Bei einem negativen Wert von $nth wird vom Ende des Strings gesucht.

Strings::after('Nette_ist_großartig', '_', 2);  // 'großartig'
Strings::after('Nette_ist_großartig', '_', -1); // 'großartig'
Strings::after('Nette_ist_großartig', ' ');     // null
Strings::after('Nette_ist_großartig', '_', 3);  // null

indexOf (string $haystack, string $needle, int $nth=1): ?int

Gibt die Position in Zeichen des n-ten $nth Vorkommens des Strings $needle im String $haystack zurück. Oder null, wenn $needle nicht gefunden wurde. Bei einem negativen Wert von $nth wird vom Ende des Strings gesucht.

Strings::indexOf('abc abc abc', 'abc', 2);  // 4
Strings::indexOf('abc abc abc', 'abc', -1); // 8
Strings::indexOf('abc abc abc', 'd');       // null

Kodierung

fixEncoding (string $s): string

Entfernt ungültige UTF-8-Zeichen aus dem String.

$correctStrings = Strings::fixEncoding($string);

checkEncoding (string $s): bool

Stellt fest, ob es sich um einen gültigen UTF-8-String handelt.

$isUtf8 = Strings::checkEncoding($string);

Verwenden Sie Nette\Utils\Validator::isUnicode().

toAscii (string $s): string

Konvertiert einen UTF-8-String in ASCII, d.h. entfernt Diakritika usw.

Strings::toAscii('gelbes Pferd'); // 'gelbes Pferd' (Annahme: Original war 'žluťoučký kůň')

Erfordert die PHP-Erweiterung intl.

chr (int $code): string

Gibt ein spezifisches Zeichen in UTF-8 aus einem Codepunkt zurück (Zahl im Bereich 0×0000..D7FF und 0xE000..10FFFF).

Strings::chr(0xA9); // '©' in UTF-8-Kodierung

ord (string $char): int

Gibt den Codepunkt eines spezifischen Zeichens in UTF-8 zurück (Zahl im Bereich 0×0000..D7FF oder 0xE000..10FFFF).

Strings::ord('©'); // 0xA9

Reguläre Ausdrücke

Die Klasse Strings bietet Funktionen für die Arbeit mit regulären Ausdrücken. Im Gegensatz zu nativen PHP-Funktionen verfügen sie über eine verständlichere API, bessere Unterstützung für Unicode und vor allem Fehlererkennung. Jeder Fehler bei der Kompilierung oder Verarbeitung eines Ausdrucks wirft eine Ausnahme Nette\RegexpException.

split (string $subject, string $pattern, bool $captureOffset=false, bool $skipEmpty=false, int $limit=-1, bool $utf8=false): array

Teilt einen String anhand eines regulären Ausdrucks in ein Array auf. Ausdrücke in Klammern werden ebenfalls erfasst und zurückgegeben.

Strings::split('hello, world', '~,\s*~');
// ['hello', 'world']

Strings::split('hello, world', '~(,)\s*~');
// ['hello', ',', 'world']``

Wenn $skipEmpty true ist, werden nur nicht leere Elemente zurückgegeben:

Strings::split('hello, world, ', '~,\s*~');
// ['hello', 'world', '']

Strings::split('hello, world, ', '~,\s*~', skipEmpty: true);
// ['hello', 'world']

Wenn $limit angegeben ist, werden nur Teilstrings bis zum Limit zurückgegeben, und der Rest des Strings wird im letzten Element platziert. Ein Limit von –1 oder 0 bedeutet keine Beschränkung.

Strings::split('hello, world, third', '~,\s*~', limit: 2);
// ['hello', 'world, third']

Wenn $utf8 true ist, wird die Auswertung in den Unicode-Modus umgeschaltet. Ähnlich wie bei der Angabe des Modifikators u.

Wenn $captureOffset true ist, wird für jede gefundene Übereinstimmung auch ihre Position im String zurückgegeben (in Bytes; wenn $utf8 gesetzt ist, in Zeichen). Dies ändert den Rückgabewert in ein Array, bei dem jedes Element ein Paar aus dem übereinstimmenden String und seiner Position ist.

Strings::split('gelb, Pferd', '~,\s*~', captureOffset: true);
// [['gelb', 0], ['Pferd', 7]] (Annahme: Original war 'žlutý, kůň')

Strings::split('gelb, Pferd', '~,\s*~', captureOffset: true, utf8: true);
// [['gelb', 0], ['Pferd', 6]] (Annahme: Original war 'žlutý, kůň')

match (string $subject, string $pattern, bool $captureOffset=false, int $offset=0, bool $unmatchedAsNull=false, bool $utf8=false): ?array

Sucht im String nach einem Teil, der dem regulären Ausdruck entspricht, und gibt ein Array mit dem gefundenen Ausdruck und einzelnen Teilausdrücken zurück, oder null.

Strings::match('hello!', '~\w+(!+)~');
// ['hello!', '!']

Strings::match('hello!', '~X~');
// null

Wenn $unmatchedAsNull true ist, werden nicht erfasste Teilausdrücke als null zurückgegeben; andernfalls werden sie als leerer String zurückgegeben oder nicht zurückgegeben:

Strings::match('hello', '~\w+(!+)?~');
// ['hello']

Strings::match('hello', '~\w+(!+)?~', unmatchedAsNull: true);
// ['hello', null]

Wenn $utf8 true ist, wird die Auswertung in den Unicode-Modus umgeschaltet. Ähnlich wie bei der Angabe des Modifikators u:

Strings::match('gelbes Pferd', '~\w+~');
// ['gelbes'] (Annahme: Original war 'žlutý kůň', Standard PCRE ohne u)

Strings::match('gelbes Pferd', '~\w+~', utf8: true);
// ['gelbes'] (Annahme: Original war 'žlutý kůň')

Der Parameter $offset kann verwendet werden, um die Position anzugeben, ab der die Suche beginnen soll (in Bytes; wenn $utf8 gesetzt ist, in Zeichen).

Strings::match('gelbes!', '~\w+(!+)?~', captureOffset: true);
// [['gelbes!', 0], ['!', 6]] (Annahme: Original war 'žlutý!', Standard PCRE ohne u)

Strings::match('gelbes!', '~\w+(!+)?~', captureOffset: true, utf8: true);
// [['gelbes!', 0], ['!', 5]] (Annahme: Original war 'žlutý!')

matchAll (string $subject, string $pattern, bool $captureOffset=false, int $offset=0, bool $unmatchedAsNull=false, bool $patternOrder=false, bool $utf8=false, bool $lazy=false): array|Generator

Sucht im String nach allen Vorkommen, die dem regulären Ausdruck entsprechen, und gibt ein Array von Arrays mit dem gefundenen Ausdruck und einzelnen Teilausdrücken zurück.

Strings::matchAll('hello, world!!', '~\w+(!+)?~');
/* [
	0 => ['hello'],
	1 => ['world!!', '!!'],
] */

Wenn $patternOrder true ist, ändert sich die Struktur der Ergebnisse so, dass im ersten Eintrag ein Array der vollständigen Musterübereinstimmungen steht, im zweiten ein Array der Strings, die dem ersten geklammerten Teilausdruck entsprechen, und so weiter:

Strings::matchAll('hello, world!!', '~\w+(!+)?~', patternOrder: true);
/* [
	0 => ['hello', 'world!!'],
	1 => ['', '!!'],
] */

Wenn $unmatchedAsNull true ist, werden nicht erfasste Teilausdrücke als null zurückgegeben; andernfalls werden sie als leerer String zurückgegeben oder nicht zurückgegeben:

Strings::matchAll('hello, world!!', '~\w+(!+)?~', unmatchedAsNull: true);
/* [
	0 => ['hello', null],
	1 => ['world!!', '!!'],
] */

Wenn $utf8 true ist, wird die Auswertung in den Unicode-Modus umgeschaltet. Ähnlich wie bei der Angabe des Modifikators u:

Strings::matchAll('gelbes Pferd', '~\w+~');
/* [
	0 => ['gelbes'],
	1 => ['Pferd'],
] */ // Annahme: Original 'žlutý kůň', Standard PCRE ohne u

Strings::matchAll('gelbes Pferd', '~\w+~', utf8: true);
/* [
	0 => ['gelbes'],
	1 => ['Pferd'],
] */ // Annahme: Original 'žlutý kůň'

Der Parameter $offset kann verwendet werden, um die Position anzugeben, ab der die Suche beginnen soll (in Bytes; wenn $utf8 gesetzt ist, in Zeichen).

Strings::matchAll('gelbes Pferd', '~\w+~', captureOffset: true);
/* [
	0 => [['gelbes', 0]],
	1 => [['Pferd', 7]],
] */ // Annahme: Original 'žlutý kůň', Standard PCRE ohne u

Strings::matchAll('gelbes Pferd', '~\w+~', captureOffset: true, utf8: true);
/* [
	0 => [['gelbes', 0]],
	1 => [['Pferd', 6]],
] */ // Annahme: Original 'žlutý kůň'

Wenn $lazy true ist, gibt die Funktion einen Generator anstelle eines Arrays zurück, was erhebliche Leistungsvorteile bei der Arbeit mit großen Strings bringt. Der Generator ermöglicht die schrittweise Suche nach Übereinstimmungen, anstatt den gesamten String auf einmal zu verarbeiten. Dies ermöglicht die effiziente Verarbeitung auch extrem großer Eingabetexte. Darüber hinaus können Sie die Verarbeitung jederzeit unterbrechen, wenn Sie die gesuchte Übereinstimmung finden, was Rechenzeit spart.

$matches = Strings::matchAll($largeText, '~\w+~', lazy: true);
foreach ($matches as $match) {
    echo "Gefunden: $match[0]\n";
    // Die Verarbeitung kann jederzeit unterbrochen werden
}

replace (string $subject, string|array $pattern, string|callable $replacement=`''`, int $limit=-1, bool $captureOffset=false, bool $unmatchedAsNull=false, bool $utf8=false): string

Ersetzt alle Vorkommen, die dem regulären Ausdruck entsprechen. $replacement ist entweder eine Maske für den Ersatzstring oder ein Callback.

Strings::replace('hello, world!', '~\w+~', '--');
// '--, --!'

Strings::replace('hello, world!', '~\w+~', fn($m) => strrev($m[0]));
// 'olleh, dlrow!'

Die Funktion ermöglicht auch die Durchführung mehrerer Ersetzungen, indem im zweiten Parameter ein Array im Format pattern => replacement übergeben wird:

Strings::replace('hello, world!', [
	'~\w+~' => '--',
	'~,\s+~' => ' ',
]);
// '-- --!'

Der Parameter $limit begrenzt die Anzahl der durchgeführten Ersetzungen. Ein Limit von –1 bedeutet keine Beschränkung.

Wenn $utf8 true ist, wird die Auswertung in den Unicode-Modus umgeschaltet. Ähnlich wie bei der Angabe des Modifikators u.

Strings::replace('gelbes Pferd', '~\w+~', '--');
// '-- --' (Annahme: Original 'žlutý kůň', Standard PCRE ohne u)

Strings::replace('gelbes Pferd', '~\w+~', '--', utf8: true);
// '-- --' (Annahme: Original 'žlutý kůň')

Wenn $captureOffset true ist, wird für jede gefundene Übereinstimmung auch ihre Position im String an den Callback übergeben (in Bytes; wenn $utf8 gesetzt ist, in Zeichen). Dies ändert die Form des übergebenen Arrays, bei dem jedes Element ein Paar aus dem übereinstimmenden String und seiner Position ist.

Strings::replace(
	'gelbes Pferd',
	'~\w+~',
	function (array $m) { dump($m); return ''; },
	captureOffset: true,
);
// dumps [['gelbes', 0]] und [['Pferd', 7]] (Annahme: Original 'žlutý kůň', Standard PCRE ohne u)

Strings::replace(
	'gelbes Pferd',
	'~\w+~',
	function (array $m) { dump($m); return ''; },
	captureOffset: true,
	utf8: true,
);
// dumps [['gelbes', 0]] und [['Pferd', 6]] (Annahme: Original 'žlutý kůň')

Wenn $unmatchedAsNull true ist, werden nicht erfasste Teilausdrücke als null an den Callback übergeben; andernfalls werden sie als leerer String übergeben oder nicht übergeben:

Strings::replace(
	'ac',
	'~(a)(b)*(c)~',
	function (array $m) { dump($m); return ''; },
);
// dumps ['ac', 'a', '', 'c']

Strings::replace(
	'ac',
	'~(a)(b)*(c)~',
	function (array $m) { dump($m); return ''; },
	unmatchedAsNull: true,
);
// dumps ['ac', 'a', null, 'c']

Arbeiten mit Zeichenketten

Änderung der Groß-/Kleinschreibung

lower (string $s): string

upper (string $s): string

firstUpper (string $s): string

firstLower (string $s): string

capitalize (string $s): string

Bearbeitung von Zeichenketten

normalize (string $s): string

unixNewLines (string $s): string

platformNewLines (string $s): string

webalize (string $s, ?string $charlist=null, bool $lower=true): string

trim (string $s, ?string $charlist=null): string

truncate (string $s, int $maxLen, string $append=`'…'`): string

indent (string $s, int $level=1, string $indentationChar=`"\t"`): string

padLeft (string $s, int $length, string $pad=`' '`): string

padRight (string $s, int $length, string $pad=`' '`): string

substring (string $s, int $start, ?int $length=null): string

reverse (string $s): string

length (string $s): int

startsWith (string $haystack, string $needle): bool

endsWith (string $haystack, string $needle): bool

contains (string $haystack, string $needle): bool

compare (string $left, string $right, ?int $length=null): bool

findPrefix (…$strings): string

before (string $haystack, string $needle, int $nth=1): ?string

after (string $haystack, string $needle, int $nth=1): ?string

indexOf (string $haystack, string $needle, int $nth=1): ?int

Kodierung

fixEncoding (string $s): string

checkEncoding (string $s): bool

toAscii (string $s): string

chr (int $code): string

ord (string $char): int

Reguläre Ausdrücke

split (string $subject, string $pattern, bool $captureOffset=false, bool $skipEmpty=false, int $limit=-1, bool $utf8=false): array

match (string $subject, string $pattern, bool $captureOffset=false, int $offset=0, bool $unmatchedAsNull=false, bool $utf8=false): ?array

matchAll (string $subject, string $pattern, bool $captureOffset=false, int $offset=0, bool $unmatchedAsNull=false, bool $patternOrder=false, bool $utf8=false, bool $lazy=false): array|Generator

replace (string $subject, string|array $pattern, string|callable $replacement='', int $limit=-1, bool $captureOffset=false, bool $unmatchedAsNull=false, bool $utf8=false): string

replace (string $subject, string|array $pattern, string|callable $replacement=`''`, int $limit=-1, bool $captureOffset=false, bool $unmatchedAsNull=false, bool $utf8=false): string