Nette Documentation Preview

syntax 
String funkciók
***************

.[perex]
[api:Nette\Utils\Strings] egy statikus osztály, amely számos hasznos függvényt tartalmaz az UTF-8 kódolt karakterláncokkal való munkához.


Telepítés:

```shell
composer require nette/utils
```

Minden példa feltételezi, hogy a következő osztály alias van definiálva:

```php
use Nette\Utils\Strings;
```


Letter Case .[#toc-letter-case]
===============================

Ezek a funkciók a `mbstring` PHP kiterjesztést igénylik.


lower(string $s): string .[method]
----------------------------------

Az UTF-8 karakterlánc minden karakterét kisbetűvé alakítja.

```php
Strings::lower('Hello world'); // 'hello world'
```


upper(string $s): string .[method]
----------------------------------

Az UTF-8 karakterlánc összes karakterét nagybetűvé alakítja.

```php
Strings::upper('Hello world'); // 'HELLO WORLD'
```


firstUpper(string $s): string .[method]
---------------------------------------

Az UTF-8 karakterlánc első karakterét nagybetűvé alakítja, a többi karaktert változatlanul hagyja.

```php
Strings::firstUpper('hello world'); // 'Hello world'
```


firstLower(string $s): string .[method]
---------------------------------------

Az UTF-8 karakterlánc első karakterét kisbetűssé alakítja, a többi karaktert változatlanul hagyja.

```php
Strings::firstLower('Hello world'); // 'hello world'
```


capitalize(string $s): string .[method]
---------------------------------------

Egy UTF-8 karakterlánc minden szavának első karakterét nagybetűsre, a többit pedig kisbetűsre alakítja.

```php
Strings::capitalize('Hello world'); // 'Hello World'
```


Egy karakterlánc szerkesztése .[#toc-editing-a-string]
======================================================


normalize(string $s): string .[method]
--------------------------------------

Eltávolítja a vezérlő karaktereket, normalizálja a sortöréseket a `\n` címre, eltávolítja a vezető és az utolsó üres sorokat, levágja a sorvégeket, normalizálja az UTF-8 formátumot az NFC normál formájára.


unixNewLines(string $s): string .[method]
-----------------------------------------

Átalakítja a sortöréseket a Unix rendszerekben használt `\n` címre. A sortörések a következők: `\n`, `\r`, `\r\n`, U+2028 sorválasztó, U+2029 bekezdésválasztó.

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


platformNewLines(string $s): string .[method]
---------------------------------------------

A sortörést az aktuális platformra jellemző karakterekre konvertálja, azaz Windowson a `\r\n`, máshol a `\n` karakterekre. A sortörések a következők: `\n`, `\r`, `\r\n`, U+2028 sorválasztó, U+2029 bekezdésválasztó.

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


webalize(string $s, string $charlist=null, bool $lower=true): string .[method]
------------------------------------------------------------------------------

Az UTF-8 karakterláncot az URL-ben használt formára módosítja, azaz eltávolítja a diakritikus jeleket, és az angol ábécé betűinek és a számoknak a kivételével minden karaktert kötőjellel helyettesít.

```php
Strings::webalize('žluťoučký kůň'); // 'zlutoucky-kun'
```

Más karakterek is megmaradhatnak, de azokat második argumentumként kell átadni.

```php
Strings::webalize('10. image_id', '._'); // '10.-image_id'
```

A harmadik argumentum kiküszöbölheti a karakterlánc kisbetűvé alakítását.

```php
Strings::webalize('Hello world', null, false); // 'Hello-world'
```

.[caution]
Szükséges a `intl` PHP kiterjesztés.


trim(string $s, string $charlist=null): string .[method]
--------------------------------------------------------

Eltávolítja a bal és jobb oldali szóközöket (vagy a második argumentumként átadott karaktereket) egy UTF-8 kódolt karakterláncból.

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


truncate(string $s, int $maxLen, string $append=`'…'`): string .[method]
------------------------------------------------------------------------

Az UTF-8 karakterláncot a megadott maximális hosszúságra vágja le, miközben megpróbálja elkerülni az egész szavak szétválasztását. Csak akkor, ha a karakterlánc csonkolva van, egy ellipszist (vagy valami mást, amit a harmadik argumentummal állítunk be) csatol a karakterlánchoz.

```php
$text = 'Hello, how are you today?';
Strings::truncate($text, 5);       // 'Hell…'
Strings::truncate($text, 20);      // 'Hello, how are you…'
Strings::truncate($text, 30);      // 'Hello, how are you today?'
Strings::truncate($text, 20, '~'); // 'Hello, how are you~'
```


indent(string $s, int $level=1, string $indentationChar=`"\t"`): string .[method]
---------------------------------------------------------------------------------

Többsoros szöveg balról történő behúzása. A második argumentum határozza meg, hogy hány behúzásjelet használjon, míg maga a behúzás a harmadik argumentum (alapértelmezés szerint *tab*).

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


padLeft(string $s, int $length, string $pad=`' '`): string .[method]
--------------------------------------------------------------------

Kitölti az UTF-8 karakterláncot a megadott hosszúságra a `$pad` karakterlánc elejére történő előtagolással.

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


padRight(string $s, int $length, string $pad=`' '`): string .[method]
---------------------------------------------------------------------

UTF-8 karakterlánc kitöltése megadott hosszúságúra a `$pad` karakterlánc végéhez való hozzáadásával.

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


substring(string $s, int $start, int $length=null): string .[method]
--------------------------------------------------------------------

Visszaadja az UTF-8 karakterlánc egy részét, amelyet a `$start` kezdőpozíció és a `$length` hossza határoz meg. Ha a `$start` negatív, akkor a visszaadott karakterlánc a karakterlánc végétől számított `$start`'th karaktertől kezdődik.

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


reverse(string $s): string .[method]
------------------------------------

Megfordítja az UTF-8 karakterláncot.

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


length(string $s): int .[method]
--------------------------------

Visszaadja az UTF-8 karakterláncban lévő karakterek (nem bájtok) számát.

Ez a Unicode kódpontok száma, ami eltérhet a graphemák számától.

```php
Strings::length('Nette'); // 5
Strings::length('red');   // 3
```


startsWith(string $haystack, string $needle): bool .[method deprecated]
-----------------------------------------------------------------------

Ellenőrzi, hogy a `$haystack` karakterlánc kezdőbetűje `$needle`.

```php
$haystack = 'Begins';
$needle = 'Be';
Strings::startsWith($haystack, $needle); // true
```

.[note]
Használja a natív `str_starts_with()`:https://www.php.net/manual/en/function.str-starts-with.php.


endsWith(string $haystack, string $needle): bool .[method deprecated]
---------------------------------------------------------------------

Ellenőrzi, hogy a `$haystack` karakterlánc a `$needle` végződéssel végződik-e.

```php
$haystack = 'Ends';
$needle = 'ds';
Strings::endsWith($haystack, $needle); // true
```

.[note]
Használja a natív `str_ends_with()`:https://www.php.net/manual/en/function.str-ends-with.php.


contains(string $haystack, string $needle): bool .[method deprecated]
---------------------------------------------------------------------

Ellenőrzi, hogy a `$haystack` karakterlánc tartalmazza-e a `$needle` címet.

```php
$haystack = 'Contains';
$needle = 'tai';
Strings::contains($haystack, $needle); // true
```

.[note]
Használja a natív `str_contains()`:https://www.php.net/manual/en/function.str-contains.php.


compare(string $left, string $right, int $length=null): bool .[method]
----------------------------------------------------------------------

Összehasonlít két UTF-8 karakterláncot vagy azok részeit, a karakterek esetének figyelembevétele nélkül. Ha a `$length` értéke nulla, akkor egész karakterláncokat hasonlít össze, ha negatív, akkor a karakterláncok végétől számított megfelelő számú karaktert, ellenkező esetben az elejétől számított megfelelő számú karaktert hasonlít össze.

```php
Strings::compare('Nette', 'nette');     // true
Strings::compare('Nette', 'next', 2);   // true - two first characters match
Strings::compare('Nette', 'Latte', -2); // true - two last characters match
```


findPrefix(...$strings): string .[method]
-----------------------------------------

Megkeresi a karakterláncok közös előtagját, vagy üres karakterláncot ad vissza, ha az előtagot nem találta meg.

```php
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 .[method]
-----------------------------------------------------------------------

Visszaadja a `$haystack` egy részét a `$needle` `$nth` előfordulása előtt, vagy visszaadja a `null` -t, ha a tűt nem találták. A negatív érték azt jelenti, hogy a végétől kezdve keres.

```php
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 .[method]
----------------------------------------------------------------------

Visszaadja a `$haystack` egy részét a `$needle` `$nth` előfordulása után, vagy visszaadja a `null` -t, ha a `$needle` nem található. A `$nth` negatív értéke azt jelenti, hogy a végétől kezdve keressük.

```php
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 .[method]
---------------------------------------------------------------------

Visszaadja a `$nth` karakterekben kifejezett pozícióját a `$needle` előfordulásának a `$haystack` vagy a `null` oldalon, ha a `$needle` nem található. A `$nth` negatív értéke azt jelenti, hogy a végétől kezdve keressük.

```php
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 .[#toc-encoding]
========================


fixEncoding(string $s): string .[method]
----------------------------------------

Eltávolítja az összes érvénytelen UTF-8 karaktert egy karakterláncból.

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


checkEncoding(string $s): bool .[method deprecated]
---------------------------------------------------

Ellenőrzi, hogy a karakterlánc érvényes-e UTF-8 kódolásban.

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

.[note]
Használja a [Nette\Utils\Validator::isUnicode() |validators#isUnicode] függvényt.


toAscii(string $s): string .[method]
------------------------------------

Az UTF-8 karakterláncot ASCII-re konvertálja, azaz eltávolítja a diakritikus jeleket stb.

```php
Strings::toAscii('žluťoučký kůň'); // 'zlutoucky kun'
```

.[caution]
PHP kiterjesztést igényel: `intl`.


chr(int $code): string .[method]
--------------------------------

Egy adott UTF-8 karaktert ad vissza kódpontból (szám a 0x0000..D7FF vagy 0xE000..10FFFF tartományban).

```php
Strings::chr(0xA9); // '©'
```


ord(string $char): int .[method]
--------------------------------

Egy adott UTF-8 karakter kódpontját adja vissza (szám a 0x0000..D7FF vagy 0xE000..10FFFF tartományban).

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


Szabályos kifejezések .[#toc-regular-expressions]
=================================================

A Strings osztály függvényeket biztosít a reguláris kifejezésekkel való munkához. A natív PHP függvényektől eltérően érthetőbb API-val, jobb Unicode támogatással és ami a legfontosabb, hibaérzékeléssel rendelkeznek. Bármilyen fordítási vagy kifejezésfeldolgozási hiba a `Nette\RegexpException` kivételt dob.


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

A karakterláncot a reguláris kifejezésnek megfelelően tömbökre osztja. A zárójelben lévő kifejezéseket is rögzíti és visszaadja.

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

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

Ha a `$skipEmpty` értéke `true`, csak a nem üres elemek kerülnek visszaadásra:

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

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

Ha `$limit` van megadva, akkor csak a határértékig terjedő részláncok kerülnek vissza, a string többi része pedig az utolsó elembe kerül. A -1 vagy 0 értékű határérték azt jelenti, hogy nincs határérték.

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

Ha a `$utf8` a `true`, a kiértékelés Unicode módra vált. Ez hasonló az `u` módosító megadásához.

Ha a `$captureOffset` a `true`, akkor minden egyes előforduló egyezés esetén annak a karakterláncban elfoglalt helye is visszaküldésre kerül (bájtban; karakterekben, ha a `$utf8` be van állítva). Ez a visszatérési értéket egy tömbre változtatja, amelynek minden eleme egy pár, amely a megfelelő karakterláncból és annak pozíciójából áll.

```php
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 .[method]
--------------------------------------------------------------------------------------------------------------------------------------------------

Megkeresi a karakterláncban a reguláris kifejezésnek megfelelő részt, és egy tömböt ad vissza a talált kifejezéssel és az egyes részkifejezésekkel, vagy `null`.

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

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

Ha a `$unmatchedAsNull` a `true`, a nem illeszkedő részminták nullaként kerülnek visszaadásra; egyébként üres karakterláncként vagy nem kerülnek visszaadásra:

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

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

Ha a `$utf8` a `true`, az értékelés Unicode módra vált. Ez hasonló az `u` módosító megadásához:

```php
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; karakterekben, ha a `$utf8` be van állítva).

Ha a `$captureOffset` a `true`, akkor minden egyes előforduló találat esetén annak a karakterláncban elfoglalt pozíciója is visszaküldésre kerül (bájtokban; karakterekben, ha a `$utf8` be van állítva). Ezáltal a visszatérési érték egy olyan tömbre változik, amelynek minden eleme egy pár, amely a megfelelő karakterláncból és annak eltolásából áll:

```php
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): array .[method]
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Megkeresi a karakterlánc minden olyan előfordulását, amely megfelel a reguláris kifejezésnek, és egy olyan tömböt ad vissza, amely tartalmazza a talált kifejezést és az egyes részkifejezéseket.

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

Ha a `$patternOrder` értéke `true`, akkor az eredmények szerkezete úgy változik, hogy az első elem a teljes minta egyezéseinek tömbje, a második az első almintának megfelelő karakterláncok tömbje zárójelben, és így tovább:

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

Ha a `$unmatchedAsNull` a `true`, a nem illeszkedő részminták nullaként kerülnek visszaadásra; egyébként üres karakterláncként kerülnek visszaadásra, vagy nem kerülnek visszaadásra:

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

Ha a `$utf8` a `true`, az értékelés Unicode módra vált. Ez hasonló az `u` módosító megadásához:

```php
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; karakterekben, ha a `$utf8` be van állítva).

Ha a `$captureOffset` a `true`, akkor minden egyes előforduló találat esetén annak a karakterláncban elfoglalt pozíciója is visszaküldésre kerül (bájtokban; karakterekben, ha a `$utf8` be van állítva). Ezáltal a visszatérési érték egy olyan tömbre változik, amelynek minden eleme egy pár, amely a megfelelő karakterláncból és annak pozíciójából áll:

```php
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]],
] */
```


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

A reguláris kifejezésnek megfelelő összes előfordulást helyettesíti. A `$replacement` vagy egy helyettesítő karakterlánc maszkja vagy egy visszahívás.

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

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

A függvény többszörös helyettesítést is lehetővé tesz, ha a második paraméterben egy `pattern => replacement` formájú tömböt ad át:

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

A `$limit` paraméter korlátozza a helyettesítések számát. A -1-es korlát azt jelenti, hogy nincs korlát.

Ha a `$utf8` a `true`, a kiértékelés Unicode módra vált. Ez hasonló a `u` módosító megadásához.

```php
Strings::replace('žlutý kůň', '~\w+~', '--');
// 'ž--ý --ůň'

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

Ha a `$captureOffset` a `true`, akkor minden egyes előforduló egyezés esetén a karakterláncban elfoglalt pozícióját (bájtokban; karakterekben, ha a `$utf8` be van állítva) is átadjuk a visszahívásnak. Ez megváltoztatja az átadott tömb formáját, ahol minden elem egy pár, amely az illesztett karakterláncból és annak pozíciójából áll.

```php
Strings::replace(
	'žlutý kůň',
	'~\w+~',
	function (array $m) { dump($m); return ''; },
	captureOffset: true,
);
// dumps [['lut', 2]] a [['k', 8]]

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

Ha a `$unmatchedAsNull` a `true`, a nem illeszkedő részminták nullaként kerülnek átadásra a callbacknek; egyébként üres karakterláncként kerülnek átadásra vagy nem kerülnek átadásra:

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

String funkciók

Nette\Utils\Strings egy statikus osztály, amely számos hasznos függvényt tartalmaz az UTF-8 kódolt karakterláncokkal való munkához.

Telepítés:

composer require nette/utils

Minden példa feltételezi, hogy a következő osztály alias van definiálva:

use Nette\Utils\Strings;

Letter Case

Ezek a funkciók a mbstring PHP kiterjesztést igénylik.

lower(string $s): string

Az UTF-8 karakterlánc minden karakterét kisbetűvé alakítja.

Strings::lower('Hello world'); // 'hello world'

upper(string $s): string

Az UTF-8 karakterlánc összes karakterét nagybetűvé alakítja.

Strings::upper('Hello world'); // 'HELLO WORLD'

firstUpper(string $s): string

Az UTF-8 karakterlánc első karakterét nagybetűvé alakítja, a többi karaktert változatlanul hagyja.

Strings::firstUpper('hello world'); // 'Hello world'

firstLower(string $s): string

Az UTF-8 karakterlánc első karakterét kisbetűssé alakítja, a többi karaktert változatlanul hagyja.

Strings::firstLower('Hello world'); // 'hello world'

capitalize(string $s): string

Egy UTF-8 karakterlánc minden szavának első karakterét nagybetűsre, a többit pedig kisbetűsre alakítja.

Strings::capitalize('Hello world'); // 'Hello World'

Egy karakterlánc szerkesztése

normalize(string $s): string

Eltávolítja a vezérlő karaktereket, normalizálja a sortöréseket a \n címre, eltávolítja a vezető és az utolsó üres sorokat, levágja a sorvégeket, normalizálja az UTF-8 formátumot az NFC normál formájára.

unixNewLines(string $s): string

Átalakítja a sortöréseket a Unix rendszerekben használt \n címre. A sortörések a következők: \n, \r, \r\n, U+2028 sorválasztó, U+2029 bekezdésválasztó.

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

platformNewLines(string $s): string

A sortörést az aktuális platformra jellemző karakterekre konvertálja, azaz Windowson a \r\n, máshol a \n karakterekre. A sortörések a következők: \n, \r, \r\n, U+2028 sorválasztó, U+2029 bekezdésválasztó.

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

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

Az UTF-8 karakterláncot az URL-ben használt formára módosítja, azaz eltávolítja a diakritikus jeleket, és az angol ábécé betűinek és a számoknak a kivételével minden karaktert kötőjellel helyettesít.

Strings::webalize('žluťoučký kůň'); // 'zlutoucky-kun'

Más karakterek is megmaradhatnak, de azokat második argumentumként kell átadni.

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

A harmadik argumentum kiküszöbölheti a karakterlánc kisbetűvé alakítását.

Strings::webalize('Hello world', null, false); // 'Hello-world'

Szükséges a intl PHP kiterjesztés.

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

Eltávolítja a bal és jobb oldali szóközöket (vagy a második argumentumként átadott karaktereket) egy UTF-8 kódolt karakterláncból.

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

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

Az UTF-8 karakterláncot a megadott maximális hosszúságra vágja le, miközben megpróbálja elkerülni az egész szavak szétválasztását. Csak akkor, ha a karakterlánc csonkolva van, egy ellipszist (vagy valami mást, amit a harmadik argumentummal állítunk be) csatol a karakterlánchoz.

$text = 'Hello, how are you today?';
Strings::truncate($text, 5);       // 'Hell…'
Strings::truncate($text, 20);      // 'Hello, how are you…'
Strings::truncate($text, 30);      // 'Hello, how are you today?'
Strings::truncate($text, 20, '~'); // 'Hello, how are you~'

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

Többsoros szöveg balról történő behúzása. A második argumentum határozza meg, hogy hány behúzásjelet használjon, míg maga a behúzás a harmadik argumentum (alapértelmezés szerint tab).

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

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

Kitölti az UTF-8 karakterláncot a megadott hosszúságra a $pad karakterlánc elejére történő előtagolással.

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

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

UTF-8 karakterlánc kitöltése megadott hosszúságúra a $pad karakterlánc végéhez való hozzáadásával.

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

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

Visszaadja az UTF-8 karakterlánc egy részét, amelyet a $start kezdőpozíció és a $length hossza határoz meg. Ha a $start negatív, akkor a visszaadott karakterlánc a karakterlánc végétől számított $start'th karaktertől 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ítja az UTF-8 karakterláncot.

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

length(string $s): int

Visszaadja az UTF-8 karakterláncban lévő karakterek (nem bájtok) számát.

Ez a Unicode kódpontok száma, ami eltérhet a graphemák számától.

Strings::length('Nette'); // 5
Strings::length('red');   // 3

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

Ellenőrzi, hogy a $haystack karakterlánc kezdőbetűje $needle.

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

Használja a natív str_starts_with().

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

Ellenőrzi, hogy a $haystack karakterlánc a $needle végződéssel végződik-e.

$haystack = 'Ends';
$needle = 'ds';
Strings::endsWith($haystack, $needle); // true

Használja a natív str_ends_with().

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

Ellenőrzi, hogy a $haystack karakterlánc tartalmazza-e a $needle címet.

$haystack = 'Contains';
$needle = 'tai';
Strings::contains($haystack, $needle); // true

Használja a natív str_contains().

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

Összehasonlít két UTF-8 karakterláncot vagy azok részeit, a karakterek esetének figyelembevétele nélkül. Ha a $length értéke nulla, akkor egész karakterláncokat hasonlít össze, ha negatív, akkor a karakterláncok végétől számított megfelelő számú karaktert, ellenkező esetben az elejétől számított megfelelő számú karaktert hasonlít össze.

Strings::compare('Nette', 'nette');     // true
Strings::compare('Nette', 'next', 2);   // true - two first characters match
Strings::compare('Nette', 'Latte', -2); // true - two last characters match

findPrefix(…$strings): string

Megkeresi a karakterláncok közös előtagját, vagy üres karakterláncot ad vissza, ha az előtagot nem találta meg.

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 egy részét a $needle $nth előfordulása előtt, vagy visszaadja a null -t, ha a tűt nem találták. A negatív érték azt jelenti, hogy a végétől kezdve 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 egy részét a $needle $nth előfordulása után, vagy visszaadja a null -t, ha a $needle nem található. A $nth negatív értéke azt jelenti, hogy a végétől kezdve keressük.

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 $nth karakterekben kifejezett pozícióját a $needle előfordulásának a $haystack vagy a null oldalon, ha a $needle nem található. A $nth negatív értéke azt jelenti, hogy a végétől kezdve keressük.

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 összes érvénytelen UTF-8 karaktert egy karakterláncból.

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

checkEncoding(string $s): bool

Ellenőrzi, hogy a karakterlánc érvényes-e UTF-8 kódolásban.

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

Használja a Nette\Utils\Validator::isUnicode() függvényt.

toAscii(string $s): string

Az UTF-8 karakterláncot ASCII-re konvertálja, azaz eltávolítja a diakritikus jeleket stb.

Strings::toAscii('žluťoučký kůň'); // 'zlutoucky kun'

PHP kiterjesztést igényel: intl.

chr(int $code): string

Egy adott UTF-8 karaktert ad vissza kódpontból (szám a 0×0000..D7FF vagy 0×E000..10FFFF tartományban).

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

ord(string $char): int

Egy adott UTF-8 karakter kódpontját adja vissza (szám a 0×0000..D7FF vagy 0×E000..10FFFF tartományban).

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

Szabályos kifejezések

A Strings osztály függvényeket biztosít a reguláris kifejezésekkel való munkához. A natív PHP függvényektől eltérően érthetőbb API-val, jobb Unicode támogatással és ami a legfontosabb, hibaérzékeléssel rendelkeznek. Bármilyen fordítási vagy kifejezésfeldolgozási hiba a Nette\RegexpException kivételt dob.

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

A karakterláncot a reguláris kifejezésnek megfelelően tömbökre osztja. A zárójelben lévő kifejezéseket is rögzíti és visszaadja.

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

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

Ha a $skipEmpty értéke 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 $limit van megadva, akkor csak a határértékig terjedő részláncok kerülnek vissza, a string többi része pedig az utolsó elembe kerül. A –1 vagy 0 értékű határérték azt jelenti, hogy nincs határérték.

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

Ha a $utf8 a true, a kiértékelés Unicode módra vált. Ez hasonló az u módosító megadásához.

Ha a $captureOffset a true, akkor minden egyes előforduló egyezés esetén annak a karakterláncban elfoglalt helye is visszaküldésre kerül (bájtban; karakterekben, ha a $utf8 be van állítva). Ez a visszatérési értéket egy tömbre változtatja, amelynek minden eleme egy pár, amely a megfelelő karakterláncbó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

Megkeresi a karakterláncban a reguláris kifejezésnek megfelelő részt, és egy tömböt ad vissza a talált kifejezéssel és az egyes részkifejezésekkel, vagy null.

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

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

Ha a $unmatchedAsNull a true, a nem illeszkedő részminták nullaként kerülnek visszaadásra; egyébként üres karakterláncként vagy nem kerülnek visszaadásra:

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

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

Ha a $utf8 a true, az értékelés Unicode módra vált. Ez hasonló az u módosító megadásához:

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; karakterekben, ha a $utf8 be van állítva).

Ha a $captureOffset a true, akkor minden egyes előforduló találat esetén annak a karakterláncban elfoglalt pozíciója is visszaküldésre kerül (bájtokban; karakterekben, ha a $utf8 be van állítva). Ezáltal a visszatérési érték egy olyan tömbre változik, amelynek minden eleme egy pár, amely a megfelelő karakterláncbó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): array

Megkeresi a karakterlánc minden olyan előfordulását, amely megfelel a reguláris kifejezésnek, és egy olyan tömböt ad vissza, amely tartalmazza a talált kifejezést és az egyes részkifejezéseket.

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

Ha a $patternOrder értéke true, akkor az eredmények szerkezete úgy változik, hogy az első elem a teljes minta egyezéseinek tömbje, a második az első almintának megfelelő karakterláncok tömbje zárójelben, és így tovább:

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

Ha a $unmatchedAsNull a true, a nem illeszkedő részminták nullaként kerülnek visszaadásra; egyébként üres karakterláncként kerülnek visszaadásra, vagy nem kerülnek visszaadásra:

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

Ha a $utf8 a true, az értékelés Unicode módra vált. Ez hasonló az u módosító megadásához:

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; karakterekben, ha a $utf8 be van állítva).

Ha a $captureOffset a true, akkor minden egyes előforduló találat esetén annak a karakterláncban elfoglalt pozíciója is visszaküldésre kerül (bájtokban; karakterekben, ha a $utf8 be van állítva). Ezáltal a visszatérési érték egy olyan tömbre változik, amelynek minden eleme egy pár, amely a megfelelő karakterláncbó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]],
] */

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

A reguláris kifejezésnek megfelelő összes előfordulást helyettesíti. A $replacement vagy egy helyettesítő karakterlánc maszkja vagy egy visszahívás.

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

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

A függvény többszörös helyettesítést is lehetővé tesz, ha a második paraméterben egy pattern => replacement formájú tömböt ad át:

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

A $limit paraméter korlátozza a helyettesítések számát. A –1-es korlát azt jelenti, hogy nincs korlát.

Ha a $utf8 a true, a kiértékelés Unicode módra vált. Ez hasonló a u módosító megadásához.

Strings::replace('žlutý kůň', '~\w+~', '--');
// 'ž--ý --ůň'

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

Ha a $captureOffset a true, akkor minden egyes előforduló egyezés esetén a karakterláncban elfoglalt pozícióját (bájtokban; karakterekben, ha a $utf8 be van állítva) is átadjuk a visszahívásnak. Ez megváltoztatja az átadott tömb formáját, ahol minden elem egy pár, amely az illesztett karakterláncbó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]] a [['k', 8]]

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

Ha a $unmatchedAsNull a true, a nem illeszkedő részminták nullaként kerülnek átadásra a callbacknek; egyébként üres karakterláncként kerülnek átadásra 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']