Copypaste no desenvolvimento de aplicativos — o que é, por que é perigoso e como evitar

O que é copypaste?

Copypaste (programação copiar e colar) é mover código existente para um novo lugar com poucas ou nenhuma alteração. O termo é usado de forma pejorativa: implica que o desenvolvedor não está projetando uma solução, mas copiando mecanicamente um bloco pronto, muitas vezes sem entender completamente como ele funciona.

O copypaste é de dois tipos: intencional e acidental. Intencional — quando um desenvolvedor copia código deliberadamente com um plano para refatorar depois (mas o plano muitas vezes é abandonado). Acidental — quando a duplicação surge despercebida, por exemplo, dois desenvolvedores escrevem independentemente a mesma lógica para telas diferentes.

De acordo com o relatório SonarQube State of Clean Code (2025), o código duplicado representa em média 12–18 por cento do volume total de código em projetos comerciais. Ao mesmo tempo, o custo de corrigir um bug em código duplicado é 2,5 vezes maior do que em código com implementação única, porque o desenvolvedor precisa encontrar e corrigir todas as cópias.

A principal ferramenta contra o copypaste é o princípio DRY (Don't Repeat Yourself). No entanto, absolutizar o DRY também é perigoso: às vezes copiar é justificado quando duas cópias devem evoluir independentemente uma da outra. É importante distinguir entre “duplicação acidental” (que deve ser eliminada) e “duplicação necessária” (que deve ser documentada).

Por que o copypaste é perigoso

O primeiro e mais crítico perigo é a propagação de bugs. Se o código original tem um defeito, ele é copiado para todos os novos locais junto com o código. Quando o defeito é descoberto e corrigido no módulo original, as cópias permanecem sem correção. O desenvolvedor pode nem saber que o bug existe em cinco arquivos diferentes.

O segundo perigo é a evolução desigual. Duas cópias do mesmo algoritmo acumulam modificações diferentes ao longo do tempo. Uma cópia adiciona validação de valores limite, outra altera o formato de saída. Depois de alguns meses, torna-se impossível saber qual versão é a “correta” e o projeto perde consistência de comportamento.

O terceiro perigo é o aumento do volume de testes. Cada instância de copypaste requer seus próprios testes. Se a lógica comum for extraída em uma única função, ela pode ser coberta com um conjunto de testes e reutilizada. Com a duplicação, cada cópia deve ser testada separadamente — isso multiplica o tempo de execução de CI e o tamanho da base de testes a ser mantida.

O quarto perigo é a ilusão de produtividade. O copypaste cria uma falsa sensação de velocidade: o desenvolvedor cola rapidamente o código e vê que a tela funciona. Mas essa “velocidade” se transforma em dívida técnica que terá que ser paga com juros quando um bug for encontrado no bloco duplicado ou uma alteração na lógica de negócios for necessária.

Por que os desenvolvedores copiam código

Entender as razões do copypaste ajuda a estabelecer uma prevenção adequada. Na maioria das vezes, os desenvolvedores copiam código não por preguiça, mas por pressão de prazos, falta de conhecimento ou arquitetura inconveniente.

A primeira razão são os prazos apertados. Quando uma tela precisa ser feita em dois dias e uma tela semelhante já existe, o desenvolvedor a copia inteiramente e altera apenas o que o usuário vê. Não há tempo para refatorar e extrair um componente compartilhado — o cliente exige resultados. Como resultado, aparece uma segunda tela com 80 por cento de código compartilhado, mas com um histórico independente de alterações.

A segunda razão é a falta de uma abstração unificada. Se o projeto não possui um componente compartilhado para uma tarefa típica (por exemplo, uma tela de lista com pull-to-refresh), cada desenvolvedor escreverá sua própria implementação ou copiará a de um colega. As decisões arquiteturais tomadas no início do projeto afetam diretamente a quantidade de copypaste futuro.

A terceira razão é o medo de quebrar código funcional. O desenvolvedor sabe que o módulo existente funciona. Refatorar para extrair código compartilhado pode afetar a funcionalidade existente. Se a cobertura de testes é baixa, o risco de quebra supera o benefício percebido da refatoração, e o desenvolvedor escolhe o caminho seguro — copiar.

Aborde as causas, não os sintomas. Reduzir prazos e introduzir revisão de código não resolverá o problema se o projeto não tiver uma base arquitetural sólida. Invista tempo na criação de componentes reutilizáveis desde o início — é a única maneira de reduzir a tentação do copypaste no futuro.

Ferramentas de detecção de duplicatas

A detecção de copypaste é realizada por analisadores automáticos que comparam fragmentos de código e identificam correspondências acima de um determinado limite. As melhores ferramentas operam no nível de AST (Árvore de Sintaxe Abstrata) e ignoram formatação, nomes de variáveis e comentários.

PMD CPD (Copy-Paste Detector) é a ferramenta mais comum para Java, Kotlin, Swift, JavaScript, Python e C++. O CPD analisa os tokens do código fonte e encontra duplicatas mais longas que um número mínimo de tokens especificado (padrão 100). Configurar o limite é chave para resultados de qualidade: um limite muito baixo gera muitos falsos positivos (padrões comuns como imports), um limite muito alto perde duplicatas reais.

Executando PMD CPD via Gradle

plugins {
    id 'pmd'
}

pmd {
    toolVersion = '7.0.0'
    ruleSetFiles = files("pmd-rules.xml")
}

tasks.register('cpd') {
    doLast {
        exec {
            workingDir = projectDir
            commandLine 'cpd',
                '--minimum-tokens', '75',
                '--language', 'kotlin',
                '--files', 'src/main/kotlin',
                '--format', 'xml',
                '--failOnViolation', 'true'
        }
    }
}

SonarQube incorpora um detector de duplicatas diretamente no Quality Gate. A regra Duplicated Blocks (%) mostra a porcentagem de código duplicado. Um limite de 5 por cento é considerado saudável para projetos comerciais. Excedê-lo bloqueia a promoção para o branch de lançamento. O SonarQube também agrupa as duplicatas por tipo: correspondências exatas e cópias estruturais (com identificadores renomeados).

Para JavaScript e TypeScript, as duplicatas são detectadas usando ESLint com o plugin eslint-plugin-sonarjs (regra no-duplicate-string) e o utilitário jscpd, que suporta mais de 150 idiomas. O jscpd é especialmente conveniente para monorepositórios: ele encontra duplicatas entre pacotes, não apenas dentro de um único módulo.

Estratégias para refatorar código duplicado

A refatoração de copypaste se resume a um princípio: extrair a parte comum e parametrizar as diferenças. A técnica específica depende da extensão da duplicação e do contexto.

O caso mais simples é a duplicação dentro de uma mesma classe (por exemplo, dois métodos com a mesma lógica, mas tipos diferentes). A solução é generalizar com genéricos ou reutilizar um método com um parâmetro de tipo. Se a duplicação abranger várias classes — extraia o código comum para uma classe utilitária ou função de extensão.

Um caso mais complexo é a duplicação no nível de tela ou módulo. Aqui, simplesmente extrair uma função não ajuda, porque a estrutura da UI, a lógica do ciclo de vida e a vinculação de dados estão todas duplicadas. A solução é criar uma classe base de tela comum ou um componente de visão composto, e passar as diferenças através de parâmetros ou de um protocolo.

// before - two copies of the same UITableViewController
class UserListController: UITableViewController {
    private let viewModel = UserListViewModel()
    // 40 lines of code
}

class ProductListController: UITableViewController {
    private let viewModel = ProductListViewModel()
    // same 40 lines but with Product instead of User
}

// after - generic base class shared
class ListViewController<T: ListViewModel>: UITableViewController {
    let viewModel: T
    // 40 lines of code - once only

    init(viewModel: T) {
        self.viewModel = viewModel
        super.init(style: .plain)
    }
}

O caso mais complexo é a duplicação entre microsserviços ou bibliotecas. Extrair código compartilhado pode levar a dependências circulares ou acoplamento injustificado. Nesses casos, o copypaste pode ser uma decisão consciente: duas equipes mantêm serviços independentes, e uma biblioteca compartilhada cria mais problemas do que resolve. O segredo é documentar essa decisão e verificar regularmente se as cópias divergiram o suficiente para justificar a unificação.

Prevenção de copypaste a nível de equipe

Prevenir o copypaste é mais eficaz do que refatorar código já duplicado. As principais medidas preventivas estão na organização do processo de desenvolvimento, não na tecnologia.

A primeira medida é a revisão de código com foco em duplicação. A lista de verificação da revisão deve incluir o item: “Este PR contém código que já existe no projeto?” Se o revisor detectar copypaste — ele bloqueia a mesclagem até que o componente compartilhado seja extraído. Esse requisito deve fazer parte da Definition of Done da equipe.

A segunda medida é uma biblioteca de componentes compartilhada. Cada padrão de UI que aparece em duas ou mais telas deve ser extraído em um módulo comum. Crie um módulo compartilhado no projeto e torne-o o ponto de entrada obrigatório para todos os componentes de UI. Se um componente não existir — ele é criado primeiro, depois usado na tela.

A terceira medida é a automação em CI/CD. Adicione uma etapa de verificação de código duplicado ao pipeline (PMD CPD, jscpd, SonarQube). Exceder o limite resulta em falha de compilação. O desenvolvedor não pode mesclar um PR que aumente a proporção de copypaste acima do nível permitido. Isso transfere a responsabilidade da revisão de código para a automação e garante que nenhuma duplicata passe despercebida.

Cultive uma cultura de “uma implementação — um lugar.” Se você vir uma oportunidade de reutilização — não adie a refatoração para depois. Cada copypaste deixado “para depois” se multiplica e se transforma em dívida técnica incontrolável.