Hướng dẫn what is late static binding in php for? - liên kết tĩnh trễ trong php để làm gì?

Question

Chính xác thì các ràng buộc tĩnh muộn trong PHP là gì?

Nội dung chính Show

Mục đích của liên kết tĩnh muộn trong PHP là gì?
Liên kết muộn và ràng buộc sớm trong PHP là gì?
Những lợi thế của ràng buộc tĩnh là gì?
Phiên bản PHP nào đã giới thiệu khái niệm gọi là ràng buộc tĩnh muộn?

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

Hướng dẫn what is late static binding in php for? - liên kết tĩnh trễ trong php để làm gì?

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
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 bảo lưu.

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ử

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();

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ở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();

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àm

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();

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ó.

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: http://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: https://refactoring.guru/design-patterns/singleton/php/example

Ví 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

Mục đích của liên kết tĩnh muộn trong PHP là gì?

Khái niệm về các ràng buộc tĩnh muộn mang lại từ khóa 'tĩnh' mới, khi được sử dụng, liên kết chức năng với lớp thời gian chạy hoặc lớp nơi chức năng được sử dụng lần đầu tiên. Ngoài ra, bất kỳ hàm hoặc biến tĩnh nào thường được thực hiện trong thời gian chạy chứ không phải trong thời gian biên dịch.binds the function to the runtime class, or the class where the function was first used. In addition to this, any static function or variable is usually executed during runtime and not during compile time.

Liên kết muộn và ràng buộc sớm trong PHP là gì?

Nếu trình biên dịch biết tại thời gian biên dịch được gọi là hàm nào, nó được gọi là ràng buộc sớm.Nếu một trình biên dịch không biết tại biên dịch thời gian nào có chức năng gọi lên cho đến khi chạy, nó được gọi là ràng buộc muộn.

Những lợi thế của ràng buộc tĩnh là gì?

Dưới đây là một số lợi thế được đưa ra.Thực thi liên kết tĩnh là hiệu quả hơn và nhanh hơn động.Trình biên dịch liên kết này biết rằng các loại phương thức này không thể bị ghi đè.Trong liên kết tĩnh, loại được sử dụng trong khi liên kết động sử dụng các đối tượng cho các ràng buộc.more efficient & faster than Dynamic. This Binding compiler knows that these types of methods can not be overridden. In the Static Binding, the type is used while Dynamic Binding uses objects for Bindings.

Phiên bản PHP nào đã giới thiệu khái niệm gọi là ràng buộc tĩnh muộn?

Điều này được gọi là ràng buộc tĩnh muộn.Tính năng này của ràng buộc tĩnh muộn đã được giới thiệu trong PHP 5.3 trở lên, các phiên bản trước sẽ cho thấy một lỗi nghiêm trọng.PHP 5.3 and above, previous versions will show a fatal error.

programming php PHP static PHP new static In PHP __toString PHP

Hướng dẫn what is late static binding in php for? - liên kết tĩnh trễ trong php để làm gì?

Mục đích của liên kết tĩnh muộn trong PHP là gì?

Liên kết muộn và ràng buộc sớm trong PHP là gì?

Những lợi thế của ràng buộc tĩnh là gì?

Phiên bản PHP nào đã giới thiệu khái niệm gọi là ràng buộc tĩnh muộn?

Bài Viết Liên Quan

Quảng Cáo

Có thể bạn quan tâm

Toplist được quan tâm

Quảng cáo

Xem Nhiều

Quảng cáo

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội