Nette Documentation Preview

syntax 
Dize İşlevleri
**************

.[perex]
[api:Nette\Utils\Strings] UTF-8 kodlu dizelerle çalışmak için birçok yararlı işlev içeren statik bir sınıftır.


Kurulum:

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

Tüm örnekler aşağıdaki sınıf takma adının tanımlandığını varsayar:

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


Harf Kutusu .[#toc-letter-case]
===============================

Bu işlevler `mbstring` PHP uzantısını gerektirir.


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

UTF-8 dizesinin tüm karakterlerini küçük harfe dönüştürür.

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


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

UTF-8 dizesinin tüm karakterlerini büyük harfe dönüştürür.

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


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

UTF-8 dizesinin ilk karakterini büyük harfe dönüştürür ve diğer karakterleri değiştirmeden bırakır.

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


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

UTF-8 dizesinin ilk karakterini küçük harfe dönüştürür ve diğer karakterleri değiştirmeden bırakır.

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


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

UTF-8 dizesindeki her sözcüğün ilk karakterini büyük harfe, diğerlerini küçük harfe dönüştürür.

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


Dizeyi Düzenleme .[#toc-editing-a-string]
=========================================


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

Kontrol karakterlerini kaldırır, satır sonlarını `\n` olarak normalleştirir, baştaki ve sondaki boş satırları kaldırır, satırlardaki son boşlukları keser, UTF-8'i NFC'nin normal biçimine normalleştirir.


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

Satır sonlarını Unix sistemlerinde kullanılan `\n` adresine dönüştürür. Satır sonları şunlardır: `\n`, `\r`, `\r\n`, U+2028 satır ayırıcı, U+2029 paragraf ayırıcı.

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


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

Satır sonlarını geçerli platforma özgü karakterlere dönüştürür, yani Windows'ta `\r\n` ve başka yerlerde `\n`. Satır sonları `\n`, `\r`, `\r\n`, U+2028 satır ayırıcı, U+2029 paragraf ayırıcıdır.

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


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

UTF-8 dizesini URL'de kullanılan biçime dönüştürür, yani aksan işaretlerini kaldırır ve İngilizce alfabenin harfleri ve sayılar dışındaki tüm karakterleri tire ile değiştirir.

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

Diğer karakterler de korunabilir, ancak bunlar ikinci argüman olarak aktarılmalıdır.

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

Üçüncü bağımsız değişken dizenin küçük harfe dönüştürülmesini engelleyebilir.

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

.[caution]
PHP uzantısı gerektirir `intl`.


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

UTF-8 kodlu bir dizeden sol ve sağ taraftaki tüm boşlukları (veya ikinci bağımsız değişken olarak aktarılan karakterleri) kaldırır.

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


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

Bir UTF-8 dizesini, tüm sözcükleri bölmemeye çalışarak, verilen maksimum uzunlukta keser. Yalnızca dize kesilirse, dizeye bir üç nokta (veya üçüncü bağımsız değişkenle ayarlanan başka bir şey) eklenir.

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

Çok satırlı bir metni soldan girintiler. İkinci bağımsız değişken kaç girinti karakteri kullanılacağını belirlerken, girintinin kendisi üçüncü bağımsız değişkendir (varsayılan olarak *tab*).

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


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

Bir UTF-8 dizesini, `$pad` dizesinin başına ekleyerek verilen uzunlukta doldurur.

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


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

`$pad` dizesini sonuna ekleyerek UTF-8 dizesini verilen uzunlukta tamponlar.

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


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

Başlangıç konumu `$start` ve uzunluğu `$length` ile belirtilen UTF-8 dizesinin bir bölümünü döndürür. `$start` negatifse, döndürülen dize dizenin sonundan itibaren `$start`'inci karakterden başlar.

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

UTF-8 dizesini tersine çevirir.

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


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

UTF-8 dizesindeki karakter sayısını (bayt değil) döndürür.

Bu, grafem sayısından farklı olabilen Unicode kod noktalarının sayısıdır.

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


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

`$haystack` dizesinin `$needle` ile başlayıp başlamadığını kontrol eder.

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

.[note]
Yerel `str_starts_with()`:https://www.php.net/manual/en/function.str-starts-with.php adresini kullanın.


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

`$haystack` dizesinin `$needle` ile bitip bitmediğini kontrol eder.

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

.[note]
Yerel `str_ends_with()`:https://www.php.net/manual/en/function.str-ends-with.php adresini kullanın.


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

`$haystack` dizesinin `$needle` içerip içermediğini kontrol eder.

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

.[note]
Yerel `str_contains()`:https://www.php.net/manual/en/function.str-contains.php adresini kullanın.


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

Karakter durumunu dikkate almadan iki UTF-8 dizgisini veya parçalarını karşılaştırır. `$length` boşsa, tüm dizgiler karşılaştırılır, negatifse, dizgilerin sonundan itibaren karşılık gelen karakter sayısı karşılaştırılır, aksi takdirde başlangıçtan itibaren uygun karakter sayısı karşılaştırılır.

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

Dizelerin ortak önekini bulur veya önek bulunamazsa boş dize döndürür.

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

`$haystack` öğesinin `$nth` öğesinin `$needle` öğesinden önceki kısmını döndürür veya iğne bulunamazsa `null` öğesini döndürür. Negatif değer, sondan itibaren arama anlamına gelir.

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

`$needle` 'nin `$nth` oluşumundan sonra `$haystack` 'un bir kısmını döndürür veya `$needle` bulunamazsa `null` 'u döndürür. Negatif `$nth` değeri sondan arama anlamına gelir.

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

`$needle` 'in `$haystack` 'de veya `$needle` bulunamadıysa `null` 'de `$nth` oluşumunun karakter cinsinden konumunu verir. Negatif `$nth` değeri sondan arama anlamına gelir.

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


Kodlama .[#toc-encoding]
========================


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

Bir dizeden tüm geçersiz UTF-8 karakterlerini kaldırır.

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


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

Dizenin UTF-8 kodlamasında geçerli olup olmadığını denetler.

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

.[note]
[Nette\Utils\Validator::isUnicode() |validators#isUnicode] işlevini kullanın.


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

UTF-8 dizesini ASCII'ye dönüştürür, yani aksan işaretlerini vb. kaldırır.

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

.[caution]
PHP uzantısı gerektirir `intl`.


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

Kod noktasından UTF-8'de belirli bir karakteri döndürür (0x0000..D7FF veya 0xE000..10FFFF aralığındaki sayı).

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


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

UTF-8'de belirli bir karakterin kod noktasını döndürür (0x0000..D7FF veya 0xE000..10FFFF aralığında sayı).

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


Düzenli İfadeler .[#toc-regular-expressions]
============================================

Strings sınıfı düzenli ifadelerle çalışmak için işlevler sağlar. Yerel PHP işlevlerinin aksine, daha anlaşılır bir API'ye, daha iyi Unicode desteğine ve en önemlisi hata algılamaya sahiptirler. Herhangi bir derleme veya ifade işleme hatası bir `Nette\RegexpException` istisnası fırlatacaktır.


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

Dizeyi düzenli ifadeye göre dizilere böler. Parantez içindeki ifadeler de yakalanacak ve döndürülecektir.

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

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

`$skipEmpty` `true` ise, yalnızca boş olmayan öğeler iade edilecektir:

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

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

`$limit` belirtilirse, yalnızca sınıra kadar olan alt dizeler döndürülür ve dizenin geri kalanı son öğeye yerleştirilir. Limitin -1 veya 0 olması limit olmadığı anlamına gelir.

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

Eğer `$utf8` `true` ise, değerlendirme Unicode moduna geçer. Bu, `u` değiştiricisini belirtmeye benzer.

Eğer `$captureOffset` `true` ise, oluşan her eşleşme için dizedeki konumu da döndürülür (bayt cinsinden; `$utf8` ayarlanmışsa karakter cinsinden). Bu, dönüş değerini, her bir elemanın eşleşen dize ve konumundan oluşan bir çift olduğu bir diziye dönüştürür.

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

Dizeyi düzenli ifadeyle eşleşen kısım için arar ve bulunan ifadeyi ve tek tek alt ifadeleri içeren bir dizi veya `null` döndürür.

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

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

`$unmatchedAsNull` `true` ise, eşleşmeyen alt örüntüler null olarak döndürülür; aksi takdirde boş bir dize olarak döndürülür veya döndürülmez:

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

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

Eğer `$utf8` `true` ise, değerlendirme Unicode moduna geçer. Bu, `u` değiştiricisini belirtmeye benzer:

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

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

`$offset` parametresi, aramanın başlatılacağı konumu belirtmek için kullanılabilir (bayt cinsinden; `$utf8` ayarlanmışsa karakter cinsinden).

Eğer `$captureOffset` `true` ise, oluşan her eşleşme için dizedeki konumu da döndürülür (bayt cinsinden; `$utf8` ayarlanmışsa karakter cinsinden). Bu, dönüş değerini, her bir elemanın eşleşen dize ve ofsetinden oluşan bir çift olduğu bir diziye dönüştürür:

```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, bool $lazy=false): array|Generator .[method]
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Dizeyi, düzenli ifadeyle eşleşen tüm oluşumlar için arar ve bulunan ifadeyi ve her bir alt ifadeyi içeren bir dizi dizisi döndürür.

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

`$patternOrder` `true` ise, sonuçların yapısı değişir, böylece ilk öğe tam kalıp eşleşmelerinin bir dizisi olur, ikincisi parantez içindeki ilk alt kalıba karşılık gelen dizelerin bir dizisi olur ve bu böyle devam eder:

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

`$unmatchedAsNull` `true` ise, eşleşmeyen alt örüntüler null olarak döndürülür; aksi takdirde boş bir dize olarak döndürülür veya döndürülmez:

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

Eğer `$utf8` `true` ise, değerlendirme Unicode moduna geçer. Bu, `u` değiştiricisini belirtmeye benzer:

```php
Strings::matchAll('žlutý kůň', '~\w+~');
/* [
	0 => ['lut'],
	1 => ['k'],
] */

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

`$offset` parametresi, aramanın başlatılacağı konumu belirtmek için kullanılabilir (bayt cinsinden; `$utf8` ayarlanmışsa karakter cinsinden).

Eğer `$captureOffset` `true` ise, oluşan her eşleşme için dizedeki konumu da döndürülür (bayt cinsinden; `$utf8` ayarlanmışsa karakter cinsinden). Bu, dönüş değerini, her bir elemanın eşleşen dize ve konumundan oluşan bir çift olduğu bir diziye dönüştürür:

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

Eğer `$lazy` `true` ise, fonksiyon bir dizi yerine bir `Generator` döndürür, bu da büyük dizelerle çalışırken önemli performans avantajları sağlar. Üreteç, tüm dizeyi bir kerede işlemek yerine eşleşmelerin artımlı olarak bulunmasına olanak tanır. Bu, son derece büyük girdi metinlerinin verimli bir şekilde işlenmesini sağlar. Ayrıca, istediğiniz eşleşmeyi bulduğunuzda işlemeyi istediğiniz zaman kesebilir ve hesaplama süresinden tasarruf edebilirsiniz.

```php
$matches = Strings::matchAll($largeText, '~\w+~', lazy: true);
foreach ($matches as $match) {
    echo "Found: $match[0]\n";
    // Processing can be interrupted at any time
}
```


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

Düzenli ifadeyle eşleşen tüm oluşumları değiştirir. `$replacement` ya bir değiştirme dizesi maskesi ya da bir geri aramadır.

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

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

Fonksiyon ayrıca ikinci parametreye `pattern => replacement` şeklinde bir dizi geçirerek çoklu değiştirmelere izin verir:

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

`$limit` parametresi ikame sayısını sınırlar. Limit -1, limit olmadığı anlamına gelir.

Eğer `$utf8` `true` ise, değerlendirme Unicode moduna geçer. Bu, `u` değiştiricisini belirtmeye benzer.

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

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

Eğer `$captureOffset` `true` ise, oluşan her eşleşme için dizedeki konumu (bayt cinsinden; `$utf8` ayarlanmışsa karakter cinsinden) da geri aramaya aktarılır. Bu, aktarılan dizinin biçimini değiştirir; burada her eleman eşleşen dize ve konumundan oluşan bir çifttir.

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

`$unmatchedAsNull` `true` ise, eşleşmeyen alt örüntüler geri aramaya null olarak aktarılır; aksi takdirde boş bir dize olarak aktarılır veya aktarılmaz:

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

Dize İşlevleri

Nette\Utils\Strings UTF-8 kodlu dizelerle çalışmak için birçok yararlı işlev içeren statik bir sınıftır.

Kurulum:

composer require nette/utils

Tüm örnekler aşağıdaki sınıf takma adının tanımlandığını varsayar:

use Nette\Utils\Strings;

Harf Kutusu

Bu işlevler mbstring PHP uzantısını gerektirir.

lower(string $s): string

UTF-8 dizesinin tüm karakterlerini küçük harfe dönüştürür.

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

upper(string $s): string

UTF-8 dizesinin tüm karakterlerini büyük harfe dönüştürür.

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

firstUpper(string $s): string

UTF-8 dizesinin ilk karakterini büyük harfe dönüştürür ve diğer karakterleri değiştirmeden bırakır.

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

firstLower(string $s): string

UTF-8 dizesinin ilk karakterini küçük harfe dönüştürür ve diğer karakterleri değiştirmeden bırakır.

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

capitalize(string $s): string

UTF-8 dizesindeki her sözcüğün ilk karakterini büyük harfe, diğerlerini küçük harfe dönüştürür.

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

Dizeyi Düzenleme

normalize(string $s): string

Kontrol karakterlerini kaldırır, satır sonlarını \n olarak normalleştirir, baştaki ve sondaki boş satırları kaldırır, satırlardaki son boşlukları keser, UTF-8'i NFC'nin normal biçimine normalleştirir.

unixNewLines(string $s): string

Satır sonlarını Unix sistemlerinde kullanılan \n adresine dönüştürür. Satır sonları şunlardır: \n, \r, \r\n, U+2028 satır ayırıcı, U+2029 paragraf ayırıcı.

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

platformNewLines(string $s): string

Satır sonlarını geçerli platforma özgü karakterlere dönüştürür, yani Windows'ta \r\n ve başka yerlerde \n. Satır sonları \n, \r, \r\n, U+2028 satır ayırıcı, U+2029 paragraf ayırıcıdır.

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

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

UTF-8 dizesini URL'de kullanılan biçime dönüştürür, yani aksan işaretlerini kaldırır ve İngilizce alfabenin harfleri ve sayılar dışındaki tüm karakterleri tire ile değiştirir.

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

Diğer karakterler de korunabilir, ancak bunlar ikinci argüman olarak aktarılmalıdır.

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

Üçüncü bağımsız değişken dizenin küçük harfe dönüştürülmesini engelleyebilir.

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

PHP uzantısı gerektirir intl.

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

UTF-8 kodlu bir dizeden sol ve sağ taraftaki tüm boşlukları (veya ikinci bağımsız değişken olarak aktarılan karakterleri) kaldırır.

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

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

Bir UTF-8 dizesini, tüm sözcükleri bölmemeye çalışarak, verilen maksimum uzunlukta keser. Yalnızca dize kesilirse, dizeye bir üç nokta (veya üçüncü bağımsız değişkenle ayarlanan başka bir şey) eklenir.

$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

Çok satırlı bir metni soldan girintiler. İkinci bağımsız değişken kaç girinti karakteri kullanılacağını belirlerken, girintinin kendisi üçüncü bağımsız değişkendir (varsayılan olarak tab).

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

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

Bir UTF-8 dizesini, $pad dizesinin başına ekleyerek verilen uzunlukta doldurur.

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

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

$pad dizesini sonuna ekleyerek UTF-8 dizesini verilen uzunlukta tamponlar.

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

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

Başlangıç konumu $start ve uzunluğu $length ile belirtilen UTF-8 dizesinin bir bölümünü döndürür. $start negatifse, döndürülen dize dizenin sonundan itibaren $start'inci karakterden başlar.

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

reverse(string $s): string

UTF-8 dizesini tersine çevirir.

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

length(string $s): int

UTF-8 dizesindeki karakter sayısını (bayt değil) döndürür.

Bu, grafem sayısından farklı olabilen Unicode kod noktalarının sayısıdır.

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

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

$haystack dizesinin $needle ile başlayıp başlamadığını kontrol eder.

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

Yerel str_starts_with() adresini kullanın.

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

$haystack dizesinin $needle ile bitip bitmediğini kontrol eder.

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

Yerel str_ends_with() adresini kullanın.

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

$haystack dizesinin $needle içerip içermediğini kontrol eder.

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

Yerel str_contains() adresini kullanın.

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

Karakter durumunu dikkate almadan iki UTF-8 dizgisini veya parçalarını karşılaştırır. $length boşsa, tüm dizgiler karşılaştırılır, negatifse, dizgilerin sonundan itibaren karşılık gelen karakter sayısı karşılaştırılır, aksi takdirde başlangıçtan itibaren uygun karakter sayısı karşılaştırılır.

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

Dizelerin ortak önekini bulur veya önek bulunamazsa boş dize döndürür.

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

$haystack öğesinin $nth öğesinin $needle öğesinden önceki kısmını döndürür veya iğne bulunamazsa null öğesini döndürür. Negatif değer, sondan itibaren arama anlamına gelir.

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

$needle 'nin $nth oluşumundan sonra $haystack 'un bir kısmını döndürür veya $needle bulunamazsa null 'u döndürür. Negatif $nth değeri sondan arama anlamına gelir.

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

$needle 'in $haystack 'de veya $needle bulunamadıysa null 'de $nth oluşumunun karakter cinsinden konumunu verir. Negatif $nth değeri sondan arama anlamına gelir.

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

Kodlama

fixEncoding(string $s): string

Bir dizeden tüm geçersiz UTF-8 karakterlerini kaldırır.

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

checkEncoding(string $s): bool

Dizenin UTF-8 kodlamasında geçerli olup olmadığını denetler.

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

Nette\Utils\Validator::isUnicode() işlevini kullanın.

toAscii(string $s): string

UTF-8 dizesini ASCII'ye dönüştürür, yani aksan işaretlerini vb. kaldırır.

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

PHP uzantısı gerektirir intl.

chr(int $code): string

Kod noktasından UTF-8'de belirli bir karakteri döndürür (0×0000..D7FF veya 0×E000..10FFFF aralığındaki sayı).

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

ord(string $char): int

UTF-8'de belirli bir karakterin kod noktasını döndürür (0×0000..D7FF veya 0×E000..10FFFF aralığında sayı).

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

Düzenli İfadeler

Strings sınıfı düzenli ifadelerle çalışmak için işlevler sağlar. Yerel PHP işlevlerinin aksine, daha anlaşılır bir API'ye, daha iyi Unicode desteğine ve en önemlisi hata algılamaya sahiptirler. Herhangi bir derleme veya ifade işleme hatası bir Nette\RegexpException istisnası fırlatacaktır.

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

Dizeyi düzenli ifadeye göre dizilere böler. Parantez içindeki ifadeler de yakalanacak ve döndürülecektir.

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

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

$skipEmpty true ise, yalnızca boş olmayan öğeler iade edilecektir:

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

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

$limit belirtilirse, yalnızca sınıra kadar olan alt dizeler döndürülür ve dizenin geri kalanı son öğeye yerleştirilir. Limitin –1 veya 0 olması limit olmadığı anlamına gelir.

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

Eğer $utf8 true ise, değerlendirme Unicode moduna geçer. Bu, u değiştiricisini belirtmeye benzer.

Eğer $captureOffset true ise, oluşan her eşleşme için dizedeki konumu da döndürülür (bayt cinsinden; $utf8 ayarlanmışsa karakter cinsinden). Bu, dönüş değerini, her bir elemanın eşleşen dize ve konumundan oluşan bir çift olduğu bir diziye dönüştürür.

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

Dizeyi düzenli ifadeyle eşleşen kısım için arar ve bulunan ifadeyi ve tek tek alt ifadeleri içeren bir dizi veya null döndürür.

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

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

$unmatchedAsNull true ise, eşleşmeyen alt örüntüler null olarak döndürülür; aksi takdirde boş bir dize olarak döndürülür veya döndürülmez:

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

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

Eğer $utf8 true ise, değerlendirme Unicode moduna geçer. Bu, u değiştiricisini belirtmeye benzer:

Strings::match('žlutý kůň', '~\w+~');
// ['lut']

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

$offset parametresi, aramanın başlatılacağı konumu belirtmek için kullanılabilir (bayt cinsinden; $utf8 ayarlanmışsa karakter cinsinden).

Eğer $captureOffset true ise, oluşan her eşleşme için dizedeki konumu da döndürülür (bayt cinsinden; $utf8 ayarlanmışsa karakter cinsinden). Bu, dönüş değerini, her bir elemanın eşleşen dize ve ofsetinden oluşan bir çift olduğu bir diziye dönüştürür:

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

Dizeyi, düzenli ifadeyle eşleşen tüm oluşumlar için arar ve bulunan ifadeyi ve her bir alt ifadeyi içeren bir dizi dizisi döndürür.

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

$patternOrder true ise, sonuçların yapısı değişir, böylece ilk öğe tam kalıp eşleşmelerinin bir dizisi olur, ikincisi parantez içindeki ilk alt kalıba karşılık gelen dizelerin bir dizisi olur ve bu böyle devam eder:

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

$unmatchedAsNull true ise, eşleşmeyen alt örüntüler null olarak döndürülür; aksi takdirde boş bir dize olarak döndürülür veya döndürülmez:

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

Eğer $utf8 true ise, değerlendirme Unicode moduna geçer. Bu, u değiştiricisini belirtmeye benzer:

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

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

$offset parametresi, aramanın başlatılacağı konumu belirtmek için kullanılabilir (bayt cinsinden; $utf8 ayarlanmışsa karakter cinsinden).

Eğer $captureOffset true ise, oluşan her eşleşme için dizedeki konumu da döndürülür (bayt cinsinden; $utf8 ayarlanmışsa karakter cinsinden). Bu, dönüş değerini, her bir elemanın eşleşen dize ve konumundan oluşan bir çift olduğu bir diziye dönüştürür:

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

Eğer $lazy true ise, fonksiyon bir dizi yerine bir Generator döndürür, bu da büyük dizelerle çalışırken önemli performans avantajları sağlar. Üreteç, tüm dizeyi bir kerede işlemek yerine eşleşmelerin artımlı olarak bulunmasına olanak tanır. Bu, son derece büyük girdi metinlerinin verimli bir şekilde işlenmesini sağlar. Ayrıca, istediğiniz eşleşmeyi bulduğunuzda işlemeyi istediğiniz zaman kesebilir ve hesaplama süresinden tasarruf edebilirsiniz.

$matches = Strings::matchAll($largeText, '~\w+~', lazy: true);
foreach ($matches as $match) {
    echo "Found: $match[0]\n";
    // Processing can be interrupted at any time
}

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

Düzenli ifadeyle eşleşen tüm oluşumları değiştirir. $replacement ya bir değiştirme dizesi maskesi ya da bir geri aramadır.

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

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

Fonksiyon ayrıca ikinci parametreye pattern => replacement şeklinde bir dizi geçirerek çoklu değiştirmelere izin verir:

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

$limit parametresi ikame sayısını sınırlar. Limit –1, limit olmadığı anlamına gelir.

Eğer $utf8 true ise, değerlendirme Unicode moduna geçer. Bu, u değiştiricisini belirtmeye benzer.

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

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

Eğer $captureOffset true ise, oluşan her eşleşme için dizedeki konumu (bayt cinsinden; $utf8 ayarlanmışsa karakter cinsinden) da geri aramaya aktarılır. Bu, aktarılan dizinin biçimini değiştirir; burada her eleman eşleşen dize ve konumundan oluşan bir çifttir.

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]]

$unmatchedAsNull true ise, eşleşmeyen alt örüntüler geri aramaya null olarak aktarılır; aksi takdirde boş bir dize olarak aktarılır veya aktarılmaz:

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