Stringekkel való munka
A Nette\Utils\Strings egy statikus osztály hasznos függvényekkel a stringekkel való munkához, főként UTF-8 kódolásban.
Telepítés:
composer require nette/utils
Minden példa feltételezi a létrehozott aliast:
use Nette\Utils\Strings;
Kis- és nagybetűk váltása
Ezek a függvények a mbstring
PHP kiterjesztést igénylik.
lower (string $s): string
Átalakít egy UTF-8 stringet kisbetűssé.
Strings::lower('Dobrý den'); // 'dobrý den'
upper (string $s): string
Átalakít egy UTF-8 stringet nagybetűssé.
Strings::upper('Dobrý den'); // 'DOBRÝ DEN'
firstUpper (string $s): string
Átalakítja egy UTF-8 string első betűjét naggyá, a többit változatlanul hagyja.
Strings::firstUpper('dobrý den'); // 'Dobrý den'
firstLower (string $s): string
Átalakítja egy UTF-8 string első betűjét kissé, a többit változatlanul hagyja.
Strings::firstLower('Dobrý den'); // 'dobrý den'
capitalize (string $s): string
Átalakítja egy UTF-8 string minden szavának első betűjét naggyá, a többit kissé.
Strings::capitalize('Dobrý den'); // 'Dobrý Den'
String módosítása
normalize (string $s): string
Eltávolítja a vezérlőkaraktereket, normalizálja a sorvégeket \n
-re, levágja a kezdő és záró üres
sorokat, levágja a sorok jobb oldali szóközét, normalizálja az UTF-8-at NFC normál formára.
unixNewLines (string $s): string
Átalakítja a sorvégeket \n
-re, amelyet Unix rendszereken használnak. A sorvégek: \n
,
\r
, \r\n
, U+2028 line separator, U+2029 paragraph separator.
$unixLikeLines = Strings::unixNewLines($string);
platformNewLines (string $s): string
Átalakítja a sorvégeket az aktuális platformra jellemző karakterekre, azaz \r\n
-re Windows-on és
\n
-re máshol. A sorvégek: \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
Módosít egy UTF-8 stringet URL-ben használatos formára, azaz eltávolítja az ékezeteket, és az angol ábécé betűin és számjegyein kívül minden karaktert kötőjelre cserél.
Strings::webalize('náš produkt'); // 'nas-produkt'
Ha más karaktereket is meg kell őrizni, azokat a függvény második paraméterében lehet megadni.
Strings::webalize('10. obrázek_id', '._'); // '10.-obrazek_id'
A harmadik paraméterrel letiltható a kisbetűsre alakítás.
Strings::webalize('Dobrý den', null, false); // 'Dobry-den'
PHP intl
kiterjesztést igényel.
trim (string $s, ?string $charlist=null): string
Levágja a szóközöket (vagy a második paraméterben megadott egyéb karaktereket) egy UTF-8 string elejéről és végéről.
Strings::trim(' Hello '); // 'Hello'
truncate (string $s, int $maxLen,
string $append=`'…'
`): string
Levág egy UTF-8 stringet a megadott maximális hosszúságra, miközben igyekszik megőrizni az egész szavakat. Ha a string lerövidül, a végére három pontot tesz (ez a harmadik paraméterrel módosítható).
$text = 'Řekněte, jak se máte?';
Strings::truncate($text, 5); // 'Řekn…'
Strings::truncate($text, 20); // 'Řekněte, jak se…'
Strings::truncate($text, 30); // 'Řekněte, jak se máte?'
Strings::truncate($text, 20, '~'); // 'Řekněte, jak se~'
indent (string $s, int $level=1, string
$indentationChar=`"\t"
`): string
Behúz egy többsoros szöveget balról. A behúzások számát a második paraméter, a behúzás karakterét a harmadik paraméter határozza meg (alapértelmezett érték a tabulátor).
Strings::indent('Nette'); // "\tNette"
Strings::indent('Nette', 2, '+'); // '++Nette'
padLeft (string $s, int $length, string
$pad=`' '
`): string
Kiegészít egy UTF-8 stringet a megadott hosszúságra a $pad
string ismétlésével balról.
Strings::padLeft('Nette', 6); // ' Nette'
Strings::padLeft('Nette', 8, '+*'); // '+*+Nette'
padRight (string $s, int $length,
string $pad=`' '
`): string
Kiegészít egy UTF-8 stringet a megadott hosszúságra a $pad
string ismétlésével jobbról.
Strings::padRight('Nette', 6); // 'Nette '
Strings::padRight('Nette', 8, '+*'); // 'Nette+*+'
substring (string $s, int $start, ?int $length=null): string
Visszaadja a $s
UTF-8 string egy részét, amelyet a $start
kezdőpozíció és a
$length
hosszúság határoz meg. Ha a $start
negatív, a visszaadott string a végétől számított
-$start
karakterrel kezdődik.
Strings::substring('Nette Framework', 0, 5); // 'Nette'
Strings::substring('Nette Framework', 6); // 'Framework'
Strings::substring('Nette Framework', -4); // 'work'
reverse (string $s): string
Megfordít egy UTF-8 stringet.
Strings::reverse('Nette'); // 'etteN'
length (string $s): int
Visszaadja a karakterek (nem bájtok) számát egy UTF-8 stringben.
Ez az Unicode kódpontok száma, amely eltérhet a grafémák számától.
Strings::length('Nette'); // 5
Strings::length('červená'); // 7
startsWith (string $haystack, string $needle): bool
Megállapítja, hogy a $haystack
string a $needle
stringgel kezdődik-e.
$haystack = 'Začíná';
$needle = 'Za';
Strings::startsWith($haystack, $needle); // true
Használja a natív str_starts_with()
függvényt.
endsWith (string $haystack, string $needle): bool
Megállapítja, hogy a $haystack
string a $needle
stringgel végződik-e.
$haystack = 'Končí';
$needle = 'čí';
Strings::endsWith($haystack, $needle); // true
Használja a natív str_ends_with()
függvényt.
contains (string $haystack, string $needle): bool
Megállapítja, hogy a $haystack
string tartalmazza-e a $needle
-t.
$haystack = 'Posluchárna';
$needle = 'sluch';
Strings::contains($haystack, $needle); // true
Használja a natív str_contains()
függvényt.
compare (string $left, string $right, ?int $length=null): bool
Két UTF-8 string vagy azok részeinek összehasonlítása kis- és nagybetűk figyelmen kívül hagyásával. Ha a
$length
null, a teljes stringeket hasonlítja össze, ha negatív, a stringek végétől számított megfelelő
számú karaktert hasonlítja össze, egyébként a stringek elejétől számított megfelelő számú karaktert
hasonlítja össze.
Strings::compare('Nette', 'nette'); // true
Strings::compare('Nette', 'next', 2); // true - az első 2 karakter egyezik
Strings::compare('Nette', 'Latte', -2); // true - az utolsó 2 karakter egyezik
findPrefix (…$strings): string
Megkeresi a stringek közös elejét. Vagy üres stringet ad vissza, ha nem található közös prefix.
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
Visszaadja a $haystack
stringnek a $needle
string n-edik $nth
előfordulása előtti
részét. Vagy null
-t, ha a $needle
nem található. Negatív $nth
érték esetén a string
végétől keres.
Strings::before('Nette_is_great', '_', 1); // 'Nette'
Strings::before('Nette_is_great', '_', -2); // 'Nette'
Strings::before('Nette_is_great', ' '); // null
Strings::before('Nette_is_great', '_', 3); // null
after (string $haystack, string $needle, int $nth=1): ?string
Visszaadja a $haystack
stringnek a $needle
string n-edik $nth
előfordulása utáni
részét. Vagy null
-t, ha a $needle
nem található. Negatív $nth
érték esetén a string
végétől keres.
Strings::after('Nette_is_great', '_', 2); // 'great'
Strings::after('Nette_is_great', '_', -1); // 'great'
Strings::after('Nette_is_great', ' '); // null
Strings::after('Nette_is_great', '_', 3); // null
indexOf (string $haystack, string $needle, int $nth=1): ?int
Visszaadja a $needle
string n-edik $nth
előfordulásának pozícióját karakterekben a
$haystack
stringben. Vagy null
-t, ha a $needle
nem található. Negatív $nth
érték esetén a string végétől keres.
Strings::indexOf('abc abc abc', 'abc', 2); // 4
Strings::indexOf('abc abc abc', 'abc', -1); // 8
Strings::indexOf('abc abc abc', 'd'); // null
Kódolás
fixEncoding (string $s): string
Eltávolítja az érvénytelen UTF-8 karaktereket a stringből.
$correctStrings = Strings::fixEncoding($string);
checkEncoding (string $s): bool
Megállapítja, hogy érvényes UTF-8 stringről van-e szó.
$isUtf8 = Strings::checkEncoding($string);
Használja a Nette\Utils\Validator::isUnicode() metódust.
toAscii (string $s): string
Átalakít egy UTF-8 stringet ASCII-ra, azaz eltávolítja az ékezeteket stb.
Strings::toAscii('žluťoučký kůň'); // 'zlutoucky kun'
PHP intl
kiterjesztést igényel.
chr (int $code): string
Visszaad egy specifikus UTF-8 karaktert a kódpontból (szám a 0×0000..D7FF és 0xE000..10FFFF tartományban).
Strings::chr(0xA9); // '©' UTF-8 kódolásban
ord (string $char): int
Visszaadja egy konkrét UTF-8 karakter kódpontját (szám a 0×0000..D7FF vagy 0xE000..10FFFF tartományban).
Strings::ord('©'); // 0xA9
Reguláris kifejezések
A Strings osztály függvényeket kínál a reguláris kifejezésekkel való munkához. A natív PHP függvényekkel
ellentétben érthetőbb API-val, jobb Unicode támogatással és mindenekelőtt hibadetektálással rendelkeznek. Bármilyen hiba
a kifejezés fordítása vagy feldolgozása során Nette\RegexpException
kivételt dob.
split (string $subject, string $pattern, bool $captureOffset=false, bool $skipEmpty=false, int $limit=-1, bool $utf8=false): array
Feloszt egy stringet egy tömbre reguláris kifejezés alapján. A zárójelben lévő kifejezések is rögzítésre és visszaadásra kerülnek.
Strings::split('hello, world', '~,\s*~');
// ['hello', 'world']
Strings::split('hello, world', '~(,)\s*~');
// ['hello', ',', 'world']``
Ha a $skipEmpty
true
, csak a nem üres elemek kerülnek visszaadásra:
Strings::split('hello, world, ', '~,\s*~');
// ['hello', 'world', '']
Strings::split('hello, world, ', '~,\s*~', skipEmpty: true);
// ['hello', 'world']
Ha a $limit
meg van adva, csak a limitig terjedő részstringek kerülnek visszaadásra, és a string többi
része az utolsó elembe kerül. A –1 vagy 0 limit nem jelent korlátozást.
Strings::split('hello, world, third', '~,\s*~', limit: 2);
// ['hello', 'world, third']
Ha az $utf8
true
, az értékelés Unicode módba vált. Hasonlóan ahhoz, mintha az u
módosítót adná meg.
Ha a $captureOffset
true
, minden előforduló egyezéshez visszaadásra kerül a pozíciója is a
stringben (bájtokban; ha az $utf8
be van állítva, akkor karakterekben). Ez megváltoztatja a visszatérési
értéket egy tömbre, ahol minden elem egy pár, amely az egyező stringből és annak pozíciójából áll.
Strings::split('žlutý, kůň', '~,\s*~', captureOffset: true);
// [['žlutý', 0], ['kůň', 9]]
Strings::split('žlutý, kůň', '~,\s*~', captureOffset: true, utf8: true);
// [['žlutý', 0], ['kůň', 7]]
match (string $subject, string $pattern, bool $captureOffset=false, int $offset=0, bool $unmatchedAsNull=false, bool $utf8=false): ?array
Keres a stringben egy részt, amely megfelel a reguláris kifejezésnek, és visszaad egy tömböt a talált kifejezéssel és
az egyes részkifejezésekkel, vagy null
-t.
Strings::match('hello!', '~\w+(!+)~');
// ['hello!', '!']
Strings::match('hello!', '~X~');
// null
Ha az $unmatchedAsNull
true
, a nem rögzített részminták null-ként kerülnek visszaadásra;
egyébként üres stringként vagy nem kerülnek visszaadásra:
Strings::match('hello', '~\w+(!+)?~');
// ['hello']
Strings::match('hello', '~\w+(!+)?~', unmatchedAsNull: true);
// ['hello', null]
Ha az $utf8
true
, az értékelés Unicode módba vált. Hasonlóan ahhoz, mintha az u
módosítót adná meg:
Strings::match('žlutý kůň', '~\w+~');
// ['lut']
Strings::match('žlutý kůň', '~\w+~', utf8: true);
// ['žlutý']
A $offset
paraméterrel megadható a keresés kezdőpozíciója (bájtokban; ha az $utf8
be van
állítva, akkor karakterekben).
Ha a $captureOffset
true
, minden előforduló egyezéshez visszaadásra kerül a pozíciója is a
stringben (bájtokban; ha az $utf8
be van állítva, akkor karakterekben). Ez megváltoztatja a visszatérési
értéket egy tömbre, ahol minden elem egy pár, amely az egyező stringből és annak eltolásából áll:
Strings::match('žlutý!', '~\w+(!+)?~', captureOffset: true);
// [['lut', 2]]
Strings::match('žlutý!', '~\w+(!+)?~', captureOffset: true, utf8: true);
// [['žlutý!', 0], ['!', 5]]
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
Keres a stringben minden olyan előfordulást, amely megfelel a reguláris kifejezésnek, és visszaad egy tömbökből álló tömböt a talált kifejezéssel és az egyes részkifejezésekkel.
Strings::matchAll('hello, world!!', '~\w+(!+)?~');
/* [
0 => ['hello'],
1 => ['world!!', '!!'],
] */
Ha a $patternOrder
true
, az eredmények szerkezete megváltozik úgy, hogy az első elem a teljes
mintaegyezések tömbje, a második a zárójelben lévő első részmintának megfelelő stringek tömbje, és így tovább:
Strings::matchAll('hello, world!!', '~\w+(!+)?~', patternOrder: true);
/* [
0 => ['hello', 'world!!'],
1 => ['', '!!'],
] */
Ha az $unmatchedAsNull
true
, a nem rögzített részminták null-ként kerülnek visszaadásra;
egyébként üres stringként vagy nem kerülnek visszaadásra:
Strings::matchAll('hello, world!!', '~\w+(!+)?~', unmatchedAsNull: true);
/* [
0 => ['hello', null],
1 => ['world!!', '!!'],
] */
Ha az $utf8
true
, az értékelés Unicode módba vált. Hasonlóan ahhoz, mintha az u
módosítót adná meg:
Strings::matchAll('žlutý kůň', '~\w+~');
/* [
0 => ['lut'],
1 => ['k'],
] */
Strings::matchAll('žlutý kůň', '~\w+~', utf8: true);
/* [
0 => ['žlutý'],
1 => ['kůň'],
] */
A $offset
paraméterrel megadható a keresés kezdőpozíciója (bájtokban; ha az $utf8
be van
állítva, akkor karakterekben).
Ha a $captureOffset
true
, minden előforduló egyezéshez visszaadásra kerül a pozíciója is a
stringben (bájtokban; ha az $utf8
be van állítva, akkor karakterekben). Ez megváltoztatja a visszatérési
értéket egy tömbre, ahol minden elem egy pár, amely az egyező stringből és annak pozíciójából áll:
Strings::matchAll('žlutý kůň', '~\w+~', captureOffset: true);
/* [
0 => [['lut', 2]],
1 => [['k', 8]],
] */
Strings::matchAll('žlutý kůň', '~\w+~', captureOffset: true, utf8: true);
/* [
0 => [['žlutý', 0]],
1 => [['kůň', 6]],
] */
Ha a $lazy
true
, a függvény Generator
-t ad vissza tömb helyett, ami jelentős
teljesítményelőnyökkel jár nagy stringekkel való munka során. A generátor lehetővé teszi az egyezések fokozatos
keresését, ahelyett, hogy az egész stringet egyszerre keresné. Ez lehetővé teszi a rendkívül nagy bemeneti szövegek
hatékony feldolgozását is. Ráadásul bármikor megszakíthatja a feldolgozást, ha megtalálja a keresett egyezést, ami
számítási időt takarít meg.
$matches = Strings::matchAll($largeText, '~\w+~', lazy: true);
foreach ($matches as $match) {
echo "Találat: $match[0]\n";
// A feldolgozás bármikor megszakítható
}
replace (string $subject, string|array
$pattern, string|callable $replacement=''
, int $limit=-1, bool $captureOffset=false, bool
$unmatchedAsNull=false, bool $utf8=false): string
Lecseréli az összes olyan előfordulást, amely megfelel a reguláris kifejezésnek. A $replacement
vagy egy
helyettesítő string maszkja, vagy egy callback.
Strings::replace('hello, world!', '~\w+~', '--');
// '--, --!'
Strings::replace('hello, world!', '~\w+~', fn($m) => strrev($m[0]));
// 'olleh, dlrow!'
A funkció lehetővé teszi több csere végrehajtását is azáltal, hogy a második paraméterben egy
pattern => replacement
alakú tömböt adunk át:
Strings::replace('hello, world!', [
'~\w+~' => '--',
'~,\s+~' => ' ',
]);
// '-- --!'
A $limit
paraméter korlátozza a végrehajtott cserék számát. A –1 limit nem jelent korlátozást.
Ha az $utf8
true
, az értékelés Unicode módba vált. Hasonlóan ahhoz, mintha az u
módosítót adná meg.
Strings::replace('žlutý kůň', '~\w+~', '--');
// 'ž--ý --ůň'
Strings::replace('žlutý kůň', '~\w+~', '--', utf8: true);
// '-- --'
Ha a $captureOffset
true
, minden előforduló egyezéshez a callbacknek átadásra kerül a
pozíciója is a stringben (bájtokban; ha az $utf8
be van állítva, akkor karakterekben). Ez megváltoztatja az
átadott tömb formáját, ahol minden elem egy pár, amely az egyező stringből és annak pozíciójából áll.
Strings::replace(
'žlutý kůň',
'~\w+~',
function (array $m) { dump($m); return ''; },
captureOffset: true,
);
// dumps [['lut', 2]] és [['k', 8]]
Strings::replace(
'žlutý kůň',
'~\w+~',
function (array $m) { dump($m); return ''; },
captureOffset: true,
utf8: true,
);
// dumps [['žlutý', 0]] és [['kůň', 6]]
Ha az $unmatchedAsNull
true
, a nem rögzített részminták null-ként kerülnek átadásra a
callbacknek; egyébként üres stringként vagy nem kerülnek átadásra:
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']