Sáng nay, tôi đã đọc một bình luận của một trong những thành viên cộng đồng trực tuyến của chúng tôi thảo luận về một số lý do đằng sau việc áp dụng chậm của PHP 8. Một thành viên tuyên bố rằng đó là do các vấn đề tương thích PHP trong các bản phát hành mới. Ngược lại, một điều khác đặt nó xuống thực tế là phần mềm/khung quan trọng không hỗ trợ Php 8 cho đến gần đây. Tôi nghĩ rằng có sự thật cho cả hai lý do đó và họ gắn kết với nhau.
Php 8 được phát hành vào tháng 11 năm 2020 và tính đến tháng 5 năm 2022, chỉ có khoảng 3% trang web dựa trên PHP hiện đang sử dụng nó! Tuy nhiên, thực sự đã mất rất nhiều phần mềm/khung trong một thời gian dài để đạt được hỗ trợ Full 8 Full, ví dụ, WordPress, Magento, MediaWiki, Joomla và những người khác được Syndesi đề cập. Ngoài ra, trong tương lai, Microsoft sẽ không hỗ trợ PHP 8.
Việc áp dụng chậm của PHP 8. Tại sao?
Có lẽ vòng đời của PHP là quá nhanh để các tổ chức theo kịp? Đó là một trong những câu hỏi xuất hiện trong đầu khi tôi phát hiện ra rằng hơn một nửa số trang web PHP vẫn đang chạy Php 7, điều này mất hỗ trợ bảo mật trong sáu tháng.
Vâng, không thực sự. Nó không chỉ là một vấn đề PHP. Nó trên bảng. Không gian doanh nghiệp ghét nâng cấp và muốn ở lại phiên bản hiện đang được cài đặt càng lâu càng tốt. Đây là một vấn đề mà nhiều người phải đối mặt, từ Windows 8 đến MySQL 8 đến Rhel 8. Có lẽ nó có một cái gì đó về phiên bản ‘8 8 ?? cười lớn
Các công ty ngần ngại nâng cấp cho sự lo lắng về các vấn đề tương thích và gián đoạn dịch vụ, vì vậy họ trì hoãn việc nâng cấp thay thế. Khi việc nâng cấp cấp bách trở nên quan trọng, đó là khi một số công ty và trang web doanh nghiệp nhỏ bắt đầu suy nghĩ về việc nâng cấp. Tuy nhiên, một số chỉ để mọi thứ chạy với các bản phát hành cũ hơn, chậm và kém an toàn hơn khi họ bám vào một số bảo mật được cung cấp bởi backports.
Có một cái nhìn vào:
- 2022 Báo cáo cảnh quan PHP. [PDF]. [PDF]
- Drupal từ Php 8.1 hỗ trợ trong việc lưu trữ và phân phối.
- WordPress Php 8 Thống kê áp dụng.
Tại sao nâng cấp lên Php 8?
Nguồn: Php.Watch/articles/jit-in-depth-Php 8 JIT rất nhanh! php.watch/articles/jit-in-depth – PHP 8’s JIT is fast!
Nếu bạn muốn nâng cấp lên Php 8 ngay bây giờ, hãy đọc điều này: Kiểm tra khả năng tương thích của Php 8.
Php 7 nhanh hơn ít nhất 2 lần so với Php 5.6. Đối với Php 7 so với Php 8, các cải tiến không quyết liệt nhưng dựa trên nhiều điểm chuẩn; Nó & nbsp; quá đủ & nbsp; để được & nbsp; đáng giá. Ngoài tốc độ, PHP 8 còn cung cấp các tính năng mới như trình biên dịch được dự đoán nhiều [JIT] [xem điểm chuẩn trên], tối ưu hóa hiệu suất khác và hỗ trợ JSON tích hợp/cốt lõi, để đặt tên cho một số.
Sự kết luận
Nó rất cần thiết để giữ cho PHP cập nhật từ quan điểm bảo mật. Hiệu suất PHP nhanh hơn có ý nghĩa ngoài bảo mật vì người dùng cuối đang trở nên ít chịu được các trang web và ứng dụng chậm. Theo các điểm chuẩn khác nhau trên web, PHP 8 nhanh hơn đáng kể so với PHP 7. Khi đóng, thời gian để nâng cấp các ứng dụng của bạn lên PHP 8!
Vậy tại sao chỉ có 3% trang web PHP đã cài đặt PHP 8? Vâng, nó đi vào văn hóa của ngành công nghiệp. Nó không chỉ là một vấn đề PHP.
_____
Đây là một bài viết tiếp theo cho 78% web được cung cấp bởi PHP [3% trên Php 8].
Tags: linux, hiệu suất, PHP
Php 8 đã được chính thức phát hành cho tính khả dụng chung vào ngày 26 tháng 11 năm 2020!
Bản cập nhật mới này mang lại nhiều tối ưu hóa và tính năng mạnh mẽ cho ngôn ngữ. Chúng tôi rất vui mừng khi đưa bạn qua những thay đổi thú vị nhất cho phép chúng tôi viết mã tốt hơn và xây dựng các ứng dụng mạnh mẽ hơn.
Bạn đã sẵn sàng chưa? Hãy để lặn xuống!
PHP JIT [chỉ trong trình biên dịch thời gian]
Tính năng được hoan nghênh nhất đi kèm với Php 8 là trình biên dịch chỉ trong thời gian [JIT]. JIT là gì?Just-in-time [JIT] compiler. What is JIT all about?
Đề xuất RFC mô tả JIT như sau:
Php PHP JIT được triển khai như một phần gần như độc lập của Opcache. Nó có thể được bật/tắt tại thời gian biên dịch PHP và thời gian chạy. Khi được bật, mã gốc của các tệp PHP được lưu trữ trong một vùng bổ sung của bộ nhớ chia sẻ opcache và op_array → opcodes []. Handler [s] giữ các con trỏ đến các điểm nhập của mã JIT-ed.
Vì vậy, làm thế nào chúng ta đến với JIT, và sự khác biệt giữa JIT vs Opcache là gì?
Để hiểu rõ hơn về JIT là gì cho PHP, hãy để xem nhanh về cách PHP thực thi mã nguồn đến kết quả cuối cùng.
Việc thực hiện PHP là một quá trình 4 giai đoạn:
- Lexing/tokenizing: Đầu tiên, trình thông dịch đọc mã PHP và xây dựng một bộ mã thông báo.: First, the interpreter reads the PHP code and builds a set of tokens.
- Phân tích cú pháp: Trình thông dịch kiểm tra xem tập lệnh có khớp với các quy tắc cú pháp và sử dụng mã thông báo để xây dựng một cây cú pháp trừu tượng [AST], biểu diễn phân cấp của cấu trúc của mã nguồn.: The interpreter checks if the script matches the syntax rules and uses tokens to build an Abstract Syntax Tree [AST], a hierarchical representation of the structure of source code.
- Biên dịch: Trình thông dịch đi qua cây và dịch các nút AST thành các opcode zend cấp thấp, là các định danh số xác định loại lệnh được thực hiện bởi Zend VM.: The interpreter traverses the tree and translates AST nodes into low-level Zend opcodes, which are numeric identifiers determining the type of instruction performed by the Zend VM.
- Giải thích: Opcodes được giải thích và chạy trên Zend VM.: Opcodes are interpreted and run on the Zend VM.
Hình ảnh sau đây cho thấy một biểu diễn trực quan của quá trình thực hiện PHP cơ bản.
Vì vậy, làm thế nào để opcache làm cho PHP nhanh hơn? Và những thay đổi trong quá trình thực hiện với JIT?
Tiện ích mở rộng opcache
PHP là một ngôn ngữ được giải thích. Điều này có nghĩa là, khi tập lệnh PHP chạy, trình thông dịch phân tích cú pháp, biên dịch và thực thi mã nhiều lần trên mỗi yêu cầu. Điều này có thể dẫn đến lãng phí tài nguyên CPU và thời gian bổ sung.
Đây là nơi tiện ích mở rộng Opcache xuất hiện:
Cấm OPCache cải thiện hiệu suất PHP bằng cách lưu trữ mã byte được biên dịch trước trong bộ nhớ chia sẻ, do đó loại bỏ sự cần thiết của PHP để tải và phân tích các tập lệnh trên mỗi yêu cầu.
Với OPCache được bật, trình thông dịch PHP trải qua quá trình 4 giai đoạn chỉ được đề cập ở trên khi tập lệnh lần đầu tiên chạy. Vì các byte PHP được lưu trữ trong bộ nhớ chia sẻ, chúng ngay lập tức có sẵn dưới dạng biểu diễn trung gian cấp thấp và có thể được thực thi trên Zend VM ngay lập tức.
Kể từ Php 5.5, tiện ích mở rộng Zend Opcache có sẵn theo mặc định và bạn có thể kiểm tra xem bạn có cấu hình chính xác bằng cách gọi
class Test {
// Error: Using null default on non-nullable property
public function __construct[public Type $prop = null] {}
// Correct: Make the type explicitly nullable instead
public function __construct[public ?Type $prop = null] {}
}Đọc đề xuất: Cách cải thiện giới hạn bộ nhớ PHP trong WordPress.
Tải trước
Opcache gần đây đã được cải thiện với việc triển khai tải trước, một tính năng Opcache mới được thêm vào với PHP 7.4. Tải trước cung cấp một cách để lưu trữ một tập hợp các tập lệnh được chỉ định vào bộ nhớ opcache trước khi bất kỳ mã ứng dụng nào được chạy. Tuy nhiên, nó & nbsp; không mang lại sự cải thiện hiệu suất hữu hình cho các ứng dụng dựa trên web điển hình.
Bạn có thể đọc thêm về việc tải trước trong phần giới thiệu của chúng tôi về Php 7.4.
Với JIT, PHP di chuyển một bước về phía trước.
JIT - Trình biên dịch thời gian công bằng
Ngay cả khi các opcodes là đại diện trung gian cấp thấp, chúng vẫn phải được biên dịch thành mã máy. JIT, không giới thiệu bất kỳ biểu mẫu IR [đại diện trung gian] bổ sung nào, nhưng sử dụng Dynasm [trình biên dịch động cho công cụ tạo mã] để tạo mã gốc trực tiếp từ mã byte PHP.
Nói tóm lại, JIT dịch các phần nóng của mã trung gian thành mã máy. Bỏ qua biên dịch, nó có thể mang lại những cải tiến đáng kể trong hiệu suất và sử dụng bộ nhớ.JIT translates the hot parts of the intermediate code into machine code. Bypassing compilation, it’d be able to bring considerable improvements in performance and memory usage.
Zeev Surasky, đồng tác giả của đề xuất PHP JIT, cho thấy mức độ tính toán sẽ nhanh hơn với JIT:
Nhưng, JIT sẽ cải thiện hiệu quả hiệu suất WordPress?
JIT cho các ứng dụng web trực tiếp
Theo JIT RFC, việc triển khai trình biên dịch trong thời gian sẽ cải thiện hiệu suất PHP. Nhưng chúng ta có thực sự trải nghiệm những cải tiến như vậy trong các ứng dụng thực tế như WordPress không?
Các thử nghiệm ban đầu cho thấy JIT sẽ làm cho khối lượng công việc sử dụng nhiều CPU chạy nhanh hơn đáng kể. Tuy nhiên, RFC cảnh báo:
Giống như các nỗ lực trước đây-hiện tại nó dường như không cải thiện đáng kể các ứng dụng thực tế như WordPress [với opcache.jit = 1235 326 req/giây so với 315 req/giây].
Nó đã lên kế hoạch để cung cấp thêm nỗ lực, cải thiện JIT cho các ứng dụng thực tế, sử dụng các hình ảnh định hình và tối ưu hóa đầu cơ.
Với JIT được bật, mã sẽ được chạy bởi Zend VM, nhưng bởi chính CPU, sẽ cải thiện tốc độ tính toán. Các ứng dụng web như WordPress cũng dựa vào các yếu tố khác như TTFB, tối ưu hóa cơ sở dữ liệu, yêu cầu HTTP, v.v.
Vì vậy, chúng ta không nên mong đợi một sự tăng đáng kể về tốc độ thực hiện PHP khi nói đến WordPress và các ứng dụng tương tự. Tuy nhiên, JIT có thể mang lại một số lợi ích cho các nhà phát triển.
Theo Nikita Popov:
Các lợi ích của trình biên dịch JIT là gần như [và như đã được nêu trong RFC]:
- Hiệu suất tốt hơn đáng kể cho mã số.
- Hiệu suất tốt hơn một chút cho mã ứng dụng web PHP điển hình của người dùng.
- Khả năng chuyển nhiều mã hơn từ C sang PHP, vì giờ đây PHP sẽ đủ nhanh.
Vì vậy, trong khi JIT sẽ khó mang lại những cải tiến lớn cho hiệu suất WordPress, thì nó sẽ được nâng cấp PHP lên cấp độ tiếp theo, khiến nó trở thành ngôn ngữ mà nhiều chức năng có thể được viết trực tiếp.
Nhược điểm sẽ là sự phức tạp lớn hơn có thể làm tăng chi phí bảo trì, ổn định và gỡ lỗi. Theo Dmitry Stogov:
JIT JIT cực kỳ đơn giản, nhưng dù sao nó cũng làm tăng mức độ phức tạp của PHP, nguy cơ của loại lỗi mới và chi phí phát triển và bảo trì.
Đề xuất bao gồm JIT trong Php 8 được thông qua với 50 đến 2 phiếu.
Php 8 là ở đây! 🚀 Kiểm tra sâu của chúng tôi vào các tính năng mới! Nhấp để tweetClick to Tweet
Cải tiến Php 8 và các tính năng mới
Ngoài JIT, chúng tôi có thể mong đợi nhiều tính năng và cải tiến với PHP 8. Danh sách sau đây là lựa chọn được lựa chọn cẩn thận của chúng tôi về các bổ sung và thay đổi sắp tới sẽ làm cho PHP đáng tin cậy và hiệu quả hơn.
Thúc đẩy tài sản của nhà xây dựng
Do kết quả của một cuộc thảo luận đang diễn ra về việc cải thiện công thái học đối tượng trong PHP, RFC quảng bá thuộc tính của hàm tạo đề xuất một cú pháp mới và ngắn gọn hơn sẽ đơn giản hóa khai báo tài sản, làm cho nó ngắn hơn và ít dư thừa hơn.
Đề xuất này chỉ liên quan đến các tham số được quảng bá, tức là các tham số phương thức đó có tiền tố với các từ khóa hiển thị công khai, được bảo vệ và khả năng hiển thị riêng tư.promoted parameters, i.e. those method parameters prefixed with public, protected, and private visibility keywords.
Hiện tại, tất cả các thuộc tính phải được lặp lại nhiều lần [ít nhất bốn lần] trước khi chúng ta có thể sử dụng chúng với các đối tượng. Xem xét ví dụ sau từ RFC:
class Point {
public int $x;
public int $y;
public int $z;
public function __construct[
int $x = 0,
int $y = 0,
int $z = 0,
] {
$this->x = $x;
$this->y = $y;
$this->z = $z;
}
}Theo Nikita Popov, tác giả RFC, chúng ta phải viết tên tài sản ít nhất bốn lần ở ba nơi khác nhau: khai báo tài sản, tham số hàm tạo và gán tài sản. Cú pháp này không thể sử dụng được, đặc biệt là trong các lớp có nhiều thuộc tính và tên mô tả hơn.
RFC này đề xuất hợp nhất hàm tạo và định nghĩa tham số. Vì vậy, như của Php 8, chúng tôi có một cách có thể sử dụng nhiều tham số có thể sử dụng. Mã nhìn thấy ở trên có thể thay đổi như hình dưới đây:
class Point {
public function __construct[
public int $x = 0,
public int $y = 0,
public int $z = 0,
] {}
}Và đó là nó. Vì vậy, chúng tôi có một cách mới để thúc đẩy các thuộc tính ngắn hơn, dễ đọc hơn và ít bị lỗi hơn. Theo Nikita:
Nó có một phép biến đổi cú pháp đơn giản mà chúng tôi đang làm. Nhưng điều đó làm giảm lượng mã nồi hơi bạn phải viết cho các đối tượng giá trị cụ thể
Tuyên bố thuộc tính được chuyển đổi khi chúng tôi tuyên bố rõ ràng các thuộc tính đó và chúng tôi có thể sử dụng API phản xạ để định nghĩa thuộc tính hướng nội trước khi thực hiện [xem Desugaring]:
Sự phản ánh [và các cơ chế hướng nội khác] sẽ quan sát trạng thái sau khi đi tiểu. Điều này có nghĩa là các thuộc tính được quảng bá sẽ xuất hiện giống như các thuộc tính được khai báo rõ ràng và các đối số cấu trúc được quảng bá sẽ xuất hiện dưới dạng các đối số cấu trúc thông thường.
// before desugaring
class Point {
public function __construct[public int $x = 0] {}
}
// after desugaring
class Point {
public int $x;
public function __construct[int $x = 0] {
$this->x = $x;
}
}Di sản
Chúng tôi không có bất kỳ hạn chế nào trong việc sử dụng kế thừa kết hợp với các tham số được quảng bá. Dù sao, có một mối quan hệ cụ thể giữa các nhà xây dựng lớp cha và phụ huynh. Theo Nikita:
Thông thường, chúng tôi nói rằng các phương thức luôn phải tương thích với phương pháp cha. [V]] Nhưng quy tắc này không áp dụng cho hàm tạo. Vì vậy, hàm tạo thực sự thuộc về một lớp duy nhất và các hàm tạo giữa cha mẹ và lớp con không phải tương thích theo bất kỳ cách nào.
Đây là một ví dụ:
class Test {
public function __construct[
public int $x = 0
] {}
}
class Child extends Test {
public function __construct[
$x,
public int $y = 0,
public int $z = 0,
] {
parent::__construct[$x];
}
}Những gì không được phép với các thuộc tính được quảng bá
Các thuộc tính được quảng bá được cho phép trong các nhà xây dựng và đặc điểm không phải là Abstract, nhưng có một số hạn chế đáng được đề cập ở đây.
Các nhà xây dựng trừu tượngCác thuộc tính được quảng bá không được phép trong các lớp và giao diện trừu tượng:
abstract class Test {
// Error: Abstract constructor.
abstract public function __construct[private $x];
}
interface Test {
// Error: Abstract constructor.
public function __construct[private $x];
}Một trong những ràng buộc đáng chú ý nhất có liên quan đến khả năng vô hiệu. Trước đây, chúng tôi đã sử dụng một loại không thể tin được. Nhưng với giá trị mặc định null, loại này hoàn toàn không thể vượt qua được. Nhưng với các loại tài sản, chúng tôi không có hành vi ngầm này vì các tham số được quảng bá yêu cầu khai báo tài sản và loại vô hiệu hóa phải được khai báo rõ ràng. Xem ví dụ sau từ RFC:
class Test {
// Error: Using null default on non-nullable property
public function __construct[public Type $prop = null] {}
// Correct: Make the type explicitly nullable instead
public function __construct[public ?Type $prop = null] {}
}Vì có thể gọi không phải là loại được hỗ trợ cho các thuộc tính, chúng tôi không được phép sử dụng loại có thể gọi trong các thuộc tính được quảng bá:
class Test {
// Error: Callable type not supported for properties.
public function __construct[public callable $callback] {}
}Chỉ có thể sử dụng từ khóa hiển thị với các tham số được quảng bá, do đó, việc khai báo các thuộc tính của hàm tạo với từ khóa
class Test {
// Error: Using null default on non-nullable property
public function __construct[public Type $prop = null] {}
// Correct: Make the type explicitly nullable instead
public function __construct[public ?Type $prop = null] {}
}class Test {
// Error: "var" keyword is not supported.
public function __construct[var $prop] {}
}Chúng ta có thể kết hợp các thuộc tính được quảng bá và các thuộc tính rõ ràng trong cùng một lớp, nhưng các thuộc tính không thể được khai báo hai lần:
class Test {
public string $prop;
public int $explicitProp;
// Correct
public function __construct[public int $promotedProp, int $arg] {
$this->explicitProp = $arg;
}
// Error: Redeclaration of property.
public function __construct[public string $prop] {}
}Lý do ở đây là loại được khai báo khác với tham số Variadic, thực sự là một mảng:
class Test {
// Error: Variadic parameter.
public function __construct[public string ...$strings] {}
}Đọc thêm
Để xem gần hơn tại quảng cáo bất động sản của Coststructor, hãy lắng nghe cuộc phỏng vấn này với Nikita Popov. Để biết tổng quan sâu sắc về công thái học đối tượng trong PHP, hãy xem bài đăng này và cuộc phỏng vấn sau đây với Larry Garfield.
Xác nhận các phương pháp tính trạng trừu tượng
Các đặc điểm được định nghĩa là một cơ chế để tái sử dụng mã trong các ngôn ngữ kế thừa duy nhất như PHP. Thông thường, chúng được sử dụng để khai báo các phương thức có thể được sử dụng trong nhiều lớp.
Một đặc điểm cũng có thể chứa các phương pháp trừu tượng. Các phương pháp này chỉ đơn giản là khai báo chữ ký của phương thức, nhưng việc triển khai phương thức phải được thực hiện trong lớp bằng cách sử dụng đặc điểm.
Theo hướng dẫn sử dụng PHP,
Các đặc điểm của người Viking hỗ trợ việc sử dụng các phương pháp trừu tượng để áp đặt các yêu cầu đối với lớp triển lãm.
Điều này cũng có nghĩa là chữ ký của các phương pháp phải khớp. Nói cách khác, loại và số lượng đối số cần thiết cần phải giống nhau.
Dù sao, theo Nikita Popov, tác giả của RFC, xác thực chữ ký hiện chỉ được thi hành một cách vui vẻ:
- Nó không được thực thi trong trường hợp phổ biến nhất, trong đó việc thực hiện phương thức được cung cấp bởi lớp sử dụng: //3v4l.org/sevk3
- Nó được thi hành nếu việc thực hiện đến từ một lớp phụ huynh: //3v4l.org/4vcip
- Nó được thi hành nếu việc thực hiện đến từ một lớp con: //3v4l.org/q7bq2
Ví dụ sau đây từ Nikita liên quan đến trường hợp đầu tiên [không có chữ ký được thực thi]:
class Point {
public function __construct[
public int $x = 0,
public int $y = 0,
public int $z = 0,
] {}
}Với điều đó đã được nói, RFC này đề xuất luôn luôn gây ra lỗi nghiêm trọng nếu phương pháp thực hiện không tương thích với phương pháp tính trạng trừu tượng, bất kể nguồn gốc của nó:
class Point {
public function __construct[
public int $x = 0,
public int $y = 0,
public int $z = 0,
] {}
}RFC này đã được nhất trí chấp thuận.
Chữ ký phương pháp không tương thích
Trong PHP, các lỗi kế thừa do chữ ký phương pháp không tương thích ném lỗi nghiêm trọng hoặc cảnh báo tùy thuộc vào những gì gây ra lỗi.
Nếu một lớp đang thực hiện một giao diện, chữ ký phương pháp không tương thích sẽ ném một lỗi nghiêm trọng. Theo tài liệu giao diện đối tượng:
Lớp thực hiện giao diện phải sử dụng chữ ký phương thức tương thích với LSP [nguyên tắc thay thế Liskov]. Không làm như vậy sẽ dẫn đến một lỗi nghiêm trọng.
Dưới đây là một ví dụ về lỗi kế thừa với giao diện:
class Point {
public function __construct[
public int $x = 0,
public int $y = 0,
public int $z = 0,
] {}
}Trong Php 7.4, mã trên sẽ đưa ra lỗi sau:
class Point {
public function __construct[
public int $x = 0,
public int $y = 0,
public int $z = 0,
] {}
}Một chức năng trong một lớp trẻ có chữ ký không tương thích sẽ đưa ra cảnh báo. Xem mã sau từ RFC:
class Point {
public function __construct[
public int $x = 0,
public int $y = 0,
public int $z = 0,
] {}
}Trong Php 7.4, mã trên chỉ đơn giản là đưa ra cảnh báo:
class Point {
public function __construct[
public int $x = 0,
public int $y = 0,
public int $z = 0,
] {}
}Bây giờ, RFC này đề xuất luôn luôn có một lỗi nghiêm trọng đối với chữ ký phương pháp không tương thích. Với Php 8, mã chúng tôi đã thấy trước đó ở trên sẽ nhắc như sau:
class Point {
public function __construct[
public int $x = 0,
public int $y = 0,
public int $z = 0,
] {}
}Mảng bắt đầu bằng một chỉ số tiêu cực
Trong PHP, nếu một mảng bắt đầu với chỉ số âm [
class Test {
// Error: Using null default on non-nullable property
public function __construct[public Type $prop = null] {}
// Correct: Make the type explicitly nullable instead
public function __construct[public ?Type $prop = null] {}
}class Test {
// Error: Callable type not supported for properties.
public function __construct[public callable $callback] {}
}class Point {
public function __construct[
public int $x = 0,
public int $y = 0,
public int $z = 0,
] {}
}Trong Php 7.4, kết quả sẽ như sau:
class Point {
public function __construct[
public int $x = 0,
public int $y = 0,
public int $z = 0,
] {}
}Bây giờ, RFC này đề xuất thay đổi mọi thứ để chỉ số thứ hai sẽ là
class Test {
// Error: Callable type not supported for properties.
public function __construct[public callable $callback] {}
}class Test {
// Error: Callable type not supported for properties.
public function __construct[public callable $callback] {}
}Trong Php 8, mã trên sẽ dẫn đến mảng sau:
class Point {
public function __construct[
public int $x = 0,
public int $y = 0,
public int $z = 0,
] {}
}Với Php 8, các mảng bắt đầu với một chỉ số tiêu cực thay đổi hành vi của họ. Đọc thêm về sự không tương thích ngược trong RFC.
Liên minh các loại 2.0
Các loại công đoàn chấp nhận các giá trị có thể thuộc các loại khác nhau. Hiện tại, PHP không cung cấp hỗ trợ cho các loại công đoàn, ngoại trừ cú pháp
class Test {
// Error: Callable type not supported for properties.
public function __construct[public callable $callback] {}
}class Test {
// Error: Callable type not supported for properties.
public function __construct[public callable $callback] {}
}Trước PHP 8, các loại liên minh chỉ có thể được chỉ định trong các chú thích PHPDOC, như được hiển thị trong ví dụ sau từ RFC:
// before desugaring
class Point {
public function __construct[public int $x = 0] {}
}
// after desugaring
class Point {
public int $x;
public function __construct[int $x = 0] {
$this->x = $x;
}
}Giờ đây, RFC TYPE 2.0 đề xuất thêm hỗ trợ cho các loại liên minh trong chữ ký chức năng, do đó chúng tôi đã giành được tài liệu dựa trên tài liệu nội tuyến nữa, nhưng sẽ xác định các loại liên minh với cú pháp
class Test {
// Error: Callable type not supported for properties.
public function __construct[public callable $callback] {}
}// before desugaring
class Point {
public function __construct[public int $x = 0] {}
}
// after desugaring
class Point {
public int $x;
public function __construct[int $x = 0] {
$this->x = $x;
}
}Như Nikita Popov đã giải thích trong RFC,
Các loại hỗ trợ liên minh trong ngôn ngữ cho phép chúng tôi chuyển thêm thông tin loại từ PHPDOC sang chữ ký chức năng, với những lợi thế thông thường mà điều này mang lại:
- Các loại thực sự được thực thi, vì vậy những sai lầm có thể bị bắt sớm.
- Bởi vì chúng được thực thi, thông tin loại ít có khả năng trở nên lỗi thời hoặc bỏ lỡ các trường hợp cạnh tranh.
- Các loại được kiểm tra trong quá trình thừa kế, thực thi nguyên tắc thay thế Liskov.
- Các loại có sẵn thông qua phản xạ.
- Cú pháp ít hơn rất nhiều so với phpDoc.
Các loại công đoàn hỗ trợ tất cả các loại có sẵn, với một số hạn chế:
- Loại
6 không thể là một phần của liên minh, vìclass Test { // Error: Callable type not supported for properties. public function __construct[public callable $callback] {} }
6 có nghĩa là một hàm không trả về bất kỳ giá trị nào.class Test { // Error: Callable type not supported for properties. public function __construct[public callable $callback] {} } - Loại
8 chỉ được hỗ trợ trong các loại công đoàn nhưng nó không được phép sử dụng như một loại độc lập.class Test { // Error: Callable type not supported for properties. public function __construct[public callable $callback] {} } - Ký hiệu loại vô hiệu [
9] cũng được phép, có nghĩa làclass Test { // Error: Callable type not supported for properties. public function __construct[public callable $callback] {} }
0, nhưng chúng tôi không được phép đưa ký hiệuclass Test { // Error: "var" keyword is not supported. public function __construct[var $prop] {} }
9 trong các loại liên minh [không được phép và chúng tôi nên sử dụngclass Test { // Error: Callable type not supported for properties. public function __construct[public callable $callback] {} }
3 thay thế].class Test { // Error: "var" keyword is not supported. public function __construct[var $prop] {} } - Vì nhiều chức năng [tức là
4,class Test { // Error: "var" keyword is not supported. public function __construct[var $prop] {} }
5,class Test { // Error: "var" keyword is not supported. public function __construct[var $prop] {} }
6, v.v.] bao gồmclass Test { // Error: "var" keyword is not supported. public function __construct[var $prop] {} }
7 trong số các loại lợi nhuận có thể, loại giả ____77 cũng được hỗ trợ.class Test { // Error: "var" keyword is not supported. public function __construct[var $prop] {} }
Bạn có thể đọc thêm về Liên minh các loại V2 trong RFC.
Lỗi loại nhất quán cho các chức năng nội bộ
Khi chuyển một tham số của loại bất hợp pháp, các chức năng nội bộ và người dùng được xác định là khác nhau.
Các chức năng do người dùng xác định ném
class Test {
// Error: "var" keyword is not supported.
public function __construct[var $prop] {}
}class Test {
// Error: Callable type not supported for properties.
public function __construct[public callable $callback] {}
}// before desugaring
class Point {
public function __construct[public int $x = 0] {}
}
// after desugaring
class Point {
public int $x;
public function __construct[int $x = 0] {
$this->x = $x;
}
}Điều này sẽ dẫn đến cảnh báo sau:
// before desugaring
class Point {
public function __construct[public int $x = 0] {}
}
// after desugaring
class Point {
public int $x;
public function __construct[int $x = 0] {
$this->x = $x;
}
}Nếu
class Test {
public string $prop;
public int $explicitProp;
// Correct
public function __construct[public int $promotedProp, int $arg] {
$this->explicitProp = $arg;
}
// Error: Redeclaration of property.
public function __construct[public string $prop] {}
}class Test {
// Error: "var" keyword is not supported.
public function __construct[var $prop] {}
}Tình huống này sẽ dẫn đến một số vấn đề được giải thích rõ trong phần các vấn đề của RFC.
Để loại bỏ những mâu thuẫn này, RFC này đề xuất tạo API phân tích tham số bên trong để luôn tạo
class Test {
public string $prop;
public int $explicitProp;
// Correct
public function __construct[public int $promotedProp, int $arg] {
$this->explicitProp = $arg;
}
// Error: Redeclaration of property.
public function __construct[public string $prop] {}
}Trong Php 8, mã trên đã đưa ra lỗi sau:
// before desugaring
class Point {
public function __construct[public int $x = 0] {}
}
// after desugaring
class Point {
public int $x;
public function __construct[int $x = 0] {
$this->x = $x;
}
}ném biểu thức
Trong PHP,
class Test {
public string $prop;
public int $explicitProp;
// Correct
public function __construct[public int $promotedProp, int $arg] {
$this->explicitProp = $arg;
}
// Error: Redeclaration of property.
public function __construct[public string $prop] {}
}Bạn muốn biết làm thế nào chúng ta tăng lưu lượng truy cập trên 1000%?
Tham gia với hơn 20.000 người khác nhận được bản tin hàng tuần của chúng tôi với các mẹo nội bộ WordPress!
Theo dõi ngay
RFC này đề xuất chuyển đổi câu lệnh
class Test {
public string $prop;
public int $explicitProp;
// Correct
public function __construct[public int $promotedProp, int $arg] {
$this->explicitProp = $arg;
}
// Error: Redeclaration of property.
public function __construct[public string $prop] {}
}Xem các ví dụ sau từ RFC:
// before desugaring
class Point {
public function __construct[public int $x = 0] {}
}
// after desugaring
class Point {
public int $x;
public function __construct[int $x = 0] {
$this->x = $x;
}
}Bản đồ yếu
Bản đồ yếu là một tập hợp các dữ liệu [đối tượng] trong đó các khóa được tham chiếu yếu, có nghĩa là chúng không bị ngăn không được thu thập rác.
Php 7.4 đã thêm hỗ trợ cho các tài liệu tham khảo yếu như một cách để giữ lại một tham chiếu đến một đối tượng không ngăn cản chính đối tượng bị phá hủy. Như Nikita Popov đã chỉ ra,
Các tài liệu tham khảo yếu của RAW chỉ là tính hữu dụng hạn chế của chính chúng và các bản đồ yếu được sử dụng phổ biến hơn nhiều trong thực tế. Không thể thực hiện một bản đồ yếu hiệu quả trên đầu các tài liệu tham khảo yếu PHP vì khả năng đăng ký một cuộc gọi lại phá hủy không được cung cấp.
Đó là lý do tại sao RFC này giới thiệu một lớp
class Test {
public string $prop;
public int $explicitProp;
// Correct
public function __construct[public int $promotedProp, int $arg] {
$this->explicitProp = $arg;
}
// Error: Redeclaration of property.
public function __construct[public string $prop] {}
}Trong các quy trình chạy dài, điều này sẽ ngăn chặn rò rỉ bộ nhớ và cải thiện hiệu suất. & NBSP; xem ví dụ sau từ RFC:
// before desugaring
class Point {
public function __construct[public int $x = 0] {}
}
// after desugaring
class Point {
public int $x;
public function __construct[int $x = 0] {
$this->x = $x;
}
}Với Php 8, mã trên sẽ tạo ra kết quả sau [xem mã đang hoạt động ở đây]:
// before desugaring
class Point {
public function __construct[public int $x = 0] {}
}
// after desugaring
class Point {
public int $x;
public function __construct[int $x = 0] {
$this->x = $x;
}
}Nếu bạn giải quyết đối tượng, khóa sẽ tự động bị xóa khỏi bản đồ yếu:
// before desugaring
class Point {
public function __construct[public int $x = 0] {}
}
// after desugaring
class Point {
public int $x;
public function __construct[int $x = 0] {
$this->x = $x;
}
}Bây giờ kết quả sẽ là như sau:
// before desugaring
class Point {
public function __construct[public int $x = 0] {}
}
// after desugaring
class Point {
public int $x;
public function __construct[int $x = 0] {
$this->x = $x;
}
}Để xem xét kỹ hơn các bản đồ yếu, hãy xem RFC. Đề xuất đã được nhất trí phê duyệt.
Danh sách dấu phẩy trong danh sách tham số
Dấu phẩy là dấu phẩy được thêm vào danh sách các mục trong các bối cảnh khác nhau. Php 7.2 đã giới thiệu dấu phẩy kéo dài trong cú pháp danh sách, Php 7.3 đã giới thiệu dấu phẩy kéo dài trong các cuộc gọi chức năng.
Php 8 hiện giới thiệu dấu phẩy trong danh sách tham số với các hàm, phương thức và đóng, như được hiển thị trong ví dụ sau:
class Test {
public function __construct[
public int $x = 0
] {}
}
class Child extends Test {
public function __construct[
$x,
public int $y = 0,
public int $z = 0,
] {
parent::__construct[$x];
}
}Đề xuất này được thông qua với 58 đến 1 phiếu bầu.
Cho phép :: Lớp cú pháp trên các đối tượng
Để tìm nạp tên của một lớp, chúng ta có thể sử dụng cú pháp
class Test {
public string $prop;
public int $explicitProp;
// Correct
public function __construct[public int $promotedProp, int $arg] {
$this->explicitProp = $arg;
}
// Error: Redeclaration of property.
public function __construct[public string $prop] {}
}class Test {
public function __construct[
public int $x = 0
] {}
}
class Child extends Test {
public function __construct[
$x,
public int $y = 0,
public int $z = 0,
] {
parent::__construct[$x];
}
}Với Php 8,
class Test {
public string $prop;
public int $explicitProp;
// Correct
public function __construct[public int $promotedProp, int $arg] {
$this->explicitProp = $arg;
}
// Error: Redeclaration of property.
public function __construct[public string $prop] {}
}class Test {
public string $prop;
public int $explicitProp;
// Correct
public function __construct[public int $promotedProp, int $arg] {
$this->explicitProp = $arg;
}
// Error: Redeclaration of property.
public function __construct[public string $prop] {}
}class Test {
// Error: Variadic parameter.
public function __construct[public string ...$strings] {}
}class Test {
// Error: "var" keyword is not supported.
public function __construct[var $prop] {}
}Đề xuất này đã được nhất trí phê duyệt.
Thuộc tính v2
Các thuộc tính, còn được gọi là các chú thích, được cấu trúc siêu dữ liệu có thể được sử dụng để chỉ định các thuộc tính cho các đối tượng, phần tử hoặc tệp.
Cho đến Php 7.4, các phân loại doc là cách duy nhất để thêm siêu dữ liệu vào các khai báo của các lớp, chức năng, v.v. Thuộc tính, chức năng, phương thức, tham số và hằng số.
Các thuộc tính được thêm vào trước khi khai báo mà họ đề cập đến. Xem các ví dụ sau từ RFC:
class Test {
public function __construct[
public int $x = 0
] {}
}
class Child extends Test {
public function __construct[
$x,
public int $y = 0,
public int $z = 0,
] {
parent::__construct[$x];
}
}Các thuộc tính có thể được thêm vào trước hoặc sau khi nhận xét khối tài liệu:
class Test {
public function __construct[
public int $x = 0
] {}
}
class Child extends Test {
public function __construct[
$x,
public int $y = 0,
public int $z = 0,
] {
parent::__construct[$x];
}
}Mỗi khai báo có thể có một hoặc nhiều thuộc tính và mỗi thuộc tính có thể có một hoặc nhiều giá trị liên quan:
class Test {
public function __construct[
public int $x = 0
] {}
}
class Child extends Test {
public function __construct[
$x,
public int $y = 0,
public int $z = 0,
] {
parent::__construct[$x];
}
}Xem RFC để biết tổng quan sâu hơn về các thuộc tính PHP, trường hợp sử dụng và cú pháp thay thế.
Có tên là đối số
Các đối số được đặt tên cung cấp một cách mới để chuyển các đối số cho một hàm trong PHP:
Các đối số được đặt tên cho phép chuyển các đối số đến một hàm dựa trên tên tham số, thay vì vị trí tham số.
Chúng ta có thể chuyển các đối số được đặt tên cho một hàm bằng cách thêm tên tham số trước giá trị của nó:
class Test {
public function __construct[
public int $x = 0
] {}
}
class Child extends Test {
public function __construct[
$x,
public int $y = 0,
public int $z = 0,
] {
parent::__construct[$x];
}
}Chúng tôi cũng được phép sử dụng các từ khóa dành riêng, như được hiển thị trong ví dụ dưới đây:
class Test {
public function __construct[
public int $x = 0
] {}
}
class Child extends Test {
public function __construct[
$x,
public int $y = 0,
public int $z = 0,
] {
parent::__construct[$x];
}
}Nhưng chúng tôi không được phép truyền một tên tham số một cách linh hoạt. Tham số phải là một định danh và không cho phép cú pháp sau:the following syntax is not allowed:
class Test {
public function __construct[
public int $x = 0
] {}
}
class Child extends Test {
public function __construct[
$x,
public int $y = 0,
public int $z = 0,
] {
parent::__construct[$x];
}
}Theo Nikita Popov, tác giả của RFC này, được đặt tên là đối số cung cấp một số lợi thế.
Trước hết, các đối số được đặt tên sẽ giúp chúng tôi viết mã dễ hiểu hơn vì ý nghĩa của chúng là tự ghi chép. Ví dụ dưới đây từ RFC là tự giải thích:
class Test {
public function __construct[
public int $x = 0
] {}
}
class Child extends Test {
public function __construct[
$x,
public int $y = 0,
public int $z = 0,
] {
parent::__construct[$x];
}
}Các đối số được đặt tên là độc lập theo thứ tự. Điều này có nghĩa là chúng ta không bị buộc phải chuyển các đối số cho một hàm theo cùng thứ tự với chữ ký hàm:
class Test {
public function __construct[
public int $x = 0
] {}
}
class Child extends Test {
public function __construct[
$x,
public int $y = 0,
public int $z = 0,
] {
parent::__construct[$x];
}
}Nó cũng có thể kết hợp các đối số được đặt tên với các đối số vị trí:
abstract class Test {
// Error: Abstract constructor.
abstract public function __construct[private $x];
}
interface Test {
// Error: Abstract constructor.
public function __construct[private $x];
}Một lợi thế lớn khác của các đối số được đặt tên là chúng chỉ cho phép chỉ định những đối số mà chúng tôi muốn thay đổi. Chúng tôi không phải chỉ định các đối số mặc định nếu chúng tôi không muốn ghi đè lên các giá trị mặc định. Ví dụ sau từ RFC cho thấy rõ:
abstract class Test {
// Error: Abstract constructor.
abstract public function __construct[private $x];
}
interface Test {
// Error: Abstract constructor.
public function __construct[private $x];
}Các đối số được đặt tên có thể được sử dụng với các thuộc tính PHP, như được hiển thị trong ví dụ sau từ RFC:
abstract class Test {
// Error: Abstract constructor.
abstract public function __construct[private $x];
}
interface Test {
// Error: Abstract constructor.
public function __construct[private $x];
}Tuy nhiên, việc truyền đối số vị trí sau khi các đối số được đặt tên không được phép và sẽ dẫn đến lỗi thời gian biên dịch. Điều tương tự xảy ra khi bạn vượt qua cùng một tên tham số hai lần.
Các đối số được đặt tên là tiện dụng với các tuyên bố của lớp vì các nhà xây dựng thường có nhiều tham số và các đối số được đặt tên cung cấp một cách sử dụng nhiều hơn để khai báo một lớp.
Để xem gần hơn tại các đối số được đặt tên, với các ràng buộc, sự không tương thích ngược và một số ví dụ, xem các đối số được đặt tên RFC.
Nhà điều hành Nullsafe
RFC này giới thiệu toán tử nullsafe
class Test {
// Error: Variadic parameter.
public function __construct[public string ...$strings] {}
}Trong đánh giá ngắn mạch, toán tử thứ hai chỉ được đánh giá nếu toán tử thứ nhất không đánh giá thành
class Test {
// Error: Callable type not supported for properties.
public function __construct[public callable $callback] {}
}class Test {
// Error: Callable type not supported for properties.
public function __construct[public callable $callback] {}
}class Test {
// Error: Callable type not supported for properties.
public function __construct[public callable $callback] {}
}Xem xét các ví dụ sau từ RFC:
abstract class Test {
// Error: Abstract constructor.
abstract public function __construct[private $x];
}
interface Test {
// Error: Abstract constructor.
public function __construct[private $x];
}Nếu
class Test {
// Error: Variadic parameter.
public function __construct[public string ...$strings] {}
}class Test {
// Error: Variadic parameter.
public function __construct[public string ...$strings] {}
}class Test {
// Error: Variadic parameter.
public function __construct[public string ...$strings] {}
}class Test {
// Error: Callable type not supported for properties.
public function __construct[public callable $callback] {}
}Xem RFC toán tử Nullsafe để biết các ví dụ, ngoại lệ và phạm vi trong tương lai.
Chuỗi saner để so sánh số
Trong các phiên bản PHP trước đây, khi thực hiện so sánh không nghiêm trọng giữa các chuỗi và số, PHP trước tiên đưa chuỗi vào một số, sau đó thực hiện so sánh giữa số nguyên hoặc phao. Ngay cả khi hành vi này khá hữu ích trong một số kịch bản, nó có thể tạo ra kết quả sai cũng có thể dẫn đến lỗi và/hoặc các vấn đề bảo mật.
Xem xét ví dụ sau từ RFC:
abstract class Test {
// Error: Abstract constructor.
abstract public function __construct[private $x];
}
interface Test {
// Error: Abstract constructor.
public function __construct[private $x];
}Php 8 giới thiệu chuỗi saner để so sánh số, nhằm mục đích làm cho chuỗi để so sánh số hợp lý hơn. Theo lời của Nikita Popov,
RFC này dự định sẽ cung cấp cho chuỗi để so sánh số một hành vi hợp lý hơn: khi so sánh với một chuỗi số, hãy sử dụng so sánh số [giống như bây giờ]. Mặt khác, chuyển đổi số thành chuỗi và sử dụng so sánh chuỗi.
Bảng sau so sánh hành vi của chuỗi với số so sánh số phiên bản PHP trước đó và trong Php 8:
abstract class Test {
// Error: Abstract constructor.
abstract public function __construct[private $x];
}
interface Test {
// Error: Abstract constructor.
public function __construct[private $x];
}Đọc thêm về nhiều ý nghĩa của thay đổi này và cách so sánh chuỗi với số thay đổi trong Php 8 trong RFC chính thức từ Nikita Popov.
Chuỗi số saner
Trong PHP, các chuỗi chứa số lượng thuộc ba loại:
- Chuỗi số: Chuỗi chứa một số tùy chọn đi trước không gian trắng.: strings containing a number optionally preceded by whitespaces.
- Chuỗi hàng đầu-Numeric: Các chuỗi có ký tự ban đầu là chuỗi số và ký tự dấu vết không phải là người.: strings whose initial characters are numeric strings and trailing characters are non-numeric.
- Chuỗi không phải là số: Các chuỗi không rơi vào cả hai loại trước đó.: strings not falling in neither of the previous categories.
Các chuỗi số và chuỗi hàng đầu được xử lý khác nhau tùy thuộc vào hoạt động được thực hiện. Ví dụ:
- Chuỗi rõ ràng sang chuyển đổi số [nghĩa là
00 vàclass Point { public function __construct[ public int $x = 0, public int $y = 0, public int $z = 0, ] {} }
01 CASTS] Chuyển đổi số chuỗi số và hàng đầu. Chuyển đổi rõ ràng một chuỗi không phải là số thành một số tạo ra 0. [i.e.class Point { public function __construct[ public int $x = 0, public int $y = 0, public int $z = 0, ] {} }
00 andclass Point { public function __construct[ public int $x = 0, public int $y = 0, public int $z = 0, ] {} }
01 type casts] convert numeric and leading-numeric strings numbers. Explicitly converting a non-numeric string to a number produces 0.class Point { public function __construct[ public int $x = 0, public int $y = 0, public int $z = 0, ] {} } - Chuỗi ẩn sang chuyển đổi số [nghĩa là không khai báo ____102] dẫn đến các kết quả khác nhau cho các chuỗi số và không số. Chuỗi không phải là số chuyển đổi số ném
9. [i.e. noclass Test { // Error: "var" keyword is not supported. public function __construct[var $prop] {} }
02 declaration] lead to different results for numeric and non-numeric strings. Non-numeric string to number conversions throw aclass Point { public function __construct[ public int $x = 0, public int $y = 0, public int $z = 0, ] {} }
9.class Test { // Error: "var" keyword is not supported. public function __construct[var $prop] {} }
04 trả về chỉ đúng cho các chuỗi số.true only for numeric strings.class Point { public function __construct[ public int $x = 0, public int $y = 0, public int $z = 0, ] {} }
Chuỗi bù, các hoạt động số học, hoạt động tăng và giảm, so sánh chuỗi và chuỗi và các hoạt động bitwise cũng dẫn đến các kết quả khác nhau.
RFC này đề xuất:
Hợp nhất các chế độ chuỗi số khác nhau thành một khái niệm duy nhất: các ký tự số chỉ với cả khoảng trắng dẫn và dấu vết cho phép. Bất kỳ loại chuỗi nào khác là không phải là số và sẽ ném các kiểu mẫu khi được sử dụng trong bối cảnh số.
Điều này có nghĩa là, tất cả các chuỗi hiện đang phát ra giá trị số không được hình thành tốt mà gặp phải sẽ được phân loại lại thành E_Warning, một giá trị không phải là số người gặp phải, trừ khi chuỗi hàng đầu chỉ chứa khoảng trắng. Và các trường hợp khác nhau hiện đang phát ra một e_warning sẽ được quảng bá lên
9s.E_NOTICE “A non well formed numeric value encountered” will be reclassified into the E_WARNING “A non-numeric value encountered” except if the leading-numeric string contained only trailing whitespace. And the various cases which currently emit an E_WARNING will be promoted toclass Test { // Error: "var" keyword is not supported. public function __construct[var $prop] {} }9s.class Test { // Error: "var" keyword is not supported. public function __construct[var $prop] {} }
Để biết tổng quan sâu sắc hơn về các chuỗi số trong PHP 8, với các ví dụ mã, ngoại lệ và các vấn đề tương thích ngược, hãy xem RFC.
Khớp biểu thức v2
Biểu thức
class Point {
public function __construct[
public int $x = 0,
public int $y = 0,
public int $z = 0,
] {}
}class Point {
public function __construct[
public int $x = 0,
public int $y = 0,
public int $z = 0,
] {}
}Để hiểu sự khác biệt giữa hai cấu trúc điều khiển, hãy xem xét ví dụ
class Point {
public function __construct[
public int $x = 0,
public int $y = 0,
public int $z = 0,
] {}
}abstract class Test {
// Error: Abstract constructor.
abstract public function __construct[private $x];
}
interface Test {
// Error: Abstract constructor.
public function __construct[private $x];
}Bây giờ chúng ta có thể nhận được kết quả tương tự như mã ở trên với biểu thức
class Point {
public function __construct[
public int $x = 0,
public int $y = 0,
public int $z = 0,
] {}
}abstract class Test {
// Error: Abstract constructor.
abstract public function __construct[private $x];
}
interface Test {
// Error: Abstract constructor.
public function __construct[private $x];
}Một lợi thế đáng kể của việc sử dụng biểu thức
class Point {
public function __construct[
public int $x = 0,
public int $y = 0,
public int $z = 0,
] {}
}class Point {
public function __construct[
public int $x = 0,
public int $y = 0,
public int $z = 0,
] {}
}class Point {
public function __construct[
public int $x = 0,
public int $y = 0,
public int $z = 0,
] {}
}class Point {
public function __construct[
public int $x = 0,
public int $y = 0,
public int $z = 0,
] {}
}class Point {
public function __construct[
public int $x = 0,
public int $y = 0,
public int $z = 0,
] {}
}Biểu thức
class Point {
public function __construct[
public int $x = 0,
public int $y = 0,
public int $z = 0,
] {}
}abstract class Test {
// Error: Abstract constructor.
abstract public function __construct[private $x];
}
interface Test {
// Error: Abstract constructor.
public function __construct[private $x];
}Để biết các ví dụ và trường hợp sử dụng bổ sung, hãy xem biểu thức Match V2 RFC và tài liệu PHP.
Kiểm tra loại chặt chẽ hơn cho các toán tử số học/bitwise
Trong các phiên bản PHP trước đây, việc áp dụng các toán tử số học và bitwise cho một mảng, tài nguyên hoặc đối tượng không quá tải đã được cho phép. Dù sao, hành vi đôi khi không nhất quán.
Trong RFC này, Nikita Popov cho thấy hành vi đó có thể không hợp lý đến mức nào với một ví dụ đơn giản:
abstract class Test {
// Error: Abstract constructor.
abstract public function __construct[private $x];
}
interface Test {
// Error: Abstract constructor.
public function __construct[private $x];
}Nikita giải thích cách áp dụng toán tử số học hoặc bitwise cho các mảng, tài nguyên hoặc các đối tượng không quá tải dẫn đến các kết quả khác nhau:
Toán tử +, -, *, /, **:
- Ném lỗi ngoại lệ trên toán hạng mảng. [Không bao gồm + nếu cả hai toán hạng là mảng.]
- Tiết âm chuyển đổi một toán hạng tài nguyên thành ID tài nguyên dưới dạng số nguyên.
- Chuyển đổi một toán hạng đối tượng thành số nguyên, trong khi ném thông báo.
Người vận hành %,, &, |, ^:
- Âm thầm chuyển đổi một toán hạng mảng thành số nguyên 0 nếu trống hoặc số nguyên nếu không trống.
- Tiết âm chuyển đổi một toán hạng tài nguyên thành ID tài nguyên dưới dạng số nguyên.
- Chuyển đổi một toán hạng đối tượng thành số nguyên, trong khi ném thông báo.
Người vận hành %,, &, |, ^:
- Âm thầm chuyển đổi một toán hạng mảng thành số nguyên 0 nếu trống hoặc số nguyên nếu không trống.
Nhà điều hành ~:
- Ném một ngoại lệ lỗi cho các toán hạng mảng, tài nguyên và đối tượng.
Người vận hành ++ và -:
Âm thầm không làm gì nếu toán hạng là một mảng, tài nguyên hoặc đối tượng.
Với Php 8, mọi thứ thay đổi và hành vi giống nhau cho tất cả các toán tử số học và bitwise:
Ném ngoại lệ
class Test {
// Error: "var" keyword is not supported.
public function __construct[var $prop] {}
}str_contains
Chức năng PHP mới
class Test {
// Error: Using null default on non-nullable property
public function __construct[public Type $prop = null] {}
// Correct: Make the type explicitly nullable instead
public function __construct[public ?Type $prop = null] {}
}Php 8 mang đến một số chức năng mới cho ngôn ngữ:
Trước Php 8, Strstr và Strpos là các tùy chọn điển hình cho các nhà phát triển tìm kiếm một kim bên trong một chuỗi nhất định. Vấn đề là cả hai chức năng đều được coi là rất trực quan và việc sử dụng của họ có thể gây nhầm lẫn cho các nhà phát triển PHP mới. Xem ví dụ sau:FALSE, but may also return a non-Boolean value which evaluates to FALSE. […] Use the === operator for testing the return value of this function.”
Trong ví dụ trên, chúng tôi đã sử dụng toán tử so sánh
class Point {
public function __construct[
public int $x = 0,
public int $y = 0,
public int $z = 0,
] {}
}Chức năng này có thể trả về Boolean Sai, nhưng cũng có thể trả về giá trị phi Boolean đánh giá là sai. [Mạnh] Sử dụng toán tử === để kiểm tra giá trị trả về của hàm này.
class Test {
// Error: Using null default on non-nullable property
public function __construct[public Type $prop = null] {}
// Correct: Make the type explicitly nullable instead
public function __construct[public ?Type $prop = null] {}
}Hơn nữa, một số khung cung cấp các hàm trợ giúp để tìm kiếm một giá trị bên trong một chuỗi đã cho [xem tài liệu Trợ lý Laravel làm ví dụ].
Bây giờ, RFC này đề xuất giới thiệu một chức năng mới cho phép tìm kiếm bên trong một chuỗi:
class Point {
public function __construct[
public int $x = 0,
public int $y = 0,
public int $z = 0,
] {}
}class Test {
// Error: Using null default on non-nullable property
public function __construct[public Type $prop = null] {}
// Correct: Make the type explicitly nullable instead
public function __construct[public ?Type $prop = null] {}
}Việc sử dụng của nó là khá đơn giản.
class Point {
public function __construct[
public int $x = 0,
public int $y = 0,
public int $z = 0,
] {}
}class Point {
public function __construct[
public int $x = 0,
public int $y = 0,
public int $z = 0,
] {}
}class Point {
public function __construct[
public int $x = 0,
public int $y = 0,
public int $z = 0,
] {}
}class Point {
public function __construct[
public int $x = 0,
public int $y = 0,
public int $z = 0,
] {}
}class Test {
// Error: "var" keyword is not supported.
public function __construct[var $prop] {}
}At the time of this writing,
class Point {
public function __construct[
public int $x = 0,
public int $y = 0,
public int $z = 0,
] {}
}Vì vậy, nhờ
class Point {
public function __construct[
public int $x = 0,
public int $y = 0,
public int $z = 0,
] {}
}Mà dễ đọc hơn và ít dễ bị lỗi hơn [xem mã này đang hoạt động ở đây]. Tại thời điểm viết bài này, class Point {
public function __construct[
public int $x = 0,
public int $y = 0,
public int $z = 0,
] {}
}
18 nhạy cảm với trường hợp, nhưng điều này có thể thay đổi trong tương lai.
class Point {
public function __construct[
public int $x = 0,
public int $y = 0,
public int $z = 0,
] {}
}Ngoài hàm
class Point {
public function __construct[
public int $x = 0,
public int $y = 0,
public int $z = 0,
] {}
}class Point {
public function __construct[
public int $x = 0,
public int $y = 0,
public int $z = 0,
] {}
}class Point {
public function __construct[
public int $x = 0,
public int $y = 0,
public int $z = 0,
] {}
}Các chức năng mới này kiểm tra xem một chuỗi đã cho bắt đầu hoặc kết thúc bằng một chuỗi khác:
class Test {
// Error: Using null default on non-nullable property
public function __construct[public Type $prop = null] {}
// Correct: Make the type explicitly nullable instead
public function __construct[public ?Type $prop = null] {}
}Cả hai chức năng trả về
class Test {
// Error: "var" keyword is not supported.
public function __construct[var $prop] {}
}class Point {
public function __construct[
public int $x = 0,
public int $y = 0,
public int $z = 0,
] {}
}class Point {
public function __construct[
public int $x = 0,
public int $y = 0,
public int $z = 0,
] {}
}Theo Will Hudgins, tác giả của RFC này,
Chức năng
28 vàclass Point { public function __construct[ public int $x = 0, public int $y = 0, public int $z = 0, ] {} }29 thường rất cần thiết đến nỗi nhiều khung PHP chính hỗ trợ nó, bao gồm Symfony, Laravel, YII, Fuelphp và Phalcon.class Point { public function __construct[ public int $x = 0, public int $y = 0, public int $z = 0, ] {} }
Nhờ họ, giờ đây chúng tôi có thể tránh sử dụng các hàm dưới tối ưu và ít trực quan hơn như
class Point {
public function __construct[
public int $x = 0,
public int $y = 0,
public int $z = 0,
] {}
}class Test {
// Error: Using null default on non-nullable property
public function __construct[public Type $prop = null] {}
// Correct: Make the type explicitly nullable instead
public function __construct[public ?Type $prop = null] {}
}Bạn có thể thấy mã này hoạt động ở đây.
RFC này đã được phê duyệt với 51 đến 4 phiếu.
get_debug_type
class Point {
public function __construct[
public int $x = 0,
public int $y = 0,
public int $z = 0,
] {}
}class Point {
public function __construct[
public int $x = 0,
public int $y = 0,
public int $z = 0,
] {}
}class Point {
public function __construct[
public int $x = 0,
public int $y = 0,
public int $z = 0,
] {}
}Đó là một cải tiến tốt cho ngôn ngữ, vì
class Point {
public function __construct[
public int $x = 0,
public int $y = 0,
public int $z = 0,
] {}
}RFC cung cấp hai ví dụ hữu ích để hiểu sự khác biệt giữa hàm
class Point {
public function __construct[
public int $x = 0,
public int $y = 0,
public int $z = 0,
] {}
}class Point {
public function __construct[
public int $x = 0,
public int $y = 0,
public int $z = 0,
] {}
}class Point {
public function __construct[
public int $x = 0,
public int $y = 0,
public int $z = 0,
] {}
}class Test {
// Error: Using null default on non-nullable property
public function __construct[public Type $prop = null] {}
// Correct: Make the type explicitly nullable instead
public function __construct[public ?Type $prop = null] {}
}Với Php 8, chúng ta có thể sử dụng
class Point {
public function __construct[
public int $x = 0,
public int $y = 0,
public int $z = 0,
] {}
}class Test {
// Error: Using null default on non-nullable property
public function __construct[public Type $prop = null] {}
// Correct: Make the type explicitly nullable instead
public function __construct[public ?Type $prop = null] {}
}Bảng sau đây cho thấy các giá trị trả về
class Point {
public function __construct[
public int $x = 0,
public int $y = 0,
public int $z = 0,
] {}
}class Point {
public function __construct[
public int $x = 0,
public int $y = 0,
public int $z = 0,
] {}
}| 1 | Số nguyên | int |
| 0.1 | kép | trôi nổi |
| thật | Boolean | bool |
| sai | Boolean | bool |
| sai | vô giá trị | sai |
| vô giá trị | VÔ GIÁ TRỊ | VÔ GIÁ TRỊ |
| "WordPress" | sợi dây | sợi dây |
| [1,2,3] | mảng | Một lớp có tên là Foo Foo \ Bar |
| sự vật | mảng | Một lớp có tên là Foo Foo \ Bar |
sự vật
Foo \ bar
- Một lớp ẩn danh: this RFC introduces a Stringable interface that is automatically added to classes implementing the
47 method. The main goal here is to use theclass Point { public function __construct[ public int $x = 0, public int $y = 0, public int $z = 0, ] {} }
48 union type.class Point { public function __construct[ public int $x = 0, public int $y = 0, public int $z = 0, ] {} } - [Email & NBSP; được bảo vệ]: this RFC proposes to implement the current DOM Living Standard to the PHP DOM extension by introducing new interfaces and public properties.
- RFC bổ sung:
PHP 8 introduces the usage of
49 as return type next toclass Point { public function __construct[ public int $x = 0, public int $y = 0, public int $z = 0, ] {} }
50 andclass Point { public function __construct[ public int $x = 0, public int $y = 0, public int $z = 0, ] {} }
51 types.class Point { public function __construct[ public int $x = 0, public int $y = 0, public int $z = 0, ] {} } - Dưới đây là danh sách nhanh các cải tiến được phê duyệt bổ sung đến với Php 8:: this RFC resolves some residual inconsistencies in PHP’s variable syntax.
Giao diện Stringable: RFC này giới thiệu một giao diện có thể chuỗi được tự động thêm vào các lớp thực hiện phương thức class Point {
public function __construct[
public int $x = 0,
public int $y = 0,
public int $z = 0,
] {}
}
47. Mục tiêu chính ở đây là sử dụng loại Liên minh class Point {
public function __construct[
public int $x = 0,
public int $y = 0,
public int $z = 0,
] {}
}
48.
class Point {
public function __construct[
public int $x = 0,
public int $y = 0,
public int $z = 0,
] {}
}class Point {
public function __construct[
public int $x = 0,
public int $y = 0,
public int $z = 0,
] {}
}API tiêu chuẩn DOM Living mới trong ext/DOM: RFC này đề xuất triển khai tiêu chuẩn DOM hiện tại cho phần mở rộng PHP DOM bằng cách giới thiệu các giao diện mới và các thuộc tính công cộng.
Loại trả về tĩnh: Php 8 giới thiệu việc sử dụng
class Point {
public function __construct[
public int $x = 0,
public int $y = 0,
public int $z = 0,
] {}
}class Point {
public function __construct[
public int $x = 0,
public int $y = 0,
public int $z = 0,
] {}
}class Point {
public function __construct[
public int $x = 0,
public int $y = 0,
public int $z = 0,
] {}
}Điểm chuẩn hiệu suất của PHP 818.4% more requests per second than PHP 7.4. Likewise, Laravel on PHP 8.0 can run 8.5% more requests per second than PHP 7.3.
Nếu bạn đang tự hỏi Php 8 nhanh như thế nào, chúng tôi có câu trả lời. Chúng tôi đã đánh giá 20 nền tảng/cấu hình PHP trên 7 phiên bản PHP khác nhau [5.6, 7.0, 7.1, 7.2, 7.3 và 8.0].
Php 8.0 nổi lên như người chiến thắng trong hầu hết các nền tảng hỗ trợ nó, bao gồm WordPress và Laravel.
Biên dịch điểm chuẩn PHP của các nền tảng hàng đầuClick to Tweet
Chẳng hạn, WordPress trên PHP 8.0 có thể xử lý thêm 18,4% yêu cầu mỗi giây so với Php 7.4. Tương tự như vậy, Laravel trên PHP 8.0 có thể chạy thêm 8,5% yêu cầu mỗi giây so với Php 7.3.
Nếu trang web hoặc ứng dụng của bạn tương thích hoàn toàn với PHP 8.0, bạn nên lên kế hoạch cập nhật môi trường máy chủ của bạn lên Php 8.0 càng sớm càng tốt. Bạn [và người dùng của bạn] chắc chắn sẽ đánh giá cao lợi ích hiệu suất của nó. Tuy nhiên, vui lòng kiểm tra trang web của bạn kỹ lưỡng trước khi cập nhật.
Bạn có thể đọc bài viết điểm chuẩn PHP của chúng tôi để biết thêm thông tin, chẳng hạn như dữ liệu hiệu suất chi tiết, hiểu biết và đồ thị đẹp!
Php 8 đã được phát hành cho GA và mang lại nhiều tối ưu hóa và tính năng cho ngôn ngữ. 🚀 Kiểm tra lần lặn sâu của chúng tôi vào Php 8! Nhấp để tweet
Bản tóm tắt
- Thật là một chuyến đi! Trong bài đăng này, chúng tôi đã đề cập đến các tối ưu hóa và tính năng thú vị nhất đi kèm với PHP 8. trong số đó được chờ đợi nhất chắc chắn là trình biên dịch thời gian, nhưng có rất nhiều điều với PHP 8.
- Hãy chắc chắn để đánh dấu bài đăng trên blog này để tham khảo trong tương lai của bạn. 🤓
- Bây giờ đến lượt của bạn: Bạn đã sẵn sàng để kiểm tra các tính năng PHP mới chưa? cái nào là sở thích của bạn? Thả một dòng trong phần bình luận dưới đây.
- Tiết kiệm thời gian, chi phí và tối đa hóa hiệu suất trang web với:
Trợ giúp ngay lập tức từ các chuyên gia lưu trữ WordPress, 24/7.