Échouer rapidement

Principe fondamental

Détectez et signalez les pannes dès qu'elles se produisent, empêchant ainsi les états non valides de se propager dans le système.

1. Validation des entrées

class UserRegistration {
    public function register(array $data): void {
        // Validate all inputs immediately
        $this->validateEmail($data['email']);
        $this->validatePassword($data['password']);
        $this->validateAge($data['age']);

        // Only proceed if all validations pass
        $this->createUser($data);
    }

    private function validateEmail(string $email): void {
        if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
            throw new ValidationException('Invalid email format');
        }
        if ($this->emailExists($email)) {
            throw new DuplicateEmailException('Email already registered');
        }
    }
}

Objectif :

• Empêche les données invalides d'entrer dans le système
• Économise les ressources en échouant avant des opérations complexes
• Fournit des messages d'erreur clairs aux utilisateurs
• Maintient l'intégrité des données

2. Chargement de la configuration

class AppConfig {
    private array $config;

    public function __construct(string $configPath) {
        if (!file_exists($configPath)) {
            throw new ConfigurationException("Config file not found: $configPath");
        }

        $config = parse_ini_file($configPath, true);
        if ($config === false) {
            throw new ConfigurationException("Invalid config file format");
        }

        $this->validateRequiredSettings($config);
        $this->config = $config;
    }

    private function validateRequiredSettings(array $config): void {
        $required = ['database', 'api_key', 'environment'];
        foreach ($required as $key) {
            if (!isset($config[$key])) {
                throw new ConfigurationException("Missing required config: $key");
            }
        }
    }
}

Objectif :

• Garantit que l'application démarre avec une configuration valide
• Empêche les erreurs d'exécution dues à des paramètres manquants
• Rend les problèmes de configuration immédiatement visibles
• Simplifie les problèmes de configuration du débogage

3. Initialisation des ressources

class DatabaseConnection {
    private PDO $connection;

    public function __construct(array $config) {
        try {
            $this->validateDatabaseConfig($config);
            $this->connection = new PDO(
                $this->buildDsn($config),
                $config['username'],
                $config['password'],
                [PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION]
            );
        } catch (PDOException $e) {
            throw new DatabaseConnectionException(
                "Failed to connect to database: " . $e->getMessage()
            );
        }
    }

    private function validateDatabaseConfig(array $config): void {
        $required = ['host', 'port', 'database', 'username', 'password'];
        foreach ($required as $param) {
            if (!isset($config[$param])) {
                throw new DatabaseConfigException("Missing $param in database config");
            }
        }
    }
}

Objectif :

• Veille à ce que les ressources soient correctement initialisées
• Empêche l'application de s'exécuter avec des ressources non valides
• Rend les problèmes de ressources visibles lors du démarrage
• Évite les échecs en cascade dus à des ressources non valides

4. Appels de service externe

class PaymentGateway {
    public function processPayment(Order $order): PaymentResult {
        // Validate API credentials
        if (!$this->validateApiCredentials()) {
            throw new ApiConfigurationException('Invalid API credentials');
        }

        // Validate order before external call
        if (!$order->isValid()) {
            throw new InvalidOrderException('Invalid order state');
        }

        try {
            $response = $this->apiClient->charge($order);

            if (!$response->isSuccessful()) {
                throw new PaymentFailedException($response->getError());
            }

            return new PaymentResult($response);
        } catch (ApiException $e) {
            throw new PaymentProcessingException(
                "Payment processing failed: " . $e->getMessage()
            );
        }
    }
}

Objectif :

• Empêche les appels d'API inutiles avec des données non valides
• Gagne du temps et des ressources
• Fournit un retour immédiat sur les problèmes d'API
• Maintient la fiabilité du système lors des interactions de service externe

5. Pipelines de traitement des données

class DataProcessor {
    public function processBatch(array $records): array {
        $this->validateBatchSize($records);

        $results = [];
        foreach ($records as $index => $record) {
            try {
                $this->validateRecord($record);
                $results[] = $this->processRecord($record);
            } catch (ValidationException $e) {
                throw new BatchProcessingException(
                    "Failed at record $index: " . $e->getMessage()
                );
            }
        }

        return $results;
    }

    private function validateBatchSize(array $records): void {
        if (empty($records)) {
            throw new EmptyBatchException('Empty batch provided');
        }

        if (count($records) > 1000) {
            throw new BatchSizeException('Batch size exceeds maximum limit');
        }
    }
}

Objectif :

• Assure la cohérence des données tout au long du traitement
• Empêche le traitement partiel des données invalides
• Rend les problèmes de données visibles rapidement
• Simplifie le suivi des erreurs dans les pipelines complexes
• Maintient l'intégrité des données tout au long des transformations

Avantages de l’échec rapide

1. Détection précoce des erreurs
2. Débogage plus propre
3. Empêche les pannes en cascade
4. Maintient l'intégrité des données
5. Améliore la fiabilité du système

Meilleures pratiques

1. Utilisez des déclarations de type fort
2. Mettre en œuvre une validation approfondie des entrées
3. Lancer des exceptions spécifiques
4. Valider tôt dans le processus
5. Utiliser des assertions dans le développement
6. Mettre en œuvre une gestion appropriée des erreurs
7. Enregistrer les échecs de manière appropriée

Quand utiliser Fail Fast

1. Validation des entrées
2. Chargement de la configuration
3. Initialisation des ressources
4. Appels de service externes
5. Pipelines de traitement des données

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!