Pertanyaan Kapan menggunakan diri lebih dari $ ini?


Di PHP 5, apa perbedaan antara menggunakan self dan $this?

Kapan masing-masing tepat?


1775
2017-09-30 06:23


asal


Jawaban:


Jawaban singkat

Menggunakan $this untuk merujuk ke arus   obyek. Menggunakan self untuk merujuk pada   kelas saat ini. Dengan kata lain, gunakan    $this->member untuk anggota non-statis,   menggunakan self::$member untuk anggota statis.

Jawaban Lengkap

Berikut ini contohnya benar penggunaan $this dan self untuk variabel anggota non-statis dan statis:

<?php
class X {
    private $non_static_member = 1;
    private static $static_member = 2;

    function __construct() {
        echo $this->non_static_member . ' '
           . self::$static_member;
    }
}

new X();
?>

Berikut ini contohnya salah penggunaan $this dan self untuk variabel anggota non-statis dan statis:

<?php
class X {
    private $non_static_member = 1;
    private static $static_member = 2;

    function __construct() {
        echo self::$non_static_member . ' '
           . $this->static_member;
    }
}

new X();
?>

Berikut ini contohnya polimorfisme dengan $this untuk fungsi anggota:

<?php
class X {
    function foo() {
        echo 'X::foo()';
    }

    function bar() {
        $this->foo();
    }
}

class Y extends X {
    function foo() {
        echo 'Y::foo()';
    }
}

$x = new Y();
$x->bar();
?>

Berikut ini contohnya menekan perilaku polimorfik dengan menggunakan self untuk fungsi anggota:

<?php
class X {
    function foo() {
        echo 'X::foo()';
    }

    function bar() {
        self::foo();
    }
}

class Y extends X {
    function foo() {
        echo 'Y::foo()';
    }
}

$x = new Y();
$x->bar();
?>

Idenya adalah itu $this->foo() memanggil foo() fungsi anggota apa pun> adalah jenis yang tepat dari objek saat ini. Jika objeknya adalah type X, demikian> panggilan X::foo(). Jika objeknya adalah type Y, panggilannya Y::foo(). Tetapi dengan> self :: foo (), X::foo() selalu disebut.

Dari http://www.phpbuilder.com/board/showthread.php?t=10354489:

Oleh http://board.phpbuilder.com/member.php?145249-laserlight


1508
2017-09-30 06:29



Kata kunci sendiri TIDAK hanya merujuk ke 'kelas saat ini', setidaknya tidak dengan cara yang membatasi Anda untuk anggota statis. Dalam konteks anggota non-statis, self juga menyediakan cara melewati vtable (lihat wiki di vtable) untuk objek saat ini. Sama seperti yang bisa Anda gunakan parent::methodName() untuk memanggil versi orang tua dari suatu fungsi, sehingga Anda dapat menelepon self::methodName() untuk memanggil implementasi kelas saat ini dari suatu metode.

class Person {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }

    public function getTitle() {
        return $this->getName()." the person";
    }

    public function sayHello() {
        echo "Hello, I'm ".$this->getTitle()."<br/>";
    }

    public function sayGoodbye() {
        echo "Goodbye from ".self::getTitle()."<br/>";
    }
}

class Geek extends Person {
    public function __construct($name) {
        parent::__construct($name);
    }

    public function getTitle() {
        return $this->getName()." the geek";
    }
}

$geekObj = new Geek("Ludwig");
$geekObj->sayHello();
$geekObj->sayGoodbye();

Ini akan menampilkan:

Halo, saya Ludwig si geek
     Selamat tinggal dari Ludwig orangnya

sayHello() menggunakan $this pointer, sehingga vtabel dipanggil untuk memanggil Geek::getTitle(). sayGoodbye() menggunakan self::getTitle(), jadi vtable tidak digunakan, dan Person::getTitle() disebut. Dalam kedua kasus, kita berurusan dengan metode objek instantiated, dan memiliki akses ke $this pointer dalam fungsi yang disebut.


710
2017-07-27 18:00



JANGAN GUNAKAN self::, gunakan static::

Ada aspek lain dari diri :: yang perlu disebutkan. Mengganggu self:: mengacu pada ruang lingkup pada titik definisi tidak pada titik eksekusi. Pertimbangkan kelas sederhana ini dengan dua metode:

class Person
{

    public static function status()
    {
        self::getStatus();
    }

    protected static function getStatus()
    {
        echo "Person is alive";
    }

}

Jika kita memanggil Person::status() kita akan melihat "Orang itu hidup". Sekarang perhatikan apa yang terjadi ketika kita membuat kelas yang mewarisi dari ini:

class Deceased extends Person
{

    protected static function getStatus()
    {
        echo "Person is deceased";
    }

}

Panggilan Deceased::status() kami berharap untuk melihat "Orang sudah meninggal" namun apa yang kami lihat adalah "Orang itu hidup" karena ruang lingkup berisi definisi metode asli saat panggilan ke self::getStatus() didefinisikan.

PHP 5.3 memiliki solusi. itu static:: Operator resolusi mengimplementasikan "late static binding" yang merupakan cara mewah untuk mengatakan bahwa itu terikat pada ruang lingkup kelas yang disebut. Ubah baris di status() untuk static::getStatus() dan hasilnya adalah apa yang Anda harapkan. Dalam versi PHP yang lebih lama Anda harus menemukan kludge untuk melakukan ini.

Lihat Dokumentasi PHP

Jadi untuk menjawab pertanyaan tidak seperti yang diminta ...

$this-> mengacu pada objek saat ini (sebuah instance dari kelas), sedangkan static::mengacu pada kelas


428
2017-07-24 15:08



Untuk benar-benar memahami apa yang kita bicarakan ketika kita berbicara tentang self melawan $this, kita harus benar-benar menggali apa yang terjadi pada level konseptual dan praktis. Saya tidak benar-benar merasakan jawaban yang tepat, jadi inilah usaha saya.

Mari kita mulai dengan membicarakan tentang apa a kelas dan sebuah obyek aku s.

Kelas Dan Benda, Secara Konseptual

Terus aku s Sebuah kelas? Banyak orang mendefinisikannya sebagai cetak biru atau a template untuk sebuah objek. Bahkan, Anda bisa membaca lebih lanjut Tentang Kelas Di PHP Di Sini. Dan sampai taraf tertentu itulah yang sebenarnya. Mari kita lihat kelas:

class Person {
    public $name = 'my name';
    public function sayHello() {
        echo "Hello";
    }
}

Seperti yang Anda ketahui, ada properti di kelas yang disebut $name dan metode (fungsi) yang disebut sayHello().

Nya sangat penting untuk dicatat bahwa kelas adalah struktur statis. Yang artinya kelas Person, begitu didefinisikan, selalu sama di mana pun Anda melihatnya.

Objek di sisi lain adalah apa yang disebut contoh dari Kelas. Maksudnya adalah kita mengambil "cetak biru" kelas, dan menggunakannya untuk membuat salinan yang dinamis. Salinan ini sekarang secara khusus terkait dengan variabel yang disimpan di dalamnya. Oleh karena itu, setiap perubahan pada suatu contoh bersifat lokal untuk contoh itu.

$bob = new Person;
$adam = new Person;
$bob->name = 'Bob';
echo $adam->name; // "my name"

Kami menciptakan baru contoh kelas menggunakan new operator.

Oleh karena itu, kami mengatakan bahwa Kelas adalah struktur global, dan Objek adalah struktur lokal. Jangan khawatir tentang itu lucu -> sintaks, kita akan membahasnya sedikit.

Satu hal lain yang harus kita bicarakan, adalah kita bisa memeriksa jika sebuah instance adalah sebuah instanceof kelas khusus: $bob instanceof Person yang mengembalikan boolean jika $bob contoh dibuat menggunakan Person kelas, atau seorang anak dari Person.

Menentukan Negara

Jadi, mari kita gali sedikit tentang apa yang sebenarnya ada dalam kelas. Ada 5 jenis "hal" yang berisi kelas:

  1. Properties - Anggap ini sebagai variabel yang akan dikandung oleh setiap instance.

    class Foo {
        public $bar = 1;
    }
    
  2. Properti Statis - Anggap ini sebagai variabel yang dibagikan di tingkat kelas. Berarti bahwa mereka tidak pernah disalin oleh setiap contoh.

    class Foo {
        public static $bar = 1;
    }
    
  3. Metode - Ini adalah fungsi yang setiap instance akan berisi (dan beroperasi pada instance).

    class Foo {
        public function bar() {}
    }
    
  4. Metode Statis - Ini adalah fungsi yang dibagikan di seluruh kelas. Mereka melakukannya tidak beroperasi pada instance, tetapi hanya pada properti statis.

    class Foo {
        public static function bar() {}
    }
    
  5. Konstanta - Konstanta Kelas diselesaikan. Tidak akan masuk lebih dalam di sini, tetapi menambahkan kelengkapan:

    class Foo {
        const BAR = 1;
    }
    

Jadi pada dasarnya, kami menyimpan informasi tentang wadah kelas dan objek menggunakan "petunjuk" tentang statis yang mengidentifikasi apakah informasi dibagi (dan karenanya statis) atau tidak (dan karenanya dinamis).

Negara dan Metode

Di dalam suatu metode, instance objek diwakili oleh $thisvariabel. Keadaan objek saat ini ada di sana, dan bermutasi (mengubah) properti apa pun akan menghasilkan perubahan pada instance tersebut (tetapi tidak yang lain).

Jika suatu metode disebut secara statis, maka $this variabel tak terdefinisi. Ini karena tidak ada contoh terkait dengan panggilan statis.

Hal yang menarik di sini adalah bagaimana panggilan statis dibuat. Jadi mari kita bicara tentang bagaimana kita mengakses negara:

Mengakses Negara

Jadi sekarang kita telah menyimpan keadaan itu, kita perlu mengaksesnya. Ini bisa agak rumit (atau cara lebih dari sedikit), jadi mari kita membagi ini menjadi dua sudut pandang: dari luar sebuah instance / kelas (katakanlah dari panggilan fungsi normal, atau dari lingkup global), dan di dalam sebuah instance / kelas (dari dalam suatu metode pada obyek).

Dari Luar Instance / Kelas

Dari luar sebuah instance / kelas, aturan kami cukup sederhana dan dapat diprediksi. Kami memiliki dua operator, dan masing-masing memberitahu kami segera jika kita berurusan dengan instance atau kelas statis:

  • -> - operator-objek - Ini selalu digunakan saat kami mengakses instance.

    $bob = new Person;
    echo $bob->name;
    

    Penting untuk memperhatikan panggilan itu Person->foo tidak masuk akal (sejak Person adalah kelas, bukan instance). Oleh karena itu, itu adalah kesalahan parse.

  • :: - lingkup-resolusi-operator - Ini selalu digunakan untuk mengakses properti atau metode statis Class.

    echo Foo::bar()
    

    Selain itu, kita dapat memanggil metode statis pada objek dengan cara yang sama:

    echo $foo::bar()
    

    Nya sangat Penting untuk dicatat bahwa ketika kita melakukan ini dari luar, Instance objek disembunyikan dari bar() metode. Artinya sama persis dengan menjalankan:

    $class = get_class($foo);
    $class::bar();
    

Karena itu, $this tidak didefinisikan dalam panggilan statis.

Dari Inside Of An Instance / Kelas

Segalanya berubah sedikit di sini. Operator yang sama digunakan, tetapi maknanya menjadi sangat kabur.

Itu operator-objek  -> masih digunakan untuk melakukan panggilan ke status instance objek.

class Foo {
    public $a = 1;
    public function bar() {
        return $this->a;
    }
}

Memanggil bar() metode aktif $foo (sebuah contoh dari Foo) menggunakan operator-objek: $foo->bar() akan menghasilkan versi instance dari $a.

Jadi itulah yang kami harapkan.

Arti dari :: operator meskipun ada perubahan. Itu tergantung pada konteks panggilan ke fungsi saat ini:

  • Dalam konteks statis

    Dalam konteks statis, panggilan apa pun yang dilakukan menggunakan :: juga akan statis. Mari kita lihat sebuah contoh:

    class Foo {
        public function bar() {
            return Foo::baz();
        }
        public function baz() {
            return isset($this);
        }
    }
    

    Panggilan Foo::bar() akan memanggil baz() metode statis, dan karenanya $this akan tidak diisi. Perlu dicatat bahwa dalam versi terbaru PHP (5.3+) ini akan memicu E_STRICT kesalahan, karena kami memanggil metode non-statis secara statis.

  • Dalam konteks instan

    Dalam konteks contoh di sisi lain, panggilan dibuat menggunakan :: tergantung pada penerima panggilan (metode yang kita panggil). Jika metode didefinisikan sebagai static, maka itu akan menggunakan panggilan statis. Jika tidak, itu akan meneruskan informasi instan.

    Jadi, melihat kode di atas, menelepon $foo->bar() akan kembali true, karena panggilan "statis" terjadi di dalam konteks instance.

Masuk akal? Tidak berpikir begitu. Ini membingungkan.

Kata Kunci Short-Cut

Karena mengikat semuanya bersama-sama menggunakan nama kelas agak kotor, PHP menyediakan 3 kata kunci "pintas" dasar untuk membuat ruang lingkup menyelesaikan lebih mudah.

  • self - Ini mengacu pada nama kelas saat ini. Begitu self::baz() sama dengan Foo::baz() dalam Foo kelas (metode apa pun di atasnya).

  • parent - Ini mengacu pada induk kelas saat ini.

  • static - Ini mengacu pada kelas yang disebut. Berkat pewarisan, kelas anak dapat mengganti metode dan properti statis. Jadi memanggil mereka menggunakan static bukannya nama kelas memungkinkan kita untuk menyelesaikan dari mana panggilan itu berasal, daripada level saat ini.

Contoh

Cara termudah untuk memahami ini adalah dengan mulai mencari beberapa contoh. Mari pilih kelas:

class Person {
    public static $number = 0;
    public $id = 0;
    public function __construct() {
        self::$number++;
        $this->id = self::$number;
    }
    public $name = "";
    public function getName() {
        return $this->name;
    }
    public function getId() {
        return $this->id;
    }
}

class Child extends Person {
    public $age = 0;
    public function __construct($age) {
        $this->age = $age;
        parent::__construct();
    }
    public function getName() {
        return 'child: ' . parent::getName();
    }
}

Sekarang, kami juga melihat warisan di sini. Abaikan sejenak bahwa ini adalah model objek yang buruk, tetapi mari kita lihat apa yang terjadi ketika kita bermain dengan ini:

$bob = new Person;
$bob->name = "Bob";
$adam = new Person;
$adam->name = "Adam";
$billy = new Child;
$billy->name = "Billy";
var_dump($bob->getId()); // 1
var_dump($adam->getId()); // 2
var_dump($billy->getId()); // 3

Jadi penghitung ID dibagikan di kedua instance dan anak-anak (karena kami menggunakan self untuk mengaksesnya. Jika kami menggunakan static, kita bisa menimpanya di kelas anak-anak).

var_dump($bob->getName()); // Bob
var_dump($adam->getName()); // Adam
var_dump($billy->getName()); // child: Billy

Perhatikan bahwa kami sedang mengeksekusi Person::getName()  contoh metode setiap saat. Tapi kami menggunakan parent::getName() untuk melakukannya di salah satu kasus (kasus anak). Inilah yang membuat pendekatan ini kuat.

Firman Perhatian # 1

Perhatikan bahwa konteks panggilan adalah yang menentukan apakah suatu instance digunakan. Karena itu:

class Foo {
    public function isFoo() {
        return $this instanceof Foo;
    }
}

Tidak selalu benar.

class Bar {
    public function doSomething() {
        return Foo::isFoo();
    }
}
$b = new Bar;
var_dump($b->doSomething()); // bool(false)

Sekarang ini sangat aneh di sini. Kami memanggil kelas yang berbeda, tetapi $this yang diteruskan ke Foo::isFoo() metode adalah contoh dari $bar.

Ini dapat menyebabkan berbagai bug dan konseptual WTF-ery. Jadi saya sangat menyarankan menghindari :: operator dari dalam metode instance pada apa pun kecuali tiga kata kunci "pintas" virtual tersebut (static, self, dan parent).

Kata-kata peringatan # 2

Perhatikan bahwa metode dan properti statis dibagikan oleh semua orang. Itu membuat mereka pada dasarnya adalah variabel global. Dengan semua masalah yang sama dengan global. Jadi saya akan benar-benar ragu-ragu untuk menyimpan informasi dalam metode / properti statis kecuali Anda merasa nyaman dengan itu menjadi benar-benar global.

Firman Perhatian # 3

Secara umum Anda akan ingin menggunakan apa yang dikenal sebagai Late-Static-Binding dengan menggunakan static dari pada self. Tetapi perhatikan bahwa mereka bukan hal yang sama, sehingga mengatakan "selalu digunakan static dari pada self benar-benar cupet. Sebaliknya, berhenti dan pikirkan panggilan yang ingin Anda buat dan pikirkan jika Anda ingin kelas anak dapat mengesampingkan itu statis diselesaikan panggilan.

TL / DR

Sayang sekali, kembalilah dan bacalah. Mungkin terlalu lama, tapi itu lama karena ini adalah topik yang kompleks

TL / DR # 2

Baiklah. Pendeknya, self digunakan untuk referensi nama kelas saat inidalam suatu kelas, dimana $this mengacu pada objek saat ini contoh. Perhatikan itu self adalah potongan / tempel pintas. Anda dapat menggantinya dengan aman dengan nama kelas Anda, dan itu akan berfungsi dengan baik. Tapi $this adalah variabel dinamis yang tidak dapat ditentukan sebelumnya (dan bahkan mungkin bukan kelas Anda).

TL / DR # 3

Jika operator objek digunakan (->), maka kamu selalu tahu Anda sedang berhadapan dengan sebuah instance. Jika ruang lingkup-resolusi-operator digunakan (::), Anda memerlukan informasi lebih lanjut tentang konteksnya (apakah kita sudah berada dalam konteks-objek? Apakah kita berada di luar objek? dll).


228
2018-06-10 15:21



self (bukan $ self) mengacu pada mengetik kelas, dimana $this mengacu pada arus contoh kelas. self adalah untuk digunakan dalam fungsi anggota statis untuk memungkinkan Anda mengakses variabel anggota statis. $this digunakan dalam fungsi anggota non-statis, dan merupakan referensi ke instance kelas tempat fungsi anggota dipanggil.

Karena this adalah objek, Anda menggunakannya seperti: $this->member

Karena self bukan objek, itu pada dasarnya adalah tipe yang secara otomatis mengacu pada kelas saat ini, Anda menggunakannya seperti: self::member


109
2017-09-30 07:26



$this-> digunakan untuk merujuk ke contoh spesifik dari variabel kelas (variabel anggota) atau metode.

Example: 
$derek = new Person();

$ derek sekarang adalah contoh spesifik dari Orang. Setiap Orang memiliki first_name dan last_name, tetapi $ derek memiliki first_name dan last_name spesifik (Derek Martin). Di dalam instance $ derek, kita dapat merujuk pada $ this-> first_name dan $ this-> last_name

ClassName :: digunakan untuk merujuk ke jenis kelas, dan variabel statisnya, metode statis. Jika itu membantu, Anda dapat mengganti kata "statis" dengan "berbagi" secara mental. Karena mereka dibagikan, mereka tidak dapat merujuk ke $ this, yang mengacu pada contoh spesifik (tidak dibagikan). Variabel Statis (yaitu $ db_connection statis) dapat dibagi di antara semua instance jenis objek. Sebagai contoh, semua objek database berbagi koneksi tunggal (koneksi $ statis).

Variabel Statis Contoh: Anggaplah kita memiliki kelas basis data dengan variabel anggota tunggal: statis $ num_connections; Sekarang, taruh ini di konstruktor:

function __construct()
{
    if(!isset $num_connections || $num_connections==null)
    {
        $num_connections=0;
    }
    else
    {
        $num_connections++;
    }
}

Sama seperti objek memiliki konstruktor, mereka juga memiliki destruktor, yang dieksekusi ketika objek mati atau tidak disetel:

function __destruct()
{
    $num_connections--;
}

Setiap kali kita membuat instance baru, itu akan meningkatkan penghitung koneksi kita satu per satu. Setiap kali kita menghancurkan atau berhenti menggunakan instance, itu akan mengurangi penghitung koneksi satu per satu. Dengan cara ini, kita dapat memantau jumlah instance dari objek database yang telah kita gunakan dengan:

echo DB::num_connections;

Karena $ num_connections bersifat statis (bersama), ini akan mencerminkan jumlah objek database aktif. Anda mungkin telah melihat teknik ini digunakan untuk membagi koneksi database di antara semua instance kelas database. Ini dilakukan karena membuat koneksi database memakan waktu lama, jadi sebaiknya buat hanya satu, dan bagikan (ini disebut Pola Singleton).

Metode Statis (mis. Public static View :: format_phone_number ($ digit)) dapat digunakan TANPA pertama instantiating salah satu dari objek tersebut (mis. Mereka tidak secara internal merujuk ke $ this).

Contoh Metode Statis:

public static function prettyName($first_name, $last_name)
{
    echo ucfirst($first_name).' '.ucfirst($last_name);
}

echo Person::prettyName($derek->first_name, $derek->last_name);

Seperti yang Anda lihat, public static function prettyName tidak tahu apa-apa tentang objek. Ini hanya bekerja dengan parameter yang Anda berikan, seperti fungsi normal yang bukan bagian dari objek. Lalu mengapa repot-repot, jika kita bisa memilikinya bukan sebagai bagian dari objek?

  1. Pertama, melampirkan fungsi ke objek membantu Anda mengatur semua hal, jadi Anda tahu di mana menemukannya.
  2. Kedua, mencegah penamaan konflik. Dalam proyek besar, Anda cenderung memiliki dua pengembang membuat fungsi getName (). Jika seseorang membuat ClassName1 :: getName (), dan yang lainnya membuat ClassName2 :: getName (), itu tidak masalah sama sekali. Tidak ada konflik. Yay metode statis!

DIRI:: Jika Anda coding di luar objek yang memiliki metode statis yang ingin Anda rujuk, Anda harus menyebutnya menggunakan nama objek Lihat :: format_phone_number ($ phone_number); Jika Anda coding dalam objek yang memiliki metode statis yang ingin Anda rujuk, Anda bisa antara gunakan nama objek Lihat :: format_phone_number ($ pn), ATAU Anda dapat menggunakan self :: format_phone_number ($ pn) shortcut

Hal yang sama berlaku untuk variabel statis: Contoh: Lihat :: templates_path versus self :: templates_path

Di dalam kelas DB, jika kita mengacu pada metode statis dari beberapa objek lain, kita akan menggunakan nama objek: Contoh: Sesi :: getUsersOnline ();

Tetapi jika kelas DB ingin merujuk ke variabel statisnya sendiri, itu hanya akan mengatakan diri: Contoh: self :: koneksi;

Harapan yang membantu memperjelas semuanya :)


93
2017-10-22 17:52



Dari posting blog ini:

  • self mengacu pada kelas saat ini
  • self dapat digunakan untuk memanggil fungsi statis dan mereferensikan variabel anggota statis
  • self dapat digunakan di dalam fungsi statis
  • self juga dapat mematikan perilaku polimorfik dengan melewati vtable
  • $this mengacu pada objek saat ini
  • $this dapat digunakan untuk memanggil fungsi statis
  • $this tidak boleh digunakan untuk memanggil variabel anggota statis. Menggunakan self sebagai gantinya.
  • $this tidak dapat digunakan di dalam fungsi statis

27
2018-05-10 12:00



Di PHP, Anda menggunakan kata kunci sendiri untuk mengakses properti dan metode statis.

Masalahnya adalah Anda dapat mengganti $this->method() dengan self::method()di mana saja, tidak peduli method() dinyatakan statis atau tidak. Jadi yang mana yang harus kamu gunakan?

Pertimbangkan kode ini:

class ParentClass {
    function test() {
        self::who();    // will output 'parent'
        $this->who();   // will output 'child'
    }

    function who() {
        echo 'parent';
    }
}

class ChildClass extends ParentClass {
    function who() {
        echo 'child';
    }
}

$obj = new ChildClass();
$obj->test();

Dalam contoh ini, self::who() akan selalu menghasilkan ‘induk’, sementara $this->who() akan tergantung pada kelas apa yang dimiliki objek.

Sekarang kita dapat melihat bahwa diri mengacu pada kelas yang disebut, sementara $this mengacu kepada kelas objek saat ini.

Jadi, Anda harus menggunakan diri sendiri kapan $this tidak tersedia, atau ketika Anda tidak ingin mengizinkan kelas turunan untuk menimpa metode saat ini.


23
2017-12-29 13:20



Di dalam definisi kelas, $ ini mengacu pada objek saat ini, sementara diri mengacu pada kelas saat ini.

Anda perlu mengacu pada elemen kelas yang menggunakan diri, dan merujuk ke elemen objek menggunakan $ this.

self::STAT // refer to a constant value
self::$stat // static variable
$this->stat // refer to an object variable  

19
2018-05-08 06:58