La mutabilité et l'immutabilité sont des concepts essentiels en programmation informatique. Découvrez tout ce que vous devez savoir sur cette notion, et les avantages de chacun de ces deux états !
Pour créer du code informatique stable et efficace, il est essentiel de connaître les principes fondamentaux. La mutabilité et l'immutabilité font partie de ces principes.
Tous les développeurs doivent connaître ces notions, et tenter de les implémenter dans leurs travaux. À travers ce dossier, découvrez tout ce que vous devez savoir sur la mutabilité et l'immutabilité et comment appliquer ces concepts à vos projets.
Mutable vs Immutable : qu'est-ce que c'est ?
En programmation, un objet peut avoir un état mutable et immuable. Cet état détermine la façon dont les variables peuvent être assignées et modifiées.
À l'heure où la plupart des sites web et applications sont dynamiques, les données ont impérativement besoin d'être modifiées. Toutefois, la façon dont ces données changent varie.
Les objets mutables peuvent être modifiés, ou mutés, après avoir été créés, et transformés en autres données ou variables. Au contraire, les objets immuables ne peuvent être changés.
On peut les comparer à des faits établis, des sources de confiance. Les données ou variables resteront identiques. Pour travailler avec de nouvelles données, il sera nécessaire d'effectuer une copie de l'objet et d'effectuer les modifications ci-dessus.
Quels sont les avantages de l'immutabilitée ?
La mutation des objets peut avoir des effets imprévisibles. Lorsque le code ou l'état d'un objet mute, des erreurs peuvent survenir. Il est donc souvent préférable d'opter pour l'immutabilité.
Cet état apporte plusieurs avantages, dont une lisibilité améliorée. Les variables restent identiques, ce qui permet de mieux comprendre le code et de raisonner dessus.
Même si l'écriture de code immuable peut demander plus d'efforts, il sera plus rapide de le mettre à jour sur le long terme. Sa gestion est également plus efficace.
Autre avantage : le code immuable offre une meilleure traçabilité. Il est très facile de vérifier comment et où les données ont été modifiées dans le code, et de déterminer quelles parties de l'application requièrent d'être rechargées avec chaque changement.
La sécurité est également renforcée, car un objet immuable restera valide et sûr. Aucun processus en arrière-plan ne sera capable de le modifier sans que vous le sachiez.
L'immutabilité est aussi adaptée à la programmation modulaire. Pour cause, la mutation des modules peut provoquer la perte des avantages liés à la modularité comme la lisibilité et la testabilité du code.
En outre, le cache des références des objets immuables est possible puisqu'ils ne changeront pas. Enfin, le test et le débogage du code sont largement simplifiés.
Avantages de la mutabilité
L'immutabilité présente de nombreux avantages, mais tous les programmeurs ne travaillent pas de cette façon. Ceci s'explique par plusieurs facteurs.
Tout d'abord, de nombreux développeurs ne connaissent pas ce concept. Beaucoup de programmeurs continuent aussi à utiliser les objets mutables par manque de temps ou par paresse. La mutabilité permet souvent de réduire le code, et le nombre de variables à nommer.
Pourtant, utiliser la mutation pour accélérer le processus peut provoquer une perte de temps ultérieure puisqu'il sera nécessaire de retrouver les bugs engendrés. Il est donc essentiel de soupeser les avantages et inconvénients de chaque approche.
Dans certains cas, il n'est tout simplement pas possible d'éviter la mutation. C'est notamment le cas pour des modifications apportées à l'interface utilisateur. Par exemple, modifier dynamiquement le HTML d'une page quand l'utilisateur clique sur un bouton requiert une mutation.
De même, quand la vitesse est la priorité, la mutation de valeurs peut s'avérer plus adéquate que de les copier chaque fois qu'un changement peut permettre d'accélérer l'interface. C'est notamment le cas pour les développeurs de jeux vidéo ou les programmeurs de logiciels boursiers avec des tableaux en temps réel.
Enfin, pour les applications et programmes les plus petits, les risques associés à la mutation n'ont pas suffisamment d'impact pour s'en inquiéter. C'est le cas lorsque la sécurité et les performances ne sont pas cruciales.
Qu’en est-il de la mutabilité avec JavaScript ?
Certains langages ont des caractéristiques comme les mots-clés requis, distinguant clairement les variables mutables et immuables ou restreignant les éléments pouvant muter. Par exemple, dans certains cas, seules les variables créées peuvent muter. Ces caractéristiques et restrictions rendent la mutation plus complexe.
Ce n'est pas le cas de JavaScript. Presque tous les éléments peuvent être mutés facilement, et certaines fonctionnalités du langage se comportent d'une certaine façon parce qu'elles utilisent la mutation en interne.
Par nature, JavaScript simplifie fortement la mutation de variables. Il est même possible de muter les prototypes, y compris les Arrays (tableaux) et les Objets.
Malheureusement, la mutation est la source de nombreux bugs dans les applications web JavaScript. Un problème courant survient lorsque l'appel d'une fonction provoque la mutation d'une valeur dans le code.
Si un autre morceau du code utilise aussi cette valeur, il ne réalisera pas forcément que la fonction a été appelée et se comportera comme s'il s'agissait d'une autre valeur.
Les « Live Collections » sont des listes de nœuds ou d'éléments mutables. Ceci englobe toute méthode JavaScript retournant une HTMLCollection ou une Live NodeList, puisque ces types de données se mettent à jour automatiquement quand le DOM change.
Une NodeList peut d'ailleurs être « live » ou « statique ». Parmi ces méthodes, GetElementsByName retourne une Live NodeList Collection d'éléments dans le document avec un nom donné, GetElementsByTagName retourne une Live HTMLColllection d'éléments ayant le nom de tag indiqué, et GetElementsByClassName retourne une Live HTMLCollection contenant tous les éléments avec le nom de classe donné.
Les méthodes de Live Collection sont mutables, car leur valeur change pour refléter les changements sur les éléments de la page. Toute action de mise à jour du DOM, comme l'ajout ou la suppression d'éléments ou le changement de texte, entraîne une mise à jour de la Live Collection.
Ceci peut compliquer le développement, car il n'est pas possible de contrôler complètement les changements du DOM. La liste des éléments peut aussi changer pendant les opérations de calcul, causant des effets secondaires inattendus. Ceci peut même mener à une mauvaise expérience utilisateur.
Il est souvent préférable de choisir une alternative immuable aux Live Collections, comme les Elements Arrays (tableaux d'éléments). Ceci permet de cloner les tableaux, d'effectuer des changements sur les ensembles d'éléments clonés identiques à la version live, puis de les insérer à nouveau dans la page pour remplacer les éléments originaux.
De nombreuses méthodes JavaScript d'obtention d'éléments du DOM retournent des collections ou des tableaux live. Il n'est donc pas possible de les éviter totalement.
Parmi les méthodes JavaScript utilisant la mutation, on compte les méthodes de mutation de tableau, les déclarations de variable, les fonctions void, les méthodes de mutation de carte, de set, ou encore les arguments de fonction mutants.
Immutable vs Mutable avec Python
La mutabilité d'objets est l'une des caractéristiques qui font de Python un langage dynamique. Tous les éléments sont traités comme des objets, et chaque objet a trois attributs : l'identité, le type et la valeur. L'identité et le type ne peuvent être changés après la création, mais les valeurs peuvent être changées pour des objets mutables.
En langage Python, la mutabilité est la capacité des objets à changer leurs valeurs. Il s'agit généralement d'objets stockant une collection de données.
On parle d'immutabilité quand la valeur d'un objet ne peut être modifiée au cours du temps. Une fois créée, la valeur de l'objet est permanente.
Les objets mutables sont les listes, les sets, les dictionnaires. Les objets immuables sont les nombres, les strings, les tuples et les ensembles gelés. Pour les classes définies par l'utilisateur, tout dépend des caractéristiques choisies.
Les listes Python sont des types de données mutables, car les éléments composant la liste peuvent être modifiés. Les éléments individuels peuvent être remplacés, et l'ordre des éléments peut être modifié même après la création de la liste.
Les tuples présentent une structure de données similaire aux listes, mais sont immuables. Une fois que les éléments sont ajoutés et que le tuple est créé, il restera inchangé. Toutefois, comme les listes, les tuples peuvent contenir n'importe quel objet Python y compris des objets mutables.
Les sets ou ensembles sont des collections de types de données pouvant être utilisés pour effectuer des opérations mathématiques. Chaque élément d'un set est unique et immuable. Les valeurs ne peuvent être changées, mais il est possible d'ajouter et de retirer des éléments puisque le set lui-même est mutable.
Immutable ou mutable, un choix crucial pour les développeurs
Vous l'aurez compris : la mutabilité et l'immutabilité présentent chacune des avantages et des inconvénients. Pour chaque projet de code, il est essentiel de choisir la bonne approche en fonction des contraintes et du langage de programmation utilisé.
Pour essayer d'implémenter l'une de ces deux notions, vous pouvez commencer par choisir un projet et suivre les résultats pour vérifier l'impact. En cas d'effet positif sur le flux de travail ou le produit, libre à vous d'adopter cette approche pour vos futurs projets et mises à jour.
Afin d'apprendre à manier les meilleures pratiques de développement logiciel, vous pouvez choisir DevUniversity. Nos formations à distance vous permettent de maîtriser tous les outils et techniques requis pour devenir ingénieur DevOps. Découvrez DevUniversity !
Vous savez tout sur la notion de mutabilité en programmation. Pour plus d'informations sur le même sujet, découvrez notre dossier sur les pipelines DevOps.
