YAGNI (Du wirst es nicht brauchen)

Grundprinzip

Implementieren Sie Funktionen nur dann, wenn Sie sie tatsächlich benötigen, und nicht, wenn Sie glauben, dass Sie sie in Zukunft benötigen könnten.

Beispiele

Vorzeitige Abstraktion (schlecht)

// Over-engineered solution anticipating future needs
class UserService {
    private $database;
    private $cache;
    private $logger;
    private $notifications;
    private $analytics;

    public function __construct(
        DatabaseInterface $database,
        CacheInterface $cache,
        LoggerInterface $logger,
        NotificationService $notifications,
        AnalyticsService $analytics
    ) {
        $this->database = $database;
        $this->cache = $cache;
        $this->logger = $logger;
        $this->notifications = $notifications;
        $this->analytics = $analytics;
    }

    public function createUser($data) {
        $this->logger->info('Creating user');
        $user = $this->database->insert('users', $data);
        $this->cache->set('user_' . $user->id, $user);
        $this->notifications->sendWelcomeEmail($user);
        $this->analytics->trackUserCreation($user);
        return $user;
    }
}

Einfache Implementierung (gut)

class UserService {
    private $database;

    public function __construct(DatabaseInterface $database) {
        $this->database = $database;
    }

    public function createUser($data) {
        return $this->database->insert('users', $data);
    }
}

Szenarien aus der realen Welt

Beispiel für E-Commerce

// Bad: Implementing unused features
class Product {
    private $name;
    private $price;
    private $stock;
    private $weight;          // Not needed yet
    private $dimensions;      // Not needed yet
    private $shippingZones;   // Not needed yet
    private $taxCategories;   // Not needed yet
    private $customFields;    // Not needed yet

    public function calculateShipping($address) {
        // Complex shipping calculation that isn't required
    }

    public function calculateTax($country) {
        // Complex tax calculation that isn't required
    }
}

// Good: Implementing what's needed now
class Product {
    private $name;
    private $price;
    private $stock;

    public function __construct(string $name, float $price, int $stock) {
        $this->name = $name;
        $this->price = $price;
        $this->stock = $stock;
    }
}

Gängige Anti-Patterns

1. Aufbau komplexer Konfigurationssysteme, bevor sie benötigt werden
2. Erstellen ausgefeilter Vererbungshierarchien für zukünftige Erweiterbarkeit
3. Hinzufügen von Datenbankfeldern für potenzielle zukünftige Funktionen
4. Implementierung nicht benötigter API-Endpunkte
5. Generische Lösungen für spezifische Probleme erstellen

Vorteile

1. Reduzierte Komplexität der Codebasis
2. Geringere Wartungskosten
3. Schnellere Entwicklungszyklen
4. Bessere Konzentration auf aktuelle Anforderungen
5. Weniger technische Schulden

Ausnahmefälle

1. Kernarchitekturentscheidungen
2. Datenstrukturen, deren spätere Änderung teuer ist
3. Sicherheitsaspekte
4. Anforderungen zur Einhaltung gesetzlicher Vorschriften

Das obige ist der detaillierte Inhalt vonYAGNI (Du wirst es nicht brauchen). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!