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

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

Dize İşlevleri

Harf Kutusu

lower (string $s): string

upper (string $s): string

firstUpper (string $s): string

firstLower (string $s): string

capitalize (string $s): string

Dizeyi Düzenleme

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

Kodlama

fixEncoding (string $s): string

checkEncoding (string $s): bool

toAscii (string $s): string

chr (int $code): string

ord (string $char): int

Düzenli İfadeler

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