Chính xác thì các ràng buộc tĩnh muộn trong PHP là gì?
Mark Amery
133K78 Huy hiệu vàng395 Huy hiệu bạc444 Huy hiệu đồng78 gold badges395 silver badges444 bronze badges
Đã hỏi ngày 16 tháng 12 năm 2009 lúc 7:17Dec 16, 2009 at 7:17
Bạn chắc chắn cần phải đọc các ràng buộc tĩnh muộn trong hướng dẫn sử dụng PHP. Tuy nhiên, tôi sẽ cố gắng cho bạn một bản tóm tắt nhanh chóng.
Về cơ bản, nó sôi sục đến thực tế là từ khóa
class alpha {
function classname[]{
return __CLASS__;
}
function selfname[]{
return self::classname[];
}
function staticname[]{
return static::classname[];
}
}
class beta extends alpha {
function classname[]{
return __CLASS__;
}
}
$beta = new beta[];
echo $beta->selfname[]; // Output: alpha
echo $beta->staticname[]; // Output: beta
0 không tuân theo các quy tắc kế thừa tương tự. class alpha {
function classname[]{
return __CLASS__;
}
function selfname[]{
return self::classname[];
}
function staticname[]{
return static::classname[];
}
}
class beta extends alpha {
function classname[]{
return __CLASS__;
}
}
$beta = new beta[];
echo $beta->selfname[]; // Output: alpha
echo $beta->staticname[]; // Output: beta
0 luôn giải quyết cho lớp mà nó được sử dụng. Điều này có nghĩa là nếu bạn tạo một phương thức trong lớp cha và gọi nó từ lớp con, class alpha {
function classname[]{
return __CLASS__;
}
function selfname[]{
return self::classname[];
}
function staticname[]{
return static::classname[];
}
}
class beta extends alpha {
function classname[]{
return __CLASS__;
}
}
$beta = new beta[];
echo $beta->selfname[]; // Output: alpha
echo $beta->staticname[]; // Output: beta
0 sẽ không tham khảo đứa trẻ như bạn mong đợi.Binding tĩnh muộn giới thiệu một cách sử dụng mới cho từ khóa
class alpha {
function classname[]{
return __CLASS__;
}
function selfname[]{
return self::classname[];
}
function staticname[]{
return static::classname[];
}
}
class beta extends alpha {
function classname[]{
return __CLASS__;
}
}
$beta = new beta[];
echo $beta->selfname[]; // Output: alpha
echo $beta->staticname[]; // Output: beta
3, trong đó giải quyết sự thiếu sót đặc biệt này. Khi bạn sử dụng class alpha {
function classname[]{
return __CLASS__;
}
function selfname[]{
return self::classname[];
}
function staticname[]{
return static::classname[];
}
}
class beta extends alpha {
function classname[]{
return __CLASS__;
}
}
$beta = new beta[];
echo $beta->selfname[]; // Output: alpha
echo $beta->staticname[]; // Output: beta
3, nó đại diện cho lớp nơi bạn sử dụng lần đầu tiên, tức là. Nó 'ràng buộc' với lớp thời gian chạy.Đó là hai khái niệm cơ bản đằng sau nó. Cách
class alpha {
function classname[]{
return __CLASS__;
}
function selfname[]{
return self::classname[];
}
function staticname[]{
return static::classname[];
}
}
class beta extends alpha {
function classname[]{
return __CLASS__;
}
}
$beta = new beta[];
echo $beta->selfname[]; // Output: alpha
echo $beta->staticname[]; // Output: beta
0, class alpha {
function classname[]{
return __CLASS__;
}
function selfname[]{
return self::classname[];
}
function staticname[]{
return static::classname[];
}
}
class beta extends alpha {
function classname[]{
return __CLASS__;
}
}
$beta = new beta[];
echo $beta->selfname[]; // Output: alpha
echo $beta->staticname[]; // Output: beta
6 và class alpha {
function classname[]{
return __CLASS__;
}
function selfname[]{
return self::classname[];
}
function staticname[]{
return static::classname[];
}
}
class beta extends alpha {
function classname[]{
return __CLASS__;
}
}
$beta = new beta[];
echo $beta->selfname[]; // Output: alpha
echo $beta->staticname[]; // Output: beta
3 hoạt động khi class alpha {
function classname[]{
return __CLASS__;
}
function selfname[]{
return self::classname[];
}
function staticname[]{
return static::classname[];
}
}
class beta extends alpha {
function classname[]{
return __CLASS__;
}
}
$beta = new beta[];
echo $beta->selfname[]; // Output: alpha
echo $beta->staticname[]; // Output: beta
3 đang chơi có thể rất tinh tế, vì vậy thay vì đi vào chi tiết hơn, tôi thực sự khuyên bạn nên nghiên cứu các ví dụ trang thủ công. Một khi bạn hiểu những điều cơ bản của mỗi từ khóa, các ví dụ khá cần thiết để xem loại kết quả nào bạn sẽ nhận được.
Danman
11.1k4 Huy hiệu vàng39 Huy hiệu bạc58 Huy hiệu Đồng4 gold badges39 silver badges58 bronze badges
Đã trả lời ngày 16 tháng 12 năm 2009 lúc 7:57Dec 16, 2009 at 7:57
Zombatzombatzombat
91.2K24 Huy hiệu vàng156 Huy hiệu bạc164 Huy hiệu đồng24 gold badges156 silver badges164 bronze badges
1
Từ PHP: ràng buộc tĩnh muộn - Hướng dẫn sử dụng:
Kể từ PHP 5.3.0, PHP thực hiện một tính năng gọi là liên kết tĩnh muộn có thể được sử dụng để tham chiếu lớp được gọi trong bối cảnh kế thừa tĩnh.
Liên kết tĩnh muộn cố gắng giải quyết giới hạn đó bằng cách giới thiệu một từ khóa tham chiếu lớp ban đầu được gọi là thời gian chạy. ... Người ta đã quyết định không giới thiệu một từ khóa mới, mà là sử dụng
3 đã được bảo lưu.class alpha { function classname[]{ return __CLASS__; } function selfname[]{ return self::classname[]; } function staticname[]{ return static::classname[]; } } class beta extends alpha { function classname[]{ return __CLASS__; } } $beta = new beta[]; echo $beta->selfname[]; // Output: alpha echo $beta->staticname[]; // Output: beta
Hãy xem một ví dụ:
Các ràng buộc tĩnh muộn hoạt động bằng cách lưu trữ lớp có tên trong "cuộc gọi không chuyển tiếp cuối cùng". Trong trường hợp các cuộc gọi phương thức tĩnh, đây là lớp được đặt tên rõ ràng [thường là phương thức bên trái của toán tử
0]; Trong trường hợp các cuộc gọi phương thức không tĩnh, nó là lớp của đối tượng. Một "cuộc gọi chuyển tiếp" là một cuộc gọi tĩnh được giới thiệu bởiabstract class AbstractTemplate { public const AWESOME_LIST = ['']; public function someFunction[]: void { $awesomeList = $this->getAwesomeList[]; // OUTPUT: ['harry','henk','john']; var_dump[$awesomeList]; } /** * This function gets static constants from CHILD classes */ public function getAwesomeList[]: array { return static::AWESOME_LIST; } } class ConcreteTemplate extends AbstractTemplate { public const AWESOME_LIST = ['harry','henk','john']; public function someFunction[]: void { parent::someFunction[]; } } $concreteTemplate = new ConcreteTemplate[]; $concreteTemplate->someFunction[];
1,abstract class AbstractTemplate { public const AWESOME_LIST = ['']; public function someFunction[]: void { $awesomeList = $this->getAwesomeList[]; // OUTPUT: ['harry','henk','john']; var_dump[$awesomeList]; } /** * This function gets static constants from CHILD classes */ public function getAwesomeList[]: array { return static::AWESOME_LIST; } } class ConcreteTemplate extends AbstractTemplate { public const AWESOME_LIST = ['harry','henk','john']; public function someFunction[]: void { parent::someFunction[]; } } $concreteTemplate = new ConcreteTemplate[]; $concreteTemplate->someFunction[];
2,abstract class AbstractTemplate { public const AWESOME_LIST = ['']; public function someFunction[]: void { $awesomeList = $this->getAwesomeList[]; // OUTPUT: ['harry','henk','john']; var_dump[$awesomeList]; } /** * This function gets static constants from CHILD classes */ public function getAwesomeList[]: array { return static::AWESOME_LIST; } } class ConcreteTemplate extends AbstractTemplate { public const AWESOME_LIST = ['harry','henk','john']; public function someFunction[]: void { parent::someFunction[]; } } $concreteTemplate = new ConcreteTemplate[]; $concreteTemplate->someFunction[];
3 hoặc, nếu đi lên trong hệ thống phân cấp lớp,abstract class AbstractTemplate { public const AWESOME_LIST = ['']; public function someFunction[]: void { $awesomeList = $this->getAwesomeList[]; // OUTPUT: ['harry','henk','john']; var_dump[$awesomeList]; } /** * This function gets static constants from CHILD classes */ public function getAwesomeList[]: array { return static::AWESOME_LIST; } } class ConcreteTemplate extends AbstractTemplate { public const AWESOME_LIST = ['harry','henk','john']; public function someFunction[]: void { parent::someFunction[]; } } $concreteTemplate = new ConcreteTemplate[]; $concreteTemplate->someFunction[];
4. Hàmabstract class AbstractTemplate { public const AWESOME_LIST = ['']; public function someFunction[]: void { $awesomeList = $this->getAwesomeList[]; // OUTPUT: ['harry','henk','john']; var_dump[$awesomeList]; } /** * This function gets static constants from CHILD classes */ public function getAwesomeList[]: array { return static::AWESOME_LIST; } } class ConcreteTemplate extends AbstractTemplate { public const AWESOME_LIST = ['harry','henk','john']; public function someFunction[]: void { parent::someFunction[]; } } $concreteTemplate = new ConcreteTemplate[]; $concreteTemplate->someFunction[];
5 có thể được sử dụng để truy xuất một chuỗi có tên của lớp được gọi là vàabstract class AbstractTemplate { public const AWESOME_LIST = ['']; public function someFunction[]: void { $awesomeList = $this->getAwesomeList[]; // OUTPUT: ['harry','henk','john']; var_dump[$awesomeList]; } /** * This function gets static constants from CHILD classes */ public function getAwesomeList[]: array { return static::AWESOME_LIST; } } class ConcreteTemplate extends AbstractTemplate { public const AWESOME_LIST = ['harry','henk','john']; public function someFunction[]: void { parent::someFunction[]; } } $concreteTemplate = new ConcreteTemplate[]; $concreteTemplate->someFunction[];
3 giới thiệu phạm vi của nó.abstract class AbstractTemplate { public const AWESOME_LIST = ['']; public function someFunction[]: void { $awesomeList = $this->getAwesomeList[]; // OUTPUT: ['harry','henk','john']; var_dump[$awesomeList]; } /** * This function gets static constants from CHILD classes */ public function getAwesomeList[]: array { return static::AWESOME_LIST; } } class ConcreteTemplate extends AbstractTemplate { public const AWESOME_LIST = ['harry','henk','john']; public function someFunction[]: void { parent::someFunction[]; } } $concreteTemplate = new ConcreteTemplate[]; $concreteTemplate->someFunction[];
Akinuri
9.84010 Huy hiệu vàng58 Huy hiệu bạc97 Huy hiệu đồng10 gold badges58 silver badges97 bronze badges
Đã trả lời ngày 22 tháng 12 năm 2012 lúc 7:10Dec 22, 2012 at 7:10
Mrinmoy Ghoshalmrinmoy GhoshalMrinmoy Ghoshal
2.7841 Huy hiệu vàng18 Huy hiệu bạc17 Huy hiệu đồng1 gold badge18 silver badges17 bronze badges
1
Không có hành vi rõ ràng lắm:
Mã sau đây tạo ra 'Alphabeta'.
class alpha {
function classname[]{
return __CLASS__;
}
function selfname[]{
return self::classname[];
}
function staticname[]{
return static::classname[];
}
}
class beta extends alpha {
function classname[]{
return __CLASS__;
}
}
$beta = new beta[];
echo $beta->selfname[]; // Output: alpha
echo $beta->staticname[]; // Output: beta
Tuy nhiên, nếu chúng ta xóa khai báo hàm ClassName khỏi lớp Beta, chúng ta sẽ nhận được 'alphaalpha' do kết quả.
Farkie
3.2572 Huy hiệu vàng22 Huy hiệu bạc33 Huy hiệu Đồng2 gold badges22 silver badges33 bronze badges
Đã trả lời ngày 19 tháng 11 năm 2013 lúc 14:06Nov 19, 2013 at 14:06
JokeriusjokeriusJokerius
1.2701 Huy hiệu vàng14 Huy hiệu bạc20 Huy hiệu Đồng1 gold badge14 silver badges20 bronze badges
1
Tôi đang trích dẫn từ cuốn sách: "Mã Cuting Edge viết php Master".
Liên kết tĩnh muộn là một tính năng được giới thiệu với PHP 5.3. Nó cho phép chúng ta kế thừa các phương thức tĩnh từ một lớp cha và tham chiếu lớp con được gọi.
Điều này có nghĩa là bạn có thể có một lớp trừu tượng với các phương thức tĩnh và tham chiếu các triển khai cụ thể của lớp con bằng cách sử dụng ký hiệu SPATIC :: [] thay vì phương thức tự :::].static::method[] notation instead of the self::method[].
Vui lòng xem xét tài liệu PHP chính thức: //php.net/manual/en/langage.oop5.late-static-bindings.php
Cách rõ ràng nhất để giải thích ràng buộc tĩnh trễ là với một ví dụ thực hành. Tôi đang sử dụng nó trong một mẫu phương thức mẫu. Xem bên dưới.
abstract class AbstractTemplate {
public const AWESOME_LIST = [''];
public function someFunction[]: void {
$awesomeList = $this->getAwesomeList[];
// OUTPUT: ['harry','henk','john'];
var_dump[$awesomeList];
}
/**
* This function gets static constants from CHILD classes
*/
public function getAwesomeList[]: array
{
return static::AWESOME_LIST;
}
}
class ConcreteTemplate extends AbstractTemplate {
public const AWESOME_LIST = ['harry','henk','john'];
public function someFunction[]: void {
parent::someFunction[];
}
}
$concreteTemplate = new ConcreteTemplate[];
$concreteTemplate->someFunction[];
Lưu ý từ khóa
class alpha {
function classname[]{
return __CLASS__;
}
function selfname[]{
return self::classname[];
}
function staticname[]{
return static::classname[];
}
}
class beta extends alpha {
function classname[]{
return __CLASS__;
}
}
$beta = new beta[];
echo $beta->selfname[]; // Output: alpha
echo $beta->staticname[]; // Output: beta
3 trong phương thức abstract class AbstractTemplate {
public const AWESOME_LIST = [''];
public function someFunction[]: void {
$awesomeList = $this->getAwesomeList[];
// OUTPUT: ['harry','henk','john'];
var_dump[$awesomeList];
}
/**
* This function gets static constants from CHILD classes
*/
public function getAwesomeList[]: array
{
return static::AWESOME_LIST;
}
}
class ConcreteTemplate extends AbstractTemplate {
public const AWESOME_LIST = ['harry','henk','john'];
public function someFunction[]: void {
parent::someFunction[];
}
}
$concreteTemplate = new ConcreteTemplate[];
$concreteTemplate->someFunction[];
8. Hãy thay đổi một chút bây giờ:public function getAwesomeList[]: array
{
return self::AWESOME_LIST;
}
Đầu ra của
abstract class AbstractTemplate {
public const AWESOME_LIST = [''];
public function someFunction[]: void {
$awesomeList = $this->getAwesomeList[];
// OUTPUT: ['harry','henk','john'];
var_dump[$awesomeList];
}
/**
* This function gets static constants from CHILD classes
*/
public function getAwesomeList[]: array
{
return static::AWESOME_LIST;
}
}
class ConcreteTemplate extends AbstractTemplate {
public const AWESOME_LIST = ['harry','henk','john'];
public function someFunction[]: void {
parent::someFunction[];
}
}
$concreteTemplate = new ConcreteTemplate[];
$concreteTemplate->someFunction[];
9 tại public function getAwesomeList[]: array
{
return self::AWESOME_LIST;
}
0 sẽ là:array [size=1]
0 => string '' [length=0]
Từ khóa
class alpha {
function classname[]{
return __CLASS__;
}
function selfname[]{
return self::classname[];
}
function staticname[]{
return static::classname[];
}
}
class beta extends alpha {
function classname[]{
return __CLASS__;
}
}
$beta = new beta[];
echo $beta->selfname[]; // Output: alpha
echo $beta->staticname[]; // Output: beta
3 được sử dụng trong mẫu thiết kế singleton. Xem liên kết: //refactoring.guru/design-patterns/singleton/php/exampleVí dụ đơn giản nhất để hiển thị sự khác biệt. Lưu ý, bản thân :: $ c
Note, self::$c
class A
{
static $c = 7;
public static function getVal[]
{
return self::$c;
}
}
class B extends A
{
static $c = 8;
}
B::getVal[]; // 7
Ràng buộc tĩnh muộn, lưu ý tĩnh :: $ cstatic::$c
class A
{
static $c = 7;
public static function getVal[]
{
return static::$c;
}
}
class B extends A
{
static $c = 8;
}
B::getVal[]; // 8
Đã trả lời ngày 23 tháng 2 năm 2016 lúc 12:00Feb 23, 2016 at 12:00
Nhìn vào nó từ một "Tại sao tôi sẽ sử dụng cái này?" Quan điểm, về cơ bản, đó là một cách để thay đổi bối cảnh mà phương thức tĩnh đang được giải thích/chạy.
Với
class alpha {
function classname[]{
return __CLASS__;
}
function selfname[]{
return self::classname[];
}
function staticname[]{
return static::classname[];
}
}
class beta extends alpha {
function classname[]{
return __CLASS__;
}
}
$beta = new beta[];
echo $beta->selfname[]; // Output: alpha
echo $beta->staticname[]; // Output: beta
0, bối cảnh là một trong đó bạn xác định phương thức ban đầu. Với class alpha {
function classname[]{
return __CLASS__;
}
function selfname[]{
return self::classname[];
}
function staticname[]{
return static::classname[];
}
}
class beta extends alpha {
function classname[]{
return __CLASS__;
}
}
$beta = new beta[];
echo $beta->selfname[]; // Output: alpha
echo $beta->staticname[]; // Output: beta
3, đó là cái bạn gọi nó từ đó.
Đã trả lời ngày 13 tháng 8 năm 2015 lúc 12:27Aug 13, 2015 at 12:27
DanmandanmanDanMan
11.1k4 Huy hiệu vàng39 Huy hiệu bạc58 Huy hiệu Đồng4 gold badges39 silver badges58 bronze badges
Đã trả lời ngày 16 tháng 12 năm 2009 lúc 7:57
abstract class Builder {
public static function build[] {
return new static;
}
}
class Member extends Builder {
public function who_am_i[] {
echo 'Member';
}
}
Member::build[]->who_am_i[];
ZombatzombatSep 9, 2010 at 6:13
91.2K24 Huy hiệu vàng156 Huy hiệu bạc164 Huy hiệu đồngPetah
Từ PHP: ràng buộc tĩnh muộn - Hướng dẫn sử dụng:27 gold badges155 silver badges211 bronze badges
Kể từ PHP 5.3.0, PHP thực hiện một tính năng gọi là liên kết tĩnh muộn có thể được sử dụng để tham chiếu lớp được gọi trong bối cảnh kế thừa tĩnh.
class A{
protected static $things;
}
class B extends A {
public static function things[]{
static::$things[1] = 'Thing B';
return static::$things;
}
}
class C extends A{
public static function things[]{
static::$things[2] = 'Thing C';
return static::$things;
}
}
print_r[C::things[]];
// Array [
// [2] => Thing C
// ]
B::things[];
print_r[C::things[]];
// Array [
// [2] => Thing C
// [1] => Thing B
// ]
Bạn có thể sửa nó bằng cách khai báo cùng một biến trong từng lớp trẻ em, ví dụ:
class C extends A{
protected static $things; // add this and B will not interfere!
public static function things[]{
static::$things[2] = 'Thing C';
return static::$things;
}
}
Đã trả lời ngày 3 tháng 5 năm 2019 lúc 16:26May 3, 2019 at 16:26
Fortefrank FortefrankFrank Forte
1.85718 Huy hiệu bạc18 Huy hiệu đồng18 silver badges18 bronze badges