Grundlegender Leitfaden zum Refactoring von Code für ein saubereres und ausgefeilteres Design

In der schnelllebigen Welt der Softwareentwicklung ist das Schreiben von sauberem und wartbarem Code unerlässlich. Inspiriert von Onkel Bobs „Clean Code“ befassen wir uns mit fünf entscheidenden Refactoring-Prinzipien zur Verbesserung Ihrer Codebasis. Jedes Prinzip wird von TypeScript-Codebeispielen begleitet, die zeigen, wie diese Verbesserungen implementiert werden können. Lassen Sie uns gemeinsam unseren Code verfeinern!

1️⃣ Sagen Sie Nein zu großen Funktionen

Erklärung: Uncle Bob empfiehlt, die Funktionen prägnant zu halten, idealerweise weniger als 20 Zeilen. Große Funktionen können schwierig zu verstehen, zu testen und zu warten sein. Indem Sie Funktionen in kleinere, besser handhabbare Teile aufteilen, verbessern Sie die Lesbarkeit und reduzieren die Komplexität.

Vor dem Refactoring:

import fs from 'fs';

function processData(data: string[]): void {
    // Step 1: Validate data
    if (!Array.isArray(data)) {
        throw new Error("Input must be an array");
    }

    // Step 2: Clean data
    const cleanedData = data.map(item => item.trim()).filter(item => item !== '');

    // Step 3: Process data
    const result: string[] = [];
    for (const item of cleanedData) {
        if (item.length > 5) {
            result.push(item.toUpperCase());
        } else {
            result.push(item.toLowerCase());
        }
    }

    // Step 4: Save results
    fs.writeFileSync('results.txt', result.join('\n'));
}

Nach dem Refactoring:

import fs from 'fs';

function validateData(data: any): void {
    if (!Array.isArray(data)) {
        throw new Error("Input must be an array");
    }
}

function cleanData(data: string[]): string[] {
    return data.map(item => item.trim()).filter(item => item !== '');
}

function processItem(item: string): string {
    return item.length > 5 ? item.toUpperCase() : item.toLowerCase();
}

function saveResults(results: string[], filename: string = 'results.txt'): void {
    fs.writeFileSync(filename, results.join('\n'));
}

function processData(data: string[]): void {
    validateData(data);
    const cleanedData = cleanData(data);
    const results = cleanedData.map(processItem);
    saveResults(results);
}

2️⃣ Übernehmen Sie die Einzelverantwortung

Erklärung: Jede Klasse oder Methode sollte eine einzelne Verantwortung haben. Das bedeutet, dass jede Klasse oder Methode eine Sache tun sollte, und zwar gut. Durch die Einhaltung dieses Prinzips wird Ihr Code modularer, einfacher zu testen und flexibler zu ändern.

Vor dem Refactoring:

class User {
    constructor(public username: string, public email: string) {}

    sendEmail(message: string): void {
        // Code to send an email
        console.log(`Sending email to ${this.email}: ${message}`);
    }

    saveToDatabase(): void {
        // Code to save user to the database
        console.log(`Saving ${this.username} to the database`);
    }
}

Nach dem Refactoring:

class User {
    constructor(public username: string, public email: string) {}
}

class EmailService {
    sendEmail(email: string, message: string): void {
        // Code to send an email
        console.log(`Sending email to ${email}: ${message}`);
    }
}

class UserRepository {
    save(user: User): void {
        // Code to save user to the database
        console.log(`Saving ${user.username} to the database`);
    }
}

3️⃣ Vereinfachen Sie die Parameterübergabe

Erklärung: Durch die Begrenzung der Anzahl der Parameter, die eine Funktion akzeptiert, ist sie leichter zu verstehen und zu verwenden. Komplexe Funktionen mit vielen Parametern können verwirrend und fehleranfällig sein. Durch die Verwendung von Objekten oder Datenstrukturen können Sie zusammengehörige Parameter gruppieren.

Vor dem Refactoring:

function createUser(username: string, email: string, password: string, age: number, address: string): void {
    // Code to create a user
    console.log(`Creating user: ${username}, ${email}, ${password}, ${age}, ${address}`);
}

Nach dem Refactoring:

interface User {
    username: string;
    email: string;
    password: string;
    age: number;
    address: string;
}

function createUser(user: User): void {
    // Code to create a user
    console.log(`Creating user: ${user.username}, ${user.email}, ${user.password}, ${user.age}, ${user.address}`);
}

4️⃣ Vermeiden Sie magische Zahlen

Erklärung:Magische Zahlen sind wörtliche Zahlen, die ohne Erklärung direkt im Code verwendet werden. Sie können das Verständnis und die Wartung von Code erschweren. Das Ersetzen magischer Zahlen durch benannte Konstanten verbessert die Lesbarkeit und erleichtert zukünftige Änderungen.

Vor dem Refactoring:

function calculateDiscountedPrice(price: number): number {
    // Apply a discount of 15%
    return price * 0.85;
}

function calculateShippingCost(weight: number): number {
    // Shipping cost per kilogram
    return weight * 5;
}

Nach dem Refactoring:

const DISCOUNT_RATE = 0.15;
const SHIPPING_COST_PER_KG = 5;

function calculateDiscountedPrice(price: number): number {
    // Apply a discount
    return price * (1 - DISCOUNT_RATE);
}

function calculateShippingCost(weight: number): number {
    // Shipping cost per kilogram
    return weight * SHIPPING_COST_PER_KG;
}

5️⃣ Benennen Sie Variablen mit Bedeutung

Erklärung: Durch die Verwendung aussagekräftiger Variablennamen wird Ihr Code selbstdokumentierend und leichter verständlich. Vermeiden Sie aus einem Buchstaben bestehende oder kryptische Namen. Wählen Sie stattdessen Namen, die den Zweck und die Verwendung der Variablen klar zum Ausdruck bringen.

Vor dem Refactoring:

function calculate(u: number, v: number): number {
    const r = u + v;
    const p = r * 2;
    return p;
}

Nach dem Refactoring:

function calculateTotalCost(baseCost: number, additionalFees: number): number {
    const totalCost = baseCost + additionalFees;
    return totalCost;
}

Abschluss

Die Anwendung dieser Refactoring-Prinzipien auf Ihren TypeScript-Code wird dessen Klarheit, Wartbarkeit und Gesamtqualität erheblich verbessern. Saubere Codepraktiken sind für eine effektive Entwicklung und Zusammenarbeit von entscheidender Bedeutung.

Welche Refactoring-Strategien haben für Sie am besten funktioniert? Teilen Sie unten Ihre Erfahrungen oder Herausforderungen mit, mit denen Sie konfrontiert waren! ?

Das obige ist der detaillierte Inhalt vonGrundlegender Leitfaden zum Refactoring von Code für ein saubereres und ausgefeilteres Design. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!