Fonctions et objets

Ce que tu vas apprendre

• Écrire une fonction avec des types de paramètres et de retour, et activer strict_types.
• Créer une classe avec un constructeur à promotion de propriétés.
• Ranger tes classes dans un espace de noms.

Une fonction

Une fonction regroupe du code réutilisable sous un nom. Elle reçoit des paramètres et peut renvoyer un résultat avec return.

<?php
function formaterDuree(int $minutes): string
{
    $heures = intdiv($minutes, 60);
    $reste = $minutes % 60;
    return "{$heures} h {$reste} min";
}

echo formaterDuree(75); // 1 h 15 min

Dans int $minutes, int est le type attendu du paramètre. Après les parenthèses, : string indique le type de la valeur renvoyée.

Les déclarations de type

Une déclaration de type dit à PHP ce que la fonction accepte et renvoie. Voici les formes courantes.

<?php
function titreOuDefaut(?string $titre, int|float $note = 0): string
{
    return ($titre ?? "Sans titre") . " ($note)";
}

Un paramètre avec = possède une valeur par défaut : tu peux alors l'omettre à l'appel.

strict_types

Par défaut, PHP convertit les valeurs pour s'adapter au type demandé. Un "45" donné à une fonction qui attend un int devient 45 sans erreur.

Pour que PHP refuse cette conversion, ajoute en toute première instruction du fichier :

<?php
declare(strict_types=1);

function formaterDuree(int $minutes): string { /* ... */ }

formaterDuree("45"); // TypeError : un string n'est pas un int

Le mode strict s'active fichier par fichier. Il s'applique aux appels faits depuis ce fichier. Une erreur de type est signalée tout de suite plutôt que de produire un résultat bizarre plus loin.

Une classe

Une classe est un plan qui décrit une sorte d'objet : ses données (les propriétés) et ses actions (les méthodes). Un objet est un exemplaire créé à partir de ce plan.

<?php
declare(strict_types=1);

class Recette
{
    public function __construct(
        public string $titre,
        public int $duree,
    ) {
    }

    public function resume(): string
    {
        return "{$this->titre} ({$this->duree} min)";
    }
}

La méthode __construct est le constructeur : PHP l'appelle quand tu crées un objet avec new. $this désigne l'objet en cours.

La promotion de propriétés

Dans l'exemple, les paramètres du constructeur portent public. C'est la promotion de propriétés : PHP en fait à la fois des paramètres et des propriétés de l'objet, et leur affecte la valeur reçue. Disponible depuis PHP 8.0, elle évite de déclarer chaque propriété et de la réaffecter à la main.

<?php
$tarte = new Recette("Tarte aux pommes", 45);

echo $tarte->titre;    // Tarte aux pommes
echo $tarte->resume(); // Tarte aux pommes (45 min)

La flèche -> accède à une propriété ou appelle une méthode.

Protéger les données

Les mots public, protected et private règlent qui peut lire une propriété. Le mot readonly interdit de la modifier après la création :

<?php
class Ingredient
{
    public function __construct(
        public readonly string $nom,
        private float $quantite = 1.0,
    ) {
    }
}

Ici, $nom se lit de l'extérieur mais ne se change plus. $quantite est invisible hors de la classe.

Les espaces de noms

Plus ton projet grandit, plus deux classes risquent de porter le même nom. Un espace de noms (namespace) regroupe des classes sous un préfixe, comme un dossier.

<?php
declare(strict_types=1);

namespace App;

class Recette { /* ... */ }

Pour l'utiliser ailleurs, tu importes la classe avec use :

<?php
use App\Recette;

$r = new Recette("Crêpes", 30);

La déclaration namespace doit venir tout en haut du fichier, juste après declare. On rangera ces fichiers automatiquement grâce à Composer, au dernier chapitre.

À retenir

• Une fonction se déclare avec function, des paramètres typés et un type de retour après :.
• ?string signifie « chaîne ou null », int|string un type union.
• declare(strict_types=1); en tête de fichier interdit les conversions de type implicites.
• Une classe décrit des propriétés et des méthodes ; new crée un objet, -> y accède.
• La promotion de propriétés (PHP 8.0) déclare et affecte les propriétés dans les paramètres du constructeur.
• Un namespace évite les collisions de noms, use importe une classe.