Examinar cenários de refatoração de código e práticas recomendadas de 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 GitHub Copilot práticas recomendadas pode ajudá-lo a trabalhar com mais eficiência e obter melhores resultados.

práticas recomendadas GitHub Copilot

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 GitHub Copilot.

Melhorar as respostas com prompts melhores

Você pode aprimorar a qualidade das respostas de GitHub Copilot escrevendo prompts mais eficazes. Um prompt bem elaborado pode ajudar GitHub Copilot 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 GitHub 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 variável #codebase para se referir a toda a base de código: "Onde está a string de conexão do banco de dados usada na base de código?"
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.

GitHub 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.

Visual Studio Code compacta automaticamente o histórico de conversas quando a janela de contexto é preenchida. Você também pode usar o comando /compact a qualquer momento para resumir manualmente a conversa e liberar espaço de contexto. O controle da janela de contexto na caixa de entrada do chat mostra o uso atual.

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 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 GitHub Copilot encontre os arquivos certos automaticamente executando uma pesquisa de código.
Use a ferramenta #fetch para buscar conteúdo de uma página da Web ou usar #githubRepo para executar uma pesquisa de código em um repositório de 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 Agente, GitHub Copilot localiza de forma autônoma os arquivos e o contexto relevantes para você.

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

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 GitHub Copilot para otimizar o código ineficiente

GitHub 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 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 GitHub Copilot para tornar o código mais conciso

Se o código for desnecessariamente detalhado, poderá ser difícil de ler e manter. GitHub 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}")

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 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.

GitHub 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 GitHub 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 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 GitHub Copilot para reformatar 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 GitHub 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

GitHub Copilot pode ajudá-lo a refatorar código de várias maneiras. Você pode utilizar a visualização de Chat ou o Chat integrado para pedir ao GitHub Copilot que otimize códigos ineficientes, elimine repetições, torne o código mais conciso, separe unidades de código complexas, reescreva estruturas condicionais para melhorar a legibilidade e reorganize o código para adotar uma estrutura diferente.

Comentários

Esta página foi útil?