Clases y objetos en PHP: propiedades, métodos y $this

Una clase de PHP se declara con class Name { ... } y contiene propiedades (variables) y métodos (funciones). new Name() crea un objeto a partir de ella, y -> lee una propiedad o llama a un método: $user->name, $user->greet().

<?php
class User
{
    public string $name = 'Guest';

    public function greet(): string
    {
        return "Hello, {$this->name}";
    }
}

$user = new User();
echo $user->greet(), "\n";

$user->name = 'Ada';
echo $user->greet(), "\n";

La clase es el plano y el objeto es una cosa construida a partir de él. Puedes crear tantos objetos de una clase como necesites, y cada uno tiene sus propios valores en las propiedades.

Propiedades y métodos

Una propiedad se declara con una palabra clave de visibilidad, un tipo opcional y un valor por defecto opcional. Un método es una función dentro de la clase. Dentro de un método, $this es el objeto sobre el que se llamó el método, así que $this->balance lee el saldo de ese objeto.

<?php
class Account
{
    public string $owner = '';
    public float $balance = 0;

    public function deposit(float $amount): void
    {
        $this->balance += $amount;
    }

    public function summary(): string
    {
        return sprintf('%s has %.2f', $this->owner, $this->balance);
    }
}

$a = new Account();
$a->owner = 'Ada';
$a->deposit(50);
$a->deposit(25.5);

$b = new Account();
$b->owner = 'Linus';
$b->deposit(10);

echo $a->summary(), "\n";
echo $b->summary(), "\n";

Cada objeto conserva su propio $balance: ingresar en $a no toca $b. Asignar las propiedades una a una después de new acaba siendo pesado; un constructor recibe en su lugar los valores iniciales como argumentos.

public, private y protected

La visibilidad controla quién puede tocar una propiedad o llamar a un método:

Hacer una propiedad private y exponer métodos es como una clase protege sus propias reglas. Aquí el saldo solo puede cambiar mediante deposit() y withdraw(), que rechazan las cantidades incorrectas:

<?php
class Wallet
{
    private int $cents = 0;

    public function deposit(int $cents): void
    {
        if ($cents <= 0) {
            throw new InvalidArgumentException('Deposit must be positive');
        }
        $this->cents += $cents;
    }

    public function withdraw(int $cents): bool
    {
        if ($cents > $this->cents) {
            return false;
        }
        $this->cents -= $cents;
        return true;
    }

    public function balance(): int
    {
        return $this->cents;
    }
}

$w = new Wallet();
$w->deposit(500);
var_dump($w->withdraw(800));
var_dump($w->withdraw(200));
echo $w->balance(), "\n";

Leer la propiedad privada desde fuera de la clase no es un warning, es un Error:

<?php
// This throws an Error on purpose: $cents is private
class Wallet
{
    private int $cents = 500;
}

$w = new Wallet();
echo $w->cents;

Propiedades tipadas y valores sin inicializar

Una propiedad tipada sin valor por defecto empieza sin inicializar, que es distinto de null. Leerla antes de asignarle algo lanza un Error. Dale un valor por defecto, asígnala en el constructor o hazla nullable con ?Type y = null.

<?php
class Product
{
    public string $name;           // no default: uninitialized
    public ?string $sku = null;    // nullable with a default
    public int $stock = 0;
}

$p = new Product();
var_dump($p->sku, $p->stock);

try {
    echo $p->name;
} catch (Error $e) {
    echo $e->getMessage(), "\n";
}

$p->name = 'Keyboard';
echo $p->name, "\n";

Los tipos se aplican al asignar. En el modo por defecto (no estricto), $p->stock = '7' convierte la cadena numérica en 7, mientras que $p->stock = 'many' lanza un TypeError.

Propiedades readonly

Una propiedad readonly (PHP 8.1) se puede escribir una vez, desde dentro de la clase, y nunca más. Es la forma habitual de construir objetos de valor como cantidades de dinero o IDs. PHP 8.2 añadió readonly class, que hace readonly todas las propiedades.

<?php
class Order
{
    public readonly string $id;

    public function __construct(string $id)
    {
        $this->id = $id;
    }
}

$order = new Order('A-1001');
echo $order->id, "\n";

try {
    $order->id = 'B-2002';
} catch (Error $e) {
    echo $e->getMessage(), "\n";
}

Una propiedad readonly debe tener un tipo y no puede tener valor por defecto. Si necesitas una copia cambiada, crea un objeto nuevo (new Order('B-2002')) en lugar de editar el antiguo.

Imprimir un objeto con __toString

echo $object solo funciona cuando la clase define __toString(). El método devuelve la cadena que PHP debe usar siempre que el objeto se trate como texto: en echo, en una concatenación, en "{$object}".

<?php
class Money
{
    public function __construct(
        private int $cents,
        private string $currency = 'EUR',
    ) {}

    public function __toString(): string
    {
        return number_format($this->cents / 100, 2) . ' ' . $this->currency;
    }
}

$price = new Money(129900);
echo $price, "\n";
echo 'Total: ' . $price . "\n";
echo "Shipping: " . new Money(450, 'USD') . "\n";

// For debugging, print_r and var_dump show the properties
print_r(new Money(5));

Sin __toString, echo $object lanza un Error ("Object of class Money could not be converted to string"). Para depurar, print_r() y var_dump() funcionan con cualquier objeto y también muestran las propiedades privadas; consulta var_dump y print_r.

Asignar un objeto no lo copia

Este es el error que pilla a la mayoría de quienes vienen de los arrays. Asignar un array lo copia. Asignar un objeto copia solo el manejador: las dos variables apuntan entonces al mismo objeto.

<?php
class Point
{
    public int $x = 0;
    public int $y = 0;
}

$a = new Point();
$b = $a;          // same object
$b->x = 10;
echo "a->x = {$a->x}\n";

$c = clone $a;    // independent copy
$c->x = 99;
echo "a->x = {$a->x}, c->x = {$c->x}\n";

var_dump($a === $b, $a === $c, $a == $c);
var_dump($a instanceof Point);
echo get_class($c), "\n";

clone hace una copia superficial: si una propiedad contiene otro objeto, las dos copias siguen compartiendo ese objeto interior. === solo es verdadero para el mismo objeto, mientras que == compara los valores de las propiedades de dos objetos de la misma clase. Pasar un objeto a una función funciona igual que la asignación, así que una función puede cambiar el objeto que recibe.