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