Digamos que temos uma função como esta:
public void myStart()
{
for (int i = 0; i<10; i++) myFunction(i);
}
private int myFunction(int a)
{
a = foo(a);
a = bar(a);
return a;
}
private int foo(int a)
{
//do something here
//something gnarly here
//etc
return aValue;
}
private int bar(int a)
{
// do something here
//return aValue;
}
Agora, por qualquer motivo, nosso código não está funcionando. Talvez esteja gerando um erro, talvez esteja retornando o valor errado, talvez tenha ficado preso em um loop infinito.
A primeira coisa que qualquer programador de primeiro ano, é imprimir no console / padrão, (aprendendo a imprimir o Hello World antes de aprender a usar um depurador).
Por exemplo, para depurar esse código, eles podem fazer o seguinte:
private int myFunction(int a)
{
print("before foo: a=" + a);
a = foo(a);
print("before bar: a=" + a);
a = bar(a);
return a;
}
private int foo(int a)
{
//do something here
print ("foo step1: a=" + a);
//something gnarly here
print ("foo step2: a=" + a + " someOtherValue="+ someOtherValue + " array.length= " + someArray.length());
//etc
return aValue;
}
private int bar(int a)
{
// do something here
//return aValue;
}
Agora eles executam o código, obtêm uma grande impressão do console, pela qual podem rastrear onde as coisas estão dando errado.
Uma alternativa, é claro, é definir pontos de interrupção e percorrer o código em cada ponto.
Uma grande vantagem da impressão no console é que o desenvolvedor pode ver o fluxo dos valores de uma só vez, sem precisar clicar nas etapas etc.
Mas a desvantagem é que seu código é repleto de todas essas instruções de impressão que precisam ser removidas.
(É possível, talvez, pedir ao depurador para imprimir apenas determinados valores em um log ?, os pontos de interrupção podem ser facilmente adicionados ou removidos sem modificar o código.)
Eu ainda uso a impressão de console como método primário de depuração, estou me perguntando o quão comum / eficaz isso é em comparação com outra coisa por aí.
Respostas:
As instruções de impressão e o depurador não são mutuamente exclusivos. São apenas ferramentas diferentes disponíveis para você localizar / identificar bugs. Há quem afirme que nunca toca em um depurador e há quem não tem uma única instrução de log / impressão em qualquer lugar do código que escreve. Meu conselho é que você não queira fazer parte de nenhum desses grupos.
Em vez disso, aprenda a usar o log e aprenda a usar um depurador. Com a experiência, você (quase sem precisar pensar nisso) escolhe a ferramenta certa e realiza o trabalho com precisão e eficiência. Sem experiência, às vezes você escolhe um sobre o outro, e talvez demore um pouco mais a vasculhar as variáveis ou vasculhar os arquivos de log, mas isso faz parte do processo de aprendizado.
Então, para responder sua pergunta específica. Sim. Usar impressões para rastrear a execução é uma estratégia de depuração boa e amplamente usada. Contudo...
Em vez de usar instruções de impressão, considere usar uma estrutura de log. As estruturas de log têm um conceito de níveis de log, para que você possa adicionar várias mensagens de log, mas escolha um nível para cada uma. Quando seu aplicativo está sendo executado em condições normais, seu nível seria ERROR ou WARNING, para que apenas informações importantes sejam relatadas. No entanto, ao rastrear o código e precisar entender o fluxo de execução, você pode alterar o logger para INFO ou DEBUG e agora todas as instruções "print" que você já possui no código reportarão informações adicionais.
Usando uma estrutura de log ...
Atualização: Acabei de perceber que, no final, você estava perguntando: "É possível dizer ao depurador para imprimir apenas determinados valores em um log". Dependendo de qual depurador você usa. Muitos depuradores modernos permitem definir uma ação a ser chamada quando um ponto de interrupção é atingido. Em alguns (eu fiz isso no VS e no WinDbg), é possível especificar "imprimir isto e continuar". O Visual Studio os chama de "pontos de rastreamento" em vez de "pontos de interrupção"
fonte
Registro / impressão e depuradores são técnicas complementares que têm diferentes pontos fortes e fracos - é melhor usar os dois. Mas, no geral, eu diria que os depuradores são a ferramenta superior na maioria dos casos e devem ser usados primeiro, com o registro / impressão usado apenas para as coisas nas quais é realmente melhor.
Vantagens dos depuradores:
Vantagens do registro / impressão:
fonte
Imprimir de maneira padrão na saída padrão pode ser uma boa estratégia para depurar seu código, por exemplo
Eu uso muitas instruções de impressão para ver o que está acontecendo em diferentes níveis do meu código, especialmente se eu não entender completamente o erro
ou talvez o erro não tenha nenhuma informação detalhada que possa me indicar qual parte do código exatamente está causando o problema.
No entanto, você precisa se acostumar com as ferramentas de depuração, existem muitas por aí, dependendo do idioma ou plataforma que você usa.
Além disso, outro método é o log, eu registro erros o tempo todo ao trabalhar em aplicativos Android, também com o tratamento de exceções, é possível registrar facilmente um rastreamento de pilha ou uma mensagem de erro da exceção que está sendo gerada.
fonte