Vіdchuzheniy php p คงที่ สมาชิกคลาสแบบคงที่ อย่าปล่อยให้พวกเขายุ่งกับรหัสของคุณ ใครชอบวิธีการแบบคงที่

Reg.ru: โดเมนและโฮสติ้ง

นายทะเบียนและผู้ให้บริการโฮสติ้งที่ใหญ่ที่สุดในรัสเซีย

มีชื่อโดเมนมากกว่า 2 ล้านชื่อที่ให้บริการ

การจัดส่ง จดหมายสำหรับโดเมน โซลูชันสำหรับธุรกิจ

กว่า 700,000 ลูกค้าทั่วโลกได้ตัดสินใจเลือกแล้ว

*เลื่อนเคอร์เซอร์ของเมาส์เพื่อเลื่อน

กลับไปข้างหน้า

วิธีการคงที่และพลังงานใน PHP

ในเอกสารก่อนหน้านี้ เราได้เข้าใจความสามารถพื้นฐานของการเขียนโปรแกรมเชิงวัตถุใน PHP แล้ว และตอนนี้ได้ก้าวไปสู่การเรียนรู้แง่มุมที่ซับซ้อนและซับซ้อนมากขึ้น

ก่อนหน้านั้นเรามักจะทำงานกับวัตถุเสมอ เรากำหนดลักษณะคลาสเป็นเทมเพลตที่ใช้สร้างอ็อบเจ็กต์ และอ็อบเจ็กต์เป็นส่วนประกอบที่ใช้งานอยู่ซึ่งเราเรียกใช้และหน่วยงานที่ปฏิเสธการเข้าถึง

ติดดาวในการเขียนโปรแกรมเชิงวัตถุ หุ่นยนต์จริงลงทะเบียนเพื่อรับอินสแตนซ์เพิ่มเติมของชั้นเรียน และเมื่อพร้อมแล้วก็เป็นเพียงเทมเพลตสำหรับสร้างวัตถุ

มันไม่ง่ายอย่างนั้นจริงๆ เราสามารถปฏิเสธการเข้าถึงทั้งวิธีการและสิทธิ์จากคลาสเหล่านี้ ไม่ใช่ออบเจ็กต์ วิธีการดังกล่าวเรียกว่า "คงที่" โดยเจ้าหน้าที่และได้รับการร้องขอความช่วยเหลือ คำสำคัญ คงที่.

คลาส StaticExample ( static public $aNum = 0; static public function sayHello() ( print "Hello!"; ) )

วิธีการคงที่- ฟังก์ชั่นเหล่านี้คล้ายคลึงกับบริบทของคลาส พวกเขาเองไม่สามารถปฏิเสธการเข้าถึงพลังหลักใดๆ ของชั้นเรียนได้ เนื่องจากพลังดังกล่าวเป็นของวัตถุ

อย่างไรก็ตาม จากวิธีการคงที่ ดังที่คุณเดาได้อย่างไพเราะแล้ว คุณสามารถพัฒนาเป็นพลังคงที่ได้ หากคุณเปลี่ยนสิทธิ์แบบคงที่ อินสแตนซ์ทั้งหมดของคลาสสามารถปฏิเสธการเข้าถึงค่าใหม่ได้

เนื่องจากการเข้าถึงองค์ประกอบคงที่ทำได้ผ่านคลาส และหากไม่ได้ผ่านอินสแตนซ์ของออบเจ็กต์ เราไม่จำเป็นต้องมีการเปลี่ยนแปลงที่ส่งไปยังออบเจ็กต์ ซึ่งระบุด้วยชื่อของคลาส หลังจากนั้นจึงระบุกล่องคู่สองกล่อง “::”

พิมพ์ StaticExample::$aNum; ตัวอย่างคงที่::sayHello();

ด้วยไวยากรณ์นี้ คุณจะคุ้นเคยกับพื้นฐานของ OOP ใน PHP อยู่แล้ว เราปรับปรุงการก่อสร้าง "::" ร่วมกับคำหลัก พ่อแม่เพื่อปฏิเสธการเข้าถึงชั้นเรียนของพ่อที่ได้รับมอบหมายใหม่ให้กับวิธีการ

ในเวลาเดียวกัน เราถูกลดระดับลงเป็นคลาส ไม่ใช่ข้อมูลที่อยู่ในออบเจ็กต์ คุณสามารถปรับแต่งคีย์เวิร์ดในคลาสโค้ดได้ พ่อแม่เพื่อปฏิเสธการเข้าถึงซูเปอร์คลาส ไม่ใช่คลาส vikorist

หากต้องการปฏิเสธการเข้าถึงวิธีการแบบคงที่หรือพลังงานจากคลาสเดียวกันนั้น (และไม่ใช่จากคลาสลูก) เราจะใช้คำสำคัญ ตัวเอง.

คำสำคัญ ตัวเอง vikoristovuetsya สำหรับการซูมไปสู่ระดับการผลิตและการเปลี่ยนแปลงหลอก $นี่- เข้าสู่สายการผลิต เพราะเป็นอินเตอร์คลาส ตัวอย่างแบบคงที่เราถูกทารุณกรรมจนขมขื่น $aหมายเลขเพื่อขอความช่วยเหลือในนามของชั้นเรียนของฉัน

ตัวอย่างคงที่::$aNum;

และในช่วงกลางของชั้นเรียน ตัวอย่างแบบคงที่คุณสามารถวิกิรายการคำหลักได้ ตัวเอง.

คลาส StaticExample ( static public $aNum = 0; static public function sayHello() ( self::$aNum++; print "Hello! (" . self::$aNum . ")\n"; ) )

คืนความเคารพ:นอกเหนือจากการที่สัตว์ร้ายหลุดออกไปด้วยวิธีที่ได้รับมอบหมายใหม่ของคลาสปิตุภูมิแล้ว การสร้าง "::" ยังมักถูกนำไปใช้ในทางที่ผิดเสมอสำหรับการเข้าถึงวิธีการและอำนาจแบบคงที่

ตามที่กำหนดไว้ วิธีการคงที่จะไม่ถูกเรียกใช้บนอ็อบเจ็กต์ ด้วยเหตุผลเหล่านี้ วิธีการแบบคงที่และกำลังจึงมักเรียกว่ากำลังแบบเปลี่ยนแปลงได้และกำลังแบบคลาส ตามความเป็นจริง เป็นไปไม่ได้ที่จะกระตุ้นการเปลี่ยนแปลงหลอก $นี่อยู่ตรงกลางของวิธีแบบคงที่

อะไรคือความแตกต่างระหว่างวิธีคงที่และกำลัง?

ตอนนี้เรามาถึงอาหารที่สำคัญที่สุดแล้ว ทางด้านขวาคือองค์ประกอบคงที่ซึ่งแสดงคุณลักษณะที่แตกต่างกันหลายประการ

ตามคำกล่าวของเพอร์ชีซึ่งพร้อมใช้งานจากจุดใดก็ได้ในสถานการณ์ (หากคุณมีสิทธิ์เข้าถึงชั้นเรียน) ซึ่งหมายความว่าคุณสามารถขยายขนาดเป็นฟังก์ชันได้โดยไม่ต้องส่งอินสแตนซ์ของคลาสจากวัตถุหนึ่งไปยังอีกวัตถุหนึ่ง หรือที่แย่กว่านั้นคือการจัดเก็บอินสแตนซ์ของวัตถุในการเปลี่ยนแปลงทั่วโลก

ในลักษณะที่แตกต่างออกไปพลังงานคงที่มีให้สำหรับอินสแตนซ์สกินของอ็อบเจ็กต์คลาสนี้ ดังนั้นคุณจึงสามารถกำหนดค่าที่อาจมีให้กับออบเจ็กต์ประเภทนี้ทั้งหมดได้

และตัวอย่างเช่น ในสามความจริงก็คือคลาสไม่จำเป็นต้องมีอินสแตนซ์เพื่อเข้าถึงพลังงานหรือวิธีการแบบคงที่ ทำให้สามารถสร้างอินสแตนซ์อ็อบเจ็กต์ได้ รวมถึงการเรียกใช้ฟังก์ชันง่ายๆ

เพื่อสาธิต เรามาสร้างวิธีการคงที่สำหรับชั้นเรียนกัน ร้านค้าสินค้าซึ่งจะสร้างอินสแตนซ์ของออบเจ็กต์โดยอัตโนมัติ ร้านค้าสินค้า- สำหรับความช่วยเหลือเพิ่มเติมตาราง SQLiteสินค้า

ก้าวไปสู่อันดับ:

สร้างผลิตภัณฑ์ตาราง (ID INTEGER PRIMARY KEY AUTOINCREMENT, พิมพ์ TEXT, TEXT ที่ 1, ชื่อหลัก TEXT, TEXT ชื่อ, ราคาลอยตัว, numpages int, playlength int, int ส่วนลด) ตอนนี้เรามาสร้างวิธีการกันรับอินสแตนซ์() ร้านค้าสินค้าแล้วพลิกไปที่โปรแกรมแล้วคลิก

เราสามารถเพิ่มวิธีการเหล่านี้ในชั้นเรียนได้ ร้านค้าสินค้า, เรามีการสร้างสรรค์แบบไหนจากวัสดุในยุคแรกๆ ดังที่คุณทราบ PDO ย่อมาจาก PHP Data Object ข้อมูลพีเอชพี- คลาส PDO มีอินเทอร์เฟซสากลสำหรับส่วนเสริมต่างๆ

ฐานข้อมูล

// Class ShopProduct ส่วนตัว $id=0; ฟังก์ชั่นสาธารณะ setID($id) ( $this->id = $id; ) // ... ฟังก์ชั่นสาธารณะคงที่ getInstance($id, PDO $pdo) ( $stmt = $pdo->prepare("select * from products โดยที่ id=?"); $result = $stmt->execute(array($id)); $row = $stmt->fetch(); if (empty($row)) ( return null; ) if ($ แถว["type"] == "หนังสือ") ( $product = new BookProduct($row["title"], $row["firstname"], $row["mainname"], $row["price"] , $row["numpages"] ) else if ($row["type"] == "cd") ( $product = new CdProduct($row["title"], $row["firstname"], $row ["mainname"], $row["price"], $row["playlength"] ) else ( $product = new ShopProduct($row["title"], $row["firstname"], $row[" mainname"], $row["price"]); $product->setId($row["id"]); $product->setDiscount($row["discount"]); product;) // .. . ตอนนี้เรามาสร้างวิธีการกันแยกบาไคท์วิธีการ ร้านค้าสินค้าหมุนวัตถุเพื่อพิมพ์ และก็ “สมเหตุสมผล” พอที่จะมีค่าฟิลด์ไว้บนขาตั้งพิมพ์

สร้างวัตถุที่มีคุณสมบัติที่จำเป็น

ฉันจงใจละเว้นรหัสสำหรับการประมวลผลการอภัยโทษ เพื่อให้ตัวอย่างมีความกระชับมากที่สุด ตัวอย่างเช่น ด้วยเวอร์ชันที่รันอยู่จริงของโค้ดนี้ เราไม่สามารถเชื่อใจได้มากนัก และถือว่าการส่งวัตถุ PDO จะถูกสร้างอินสแตนซ์อย่างถูกต้องและเชื่อมต่อกับฐานข้อมูลที่ต้องการ

ที่จริงแล้ว เราอาจจำเป็นต้องวางวัตถุ PDO ไว้ในคลาสที่รับประกันพฤติกรรมดังกล่าว กลับไปที่เนื้อหาที่กำลังจะมีขึ้นเร็วๆ นี้ ตอนนี้เรามาสร้างวิธีการกันวิธี ร้านค้าสินค้า.

สั้นกว่าในบริบทของคลาส ลดลงในบริบทของวัตถุ ช่วยให้คุณสามารถแปลงข้อมูลที่อยู่ในฐานข้อมูลให้เป็นออบเจ็กต์ได้อย่างง่ายดาย และเราไม่ต้องการอินสแตนซ์ประเภทออบเจ็กต์แยกต่างหาก ไม่มีเหตุผลที่ดีว่าทำไมวิธีนี้จึงไม่อาศัยวิธีการหรือพลังเดียวกันในการแยกอินสแตนซ์เดี่ยวของวัตถุ เพื่อไม่ให้ฟังดูคงที่ จากนั้นหากมีวัตถุ PDO ที่ถูกต้อง เราก็สามารถคลิกที่วัตถุนั้นได้วิธีการแบบเดนมาร์ก

เป็นสถานที่ใดก็ได้ zastosuvannya

วิธีการดังกล่าวดำเนินการเสมือนเป็น "โรงงาน" โดยจะใช้วัสดุ "เด็กกำพร้า" (เช่น ข้อมูลที่นำมาจากฐานข้อมูลหรือไฟล์การกำหนดค่า) และใช้เพื่อสร้างวัตถุ

มีการเพิ่มคำว่า "โรงงาน" ก่อนโค้ดที่กำหนดให้กับการสร้างอินสแตนซ์ออบเจ็กต์ ด้วยก้นบึ้งของ "โรงงาน" ดังกล่าว เราจึงยังอยู่ใกล้คุณ

เจ้าหน้าที่ถาวร

ไม่ใช่ความผิดของผู้มีอำนาจที่จะเปลี่ยนแปลง ตัวอย่างเช่น องค์ประกอบเช่นการเข้ารหัสหรือการเข้ารหัสจะกลายเป็นโปรแกรมจะต้องถูกกำหนดด้วยตนเองในคลาส แม้ว่ารหัสเหล่านั้นจะถูกซ่อนไว้และคงที่ แต่รหัสไคลเอนต์จะไม่รับผิดชอบต่อความสามารถในการเปลี่ยนแปลงรหัสเหล่านั้น

และนี่ก็สามารถนำมาประกอบกับอำนาจถาวรที่อยู่ตรงกลางชั้นเรียนได้ เนื่องจากค่าคงที่โกลบอล ค่าคงที่คลาสไม่สามารถเปลี่ยนแปลงได้หลังจากที่ถูกกำหนดแล้ว อำนาจในการลงคะแนนสำหรับคำหลักเพิ่มเติม ค่าคงที่.

ในกรณีหน่วยงานหลักๆ ห้ามวางเครื่องหมายดอลลาร์ไว้ข้างหน้า เพื่อเอาใจพวกเขา พวกเขามักจะได้รับชื่อที่ซับซ้อนกว่า นักเขียนผู้ยิ่งใหญ่เช่นเดียวกับในก้นรุก:

คลาส ShopProduct (const AVAILABLE = 0; const OUT_OF_STOCK = 1; // ...

เจ้าหน้าที่ถาวรสามารถแก้แค้นเกินความหมายที่เป็นแบบพื้นฐานได้ ไม่สามารถกำหนดค่าคงที่ให้กับวัตถุได้

เช่นเดียวกับหน่วยงานแบบคงที่ การเข้าถึงหน่วยงานแบบคงที่เกิดขึ้นผ่านคลาส ไม่ใช่ผ่านอินสแตนซ์ของอ็อบเจ็กต์ เช่นเดียวกับค่าคงที่ที่แสดงโดยไม่มีเครื่องหมายดอลลาร์ เมื่อดำเนินการก่อนหน้า ไม่จำเป็นต้องแทนที่อักขระใดๆ ที่อยู่ข้างหน้า

ร้านพิมพ์สินค้า::AVAILABLE;

การพยายามกำหนดค่าให้กับค่าคงที่หลังจากที่ค่าคงที่แล้วจะนำไปสู่การแยกวิเคราะห์ในขั้นตอนการแยกวิเคราะห์

ค่าคงที่จะได้รับชัยชนะหากพลังนั้นมีให้กับทุกอินสแตนซ์ของคลาส และหากค่าของพลังนั้นคงที่และไม่เปลี่ยนรูป

ณ จุดนี้ฉันจะจบบทความนี้และไปยังบทความถัดไป

คุณพอใจกับเนื้อหาและต้องการเพิ่มมากขึ้นหรือไม่?
เพียงแบ่งปันกับเพื่อนและเพื่อนร่วมงาน!

ด้วยความพิเศษที่สง่างามมาก อุ๊ยการมองเห็น หน่วยงานและวิธีการคงที่- Golovnya จำเป็นต้องเข้าใจทันทีว่าสิ่งเหล่านี้คืออะไรพลังและวิธีการไม่ใช่ของวัตถุ แต่เป็นของคลาส -สิ่งนี้จะต้องเข้าใจตั้งแต่เริ่มต้นและแกน

ขาดพลังและวิธีการคงที่ใน PHP ฉันจะดูบทความนี้ก้นที่คลาสสิกที่สุดคือคลาสที่ย่อมาจากฟังก์ชันทางคณิตศาสตร์ ใครจะรู้? ชวาแล้วจะรู้ว่ามีคลาส คณิตศาสตร์คลาส e) ดังกล่าวเพื่อแทนที่การไม่มีฟังก์ชันทางคณิตศาสตร์ และวิธีการก็มีแบบคงที่ ซึ่งหมายความว่าเพื่อประเมินไซน์หรือเลขยกกำลังใดๆ คุณไม่จำเป็นต้องสร้างอ็อบเจ็กต์ของคลาสนี้ ซึ่งค่อนข้างง่าย

ให้เราเขียนสำเนาที่แก้ไขแล้วของคลาสนี้ สำหรับ PHP เท่านั้น:

คณิตศาสตร์ชั้น (
$count คงที่ส่วนตัว = 0;
ฟังก์ชั่นสาธารณะ __construct() (
ตัวเอง::$count++;
}
ฟังก์ชันคงที่สาธารณะ calcSin($x) (
คืนบาป($x);
}
ฟังก์ชันคงที่สาธารณะ calcSQRT($x) (
ส่งคืน sqrt($x);
}
ฟังก์ชันคงที่สาธารณะ getCount() (
กลับตัวเอง::$count;
}
}
echo Math::calcSin(1);
เสียงสะท้อน "
";
echo Math::calcSQRT(9);
เสียงสะท้อน "
";
$คณิตศาสตร์ = คณิตศาสตร์ใหม่();
$math_2 = คณิตศาสตร์ใหม่();
echo คณิตศาสตร์::getCount();
?>

ฉันแสดงรหัสใด? vikoristannya ของวิธีการและพลังคงที่- โปรดทราบว่าฉันได้ใช้วิธีการรักษาวัตถุแบบคลาสสิก คนที่อยู่ในสนามก็เหมือนกันหมดนับ

มันเป็นแบบคงที่และมีความหมายเหมือนกันสำหรับวัตถุทั้งหมด vikoristannya ของวิธีการและพลังคงที่ก้นยอดนิยมอีกอัน – เซ เวเดนยา โลกา บันทึกทั้งหมดจะถูกเพิ่มผ่านวิธีการคงที่ เป็นเรื่องปกติมากที่จะล้มเหลวในชั้นเรียน ซึ่งพัฒนามาจากความไม่เป็นตัวของตัวเองในการปรับตัว และที่นั่น ฟิลด์ทั้งหมดก็คงที่เช่นกัน แยก bachita ก้น vikoristannyaวิธีการและพลังคงที่ใน PHP

แต่ภาษาอื่นยังไม่เพียงพอ ดังนั้นคุณต้องทำงานกับภาษาเหล่านั้นอย่างภาคบังคับ (Late Static Binding, LSB) เป็นหัวข้อที่ถกเถียงกันถึงปัญหาสามประการที่เหลือกับผู้จำหน่าย PHP (และเราพบว่ามันถูกลบออกจาก PHP 5.3 แล้ว) มีอะไรอีกที่คุณต้องการอีกไหม? สถิตินี้เห็นได้ชัดเจนว่าการเชื่อมต่อแบบคงที่ในภายหลัง

คุณช่วยกรุณาโพสต์รหัสของคุณได้ไหม

ในการประชุมการพัฒนา PHP ซึ่งจัดขึ้นที่ปารีสเมื่อปลายฤดูใบไม้ร่วงปี 2548 หัวข้อของการสื่อสารแบบสแตติกช่วงปลายได้รับการพูดคุยอย่างเป็นทางการโดยทีมพัฒนาหลัก ถึงเวลาที่ต้องดำเนินการนี้ พร้อมกับหัวข้ออื่นๆ มากมายที่ได้รับคำสั่งในวันนี้ รายละเอียดถูกจำกัดอยู่ในขอบเขตสูงสุดของการสนทนา (Late Static Binding, LSB) เป็นหัวข้อที่ถกเถียงกันถึงปัญหาสามประการที่เหลือกับผู้จำหน่าย PHP (และเราพบว่ามันถูกลบออกจาก PHP 5.3 แล้ว) มีอะไรอีกที่คุณต้องการอีกไหม? สถิตินี้เห็นได้ชัดเจนว่าตั้งแต่นั้นเป็นต้นมา

มันตกตะลึงราวกับเป็นสิ่งใหม่ สองปีผ่านไป แกนแรกของ LSB พร้อมใช้งานสำหรับวิกิใน PHP 5.3 อย่างไรก็ตาม กระบวนการนี้ไม่ใช่เรื่องใหญ่สำหรับนักพัฒนาที่ใช้ PHP โดยสังเกตเพียงด้านข้างในคู่มือเท่านั้น

Class Beer ( const NAME = "Beer!"; public function getName() ( return self::NAME; ) ) class Ale ขยาย Beer ( const NAME = "Ale!"; ) $beerDrink = new Beer; $aleDrink = เบียร์ใหม่; echo "เบียร์คือ:" $beerDrink->getName() "\n"; สะท้อน "เอลคือ:" $aleDrink->getName() "\n";

รหัสนี้ให้ผลลัพธ์ดังต่อไปนี้:

เบียร์คือ: เบียร์! เอลคือ: เบียร์!

ระดับ เบียร์วิธีการชำระ รับชื่อ(), เอลเมื่อ tsyomu ตัวเองยังคงชี้ไปที่ชั้นเรียนที่เขาเป็นนักวิโคริสต์ (ณ ถึงผู้ชายคนนี้ชั้นเรียน เบียร์- คงที่สิ่งนี้หายไปใน PHP 5.3 แต่มีการเพิ่มคำนี้เข้าไป

-

ฉันจะให้คุณดูที่ก้น: คงที่ Class Beer ( const NAME = "Beer!"; ฟังก์ชั่นสาธารณะ getName() ( return self::NAME; ) ฟังก์ชั่นสาธารณะ getStaticName() ( return static::NAME; ) ) class Ale ขยาย Beer ( const NAME = "Ale!" ;) $beerDrink = เบียร์ใหม่; $aleDrink = เบียร์ใหม่; echo "เบียร์คือ:" $beerDrink->getName() "\n"; สะท้อน "เอลคือ:" $aleDrink->getName() "\n"; echo "เบียร์คือความจริง:" . $beerDrink->getStaticName() "\n"; echo "เอลคือจริงๆ:" . $aleDrink->getStaticName() "\n"; คำหลักใหม่บ่งชี้ว่ามีความจำเป็นต้องแทนที่ค่าคงที่ของคลาสที่ถูกระงับ แทนค่าคงที่ที่กำหนดไว้ในคลาส วิธี dedecoupling คงที่ getStaticName() ตัวเอง- คำถูกเพิ่มเพื่อใช้ฟังก์ชันใหม่และสำหรับความจุเกตเวย์

ทำงานในลักษณะเดียวกับใน รุ่นก่อนหน้า PHP. ภายในความแตกต่างที่สำคัญ (และแน่นอนว่าสาเหตุที่การเชื่อมต่อถูกเรียกล่าช้า) ระหว่างวิธีการเข้าถึงทั้งสองนี้คือ PHP หมายถึงค่าสำหรับตัวเอง::NAME

ภายใต้ชั่วโมงของ "การรวบรวม" (หากสัญลักษณ์ PHP ถูกแปลงเป็นรหัสเครื่องซึ่งประมวลผลโดยเอ็นจิ้น Zend) และสำหรับ

คงที่::NAME

ค่าจะถูกกำหนด ณ เวลาที่เปิดตัว (ในขณะนั้นหากรหัสเครื่องถูกเพิ่มลงในเครื่องยนต์ Zend)

อีกหนึ่งเครื่องมือสำหรับนักพัฒนา PHP ในอีกส่วนหนึ่ง เราจะมาดูกันว่าสิ่งนี้สามารถทำให้เกิดผลดีได้อย่างไร

สิ่งที่สำคัญที่สุดที่ต้องเข้าใจคือกำลังนั้นคงที่ และวิธีการนั้นเป็นของคลาส ไม่ใช่ของวัตถุ

ชั้นเรียนนี้มีเครื่องมือสำหรับการทำงานกับฟังก์ชันทางคณิตศาสตร์โดยไม่ต้องสร้างวัตถุ คลาสนี้มีคอนสตรัคเตอร์ที่เพิ่มพลังคงที่ของ $count ทีละหนึ่ง คลาสจะจดจำค่าของค่าโดยปล่อยให้คงที่มากขึ้น

ก่อนคำพูด เพื่อจุดประสงค์ของพลังงานคงที่ คำว่า static จะถูกใช้ และสำหรับการเข้าถึงพลังงานแบบคงที่ คำว่า self จะถูกใช้กับ double ”::”

ทุกอย่างได้รับการยกระดับโดยเฉพาะการทำงานหนักด้วยความเมตตา เรามาขยายก้นกันสักหน่อย

เคาน์เตอร์++; ) ฟังก์ชันคงที่สาธารณะ calcSin($x) ( return sin($x); ) ฟังก์ชันคงที่สาธารณะ calcSQRT($x) ( return sqrt($x); ) ฟังก์ชันคงที่สาธารณะ getCount() ( return self::$count; ) ฟังก์ชั่นสาธารณะ getCounter() ( return $this->counter; ) ) echo Math::calcSin(1); เสียงสะท้อน "
"; echo Math::calcSQRT(9); echo "
$math_1 = คณิตศาสตร์ใหม่(); $math_2 = คณิตศาสตร์ใหม่(); $math_3 = คณิตศาสตร์ใหม่(); $math_4 = คณิตศาสตร์ใหม่(); echo "วัตถุที่สร้างขึ้น:" . คณิตศาสตร์::getCount(); เสียงสะท้อน "
"; echo "วัตถุที่สร้าง: " . $math_4->getCounter(); ?>

ในกรณีที่เราเพิ่มพลังหลักให้กับคลาส $counter มันก็เพิ่มขึ้นอีกหนึ่งตัวในตัวสร้างด้วย หากกำลังหลักเป็นของออบเจ็กต์ กำลังจะถูกบันทึกไว้ระหว่างการเรียกของออบเจ็กต์ เมื่อใดก็ตามที่อินสแตนซ์ของคลาส (อ็อบเจ็กต์) ถูกสร้างขึ้น กำลังจะเท่ากับศูนย์ ใน Constructor จะเพิ่มขึ้นหนึ่งตัว

พลังงานสถิตย์เป็นของคลาส และความสำคัญของมันยังคงอยู่

ด้านล่างนี้คือส่วนต่างๆ ที่เปิดเผยการทำงานของหน่วยงานและวิธีการแบบคงที่

การพยายาม vikorize ในวิธีการคงที่จะเปลี่ยน $this เป็นความล้มเหลว (ข้อผิดพลาดร้ายแรง: การใช้ $this เมื่อไม่อยู่ในบริบทของวัตถุ)

อายุ.

"เก่า.";

// นี่คือ "การใช้ $this เมื่อไม่อยู่ในบริบทของวัตถุ" ) ) $TestClass = TestClass ใหม่(); $TestClass->sayHello(); -

ก่อนพูดโดยไม่มีแถว:

$TestClass->sayHello();

จะไม่มีการอภัยโทษ เว้นแต่ว่าคุณพยายามเรียกใช้วิธีการคงที่ในโค้ดด้วย $this ที่เปลี่ยนแปลงได้ และคุณจะได้รับการแจ้งเตือนเกี่ยวกับการอภัยโทษทันที

ถ้าถอดคำว่าคงที่ในกรณีนี้ออกไปก็จะไม่มีความเมตตา

เช่นเดียวกับวิธีการคงที่ เราสามารถขึ้นไปสู่พลังของวัตถุได้ ซึ่งจะนำไปสู่ความเมตตา คุณสามารถไปไกลกว่านั้นไปยังหน่วยงานคงที่โดยใช้การก่อสร้างเพิ่มเติม self::$age เปลี่ยนค่าซึ่งเป็นเครื่องหมาย $ หน้าชื่อการเปลี่ยนแปลง เพื่อแทนที่โครงสร้าง $this->age

ลักษณะคงที่เป็นรายวันในอ็อบเจ็กต์คลาส

; print_r($TestClass); เสียงสะท้อน ""; ?>

วิธีการคงที่สามารถเรียกได้โดยใช้โครงสร้าง self::method() ก้น:

พิมพ์สวัสดี(); -

พลังงานคงที่สามารถแยกแยะได้ในบริบทของคลาส vikory และไวยากรณ์:

เสียงสะท้อน TestClass::$ อายุ;

นอกจากนี้ ความพยายามที่จะทำร้ายเจ้าหน้าที่จนถึงขั้นใช้อำนาจอย่างสุดขั้วส่งผลให้เกิดการลงโทษ: “ข้อผิดพลาดร้ายแรง: การเข้าถึงทรัพย์สินคงที่ที่ไม่ได้ประกาศ”

พลังงานคงที่สามารถเปลี่ยนแปลงได้ในบริบทของคลาส vikory และไวยากรณ์:

TestClass::$อายุ += 20; // ตัวอย่างเช่น

ตัวอย่างโค้ดเพิ่มเติมพร้อมวิธีและพลังแบบคงที่

เป็นของใครใช้บ้างคะ? ตัวเลือกง่ายๆวิโคริสทันยา วิธีการและพลังคงที่ มากกว่า รหัสง่ายๆคุณจะเข้าใจด้วยวิธีนี้คุณจะจำเนื้อหาได้ดีขึ้น

".TestClass::$age; // echo TestClass::$txt; // ข้อผิดพลาด: ข้อผิดพลาดร้ายแรง: การเข้าถึงคุณสมบัติคงที่ที่ไม่ได้ประกาศ echo "
"; TestClass::sayHi(); เสียงสะท้อน "
"; TestClass::sayHello(); // และแกนจัดการเพื่อปฏิเสธการเข้าถึงตัวแปรคงที่ผ่านวัตถุ ($obj::$age)... echo "
"; $obj = new TestClass; echo "เราลดอินพุตให้เป็นตัวแปรคงที่ผ่านอ็อบเจ็กต์: " . $obj::$age; ?>

โปรดทราบ และนี่เป็นสิ่งสำคัญที่เราได้แปลงเป็นวิธี sayHi() แบบไม่คงที่ โดยเปลี่ยนไวยากรณ์เป็นองค์ประกอบคลาสแบบคงที่

สรุป

• Golovna: พลังงานคงที่เป็นของคลาส ไม่ใช่ของวัตถุ
• วิธีการแบบสแตติกไม่สามารถขยายเป็นวิธีการที่มีกำลังสูงสุดและคลาสได้ $this->name ใช้ไม่ได้ที่นี่
• วิธีการแบบคงที่สามารถขยายไปสู่หน่วยงานแบบคงที่ได้โดยใช้ self::$name
• ลักษณะคลาสแบบคงที่ไม่พร้อมใช้งานสำหรับอ็อบเจ็กต์
• วิธีการหลักสามารถเปลี่ยนเป็นกำลังคงที่ได้โดยใช้ self::$name
• พลังงานคงที่สามารถแสดงได้ในบริบทของคลาสโดยใช้ไวยากรณ์: TestClass::$age
• วิธีการหลักสามารถเรียกได้ในบริบทของวัตถุ ($object->method()) และคลาสที่ใช้ไวยากรณ์ TestClass::method()
• ด้วยความช่วยเหลือของไวยากรณ์ $object::$age ฉันสามารถปฏิเสธการเข้าถึงพลังงานคงที่ผ่านวัตถุได้

ความคล้ายคลึงกับ JavaScript

JavaScript มีคลาสคณิตศาสตร์ที่สามารถรองรับฟังก์ชันทางคณิตศาสตร์ได้หลากหลาย

ในการคำนวณทางคณิตศาสตร์ (การคำนวณไซน์และเลขชี้กำลัง) JavaScript ไม่จำเป็นต้องสร้างอ็อบเจ็กต์ในคลาส Math เนื่องจากวิธีการเหล่านี้เป็นแบบคงที่ ก่อนที่จะเรียน PHP ฉันไม่เคยเข้าใจว่ามันเกี่ยวกับอะไร และเมื่อได้เรียนรู้คลาสและวัตถุใน PHP ทุกอย่างก็ชัดเจนในหัวของฉัน

ในความเป็นจริง มันง่ายมากที่จะเข้าถึงวิธีการทางคณิตศาสตร์โดยตรงในชั้นเรียนคณิตศาสตร์ ซึ่งเป็นวัตถุที่สร้างขึ้นโดยเฉพาะ

ไม่ใช่เรื่องลับที่ผู้คนชอบจัดอาหารบนโต๊ะในที่ประชุม ไม่เคยเพียงพอมาก่อน ทันทีที่ความสัมพันธ์กับความเป็นจริงปรากฏ แต่ความจริงก็พรากจากข้อเท็จจริง - จงถาม แน่นอนว่าโภชนาการและโภชนาการอื่น ๆ เมื่อมองแวบแรกดูเหมือนว่าคุณไม่ประมาท แต่จริงๆ แล้วคุณควรตรวจสอบว่าคุณรู้จักภาษาที่คุณกำลังเขียนดีแค่ไหน

ลองแปรงอาหารเหล่านี้ดู คำว่า "คงที่" หมายถึงอะไรใน PHP และมันจะติดขัดหรือไม่?

คำหลักแบบคงที่คือสามใน PHP ค่านิยมต่างๆ-

เรามาเรียงลำดับตามลำดับเวลาเมื่อมีกลิ่นเหม็นปรากฏในภาษา

ความสำคัญอันดับแรก – การเปลี่ยนแปลงท้องถิ่นแบบคงที่

ฟังก์ชั่น foo() ( $a = 0; echo $a; $a = $a + 1; ) foo(); // 0 foo(); // 0 foo(); // 0

PHP มีการเปลี่ยนแปลงในเครื่อง ซึ่งหมายความว่าสามารถเปลี่ยนแปลงได้ ไพเราะ และได้ลบความหมายที่อยู่ตรงกลางของฟังก์ชัน (เมธอด) ไป ซึ่งเห็นได้ชัดเจนภายในชั่วโมงสุดท้ายของการสรุปฟังก์ชัน (เมธอด) เท่านั้น เมื่อคุณออกจากวิธีการ การเปลี่ยนแปลงในเครื่องจะลดลง และเมื่อคุณป้อนอีกครั้ง การเปลี่ยนแปลงจะถูกสร้างขึ้นอีกครั้ง โค้ดมีการเปลี่ยนแปลงในเครื่อง - การเปลี่ยนแปลง $a - มีต้นกำเนิดเฉพาะในช่วงกลางของฟังก์ชัน foo() และทันทีหลังจากคลิกฟังก์ชันนี้จะถูกสร้างใหม่อีกครั้ง การเพิ่มขึ้นของการเปลี่ยนแปลงในโค้ดนี้ไร้ประโยชน์ แฟรกเมนต์ในแถวถัดไปของฟังก์ชันโค้ดเพื่อทำงานให้เสร็จ และค่าการเปลี่ยนแปลงจะถูกใช้ไป ไม่ว่าเราจะเรียกใช้ฟังก์ชัน foo() กี่ครั้ง เราก็จะพิมพ์ 0...

อย่างไรก็ตาม ทุกอย่างจะเปลี่ยนไปหากเราใส่คำสำคัญไว้หน้าคำ:

ฟังก์ชั่น foo() ( static $a = 0; echo $a; $a = $a + 1; ) foo(); // 0 foo(); // 1 foo(); // 2

1. คีย์เวิร์ดแบบคงที่ซึ่งเขียนก่อนค่าการเปลี่ยนแปลงในเครื่อง ก่อให้เกิดผลกระทบต่อไปนี้:
2. สิ่งที่แนบมาจะแสดงเพียงครั้งเดียวในการเรียกใช้ฟังก์ชันครั้งแรก
3. ค่าที่กำหนดในลักษณะนี้จะถูกบันทึกหลังจากฟังก์ชันเสร็จสิ้น

เมื่อมีการเรียก ฟังก์ชันการแทนที่การเปลี่ยนแปลงที่เลือกจะถูกบันทึกก่อนค่า คำว่าคงที่ก็เรียกอีกอย่างว่า.

การเปลี่ยนแปลงท้องถิ่นแบบคงที่

ข้อผิดพลาดของการเปลี่ยนแปลงแบบคงที่

เป็นที่ชัดเจนเช่นเคยใน PHP ว่าคุณไม่สามารถทำได้หากไม่มี "หลุมพราง"หินก้อนแรก - การเปลี่ยนแปลงแบบคงที่สามารถถูกจัดสรรโดยการแสดงออกคงที่หรือคงที่
รหัสแกนคือ:
ย่อมจะทำให้ parser ถูกฆ่าอย่างหลีกเลี่ยงไม่ได้ โชคดีที่เริ่มต้นด้วยเวอร์ชัน 5.6 คุณสามารถกำหนดไม่เพียงแต่ค่าคงที่เท่านั้น แต่ยังรวมถึงนิพจน์คงที่ด้วย (เช่น "1+2" ​​หรือ "") เพื่อให้นิพจน์ดังกล่าวไม่อยู่ในโค้ดอื่นและสามารถคำนวณได้ที่ ขั้นตอนการรวบรวมtsіі

หินนั้นแตกต่าง - พบวิธีการได้ในสำเนาเดียว
ที่นี่ทุกอย่างพับขึ้นอีกเล็กน้อย เพื่อให้สิ่งต่าง ๆ ชัดเจนยิ่งขึ้น ฉันจะให้รหัส:
คลาส A ( ฟังก์ชั่นสาธารณะ foo() ( static $x = 0; echo ++$x; ) ) $a1 = A ใหม่; $a2 = A ใหม่; $a1->ฟู(); // 1 $a2->foo(); // 2 $a1->foo(); // 3 $a2->foo(); // 4
ตรงกันข้ามกับความเข้าใจตามสัญชาตญาณของ "วัตถุต่างๆ - วิธีการที่แตกต่างกันเราเข้าใจดีว่าวิธีการแบบไดนามิกใน PHP "ไม่คูณ" ปรากฎว่าเราจะมีอ็อบเจ็กต์หลายร้อยอ็อบเจ็กต์ในคลาสนี้ วิธีการนี้สามารถนำไปใช้ได้ในสำเนาเดียวเท่านั้น เพียงแค่มีการเรียกสกิน $this ที่แตกต่างกันจะถูกเผยแพร่ในแต่ละอัน

พฤติกรรมดังกล่าวอาจไม่เป็นที่ยอมรับของผู้เรียนที่ไม่ได้เตรียมตัวและกลายเป็นผู้อภัยโทษ มีความจำเป็นต้องระบุว่าคลาส (หรือเมธอด) จะต้องถูกยกเลิกก่อนที่จะสร้างเมธอดใหม่:

คลาส A ( ฟังก์ชั่นสาธารณะ foo() ( static $x = 0; echo ++$x; ) ) คลาส B ขยาย A ( ) $a1 = new A; $b1 = B ใหม่; $a1->ฟู(); // 1 $ b1-> foo (); // 1 $a1->foo(); // 2 $b1->foo(); // 2

หมายเหตุ: วิธีการแบบไดนามิกใน PHP ขึ้นอยู่กับบริบทของคลาส ไม่ใช่วัตถุ และเฉพาะในรันไทม์เท่านั้นที่การทดแทน "$this = current object" จะถูกสร้างขึ้น

ความสำคัญของกันและกันคือกำลังคงที่และวิธีการเรียน

ในโมเดลอ็อบเจ็กต์ PHP เป็นไปได้ที่จะตั้งค่าพลังของเมธอด ไม่เพียงแต่สำหรับอ็อบเจ็กต์ - อินสแตนซ์ของคลาส แต่ยังสำหรับชื่อคลาสด้วย โดยที่คำหลักเป็นแบบคงที่:

คลาส A ( public static $x = "foo"; public static function test() ( return 42; ) ) echo A::$x; // "foo" echo A:: test(); // 42
ในการเข้าถึงพลังและวิธีการดังกล่าว มีการใช้โครงสร้างที่มีกรอบสองเท่า (“Paamayim Nekudotayim”) เช่น IM_CLASS:: $IM_IZminnoy และ IM_CLASS:: IM_Method()

ดำเนินไปโดยไม่ได้บอกว่าหน่วยงานคงที่และวิธีการคงที่มีลักษณะเฉพาะของตัวเองและมี "ข้อผิดพลาด" ของตัวเองที่ต้องทราบ

ลักษณะเฉพาะของสิ่งแรกซ้ำซาก - ไม่มี $ สิ่งนี้เป็นไปไม่ได้ที่จะคล้ายกับความหมายที่แท้จริงของวิธีการแบบคงที่ - มีส่วนของการเชื่อมต่อกับคลาสและไม่ใช่วัตถุ ซึ่งไม่มี $this pseudo-change ซึ่งบ่งชี้ว่าในวิธีไดนามิกของวัตถุปัจจุบัน ซึ่งเป็นตรรกะที่สมบูรณ์

อย่างไรก็ตาม จำเป็นต้องรู้ว่า PHP ไม่เหมือนกับภาษาอื่นๆ ตรงที่ไม่รู้จักสถานการณ์ “$this is wrote in a static method” ในขั้นตอนการแยกวิเคราะห์หรือคอมไพล์ ข้อผิดพลาดประเภทนี้อาจล้มเหลวในรันไทม์หากคุณพยายามลบโค้ดจาก $this ในระหว่างวิธีการคงที่

รหัสเช่นนี้:
คลาส A ( public $id = 42; ฟังก์ชันสาธารณะแบบคงที่ foo() ( echo $this->id; ) )
หากคุณไปไม่ถึงจุดสิ้นสุดของวัน คุณจะไม่พยายามใช้เมธอด foo() ด้วยวิธีที่ไม่เหมาะสม:
$a = ก ใหม่; $a->foo(); (เลือก "ข้อผิดพลาดร้ายแรง: การใช้ $this เมื่อไม่อยู่ในบริบทของวัตถุทันที")

ความพิเศษของเพื่อนไม่ใช่สัจพจน์!
คลาส A ( ฟังก์ชั่นสาธารณะแบบคงที่ foo() ( echo 42; ) ) $a = new A; $a->foo();
เฉยๆ. วิธีการคงที่ซึ่งไม่สามารถใช้ในโค้ด $this สามารถเรียกได้ในบริบทแบบไดนามิก เช่น วิธีการวัตถุ นี่ไม่ใช่ปัญหาใน PHP

สิ่งที่ตรงกันข้ามไม่เป็นความจริงทั้งหมด:
คลาส A ( ฟังก์ชั่นสาธารณะ foo() ( echo 42; ) ) A::foo();
วิธีการแบบไดนามิกอื่นนอกเหนือจาก $this สามารถเพิ่มลงในบริบทคงที่ได้ อย่างไรก็ตาม คุณลบ "วิธีการที่ไม่คงที่ A::foo() ไม่ควรเรียกแบบคงที่" ล่วงหน้าของระดับ E_STRICT คุณได้รับคำแนะนำที่นี่ - ให้ปฏิบัติตามมาตรฐานรหัสหรือเพื่อยับยั้งความก้าวหน้า เพอร์ชี่ สว่างยิ่งขึ้น สวยยิ่งขึ้น

และก่อนจะพูดทุกอย่างที่เขียนค่อนข้างจุกจิกโดยไม่มีวิธีการ การใช้พลังงานคงที่ผ่าน “->” เป็นไปไม่ได้และนำไปสู่ความพ่ายแพ้ร้ายแรง

ค่าที่สามซึ่งดูเหมือนจะซับซ้อนที่สุดคือการเชื่อมต่อแบบคงที่ล่าช้า

นักพัฒนา PHP mov ไม่สนใจกับความหมายสองประการของคีย์เวิร์ด "static" และในเวอร์ชัน 5.3 พวกเขาได้เพิ่มฟีเจอร์ mov อีกอันหนึ่งที่ใช้งานโดยคำนั้น! สิ่งนี้เรียกว่า "การผูกแบบคงที่ล่าช้า" หรือ LSB (การผูกแบบคงที่แบบล่าช้า)

เพื่อทำความเข้าใจแก่นแท้ของ LSB ด้วยวิธีที่ง่ายที่สุดกับหุ้นที่น่าอึดอัดใจ:

โมเดลคลาส ( public static $table = "table"; public static function getTable() ( return self::$table; ) ) echo Model::getTable(); // "โต๊ะ"
คำหลัก self ใน PHP เดิมทีหมายถึง "ฉันเป็นชั้นเรียนที่เขียนคำนี้" ในกรณีนี้ self จะถูกแทนที่ด้วยคลาส Model และ self::$table - โดย Model::$table
ความสามารถประเภทนี้เรียกว่าการเชื่อมต่อแบบคงที่ตั้งแต่เนิ่นๆ ทำไมเร็ว? เนื่องจากการเชื่อมต่อระหว่างตนเองและชื่อเฉพาะกับคลาสนั้นไม่ได้สร้างขึ้นในรันไทม์ แต่ในขั้นตอนก่อนหน้านั้นมาก - การแยกวิเคราะห์และการคอมไพล์โค้ด “คงที่มากขึ้น” - นั่นคือสิ่งที่เราหมายถึงเกี่ยวกับพลังงานคงที่และวิธีการ

เรามาเปลี่ยนรหัสของเรากัน:

โมเดลคลาส ( public static $table = "table"; public static function getTable() ( return self::$table; ) ) class User ขยายโมเดล ( public static $table = "users"; ) echo User::getTable() ; // "โต๊ะ"

ตอนนี้คุณเข้าใจแล้วว่าทำไม PHP ถึงไม่ได้ใช้งานง่ายในสถานการณ์นี้ self ถูกผูกไว้กับคลาส Model และหากยังไม่มีความรู้เกี่ยวกับคลาส User ก็จะชี้ไปที่ Model

แยกบูติ?

เพื่อแก้ปัญหาภาวะที่กลืนไม่เข้าคายไม่ออกนี้ กลไกในการเชื่อมโยง "สาย" จึงถูกคิดค้นขึ้นในขั้นตอนรันไทม์ วิธีแก้ปัญหาค่อนข้างง่าย - เพียงแทนที่คำว่า "self" ด้วย "static" แล้วลิงก์จะถูกสร้างขึ้นด้วยคลาสนี้ ซึ่งโค้ดนี้เรียกใช้ ไม่ใช่ด้วยสิ่งนี้ แทนที่จะเขียน:
class Model ( public static $table = "table"; public static function getTable() ( return static::$table; ) ) class User ขยายโมเดล ( public static $table = "users"; ) echo User::getTable() ; // "ผู้ใช้"

นี่คือ "การเชื่อมต่อแบบคงที่ในภายหลัง" อันลึกลับ

จำเป็นต้องทราบว่าเพื่อความชัดเจนยิ่งขึ้นใน PHP นอกเหนือจากคำว่า "คงที่" แล้วยังมีฟังก์ชันพิเศษ get_call_class() ซึ่งจะแจ้งให้คุณทราบ - ในบริบทของคลาสใด นาราซีฉันกำลังเรียกใช้รหัสของคุณ

บทสนทนาอันยาวไกล!