Trop de types primitifs

Usage de types primitifs au lieu de petits objets pour des tâches simples

Dans un code bien structuré, il est préférable de créer de petits objets pour représenter des informations spécifiques telles que les devises, les intervalles de valeurs ou les numéros de téléphone. Cependant, une obsession des types primitifs se manifeste lorsque des entiers, des chaînes de caractères ou d'autres types primitifs sont employés à la place d'objets dédiés. Par exemple, au lieu de concevoir une classe « Devise » pour manipuler des valeurs monétaires, le code utilise un simple float ou int. Ce choix, bien qu'initialement pratique, finit par complexifier la maintenance et la lisibilité du code.

Utilisation de constantes pour encoder des informations

Une pratique courante dans ce contexte est de définir des constantes pour signifier des informations spécifiques, comme ROLE_UTILISATEUR_ADMIN = 1, pour désigner les utilisateurs administrateurs. Ce type de codage par des valeurs numériques ou textuelles devient problématique dès lors que le nombre de rôles ou de catégories augmente, ou si ces valeurs nécessitent des modifications. Cette approche de codage rigide limite l’évolutivité du code et peut facilement introduire des erreurs subtiles.

Emploi de chaînes de caractères constantes comme noms de champs dans des tableaux de données

Trop de primitifs se manifeste également lorsque des chaînes de caractères sont utilisées comme clés dans des tableaux ou dictionnaires pour représenter des noms de champs. Par exemple, dans une classe contenant un tableau de données hétérogènes, des constantes sous forme de chaînes de caractères sont définies pour accéder aux différents champs (par exemple, array["NOM_UTILISATEUR"]). Cette approche rend le code moins explicite, plus fragile et susceptible de générer des erreurs lorsque des modifications sont apportées aux champs.

Les causes

Une solution de facilité dans des moments de rapidité

Comme pour de nombreuses pratiques de codage mal avisées, l’obsession des types primitifs provient souvent d’une solution de facilité ou d'une approche temporaire qui devient permanente. Le développeur pourrait se dire : « Il me suffit d'un champ pour stocker cette donnée ! » Utiliser un type primitif est alors plus rapide que de créer une classe dédiée, ce qui est perçu comme un effort injustifié. Cependant, au fur et à mesure que de nouvelles données sont ajoutées de la même manière, la classe gonfle et devient difficile à manipuler et à maintenir.

Simulation de types par des primitives

Pour éviter de concevoir de nouveaux types, il est fréquent de recourir à des types primitifs qui « simulent » les types nécessaires. Cela conduit à des listes de valeurs autorisées sous forme de nombres ou de chaînes, qui servent de type de substitution. Les noms de ces valeurs spécifiques sont ensuite attribués via des constantes pour faciliter la lecture, mais cela entraîne une diffusion de ces constantes dans le code et rend difficile l’identification de leur signification et de leur logique.

Simulation de champs à l’aide de types primitifs

Un autre symptôme courant est l’utilisation de tableaux de données contenant des types primitifs pour simuler des champs. Ainsi, la classe inclut un tableau avec des données variées, et des constantes sous forme de chaînes de caractères servent d’index pour accéder à chaque type de donnée dans le tableau. Cette approche limite la clarté du code et augmente le risque d’erreurs, car ces chaînes d’index peuvent être facilement modifiées ou mal utilisées.

Gérer ce genre de cas

Créer des classes dédiées pour les groupes logiques de primitives

Lorsqu'une classe contient de nombreux champs primitifs, il peut être pertinent de les regrouper logiquement au sein d'une nouvelle classe qui porte un nom explicite, facilitant ainsi la compréhension de leur rôle. Par ailleurs, le comportement associé à ces données peut être déplacé dans cette classe, offrant une meilleure encapsulation et rendant le code plus maintenable. La technique Remplacer une valeur de donnée par un objet est recommandée.

Encapsuler les paramètres primitifs dans un objet

Lorsque des valeurs primitives sont fréquemment passées en paramètres dans les méthodes, il est judicieux de créer un objet paramètre pour les regrouper. Cela améliore la lisibilité et permet de conserver la cohérence des données transmises. Les techniques Introduire un objet paramètre et Préserver l’objet entier sont adaptées pour atteindre cet objectif.

Remplacer les codes de type par des classes ou des sous-classes

Lorsque des variables de type primitif servent à encoder des informations complexes, comme des codes de type, il est préférable de les remplacer par une classe ou des sous-classes dédiées. Par exemple, au lieu d'utiliser un int pour représenter des catégories d'utilisateurs, une classe TypeUtilisateur ou des sous-classes Admin, Client, etc., permettent de structurer le code de manière claire. Les techniques Remplacer un code de type par une classe, Remplacer un code de type par des sous-classes et Remplacer un code de type par un état/stratégie permettent d’adapter le code aux besoins spécifiques de chaque type.

Remplacer les tableaux par des objets

Dans les cas où des tableaux de données hétérogènes sont utilisés, remplacer ces tableaux par des objets permet d’assurer une meilleure structuration du code. Chaque champ de l'objet remplace un élément du tableau, rendant l’intention du code plus claire. Pour cette tâche, la technique Remplacer un tableau par un objet est recommandée.

Conclusion

L’utilisation d’objets en lieu et place des types primitifs permet d’augmenter la flexibilité du code. Les objets apportent une structure et peuvent évoluer avec les besoins, contrairement aux primitives qui imposent souvent des contraintes rigides.

Le regroupement des opérations sur des données spécifiques au sein de classes permet d'éviter la dispersion du code. Les opérations deviennent centralisées et le code devient plus simple à comprendre, avec des données explicites et des comportements associés. Cela élimine les suppositions sur la signification de certaines constantes ou sur les raisons de leur présence dans des tableaux.

La structuration par objets facilite l'identification de code dupliqué. Les doublons sont généralement plus difficiles à repérer lorsque des types primitifs sont disséminés dans le code, alors que les objets permettent de centraliser les données et les opérations, rendant plus évidentes les répétitions ou les similitudes dans les opérations.

Publié le

me contacter

* champ obligatoire