Revisión de escenarios de refactorización de código y procedimientos recomendados de GitHub Copilot

6 minutos

La refactorización de código es el proceso de reestructuración del código existente sin cambiar su comportamiento. Las ventajas de la refactorización incluyen mejorar la legibilidad del código, reducir la complejidad, facilitar el mantenimiento del código y permitir que se agreguen más fácilmente nuevas características. La implementación de procedimientos recomendados de GitHub Copilot puede ayudarle a trabajar de forma más eficaz y obtener mejores resultados.

Procedimientos recomendados de GitHub Copilot

GitHub Copilot es una herramienta eficaz que puede ayudarle a refactorizar y mejorar el código. Sin embargo, para obtener los mejores resultados, debe seguir algunos procedimientos recomendados al usar Copilot.

Mejora las respuestas con mejores indicaciones

Puede mejorar la calidad de las respuestas de Copilot escribiendo mensajes más eficaces. Un aviso bien diseñado puede ayudar a Copilot a comprender mejor sus requisitos y generar sugerencias de código más relevantes.

Las instrucciones siguientes pueden ayudarle a escribir mejores mensajes:

Comience de manera general y luego sea específico.

Generate a Calculator class. Add methods for addition, subtraction, multiplication, division, and factorial. Don't use any external libraries and don't use recursion.

Proporcione ejemplos de lo que desea.

Generate a function that takes a string and returns the number of vowels in it. For example: findVowels("hello") returns 2, findVowels("sky") returns 0.

Divida las tareas complejas en tareas más sencillas.

En lugar de pedir a Copilot que "Genere una aplicación de planificador de comidas", divida los mensajes en tareas más pequeñas.

Por ejemplo:

Generate a function that takes a list of ingredients and returns a list of recipes.

Generate a function that takes a list of recipes and returns a shopping list.

Generate a function that takes a list of recipes and returns a meal plan for the week.

Proporcione el contexto adecuado, como selecciones de código, archivos, salida del terminal, etc.

Por ejemplo, use la #codebase variable para hacer referencia a todo el código base: "¿Dónde se usa la cadena de conexión de la base de datos en #codebase?"
Iteración en las indicaciones.

Proporcione avisos de seguimiento para refinar o modificar la respuesta.

Por ejemplo, si comienzas con la siguiente indicación:

"Escriba una función para calcular el factorial de un número".

Puede realizar un seguimiento con:

"No use recursividad ni optimice mediante el almacenamiento en caché".

Y después:

"Use nombres de variables significativos".
Mantenga relevante el historial de chats.

Copilot usa el historial de la conversación para proporcionar contexto. Quite las preguntas y respuestas anteriores del historial si no son relevantes. O bien, inicie una nueva sesión si desea cambiar el contexto.

Proporcionar el contexto y las herramientas adecuados

Enriquecer las solicitudes con contexto relevante para obtener respuestas más precisas y relevantes en el chat. Con las herramientas adecuadas, puede aumentar la productividad del desarrollador.

En el modo de agente, seleccione el botón herramientas para configurar las herramientas que desea usar, o agregarlas explícitamente a la consulta.
Use #codebase para permitir que Copilot encuentre automáticamente los archivos correctos mediante la realización de una búsqueda de código.
Use la #fetch herramienta para capturar contenido de una página web o usar #githubRepo para realizar una búsqueda de código en un repositorio de GitHub.
Haga referencia a archivos, carpetas o símbolos en su indicación mediante #<file name>, #<folder name> o #<symbol>.
Arrastre y coloque archivos, carpetas o pestañas del editor en el campo de chat.
Agregue problemas, errores de prueba o salida del terminal al mensaje de chat para dar contexto específico al escenario.

Nota:

Cuando se usa el modo de agente, Copilot busca de forma autónoma los archivos y el contexto pertinentes.

Escenarios comunes de refactorización de código

GitHub Copilot puede ayudarle a refactorizar rápidamente el código de muchas maneras. En la lista siguiente se incluyen algunos escenarios comunes para refactorizar código:

Optimización del código ineficaz
Limpieza del código repetido
Hacer que el código sea más conciso
División de unidades complejas de código
Volver a escribir código condicional para mejorar la legibilidad
Reformatear el código para usar una estructura diferente

Uso de GitHub Copilot para optimizar código ineficaz

Copilot puede ayudarle a optimizar el código. Por ejemplo, puede optimizar el código para que el código se ejecute más rápidamente.

Tenga en cuenta el siguiente script de Bash:

#!/bin/bash
# Find all .txt files and count the number of lines in each file
for file in $(find . -type f -name "*.txt"); do
  wc -l "$file"
done

Puede usar características de chat para evaluar las opciones para optimizar distintos aspectos del script, como el rendimiento.

#!/bin/bash
# Find all .txt files and count the number of lines in each file (improved performance)
find . -type f -name "*.txt" -print0 | xargs -0 wc -l

Uso de GitHub Copilot para limpiar código repetido

Evitar la repetición hará que el código sea más fácil de revisar y depurar. Por ejemplo, si el mismo cálculo se realiza más de una vez en diferentes lugares de un archivo, puede mover el cálculo a una función.

En el siguiente ejemplo muy sencillo de JavaScript, el mismo cálculo (precio de artículo multiplicado por el número de artículos vendidos) se realiza en dos lugares.

let totalSales = 0;
let applePrice = 3;
let appleSold = 100;
totalSales += applePrice * appleSold;

let orangePrice = 2;
let orangeSold = 50;
totalSales += orangePrice * orangeSold;

console.log(`Total: ${totalSales}`);

Puede pedir a las características de chat que muevan el cálculo repetido a una función.

function calculateTotal(price, quantity) {
    return price * quantity;
}
let totalSales = 0;
let applePrice = 3;
let appleSold = 100;
totalSales += calculateTotal(applePrice, appleSold);

let orangePrice = 2;
let orangeSold = 50;
totalSales += calculateTotal(orangePrice, orangeSold);
console.log(`Total: ${totalSales}`);

Uso de GitHub Copilot para que el código sea más conciso

Si el código es innecesariamente detallado, puede ser difícil de leer y mantener. Copilot puede sugerir una versión más concisa del código seleccionado.

El siguiente código de Python genera el área de un rectángulo y un círculo, pero el código podría escribirse de forma más concisa:

def calculate_area_of_rectangle(length, width):
    area = length * width
    return area

def calculate_area_of_circle(radius):
    area = 3.14 * radius * radius
    return area

rectangle_length = 5
rectangle_width = 10
rectangle_area = calculate_area_of_rectangle(rectangle_length, rectangle_width)
print(f"Area of rectangle: {rectangle_area}")

circle_radius = 7
circle_area = calculate_area_of_circle(circle_radius)
print(f"Area of circle: {circle_area}")

GitHub Copilot puede ayudarle a refactorizar el código y hacerlo más conciso.

def calculate_area_of_rectangle(length, width):
    return length * width

def calculate_area_of_circle(radius):
    return 3.14 * radius * radius

rectangle_length = 5
rectangle_width = 10
print(f"Area of rectangle: {calculate_area_of_rectangle(rectangle_length, rectangle_width)}")

circle_radius = 7
print(f"Area of circle: {calculate_area_of_circle(circle_radius)}")

Uso de GitHub Copilot para dividir unidades complejas de código

Es probable que los métodos o funciones grandes que realizan varias operaciones ofrezcan menos oportunidades de reutilización que las funciones más pequeñas y sencillas que se centran en realizar una operación determinada. También pueden ser más difíciles de entender y depurar.

Copilot puede ayudarle a dividir bloques complejos de código en unidades más pequeñas que sean más adecuadas para su reutilización.

El siguiente código de Python es un ejemplo muy sencillo, pero muestra el principio de dividir una sola función en dos funciones que realizan operaciones concretas.

import pandas as pd
from pandas.io.formats.styler import Styler

def process_data(item, price):
    # Cleanse the data
    item = item.strip()    # Remove leading and trailing whitespace
    price = price.strip()  # Remove leading and trailing whitespace
    price = float(price)   # Convert price to a float
    # More cleansing operations can be added here

    # Create and print a DataFrame
    data = {'Item': [item], 'Price': [price]}
    df = pd.DataFrame(data)
    print(df.to_string(index=False))

# Example usage
item = "  Apple  "
price = "  1.50  "
process_data(item, price)

Puede usar Copilot para refactorizar el código para crear funciones para limpiar datos, imprimir datos y procesar datos.

import pandas as pd
from pandas.io.formats.styler import Styler

def cleanse_data(item, price):
    # Cleanse the data
    item = item.strip()    # Remove leading and trailing whitespace
    price = price.strip()  # Remove leading and trailing whitespace
    price = float(price)   # Convert price to a float
    return item, price

def print_data(item, price):
    # Create and print a DataFrame
    data = {'Item': [item], 'Price': [price]}
    df = pd.DataFrame(data)
    print(df.to_string(index=False))

def process_data(item, price):
    item, price = cleanse_data(item, price)
    print_data(item, price)

# Example usage
item = "  Apple  "
price = "  1.50  "
item, price = cleanse_data(item, price)
print_data(item, price)

Uso de GitHub Copilot para volver a escribir código condicional para mejorar la legibilidad

A menudo hay varias maneras de escribir código que sí, o no, se ejecuta en función de varias condiciones. Algunas estructuras condicionales son más adecuadas que otras para casos de uso concretos y elegir una estructura condicional alternativa a veces puede facilitar la lectura del código.

Este método de Java usa una serie de instrucciones if y else if para determinar qué operación se va a realizar:

public string getSound(String animal) {
    if (animal == null) {
        System.out.println("Animal is null");
    } else if (animal.equalsIgnoreCase("Dog")) {
        return "bark";
    } else if (animal.equalsIgnoreCase("Cat")) {
        return "meow";
    } else if (animal.equalsIgnoreCase("Bird")) {
        return "tweet";
    }
    return "unknown";
}

Una instrucción switch podría ser una mejor manera de aplicar la misma lógica.

/**
    * Returns the sound made by the specified animal.
    *
    * @param animal the name of the animal
    * @return the sound made by the animal, or "unknown" if the animal is not recognized
    */
public String getAnimalSound(String animal) {
    return switch (animal) {
        case null -> "Animal is null";
        case "Dog" -> "bark";
        case "Cat" -> "meow";
        case "Bird" -> "tweet";
        default -> "unknown";
    };
}

Uso de GitHub Copilot para volver a formatear el código para usar una estructura diferente

Supongamos que tiene la siguiente función en JavaScript:

function listRepos(o, p) {
    return fetch(`https://api.github.com/orgs/${o}/repos?per_page=${parseInt()}`)
        .then(response => response.json())
        .then( (data) => data);
}

Si los estándares de codificación requieren que use la notación de flecha para las funciones y los nombres descriptivos de los parámetros, puede usar Copilot para ayudarle a realizar estos cambios.

const listRepositories = (organization, perPage) => {
    return fetch(`https://api.github.com/orgs/${organization}/repos?per_page=${parseInt(perPage)}`)
        .then(response => response.json())
        .then(data => data);
};

Resumen

GitHub Copilot puede ayudarle a refactorizar el código de varias maneras. Puede usar la vista Chat o Chat en línea para pedir a Copilot que optimice el código ineficaz, limpie el código repetido, haga que el código sea más conciso, divida unidades complejas de código, reescriba el código condicional para mejorar la legibilidad y volver a formatear el código para usar una estructura diferente.