Eine Abstraktionsebene: Der Schlüssel zu sauberen Funktionen

Haben Sie schon einmal eine Funktion betrachtet und sich in ihrer Komplexität verloren gefühlt? Lassen Sie uns ein grundlegendes Prinzip von sauberem Code untersuchen: Funktionen sollten nur eine Abstraktionsebene beibehalten.

Hier ist ein reales Beispiel für die Benutzererstellung in einer Webanwendung:

// ❌ 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);
}

Diese Funktion mischt verschiedene Abstraktionsebenen:

• Geschäftslogik auf hoher Ebene (Benutzererstellungsablauf)
• Operationen auf mittlerer Ebene (Datenvalidierung, Formatierung)
• Details auf niedriger Ebene (Passwort-Hashing)

Lassen Sie es uns nach dem Prinzip der einzelnen Abstraktionsebene umgestalten:

// ✅ 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()
  };
}

Vorteile dieses Ansatzes

1. Lesbarkeit: Die Hauptfunktion liest sich wie eine Geschichte und beschreibt, was auf hoher Ebene passiert
2. Wartbarkeit: Jede Funktion hat eine einzige Verantwortung, wodurch Änderungen sicherer werden
3. Testbarkeit: Sie können jeden Teil der Logik unabhängig testen
4. Wiederverwendbarkeit: Diese fokussierten Funktionen können in anderen Kontexten wiederverwendet werden

Wichtige Erkenntnisse

Beim Schreiben von Funktionen:

• Konzentrieren Sie sie auf eine Abstraktionsebene
• Extrahieren Sie komplexe Operationen in gut benannte Funktionen
• Lassen Sie die Hauptfunktion eine Geschichte erzählen
• Betrachten Sie jede Funktion als einen einzelnen Schritt in Ihrem Prozess

Denken Sie daran: Wenn Sie „wie“ und „was“ in derselben Funktion vermischen, haben Sie es wahrscheinlich mit mehreren Abstraktionsebenen zu tun. Teilen Sie sie auf!

Das obige ist der detaillierte Inhalt vonEine Abstraktionsebene: Der Schlüssel zu sauberen Funktionen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!