Iterator Pattern vs Composite Pattern

1. Iterator Pattern

Parcours séquentiel des collections : Le Iterator Pattern permet de parcourir une collection d'objets (fichiers et dossiers) de manière séquentielle sans exposer la structure interne de la collection.
Séparation de la logique d'itération : La logique d'itération est encapsulée dans un itérateur, ce qui permet d'utiliser le même mécanisme pour différentes collections.
Exemple : Itérer sur une liste de fichiers et dossiers dans un répertoire à plat sans tenir compte des sous-dossiers.

2. Composite Pattern

Gestion d'objets en structure arborescente : Le Composite Pattern permet de traiter des objets individuels (fichiers) et des groupes d'objets (dossiers) de manière uniforme. Chaque dossier peut contenir des fichiers ou d'autres dossiers, et la structure peut être parcourue récursivement.
Unification du traitement des composants : Que ce soit un fichier ou un dossier, chaque élément peut être manipulé de manière identique grâce à une interface commune.
Exemple : Représenter et parcourir une structure hiérarchique de dossiers et fichiers où chaque dossier peut contenir des fichiers ou d'autres dossiers.

Comparaison directe :

Caractéristique	Iterator Pattern	Composite Pattern
Objectif principal	Parcourir des collections d'objets séquentiellement	Gérer et parcourir une structure arborescente d'objets
Changement dynamique	Oui, il peut parcourir différentes collections	Non, structure hiérarchique fixée une fois construite
Complexité cachée	Oui, la logique d'itération est encapsulée	Non, la structure arborescente est exposée et traitée unifiée
Flexibilité dans l'ajout de composants	Moyenne, on peut changer la collection à parcourir	Très flexible, peut ajouter ou supprimer des composants à la volée
Exemple d'application	Parcourir une liste de fichiers et dossiers	Représenter une structure de dossiers et fichiers imbriqués

Exemples

1. Iterator Pattern

Imaginons que nous ayons une collection à plat de fichiers et dossiers dans un répertoire sans sous-dossiers. Avec le Iterator Pattern, nous pouvons parcourir cette liste séquentiellement pour afficher le contenu.

$items = [
    new File('file_1'),
    new File('file_2'),
    new File('file_3'),
    new Folder('folder_1'),
    new Folder('folder_2'),
    new Folder('folder_3'),
];

$iterator = new FileSystemIterator($items);

while ($iterator->hasNext()) {
    $item = $iterator->current();
    echo $item->getName() . "\n";
    $iterator->next();
}

Sortie dans le terminal :

file_1
file_2
file_3
folder_1
folder_2
folder_3

Dans cet exemple, nous utilisons un FileSystemIterator pour parcourir une collection à plat de fichiers et dossiers sans gestion de la hiérarchie. Chaque élément est traité individuellement.

2. Composite Pattern

Dans le cas du Composite Pattern, nous allons gérer une structure arborescente de fichiers et dossiers. Chaque dossier peut contenir d'autres dossiers ou fichiers, et nous afficherons cette structure de manière récursive.

$folder1 = new Folder('folder_1');
$folder2 = new Folder('folder_2');
$folder3 = new Folder('folder_3');
$file1 = new File('file_1');
$file2 = new File('file_2');
$file3 = new File('file_3');

$rootFolder = new Folder('root');
$rootFolder->add($folder1);
$rootFolder->add($folder2);
$rootFolder->add($folder3);
$rootFolder->add($file1);
$rootFolder->add($file2);
$rootFolder->add($file3);

echo $rootFolder->display();

Sortie dans le terminal :

Folder: root
  Folder: folder_1
  Folder: folder_2
  Folder: folder_3
  File: file_1
  File: file_2
  File: file_3

Dans cet exemple, nous utilisons le Composite Pattern pour gérer une structure hiérarchique. Les dossiers peuvent contenir d'autres éléments, et la méthode display() parcourt récursivement chaque élément, qu'il s'agisse d'un fichier ou d'un dossier.

Explications

Dans le Iterator Pattern, la collection est parcourue de manière séquentielle, sans gestion de la hiérarchie ou de sous-dossiers. Chaque élément est traité indépendamment, qu'il s'agisse d'un fichier ou d'un dossier.
Le Composite Pattern permet de gérer une structure hiérarchique où les dossiers peuvent contenir d'autres dossiers ou fichiers. Il permet de manipuler des objets simples (fichiers) et des composites (dossiers) de manière unifiée et récursive.

Cas d'utilisation des patterns

Le Iterator Pattern est utile lorsqu'il s'agit de parcourir une collection simple à plat, comme une liste de fichiers et dossiers dans un répertoire sans structure imbriquée.
Le Composite Pattern est adapté aux structures hiérarchiques complexes, comme un système de fichiers avec des dossiers imbriqués. Il permet de manipuler des composants simples et composites de manière uniforme.

Conclusion

Le Iterator Pattern est parfait pour parcourir une collection séquentiellement, sans gestion de la hiérarchie. Cela convient bien pour des systèmes où les dossiers et fichiers ne sont pas imbriqués, ou si tu veux seulement lister des éléments à plat.
Le Composite Pattern est plus adapté pour des systèmes hiérarchiques où des objets individuels (fichiers) et des groupes d'objets (dossiers) doivent être manipulés de manière unifiée et récursive.

En résumé, le Iterator Pattern est idéal pour des collections à plat, tandis que le Composite Pattern convient mieux pour des structures arborescentes plus complexes comme des systèmes de fichiers imbriqués.