Hướng dẫn what is late binding and early binding in php? - ràng buộc muộn và ràng buộc sớm trong php là 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

Binding trễ trong PHP là gì?
Binding late là gì so với ràng buộc sớm là gì?
Ràng buộc sớm là gì?
Sự khác biệt giữa ràng buộc sớm và muộn giải thích với một ví dụ của mỗi người là gì?

Mark Amery

132K78 Huy hiệu vàng395 Huy hiệu bạc442 Huy hiệu Đồng78 gold badges395 silver badges442 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

Huy hiệu vàng 11K439 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.1K24 Huy hiệu vàng155 Huy hiệu bạc164 Huy hiệu đồng24 gold badges155 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ụ:

<?php
    class Car
    {
        public static function run()
        {
            return static::getName();
        }

        private static function getName()
        {
            return 'Car';
        }
    }

    class Toyota extends Car
    {
        public static function getName()
        {
            return 'Toyota';
        }
    }

    echo Car::run(); // Output: Car
    echo Toyota::run(); // Output: Toyota
?>

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.75010 huy hiệu vàng58 Huy hiệu bạc96 Huy hiệu đồng10 gold badges58 silver badges96 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.2472 Huy hiệu vàng21 Huy hiệu bạc33 Huy hiệu đồng2 gold badges21 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

Huy hiệu vàng 11K439 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.1K24 Huy hiệu vàng155 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.84718 Huy hiệu bạc18 Huy hiệu đồng18 silver badges18 bronze badges

Binding trễ trong PHP là gì?

"Binding muộn" xuất phát từ thực tế là tĩnh :: sẽ không được giải quyết bằng cách sử dụng lớp nơi phương thức được xác định nhưng nó sẽ được tính toán bằng cách sử dụng thông tin thời gian chạy. Nó cũng được gọi là "liên kết tĩnh" vì nó có thể được sử dụng cho (nhưng không giới hạn ở) các cuộc gọi phương thức tĩnh.comes from the fact that static:: will not be resolved using the class where the method is defined but it will rather be computed using runtime information. It was also called a "static binding" as it can be used for (but is not limited to) static method calls.

Binding late là gì so với ràng buộc sớm là gì?

Sự khác biệt chính giữa ràng buộc sớm và muộn liên quan đến chuyển đổi loại.Mặc dù ràng buộc sớm cung cấp kiểm tra thời gian biên dịch tất cả các loại để không có diễn viên ngầm nào xảy ra, các loại kiểm tra ràng buộc trễ chỉ khi đối tượng được tạo hoặc hành động được thực hiện trên loại.early binding provides compile-time checking of all types so that no implicit casts occur, late binding checks types only when the object is created or an action is performed on the type.

Ràng buộc sớm là gì?

Liên kết sớm: Liên kết có thể được giải quyết tại thời điểm biên dịch bởi trình biên dịch được gọi là liên kết tĩnh hoặc sớm.Liên kết của tất cả các phương pháp tĩnh, riêng tư và cuối cùng được thực hiện vào thời gian biên dịch.The binding which can be resolved at compile time by the compiler is known as static or early binding. Binding of all the static, private and final methods is done at compile-time.

Sự khác biệt giữa ràng buộc sớm và muộn giải thích với một ví dụ của mỗi người là gì?

Các cuộc gọi phương thức thông thường và các cuộc gọi phương thức quá tải là các ví dụ về ràng buộc sớm, trong khi phản xạ và ghi đè phương pháp (đa hình thời gian chạy) là các ví dụ về ràng buộc muộn.Sự ràng buộc của các phương thức riêng tư, tĩnh và cuối cùng xảy ra vào thời gian biên dịch vì chúng không thể bị ghi đè.. The binding of private, static, and final methods happens at the compile-time as they cannot be overridden.

programming php __Invoke In PHP __toString PHP Namespace PHP