Un niveau d'abstraction : la clé des fonctions propres

Avez-vous déjà regardé une fonction et vous êtes-vous senti perdu dans sa complexité ? Explorons un principe fondamental du code propre : les fonctions ne doivent maintenir qu'un seul niveau d'abstraction.

Voici un exemple concret de création d'utilisateurs dans une application Web :

// ❌ A function doing too many things at different abstraction levels
function createUser(userData) {
  // Validate data
  if (!userData.email || !userData.email.includes('@')) {
    return 'Invalid email';
  }
  if (userData.password.length < 8) {
    return 'Password too short';
  }

  // Hash password
  const salt = generateSalt();
  const hashedPassword = hashWithSalt(userData.password, salt);

  // Format user data
  const user = {
    email: userData.email.toLowerCase(),
    password: hashedPassword,
    salt: salt,
    createdAt: new Date()
  };

  // Save to DB
  saveUserToDatabase(user);
}

Cette fonction mélange différents niveaux d'abstraction :

• Logique métier de haut niveau (flux de création d'utilisateurs)
• Opérations de niveau intermédiaire (validation des données, formatage)
• Détails de bas niveau (hachage de mot de passe)

Refactorisons-le en suivant le principe du niveau unique d'abstraction :

// ✅ Clean version with one level of abstraction
function createUser(userData) {
  const validationError = validateUserData(userData);
  if (validationError) return validationError;

  const securePassword = hashPassword(userData.password);
  const formattedUser = formatUserData(userData.email, securePassword);

  return saveUserToDatabase(formattedUser);
}

function validateUserData({ email, password }) {
  if (!email || !email.includes('@')) return 'Invalid email';
  if (password.length < 8) return 'Password too short';
  return null;
}

function hashPassword(password) {
  const salt = generateSalt();
  return {
    hash: hashWithSalt(password, salt),
    salt
  };
}

function formatUserData(email, securePassword) {
  return {
    email: email.toLowerCase(),
    password: securePassword.hash,
    salt: securePassword.salt,
    createdAt: new Date()
  };
}

Avantages de cette approche

1. Lisibilité : La fonction principale se lit comme une histoire, décrivant ce qui se passe à un niveau élevé
2. Maintenabilité : Chaque fonction a une responsabilité unique, ce qui rend les changements plus sûrs
3. Testabilité : Vous pouvez tester chaque élément de logique indépendamment
4. Réutilisabilité : Ces fonctions ciblées peuvent être réutilisées dans d'autres contextes

Points clés à retenir

Lors de l'écriture de fonctions :

• Gardez-les concentrés sur un seul niveau d'abstraction
• Extraire des opérations complexes dans des fonctions bien nommées
• Faire en sorte que la fonction principale raconte une histoire
• Pensez à chaque fonction comme une seule étape de votre processus

Rappelez-vous : Si vous mélangez « comment » et « quoi » dans la même fonction, vous avez probablement affaire à plusieurs niveaux d'abstraction. Séparez-les !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!