PHP Türü

Nette\Utils\Type, bir PHP veri türünü temsil eder. Dizeden ya da reflection'dan elde edilmiş türleri çözümlemek, karşılaştırmak ve onlarla çalışmak için kullanılır.

PHP bugün çok zengin bir tür sistemine sahip: skaler türlerden (int, string) nesnelere ve arayüzlere, oradan bileşik türlere (birleşim A|B, kesişim A&B ya da ayrık normal biçim (A&B)|D) kadar. Buna ek olarak void, never, mixed gibi özel türler ile self ve static gibi göreli türler de var.

Bu türlerle doğrudan, özellikle ReflectionType üzerinden çalışmak çoğu zaman zahmetlidir; çünkü ReflectionNamedType, ReflectionUnionType ve diğer nesneleri özyinelemeli olarak ayırt etmeniz gerekir. Nette\Utils\Type sınıfı bunların hepsini sarmalar ve PHP'nin desteklediği herhangi bir türle çalışmak için birleşik ve sezgisel bir API sunar.

Örneğin bir türün başka bir türü kabul edip etmediğini (uyumluluğu) kolayca denetlemenizi, türleri genişletmenizi ya da reflection'ları okunabilir bir yazıma dönüştürmenizi sağlar.

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\Type;

fromReflection ($reflection): ?Type

Bu statik metot, reflection'dan yola çıkarak bir Type nesnesi oluşturur. Parametre bir ReflectionMethod ya da ReflectionFunction nesnesi (dönüş değerinin türünü döndürür) veya bir ReflectionParameter ya da ReflectionProperty nesnesi olabilir. self, static ve parent değerlerini gerçek sınıf adına çözer. İlgili öğenin türü yoksa null döndürür.

class DemoClass
{
	public self $foo;
}

$prop = new ReflectionProperty(DemoClass::class, 'foo');
echo Type::fromReflection($prop); // 'DemoClass'

fromString (string $type): Type

Bu statik metot, bir Type nesnesini metinsel temsilinden oluşturur.

$type = Type::fromString('Foo|Bar');
echo $type;      // 'Foo|Bar'

fromValue (mixed $value): Type

Verilen değerin türünden yola çıkarak bir Type nesnesi oluşturan statik metot.

$type = Type::fromValue('hello'); // 'string'
$type = Type::fromValue(123);     // 'int'
$type = Type::fromValue(new stdClass); // 'stdClass'

PHP resource türünü desteklemediğinden, resource'lar için mixed döndürür. Anonim sınıflar için en yakın atanın adını ya da object döndürür.

$obj = new class extends Foo { };
$type = Type::fromValue($obj);    // 'Foo'

getNames (): (string|array)[]

Bileşik bir türü oluşturan alt türleri temsil eden dizelerden oluşan bir dizi döndürür. Kesişim türlerinde dizilerden oluşan bir dizi döndürür.

$type = Type::fromString('string|null'); // ya da '?string'
$type->getNames();  // ['string', 'null']

$type = Type::fromString('(Foo&Bar)|string');
$type->getNames();  // [['Foo', 'Bar'], 'string']

getTypes(): Type[]

Bileşik bir türü oluşturan alt türleri temsil eden Type nesnelerinden oluşan bir dizi döndürür:

$type = Type::fromString('string|null'); // ya da '?string'
$type->getTypes();  // [Type::fromString('string'), Type::fromString('null')]

$type = Type::fromString('(Foo&Bar)|string');
$type->getTypes();  // [Type::fromString('Foo&Bar'), Type::fromString('string')]

$type = Type::fromString('Foo&Bar');
$type->getTypes();  // [Type::fromString('Foo'), Type::fromString('Bar')]

getSingleName(): ?string

Basit türlerde (?string gibi basit nullable türler dahil) tür adını döndürür. Diğer durumlarda null döndürür.

$type = Type::fromString('string|null');
echo $type;                       // '?string'
echo $type->getSingleName();      // 'string'

$type = Type::fromString('?Foo');
echo $type;                       // '?Foo'
echo $type->getSingleName();      // 'Foo'

$type = Type::fromString('Foo|Bar');
echo $type;                       // 'Foo|Bar'
echo $type->getSingleName();      // null (birleşim türü)

isSimple(): bool

Türün basit olup olmadığını döndürür. Basit türlere, basit nullable türler de (örneğin ?string, ?Foo) dahildir:

$type = Type::fromString('string');
$type->isSimple();       // true
$type->isUnion();        // false

$type = Type::fromString('?Foo'); // ya da 'Foo|null'
$type->isSimple();       // true
$type->isUnion();        // true (çünkü null içeriyor)

isUnion(): bool

Türün birleşim türü olup olmadığını (| içerip içermediğini) döndürür.

$type = Type::fromString('Foo&Bar');
$type->isUnion();        // true

isIntersection(): bool

Türün kesişim türü olup olmadığını (& içerip içermediğini) döndürür.

$type = Type::fromString('Foo&Bar');
$type->isIntersection(); // true

isBuiltin(): bool

Türün basit ve aynı zamanda PHP'nin yerleşik türlerinden biri (string, int, array, callable vb.) olup olmadığını döndürür.

$type = Type::fromString('string');
$type->isBuiltin(); // true

$type = Type::fromString('string|int');
$type->isBuiltin(); // false

$type = Type::fromString('Foo');
$type->isBuiltin(); // false

isClass(): bool

Türün basit ve aynı zamanda bir sınıf adı olup olmadığını (yani string ya da int gibi yerleşik bir tür olmadığını) döndürür.

$type = Type::fromString('string');
$type->isClass();   // false

$type = Type::fromString('Foo|null');
$type->isClass();   // true

$type = Type::fromString('Foo|Bar');
$type->isClass();   // false

isClassKeyword(): bool

Türün self, parent ya da static iç anahtar sözcüklerinden biri olup olmadığını döndürür.

$type = Type::fromString('self');
$type->isClassKeyword();   // true

$type = Type::fromString('Foo');
$type->isClassKeyword();   // false

allows (string|Type $type): bool

allows() metodu tür uyumluluğunu denetler. Örneğin belirli bir türdeki değerin, bu türü bekleyen bir fonksiyona parametre olarak aktarılıp aktarılamayacağını belirleyebilir.

$type = Type::fromString('string|null');
$type->allows('string'); // true
$type->allows('null');   // true
$type->allows('Foo');    // false

$type = Type::fromString('mixed');
$type->allows('null');   // true

with (string|Type $type): Type

Hem özgün türü hem de eklenen türü kabul eden bir Type nesnesi döndürür. Yani bir birleşim türü oluşturur.

Metot akıllıdır ve türleri gereksiz yere yinelemez. Zaten var olan ya da geçerli türü kapsayan bir tür eklerseniz (örneğin string'e mixed eklerseniz), sonuç sadeleştirilir.

$type = Type::fromString('string');

// Nullable string'e genişletme
echo $type->with('null'); // '?string'

// Birleşim türü oluşturma
echo $type->with('int');  // 'string|int'

// Her şeyi kapsayan bir tür ekleme
echo $type->with('mixed'); // 'mixed'