Hướng dẫn php override function with different parameters - chức năng ghi đè php với các tham số khác nhau

Question

Kể từ Php 8.1, có một bản hack thú vị để ghi đè phương thức của một lớp với số lượng thêm các đối số cần thiết. Bạn nên sử dụng tính năng mới trong khởi tạo. Nhưng bằng cách nào?required arguments. You should use the new new in initializers feature. But how?

Nội dung chính Show

Loại bỏ việc sử dụng loại công đoàn
Bàn luận
Bạn có thể ghi đè các phương thức trong PHP không?
PHP có hỗ trợ ghi đè chức năng cha mẹ không?
Chúng ta có thể có hai chức năng có cùng tên trong PHP tại sao hoặc tại sao không?
Chúng ta có thể ghi đè hàm tạo trong PHP không?

Chúng tôi xác định một lớp có hàm tạo luôn ném ArgumentCountError và làm cho nó trở thành giá trị mặc định của mỗi tham số cần thiết (một phiên bản cải tiến của câu trả lời của @jose.serapicos). Đơn giản và mát mẻ!

Bây giờ chúng ta hãy xem nó trong hành động. Đầu tiên, chúng tôi xác định RequiredParam:

final class RequiredParameter extends \ArgumentCountError
{
    public function __construct()
    {
        // Nested hack
        throw $this;
    }
}

Và sau đó:

class Base
{
    public function something(string $baseParam): string
    {
        return $baseParam;
    }
}

class Derived extends Base
{
    public function something(
        string $baseParam,
        string|RequiredParameter $extraParam = new RequiredParameter(),
    ): string {
        return "$baseParam + $extraParam";
    }
}

Bằng cách này, không ai có thể bỏ qua các tham số bổ sung, vì RequiredParameter được khai báo là final. Nó hoạt động cho các giao diện là tốt.

Điều này tốt hay xấu như thế nào?

Một lợi thế là nó linh hoạt hơn một chút so với việc thiết lập các tham số mặc định là null, vì bạn có thể truyền cho hàm tạo của RequiredParameter danh sách các tham số tùy ý và có thể xây dựng thông báo lỗi tùy chỉnh.

Một lợi thế khác là nó được xử lý ít hơn bằng tay, và do đó an toàn hơn. Bạn có thể quên xử lý giá trị null, nhưng lớp RequiredParameter xử lý mọi việc cho bạn.

Một nhược điểm lớn của phương pháp này là nó phá vỡ các quy tắc. Đầu tiên và quan trọng nhất, bạn phải tự hỏi tại sao bạn cần điều này, bởi vì nó phá vỡ đa hình trong hầu hết các trường hợp. Sử dụng nó một cách thận trọng.

Tuy nhiên, có các trường hợp sử dụng hợp lệ cho việc này, như mở rộng phương thức của lớp cha với cùng tên (nếu bạn không thể sửa đổi cha mẹ, nếu không tôi khuyên bạn nên sử dụng các đặc điểm thay thế) và sử dụng lớp con làm độc lập (tức là không có sự trợ giúp của Loại của lớp cha).

Một nhược điểm khác là nó yêu cầu bạn sử dụng các loại công đoàn cho từng tham số. Mặc dù cách giải quyết sau đây là có thể, nhưng nó đòi hỏi bạn phải tạo ra nhiều lớp hơn, điều này có thể làm tổn thương khả năng hiểu mã của bạn, cũng như ít ảnh hưởng đến khả năng duy trì và hiệu suất (dựa trên các điều kiện của bạn). BTW, không có hack đến miễn phí.

Loại bỏ việc sử dụng loại công đoàn

Bạn có thể mở rộng từ hoặc thực hiện RequiredParameter Loại tương thích của tham số thực tế để có thể xóa nhu cầu về loại liên minh:

class BaseRequiredParameter extends Base
{
    public function __construct()
    {
        throw new \ArgumentCountError();
    }
}

class Derived extends Base
{
    public function something(
        string $baseParam,
        Base $extraParam = new BaseRequiredParameter()
    ): string {
        return "$baseParam + {$extraParam->something()}";
    }
}

Nó cũng có thể cho các chuỗi, nếu bạn thực hiện giao diện

class Base
{
    public function something(string $baseParam): string
    {
        return $baseParam;
    }
}

class Derived extends Base
{
    public function something(
        string $baseParam,
        string|RequiredParameter $extraParam = new RequiredParameter(),
    ): string {
        return "$baseParam + $extraParam";
    }
}

2 (ví dụ:

class Base
{
    public function something(string $baseParam): string
    {
        return $baseParam;
    }
}

class Derived extends Base
{
    public function something(
        string $baseParam,
        string|RequiredParameter $extraParam = new RequiredParameter(),
    ): string {
        return "$baseParam + $extraParam";
    }
}

3 thực hiện nó theo mặc định). Nó không hoạt động đối với một số loại nguyên thủy bao gồm

class Base
{
    public function something(string $baseParam): string
    {
        return $baseParam;
    }
}

class Derived extends Base
{
    public function something(
        string $baseParam,
        string|RequiredParameter $extraParam = new RequiredParameter(),
    ): string {
        return "$baseParam + $extraParam";
    }
}

4,

class Base
{
    public function something(string $baseParam): string
    {
        return $baseParam;
    }
}

class Derived extends Base
{
    public function something(
        string $baseParam,
        string|RequiredParameter $extraParam = new RequiredParameter(),
    ): string {
        return "$baseParam + $extraParam";
    }
}

5,

class Base
{
    public function something(string $baseParam): string
    {
        return $baseParam;
    }
}

class Derived extends Base
{
    public function something(
        string $baseParam,
        string|RequiredParameter $extraParam = new RequiredParameter(),
    ): string {
        return "$baseParam + $extraParam";
    }
}

6,

class Base
{
    public function something(string $baseParam): string
    {
        return $baseParam;
    }
}

class Derived extends Base
{
    public function something(
        string $baseParam,
        string|RequiredParameter $extraParam = new RequiredParameter(),
    ): string {
        return "$baseParam + $extraParam";
    }
}

7,

class Base
{
    public function something(string $baseParam): string
    {
        return $baseParam;
    }
}

class Derived extends Base
{
    public function something(
        string $baseParam,
        string|RequiredParameter $extraParam = new RequiredParameter(),
    ): string {
        return "$baseParam + $extraParam";
    }
}

8, v.v.

Để làm cho cuộc sống của bạn dễ dàng hơn, bạn có thể muốn định nghĩa hàm tạo là một đặc điểm và sử dụng nó (tôi nhận thức được câu trả lời này, nhưng trên thực tế, đây là một trường hợp hữu ích hợp lệ cho một hàm tạo trong một đặc điểm, ít nhất là IMO).

Cải thiện bài viết

Lưu bài viết

Đọc

Bàn luận

Cải thiện bài viết

Lưu bài viết

Đọc
Function Overloading: Function overloading contains same function name and that function performs different task according to number of arguments. For example, find the area of certain shapes where radius are given then it should return area of circle if height and width are given then it should give area of rectangle and others. Like other OOP languages function overloading can not be done by native approach. In PHP function overloading is done with the help of magic function __call(). This function takes function name and arguments.
Example:

Bàn luận

class BaseRequiredParameter extends Base
{
    public function __construct()
    {
        throw new \ArgumentCountError();
    }
}

class Derived extends Base
{
    public function something(
        string $baseParam,
        Base $extraParam = new BaseRequiredParameter()
    ): string {
        return "$baseParam + {$extraParam->something()}";
    }
}

1

Quá tải chức năng và ghi đè là tính năng OOPS trong PHP. Trong quá tải chức năng, nhiều hơn một hàm có thể có cùng một chữ ký phương thức nhưng số lượng đối số khác nhau. Nhưng trong trường hợp ghi đè chức năng, nhiều hàm sẽ có cùng chữ ký phương thức và số lượng đối số. & NBSP; quá tải chức năng: quá tải chức năng chứa cùng tên hàm và hàm đó thực hiện tác vụ khác nhau theo số lượng đối số. Ví dụ: tìm diện tích của các hình dạng nhất định trong đó bán kính được đưa ra thì nó sẽ quay lại diện tích của vòng tròn nếu chiều cao và chiều rộng được đưa ra thì nó sẽ cho diện tích hình chữ nhật và các khu vực khác. Giống như các ngôn ngữ OOP khác không thể thực hiện được bằng cách tiếp cận bản địa. Trong quá tải chức năng PHP được thực hiện với sự trợ giúp của hàm ma thuật __call (). Hàm này lấy tên chức năng và đối số. & Nbsp; ví dụ: & nbsp; & nbsp;

class BaseRequiredParameter extends Base
{
    public function __construct()
    {
        throw new \ArgumentCountError();
    }
}

class Derived extends Base
{
    public function something(
        string $baseParam,
        Base $extraParam = new BaseRequiredParameter()
    ): string {
        return "$baseParam + {$extraParam->something()}";
    }
}

4

class BaseRequiredParameter extends Base
{
    public function __construct()
    {
        throw new \ArgumentCountError();
    }
}

class Derived extends Base
{
    public function something(
        string $baseParam,
        Base $extraParam = new BaseRequiredParameter()
    ): string {
        return "$baseParam + {$extraParam->something()}";
    }
}

5

class BaseRequiredParameter extends Base
{
    public function __construct()
    {
        throw new \ArgumentCountError();
    }
}

class Derived extends Base
{
    public function something(
        string $baseParam,
        Base $extraParam = new BaseRequiredParameter()
    ): string {
        return "$baseParam + {$extraParam->something()}";
    }
}

6

class BaseRequiredParameter extends Base
{
    public function __construct()
    {
        throw new \ArgumentCountError();
    }
}

class Derived extends Base
{
    public function something(
        string $baseParam,
        Base $extraParam = new BaseRequiredParameter()
    ): string {
        return "$baseParam + {$extraParam->something()}";
    }
}

7

class BaseRequiredParameter extends Base
{
    public function __construct()
    {
        throw new \ArgumentCountError();
    }
}

class Derived extends Base
{
    public function something(
        string $baseParam,
        Base $extraParam = new BaseRequiredParameter()
    ): string {
        return "$baseParam + {$extraParam->something()}";
    }
}

8

class BaseRequiredParameter extends Base
{
    public function __construct()
    {
        throw new \ArgumentCountError();
    }
}

class Derived extends Base
{
    public function something(
        string $baseParam,
        Base $extraParam = new BaseRequiredParameter()
    ): string {
        return "$baseParam + {$extraParam->something()}";
    }
}

9ArgumentCountError0

ArgumentCountError1ArgumentCountError2ArgumentCountError3

class BaseRequiredParameter extends Base
{
    public function __construct()
    {
        throw new \ArgumentCountError();
    }
}

class Derived extends Base
{
    public function something(
        string $baseParam,
        Base $extraParam = new BaseRequiredParameter()
    ): string {
        return "$baseParam + {$extraParam->something()}";
    }
}

7 ArgumentCountError5ArgumentCountError6ArgumentCountError0

ArgumentCountError8ArgumentCountError9 ArgumentCountError3RequiredParam1ArgumentCountError3

class BaseRequiredParameter extends Base
{
    public function __construct()
    {
        throw new \ArgumentCountError();
    }
}

class Derived extends Base
{
    public function something(
        string $baseParam,
        Base $extraParam = new BaseRequiredParameter()
    ): string {
        return "$baseParam + {$extraParam->something()}";
    }
}

9RequiredParam4

RequiredParam5RequiredParam6 RequiredParam7

RequiredParam8RequiredParam9 RequiredParameter0

class BaseRequiredParameter extends Base
{
    public function __construct()
    {
        throw new \ArgumentCountError();
    }
}

class Derived extends Base
{
    public function something(
        string $baseParam,
        Base $extraParam = new BaseRequiredParameter()
    ): string {
        return "$baseParam + {$extraParam->something()}";
    }
}

9RequiredParameter2

RequiredParam5RequiredParam6 RequiredParameter5

RequiredParam8RequiredParam9

class BaseRequiredParameter extends Base
{
    public function __construct()
    {
        throw new \ArgumentCountError();
    }
}

class Derived extends Base
{
    public function something(
        string $baseParam,
        Base $extraParam = new BaseRequiredParameter()
    ): string {
        return "$baseParam + {$extraParam->something()}";
    }
}

9RequiredParameter9

class BaseRequiredParameter extends Base
{
    public function __construct()
    {
        throw new \ArgumentCountError();
    }
}

class Derived extends Base
{
    public function something(
        string $baseParam,
        Base $extraParam = new BaseRequiredParameter()
    ): string {
        return "$baseParam + {$extraParam->something()}";
    }
}

9final1

ArgumentCountError8final3

ArgumentCountError1final3

class BaseRequiredParameter extends Base
{
    public function __construct()
    {
        throw new \ArgumentCountError();
    }
}

class Derived extends Base
{
    public function something(
        string $baseParam,
        Base $extraParam = new BaseRequiredParameter()
    ): string {
        return "$baseParam + {$extraParam->something()}";
    }
}

4final3

final3

final9 null0null1 null2

null3ArgumentCountError3final9null6

null3 null8null9

null3 ArgumentCountError3final9RequiredParameter3

RequiredParameter4

Chức năng Ghi đè: Chức năng Quan điểm giống như các ngôn ngữ lập trình OOP khác. Trong chức năng ghi đè, cả hai lớp cha và con nên có cùng tên hàm và số lượng đối số. Nó được sử dụng để thay thế phương pháp cha mẹ trong lớp con. Mục đích của việc ghi đè là thay đổi hành vi của phương pháp lớp cha. Hai phương thức có cùng tên và cùng một tham số được gọi là ghi đè. Ví dụ: & nbsp; & nbsp; Function overriding is same as other OOPs programming languages. In function overriding, both parent and child classes should have same function name with and number of arguments. It is used to replace parent method in child class. The purpose of overriding is to change the behavior of parent class method. The two methods with the same name and same parameter is called overriding.
Example:

PHP

class BaseRequiredParameter extends Base
{
    public function __construct()
    {
        throw new \ArgumentCountError();
    }
}

class Derived extends Base
{
    public function something(
        string $baseParam,
        Base $extraParam = new BaseRequiredParameter()
    ): string {
        return "$baseParam + {$extraParam->something()}";
    }
}

1

class BaseRequiredParameter extends Base
{
    public function __construct()
    {
        throw new \ArgumentCountError();
    }
}

class Derived extends Base
{
    public function something(
        string $baseParam,
        Base $extraParam = new BaseRequiredParameter()
    ): string {
        return "$baseParam + {$extraParam->something()}";
    }
}

2 RequiredParameter7

class BaseRequiredParameter extends Base
{
    public function __construct()
    {
        throw new \ArgumentCountError();
    }
}

class Derived extends Base
{
    public function something(
        string $baseParam,
        Base $extraParam = new BaseRequiredParameter()
    ): string {
        return "$baseParam + {$extraParam->something()}";
    }
}

4

class BaseRequiredParameter extends Base
{
    public function __construct()
    {
        throw new \ArgumentCountError();
    }
}

class Derived extends Base
{
    public function something(
        string $baseParam,
        Base $extraParam = new BaseRequiredParameter()
    ): string {
        return "$baseParam + {$extraParam->something()}";
    }
}

5 null0

ArgumentCountError1null3 null3null9

class BaseRequiredParameter extends Base
{
    public function __construct()
    {
        throw new \ArgumentCountError();
    }
}

class Derived extends Base
{
    public function something(
        string $baseParam,
        Base $extraParam = new BaseRequiredParameter()
    ): string {
        return "$baseParam + {$extraParam->something()}";
    }
}

4final3

final3

class BaseRequiredParameter extends Base
{
    public function __construct()
    {
        throw new \ArgumentCountError();
    }
}

class Derived extends Base
{
    public function something(
        string $baseParam,
        Base $extraParam = new BaseRequiredParameter()
    ): string {
        return "$baseParam + {$extraParam->something()}";
    }
}

2 null9

class Base
{
    public function something(string $baseParam): string
    {
        return $baseParam;
    }
}

class Derived extends Base
{
    public function something(
        string $baseParam,
        string|RequiredParameter $extraParam = new RequiredParameter(),
    ): string {
        return "$baseParam + $extraParam";
    }
}

00 RequiredParameter7

class BaseRequiredParameter extends Base
{
    public function __construct()
    {
        throw new \ArgumentCountError();
    }
}

class Derived extends Base
{
    public function something(
        string $baseParam,
        Base $extraParam = new BaseRequiredParameter()
    ): string {
        return "$baseParam + {$extraParam->something()}";
    }
}

4

class BaseRequiredParameter extends Base
{
    public function __construct()
    {
        throw new \ArgumentCountError();
    }
}

class Derived extends Base
{
    public function something(
        string $baseParam,
        Base $extraParam = new BaseRequiredParameter()
    ): string {
        return "$baseParam + {$extraParam->something()}";
    }
}

5 null0

ArgumentCountError1null3 null3null9

class BaseRequiredParameter extends Base
{
    public function __construct()
    {
        throw new \ArgumentCountError();
    }
}

class Derived extends Base
{
    public function something(
        string $baseParam,
        Base $extraParam = new BaseRequiredParameter()
    ): string {
        return "$baseParam + {$extraParam->something()}";
    }
}

4final3

final3

class BaseRequiredParameter extends Base
{
    public function __construct()
    {
        throw new \ArgumentCountError();
    }
}

class Derived extends Base
{
    public function something(
        string $baseParam,
        Base $extraParam = new BaseRequiredParameter()
    ): string {
        return "$baseParam + {$extraParam->something()}";
    }
}

2 null9

class Base
{
    public function something(string $baseParam): string
    {
        return $baseParam;
    }
}

class Derived extends Base
{
    public function something(
        string $baseParam,
        string|RequiredParameter $extraParam = new RequiredParameter(),
    ): string {
        return "$baseParam + $extraParam";
    }
}

00 RequiredParameter7

ArgumentCountError1null3

class Base
{
    public function something(string $baseParam): string
    {
        return $baseParam;
    }
}

class Derived extends Base
{
    public function something(
        string $baseParam,
        string|RequiredParameter $extraParam = new RequiredParameter(),
    ): string {
        return "$baseParam + $extraParam";
    }
}

07null9

class Base
{
    public function something(string $baseParam): string
    {
        return $baseParam;
    }
}

class Derived extends Base
{
    public function something(
        string $baseParam,
        string|RequiredParameter $extraParam = new RequiredParameter(),
    ): string {
        return "$baseParam + $extraParam";
    }
}

12

class Base
{
    public function something(string $baseParam): string
    {
        return $baseParam;
    }
}

class Derived extends Base
{
    public function something(
        string $baseParam,
        string|RequiredParameter $extraParam = new RequiredParameter(),
    ): string {
        return "$baseParam + $extraParam";
    }
}

21

class Base
{
    public function something(string $baseParam): string
    {
        return $baseParam;
    }
}

class Derived extends Base
{
    public function something(
        string $baseParam,
        string|RequiredParameter $extraParam = new RequiredParameter(),
    ): string {
        return "$baseParam + $extraParam";
    }
}

16

class Base
{
    public function something(string $baseParam): string
    {
        return $baseParam;
    }
}

class Derived extends Base
{
    public function something(
        string $baseParam,
        string|RequiredParameter $extraParam = new RequiredParameter(),
    ): string {
        return "$baseParam + $extraParam";
    }
}

21

RequiredParameter4

class Base
{
    public function something(string $baseParam): string
    {
        return $baseParam;
    }
}

class Derived extends Base
{
    public function something(
        string $baseParam,
        string|RequiredParameter $extraParam = new RequiredParameter(),
    ): string {
        return "$baseParam + $extraParam";
    }
}

12 null0null1

class Base
{
    public function something(string $baseParam): string
    {
        return $baseParam;
    }
}

class Derived extends Base
{
    public function something(
        string $baseParam,
        string|RequiredParameter $extraParam = new RequiredParameter(),
    ): string {
        return "$baseParam + $extraParam";
    }
}

15

Bạn có thể ghi đè các phương thức trong PHP không?

Bạn có thể ghi đè bất kỳ phương thức nào của lớp cha bằng cách tạo mã cần thiết từ mẫu được xác định trước..

PHP có hỗ trợ ghi đè chức năng cha mẹ không?

Ghi đè chỉ phù hợp với các lớp dẫn xuất, trong đó lớp cha đã xác định một phương thức và lớp dẫn xuất muốn ghi đè phương thức đó.Trong PHP, bạn chỉ có thể quá tải các phương thức bằng phương pháp ma thuật __call.you can only overload methods using the magic method __call .

Chúng ta có thể có hai chức năng có cùng tên trong PHP tại sao hoặc tại sao không?

Câu trả lời ngắn gọn: Không. Chỉ có thể là một hàm có tên nhất định.No. There can only be one function with a given name.

Chúng ta có thể ghi đè hàm tạo trong PHP không?

Trong PHP, quy tắc duy nhất để ghi đè các nhà xây dựng là không có quy tắc nào!Các hàm tạo có thể được ghi đè với bất kỳ chữ ký nào.Các thông số của chúng có thể được thay đổi tự do và không có hậu quả.Constructors can be overridden with any signature. Their parameters can be changed freely and without consequence.

programming php PHP override type PHP overloaded functions PHP override class PHP function parameters