YAGNI (Vous n'en aurez pas besoin)

Principe fondamental

Implémentez les fonctionnalités uniquement lorsque vous en avez réellement besoin, et non lorsque vous pensez en avoir besoin à l'avenir.

Exemples

Abstraction prématurée (mauvaise)

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

Implémentation simple (bonne)

class UserService {
    private $database;

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

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

Scénarios du monde réel

Exemple de commerce électronique

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

Anti-modèles courants

1. Construire des systèmes de configuration complexes avant d'en avoir besoin
2. Création de hiérarchies d'héritage élaborées pour une extensibilité future
3. Ajout de champs de base de données pour de futures fonctionnalités potentielles
4. Mise en œuvre de points de terminaison d'API inutiles
5. Créer des solutions génériques pour des problèmes spécifiques

Avantages

1. Complexité de base de code réduite
2. Coût de maintenance réduit
3. Cycles de développement plus rapides
4. Mieux se concentrer sur les exigences actuelles
5. Moins de dette technique

Cas d'exception

1. Décisions d'architecture de base
2. Structures de données dont la modification ultérieure coûte cher
3. Considérations de sécurité
4. Exigences de conformité réglementaire

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!