---
title: "Sustituir algoritmo"
type: "refactoring-technique"
slug: "substitute-algorithm"
url: "http://localhost:3000/es/substitute-algorithm.md"
category: "Composing Methods"
description: "Problema: ¿Quieres reemplazar un algoritmo existente por uno nuevo? Solución: Reemplaza el cuerpo del método que implementa el algoritmo por un algoritmo nuevo."
languages: ["java", "csharp", "php", "python", "typescript"]
---
# Sustituir algoritmo

> Problema: ¿Quieres reemplazar un algoritmo existente por uno nuevo? Solución: Reemplaza el cuerpo del método que implementa el algoritmo por un algoritmo nuevo.

## Problem

¿Quieres reemplazar un algoritmo existente por uno nuevo?

## Solution

Reemplaza el cuerpo del método que implementa el algoritmo por un algoritmo nuevo.

## Why Refactor

1. La refactorización gradual no es el único método para mejorar un programa. A veces un método está tan plagado de problemas que es más fácil derribarlo y empezar de cero. Y quizá hayas encontrado un algoritmo mucho más simple y eficiente. Si es así, simplemente debes reemplazar el algoritmo antiguo por el nuevo.
2. Con el tiempo, tu algoritmo puede incorporarse a una biblioteca o framework muy conocidos y quieres deshacerte de tu implementación independiente para simplificar el mantenimiento.
3. Los requisitos de tu programa pueden cambiar tanto que tu algoritmo existente no pueda aprovecharse para la tarea.

## How to Refactor

1. Asegúrate de haber simplificado el algoritmo existente todo lo posible. Mueve el código poco importante a otros métodos usando [Extraer método](/es/extract-method). Cuantas menos piezas móviles tenga tu algoritmo, más fácil será reemplazarlo.
2. Crea tu nuevo algoritmo en un método nuevo. Reemplaza el algoritmo antiguo por el nuevo y empieza a probar el programa.
3. Si los resultados no coinciden, vuelve a la implementación antigua y compara los resultados. Identifica las causas de la discrepancia. Aunque la causa suele ser un error en el algoritmo antiguo, es más probable que se deba a algo que no funciona en el nuevo.
4. Cuando todas las pruebas se completen con éxito, ¡elimina el algoritmo antiguo para siempre!
## Relations

**Eliminates smells**

- [Código Duplicado](/es/smells/duplicate-code.md)
- [Método Largo](/es/smells/long-method.md)

## Code Examples

### java

```java
// Before
String foundPerson(String[] people){
  for (int i = 0; i < people.length; i++) {
    if (people[i].equals("Don")){
      return "Don";
    }
    if (people[i].equals("John")){
      return "John";
    }
    if (people[i].equals("Kent")){
      return "Kent";
    }
  }
  return "";
}

// After
String foundPerson(String[] people){
  List candidates =
    Arrays.asList(new String[] {"Don", "John", "Kent"});
  for (int i=0; i < people.length; i++) {
    if (candidates.contains(people[i])) {
      return people[i];
    }
  }
  return "";
}
```

### csharp

```csharp
// Before
string FoundPerson(string[] people)
{
  for (int i = 0; i < people.Length; i++) 
  {
    if (people[i].Equals("Don"))
    {
      return "Don";
    }
    if (people[i].Equals("John"))
    {
      return "John";
    }
    if (people[i].Equals("Kent"))
    {
      return "Kent";
    }
  }
  return String.Empty;
}

// After
string FoundPerson(string[] people)
{
  List<string> candidates = new List<string>() {"Don", "John", "Kent"};
  
  for (int i = 0; i < people.Length; i++) 
  {
    if (candidates.Contains(people[i])) 
    {
      return people[i];
    }
  }
  
  return String.Empty;
}
```

### php

```php
// Before
function foundPerson(array $people){
  for ($i = 0; $i < count($people); $i++) {
    if ($people[$i] === "Don") {
      return "Don";
    }
    if ($people[$i] === "John") {
      return "John";
    }
    if ($people[$i] === "Kent") {
      return "Kent";
    }
  }
  return "";
}

// After
function foundPerson(array $people){
  foreach (["Don", "John", "Kent"] as $needle) {
    $id = array_search($needle, $people, true);
    if ($id !== false) {
      return $people[$id];
    }
  }
  return "";
}
```

### python

```python
// Before
def foundPerson(people):
    for i in range(len(people)):
        if people[i] == "Don":
            return "Don"
        if people[i] == "John":
            return "John"
        if people[i] == "Kent":
            return "Kent"
    return ""

// After
def foundPerson(people):
    candidates = ["Don", "John", "Kent"]
    return people if people in candidates else ""
```

### typescript

```typescript
// Before
foundPerson(people: string[]): string{
  for (let person of people) {
    if (person.equals("Don")){
      return "Don";
    }
    if (person.equals("John")){
      return "John";
    }
    if (person.equals("Kent")){
      return "Kent";
    }
  }
  return "";
}

// After
foundPerson(people: string[]): string{
  let candidates = ["Don", "John", "Kent"];
  for (let person of people) {
    if (candidates.includes(person)) {
      return person;
    }
  }
  return "";
}
```