---
title: "Remplacer les conditions imbriquées par des clauses de garde"
type: "refactoring-technique"
slug: "replace-nested-conditional-with-guard-clauses"
url: "http://localhost:3000/fr/replace-nested-conditional-with-guard-clauses.md"
category: "Simplifying Conditional Expressions"
description: "Problème : Vous avez un groupe de conditions imbriquées et il est difficile de déterminer le flux normal d'exécution du code. Solution : Isolez toutes les vérifications spéciales et les cas limites dans des clauses distinctes et placez-les avant les vérifications principales. Idéalement, vous devriez obtenir une liste « plate » de conditions, les unes après les autres."
languages: ["java", "csharp", "php", "python", "typescript"]
---
# Remplacer les conditions imbriquées par des clauses de garde

> Problème : Vous avez un groupe de conditions imbriquées et il est difficile de déterminer le flux normal d'exécution du code. Solution : Isolez toutes les vérifications spéciales et les cas limites dans des clauses distinctes et placez-les avant les vérifications principales. Idéalement, vous devriez obtenir une liste « plate » de conditions, les unes après les autres.

## Problem

Vous avez un groupe de conditions imbriquées et il est difficile de déterminer le flux normal d'exécution du code.

## Solution

Isolez toutes les vérifications spéciales et les cas limites dans des clauses distinctes et placez-les avant les vérifications principales. Idéalement, vous devriez obtenir une liste « plate » de conditions, les unes après les autres.

## Why Refactor

Repérer la « condition infernale » est assez facile. Les indentations de chaque niveau d'imbrication forment une flèche pointant vers la droite, en direction de la douleur et du malheur :

if () {
    if () {
        do {
            if () {
                if () {
                    if () {
                        ...
                    }
                }
                ...
            }
            ...
        }
        while ();
        ...
    }
    else {
        ...
    }
}

Il est difficile de comprendre ce que fait chaque condition et comment, car le flux « normal » d'exécution du code n'est pas immédiatement évident. Ces conditions trahissent une évolution chaotique, chaque condition ayant été ajoutée comme une rustine, sans réflexion sur l'optimisation de la structure d'ensemble.

Pour simplifier la situation, isolez les cas particuliers dans des conditions distinctes qui mettent immédiatement fin à l'exécution et renvoient une valeur nulle si les clauses de garde sont vraies. En somme, votre mission ici est d'aplatir la structure.

## How to Refactor

Essayez de débarrasser le code de ses effets de bord — [Séparer la requête de la modification](/fr/separate-query-from-modifier) peut être utile à cette fin. Cette solution sera nécessaire pour le réagencement décrit ci-dessous.

1. Isolez toutes les clauses de garde qui mènent à la levée d'une exception ou au retour immédiat d'une valeur depuis la méthode. Placez ces conditions au début de la méthode.
2. Une fois le réagencement terminé et tous les tests passés avec succès, voyez si vous pouvez utiliser [Consolider une expression conditionnelle](/fr/consolidate-conditional-expression) pour les clauses de garde qui mènent aux mêmes exceptions ou valeurs de retour.
## Code Examples

### java

```java
// Before
public double getPayAmount() {
  double result;
  if (isDead){
    result = deadAmount();
  }
  else {
    if (isSeparated){
      result = separatedAmount();
    }
    else {
      if (isRetired){
        result = retiredAmount();
      }
      else{
        result = normalPayAmount();
      }
    }
  }
  return result;
}

// After
public double getPayAmount() {
  if (isDead){
    return deadAmount();
  }
  if (isSeparated){
    return separatedAmount();
  }
  if (isRetired){
    return retiredAmount();
  }
  return normalPayAmount();
}
```

### csharp

```csharp
// Before
public double GetPayAmount()
{
  double result;
  
  if (isDead)
  {
    result = DeadAmount();
  }
  else 
  {
    if (isSeparated)
    {
      result = SeparatedAmount();
    }
    else 
    {
      if (isRetired)
      {
        result = RetiredAmount();
      }
      else
      {
        result = NormalPayAmount();
      }
    }
  }
  
  return result;
}

// After
public double GetPayAmount() 
{
  if (isDead)
  {
    return DeadAmount();
  }
  if (isSeparated)
  {
    return SeparatedAmount();
  }
  if (isRetired)
  {
    return RetiredAmount();
  }
  return NormalPayAmount();
}
```

### php

```php
// Before
function getPayAmount() {
  if ($this->isDead) {
    $result = $this->deadAmount();
  } else {
    if ($this->isSeparated) {
      $result = $this->separatedAmount();
    } else {
      if ($this->isRetired) {
        $result = $this->retiredAmount();
      } else {
        $result = $this->normalPayAmount();
      }
    }
  }
  return $result;
}

// After
function getPayAmount() {
  if ($this->isDead) {
    return $this->deadAmount();
  }
  if ($this->isSeparated) {
    return $this->separatedAmount();
  }
  if ($this->isRetired) {
    return $this->retiredAmount();
  }
  return $this->normalPayAmount();
}
```

### python

```python
// Before
def getPayAmount(self):
    if self.isDead:
        result = deadAmount()
    else:
        if self.isSeparated:
            result = separatedAmount()
        else:
            if self.isRetired:
                result = retiredAmount()
            else:
                result = normalPayAmount()
    return result

// After
def getPayAmount(self):
    if self.isDead:
        return deadAmount()
    if self.isSeparated:
        return separatedAmount()
    if self.isRetired:
        return retiredAmount()
    return normalPayAmount()
```

### typescript

```typescript
// Before
getPayAmount(): number {
  let result: number;
  if (isDead){
    result = deadAmount();
  }
  else {
    if (isSeparated){
      result = separatedAmount();
    }
    else {
      if (isRetired){
        result = retiredAmount();
      }
      else{
        result = normalPayAmount();
      }
    }
  }
  return result;
}

// After
getPayAmount(): number {
  if (isDead){
    return deadAmount();
  }
  if (isSeparated){
    return separatedAmount();
  }
  if (isRetired){
    return retiredAmount();
  }
  return normalPayAmount();
}
```