Image de couverture - Fonctions Utilitaires (Utils ou Helpers) : 3 raisons d'en abuser

Fonctions Utilitaires (Utils ou Helpers) : 3 raisons d'en abuser

Les fonctions utilitaires, aussi appelées « utils » ou « helpers » sont omniprésentes dans les programmes informatiques. Mais quels sont leurs véritables atouts ?

Icône de calendrier
Icône de chronomètre 4 min

Dans le domaine du développement, la création d’applications robustes et évolutives nécessite une approche méthodique et organisée. Parmi les nombreux outils et pratiques qui soutiennent cette démarche, les fonctions utilitaires jouent un rôle crucial. Dans cet article, nous explorerons l’importance des fonctions utilitaires et comment elles contribuent à simplifier et à améliorer la qualité de notre code.

Qu’est-ce qu’une fonction utilitaire ?

Une fonction utilitaire, comme son nom l’indique, est une fonction autonome conçue pour accomplir une tâche spécifique, souvent simple et récurrente.

Aussi couramment appelées « utils » ou « helpers », les fonctions utilitaires servent à effectuer des opérations générales et qui ne sont pas directement liées à la logique d’un objet ou d’une classe spécifique.

Elles sont indépendante du contexte et peuvent être réutilisés dans différentes parties d’une application.

Les fonctions utilitaires sont souvent regroupées dans un dossier ou un module dédié (par exemple 📂 utils ou 📂 helpers), ce qui favorise une meilleure organisation et une meilleure réutilisabilité du code.

Cas d’usages

Voici une liste non-exhaustive de cas d’usages courants des fonctions utilitaires, accompagnés d’exemples d’implémentation avec le langage JavaScript.

1. Manipulation de chaînes de caractères

Une fonction utilitaire peut être utilisée pour des opérations courantes sur les chaînes de caractères :

  • Mise en majuscule/minuscule
  • Troncature/Extraction
  • Concaténation
  • Comparaison
  • Etc.
// Tronque un texte en affichant les X premiers caractères suivis de "..."
function truncate(str, maxLength) {
	return str.length <= maxLength ? str : str.substring(0, maxLength) + "...";
}

const truncatedText = truncate("Coucou les geekos", 10);
console.log(truncatedText); // => "Coucou les..."

2. formatage

Une fonction utilitaire peut être utilisée pour le formatage selon des conventions spécifiques :

  • Dates
  • Devises
  • Unités de mesure
  • Etc.
// Formate une date au format jj/mm/yyyy
function formatDate(date) {
  const day = String(date.getDate()).padStart(2, '0');
  const month = String(date.getMonth() + 1).padStart(2, '0');
  const year = date.getFullYear();
  return `${day}/${month}/${year}`;
}

const currentDate = new Date();
const formattedDate = formatDate(currentDate);
console.log(formattedDate); // Exemple => "16/04/2024"

3. Validation de données

Une fonction utilitaire peut être utilisée pour valider des données (souvent des saisies utilisateurs) :

  • Adresses email
  • Numéros de téléphone
  • Codes postaux
// Fonction de validation de format d'email
function validateEmail(email) {
  const regex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
  return regex.test(email);
}

const email1IsValid = validateEmail("totogmail.com");
const email2IsValid = validateEmail("[email protected]");

console.log(email1IsValid); // => false
console.log(email2IsValid); // => true

4. Traitement des tableaux et des objets

Elles peuvent fournir des fonctionnalités de traitement de tableaux et objets :

  • Tri
  • Filtrage
  • Transformations
  • Etc.
// Filtre les nombres (pairs ou imparis) d'un tableau
function filter(numbers, method) {
	return method === 'even'
    ? numbers.filter((num) => num % 2 === 0)
    : numbers.filter((num) => num % 2 === 1);
}

const evenNumbers = filter([1, 4, 9, 7, 2], 'even');
console.log(evenNumbers); // => [4, 2]

5. Génération de valeurs

Elles peuvent être utilisées pour générer valeurs :

  • Identifiants uniques
  • Mots de passe
  • Etc.
// Génère un mot de passe aléatoire
function randomPassword(length) {
  const charset = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789&!-@_%*/<>';
  let password = "";
  for (let i = 0; i < length; i++) {
    const randomIndex = Math.floor(Math.random() * charset.length);
    password += charset[randomIndex];
  }
  return password;
}

const pwd = randomPassword(14);
console.log(pwd); // Exemple => e6hDt!Ox8Y@q-2

6. Cryptage

Pour sécuriser les informations sensibles en les cryptant par chiffrement ou hachage.

// Fonction pour chiffrer un texte en décalant les lettres de X
function caesarCipher(str, shift) {
  return str.replace(/[a-z]/gi, char => String.fromCharCode((char.charCodeAt(0) - 97 + shift) % 26 + 97));
}

const encryptedMessage = caesarCipher("Hello, world!", 3);
console.log(encryptedMessage); // => "Khoor, zruog!"

Pourquoi utiliser des fonctions utilitaires ?

Améliorer la lisibilité

L’une des principales raisons de l’utilisation des fonctions utilitaires est la simplification du code.

Les fonctions utilitaires abstraient la complexité en encapsulant des algorithmes et des opérations, ce qui rend le code plus lisible et plus facile à comprendre.

Réutilisabilité

Les fonctions utilitaires permettent de réduire la redondance du code en factorisant des opérations fréquemment utilisées en un seul endroit.

Modularité

En isolant des fonctionnalités spécifiques dans des fonctions autonomes, les utilitaires favorisent une architecture modulaire, où chaque fonction accomplit une tâche clairement définie.

Maintenabilité et évolutivité

En séparant les fonctionnalités spécifiques en fonctions utilitaires, les développeurs peuvent facilement :

  • Tester les fonctions
  • Détecter et corriger les erreurs lorsqu’elles surviennent

En adoptant une approche modulaire, les développeurs peuvent également ajouter de nouvelles fonctionnalités ou apporter des modifications sans perturber le reste de l’application, ce qui améliore l’évolutivité et la maintenabilité du code.

En conclusion, les fonctions utilitaires jouent un rôle crucial pour résoudre des problèmes de développement courants de manière efficace. Leur utilisation permet d’améliorer la lisibilité, de favoriser la réutilisabilité et la modularité, et de faciliter la maintenance et l’évolutivité à long terme. En intégrant judicieusement les fonctions utilitaires dans vos projets, vous pourrez créer des applications plus robustes.

Lire aussi