Qu'est-ce que la cohésion et le couplage en…

La cohésion (Cohesion) est une mesure de la proximité des éléments à l'intérieur d'un module (classe, fonction). Une cohésion élevée signifie que les éléments du module sont concentrés sur l'exécution d'une seule tâche ou concept. Un module bien conçu a une cohésion élevée.

Exemples de niveaux de cohésion (de faible à élevé):

Fortuite (Coincidental): Les éléments sont liés par hasard, sans lien logique.
Logique (Logical): Les éléments effectuent un ensemble d'actions logiquement liées, mais la sélection est effectuée par du code externe.
Temporelle (Temporal): Les éléments sont liés par le fait qu'ils s'exécutent en même temps.
Procédurale (Procedural): Les éléments suivent une procédure d'exécution.
Communication (Communicational): Les éléments travaillent avec les mêmes données.
Séquentielle (Sequential): La sortie d'un élément est l'entrée d'un autre.
Fonctionnelle (Functional): Tous les éléments contribuent à l'exécution d'une fonction clairement définie.

Le couplage (Coupling) est une mesure de dépendance entre différents modules. Un faible couplage signifie que les modules sont relativement indépendants. Réduire le couplage rend le système plus flexible, maintenable et testable.

Exemples de niveaux de couplage (de élevé à faible):

Par contenu (Content): Un module accède directement aux données internes ou à l'implémentation d'un autre module.
Commun (Common): Les modules utilisent une zone de données globale partagée.
Par contrôle (Control): Un module transmet un drapeau de contrôle qui détermine le comportement d'un autre module.
Par estampillage (Stamp): Transfert de données composées (objets, structures), mais le module n'utilise qu'une partie d'entre elles.
Par données (Data): Transfert de données simples en tant que paramètres.
Par messages (Message): Les modules échangent des messages (par exemple, via des événements, interfaces). C'est la forme la plus faible de couplage.

Objectif d'une bonne conception : haute cohésion (à l'intérieur des modules) et faible couplage (entre les modules).

<?php

// Exemple de cohésion élevée (Cohésion fonctionnelle)
// Cette classe se concentre uniquement sur la gestion des utilisateurs
class UserManager {
    private array $users = [];

    public function addUser(string $name): void {
        $this->users[] = $name;
    }

    public function getUsers(): array {
        return $this->users;
    }

    public function deleteUser(string $name): void {
        $this->users = array_filter($this->users, fn($user) => $user !== $name);
    }
}

// Exemple de faible couplage (Couplage de données)
// 'processOrder' dépend uniquement des données passées ($orderId, $amount)
class OrderProcessor {
    public function processOrder(int $orderId, float $amount): bool {
        // Logique de traitement de commande...
        // Ne dépend pas directement de l'implémentation d'autres classes,
        // uniquement des données d'entrée.
        echo "Traitement de la commande ID $orderId avec un montant $amount\n";
        return true;
    }
}

// Exemple où UserManager et OrderProcessor n'ont pas une forte dépendance l'un envers l'autre.
// Ils peuvent être utilisés indépendamment ou ensemble, mais leurs changements internes
// n'affectent pas beaucoup l'un l'autre.

?>

Qu'est-ce que la cohésion et le couplage en programmation?