# Refactorización para implementar un patrón de diseño

Copilot Chat puede sugerir patrones de diseño que puede usar para mejorar el código.

El código que no sigue los patrones de diseño establecidos (como Singleton, Factory u Observer) puede generar problemas como acoplamiento estricto, falta de flexibilidad o código duplicado.

Copilot Chat puede ayudarle a usar patrones de diseño adecuados para que el código sea más flexible y fácil de mantener. Por ejemplo, puede recomendar la conversión de instancias repetitivas en un patrón Factory, o el uso del patrón Observer para desacoplar clases estrechamente conectadas.

> \[!NOTE] Las respuestas descritas en este artículo son ejemplos.
> Copilot Chat las respuestas son no deterministas, por lo que puede obtener respuestas diferentes de las que se muestran aquí.

## Escenario de ejemplo

Este código de JavaScript crea tres objetos `Person`, cada uno con las propiedades `name` y `age`. A continuación, usa el nombre de una persona para recuperar e imprimir su edad.

```javascript id=person-module
class Person {
  constructor(name, age) {
    this.name = name;
    this.age = age;
  }
}

var people = {};

function addPerson(name, age) {
  people[name] = new Person(name, age);
}

function getAge(name) {
  if (people[name]) {
    console.log(name + " is " + people[name].age + " years old.");
  } else {
    console.log("Person not found.");
  }
}

addPerson("Ana", 30);
addPerson("Mario", 25);
addPerson("Louise", 40);

getAge("Mario");
```

## Ejemplo de solicitud 1

```copilot copy prompt ref=person-module
What design patterns could improve this code? Don't show me code examples.
```

## Respuesta de ejemplo 1

Copilot sugiere los siguientes patrones:

* **Patrón Singleton**: para garantizar que solo haya una instancia del objeto `people`.
* **Patrón de Fábrica**: para desarrollar una fábrica que cree objetos `Person`.
* **Patrón de Módulo**: para encapsular el objeto `people` y las funciones relacionadas dentro de un módulo para evitar la contaminación del espacio de nombres global.

## Ejemplo de mensaje 2

Ahora puede pedirle a Copilot que implemente el patrón que considere más adecuado.

```copilot copy prompt ref=person-module
Refactor this code using the module pattern
```

## Respuesta de ejemplo 2

```javascript
const PersonModule = (function() {
  class Person {
    constructor(name, age) {
      this.name = name;
      this.age = age;
    }
  }

  const people = {};

  function addPerson(name, age) {
    people[name] = new Person(name, age);
  }

  function getAge(name) {
    if (people[name]) {
      console.log(name + " is " + people[name].age + " years old.");
    } else {
      console.log("Person not found.");
    }
  }

  return {
    addPerson,
    getAge
  };
})();

PersonModule.addPerson("Ana", 30);
PersonModule.addPerson("Mario", 25);
PersonModule.addPerson("Louise", 40);

PersonModule.getAge("Mario");
```

El patrón Module mejora la organización del código y la privacidad de los datos y reduce el riesgo de conflictos de nomenclatura, lo que hace que el código sea más escalable y fácil de mantener.

## Lectura adicional

* [Ingeniería de mensajes para GitHub Copilot Chat](/es/copilot/concepts/prompting/prompt-engineering)
* [Procedimientos recomendados para usar GitHub Copilot](/es/copilot/get-started/best-practices)