Untuk benar-benar memahami apa yang kita bicarakan ketika kita berbicara tentang selflawan $this, kita harus benar-benar menggali apa yang terjadi pada tingkat konseptual dan praktis. Saya benar-benar tidak merasakan jawaban melakukan hal ini dengan tepat, jadi inilah usaha saya.
Mari kita mulai dengan berbicara tentang apa kelas dan objek itu.
Kelas Dan Objek, Secara Konseptual
Jadi, apa adalah sebuah kelas ? Banyak orang mendefinisikannya sebagai cetak biru atau templat untuk suatu objek. Bahkan, Anda dapat membaca lebih lanjut Tentang Kelas Di PHP Di Sini . Dan sampai batas tertentu itulah sebenarnya. Mari kita lihat sebuah kelas:
class Person {
public $name = 'my name';
public function sayHello() {
echo "Hello";
}
}
Seperti yang Anda tahu, ada properti di kelas yang dipanggil $namedan metode (fungsi) dipanggil sayHello().
Ini sangat penting untuk dicatat bahwa kelas adalah struktur statis. Yang berarti bahwa kelas Person, setelah didefinisikan, selalu sama di mana pun Anda melihatnya.
Objek di sisi lain adalah apa yang disebut turunan Kelas. Artinya adalah bahwa kita mengambil "cetak biru" kelas, dan menggunakannya untuk membuat salinan yang dinamis. Salinan ini sekarang secara khusus terkait dengan variabel tempat penyimpanannya. Oleh karena itu, setiap perubahan pada instance adalah lokal untuk instance tersebut.
$bob = new Person;
$adam = new Person;
$bob->name = 'Bob';
echo $adam->name; // "my name"
Kami membuat instance baru kelas menggunakan newoperator.
Oleh karena itu, kita katakan bahwa Kelas adalah struktur global, dan Obyek adalah struktur lokal. Jangan khawatir tentang ->sintaks lucu itu , kita akan membahasnya sedikit lagi.
Satu hal lain yang harus kita bicarakan, adalah bahwa kita dapat memeriksa apakah instance adalah instanceofkelas tertentu: $bob instanceof Personyang mengembalikan boolean jika $bobinstance dibuat menggunakan Personkelas, atau anak dari Person.
Mendefinisikan Negara
Jadi mari kita gali sedikit ke dalam apa yang sebenarnya mengandung kelas Ada 5 jenis "hal" yang dikandung kelas:
Properti - Pikirkan ini sebagai variabel yang akan berisi setiap instance.
class Foo {
public $bar = 1;
}
Properti Statis - Pikirkan ini sebagai variabel yang dibagikan di tingkat kelas. Berarti mereka tidak pernah disalin oleh setiap contoh.
class Foo {
public static $bar = 1;
}
Metode - Ini adalah fungsi yang masing-masing instance akan berisi (dan beroperasi pada instance).
class Foo {
public function bar() {}
}
Metode Statis - Ini adalah fungsi yang dibagikan di seluruh kelas. Mereka tidak beroperasi pada instance, melainkan pada properti statis saja.
class Foo {
public static function bar() {}
}
Konstanta - Konstanta yang diselesaikan kelas. Tidak masuk lebih dalam di sini, tetapi menambahkan untuk kelengkapan:
class Foo {
const BAR = 1;
}
Jadi pada dasarnya, kami menyimpan informasi pada kelas dan objek kontainer menggunakan "petunjuk" tentang statis yang mengidentifikasi apakah informasi tersebut dibagikan (dan karenanya statis) atau tidak (dan karenanya dinamis).
Negara dan Metode
Di dalam suatu metode, instance objek diwakili oleh $thisvariabel. Keadaan saat objek itu ada di sana, dan bermutasi (mengubah) properti apa pun akan menghasilkan perubahan ke instance itu (tetapi tidak yang lain).
Jika suatu metode disebut secara statis, $thisvariabel tidak didefinisikan . Ini karena tidak ada instance yang terkait dengan panggilan statis.
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 status itu, kita perlu mengaksesnya. Ini bisa menjadi sedikit rumit (atau jauh lebih sedikit), jadi mari kita bagi menjadi dua sudut pandang: dari luar instance / kelas (katakanlah dari pemanggilan fungsi normal, atau dari lingkup global), dan di dalam instance / class (dari dalam metode pada objek).
Dari Luar Instance / Kelas
Dari luar instance / kelas, aturan kami cukup sederhana dan dapat diprediksi. Kami memiliki dua operator, dan masing-masing memberi tahu kami segera jika kami berurusan dengan instance atau static kelas:
->- object-operator - Ini selalu digunakan ketika kita mengakses instance.
$bob = new Person;
echo $bob->name;
Penting untuk dicatat bahwa panggilan Person->footidak masuk akal (karena Personkelas, bukan instance). Oleh karena itu, itu adalah kesalahan parse.
::- scope-resolution-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()
Ini sangat penting untuk dicatat bahwa ketika kita melakukan ini dari luar , misalnya objek tersembunyi dari bar()metode. Artinya sama persis dengan menjalankan:
$class = get_class($foo);
$class::bar();
Karena itu, $thistidak didefinisikan dalam panggilan statis.
Dari Inside Of An Instance / Class
Banyak hal berubah di sini. Operator yang sama digunakan, tetapi artinya menjadi kabur secara signifikan.
Operator objek -> masih digunakan untuk melakukan panggilan ke keadaan instance objek.
class Foo {
public $a = 1;
public function bar() {
return $this->a;
}
}
Memanggil bar()metode pada $foo(turunan dari Foo) menggunakan objek-operator: $foo->bar()akan menghasilkan versi turunan dari $a.
Jadi itulah yang kami harapkan.
Arti ::operator meskipun berubah. Itu tergantung pada konteks panggilan ke fungsi saat ini:
Dalam konteks statis
Dalam konteks statis, semua panggilan yang dibuat ::juga akan statis. Mari kita lihat sebuah contoh:
class Foo {
public function bar() {
return Foo::baz();
}
public function baz() {
return isset($this);
}
}
Memanggil Foo::bar()akan memanggil baz()metode statis, dan karenanya $thisakan tidak diisi. Perlu dicatat bahwa dalam versi PHP terbaru (5.3+) ini akan memicu E_STRICTkesalahan, karena kami memanggil metode non-statis secara statis.
Dalam konteks instance
Di dalam konteks instance di sisi lain, panggilan yang dibuat menggunakan ::tergantung pada penerima panggilan (metode yang kami panggil). Jika metode ini didefinisikan static, maka akan menggunakan panggilan statis. Jika tidak, itu akan meneruskan informasi instan.
Jadi, melihat kode di atas, panggilan $foo->bar()akan kembali true, karena panggilan "statis" terjadi di dalam konteks instance.
Masuk akal? Tidak mengira begitu. Ini membingungkan.
Kata kunci pintas
Karena mengikat semuanya bersama-sama menggunakan nama kelas agak kotor, PHP menyediakan 3 kata kunci "jalan pintas" dasar untuk mempermudah penyelesaian ruang lingkup.
self- Ini merujuk pada nama kelas saat ini. Jadi self::baz()sama dengan Foo::baz()di dalam Fookelas (metode apa pun di atasnya).
parent - Ini merujuk pada induk dari kelas saat ini.
static- Ini mengacu pada kelas yang dipanggil. Berkat warisan, kelas anak dapat menimpa metode dan properti statis. Jadi memanggil mereka menggunakan staticbukan nama kelas memungkinkan kita untuk menyelesaikan dari mana panggilan itu berasal, daripada tingkat saat ini.
Contohnya
Cara termudah untuk memahami ini adalah mulai melihat 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 seluruh instance dan anak-anak (karena kami menggunakan selfuntuk mengaksesnya. Jika kami menggunakannya static, kami bisa menimpanya dalam kelas anak).
var_dump($bob->getName()); // Bob
var_dump($adam->getName()); // Adam
var_dump($billy->getName()); // child: Billy
Perhatikan bahwa kami menjalankan metode Person::getName() instance setiap waktu. Tapi kami menggunakan parent::getName()untuk melakukannya di salah satu kasus (kasus anak). Inilah yang membuat pendekatan ini kuat.
Perhatian # 1
Perhatikan bahwa konteks panggilan adalah yang menentukan apakah 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 benar - benar aneh di sini. Kami memanggil kelas yang berbeda, tetapi $thisyang diteruskan ke Foo::isFoo()metode adalah turunan dari $bar.
Ini dapat menyebabkan semua jenis bug dan WTF-ery konseptual. Jadi saya akan sangat menyarankan menghindari ::operator dari dalam metode instan pada apa pun kecuali yang tiga virtual "short-cut" kata kunci ( static, self, dan parent).
Perhatian # 2
Perhatikan bahwa metode dan properti statis dibagikan oleh semua orang. Itu membuat mereka pada dasarnya variabel global. Dengan semua masalah yang sama dengan global. Jadi saya akan benar-benar ragu untuk menyimpan informasi dalam metode / properti statis kecuali Anda merasa nyaman dengan itu menjadi benar-benar global.
Perhatian # 3
Secara umum, Anda ingin menggunakan apa yang dikenal sebagai Late-Static-Binding dengan menggunakan staticalih-alih self. Tetapi perhatikan bahwa mereka bukan hal yang sama, jadi mengatakan "selalu gunakan staticbukannya selfbenar-benar picik. Sebaliknya, berhenti dan pikirkan tentang panggilan yang ingin Anda buat dan pikirkan jika Anda ingin kelas anak-anak dapat menimpa statis yang diselesaikan panggilan.
TL / DR
Sayang sekali, kembali dan baca. Mungkin terlalu lama, tapi itu lama karena ini adalah topik yang kompleks
TL / DR # 2
Baiklah. Singkatnya, selfdigunakan untuk mereferensikan nama kelas saat ini di dalam kelas, di mana $thismerujuk pada instance objek saat ini . Perhatikan bahwa itu selfadalah jalan pintas salin / tempel. Anda dapat dengan aman menggantinya dengan nama kelas Anda, dan itu akan berfungsi dengan baik. Tetapi $thisadalah variabel dinamis yang tidak dapat ditentukan sebelumnya (dan mungkin bahkan bukan kelas Anda).
TL / DR # 3
Jika objek-operator digunakan ( ->), maka Anda selalu tahu Anda berurusan dengan sebuah instance. Jika 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).