Disons que nous avons une fonction comme celle-ci:
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;
}
Maintenant, pour une raison quelconque, notre code ne fonctionne pas. Peut-être que cela génère une erreur, peut-être qu'il renvoie la mauvaise valeur, peut-être qu'il est coincé dans une boucle infinie.
La première chose que tout programmeur de première année est d'imprimer sur console / sortie standard (après avoir appris à imprimer Hello World avant d'apprendre à utiliser un débogueur).
Par exemple, pour déboguer ce code, ils peuvent effectuer les opérations suivantes:
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;
}
Maintenant, ils exécutent le code, ils obtiennent une grande impression de la console, qu'ils peuvent parcourir pour localiser les problèmes.
Une alternative est bien sûr de définir des points d'arrêt et de parcourir le code à chaque point.
Un avantage majeur de l'impression sur console est que le développeur peut voir le flux des valeurs en une seule fois, sans avoir à cliquer sur les étapes, etc.
Mais l'inconvénient est que votre code est ensuite criblé de toutes ces instructions d'impression qui doivent ensuite être supprimées.
(Est-il possible de dire au débogueur d'imprimer uniquement certaines valeurs dans un journal?, Les points d'arrêt peuvent ensuite être facilement ajoutés ou supprimés sans réellement modifier le code.)
J'utilise toujours l'impression sur console comme méthode de débogage principale, je me demande à quel point c'est courant / efficace par rapport à autre chose.
Réponses:
Les instructions d'impression et le débogueur ne s'excluent pas mutuellement. Ce ne sont que différents outils à votre disposition pour localiser / identifier les bugs. Il y a ceux qui prétendent qu'ils ne touchent jamais à un débogueur et il y a ceux qui n'ont aucune instruction logging / print n'importe où dans le code qu'ils écrivent. Mon conseil est que vous ne voulez faire partie d'aucun de ces groupes.
Au lieu de cela, apprenez à utiliser la journalisation et apprenez à utiliser un débogueur. Avec l'expérience, vous choisirez (presque sans y avoir pensé) le bon outil et accomplirez le travail avec précision et efficacité. Sans expérience, vous choisirez parfois l'un au-dessus de l'autre, et cela vous prendra peut-être un peu plus de temps à fouiller les variables ou à parcourir les fichiers journaux, mais cela fait partie du processus d'apprentissage.
Donc, pour répondre à votre question spécifique. Oui. L'utilisation d'impressions pour tracer l'exécution est une bonne stratégie de débogage largement utilisée. Toutefois...
Au lieu d'utiliser des instructions d'impression, envisagez d'utiliser un cadre de journalisation. Les cadres de journalisation ont un concept de niveaux de journalisation afin que vous puissiez ajouter un tas de messages de journal mais choisir un niveau pour chacun. Lorsque votre application s'exécute dans des conditions normales, votre niveau serait ERREUR ou AVERTISSEMENT afin que seuls les éléments importants soient signalés. Cependant, lorsque vous parcourez le code et avez besoin de comprendre le flux d'exécution, vous pouvez remplacer l'enregistreur par INFO ou DEBUG et maintenant toutes les instructions "print" que vous avez déjà dans le code rapporteront des informations supplémentaires.
Utilisation d'un cadre de journalisation ...
Mise à jour: je viens de remarquer à la fin que vous demandiez: "Est-il possible de dire au débogueur d'imprimer uniquement certaines valeurs dans un journal". Selon le débogueur que vous utilisez. De nombreux débogueurs modernes vous permettent de définir une action à invoquer lorsqu'un point d'arrêt est atteint. Dans certains (je l'ai fait dans VS et WinDbg), il est possible de spécifier "imprimer ceci et reprendre". Visual Studio les appelle des "points de trace" au lieu de "points d'arrêt"
la source
La journalisation / impression et les débogueurs sont des techniques complémentaires qui ont des forces et des faiblesses différentes - il est préférable d'utiliser les deux. Mais dans l'ensemble, je dirais que les débogueurs sont l'outil supérieur dans la plupart des cas et doivent être utilisés en premier, la journalisation / impression n'étant utilisée que pour les choses pour lesquelles il est réellement meilleur.
Avantages des débogueurs:
Avantages de l'enregistrement / de l'impression:
la source
L'impression sur une sortie standard d'une manière peut être une bonne stratégie pour déboguer votre code, par exemple
j'utilise beaucoup d'instructions d'impression pour voir ce qui se passe à différents niveaux de mon code, surtout si je ne comprends pas complètement l'erreur
ou peut-être que l'erreur ne contient aucune information détaillée qui pourrait me diriger vers la partie du code à l'origine du problème.
Cependant, vous devez vous habituer aux outils de débogage, il y en a beaucoup selon la langue ou la plate-forme que vous utilisez.
Une autre méthode est également la journalisation, je journalise les erreurs tout le temps lorsque je travaille sur des applications Android, également avec la gestion des exceptions, on peut facilement consigner une trace de pile ou un message d'erreur de l'exception levée.
la source