Typed properties in PHP 7.4 allow direct type declaration for class properties, improving reliability, IDE support, and code clarity; 2. They enforce type safety, reduce bugs, enable better autocompletion, and minimize constructor checks; 3. To migrate, use existing @var docblocks to add types, apply nullable or mixed as needed, ensure proper initialization, and adopt promoted properties in PHP 8.0 ; 4. Best practices include using declare(strict_types=1), preferring specific types, initializing properties, and avoiding forced typing on dynamic data—modern PHP development should embrace typed properties for robust, maintainable code.

PHP’s introduction of typed properties in PHP 7.4 was a game-changer for writing clean, reliable, and self-documenting object-oriented code. If you're still using PHP classes with untyped properties and relying solely on docblocks or runtime checks, it's time to modernize. Here's how typed properties can improve your classes and how to adopt them effectively.

What Are Typed Properties?

Typed properties let you declare the data type of a class property directly in the property declaration. Before PHP 7.4, you could only type-hint parameters and return values — not properties.

Before (PHP

class User
{
    /** @var string */
    public $name;

    /** @var int */
    public $age;
}

After (PHP 7.4 ):

class User
{
    public string $name;
    public int $age;
}

This enforces type safety at the property level — PHP will throw a TypeError if you try to assign a value of the wrong type.

Benefits of Using Typed Properties

1. Improved Code Reliability

With typed properties, invalid data assignments fail early and loudly. This reduces bugs caused by incorrect types sneaking into your objects.

$user = new User();
$user->age = "not a number"; // TypeError: Cannot assign string to int

2. Better IDE Support and Autocompletion

IDEs can now understand your property types natively, without relying on @var docblocks. This means better autocompletion, refactoring, and inline error detection.

3. Self-Documenting Code

Types are part of the code, not just comments. Anyone reading your class immediately knows what each property should contain.

4. Reduced Need for Constructor Type Checks

You no longer need to validate types in constructors as rigorously — the property itself handles basic enforcement.

class Product
{
    public string $title;
    public float $price;

    public function __construct(string $title, float $price)
    {
        $this->title = $title;
        $this->price = $price;
        // No manual type checks needed!
    }
}

How to Migrate Legacy Classes

Upgrading older classes is straightforward but requires attention to detail.

Step-by-step migration:

• Review existing docblocks for @var hints — these are your guide for typing.
• Add types to properties where the type is consistent and well-defined.
• Use nullable types when a property can be null:

  public ?string $email = null;

• Be cautious with mixed or dynamic data — if a property truly holds multiple types, consider redesigning or use mixed (PHP 8.0 ):

  public mixed $metadata = null;

Watch out for:

• Default values: You must initialize nullable or non-nullable properties appropriately.

  public string $status = ''; // OK
  public string $name;         // Error unless initialized in constructor

• Promoted properties (PHP 8.0 ): Combine constructor parameters and property assignment with type safety:

  class User {
      public function __construct(
          public string $name,
          public int $age
      ) {}
  }

Best Practices

• ? Use strict types at the top of your files:

  declare(strict_types=1);

  This ensures consistent type checking across your codebase.

• ? Prefer specific types over mixed — only use mixed or object when absolutely necessary.

• ? Initialize properties or ensure they’re set in __construct() to avoid uninitialized value errors.

• ? Don’t force types where the data is genuinely dynamic — consider encapsulating that logic instead.

---

Modernizing your classes with typed properties isn’t just about using new syntax — it’s about building more robust, maintainable applications. The combination of early error detection, better tooling, and clearer intent makes typed properties a must-use feature in modern PHP.

Basically, if you're on PHP 7.4 or higher, there's little reason not to use them.

The above is the detailed content of Modernizing Your Classes with PHP Typed Properties. For more information, please follow other related articles on the PHP Chinese website!