---
title: "Substituir Código de Erro por Exceção"
type: "refactoring-technique"
slug: "replace-error-code-with-exception"
url: "http://localhost:3000/pt-br/replace-error-code-with-exception.md"
category: "Simplifying Method Calls"
description: "Problema: Um método retorna um valor especial que indica um erro? Solução: Em vez disso, lance uma exceção."
languages: ["java", "csharp", "php", "python", "typescript"]
---
# Substituir Código de Erro por Exceção

> Problema: Um método retorna um valor especial que indica um erro? Solução: Em vez disso, lance uma exceção.

## Problem

Um método retorna um valor especial que indica um erro?

## Solution

Em vez disso, lance uma exceção.

## Why Refactor

Retornar códigos de erro é um resquício obsoleto da programação procedural. Na programação moderna, o tratamento de erros é feito por classes especiais, chamadas de exceções. Se ocorre um problema, você “lança” um erro, que então é “capturado” por um dos tratadores de exceção. Um código especial de tratamento de erros, que é ignorado em condições normais, é ativado para responder.

## Benefits

* Livra o código de um grande número de condicionais para verificar diversos códigos de erro. Os tratadores de exceção são uma forma muito mais concisa de diferenciar os caminhos de execução normais dos anormais.
* As classes de exceção podem implementar seus próprios métodos, contendo assim parte da funcionalidade de tratamento de erros (como o envio de mensagens de erro).
* Ao contrário das exceções, os códigos de erro não podem ser usados em um construtor, já que um construtor deve retornar apenas um novo objeto.

## How to Refactor

Procure executar esses passos de refatoração para apenas um código de erro de cada vez. Isso facilitará manter todas as informações importantes na cabeça e evitar erros.

1. Encontre todas as chamadas a um método que retorna códigos de erro e, em vez de verificar um código de erro, envolva-as em blocos `try`/`catch`.
2. Dentro do método, em vez de retornar um código de erro, lance uma exceção.
3. Altere a assinatura do método para que contenha informações sobre a exceção que está sendo lançada (seção `@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">Lançada quando 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;
}
```