Fonctionnel ou POO en Swift : que choisir pour un projet iOS ?

Deux faces d'une même médaille : Approche fonctionnelle vs orientée objet en Swift

Quand j'ai commencé à développer pour iOS, je pensais que la programmation orientée objet était la seule voie correcte. Classes, héritage, polymorphisme – tout cela sonnait comme une écriture sacrée pour un développeur. Mais ensuite, j'ai découvert la programmation fonctionnelle en Swift, et le monde a basculé. Il s'avère que l'on peut écrire du code qui ne mute pas l'état, qui est facile à tester et qui ressemble à une formule mathématique.

Swift est un langage unique. Il est multi-paradigme. Cela signifie que vous pouvez mélanger POO et approche fonctionnelle dans un même projet, en prenant le meilleur des deux mondes. Mais comment ne pas se perdre ? Quand utiliser les classes, et quand utiliser les closures et map ? Voyons cela.

Swift orienté objet : un classique qui fonctionne

La programmation orientée objet (POO) en Swift se construit autour des classes, des protocoles et de l'héritage. C'est un paradigme où les données et le comportement vivent ensemble. Vous créez un modèle – par exemple, « Utilisateur » – et cet objet sait lui-même comment se présenter, comment changer son nom ou calculer son âge.

Voici un exemple classique en Swift :

class User {\n    var name: String\n    var age: Int\n    \n    init(name: String, age: Int) {\n        self.name = name\n        self.age = age\n    }\n    \n    func greet() -> String {\n        return "Bonjour, je m'appelle \\(name) et j'ai \\(age) ans."\n    }\n    \n    func haveBirthday() {\n        age += 1\n    }\n}\n\nlet user = User(name: "Anna", age: 25)\nuser.haveBirthday()\nprint(user.greet()) // Bonjour, je m'appelle Anna et j'ai 26 ans.

Dans ce code, nous utilisons l'approche orientée objet en Swift. Nous avons un état (propriétés name, age) qui peut changer (méthode haveBirthday). C'est intuitif, surtout si vous venez de Java ou C++. Mais il y a un hic : l'état mutable est une source de bugs. Plus les objets se modifient entre eux, plus il est difficile de déboguer le programme.

Swift fonctionnel : la puissance des closures et de l'immuabilité

La programmation fonctionnelle en Swift propose un autre regard. Ici, les fonctions sont des « citoyens de première classe ». Vous pouvez les passer en paramètres, les retourner depuis d'autres fonctions et les stocker dans des variables. Le principe principal est celui des fonctions pures (pure functions), qui ne modifient pas l'état externe et retournent toujours le même résultat pour les mêmes données d'entrée.

Voyons à quoi ressemble le même exemple dans un style fonctionnel :

struct User {\n    let name: String\n    let age: Int\n}\n\nfunc greet(user: User) -> String {\n    return "Bonjour, je m'appelle \\(user.name) et j'ai \\(user.age) ans."\n}\n\nfunc haveBirthday(user: User) -> User {\n    return User(name: user.name, age: user.age + 1)\n}\n\nlet user = User(name: "Anna", age: 25)\nlet olderUser = haveBirthday(user: user)\nprint(greet(user: olderUser)) // Bonjour, je m'appelle Anna et j'ai 26 ans.

Remarquez : nous utilisons une structure (struct), et non une classe. Les structures en Swift sont des types de valeur (value types). Elles sont copiées lors de l'affectation. La fonction haveBirthday ne mute pas l'objet d'origine, mais en crée un nouveau. C'est l'idée clé de l'approche fonctionnelle – l'immuabilité (immutability).

Comparaison des approches : quand utiliser quoi ?

Comparons maintenant honnêtement la POO et la programmation fonctionnelle en Swift. Chacune a ses points forts.

Approche orientée objet en Swift

\n
• Avantages : Intuitive pour modéliser le monde réel. Parfaitement adaptée aux composants d'interface utilisateur (UIViewController, UIView). L'héritage simplifie la réutilisation du code.
\n
• Inconvénients : Mutabilité