ฉันเห็นตัวแปร$this
ใน PHP ตลอดเวลาและฉันไม่รู้ว่ามันใช้ทำอะไร ส่วนตัวไม่เคยใช้เลย
ใครช่วยบอกฉันหน่อยได้ไหมว่าตัวแปร$this
ทำงานอย่างไรใน PHP
ฉันเห็นตัวแปร$this
ใน PHP ตลอดเวลาและฉันไม่รู้ว่ามันใช้ทำอะไร ส่วนตัวไม่เคยใช้เลย
ใครช่วยบอกฉันหน่อยได้ไหมว่าตัวแปร$this
ทำงานอย่างไรใน PHP
คำตอบ:
เป็นการอ้างอิงถึงออบเจ็กต์ปัจจุบันซึ่งมักใช้ในโค้ดเชิงวัตถุ
ตัวอย่าง:
<?php
class Person {
public $name;
function __construct( $name ) {
$this->name = $name;
}
};
$jack = new Person('Jack');
echo $jack->name;
ซึ่งจะเก็บสตริง "Jack" ไว้เป็นคุณสมบัติของวัตถุที่สร้างขึ้น
$this
ตัวแปรใน PHP คือลองใช้กับล่ามในบริบทต่างๆ:print isset($this); //true, $this exists
print gettype($this); //Object, $this is an object
print is_array($this); //false, $this isn't an array
print get_object_vars($this); //true, $this's variables are an array
print is_object($this); //true, $this is still an object
print get_class($this); //YourProject\YourFile\YourClass
print get_parent_class($this); //YourBundle\YourStuff\YourParentClass
print gettype($this->container); //object
print_r($this); //delicious data dump of $this
print $this->yourvariable //access $this variable with ->
ดังนั้น$this
ตัวแปรหลอกจึงมีเมธอดและคุณสมบัติของวัตถุปัจจุบัน สิ่งนี้มีประโยชน์เพราะช่วยให้คุณเข้าถึงตัวแปรสมาชิกและเมธอดสมาชิกทั้งหมดภายในคลาสได้ ตัวอย่างเช่น:
Class Dog{
public $my_member_variable; //member variable
function normal_method_inside_Dog() { //member method
//Assign data to member variable from inside the member method
$this->my_member_variable = "whatever";
//Get data from member variable from inside the member method.
print $this->my_member_variable;
}
}
$this
อ้างอิงถึง PHP Object
ที่สร้างขึ้นโดยล่ามสำหรับคุณซึ่งมีอาร์เรย์ของตัวแปร
หากคุณเรียกใช้$this
ภายในเมธอดปกติในคลาสปกติให้$this
ส่งคืน Object (คลาส) ที่เมธอดนั้นอยู่
เป็นไปได้$this
ที่จะไม่ได้กำหนดหากบริบทไม่มีวัตถุหลัก
php.net มีเพจขนาดใหญ่ที่พูดถึงการเขียนโปรแกรมเชิงวัตถุ PHP และ$this
ลักษณะการทำงานขึ้นอยู่กับบริบท
https://www.php.net/manual/th/language.oop5.basic.php
ฉันรู้ว่าคำถามเดิมของมันอยู่แล้วอีกคำอธิบายที่แน่นอนเกี่ยวกับ$ นี้ $ นี้ส่วนใหญ่จะใช้เพื่ออ้างอิงคุณสมบัติของคลาส
ตัวอย่าง:
Class A
{
public $myname; //this is a member variable of this class
function callme() {
$myname = 'function variable';
$this->myname = 'Member variable';
echo $myname; //prints function variable
echo $this->myname; //prints member variable
}
}
เอาต์พุต:
function variable
member variable
เป็นวิธีอ้างอิงอินสแตนซ์ของคลาสจากภายในตัวเองเช่นเดียวกับภาษาเชิงวัตถุอื่น ๆ
จากเอกสาร PHP :
ตัวแปรหลอก $ นี้จะพร้อมใช้งานเมื่อมีการเรียกเมธอดจากภายในบริบทวัตถุ $ นี่คือการอ้างอิงถึงอ็อบเจ็กต์การเรียก (โดยปกติจะเป็นอ็อบเจ็กต์ที่เมธอดอยู่ แต่อาจเป็นอ็อบเจ็กต์อื่นหากเมธอดถูกเรียกแบบคงที่จากบริบทของอ็อบเจ็กต์รอง)
มาดูกันว่าจะเกิดอะไรขึ้นถ้าเราไม่ใช้ $ this และพยายามให้มีตัวแปรอินสแตนซ์และอาร์กิวเมนต์ตัวสร้างที่มีชื่อเดียวกันพร้อมกับข้อมูลโค้ดต่อไปนี้
<?php
class Student {
public $name;
function __construct( $name ) {
$name = $name;
}
};
$tom = new Student('Tom');
echo $tom->name;
?>
มันสะท้อนอะไร แต่
<?php
class Student {
public $name;
function __construct( $name ) {
$this->name = $name; // Using 'this' to access the student's name
}
};
$tom = new Student('Tom');
echo $tom->name;
?>
นี่ก้อง 'ทอม'
$this
ในตัวสร้างที่สอง
$name
คือ Tom แต่ภายนอกฟังก์ชันจะไม่มีค่าใด ๆ เนื่องจากขอบเขตของฟังก์ชันถูก จำกัด ไว้ที่ฟังก์ชัน
เมื่อคุณสร้างคลาสคุณมีตัวแปรและวิธีการอินสแตนซ์ (ในหลาย ๆ กรณี) (หรือที่เรียกว่าฟังก์ชัน) $ นี้เข้าถึงตัวแปรอินสแตนซ์เหล่านั้นเพื่อให้ฟังก์ชันของคุณสามารถรับตัวแปรเหล่านั้นและทำสิ่งที่จำเป็นเพื่อทำสิ่งที่คุณต้องการ
ตัวอย่างรุ่นอื่นของ meder:
class Person {
protected $name; //can't be accessed from outside the class
public function __construct($name) {
$this->name = $name;
}
public function getName() {
return $this->name;
}
}
// this line creates an instance of the class Person setting "Jack" as $name.
// __construct() gets executed when you declare it within the class.
$jack = new Person("Jack");
echo $jack->getName();
Output:
Jack
$this
คือการอ้างอิงถึงอ็อบเจ็กต์การเรียก (โดยปกติจะเป็นอ็อบเจ็กต์ที่เมธอดอยู่ แต่อาจเป็นอ็อบเจ็กต์อื่นหากเมธอดถูกเรียกแบบคงที่จากบริบทของอ็อบเจ็กต์รอง)
$ นี้เป็นตัวแปรพิเศษและหมายถึงวัตถุเดียวกันคือ ตัวเอง
มันหมายถึงอินสแตนซ์ของคลาสปัจจุบันจริงๆ
นี่คือตัวอย่างที่จะล้างข้อความข้างต้น
<?php
class Books {
/* Member variables */
var $price;
var $title;
/* Member functions */
function setPrice($par){
$this->price = $par;
}
function getPrice(){
echo $this->price ."<br/>";
}
function setTitle($par){
$this->title = $par;
}
function getTitle(){
echo $this->title ." <br/>";
}
}
?>
นี่คือคำอธิบายโดยละเอียดแบบยาว ฉันหวังว่านี่จะช่วยผู้เริ่มต้น ฉันจะทำให้มันง่ายมาก
ก่อนอื่นมาสร้างคลาส
<?php
class Class1
{
}
คุณสามารถละเว้นแท็กปิด php ได้?>
หากคุณใช้โค้ด php เท่านั้น
Class1
ตอนนี้ขอเพิ่มคุณสมบัติและภายในวิธีการ
<?php
class Class1
{
public $property1 = "I am property 1";
public $property2 = "I am property 2";
public function Method1()
{
return "I am Method 1";
}
}
คุณสมบัติเป็นเพียงตัวแปรง่ายๆ แต่เราให้คุณสมบัติชื่อเพราะมันอยู่ในคลาส
เมธอดเป็นเพียงฟังก์ชันธรรมดา ๆ แต่เราบอกว่าเมธอดเพราะมันอยู่ในคลาสด้วย
public
เฉลี่ยหลักที่วิธีการหรือสถานที่ให้บริการที่สามารถเข้าถึงได้ทุกที่ในสคริปต์
ทีนี้เราจะใช้คุณสมบัติและวิธีการข้างในได้Class1
อย่างไร?
คำตอบคือการสร้างอินสแตนซ์หรืออ็อบเจกต์ให้คิดว่าอ็อบเจกต์เป็นสำเนาของคลาส
<?php
class Class1
{
public $property1 = "I am property 1";
public $property2 = "I am property 2";
public function Method1()
{
return "I am Method 1";
}
}
$object1 = new Class1;
var_dump($object1);
เราสร้างออบเจ็กต์ซึ่งก็คือ$object1
ซึ่งเป็นสำเนาของClass1
เนื้อหาทั้งหมด และเราทิ้งเนื้อหาทั้งหมดของการใช้$object1
var_dump()
สิ่งนี้จะทำให้คุณ
object(Class1)#1 (2) { ["property1"]=> string(15) "I am property 1" ["property2"]=> string(15) "I am property 2" }
ดังนั้นเนื้อหาทั้งหมดจึงClass1
อยู่ใน$object1
ยกเว้นMethod1
ฉันไม่รู้ว่าทำไมวิธีการไม่แสดงในขณะที่ทิ้งวัตถุ
ตอนนี้ถ้าเราต้องการเข้าถึง$property1
เท่านั้น มันง่ายที่เราทำvar_dump($object1->property1);
เราเพิ่งเพิ่ม->property1
เราชี้ไปที่มัน
เรายังสามารถเข้าถึงที่เราทำMethod1()
var_dump($object1->Method1());
ตอนนี้สมมติว่าฉันต้องการเข้าถึง$property1
จากข้างในMethod1()
ฉันจะทำสิ่งนี้
<?php
class Class1
{
public $property1 = "I am property 1";
public $property2 = "I am property 2";
public function Method1()
{
$object2 = new Class1;
return $object2->property1;
}
}
$object1 = new Class1;
var_dump($object1->Method1());
เราสร้างขึ้น$object2 = new Class1;
ซึ่งเป็นสำเนาใหม่Class1
หรือเราสามารถพูดได้ว่าอินสแตนซ์ จากนั้นเราก็ชี้ไปที่property1
จาก$object2
return $object2->property1;
สิ่งนี้จะพิมพ์string(15) "I am property 1"
ในเบราว์เซอร์
ตอนนี้แทนที่จะทำภายใน Method1()
$object2 = new Class1;
return $object2->property1;
เราทำสิ่งนี้
return $this->property1;
$this
วัตถุถูกใช้ในการเรียนการอ้างถึงชั้นเอง
เป็นอีกทางเลือกหนึ่งสำหรับการสร้าง object ใหม่แล้วส่งคืนแบบนี้
$object2 = new Class1;
return $object2->property1;
ตัวอย่างอื่น
<?php
class Class1
{
public $property1 = 119;
public $property2 = 666;
public $result;
public function Method1()
{
$this->result = $this->property1 + $this->property2;
return $this->result;
}
}
$object1 = new Class1;
var_dump($object1->Method1());
เราได้สร้าง 2 $this->result
คุณสมบัติที่มีจำนวนเต็มและแล้วเราได้เพิ่มพวกเขาและนำผลที่ได้ใน
อย่าลืมนะ
$this->property1
= $property1
=119
มีค่าเท่ากัน .. ฯลฯ
ฉันหวังว่าจะอธิบายความคิด
วิดีโอชุดนี้จะช่วยคุณได้มากใน OOP
https://www.youtube.com/playlist?list=PLe30vg_FG4OSEHH6bRF8FrA7wmoAMUZLv
มันหมายถึงตัวอย่างของคลาสปัจจุบันตามที่mederกล่าว
ดูPHP เอกสาร มันอธิบายภายใต้ตัวอย่างแรก