PHP, a widely acknowledged server-side scripting language is a great tool for web app development teams. As researched by the web technology survey portal W3 Techs, “75.9% of all websites are powered by PHP.” It’s interesting how PHP has undergone significant transformations since its inception to address the ever-growing needs of web development. What started as a tool for generating basic dynamic web pages has grown into a powerful language capable of supporting large-scale applications. So, let’s explore PHP’s evolution and the crucial updates so far.
Major PHP Updates from inception till date
1. Early Versions (PHP/FI to PHP 3)
- PHP/FI (1995): The journey of PHP began when Rasmus Lerdorf created a simple set of CGI scripts with the basic feature of form handling. He named it as ‘Personal Home Page/Forms Interpreter (PHP/FI) and used it for tracking visits to his online resume.
- PHP 3 (1998): The real breakthrough came with PHP 3, when Andi Gutmans and Zeev Suraski rewrote the PHP core. PHP 3 introduced a more structured syntax and improved functionality, establishing PHP as a full-fledged scripting language for web application development.
2. PHP 4 (2000)
- Zend Engine 1.0 (performance optimization and memory management)
- Output buffering and session handling
- Object-Oriented Programming (OOP)
3. PHP 5 (2004)
- Zend Engine 2 (further performance improvements and extensibility of the language)
- Improved OOP Support features like better support for classes, methods, inheritance, interfaces, and constructors/destructors
- Exceptions (for error handling)
4. PHP 7 (2015)
- New Zend Engine 3 named PHP Next Generation (PHPNG): improved memory usage and made applications run much faster.
- Return Types and Scalar Type Declarations: type hinting (e.g., int, float, string, bool) and the ability to declare return types in functions: made the code more predictable and easier to debug.
- New syntax features: the null coalescing operator (??) and the spaceship operator (<=>): made the code more concise.
- Throwable interface for exceptions and errors: Improved issue detection and error handling
5. PHP 8 (2020)
PHP 8 is a crucial update as the features introduced are not just incremental improvements; they represent a new era for PHP that aligns it more closely with modern software development practices. Here’s an overview of all the PHP 8 versions.
PHP 8.0 (Released December 3, 2020)
- JIT (Just-In-Time) Compilation: expedites performance by compiling code into machine code at runtime.
- Union Types: Allows functions and methods to accept multiple types of values.
- Attributes (Annotations): Offers a new way to add metadata to classes, methods, and properties using a new syntax.
- Named Arguments: Call functions with arguments specified by their names, improving readability.
- Constructor Property Promotion: Combines constructor assignment and property declaration to minimize boilerplate code.
- Match Expression: A new match expression similar to switch but with safer comparisons and return values.
- Nullsafe Operator: The mechanism of “method chaining” on potentially null values; no explicit null checks required.
- Trailing Commas in Parameter Lists: Enables trailing commas in function and method parameter lists.
PHP 8.1 (Released November 25, 2021)
- Enumerations (Enums): Introduces a native enum type for defining a set of possible values.
- Fibers: Allows for cooperative multitasking by providing a way to pause and resume functions.
- Readonly Properties: Properties that can only be written once and then become read-only.
- Enhances array unpacking to handle string keys.
- Intersection Types: Allows combining multiple types into one, requiring a value to satisfy all specified types.
- Internal optimizations, including JIT compiler improvements.
PHP 8.2 (Released December 8, 2022)
- Read-only Properties: Expands the readonly feature from PHP 8.1 to allow class properties that can be assigned a value only once.
- Disjunctive Normal Form Types: Improves type system flexibility by allowing complex type expressions.
- New Fetch Style for PDO::FETCH_MODE: Adds a new fetch style for PDO that makes working with database results easier.
- Deprecations and Removals: Modifies or removes certain features and functions deprecated in earlier versions.
- Performance Enhancements: Includes various optimizations and bug fixes for improved performance.
PHP 8.3: The Latest PHP Version (Released September 10, 2024)
The latest stable release of PHP is PHP 8.3, which continues to enhance security, performance, and compatibility with modern technologies. Key improvements in this version include better error handling, optimized performance (e.g., reduced memory usage and faster response times), and enhanced compatibility with frameworks, libraries, and emerging technologies such as Progressive Web Apps (PWAs) and WebSockets. PHP 8.3 also strengthens security by providing updates to protect apps from potential threats, making it essential for developers to stay updated.
Top Highlights of PHP 8.3 at a Glance
1. Readonly Classes
PHP 8.3 introduces the ability to declare an entire class as readonly, meaning all properties in that class are implicitly readonly without the need to declare them individually. This simplifies the usage of immutable objects and enforces immutability across the class.
readonly class MyImmutableClass {
public int $id;
public string $name;
}
2. json_validate() Function
A new json_validate() function is added to validate JSON strings without fully decoding them. This comes in handy when you need to check the structure or syntax of JSON data before you work with it.
$isValid = json_validate('{"name": "John"}'); // returns true if valid
3. null Return Types
PHP 8.3 introduces null as an explicit return type, allowing developers to declare functions that can only return null.
function myFunction(): null {
return null;
}
4. Generator Improvements
Generator::throw() now works as expected with Generator objects, allowing the throwing of exceptions into generators more consistently. This can be useful for error handling in asynchronous code or lazy evaluation scenarios.
$generator = (function() {
try {
yield 1;
} catch (Exception $e) {
echo $e->getMessage();
}
})();
$generator->throw(new Exception("An error occurred"));
5. New is_any() and is_none() Functions
PHP 8.3 adds the is_any() and is_none() functions to make it easier to check multiple types or values in one go.
$value = 'example';
if (is_any($value, 'string', 'integer')) {
// Do something
}
if (is_none($value, 'array', 'object')) {
// Do something else
}
6. Disjunctive Normal Form (DNF) Types
Type unions can now be used in disjunctive normal form, improving flexibility when specifying complex return types or parameter types.
function process(mixed $value): (int|float)|(string|bool) {
// Function logic
}
Other Improvements
Array Unpacking with String Keys: PHP 8.3 improves array unpacking by allowing the use of string keys; this was previously limited to integer-indexed arrays.
New Functions: Various new built-in functions, such as str_truncate(), have been added to make string handling more flexible and performant.
Performance Optimizations: There are further performance improvements, particularly in opcache and memory handling, continuing the performance gains seen in PHP 8.x series.
PHP 8.4: Upcoming Update
PHP 8.4, to be officially released on November 21, 2024; promises to bring valuable improvements and features, enhancing both performance and developer experience. Currently, it is undergoing the pre-release phase, transitioning through Alphas, Betas, and Release Candidates.
Expected Features
- Property hooks RFC will make it easier to manage properties with less boilerplate code.
- The technique of “method chaining” without parentheses is a nice convenience
- JIT improvements should help with performance and memory usage
- The deprecation of implicit nullable types will encourage more explicit type declarations
- The new DOM HTML5 support is great for handling modern HTML content.
How to Prepare for PHP 8.4?
- Testing: Ensure your codebase is compatible with the new version by testing in a staging environment.
- Updating Dependencies: Check and update any third-party libraries or frameworks to ensure compatibility with PHP 8.4.
- Review RFCs: Stay informed about new RFCs and feature additions to leverage the new capabilities effectively.
Takeaway
The evolution of PHP continues, and with each version, it becomes a stronger and more versatile tool in the developer’s toolkit. If you haven’t upgraded yet, now is the time to explore what PHP 8 can do for your projects. Whether you’re building small-scale applications powered by PHP or enterprise-level software, these updates will make your development process smoother and more efficient.