PHP Enum Kullanımı: cases(), from(), tryFrom() ve match

Enum Neden Var: Sabitlerle Yazılan Durum Kodlarının Sorunu

Enum'lardan önce bir siparişin durumunu tutmak için çoğu projede sınıf sabitleri kullanılırdı: const BEKLEMEDE = 'pending'; gibi. Bu yaklaşımın temel sorunu, sabitlerin yalnızca birer string olmasıdır. Bir fonksiyon parametresini string $durum olarak tanımladığınızda 'pending' da 'pendng' da, hatta boş metin de kabul edilir. Hatalı değer ancak çok sonra, belki veritabanına yazılırken fark edilir. Sabitlerin ayrıntıları için PHP sabitleri yazısına bakabilirsiniz.

Enum bu açığı tür sistemiyle kapatır. PHP kılavuzu enum'u, geçersiz durumların hiç temsil edilemediği bir alan modeli kurmanın yolu olarak tanıtır. Bir parametreyi Durum $d olarak tanımladığınızda bu parametreye yalnızca Durum türünün case'leri girebilir; başka her değer anında TypeError üretir. Böylece "bu değer gerçekten geçerli mi?" kontrolünü her fonksiyonda tekrar yazmanız gerekmez.

Teknik olarak enum, özel bir sınıftır ve her case o sınıfın tek örnekli (singleton) bir nesnesidir. Bu yüzden enum'lar sınıflar, arayüzler ve trait'lerle aynı ad alanını paylaşır, aynı şekilde autoload edilebilir ve nesnenin kullanılabildiği her yerde, tip kontrolleri dahil, kullanılabilir. Ad alanları için namespace yazısına, otomatik yükleme için autoload yazısına bakın.

Pure Enum: Değeri Olmayan Case'ler

En basit enum, yalnızca case adlarından oluşur. Her case'in salt okunur bir name özelliği vardır ve bu özellik case adını büyük küçük harf duyarlı olarak verir. Aşağıdaki örnekte bir fonksiyon Durum türünde parametre alıyor; aynı case'e iki ayrı değişkenden ulaşmak aynı nesneyi verdiği için === karşılaştırması doğrudur.

<?php
enum Durum
{
    case Taslak;
    case Yayinda;
    case Arsiv;
}

function yazdir(Durum $d): void
{
    echo $d->name, "\n";
}

yazdir(Durum::Yayinda);                 // çıktı: Yayinda

$a = Durum::Taslak;
$b = Durum::Taslak;
var_dump($a === $b);                    // çıktı: bool(true)
var_dump($a instanceof Durum);          // çıktı: bool(true)
var_dump($a === 'Taslak');              // çıktı: bool(false)
var_dump(Durum::Taslak < Durum::Arsiv); // çıktı: bool(false)
var_dump($a);                           // çıktı: enum(Durum::Taslak)

Dikkat edilecek iki nokta var. Birincisi, pure case'in arkasında gizli bir sayı ya da metin yoktur: Durum::Taslak ne 0'a ne de 'Taslak' metnine eşittir. İkincisi, enum değerleri arasında sıralama yoktur. Kılavuz, nesneler üzerinde anlamlı olmadığı için < ve > karşılaştırmalarının enum'larda her zaman false döndüğünü belirtir. Sıralama gerekiyorsa backed enum kullanıp value üzerinden karşılaştırmanız veya enum'a bir sıra metodu eklemeniz gerekir.

Fonksiyona metin verdiğinizde PHP bunu tür hatası olarak durdurur. Hata mesajı hangi argümanın hangi türü beklediğini açıkça söyler:

<?php
enum Durum
{
    case Taslak;
    case Yayinda;
}

function yazdir(Durum $d): void
{
    echo $d->name, "\n";
}

yazdir('Yayinda');
// Fatal error: Uncaught TypeError: yazdir(): Argument #1 ($d) must be of type Durum, string given, called in /yol/ornek.php on line 13 and defined in /yol/ornek.php:8

Backed Enum: string ve int Karşılıklı Case'ler

Pure enum program içinde iş görür ama veritabanına, JSON'a veya bir HTML formuna nesne yazamazsınız. Bunun için her case'e sabit bir skaler karşılık verilir. Enum adından sonra iki nokta ve tür yazılır: enum Rol: string. Bu durumda her case = ile kendi değerini almak zorundadır ve bu değer salt okunur value özelliğinden okunur.

Kılavuzdaki kurallar kısaca şöyle: arka tür yalnızca int veya string olabilir, int|string gibi birleşik tür kullanılamaz. Değerler otomatik üretilmez; sıralı sayı istiyorsanız bile her birini elle yazarsınız. İki case aynı değeri paylaşamaz. Bir enum ya tamamen pure ya da tamamen backed olur, ikisi karışmaz. PHP 8.2'den beri değer olarak sabit ifadeler de yazılabilir; yani case Tr = VARSAYILAN_DIL; gibi bir sabite başvurmak geçerlidir.

<?php
enum Rol: string
{
    case Yonetici = 'admin';
    case Editor = 'editor';
    case Okur = 'reader';
}

echo Rol::Editor->value, "\n";      // çıktı: editor
echo Rol::Editor->name, "\n";       // çıktı: Editor
var_dump(Rol::from('admin'));       // çıktı: enum(Rol::Yonetici)
var_dump(Rol::tryFrom('misafir'));  // çıktı: NULL

$gelen = 'misafir';
$rol = Rol::tryFrom($gelen) ?? Rol::Okur;
echo $rol->name, "\n";              // çıktı: Okur

try {
    Rol::from('misafir');
} catch (ValueError $e) {
    echo $e->getMessage(), "\n";
}
// çıktı: "misafir" is not a valid backing value for enum Rol

value ve name salt okunurdur. $rol->value = 'x'; yazarsanız Error: Cannot modify readonly property Rol::$value, bu özelliğe referans almaya çalışırsanız Cannot indirectly modify readonly property hatası alırsınız. Bu kısıt, bir case'in değerinin program çalışırken değişmesini imkânsız kılar.

Kurala uymayan tanımlar farklı anlarda yakalanır. Backed enum içinde değeri olmayan bir case yazarsanız dosya hiç çalışmaz: Fatal error: Case B of backed enum Rol must have a value. İki case'e aynı değeri verdiğinizde ise PHP 8.5.12 dosyayı derler, hata enum ilk kullanıldığında Error: Duplicate value in enum Rol for cases A and B olarak ortaya çıkar. Yani yinelenen değer, enum'a hiç dokunmayan bir test çalıştırmasında gözden kaçabilir.

from() ve tryFrom(): Hangisini Ne Zaman Kullanmalı?

Backed enum'lar motorun otomatik eklediği BackedEnum arayüzünü uygular. Bu arayüz iki statik metot getirir. from() verilen değere karşılık gelen case'i döndürür, bulamazsa ValueError fırlatır. tryFrom() aynı işi yapar ama bulamadığında null döndürür. Kılavuzun önerisi nettir: değerin doğru olduğuna güvendiğiniz ve eksik değerin programı durdurması gereken yerlerde from(), kullanıcıdan gelen ve güvenilmeyen veride kendi hata mantığınızı kurmak için tryFrom().

Bu iki metot PHP'nin zayıf ve katı tip kurallarına uyar. Varsayılan zayıf modda int karşılıklı bir enum'a '2' metnini verirseniz değer sayıya çevrilir ve doğru case bulunur. Sayıya çevrilemeyen bir metin ise TypeError verir. Dosyanın başına declare(strict_types=1); eklediğinizde tür dönüşümü kapanır: int enum'a metin, string enum'a sayı vermek her durumda TypeError olur. Katı mod hakkında ayrıntı tip bildirimleri yazısında var.

<?php
declare(strict_types=1);

enum Oncelik: int
{
    case Dusuk = 1;
    case Orta = 2;
    case Yuksek = 3;
}

var_dump(Oncelik::from(2));        // çıktı: enum(Oncelik::Orta)
var_dump(Oncelik::tryFrom(7));     // çıktı: NULL

// $_GET ve form verisi her zaman metindir; katı modda önce int'e çevirin:
$gelen = '3';
var_dump(Oncelik::from((int) $gelen)); // çıktı: enum(Oncelik::Yuksek)

Oncelik::from('2');
// Fatal error: Uncaught TypeError: Oncelik::from(): Argument #1 ($value) must be of type int, string given in /yol/ornek.php:18

cases() ile Tüm Değerleri Listelemek

Pure ve backed fark etmeksizin her enum, motorun eklediği UnitEnum arayüzünü uygular. Bu arayüzün tek metodu cases()'tır ve case'leri tanımlandıkları sırayla, 0'dan başlayan sıralı bir dizi olarak döndürür. Bir açılır liste, bir filtre menüsü veya yönetim panelindeki seçenekler için kaynağı tek yerde tutmanın en kolay yolu budur. Aşağıdaki örnek bir <select> kutusunun seçeneklerini üretir; HTML'e yazılan her değeri htmlspecialchars() ile kaçırmayı unutmayın, neden gerekli olduğu filter_var ve çıktı kaçırma yazısında anlatılıyor.

<?php
enum Sehir: string
{
    case Istanbul = '34';
    case Ankara = '06';
    case Izmir = '35';

    public function etiket(): string
    {
        return match ($this) {
            self::Istanbul => 'İstanbul',
            self::Ankara => 'Ankara',
            self::Izmir => 'İzmir',
        };
    }
}

foreach (Sehir::cases() as $sehir) {
    printf(
        "<option value=\"%s\">%s</option>\n",
        htmlspecialchars($sehir->value),
        htmlspecialchars($sehir->etiket())
    );
}
/* çıktı:
<option value="34">İstanbul</option>
<option value="06">Ankara</option>
<option value="35">İzmir</option>
*/

echo count(Sehir::cases()), "\n";                          // çıktı: 3
echo implode(', ', array_column(Sehir::cases(), 'name')), "\n"; // çıktı: Istanbul, Ankara, Izmir

Son satırdaki array_column() kullanımı, nesne dizilerinden de sütun okuyabildiği için çalışır. Böylece tüm case adlarını veya value değerlerini tek satırda alabilirsiniz. Dizi fonksiyonlarının geri kalanı için array_map ve array_filter yazısına bakın.

Enum'a Metot, Arayüz, Sabit ve Statik Metot Eklemek

Enum'lar yalnızca değer listesi değildir; sınıf gibi metot taşıyabilir. Metodun içinde $this, o anki case'i gösterir. Pratikte metotların çoğu ya sabit bir değer döndürür ya da match ($this) ile her case için farklı sonuç üretir. Enum'lar istedikleri kadar arayüz uygulayabilir; bu durumda o arayüzü bekleyen her tip kontrolü enum case'lerini de kabul eder. Backed enum'da arayüz, arka türden sonra yazılır: enum SiparisDurumu: string implements Etiketli. Arayüzlerin genel kullanımı kalıtım ve interface yazısında var.

Enum içine sabit de koyabilirsiniz ve bir sabit bir case'i gösterebilir. Bu, aynı case'e ikinci bir ad vermenin, yani takma ad oluşturmanın resmî yoludur. Statik metotlar ise çoğunlukla alternatif kurucu olarak kullanılır: bir ölçüyü veya metni alıp uygun case'i seçen bir fromX() metodu gibi. Kalıtım olmadığı için private ile protected arasında pratikte fark yoktur.

<?php
interface Etiketli
{
    public function etiket(): string;
}

enum SiparisDurumu: string implements Etiketli
{
    case Beklemede = 'pending';
    case Hazirlaniyor = 'processing';
    case Kargoda = 'shipped';
    case Teslim = 'delivered';
    case Iptal = 'cancelled';

    public const Varsayilan = self::Beklemede;

    public function etiket(): string
    {
        return match ($this) {
            self::Beklemede => 'Ödeme bekleniyor',
            self::Hazirlaniyor => 'Hazırlanıyor',
            self::Kargoda => 'Kargoya verildi',
            self::Teslim => 'Teslim edildi',
            self::Iptal => 'İptal edildi',
        };
    }

    public function kapaliMi(): bool
    {
        return $this === self::Teslim || $this === self::Iptal;
    }

    public static function acikOlanlar(): array
    {
        return array_values(array_filter(self::cases(), fn (self $d) => !$d->kapaliMi()));
    }
}

function rozet(Etiketli $e): string
{
    return '[' . $e->etiket() . ']';
}

echo rozet(SiparisDurumu::Kargoda), "\n";            // çıktı: [Kargoya verildi]
echo SiparisDurumu::Varsayilan->name, "\n";          // çıktı: Beklemede
var_dump(SiparisDurumu::Teslim->kapaliMi());         // çıktı: bool(true)
echo implode(', ', array_map(fn ($d) => $d->value, SiparisDurumu::acikOlanlar())), "\n";
// çıktı: pending, processing, shipped

Enum'larda trait de kullanılabilir, ancak bir şartla: enum'a eklenen trait özellik (property) içeremez, yalnızca metot, statik metot ve sabit taşıyabilir. Özellikli bir trait kullanırsanız ölümcül hata alırsınız. Birden fazla enum'da tekrar eden yardımcı metotları paylaşmak için bu yol kullanışlıdır; trait'lerin genel kuralları trait kullanımı yazısında anlatılıyor.

match ile Enum: Eksik Case'i Hemen Görmek

Enum ile match birbirini tamamlar. match katı karşılaştırma (===) yaptığı ve case'ler tekil nesneler olduğu için her kol tam olarak bir case'e denk gelir. Daha önemlisi, match hiçbir kolla eşleşmeyen bir değerle karşılaşırsa sessizce devam etmez, UnhandledMatchError fırlatır. Enum'a yeni bir case eklediğinizde onu karşılamayan match ifadeleri ilk çalıştırmada kendini belli eder. switch ile farkları if, switch ve match yazısında ayrıntılı anlatılıyor.

<?php
enum Renk
{
    case Kirmizi;
    case Mavi;
    case Yesil;
}

function ad(Renk $r): string
{
    return match ($r) {
        Renk::Kirmizi => 'kırmızı',
        Renk::Mavi => 'mavi',
    };
}

echo ad(Renk::Mavi), "\n";  // çıktı: mavi
echo ad(Renk::Yesil), "\n";
// Fatal error: Uncaught UnhandledMatchError: Unhandled match case Renk::Yesil in /yol/ornek.php:13

Bu davranış, kılavuzun enum'ların neden genişletilemediğini açıklarken verdiği gerekçeyle de bağlantılıdır. Bir enum başka bir enum'u miras alabilseydi, alt enum'un yeni case'i üst enum için yazılmış ve tüm case'leri kapsadığı düşünülen match ifadelerini bozardı. Bu yüzden enum'lar her zaman final davranır.

Enum'larda Yapamadığınız Şeyler

Enum'lar sınıf ve nesne altyapısı üzerine kurulu olsa da her nesne özelliğini desteklemez. Temel fikir, case'lerin durum taşımamasıdır. Kılavuzdaki listeye göre:

• Kurucu (__construct) ve yıkıcı (__destruct) tanımlanamaz. PHP 8.5.12'de deneme Fatal error: Enum Durum cannot include magic method __construct verir.
• Statik ya da normal özellik tanımlanamaz: Fatal error: Enum Durum cannot include properties.
• Kalıtım yoktur: enum başka bir şeyi extends edemez, başka bir şey de enum'u genişletemez.
• Case klonlanamaz; clone Durum::Taslak denemesi Error: Trying to clone an uncloneable object of class Durum fırlatır. Nesne kopyalama için clone yazısına bakın.
• new Durum() ile örnek oluşturulamaz: Error: Cannot instantiate enum Durum.
• Sihirli metotlardan yalnızca __call, __callStatic ve __invoke kullanılabilir.
• Enum, kullanılmadan önce tanımlanmış olmalıdır. Aynı dosyada tanımından önce kullanılan bir enum Class "Durum" not found hatası verir.

Buna karşılık public, private ve protected metotlar ile statik metotlar, sabitler, istenen sayıda arayüz ve öznitelikler (attribute) serbesttir. ::class sihirli sabiti hem enum türünde hem de bir case üzerinde enum'un tam adını verir; çünkü case, o türün bir örneğidir. Enum'lara ve case'lere öznitelik eklemek için attributes yazısına bakabilirsiniz.

JSON, serialize() ve print_r ile Enum

Backed enum json_encode() ile kodlandığında yalnızca skaler değeri yazılır ve türü korunur: string case tırnaklı, int case tırnaksız çıkar. Pure enum'un ise JSON karşılığı yoktur. Kılavuz bunu hata olarak tanımlar; pratikte json_encode() bayraksız çağrıldığında false döner, JSON_THROW_ON_ERROR bayrağıyla çağrıldığında JsonException fırlatır. Her iki davranışı da JsonSerializable arayüzünü uygulayarak değiştirebilirsiniz. JSON bayrakları için json_encode ve json_decode yazısına bakın.

<?php
enum Rol: string
{
    case Editor = 'editor';
}

enum Oncelik: int
{
    case Orta = 2;
}

enum Durum
{
    case Taslak;
}

echo json_encode(['rol' => Rol::Editor, 'oncelik' => Oncelik::Orta]), "\n";
// çıktı: {"rol":"editor","oncelik":2}

var_dump(json_encode(Durum::Taslak));   // çıktı: bool(false)
echo json_last_error_msg(), "\n";        // çıktı: Non-backed enums have no default serialization

echo serialize(Durum::Taslak), "\n";     // çıktı: E:12:"Durum:Taslak";
var_dump(Rol::Editor === unserialize(serialize(Rol::Editor))); // çıktı: bool(true)

print_r(Oncelik::Orta);
/* çıktı:
Oncelik Enum:int
(
    [name] => Orta
    [value] => 2
)
*/

serialize() enum'lar için ayrı bir E kodu kullanır ve yalnızca enum ile case adını saklar. unserialize() bu adı görünce yeni nesne üretmez, mevcut tekil case'i geri verir; bu yüzden === karşılaştırması doğru çıkar. Eşleşen enum veya case bulunamazsa uyarı verilir ve false döner. JSON'dan geri okurken ise elinizde yalnızca skaler değer vardır; onu tekrar enum'a çevirmek için from() veya tryFrom() kullanırsınız.

Sabit İfadelerde ve Varsayılan Değerlerde Enum

Case'ler enum üzerinde sabit gibi temsil edildiği için çoğu sabit ifadede kullanılabilir: özellik varsayılanları, statik değişken başlangıç değerleri, parametre varsayılanları, global ve sınıf sabitleri. Bu sayede function listele(Siralama $yon = Siralama::Artan) gibi bir imza yazabilir, parametre verilmezse güvenli bir varsayılanla çalışabilirsiniz. Bir case'in değeri başka bir enum case'ine dayanamaz, ama normal bir sabit bir case'i gösterebilir. Enum üzerinde ArrayAccess gibi örtük sihirli çağrılar ise sabit ifadede yasaktır.

<?php
enum Siralama: string
{
    case Artan = 'asc';
    case Azalan = 'desc';
}

final class UrunSorgusu
{
    public const VARSAYILAN = Siralama::Azalan;

    public function __construct(public Siralama $yon = Siralama::Artan) {}

    public function sql(): string
    {
        return 'SELECT * FROM urunler ORDER BY fiyat ' . strtoupper($this->yon->value);
    }
}

echo (new UrunSorgusu())->sql(), "\n";
// çıktı: SELECT * FROM urunler ORDER BY fiyat ASC
echo (new UrunSorgusu(UrunSorgusu::VARSAYILAN))->sql(), "\n";
// çıktı: SELECT * FROM urunler ORDER BY fiyat DESC

Bu örnekte sıralama yönü SQL metnine doğrudan eklendi; bu, değerin enum ile sınırlandığı ve dışarıdan serbest metin gelemediği için güvenlidir. Kullanıcı verisini sorguya eklerken ise her zaman hazırlanmış ifade kullanın; ayrıntı PDO yazısında.

Uygulamalı Mini Örnek: Sipariş Durum Geçişleri

Enum'un en faydalı olduğu yerlerden biri durum makineleridir. Bir sipariş "beklemede" iken "hazırlanıyor" durumuna geçebilir ama "teslim edildi" durumundan geri dönemez. Bu kuralı dağınık if blokları yerine enum'un kendisine koymak, kuralın tek yerde yaşamasını sağlar. Veritabanından gelen metin from() ile enum'a çevrilir, çünkü veritabanındaki değerin geçerli olması beklenir; geçersizse bu bir veri hatasıdır ve programın durması doğrudur.

<?php
enum SiparisDurumu: string
{
    case Beklemede = 'pending';
    case Hazirlaniyor = 'processing';
    case Kargoda = 'shipped';
    case Teslim = 'delivered';
    case Iptal = 'cancelled';

    /** @return list<self> */
    public function sonrakiler(): array
    {
        return match ($this) {
            self::Beklemede => [self::Hazirlaniyor, self::Iptal],
            self::Hazirlaniyor => [self::Kargoda, self::Iptal],
            self::Kargoda => [self::Teslim],
            self::Teslim, self::Iptal => [],
        };
    }

    public function gecebilirMi(self $hedef): bool
    {
        return in_array($hedef, $this->sonrakiler(), true);
    }
}

$kayit = ['id' => 42, 'durum' => 'processing'];   // veritabanından gelmiş gibi
$durum = SiparisDurumu::from($kayit['durum']);

var_dump($durum->gecebilirMi(SiparisDurumu::Kargoda));    // çıktı: bool(true)
var_dump($durum->gecebilirMi(SiparisDurumu::Beklemede));  // çıktı: bool(false)
var_dump(count(SiparisDurumu::Teslim->sonrakiler()));     // çıktı: int(0)

$istek = 'refunded';                                       // formdan gelmiş gibi
$hedef = SiparisDurumu::tryFrom($istek);
echo $hedef === null ? "Geçersiz durum: $istek\n" : $hedef->name . "\n";
// çıktı: Geçersiz durum: refunded

Bu küçük örnekte üç önemli fikir bir arada: güvenilen veri için from(), dış girdi için tryFrom() ve null kontrolü, kuralların ise match içinde tüm case'leri kapsayacak şekilde yazılması. Yarın Iade adlı yeni bir case eklerseniz sonrakiler() metodu onu karşılamadığı için ilk çağrıda UnhandledMatchError verir ve eksik kuralı hemen fark edersiniz.

Sık Yapılan Hatalar

• Case'i metinle karşılaştırmak: $rol === 'editor' her zaman false'tur. Ya $rol === Rol::Editor yazın ya da $rol->value === 'editor'. Gevşek == karşılaştırması da case ile metni eşit saymaz.
• Dış girdide from() kullanmak: Kullanıcının gönderdiği her hatalı değer yakalanmamış bir ValueError'a dönüşür. Dış girdi için tryFrom() ve ?? tercih edin.
• Katı modda metni int enum'a vermek: declare(strict_types=1) açıkken $_GET değerlerini önce (int) ile çevirin.
• Enum'a durum eklemeye çalışmak: Özellik tanımlanamaz. Case'e bağlı veriyi metot içinde match ile döndürün veya ayrı bir sınıfta tutun.
• Sıralama için < ve > kullanmak: Enum'lar arasında bu karşılaştırmalar hep false döner. Sıra gerekiyorsa int backed enum ve value kullanın.
• Pure enum'u JSON'a yazmak: Sonuç false olur ve hata sessizce geçebilir. Ya backed enum kullanın ya da JSON_THROW_ON_ERROR ile hatayı görünür kılın.

Sık Sorulan Sorular

Pure enum mu backed enum mu kullanmalıyım?

Değer yalnızca program içinde dolaşıyorsa pure enum yeterlidir ve daha sadedir. Değer veritabanına, JSON'a, URL'ye veya bir forma yazılacaksa backed enum kullanın; çünkü pure enum'un JSON karşılığı yoktur ve dış dünyadan gelen değeri case'e çevirmenin hazır bir yolu bulunmaz.

Enum değerleri otomatik olarak 0, 1, 2 diye numaralanır mı?

Hayır. Pure case'lerin arkasında hiçbir sayı yoktur. Backed enum'da ise her değeri açıkça yazmanız gerekir; PHP sıralı sayı üretmez ve iki case'in aynı değeri paylaşmasına izin vermez.

Bir enum başka bir enum'dan türetilebilir mi?

Hayır, enum'lar genişletilemez ve başka bir sınıfı genişletemez. Ortak davranışı paylaşmak için arayüz uygulayabilir veya özellik içermeyen bir trait kullanabilirsiniz.

Enum hangi PHP sürümünde kullanılabilir?

Enum'lar PHP 8.1 ile geldi. Backed case değerlerinde sabit ifadeler kullanmak PHP 8.2 ile mümkün oldu. Bu yazıdaki örneklerin hiçbiri PHP 8.4 veya 8.5'e özgü bir özellik gerektirmiyor.

Marka adları sahiplerine aittir. Bu yazı bağımsız bir teknik rehberdir; adı geçen kuruluşlarla bayilik veya ortaklık ilişkisi bulunduğu anlamına gelmez.

İlgili içerikler: PHP öğrenme rehberi · PHP if, switch ve match · PHP sınıf ve nesne · PHP json_encode ve json_decode · PHP attributes