Constructor en PHP: __construct y promoción de propiedades

Un constructor de PHP es un método llamado __construct(). PHP lo llama automáticamente cuando escribes new ClassName(...), y los argumentos entre paréntesis se convierten en sus parámetros, así que el objeto empieza su vida con sus valores ya asignados.

<?php
class User
{
    public string $name;
    public int $age;

    public function __construct(string $name, int $age)
    {
        $this->name = $name;
        $this->age = $age;
    }
}

$ada = new User('Ada', 36);
echo "{$ada->name} is {$ada->age}\n";

Sin constructor crearías un objeto vacío y asignarías cada propiedad después, y nada te impediría olvidarte de una. Con un constructor, new User() sin argumentos es un ArgumentCountError.

Promoción de propiedades en el constructor

Declarar una propiedad, ponerla como parámetro y asignar $this->name = $name repite cada nombre tres veces. Desde PHP 8.0, una palabra clave de visibilidad delante de un parámetro del constructor hace las tres cosas a la vez:

<?php
class User
{
    public function __construct(
        public string $name,
        public int $age,
        private string $email = '',
    ) {}

    public function contact(): string
    {
        return $this->email !== '' ? $this->email : 'no email';
    }
}

$u = new User('Grace', 45, 'grace@example.com');
echo $u->name, ', ', $u->age, ', ', $u->contact(), "\n";

$v = new User('Linus', 28);
echo $v->name, ', ', $v->contact(), "\n";

Un parámetro promovido también puede ser readonly (public readonly string $id), que es la forma más corta de escribir un objeto de valor inmutable. Puedes mezclar parámetros promovidos y normales, y el cuerpo del constructor puede seguir conteniendo código que se ejecuta después de asignar las propiedades promovidas.

Valores por defecto y argumentos con nombre

Los parámetros del constructor aceptan valores por defecto como cualquier función. Los parámetros con valor por defecto van después de los obligatorios. Con los argumentos con nombre (PHP 8.0), quien llama puede saltar a la opción que quiere en lugar de repetir todos los valores por defecto anteriores:

<?php
class Button
{
    public function __construct(
        public string $label,
        public string $color = 'blue',
        public string $size = 'medium',
        public bool $disabled = false,
    ) {}

    public function render(): string
    {
        $attr = $this->disabled ? ' disabled' : '';
        return "<button class=\"{$this->color} {$this->size}\"{$attr}>{$this->label}</button>";
    }
}

echo (new Button('Save'))->render(), "\n";
echo (new Button('Delete', 'red'))->render(), "\n";
echo (new Button('Wait', disabled: true))->render(), "\n";

Ejecútalo: la salida contiene HTML, así que la pestaña Página muestra los tres botones renderizados y la pestaña Salida muestra las etiquetas que imprimió PHP. Fíjate en los paréntesis de (new Button('Save'))->render(): desde PHP 8.4 son opcionales, pero PHP 8.3 los necesita.

Validar los argumentos en el constructor

Un constructor no puede devolver false ni un código de error: lo que devuelva se ignora. Para rechazar una entrada incorrecta, lanza una excepción. Así el objeto nunca llega a crearse, y el resto del programa puede confiar en cada Temperature que recibe.

<?php
class Temperature
{
    public function __construct(public readonly float $celsius)
    {
        if ($celsius < -273.15) {
            throw new InvalidArgumentException("Below absolute zero: $celsius");
        }
    }

    public function fahrenheit(): float
    {
        return $this->celsius * 9 / 5 + 32;
    }
}

echo (new Temperature(21.5))->fahrenheit(), "\n";

try {
    $t = new Temperature(-300);
} catch (InvalidArgumentException $e) {
    echo 'Rejected: ', $e->getMessage(), "\n";
}

La página de try catch explica con más detalle cómo capturar estas excepciones.

Varios constructores con métodos factoría estáticos

PHP no tiene sobrecarga de constructores: una clase, un __construct. Cuando un objeto se puede construir a partir de entradas distintas (una cadena de fecha, un array, un timestamp), añade métodos estáticos con nombre que preparen los argumentos y llamen a new static(...). Hacer el constructor private obliga a todo el mundo a pasar por las factorías.

<?php
class Color
{
    private function __construct(
        public readonly int $r,
        public readonly int $g,
        public readonly int $b,
    ) {}

    public static function fromRgb(int $r, int $g, int $b): static
    {
        return new static($r, $g, $b);
    }

    public static function fromHex(string $hex): static
    {
        [$r, $g, $b] = sscanf(ltrim($hex, '#'), '%02x%02x%02x');
        return new static($r, $g, $b);
    }

    public function css(): string
    {
        return "rgb({$this->r}, {$this->g}, {$this->b})";
    }
}

echo Color::fromRgb(255, 128, 0)->css(), "\n";
echo Color::fromHex('#1e90ff')->css(), "\n";

Ahora new Color(1, 2, 3) desde fuera de la clase lanza un Error ("Call to private Color::__construct() from global scope"). La página de static explica por qué aquí se usa new static y no new self.

Llamar al constructor padre con parent::__construct

Cuando una clase hija define su propio constructor, el constructor del padre no se ejecuta por sí solo. Llámalo con parent::__construct(...), normalmente primero, para que las propiedades del padre estén asignadas antes de que la hija añada las suyas:

<?php
class Vehicle
{
    public function __construct(
        protected string $brand,
        protected int $wheels = 4,
    ) {}

    public function describe(): string
    {
        return "{$this->brand} with {$this->wheels} wheels";
    }
}

class Truck extends Vehicle
{
    public function __construct(string $brand, private int $capacityKg)
    {
        parent::__construct($brand, 6);
    }

    public function describe(): string
    {
        return parent::describe() . ", carries {$this->capacityKg} kg";
    }
}

echo (new Vehicle('Fiat'))->describe(), "\n";
echo (new Truck('Volvo', 18000))->describe(), "\n";

Si la hija no tiene constructor en absoluto, PHP usa el del padre, y new Truck('Volvo') pasaría sus argumentos directamente a Vehicle::__construct. Hay más sobre esto en herencia.

Olvidar parent::__construct

Este error no produce ningún mensaje en la línea donde ocurre. El constructor hijo se ejecuta, las propiedades tipadas del padre se quedan sin inicializar, y el programa falla más tarde, donde se produzca la primera lectura:

<?php
class Model
{
    protected array $attributes;

    public function __construct()
    {
        $this->attributes = ['created' => '2026-03-14'];
    }

    public function get(string $key): mixed
    {
        return array_key_exists($key, $this->attributes) ? $this->attributes[$key] : null;
    }
}

class Post extends Model
{
    public function __construct(public string $title)
    {
        // parent::__construct() is missing
    }
}

$post = new Post('Hello');
try {
    echo $post->get('created'), "\n";
} catch (Error $e) {
    echo $e->getMessage(), "\n";
}

Añade parent::__construct(); como primera línea de Post::__construct y vuelve a ejecutarlo: imprime la fecha. Un método relacionado, __destruct(), se ejecuta cuando desaparece la última referencia a un objeto o cuando termina el script. Rara vez hace falta en el código del día a día, porque PHP cierra los archivos y libera la memoria por sí solo al final de cada petición.