Chúng ta có thể lấy tên lớp không gian tên đủ điều kiện của một đối tượng bằng cách sử dụng hàm
get_class[$object] === $object::class;>>> get_class[$obj];
=> "App\Models\Project"
>>> [new \ReflectionClass[$obj]]->getShortName[];
=> "Project"
Một tùy chọn khác là thực sự lấy tên lớp được đặt tên đủ điều kiện của đối tượng và lấy tên lớp thông qua thao tác chuỗi
>>> end[explode['\\', get_class[$obj]]];
=> "Project"
Xin lưu ý rằng chúng ta cần thoát khỏi dấu gạch chéo ngược
get_class[$object] === $object::class;get_class[$object] === $object::class;get_class[$object] === $object::class;get_class[$object] === $object::class;get_class[$object] === $object::class;PHP có hằng số ma thuật
get_class[$object] === $object::class;get_class[$object] === $object::class;$object = array[];
$object::class;
// Fatal error: Uncaught TypeError: Cannot use ::class on value of type array in ...:...Thí dụ
namespace App\Demos;
use Foo\Bar;
use Bar\Baz as BBaz;
class Demo {}
// `use` statement is resolved:
echo Bar::class; // "Foo\Bar"
// `use` X `as` Y is resolved:
echo BBaz::class; // "Bar\Baz"
// Current namespace is resolved:
echo Demo::class; // "App\Demos\Demo"Cho đến PHP 8. 0, hằng số ma thuật
get_class[$object] === $object::class;$object = new Foo\Bar[];
echo $object::class;
// Fatal error: Cannot use ::class with dynamic class name.Với PHP8. 0, bây giờ bạn có thể sử dụng hằng số
get_class[$object] === $object::class;$object = new Foo\Bar[];
echo $object::class;
// PHP 8.0+:
// "Foo\Bar"Kết quả tương tự như $object = new Foo\Bar[];
echo $object::class;
// Fatal error: Cannot use ::class with dynamic class name.
1
$object = new Foo\Bar[];
echo $object::class;
// Fatal error: Cannot use ::class with dynamic class name.Hằng số
get_class[$object] === $object::class;$object = new Foo\Bar[];
echo $object::class;
// Fatal error: Cannot use ::class with dynamic class name.get_class[$object] === $object::class;Không phải đối tượng không được phép
Không được phép sử dụng
get_class[$object] === $object::class;Nếu bạn cần lấy kiểu của bất kỳ biến nào, PHP 8. 0 đi kèm với một hàm
$object = new Foo\Bar[];
echo $object::class;
// Fatal error: Cannot use ::class with dynamic class name.Tác động tương thích ngược
Trong các phiên bản PHP trước 8. 0, sử dụng
get_class[$object] === $object::class;Hàm get_class[] là một hàm có sẵn trong PHP được sử dụng để trả về tên lớp của một đối tượng
cú pháp
>>> end[explode['\\', get_class[$obj]]];
=> "Project"
Thông số. Hàm này chấp nhận tham số duy nhất $object chứa đối tượng cần kiểm tra. Giá trị của tham số này có thể được bỏ qua bên trong lớp
Giá trị trả về. Hàm này trả về tên lớp của đối tượng nào là một thể hiện. Nó trả về FALSE nếu đối tượng không phải là đối tượng. Nếu đối tượng bị bỏ qua khi ở trong lớp thì tên lớp được trả về
PHP hiện đại chủ yếu dựa vào kiểu hướng đối tượng để cấu trúc mã. Bạn sẽ tìm thấy phong cách này trong nhiều thư viện, khuôn khổ và dự án
Đối tượng là gì?
Trong PHP
>>> end[explode['\\', get_class[$obj]]];
=> "Project"
Một đối tượng cho phép bạn xử lý các cấu trúc dữ liệu phức tạp dưới dạng các giá trị đơn lẻ. Hãy lấy một địa chỉ làm ví dụ. Nó bao gồm một số mẩu dữ liệu
- đường phố
- số nhà
- thành phố
- mã bưu điện
- quốc gia
Với các kiểu nguyên thủy đơn giản hơn, chúng tôi không thể lưu trữ địa chỉ theo cách có ý nghĩa, vì vậy chúng tôi cần cấu trúc dữ liệu để lưu trữ địa chỉ trong một giá trị duy nhất để đảm bảo, chúng tôi theo dõi mọi phần dữ liệu thuộc về nó
Chúng tôi cũng cần đảm bảo rằng tất cả các địa chỉ đều có cùng cấu trúc để các phần của ứng dụng xử lý địa chỉ có thể dựa vào. Ví dụ: thuộc tính
>>> end[explode['\\', get_class[$obj]]];
=> "Project"
>>> end[explode['\\', get_class[$obj]]];
=> "Project"
Để đảm bảo một cấu trúc đối tượng nhất định, chúng tôi sử dụng "lớp", một loại bản thiết kế cho một đối tượng
>>> end[explode['\\', get_class[$obj]]];
=> "Project"
>>> end[explode['\\', get_class[$obj]]];
=> "Project"
Tên lớp được viết theo phong cách gọi là
>>> end[explode['\\', get_class[$obj]]];
=> "Project"
>>> end[explode['\\', get_class[$obj]]];
=> "Project"
Để tạo một đối tượng địa chỉ từ lớp này, chúng ta sử dụng toán tử
>>> end[explode['\\', get_class[$obj]]];
=> "Project"
>>> end[explode['\\', get_class[$obj]]];
=> "Project"
đầu ra
>>> end[explode['\\', get_class[$obj]]];
=> "Project"
Đầu ra cho chúng ta biết, nó là một
>>> end[explode['\\', get_class[$obj]]];
=> "Project"
>>> end[explode['\\', get_class[$obj]]];
=> "Project"
>>> end[explode['\\', get_class[$obj]]];
=> "Project"
Của cải
Bây giờ, mọi thuộc tính của đối tượng của chúng ta là
>>> end[explode['\\', get_class[$obj]]];
=> "Project"
namespace App\Demos;
use Foo\Bar;
use Bar\Baz as BBaz;
class Demo {}
// `use` statement is resolved:
echo Bar::class; // "Foo\Bar"
// `use` X `as` Y is resolved:
echo BBaz::class; // "Bar\Baz"
// Current namespace is resolved:
echo Demo::class; // "App\Demos\Demo"đầu ra
namespace App\Demos;
use Foo\Bar;
use Bar\Baz as BBaz;
class Demo {}
// `use` statement is resolved:
echo Bar::class; // "Foo\Bar"
// `use` X `as` Y is resolved:
echo BBaz::class; // "Bar\Baz"
// Current namespace is resolved:
echo Demo::class; // "App\Demos\Demo"Để truy cập một thuộc tính của một đối tượng, PHP sử dụng toán tử
>>> end[explode['\\', get_class[$obj]]];
=> "Project"
>>> end[explode['\\', get_class[$obj]]];
=> "Project"
namespace App\Demos;
use Foo\Bar;
use Bar\Baz as BBaz;
class Demo {}
// `use` statement is resolved:
echo Bar::class; // "Foo\Bar"
// `use` X `as` Y is resolved:
echo BBaz::class; // "Bar\Baz"
// Current namespace is resolved:
echo Demo::class; // "App\Demos\Demo"
namespace App\Demos;
use Foo\Bar;
use Bar\Baz as BBaz;
class Demo {}
// `use` statement is resolved:
echo Bar::class; // "Foo\Bar"
// `use` X `as` Y is resolved:
echo BBaz::class; // "Bar\Baz"
// Current namespace is resolved:
echo Demo::class; // "App\Demos\Demo"phương pháp
Nhưng việc thiết lập từng thuộc tính đơn lẻ rất tẻ nhạt và không dễ đọc. Điều gì sẽ xảy ra nếu chúng ta có thể thiết lập tất cả cùng một lúc?
$object = new Foo\Bar[];
echo $object::class;
// Fatal error: Cannot use ::class with dynamic class name.đầu ra
namespace App\Demos;
use Foo\Bar;
use Bar\Baz as BBaz;
class Demo {}
// `use` statement is resolved:
echo Bar::class; // "Foo\Bar"
// `use` X `as` Y is resolved:
echo BBaz::class; // "Bar\Baz"
// Current namespace is resolved:
echo Demo::class; // "App\Demos\Demo"Những gì chúng tôi đã thêm, là một phương pháp. Một hàm được thêm vào mọi đối tượng trong lớp của chúng tôi. Bên trong một phương thức, có một biến đặc biệt gọi là
namespace App\Demos;
use Foo\Bar;
use Bar\Baz as BBaz;
class Demo {}
// `use` statement is resolved:
echo Bar::class; // "Foo\Bar"
// `use` X `as` Y is resolved:
echo BBaz::class; // "Bar\Baz"
// Current namespace is resolved:
echo Demo::class; // "App\Demos\Demo"Phương thức
namespace App\Demos;
use Foo\Bar;
use Bar\Baz as BBaz;
class Demo {}
// `use` statement is resolved:
echo Bar::class; // "Foo\Bar"
// `use` X `as` Y is resolved:
echo BBaz::class; // "Bar\Baz"
// Current namespace is resolved:
echo Demo::class; // "App\Demos\Demo"nhà xây dựng
Tạo một đối tượng địa chỉ mà không có bất kỳ dữ liệu nào ngay từ đầu không thực sự có ý nghĩa. Sẽ hữu ích và dễ sử dụng hơn nếu chúng ta có thể đặt dữ liệu ngay khi chúng ta tạo đối tượng. Có một phương pháp đặc biệt để làm điều đó, nó được gọi là "hàm tạo"
$object = new Foo\Bar[];
echo $object::class;
// Fatal error: Cannot use ::class with dynamic class name.Đầu ra sẽ vẫn như cũ một lần nữa. Nhưng lần này, chúng ta không cần gọi thêm một phương thức để khởi tạo đối tượng của mình. Nếu một lớp có một phương thức có tên chính xác là
namespace App\Demos;
use Foo\Bar;
use Bar\Baz as BBaz;
class Demo {}
// `use` statement is resolved:
echo Bar::class; // "Foo\Bar"
// `use` X `as` Y is resolved:
echo BBaz::class; // "Bar\Baz"
// Current namespace is resolved:
echo Demo::class; // "App\Demos\Demo">>> end[explode['\\', get_class[$obj]]];
=> "Project"
>>> end[explode['\\', get_class[$obj]]];
=> "Project"
Hiển thị
Hiện tại, mọi thứ trong đối tượng
>>> end[explode['\\', get_class[$obj]]];
=> "Project"
$object = new Foo\Bar[];
echo $object::class;
// PHP 8.0+:
// "Foo\Bar"Chức năng đó sẽ sửa đổi một địa chỉ sau khi nó được tạo và chứa đầy dữ liệu. Điều đó thật vô nghĩa, một địa điểm không thay đổi địa chỉ, những con đường không chuyển sang một thành phố khác một cách kỳ diệu. Mọi người có thể chuyển đến một địa chỉ mới nhưng bản thân địa chỉ đó không thể thay đổi. Chúng tôi cần ngăn địa chỉ bị thay đổi sau khi được tạo. Đó là nơi khái niệm "khả năng hiển thị" xuất hiện. Bạn có thể đã tự hỏi, tất cả các từ khóa
namespace App\Demos;
use Foo\Bar;
use Bar\Baz as BBaz;
class Demo {}
// `use` statement is resolved:
echo Bar::class; // "Foo\Bar"
// `use` X `as` Y is resolved:
echo BBaz::class; // "Bar\Baz"
// Current namespace is resolved:
echo Demo::class; // "App\Demos\Demo"$object = new Foo\Bar[];
echo $object::class;
// PHP 8.0+:
// "Foo\Bar"Bây giờ chúng tôi đã thay đổi khả năng hiển thị của các thuộc tính địa chỉ của chúng tôi thành
namespace App\Demos;
use Foo\Bar;
use Bar\Baz as BBaz;
class Demo {}
// `use` statement is resolved:
echo Bar::class; // "Foo\Bar"
// `use` X `as` Y is resolved:
echo BBaz::class; // "Bar\Baz"
// Current namespace is resolved:
echo Demo::class; // "App\Demos\Demo"
namespace App\Demos;
use Foo\Bar;
use Bar\Baz as BBaz;
class Demo {}
// `use` statement is resolved:
echo Bar::class; // "Foo\Bar"
// `use` X `as` Y is resolved:
echo BBaz::class; // "Bar\Baz"
// Current namespace is resolved:
echo Demo::class; // "App\Demos\Demo">>> end[explode['\\', get_class[$obj]]];
=> "Project"
Có ba cấp độ hiển thị trong PHP.
namespace App\Demos;
use Foo\Bar;
use Bar\Baz as BBaz;
class Demo {}
// `use` statement is resolved:
echo Bar::class; // "Foo\Bar"
// `use` X `as` Y is resolved:
echo BBaz::class; // "Bar\Baz"
// Current namespace is resolved:
echo Demo::class; // "App\Demos\Demo"
namespace App\Demos;
use Foo\Bar;
use Bar\Baz as BBaz;
class Demo {}
// `use` statement is resolved:
echo Bar::class; // "Foo\Bar"
// `use` X `as` Y is resolved:
echo BBaz::class; // "Bar\Baz"
// Current namespace is resolved:
echo Demo::class; // "App\Demos\Demo"
namespace App\Demos;
use Foo\Bar;
use Bar\Baz as BBaz;
class Demo {}
// `use` statement is resolved:
echo Bar::class; // "Foo\Bar"
// `use` X `as` Y is resolved:
echo BBaz::class; // "Bar\Baz"
// Current namespace is resolved:
echo Demo::class; // "App\Demos\Demo"
namespace App\Demos;
use Foo\Bar;
use Bar\Baz as BBaz;
class Demo {}
// `use` statement is resolved:
echo Bar::class; // "Foo\Bar"
// `use` X `as` Y is resolved:
echo BBaz::class; // "Bar\Baz"
// Current namespace is resolved:
echo Demo::class; // "App\Demos\Demo"
namespace App\Demos;
use Foo\Bar;
use Bar\Baz as BBaz;
class Demo {}
// `use` statement is resolved:
echo Bar::class; // "Foo\Bar"
// `use` X `as` Y is resolved:
echo BBaz::class; // "Bar\Baz"
// Current namespace is resolved:
echo Demo::class; // "App\Demos\Demo"
namespace App\Demos;
use Foo\Bar;
use Bar\Baz as BBaz;
class Demo {}
// `use` statement is resolved:
echo Bar::class; // "Foo\Bar"
// `use` X `as` Y is resolved:
echo BBaz::class; // "Bar\Baz"
// Current namespace is resolved:
echo Demo::class; // "App\Demos\Demo"Bây giờ chúng ta có một đối tượng
>>> end[explode['\\', get_class[$obj]]];
=> "Project"
Chúng tôi sẽ thêm một phương thức cung cấp cho chúng tôi dữ liệu địa chỉ trong một đoạn văn bản được định dạng đẹp mắt
>>> end[explode['\\', get_class[$obj]]];
=> "Project"
Bây giờ chúng ta có thể tạo một địa chỉ và lấy biểu diễn văn bản được định dạng của nó
>>> end[explode['\\', get_class[$obj]]];
=> "Project"
Và đầu ra sẽ là
>>> end[explode['\\', get_class[$obj]]];
=> "Project"
Chúng ta có thể làm cho điều này thuận tiện hơn bằng cách sử dụng một "phương pháp kỳ diệu" khác. Các lớp PHP có một loạt các phương thức đặc biệt, tất cả đều bắt đầu bằng
namespace App\Demos;
use Foo\Bar;
use Bar\Baz as BBaz;
class Demo {}
// `use` statement is resolved:
echo Bar::class; // "Foo\Bar"
// `use` X `as` Y is resolved:
echo BBaz::class; // "Bar\Baz"
// Current namespace is resolved:
echo Demo::class; // "App\Demos\Demo"
namespace App\Demos;
use Foo\Bar;
use Bar\Baz as BBaz;
class Demo {}
// `use` statement is resolved:
echo Bar::class; // "Foo\Bar"
// `use` X `as` Y is resolved:
echo BBaz::class; // "Bar\Baz"
// Current namespace is resolved:
echo Demo::class; // "App\Demos\Demo"Lần này chúng ta sẽ tạo một phương thức
$object = new Foo\Bar[];
echo $object::class;
// Fatal error: Cannot use ::class with dynamic class name.$object = new Foo\Bar[];
echo $object::class;
// Fatal error: Cannot use ::class with dynamic class name.$object = new Foo\Bar[];
echo $object::class;
// Fatal error: Cannot use ::class with dynamic class name.>>> end[explode['\\', get_class[$obj]]];
=> "Project"
Bây giờ chúng ta chỉ có thể sử dụng địa chỉ như thể nó đã là một chuỗi
>>> end[explode['\\', get_class[$obj]]];
=> "Project"
Điều này sẽ tạo ra đầu ra giống như trước đây
Bây giờ chúng ta có một lớp cho các đối tượng địa chỉ gói dữ liệu [các thuộc tính] và một số logic [hàm tạo và phương thức toString] và được bảo vệ khỏi sự sửa đổi bên ngoài
tĩnh
Trong khi các thuộc tính và phương thức thường thuộc về các thể hiện của các lớp, có những trường hợp khi chính một lớp cần giữ các giá trị trong các thuộc tính hoặc cung cấp các phương thức. Chúng được gọi là các thuộc tính và phương thức của
$object = new Foo\Bar[];
echo $object::class;
// Fatal error: Cannot use ::class with dynamic class name.>>> end[explode['\\', get_class[$obj]]];
=> "Project"
$object = new Foo\Bar[];
echo $object::class;
// Fatal error: Cannot use ::class with dynamic class name.$object = new Foo\Bar[];
echo $object::class;
// Fatal error: Cannot use ::class with dynamic class name.>>> end[explode['\\', get_class[$obj]]];
=> "Project"
$object = new Foo\Bar[];
echo $object::class;
// Fatal error: Cannot use ::class with dynamic class name.Các công cụ sửa đổi khả năng hiển thị [
namespace App\Demos;
use Foo\Bar;
use Bar\Baz as BBaz;
class Demo {}
// `use` statement is resolved:
echo Bar::class; // "Foo\Bar"
// `use` X `as` Y is resolved:
echo BBaz::class; // "Bar\Baz"
// Current namespace is resolved:
echo Demo::class; // "App\Demos\Demo"
namespace App\Demos;
use Foo\Bar;
use Bar\Baz as BBaz;
class Demo {}
// `use` statement is resolved:
echo Bar::class; // "Foo\Bar"
// `use` X `as` Y is resolved:
echo BBaz::class; // "Bar\Baz"
// Current namespace is resolved:
echo Demo::class; // "App\Demos\Demo"
namespace App\Demos;
use Foo\Bar;
use Bar\Baz as BBaz;
class Demo {}
// `use` statement is resolved:
echo Bar::class; // "Foo\Bar"
// `use` X `as` Y is resolved:
echo BBaz::class; // "Bar\Baz"
// Current namespace is resolved:
echo Demo::class; // "App\Demos\Demo"Truy cập tĩnh ít phổ biến hơn trong PHP vì nó thường đưa ra các vấn đề tương tự như các biến toàn cục. một lớp có thuộc tính tĩnh về cơ bản giống như một biến toàn cục và có thể khiến bạn rất khó theo dõi nơi nó được thay đổi và nó được đọc từ đâu