PHP 8.2 / 8.3 Broke Your WordPress Site? Here’s Why (And How to Fix It Properly)
Senior WebCoder
The Silent Shift to Strictness
For years, PHP was known for its "forgiving" nature. You could pass the wrong data types, use undeclared variables, and the engine would mostly just shrug and keep going. That era ended with PHP 8.2 and 8.3.
When you upgrade your server to these modern versions, you aren't just getting better performance—you're getting a much stricter compiler. If your WordPress site suddenly shows a White Screen of Death (WSOD) or is flooded with "Deprecated" warnings, here is exactly what is happening under the hood.
1. The Timeline of Breaking Changes
PHP 8.2 and 8.3 aren't just minor updates; they represent a fundamental shift in how PHP handles object-oriented code and data typing.
PHP Evolution & Breaking Points
The "Warning" you ignored in PHP 8.0 often becomes a "Fatal Error" in PHP 8.3. This is why a site that seemed "fine" on 8.0 suddenly collapses on 8.2+.
2. The Main Culprit: Dynamic Properties (PHP 8.2)
In PHP 7.4, if you had a class User and did $user->new_field = 'data', PHP would silently create that field on the fly. In PHP 8.2, this is deprecated. In PHP 9.0, it will be a Fatal Error.
Why it breaks WordPress:
Many older plugins use dynamic properties to store temporary data on objects like $post or $wp_query.
The Proper Fix:
The "lazy" fix is to add an attribute to the class. The "correct" fix is to explicitly declare all properties.
3. The "Null to Internal" TypeError (PHP 8.1 / 8.2)
This is perhaps the most common reason for a complete site crash. Older code often passes null to built-in functions like strlen(), strpos(), or explode().
In PHP 8.2+, passing null where a string is expected throws a Fatal TypeError.
// PHP 7.4 (Returns 0, no error)
// PHP 8.2+ (FATAL ERROR)
$length = strlen( $null_variable );
// THE FIX: Strict Null Guarding
$length = strlen( (string) $null_variable );
// OR
$length = $null_variable ? strlen( $null_variable ) : 0;Why did my site break?
You passed null to a built-in function like strlen() or strpos(). Fixed by strict null guarding.
Your plugin is adding data to objects without declaring them in the class. Requires #[] attribute.
UTF-8 encoding changes in 8.2+. Certain string functions now require explicit character encoding sets.
PHP 8.2+ classes can be marked as readonly. If a plugin tries to modify them, it fails immediately.
Why did my site break?
You passed null to a built-in function like strlen() or strpos(). Fixed by strict null guarding.
Your plugin is adding data to objects without declaring them in the class. Requires #[] attribute.
UTF-8 encoding changes in 8.2+. Certain string functions now require explicit character encoding sets.
PHP 8.2+ classes can be marked as readonly. If a plugin tries to modify them, it fails immediately.
4. String Interpolation Deprecation (PHP 8.2)
For years, developers used ${var} and {$var} interchangeably. Starting with PHP 8.2, the ${var} syntax is officially deprecated.
The Warning:
Deprecated: Using ${var} in strings is deprecated, use {$var} instead
Why the change?
The ${var} syntax was internally inconsistent with how PHP handled complex variable parsing. By enforcing {$var}, PHP makes the engine's parser simpler and more predictable.
// DEPRECATED (PHP 8.2+)
echo "Hello ${name}";
// RECOMMENDED
echo "Hello {$name}";5. Advanced Typing: DNF Types (PHP 8.2)
Disjunctive Normal Form (DNF) types allow you to combine intersection types (A & B) with union types (A | B). This is a game-changer for writing strict, self-documenting code in complex WordPress plugins.
PHP 8.2: Disjunctive Normal Form (DNF)
Allows combining intersection types (&) and union types (|) in a single declaration.
This allows you to say: "This parameter must implement both Interface A AND Interface B, OR it can be null."
6. PHP 8.3: Typed Class Constants
In PHP 8.3, you can now add type hints to class constants. This prevents child classes from accidentally overriding a constant with an incompatible data type.
class BasePlugin {
// PHP 8.3 enforced type
public const string VERSION = '1.0.0';
}
class ChildPlugin extends BasePlugin {
// FATAL ERROR in 8.3 if typed in Base
public const int VERSION = 2;
}7. Performance Win: json_validate() (PHP 8.3)
One of the most useful additions for API-heavy WordPress sites is json_validate(). Previously, to check if a string was valid JSON, you had to json_decode() it, which consumed significant memory for large payloads.
if (json_last_error() === ...)
json_validate() checks the syntax without actually creating the associated objects in memory, leading to faster execution and lower RAM usage.
8. Modernizing Your Workflow
Fixing these issues isn't just about patching errors as they appear. It's about moving toward a Strict Type philosophy.
A. Static Analysis (The Proactive Way)
Don't wait for your site to break. Use tools like PHPStan or Psalm. These tools can scan your entire plugin/theme directory and highlight every line that will fail on PHP 8.2+.
B. The readonly Restriction
PHP 8.2 introduced readonly classes. If you mark a class as readonly, all its properties are implicitly readonly. If a hook or a third-party plugin tries to inject data into that class, the site will crash.
C. Constants in Traits
PHP 8.3 now allows constants to be defined in traits. This is a huge win for cleanliness but can cause "Redefinition Errors" if you aren't careful with naming conventions across multi-plugin environments.
Conclusion
Upgrading to PHP 8.2 and 8.3 is essential for security and speed, but it requires a disciplined approach to code maintenance. Those "Deprecated" notices aren't just noise—they are the roadmap of your site's future failure if left unaddressed.
At FUEiNT, we specialize in legacy modernization. We don't just "fix the error"; we refactor your architecture to be future-proof against the evolving PHP ecosystem.
Is your site struggling with modern PHP? → Get a PHP Compatibility Audit from FUEiNT