Refatoração de código com o GitHub Copilot

Introdução

A refatoração de código é o processo de reestruturar código existente sem alterar seu comportamento. Os benefícios da refatoração incluem melhorar a legibilidade do código, reduzir a complexidade, tornar o código mais fácil de manter e permitir que novos recursos sejam adicionados com mais facilidade.

Este artigo fornece algumas ideias para usar o Copilot para refatorar o código em seu IDE.

Compreender o código

Antes de modificar o código existente, certifique-se de entender sua finalidade e como ele funciona no momento. O Copilot pode ajudar você a entendê-lo.

1. Selecione o código relevante no editor do IDE.

2. Abra o chat embutido:

   • No VS Code: Pressione Command+i (Mac) ou Ctrl+i (Windows/Linux).
   • No Visual Studio: Pressione Alt+/.
   • Em IDEs JetBrains: Pressione Control+Shift+i (Mac) ou Ctrl+Shift+g (Windows/Linux).

3. Na caixa de entrada do chat embutido, digite uma barra (/).

4. Na lista suspensa, selecione /explain e pressione Enter.

5. Se a explicação retornada por Copilot for maior do que algumas linhas, clique em Exibir no chat para permitir que você leia a explicação com mais facilidade.

Otimizando código ineficiente

O Copilot pode ajudar você a otimizar código, por exemplo, para fazer com que o código seja executado mais rapidamente.

Código de exemplo

Nas duas seções abaixo, usaremos o seguinte script bash de exemplo para demonstrar como otimizar código ineficiente:

#!/bin/bash

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

Usar o painel do Copilot Chat

O Copilot pode dizer se o código, como o script bash do exemplo, pode ser otimizado.

1. Selecione o loop for ou todo o conteúdo do arquivo.

2. Abra Copilot Chat clicando no ícone de chat na barra de atividades ou usando o atalho de teclado:

   • VS Code e Visual Studio: Control+Command+i (Mac) / Ctrl+Alt+i (Windows/Linux)
   • JetBrains: Control+Shift+c

3. Na caixa de entrada na parte inferior do painel de chat, digite: Can this script be improved?

   O Copilot responde com uma sugestão que tornará o código mais eficiente.

4. Para aplicar a alteração sugerida:

   • No VS Code e JetBrains: mova o ponteiro do mouse sobre a sugestão no painel de chat e clique no ícone Inserir no cursor.

     

   • No Visual Studio: Clique em Visualizar e, na exibição de comparação, clique em Aceitar.

Usar o chat embutido do Copilot

Como alternativa, se você já sabe que o código existente, como o script bash de exemplo, é ineficiente:

1. Selecione o loop for ou todo o conteúdo do arquivo.

2. Abra o chat embutido:

   • No VS Code: Pressione Command+i (Mac) ou Ctrl+i (Windows/Linux).
   • No Visual Studio: Pressione Alt+/.
   • Em IDEs JetBrains: Pressione Control+Shift+i (Mac) ou Ctrl+Shift+g (Windows/Linux).

3. Digite optimize e pressione Enter.

   O Copilot sugere o código revisado. Por exemplo:

   find . -type f -name "*.txt" -exec wc -l {} +
   

   Isso é mais eficiente do que o código original mostrado anteriormente neste artigo porque o uso de -exec ... + permite que find passe vários arquivos para wc ao mesmo tempo, em vez de chamar wc uma vez para cada arquivo *.txt encontrado.

4. Avalie a sugestão do Copilot e, se concordar com a alteração:

   • No VS Code e no Visual Studio: Clique em Aceitar.
   • No JetBrains: Clique no ícone Visualizar (setas duplas) e, em seguida, clique no ícone Aplicar todas as comparações (colchetes angulares duplos).

Como acontece com todas as sugestões do Copilot, você deve sempre verificar se o código revisado é executado sem erros e produz o resultado correto.

Limpando código repetido

Evitar a repetição tornará seu código mais fácil de revisar e depurar. 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 exemplo JavaScript muito simples a seguir, 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 applesSold = 100;
totalSales += applePrice * applesSold;

let orangePrice = 5;
let orangesSold = 50;
totalSales += orangePrice * orangesSold;

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

Você pode pedir ao Copilot para mover o cálculo repetido para uma função.

1. Selecione todo o conteúdo do arquivo.

2. Abra o chat embutido:

   • No VS Code: Pressione Command+i (Mac) ou Ctrl+i (Windows/Linux).
   • No Visual Studio: Pressione Alt+/.
   • Em IDEs JetBrains: Pressione Control+Shift+i (Mac) ou Ctrl+Shift+g (Windows/Linux).

3. Digite: move repeated calculations into functions e pressione Enter.

   O Copilot sugere o código revisado. Por exemplo:

   function calculateSales(price, quantity) {
     return price * quantity;
   }
   
   let totalSales = 0;
   
   let applePrice = 3;
   let applesSold = 100;
   totalSales += calculateSales(applePrice, applesSold);
   
   let orangePrice = 5;
   let orangesSold = 50;
   totalSales += calculateSales(orangePrice, orangesSold);
   
   console.log(`Total: ${totalSales}`);
   

4. Avalie a sugestão do Copilot e, se concordar com a alteração:

   • No VS Code e no Visual Studio: Clique em Aceitar.
   • No JetBrains: Clique no ícone Visualizar (setas duplas) e, em seguida, clique no ícone Aplicar todas as comparações (colchetes angulares duplos).

Como acontece com todas as sugestões do Copilot, você deve sempre verificar se o código revisado é executado sem erros e produz o resultado correto.

Tornando o código mais conciso

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

No exemplo a seguir, esse código Python gera a área de um retângulo e um círculo, mas 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):
    import math
    area = math.pi * (radius ** 2)
    return area

length_of_rectangle = 10
width_of_rectangle = 5
area_of_rectangle = calculate_area_of_rectangle(length_of_rectangle, width_of_rectangle)
print(f"Area of rectangle: {area_of_rectangle}")

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

1. Selecione todo o conteúdo do arquivo.

2. Abra o chat embutido:

   • No VS Code: Pressione Command+i (Mac) ou Ctrl+i (Windows/Linux).
   • No Visual Studio: Pressione Alt+/.
   • Em IDEs JetBrains: Pressione Control+Shift+i (Mac) ou Ctrl+Shift+g (Windows/Linux).

3. Digite: make this more concise e pressione Enter.

   O Copilot sugere o código revisado. Por exemplo:

   import math
   
   def calculate_area_of_rectangle(length, width):
     return length * width
   
   def calculate_area_of_circle(radius):
     return math.pi * (radius ** 2)
   
   print(f"Area of rectangle: {calculate_area_of_rectangle(10, 5)}")
   print(f"Area of circle: {calculate_area_of_circle(7)}")
   

4. Avalie a sugestão do Copilot e, se concordar com a alteração:

   • No VS Code e no Visual Studio: Clique em Aceitar.
   • No JetBrains: Clique no ícone Visualizar (setas duplas) e, em seguida, clique no ícone Aplicar todas as comparações (colchetes angulares duplos).

Como acontece com todas as sugestões do Copilot, você deve sempre verificar se o código revisado é executado sem erros e produz o resultado correto.

Dividindo 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 ajudar você 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.style import Styler

def process_data(item, price):
    # Cleanse data
    item = item.strip()  # Strip whitespace from item
    price = price.strip()  # Strip whitespace from price
    price = float(price) # Convert price to a float
    # More cleansing operations 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.25"
process_data(item, price)

Para dividir a função process_data:

1. Coloque o cursor no nome da função.

2. Abra o chat embutido:

   • No VS Code: Pressione Command+i (Mac) ou Ctrl+i (Windows/Linux).
   • No Visual Studio: Pressione Alt+/.
   • Em IDEs JetBrains: Pressione Control+Shift+i (Mac) ou Ctrl+Shift+g (Windows/Linux).

3. Digite: split into 2 separate functions: one for cleansing data, the other for printing e pressione Enter.

   O Copilot sugere o código revisado. Por exemplo:

   def cleanse_data(item, price):
     # Cleanse data
     item = item.strip()  # Strip whitespace from item
     price = price.strip()  # Strip whitespace from price
     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)
   

   Note

   A sugestão de exemplo mostrada acima substitui a função existente por três funções. A terceira função simplesmente chama as outras duas funções e permite o código existente que chama a função process_data.

4. Avalie a sugestão do Copilot e, se concordar com a alteração:

   • No VS Code e no Visual Studio: Clique em Aceitar.
   • No JetBrains: Clique no ícone Visualizar (setas duplas) e, em seguida, clique no ícone Aplicar todas as comparações (colchetes angulares duplos).

Como acontece com todas as sugestões do Copilot, você deve sempre verificar se o código revisado é executado sem erros e produz o resultado correto.

Reescreva o código condicional para melhor legibilidade

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

Este 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("Oops! A null animal?");
  } else if (animal.equalsIgnoreCase("Dog")) {
      return "Bark";
  } else if ( animal.equalsIgnoreCase("Cat")) {
      return "Meow";
  } else if ( animal.equalsIgnoreCase("Bird")) {
      return "Tweet";
  }
  return "Unknown";
}

Uma instrução switch pode ser uma maneira melhor de aplicar a mesma lógica.

1. Coloque o cursor no nome do método.

2. Abra o chat embutido:

   • No VS Code: Pressione Command+i (Mac) ou Ctrl+i (Windows/Linux).
   • No Visual Studio: Pressione Alt+/.
   • Em IDEs JetBrains: Pressione Control+Shift+i (Mac) ou Ctrl+Shift+g (Windows/Linux).

3. Digite: rewrite the condition to use a switch and use Java 21 syntax with null case, but also add documentation and provide a better function name.

   Isso demonstra como você pode usar um único prompt para solicitar que o Copilot faça várias alterações.

4. Pressione Enter.

   O Copilot sugere o código revisado. Por exemplo:

   /**
    * Retrieves the sound made by a given 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 -> {
               System.out.println("Oops! A null animal?");
               yield "Unknown";
           }
           case String a when a.equalsIgnoreCase("Dog") -> "Bark";
           case String a when a.equalsIgnoreCase("Cat") -> "Meow";
           case String a when a.equalsIgnoreCase("Bird") -> "Tweet";
           default -> "Unknown";
       };
   }
   

5. Avalie a sugestão do Copilot e, se concordar com a alteração:

   • No VS Code e no Visual Studio: Clique em Aceitar.
   • No JetBrains: Clique no ícone Visualizar (setas duplas) e, em seguida, clique no ícone Aplicar todas as comparações (colchetes angulares duplos).

Como acontece com todas as sugestões do Copilot, você deve sempre verificar se o código revisado é executado sem erros e produz o resultado correto.

Reformatar o código para usar uma estrutura diferente

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

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

Se seus 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 o Copilot para ajudá-lo a fazer essas alterações.

1. Coloque o cursor no nome da função.

2. Abra o chat embutido:

   • No VS Code: Pressione Command+i (Mac) ou Ctrl+i (Windows/Linux).
   • No Visual Studio: Pressione Alt+/.
   • Em IDEs JetBrains: Pressione Control+Shift+i (Mac) ou Ctrl+Shift+g (Windows/Linux).

3. Digite: use arrow notation and better parameter names e pressione Enter.

   O Copilot sugere o código revisado. Por exemplo:

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

Melhorando o nome de um símbolo

Nomes bem escolhidos podem ajudar a tornar a linguagem mais fácil de manter. O Copilot no VS Code e o Visual Studio podem sugerir nomes alternativos para símbolos como variáveis ou funções.

1. Coloque o cursor no nome do símbolo.

2. Pressione F2.

3. Somente Visual Studio: Pressione Ctrl+Espaço.

   O Copilot sugere nomes alternativos.

   

4. Na lista suspensa, selecione um dos nomes sugeridos.

   O nome é alterado em todo o projeto.