Fonctions utilitaires (utils ou helpers) : 3 raisons d'en abuser

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 en 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.

Maintenance et de l’é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.