Ce sunt coeziunea și cuplarea în programare?

Coerența (Cohesion) este o măsură a cât de strâns legate sunt elementele din interiorul unui modul (clasă, funcție). O coerență ridicată înseamnă că elementele modulului sunt concentrate pe realizarea unei singure sarcini sau concept. Un modul bine proiectat are o coerență ridicată.

Exemple de niveluri de coerență (de la scăzut la înalt):

• Întâmplătoare (Coincidental): Elementele sunt legate aleatoriu, fără o legătură logică.
• Logică (Logical): Elementele efectuează un set de acțiuni logic legate, dar selecția este făcută de cod extern.
• Temporală (Temporal): Elementele sunt legate prin faptul că sunt executate în același timp.
• Procedurală (Procedural): Elementele urmează o procedură de execuție.
• Comunicațională (Communicational): Elementele lucrează cu aceleași date.
• Secvențială (Sequential): Ieșirea unui element devine intrarea altuia.
• Funcțională (Functional): Toate elementele contribuie la realizarea unei funcții clar definite.

Cuplajul (Coupling) este o măsură a dependenței între diferite module. Un cuplaj scăzut înseamnă că modulele sunt relativ independente între ele. Reducerea cuplajului face sistemul mai flexibil, mai ușor de întreținut și testat.

Exemple de niveluri de cuplaj (de la înalt la scăzut):

• Pe conținut (Content): Un modul accesează direct datele interne sau implementarea altui modul.
• Comunitar (Common): Modulele folosesc o zonă comună de date globală.
• Control (Control): Un modul transmite un semnal de control care determină comportamentul altui modul.
• Stamp (Stamp): Transferul de date compuse (obiecte, structuri), dar modulul folosește doar o parte din ele.
• Pe date (Data): Transferul de date simple ca parametri.
• Prin mesaje (Message): Modulele schimbă mesaje (de exemplu, prin evenimente, interfețe). Aceasta este cea mai slabă formă de cuplaj.

Scopul unui bun design: coerență ridicată (în interiorul modulelor) și cuplaj scăzut (între module).

<?php

// Exemplu de coerență ridicată (coerență funcțională)
// Această clasă se concentrează doar pe gestionarea utilizatorilor
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);
    }
}

// Exemplu de cuplaj scăzut (cuplaj de date)
// 'processOrder' depinde doar de datele transmise ($orderId, $amount)
class OrderProcessor {
    public function processOrder(int $orderId, float $amount): bool {
        // Logica de procesare a comenzii...
        // Nu depinde direct de implementarea altor clase,
        // doar de datele de intrare.
        echo "Procesare comandă ID $orderId cu suma $amount\n";
        return true;
    }
}

// Exemplu în care UserManager și OrderProcessor nu au o dependență puternică unul de celălalt.
// Pot fi folosite independent sau împreună, dar modificările interne
// nu afectează prea mult unul pe celălalt.

?>