Ciri adalah pemalar sihir dalam PHP yang selalu mengembalikan nama sifat di mana ia ditakrifkan, tanpa mengira kelas menggunakannya. 1. Ia diselesaikan pada masa kompilasi dalam skop sifat dan tidak berubah berdasarkan kelas panggilan. 2. Tidak seperti kelas__, yang mencerminkan konteks kelas semasa, __trait tetap tetap kepada nama sifat. 3. Ia berguna untuk menyahpepijat, pembalakan, dan pelaporan ralat dengan memberikan pengenalan sifat yang konsisten. 4. Ia tidak boleh digunakan di luar sifat, mengakibatkan kesilapan maut jika dicuba. 5. Kaedah aliasing dengan 'as' tidak menjejaskan nilai sifat __ kerana konteks dalaman sifat tetap tidak berubah. Oleh itu, __trait dipercayai sendiri mengenal pasti sifat, memastikan tingkah laku yang boleh diramal merentasi kelas yang berbeza.

__TRAIT__ bukanlah pemalar PHP terbina dalam-anda mungkin memikirkan __TRAIT__ , yang merupakan pemalar ajaib di PHP, sama dengan __CLASS__ , __METHOD__ , atau __FUNCTION__ . Ia digunakan secara khusus dalam konteks ciri -ciri , dan memahami bagaimana ia berkelakuan di dalam kelas (dan dalam sifat itu sendiri) mendedahkan beberapa tingkah laku kontekstual yang halus tetapi berkuasa.

Mari kita memecahkan "sihir kontekstual" __TRAIT__ dan bagaimana ia bertindak apabila sifat digunakan di dalam kelas.

Apa sebenarnya __TRAIT__

__TRAIT__ adalah pemalar sihir yang mengembalikan nama sifat yang digunakannya , sebagai rentetan. Ia hanya bermakna di dalam badan sifat. Sama seperti __CLASS__ memberi anda nama kelas semasa, __TRAIT__ memberi anda nama yang berkelayakan sifat semasa - tetapi hanya dari dalam sifat.

 sifat mytrait {
    fungsi awam getTraitName () {
        kembali __trait__;
    }
}

kelas myclass {
    Gunakan MyTrait;
}

$ obj = myClass baru ();
echo $ obj-> getTraitName (); // output: mytrait

Setakat ini, begitu mudah. Tetapi di sinilah sihir - dan kekeliruan - bermula.

Bagaimana __TRAIT__ berkelakuan di dalam kelas (ketika sifatnya digunakan)

Walaupun kaedah sifat disuntik ke dalam kelas, __TRAIT__ tidak berubah berdasarkan kelas menggunakan sifat tersebut. Ia diselesaikan pada masa penyusunan , bukan runtime, dan selalu merujuk kepada nama sendiri - tanpa mengira kelas yang menggunakannya.

Contoh: Pelbagai kelas menggunakan sifat yang sama

 Trait Logger {
    log fungsi awam ($ mesej) {
        echo '['. __Trait__. ']'. $ mesej. Php_eol;
    }
}

pengguna kelas {
    gunakan logger;
}

produk kelas {
    gunakan logger;
}

$ user = pengguna baru ();
$ produk = produk baru ();

$ user-> log ("pengguna dibuat"); // [logger] pengguna yang dibuat
$ produk-> log ("produk ditambah"); // [logger] produk ditambah

Walaupun Logger digunakan dalam kelas yang berbeza, __TRAIT__ masih menilai 'Logger' dalam kedua -dua kes. Ia tidak menjadi 'User' atau 'Product' .

Ini berbeza dengan __CLASS__ , yang akan berubah bergantung pada konteks panggilan:

 TRAIT TestContext {
    fungsi awam showclass () {
        Echo "Kelas:". __Class__. "\ n";
    }

    fungsi awam showTtrait () {
        echo "sifat:". __Trait__. "\ n";
    }
}

Contoh kelas {
    Gunakan TestContext;
}

$ e = contoh baru ();
$ e-> showclass (); // Kelas: Contoh
$ e-> showtrait (); // TRAIT: TestContext

Jadi __CLASS__ mencerminkan kelas di mana kaedah dipanggil , tetapi __TRAIT__ mencerminkan sifat di mana ia ditakrifkan - tidak kira di mana ia digunakan.

Mengapa ini penting: debugging dan pembalakan

Tingkah laku yang konsisten __TRAIT__ menjadikannya sangat berguna dalam:

• Pembalakan : Anda boleh mengenal pasti di mana garisan log datang, walaupun ia dikongsi di banyak kelas.
• Pelaporan Ralat : Membuang pengecualian dengan konteks mengenai sifat yang menghasilkan kesilapan.
• Tingkah Laku Dinamik : Melaksanakan Kod Berdasarkan Nama Trait (jarang, tetapi mungkin).

Contohnya:

 Trait Secureaccess {
    fungsi awam checkAccess () {
        jika (! $ this-> currentUserHasAccess ()) {
            membuang baru \ pengecualian ("Akses ditolak dalam sifat:". __trait__);
        }
    }
}

Ini memberikan mesej ralat yang lebih jelas daripada mengodkan nama sifat.

Takeaways utama

• ? __TRAIT__ diselesaikan di dalam sifat , pada masa penyusunan .
• ? Ia selalu mengembalikan nama sifat , tidak pernah kelas menggunakannya.
• ? Ia tidak boleh digunakan di luar sifat - ia tidak ditentukan (menghasilkan kesilapan maut).
• ? Ia tidak berubah berdasarkan konteks kelas - tidak seperti __CLASS__ .

Jadi sementara __CLASS__ adalah kontekstual kepada pemanggil, __TRAIT__ adalah rujukan sendiri dan tetap .

Satu quirk: aliasing dan as

Walaupun anda menamakan semula kaedah melalui use MyTrait::method as myMethod; , __TRAIT__ masih berfungsi sama - kerana badan kaedah tidak berubah.

 sifat apihelper {
    fungsi awam getClient () {
        echo "dari sifat:". __Trait__;
    }
}

Kelas Legacysystem {
    Gunakan apihelper {getClient sebagai getoldClient; }
}

$ obj = Legacysystem baru ();
$ obj-> getoldClient (); // masih cetakan: dari sifat: apihelper

Menamakan semula kaedah tidak menjejaskan konteks dalaman kod sifat.

Singkatnya, __TRAIT__ adalah alat yang kecil tetapi berkuasa yang mengekalkan identitinya di mana ia digunakan. Tingkah lakunya konsisten, boleh diramal, dan sangat terikat dengan definisi sifat sendiri - bukan kelas yang mengamalkannya.

Pada asasnya, ia seperti sifat yang mengatakan: "Tidak kira di mana anda menggunakan saya, saya akan sentiasa tahu siapa saya."

Atas ialah kandungan terperinci Keajaiban kontekstual __trait__: bagaimana ia berkelakuan di dalam kelas. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!