Diciamo che abbiamo una funzione come questa:
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;
}
Ora, per qualsiasi motivo, il nostro codice non funziona. Forse sta generando un errore, forse sta restituendo il valore sbagliato, forse è rimasto bloccato in un ciclo infinito.
La prima cosa che ogni programmatore del primo anno è stampare su console / std out (avendo imparato come stampare Hello World prima di imparare a utilizzare un debugger).
Ad esempio per eseguire il debug di questo codice, potrebbero eseguire le seguenti operazioni:
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;
}
Ora eseguono il codice, ottengono una grande console stampata, che possono passare per tracciare dove le cose vanno male.
Un'alternativa, naturalmente, è quella di impostare punti di interruzione e scorrere il codice in ogni punto.
Uno dei principali vantaggi della stampa su console è che lo sviluppatore può vedere il flusso dei valori in un colpo solo, senza dover fare clic sui passaggi ecc.
Ma lo svantaggio è che il tuo codice è pieno di tutte queste dichiarazioni di stampa che devono essere rimosse.
(È possibile forse dire al debugger di stampare solo determinati valori in un log ?, i punti di interruzione possono quindi essere facilmente aggiunti o rimossi senza realmente modificare il codice.)
Uso ancora la stampa da console come metodo di debug primario, mi chiedo quanto sia comune / efficace rispetto a qualcos'altro là fuori.