Examinar cenários de refatoração de código e práticas recomendadas do GitHub Copilot

6 minutos

O código de refatoração é o processo de reestruturação do código existente sem alterar seu comportamento. Os benefícios da refatoração incluem melhorar a legibilidade do código, reduzir a complexidade, facilitar a manutenção do código e permitir que novos recursos sejam adicionados com mais facilidade. Implementar as melhores práticas do GitHub Copilot pode ajudá-lo a trabalhar com mais eficiência e obter melhores resultados.

Práticas recomendadas do GitHub Copilot

O GitHub Copilot é uma ferramenta poderosa que pode ajudá-lo a refatorar e melhorar seu código. No entanto, para obter os melhores resultados, você deve seguir algumas práticas recomendadas ao usar o Copilot.

Melhorar as respostas com prompts melhores

Você pode melhorar a qualidade das respostas do Copilot escrevendo prompts mais eficazes. Um prompt bem elaborado pode ajudar o Copilot a entender melhor seus requisitos e gerar sugestões de código mais relevantes.

As diretrizes a seguir podem ajudá-lo a escrever prompts melhores:

Inicie geral e, em seguida, seja 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.

Dê exemplos do que você deseja.

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 tarefas complexas em tarefas mais simples.

Em vez de pedir ao Copilot para "Gerar um aplicativo de planejador de refeições", divida suas solicitações em tarefas menores.

Por exemplo:

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.

Forneça o contexto certo, como seleções de código, arquivos, saída de terminal e muito mais.

Por exemplo, use a #codebase variável para fazer referência a toda a base de código: "Onde a cadeia de conexão de banco de dados é usada em #codebase?"
Iterar nos seus prompts.

Forneça prompts de acompanhamento para refinar ou modificar a resposta.

Por exemplo, se você começar com o seguinte prompt:

"Escreva uma função para calcular o fatorial de um número."

Você pode seguir com:

"Não use a recursão e a otimização usando o cache."

E, em seguida:

"Usar nomes de variáveis significativos."
Mantenha o histórico de chat relevante.

Copilot usa o histórico da conversa para fornecer contexto. Remova perguntas e respostas anteriores do histórico se elas não forem relevantes. Ou inicie uma nova sessão se você quiser alterar o contexto.

Fornecer o contexto e as ferramentas corretos

Enriqueça seus prompts com contexto relevante para obter respostas mais precisas e relevantes no chat. Com as ferramentas certas, você pode aumentar a produtividade do desenvolvedor.

No modo de agente, selecione o botão ferramentas para configurar as ferramentas que você deseja usar ou adicioná-las explicitamente ao prompt.
Use #codebase para permitir que o Copilot localize os arquivos certos automaticamente executando uma pesquisa de código.
Use a #fetch ferramenta para buscar conteúdo de uma página da Web ou usar #githubRepo para executar uma pesquisa de código em um repositório GitHub.
Referenciar arquivos, pastas ou símbolos em seu prompt usando #<file name>, #<folder name>ou #<symbol>.
Arraste e solte arquivos, pastas ou guias do editor no prompt de chat.
Adicione problemas, falhas de teste ou output do terminal às suas mensagens de chat para fornecer contexto específico ao cenário.

Observação

Quando você usa o modo de agente, o Copilot localiza de forma autônoma os arquivos e o contexto relevantes para você.

Cenários comuns de refatoração de código

O GitHub Copilot pode ajudá-lo a refatorar rapidamente o código de várias maneiras. A lista a seguir inclui alguns cenários comuns para refatoração de código:

Otimizar o código ineficiente
Limpar código repetido
Tornar o código mais conciso
Dividir unidades complexas de código
Reescrever código condicional para melhor legibilidade
Reformatação de código para usar uma estrutura diferente

Usar o GitHub Copilot para otimizar o código ineficiente

Copilot pode ajudá-lo a otimizar o código. Por exemplo, você pode otimizar seu código para fazer com que o código seja executado mais rapidamente.

Considere o seguinte script 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

Você pode usar recursos de chat para avaliar opções para otimizar diferentes aspectos do script, como desempenho.

#!/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

Usar o GitHub Copilot para limpar código repetido

Evitar a repetição facilitará a revisão e a depuração do código. Por exemplo, se o mesmo cálculo for executado mais de uma vez em locais diferentes em um arquivo, você poderá mover o cálculo para uma função.

No seguinte exemplo muito simples de JavaScript, o mesmo cálculo (preço do item multiplicado pelo número de itens vendidos) é executado em dois locais.

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}`);

Você pode pedir que os recursos de chat movam o cálculo repetido para uma função.

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}`);

Usar o GitHub Copilot para tornar o código mais conciso

Se o código for desnecessariamente detalhado, poderá ser difícil de ler e manter. Copilot pode sugerir uma versão mais concisa do código selecionado.

O código Python a seguir gera a área de um retângulo e um círculo, mas o código pode ser escrito de forma mais 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}")

O GitHub Copilot pode ajudá-lo a refatorar o código e torná-lo mais 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)}")

Usar o GitHub Copilot para dividir unidades complexas de código

Métodos ou funções grandes que executam várias operações provavelmente oferecerão menos oportunidades de reutilização do que funções menores e mais simples que se concentram na execução de uma operação específica. Eles também podem ser mais difíceis de entender e depurar.

O Copilot pode ajudá-lo a dividir blocos complexos de código em unidades menores que são mais adequadas para reutilização.

O código Python a seguir é um exemplo muito simples, mas mostra o princípio de dividir uma única função em duas funções que executam operações específicas.

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)

Você pode usar o Copilot para refatorar o código para criar funções para limpar dados, imprimir dados e processar dados.

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)

Usar o GitHub Copilot para reescrever o código condicional para melhor legibilidade

Frequentemente, há várias maneiras de escrever código que é executado, ou não, dependendo de diversas condições. Algumas estruturas condicionais são mais adequadas do que outras para casos de uso específicos, e escolher uma estrutura condicional alternativa às vezes pode facilitar a leitura do código.

Esse método Java usa uma série de instruções if e else if para determinar qual operação executar:

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";
}

A instrução switch pode ser uma melhor maneira de aplicar a mesma 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";
    };
}

Usar o GitHub Copilot para reformatar o código para usar uma estrutura diferente

Suponha que você tenha a seguinte função em JavaScript:

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

Se os padrões de codificação exigirem que você use a notação de seta para funções e nomes descritivos para parâmetros, você poderá usar Copilot para ajudá-lo a fazer essas alterações.

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

Resumo

O GitHub Copilot pode ajudá-lo a refatorar o código de várias maneiras. Você pode usar a exibição chat ou o chat embutido para pedir ao Copilot que otimize o código ineficiente, limpe o código repetido, torne o código mais conciso, divida unidades complexas de código, reescreva o código condicional para melhor legibilidade e reformate o código para usar uma estrutura diferente.

Comentários

Esta página foi útil?