Classes et objets PHP : propriétés, méthodes et $this

Une classe PHP se déclare avec class Name { ... } et contient des propriétés (des variables) et des méthodes (des fonctions). new Name() crée un objet à partir d'elle, et -> lit une propriété ou appelle une méthode : $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 classe est le plan, l'objet est une chose construite à partir de lui. Vous pouvez créer autant d'objets que nécessaire à partir d'une classe, et chacun a ses propres valeurs de propriétés.

Propriétés et méthodes

Une propriété se déclare avec un mot-clé de visibilité, un type facultatif et une valeur par défaut facultative. Une méthode est une fonction dans la classe. Dans une méthode, $this est l'objet sur lequel la méthode a été appelée, donc $this->balance lit le solde de cet objet.

<?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";

Chaque objet garde son propre $balance : déposer sur $a ne touche pas $b. Définir les propriétés une par une après new devient vite fastidieux ; un constructeur prend plutôt les valeurs de départ en arguments.

public, private et protected

La visibilité contrôle qui peut toucher une propriété ou appeler une méthode :

Rendre une propriété private et exposer des méthodes, c'est ainsi qu'une classe protège ses propres règles. Ici, le solde ne peut changer que par deposit() et withdraw(), qui refusent les montants invalides :

<?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";

Lire la propriété privée depuis l'extérieur de la classe n'est pas un warning, c'est une Error :

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

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

Propriétés typées et valeurs non initialisées

Une propriété typée sans valeur par défaut commence non initialisée, ce qui est différent de null. La lire avant qu'une valeur soit affectée lève une Error. Donnez-lui une valeur par défaut, affectez-la dans le constructeur, ou rendez-la nullable avec ?Type et = 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";

Les types sont vérifiés à l'affectation. En mode par défaut (non strict), $p->stock = '7' convertit la chaîne numérique en 7, alors que $p->stock = 'many' lève une TypeError.

Propriétés readonly

Une propriété readonly (PHP 8.1) peut être écrite une fois, depuis l'intérieur de la classe, puis plus jamais. C'est la façon habituelle de construire des objets valeur comme des montants ou des identifiants. PHP 8.2 a ajouté readonly class, qui rend toutes les propriétés readonly.

<?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";
}

Une propriété readonly doit avoir un type et ne peut pas avoir de valeur par défaut. S'il vous faut une copie modifiée, créez un nouvel objet (new Order('B-2002')) au lieu de modifier l'ancien.

Afficher un objet avec __toString

echo $object ne fonctionne que si la classe définit __toString(). La méthode renvoie la chaîne que PHP doit utiliser chaque fois que l'objet est traité comme du texte : dans echo, dans une concaténation, dans "{$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));

Sans __toString, echo $object lève une Error (« Object of class Money could not be converted to string »). Pour déboguer, print_r() et var_dump() fonctionnent sur n'importe quel objet et montrent aussi les propriétés privées ; voir var_dump et print_r.

Affecter un objet ne le copie pas

C'est l'erreur qui piège le plus ceux qui viennent des tableaux. Affecter un tableau le copie. Affecter un objet ne copie que la poignée : les deux variables désignent alors le même objet.

<?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 fait une copie superficielle : si une propriété contient un autre objet, les deux copies partagent toujours cet objet intérieur. === n'est vrai que pour le même objet, alors que == compare les valeurs des propriétés de deux objets de la même classe. Passer un objet à une fonction fonctionne comme une affectation, donc une fonction peut modifier l'objet qu'elle reçoit.