Namespaces

En PHP, un namespace est une manière d'encapsuler des éléments de code. Il sert de conteneur pour toutes les classes, interfaces, fonctions et constantes que vous pourriez avoir. L'objectif principal des namespaces est d'éviter des conflits de noms entre le code de votre application.

Définition des namespaces#

Un namespace est défini en utilisant le mot-clé namespace suivi du nom que vous souhaitez donner à ce namespace. Par convention, le nom du namespace est généralement le même que le nom du répertoire contenant les fichiers PHP du namespace.

Voici un exemple simple de comment déclarer un namespace :

<?php
namespace MonNamespace;
class MaClasse {}

Dans cet exemple, nous avons déclaré un namespace appelé MonNamespace qui contient une classe appelée MaClasse.

Pourquoi utiliser les namespaces#

L'utilisation des namespaces permet de mieux organiser votre code et d'éviter des conflits de noms. Par exemple, si vous utilisez une bibliothèque tierce dans votre application qui a une classe nommée Utilisateur, et que vous avez également une classe Utilisateur dans votre application, l'utilisation des namespaces vous permettra d'utiliser les deux classes sans conflit.

Comment déclarer et utiliser les namespaces#

Pour déclarer un namespace, vous utilisez le mot-clé namespace suivi du nom du namespace. Le nom du namespace est sensible à la casse.

<?php
namespace MonApplication;

Pour utiliser une classe, une fonction ou une constante d'un autre namespace, vous pouvez utiliser le nom du namespace suivi d'une barre oblique inverse (\) et du nom de la classe, de la fonction ou de la constante.

<?php
$utilisateur = new \MonApplication\Utilisateur();

Si vous préférez, vous pouvez également utiliser le mot-clé use pour importer un namespace. Une fois un namespace importé, vous pouvez utiliser les classes, les fonctions et les constantes de ce namespace sans avoir à préfixer leur nom avec le nom du namespace.

<?php
use MonApplication\Utilisateur;
$utilisateur = new Utilisateur();

Utilisation avancée des namespaces#

Après avoir compris les bases des namespaces en PHP, vous pouvez commencer à explorer des fonctionnalités plus avancées. Ces fonctionnalités incluent l'importation de namespaces, la résolution de portée et l'utilisation du namespace global.

Importation et alias de namespaces#

En PHP, vous pouvez importer un namespace entier ou des classes, des fonctions et des constantes spécifiques d'un namespace. Pour ce faire, vous utilisez le mot-clé use.

Voici comment vous pouvez importer une classe spécifique d'un namespace :

<?php
use MonNamespace\MaClasse;
$object = new MaClasse();

Dans cet exemple, la classe MaClasse du namespace MonNamespace est importée. Vous pouvez maintenant utiliser cette classe directement sans avoir à préfixer son nom avec le nom du namespace.

Vous pouvez également utiliser le mot-clé use pour créer un alias pour une classe, une fonction ou une constante d'un namespace. Cela peut être utile si vous avez des conflits de noms. Voici comment vous pouvez créer un alias :

<?php
use MonNamespace\MaClasse as Classe;
$object = new Classe();

Dans cet exemple, la classe MaClasse du namespace MonNamespace est importée et un alias Classe est créé pour cette classe. Vous pouvez maintenant utiliser l'alias Classe pour se référer à MonNamespace\MaClasse.

Namespace et résolution de portée#

En PHP, la résolution de portée est gérée à l'aide de la barre oblique inverse (\). Si vous commencez le nom d'une classe, d'une fonction ou d'une constante avec une barre oblique inverse, PHP cherchera cet élément dans le namespace global. Voici un exemple :

<?php
namespace MonNamespace;
class MaClasse {
    public function maFonction() {
        return \strlen('Bonjour');
    }
}

Dans cet exemple, la fonction strlen est appelée dans le namespace global, même si cette fonction est appelée à l'intérieur de la classe MaClasse qui est dans le namespace MonNamespace.

Namespace global#

En PHP, tous les codes qui ne sont pas dans un namespace spécifique sont dans le namespace global. Vous pouvez accéder aux classes, aux fonctions et aux constantes du namespace global en préfixant leur nom avec une barre oblique inverse (\).

<?php
$chaine = \trim(' Bonjour ');

Dans cet exemple, la fonction trim du namespace global est appelée.

Composer et la gestion des dépendances#

Composer est un outil de gestion des dépendances pour PHP. Il vous permet de déclarer les bibliothèques dont votre projet dépend et il les gère (les installe / met à jour) pour vous.

Qu'est-ce que Composer et pourquoi l'utiliser#

Composer est un outil essentiel pour tout développeur PHP moderne. Il simplifie le processus d'installation et de mise à jour de vos dépendances, ce qui signifie que vous n'avez pas à vous soucier de télécharger manuellement les bibliothèques et de les inclure dans votre projet.

Composer vous permet également de gérer les versions de vos dépendances. Par exemple, vous pouvez spécifier que votre projet dépend de la version 1.0.0 d'une bibliothèque et Composer s'assurera que cette version spécifique est installée.

Déclaration des dépendances avec Composer#

Pour déclarer vos dépendances avec Composer, vous devez créer un fichier composer.json dans la racine de votre projet. Dans ce fichier, vous pouvez spécifier les bibliothèques dont votre projet dépend.

Voici un exemple de fichier composer.json :

{
    "require": {
        "monvendor/monpackage": "1.0.0"
    }
}

Dans cet exemple, nous déclarons que notre projet dépend de la version 1.0.0 de la bibliothèque monpackage du fournisseur monvendor.

Une fois que vous avez déclaré vos dépendances, vous pouvez utiliser la commande composer install pour installer toutes vos dépendances. Composer téléchargera les bibliothèques nécessaires et les installera dans le répertoire vendor de votre projet.

composer install

Composer et les namespaces#

Composer utilise les namespaces pour savoir quel fichier charger lorsqu'une classe spécifique est appelée. Il suit la spécification PSR-4 pour l'auto-chargement des classes, qui utilise les namespaces pour déterminer le chemin du fichier à charger.

Introduction à l'auto-chargement des classes avec Composer#

En PHP, avant de pouvoir utiliser une classe, vous devez inclure le fichier qui contient la définition de cette classe. Cela peut devenir fastidieux, surtout si vous travaillez avec de nombreux fichiers et classes. C'est là qu'intervient l'auto-chargement des classes.

L'auto-chargement des classes est une fonctionnalité qui permet à PHP de charger automatiquement une classe lorsque vous essayez de l'utiliser pour la première fois. Composer fournit une fonctionnalité d'auto-chargement des classes qui suit la spécification PSR-4.

Standard PSR-4 et son utilisation avec Composer#

PSR-4 est une spécification qui définit une façon standard d'organiser les fichiers et les dossiers dans une bibliothèque PHP. Composer utilise cette spécification pour déterminer où trouver les fichiers de classe à charger.

Pour utiliser l'auto-chargement des classes PSR-4 avec Composer, vous devez définir un mapping entre vos namespaces et les chemins des fichiers dans votre projet. Vous pouvez définir ce mapping dans votre fichier composer.json.

Voici un exemple de mapping de namespaces avec Composer :

{
    "autoload": {
        "psr-4": {
            "MonNom\\MonNamespace\\": "src/"
        }
    }
}

Dans cet exemple, nous indiquons à Composer que toutes les classes du namespace MonNamespace se trouvent dans le répertoire src/ de notre projet.

Comment Composer utilise les namespaces pour charger les classes#

Lorsque vous utilisez une classe dans votre code, Composer utilise le mapping défini dans votre fichier composer.json pour déterminer le chemin du fichier à charger. Il remplace les backslashes (\) dans le nom du namespace par des slashes (/) pour construire le chemin du fichier.

Par exemple, si vous avez une classe MaClasse dans le namespace MonNamespace\MonSousNamespace, Composer cherchera le fichier de cette classe dans le répertoire src/MonSousNamespace/MaClasse.php.

Exemples pratiques d'utilisation des namespaces avec Composer#

Maintenant que nous avons une bonne compréhension des namespaces en PHP et de leur interaction avec Composer, illustrons ces concepts avec des exemples pratiques.

Création d'un projet simple avec Composer et namespaces#

Supposons que nous ayons un projet avec la structure suivante :

/projet
    /src
        MaClasse.php
    composer.json

Et le contenu de MaClasse.php est :

<?php
namespace MonNom\MonNamespace;

class MaClasse {
    public function direBonjour() {
        return "Bonjour !";
    }
}

Nous pouvons définir le mapping de notre namespace dans composer.json comme suit :

{
    "autoload": {
        "psr-4": {
            "MonNom\\MonNamespace\\": "src/MonNamespace"
        }
    }
}

Après avoir modifié ce mapping, nous devons dire à Composer de générer le fichier d'auto-chargement avec la commande suivante :

composer dump-autoload

ou

composer du

Maintenant, nous pouvons utiliser notre classe MaClasse n'importe où dans notre projet sans avoir à inclure manuellement le fichier. Composer s'occupera de charger le fichier pour nous :

<?php
require 'vendor/autoload.php';

use MonNamespace\MaClasse;

$object = new MaClasse();
echo $object->direBonjour(); // Affiche "Bonjour !"

Ajout de dépendances avec namespaces à un projet existant#

Supposons que nous souhaitions ajouter une bibliothèque tierce à notre projet. Cette bibliothèque est hébergée sur Packagist et utilise des namespaces pour organiser son code. Nous pouvons ajouter cette bibliothèque à notre projet avec la commande composer require :

composer require vendor-name/package-name

Composer ajoutera la bibliothèque à notre projet et actualisera le fichier composer.json et le fichier d'auto-chargement. Nous pouvons maintenant utiliser les classes de cette bibliothèque dans notre projet :

<?php
require 'vendor/autoload.php';

use VendorName\PackageName\ClassName;

$object = new ClassName();

Gestion des conflits de noms avec Composer et namespaces#

L'un des avantages de l'utilisation de Composer avec les namespaces est la capacité de gérer facilement les conflits de noms. Par exemple, si nous avons deux bibliothèques qui fournissent une classe avec le même nom, nous pouvons toujours utiliser ces deux classes dans notre projet sans conflit.

Supposons que nous ayons les deux bibliothèques suivantes dans notre projet :

• monvendor/package1 qui fournit la classe MonVendor\Package1\MaClasse
• autrevendor/package2 qui fournit la classe AutreVendor\Package2\MaClasse

Même si les deux classes ont le même nom (MaClasse), aucun conflit n'existe car elles sont dans des namespaces différents. Nous pouvons utiliser ces deux classes dans notre projet comme ceci :

<?php
require 'vendor/autoload.php';

use MonVendor\Package1\MaClasse as MaClasse1;
use AutreVendor\Package2\MaClasse as MaClasse2;

$object1 = new MaClasse1();
$object2 = new MaClasse2();

Dans cet exemple, nous utilisons le mot-clé use pour importer les deux classes et nous créons un alias pour chaque classe pour éviter un conflit de noms.