---
title: "Remplacer un code d'erreur par une exception"
type: "refactoring-technique"
slug: "replace-error-code-with-exception"
url: "http://localhost:3000/fr/replace-error-code-with-exception.md"
category: "Simplifying Method Calls"
description: "Problème : une méthode renvoie une valeur spéciale qui indique une erreur ? Solution : levez plutôt une exception."
languages: ["java", "csharp", "php", "python", "typescript"]
---
# Remplacer un code d'erreur par une exception

> Problème : une méthode renvoie une valeur spéciale qui indique une erreur ? Solution : levez plutôt une exception.

## Problem

Une méthode renvoie une valeur spéciale qui indique une erreur ?

## Solution

Levez plutôt une exception.

## Why Refactor

Le renvoi de codes d'erreur est un héritage obsolète de la programmation procédurale. En programmation moderne, la gestion des erreurs est assurée par des classes spéciales appelées exceptions. Si un problème survient, vous « levez » une erreur, qui est ensuite « interceptée » par l'un des gestionnaires d'exceptions. Du code spécial de gestion des erreurs, ignoré en conditions normales, est alors activé pour réagir.

## Benefits

* Libère le code d'un grand nombre de conditions servant à vérifier divers codes d'erreur. Les gestionnaires d'exceptions sont un moyen bien plus concis de distinguer les chemins d'exécution normaux des chemins anormaux.
* Les classes d'exception peuvent implémenter leurs propres méthodes, et ainsi contenir une partie de la logique de gestion des erreurs (par exemple pour envoyer des messages d'erreur).
* Contrairement aux exceptions, les codes d'erreur ne peuvent pas être utilisés dans un constructeur, puisqu'un constructeur ne doit renvoyer qu'un nouvel objet.

## How to Refactor

Essayez d'effectuer ces étapes de refactorisation pour un seul code d'erreur à la fois. Il sera ainsi plus facile de garder en tête toutes les informations importantes et d'éviter les erreurs.

1. Trouvez tous les appels à une méthode qui renvoie des codes d'erreur et, au lieu de vérifier un code d'erreur, encadrez-les de blocs `try`/`catch`.
2. À l'intérieur de la méthode, au lieu de renvoyer un code d'erreur, levez une exception.
3. Modifiez la signature de la méthode pour qu'elle contienne des informations sur l'exception levée (section `@throws`).
## Code Examples

### java

```java
// Before
int withdraw(int amount) {
  if (amount > _balance) {
    return -1;
  }
  else {
    balance -= amount;
    return 0;
  }
}

// After
void withdraw(int amount) throws BalanceException {
  if (amount > _balance) {
    throw new BalanceException();
  }
  balance -= amount;
}
```

### csharp

```csharp
// Before
int Withdraw(int amount) 
{
  if (amount > _balance) 
  {
    return -1;
  }
  else 
  {
    balance -= amount;
    return 0;
  }
}

// After
///<exception cref="BalanceException">Levée lorsque amount > _balance</exception>
void Withdraw(int amount)
{
  if (amount > _balance) 
  {
    throw new BalanceException();
  }
  balance -= amount;
}
```

### php

```php
// Before
function withdraw($amount) {
  if ($amount > $this->balance) {
    return -1;
  } else {
    $this->balance -= $amount;
    return 0;
  }
}

// After
function withdraw($amount) {
  if ($amount > $this->balance) {
    throw new BalanceException;
  }
  $this->balance -= $amount;
}
```

### python

```python
// Before
def withdraw(self, amount):
    if amount > self.balance:
        return -1
    else:
        self.balance -= amount
    return 0

// After
def withdraw(self, amount):
    if amount > self.balance:
        raise BalanceException()
    self.balance -= amount
```

### typescript

```typescript
// Before
withdraw(amount: number): number {
  if (amount > _balance) {
    return -1;
  }
  else {
    balance -= amount;
    return 0;
  }
}

// After
withdraw(amount: number): void {
  if (amount > _balance) {
    throw new Error();
  }
  balance -= amount;
}
```