---
title: "Reemplazar Código de Error con Excepción"
type: "refactoring-technique"
slug: "replace-error-code-with-exception"
url: "http://localhost:3000/es/replace-error-code-with-exception.md"
category: "Simplifying Method Calls"
description: "Problema: ¿Un método devuelve un valor especial que indica un error? Solución: Lanza una excepción en su lugar."
languages: ["java", "csharp", "php", "python", "typescript"]
---
# Reemplazar Código de Error con Excepción

> Problema: ¿Un método devuelve un valor especial que indica un error? Solución: Lanza una excepción en su lugar.

## Problem

¿Un método devuelve un valor especial que indica un error?

## Solution

Lanza una excepción en su lugar.

## Why Refactor

Devolver códigos de error es un vestigio obsoleto de la programación procedimental. En la programación moderna, la gestión de errores la realizan clases especiales, llamadas excepciones. Si se produce un problema, «lanzas» un error, que luego es «capturado» por uno de los manejadores de excepciones. Se activa un código especial de gestión de errores, que se ignora en condiciones normales, para responder.

## Benefits

* Libera al código de una gran cantidad de condicionales para comprobar diversos códigos de error. Los manejadores de excepciones son una forma mucho más concisa de diferenciar las rutas de ejecución normales de las anómalas.
* Las clases de excepción pueden implementar sus propios métodos, conteniendo así parte de la funcionalidad de gestión de errores (como el envío de mensajes de error).
* A diferencia de las excepciones, los códigos de error no pueden usarse en un constructor, ya que un constructor debe devolver únicamente un objeto nuevo.

## How to Refactor

Intenta realizar estos pasos de refactorización para un solo código de error a la vez. Esto facilitará mantener toda la información importante en tu cabeza y evitar errores.

1. Encuentra todas las llamadas a un método que devuelve códigos de error y, en lugar de comprobar un código de error, envuélvela en bloques `try`/`catch`.
2. Dentro del método, en lugar de devolver un código de error, lanza una excepción.
3. Cambia la firma del método para que contenga información sobre la excepción que se lanza (sección `@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">Se lanza cuando 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;
}
```