Nehmen wir an, wir haben eine Funktion wie diese:
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;
}
Aus irgendeinem Grund funktioniert unser Code nicht. Vielleicht wirft es einen Fehler, vielleicht gibt es den falschen Wert zurück, vielleicht steckt es in einer Endlosschleife fest.
Das erste, was ein Programmierer im ersten Jahr programmiert, ist das Drucken auf Konsole / Standard (nachdem er gelernt hat, wie man Hello World druckt, bevor er lernt, einen Debugger zu verwenden).
Zum Debuggen dieses Codes können sie beispielsweise Folgendes tun:
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;
}
Jetzt führen sie den Code aus und erhalten einen großen Konsolendruck, mit dem sie nachverfolgen können, wo etwas schief geht.
Eine Alternative besteht natürlich darin, an jedem Punkt Haltepunkte zu setzen und den Code schrittweise durchzugehen.
Ein Hauptvorteil des Druckens auf der Konsole besteht darin, dass der Entwickler den Wertefluss auf einmal sehen kann, ohne durch Schritte usw. klicken zu müssen.
Der Nachteil ist jedoch, dass Ihr Code dann mit all diesen Druckanweisungen durchsetzt ist, die dann entfernt werden müssen.
(Ist es vielleicht möglich, den Debugger anzuweisen, nur bestimmte Werte in ein Protokoll auszudrucken? Die Haltepunkte können dann einfach hinzugefügt oder entfernt werden, ohne den Code tatsächlich zu ändern.)
Ich verwende immer noch den Konsolendruck als primäre Debugging-Methode. Ich frage mich, wie häufig / effektiv dies im Vergleich zu etwas anderem ist.
Antworten:
Druckanweisungen und Debugger schließen sich nicht gegenseitig aus. Es handelt sich lediglich um verschiedene Tools, die Ihnen zur Verfügung stehen, um Fehler zu lokalisieren / zu identifizieren. Es gibt diejenigen, die behaupten, dass sie niemals einen Debugger berühren, und es gibt diejenigen, die nirgendwo im Code, den sie schreiben, eine einzige Protokollierungs- / Druckanweisung haben. Mein Rat ist, dass Sie nicht in einer dieser Gruppen sein wollen.
Lernen Sie stattdessen die Verwendung der Protokollierung und einen Debugger. Mit der Erfahrung werden Sie (fast ohne darüber nachdenken zu müssen) das richtige Werkzeug auswählen und die Arbeit genau und effizient erledigen. Ohne Erfahrung wählen Sie manchmal eine über die andere aus, und vielleicht dauert es etwas länger, die Variablen zu durchsuchen oder Protokolldateien zu durchsuchen, aber das ist alles Teil des Lernprozesses.
Also, um Ihre spezifische Frage zu beantworten. Ja. Die Verwendung von Ausdrucken zur Verfolgung der Ausführung ist eine gute und weit verbreitete Debugging-Strategie. Jedoch...
Verwenden Sie anstelle von print-Anweisungen ein Protokollierungsframework. Protokollierungsframeworks haben ein Konzept für Protokollierungsebenen, sodass Sie eine ganze Reihe von Protokollnachrichten hinzufügen und für jede Ebene eine Ebene auswählen können. Wenn Ihre Anwendung unter normalen Bedingungen ausgeführt wird, lautet Ihre Stufe FEHLER oder WARNUNG, sodass nur wichtige Informationen gemeldet werden. Wenn Sie jedoch den Code verfolgen und den Ausführungsablauf verstehen müssen, können Sie den Logger in INFO oder DEBUG ändern. Alle "print" -Anweisungen, die Sie bereits im Code haben, geben jetzt zusätzliche Informationen aus.
Verwenden eines Protokollierungsframeworks ...
Update: Ich habe gerade am Ende bemerkt, dass Sie gefragt haben: "Ist es vielleicht möglich, den Debugger anzuweisen, nur bestimmte Werte in ein Protokoll auszudrucken?". Abhängig davon, welchen Debugger Sie verwenden. In vielen modernen Debuggern können Sie eine Aktion definieren, die aufgerufen werden soll, wenn ein Haltepunkt erreicht wird. In einigen Fällen (ich habe dies in VS und WinDbg getan) ist es möglich, "dies drucken und fortsetzen" anzugeben. Visual Studio nennt sie "Tracepoints" anstelle von "Breakpoints".
quelle
Protokollierung / Drucken und Debugger sind komplementäre Techniken mit unterschiedlichen Stärken und Schwächen - am besten verwenden Sie beide. Aber insgesamt würde ich sagen, dass Debugger in den meisten Fällen das überlegene Werkzeug sind und zuerst verwendet werden sollten, wobei das Protokollieren / Drucken nur für die Dinge verwendet wird, in denen es tatsächlich besser ist.
Vorteile von Debuggern:
Vorteile der Protokollierung / des Druckens:
quelle
Das Drucken auf Standardausgabe kann beispielsweise eine gute Strategie zum Debuggen Ihres Codes sein
Ich verwende viele print-Anweisungen, um zu sehen, was in verschiedenen Ebenen meines Codes vor sich geht, insbesondere wenn ich den Fehler nicht vollständig verstehe
oder vielleicht enthält der Fehler keine detaillierten Informationen, die mich darauf hinweisen könnten, welcher Teil des Codes genau das Problem verursacht.
Wie auch immer Sie sich an das Debuggen von Tools gewöhnen müssen, es gibt viele, je nachdem, welche Sprache oder Plattform Sie verwenden.
Eine andere Methode ist die Protokollierung. Ich protokolliere ständig Fehler, wenn ich an Android-Anwendungen arbeite. Auch bei der Ausnahmebehandlung kann man leicht einen Stack-Trace oder eine Fehlermeldung der ausgelösten Ausnahme protokollieren.
quelle