Por que variáveis ​​não utilizadas é um problema?

Eu estava limpando avisos de variáveis ​​não utilizadas um dia e comecei a refletir: qual é exatamente o problema deles?

De fato, alguns deles até ajudam na depuração (por exemplo, inspecionar detalhes da exceção ou verificar o valor de retorno antes de retornar).

Eu não conseguia encontrar um risco real de tê-los ..

Exemplos

Não quero dizer linhas que demoram a atenção de outros programadores, como:

int abc = 7;

Essa é uma redundância e distração óbvias. Quero dizer coisas como:

try {
    SomeMethod();
} catch (SomeException e) {
    // here e is unused, but during debug we can inspect exception details
    DoSomethingAboutIt();
}

De acordo com o quadro que você forneceu, é difícil argumentar contra essas variáveis ​​em si:

try {
    SomeMethod();
} catch (SomeException e) {
// here e is unused, but during debug we can inspect exception details
DoSomethingAboutIt();
}

Veja isso por exemplo. Você está capturando uma exceção e (talvez) possui um código que lida com a exceção de maneira adequada. O fato de você não estar usando a instância real da exceção não faz mal, nem ao fluxo de código nem à capacidade de compreensão.

Mas o que me faz pensar é quando você escreve sobre a legitimação de "variáveis ​​não utilizadas"

De fato, alguns deles até ajudam na depuração

Esse não é o objetivo de escrever código: ter que depurá-lo mais tarde. Para evitar mal-entendidos, devo dizer que estou bem ciente de que muitas vezes você precisa corrigir seu código; e às vezes a depuração é a solução. Mas não deve ser o primeiro, o que vem à sua mente, ao escrever código, que você deixe "pontos de ancoragem", cujo único objetivo é facilitar a depuração.

SomeClass Func() {
    // ...stuff...
    var ret = FinalComputationResult(thing, foo, bar);
    // ret is unused, but while debugging allows checking return value.
    return ret;
}

Aqui depende de quão complexo stuffé e como isso está relacionado ao valor, que é retornado.

Como uma "regra de ouro", eu diria o seguinte:

Se ajudar a entender o objetivo do código, não há problema em gerar redundância em seu código

ou, em outras palavras:

Escreva seu código com redundância livre, conforme necessário, para entender mais tarde facilmente, o que o código está fazendo

Isso resulta em: Na maioria das vezes, você deve remover as variáveis ​​"debug" .

O maior problema é a clareza . Se o seu código tem um monte de lixo estranho nele, e eu estou mantendo o código, preciso descobrir o que tudo faz.

Essa variável é usada para alguma coisa? Talvez você execute operações nele, mas nunca use seu valor para alguma coisa. Simplesmente incrementar uma variável não significa que a variável serve a um propósito se você nunca a ler (retornar, inserir outra expressão, etc.).

No entanto: se uma variável tem um propósito e é nomeada adequadamente, ela não diminui o código como um todo.

Dados os exemplos da sua pergunta atualizada e algumas outras que pensei:

• Ter uma função que chama outra função, armazena o resultado, registra-o e depois o retorna, é bastante curto e claro.

• Dividir uma instrução com várias expressões em várias instruções (por exemplo, dividir um cálculo longo e complexo em várias instruções com várias variáveis ​​intermediárias) pode tornar o código mais claro, apesar de ser mais detalhado. Com menos informações para processar por vez, o cérebro pode entender mais facilmente o que está acontecendo.

• Não usar exceções é perfeitamente adequado: a maioria dos idiomas exige que a exceção seja capturada, incluindo o fornecimento de um nome de variável a ser usado no catchbloco. Não há como contornar isso em muitas linguagens populares e os programadores estão acostumados.

Se eu precisar dedicar algum tempo a descobrir quais elementos de código têm um objetivo e quais estão apenas desperdiçando meu tempo, minha produtividade diminui. No entanto, se o código for bastante conciso e as variáveis ​​forem bem nomeadas, mesmo quando parecerem estranhas a princípio, isso reduzirá o risco de perder tempo desnecessário revisando o código para entendê-lo.

Código incorreto com variáveis ​​estranhas, blocos vazios e código morto é uma maneira de os desenvolvedores terem uma má reputação no escritório: "Eu estava corrigindo um bug no código do Snowman. Passei duas horas descobrindo o que essa função estava fazendo e trinta segundos consertando o bug! Boneco de neve é péssimo em programação! " Mas se o código serve a um propósito e é escrito de maneira clara, está perfeitamente correto.

Variáveis ​​não utilizadas que não têm nenhum objetivo óbvio são um cheiro de código, na minha opinião. Na melhor das hipóteses, eles podem ser uma distração - eles aumentam o ruído geral no módulo.

O pior caso é que os codificadores subsequentes gastam tempo descobrindo o que deveria fazer e se perguntando se o código está completo. Faça um favor a si mesmo (e a todos os outros) e se livre.

Variáveis ​​não utilizadas tornam a intenção do seu código pouco clara. Isso é ruim porque, apesar das aparências, o código é predominantemente escrito para as pessoas lerem, não para computadores .

Outros já apontaram que construir um valor e não usá-lo confunde outras pessoas que precisam ler e trabalhar com seu código. No entanto, a meu ver, o maior perigo é para si mesmo .

Uma variável não utilizada pode ser intencional ou pode ser um descuido apontando para um defeito. Por exemplo, você pode ter digitado um nome errado e armazenado um valor em um lugar quando pensou que o havia armazenado em outro. O programa resultante pode funcionar bem, mas silenciosamente fornece o resultado errado.

A análise do fluxo de dados pode ajudá-lo a encontrar esses erros e muitos outros. Portanto, vale a pena escrever seu código de forma que tudo que um analisador de fluxo de dados aponte como uma anomalia seja, de fato, um bug. A assistência automática na prevenção de erros é inestimável; muitas pessoas pensam "Oh, eu não preciso de assistência, nunca seria tão descuidado", mas até agora todos os que conheci que pensavam que estavam errados.

Existe um estilo de codificação que envolve atribuir deliberadamente qualquer coisa que tenha (ou possa se tornar) de interesse para uma variável com o objetivo específico de visualizá-la facilmente em um depurador. Isso é especialmente útil para código que se parece com:

return foo(bar(), baz(wot(12), wombat(&badger)));

Mesmo com nomes um pouco melhores para as funções, pode ser mais fácil descobrir o que está errado na chamada para foo quando escrito como:

auto awombat = wombat(&badger);
auto awot = wot(12);
auto abaz = baz(awot, abadger);
auto abar = bar();
auto afoo = foo(abar, abaz);
return afoo;

Ainda estou para trabalhar com pessoas que praticam isso como a configuração padrão, mas reescrever um pedaço de código que se recusa teimosamente a fazer algum sentido no formulário de atribuição única pode facilitar o trabalho do que está acontecendo no depurador. Sempre revertemos o código para o formato compacto "bonito" depois, mas me pergunto se isso foi um erro.

A alternativa é subir e descer a pilha e esperar que você não avance muito, ou usar depuradores reversíveis (angustiosamente raros).

Não é uma estratégia popular, mas como me ajudou a solucionar alguns erros absurdos, não acho que deva ser considerado intrinsecamente ruim.

Para pessoas que incluem seu código de teste de unidade nos mesmos projetos ou módulos que seu código "real", um campo não utilizado , como um método de objeto, é um forte sinal de que seus testes de unidade não estão testando tudo. Isso aumenta a chance de um desenvolvedor tentar usar esse campo ou método atualmente não utilizado e encontrar um bug que não estava sendo detectado até então.

Uma variável não utilizada em uma sub-rotina ou método não trivial pode indicar que o programador pretendia usá-la, mas está usando outra variável por engano (por exemplo, após a limpeza após uma operação de copiar e colar).

Uma variável não utilizada em uma sub-rotina mais trivial é provavelmente a escória desnecessária, como outras pessoas responderam. Ocasionalmente, é usado em uma instrução de trilha de navegação que é comentada atualmente:

SomeObject tmp = someMethod();
// printDebugInfoAbout (tmp);

... fica claro para os olhos que é usado lá, e somente lá (ou seja, someMethodtem um efeito colateral importante), mas o IDE não sabe disso, e remover essa variável é mais um problema do que vale a pena. Eu uso provisoriamente supressores de aviso nesses casos.

É fácil quando você escreve código para misturar duas variáveis. Você calcula uma variável B, mas usa uma variável A criada anteriormente.

Portanto, um possível motivo para uma variável não utilizada é que há um erro no seu código. É por isso que o compilador avisa. Se você "não faz" variáveis ​​não utilizadas, é até uma oferta inoperante.

Quando vir esse aviso, verifique seu código e corrija-o ou remova a variável incorreta. Se você não removê-lo, deixará de prestar atenção a esses avisos e poderá desativá-los completamente. Mas, eventualmente, você perderá uma tarde depurando o código por causa de um erro bobo.