Qu'est-ce que l'étape, l'étape et l'étape de plus dans Firebug? [dupliquer]

• Step dans fera descendre le débogueur dans n'importe quel appel de méthode sur la ligne courante. S'il y a plusieurs appels de méthode, ils seront visités dans l'ordre d'exécution; s'il n'y a pas d'appels de méthode, c'est la même chose que step over. Cela équivaut en gros à suivre chaque ligne d'exécution individuelle comme le verrait l'interprète.
• étape de plus de produit à la ligne suivante de votre portée actuelle (c.-à-d. Elle va à la ligne suivante), sans descendre dans les appels de méthode sur le chemin. Ceci est généralement utilisé pour suivre la logique à travers une méthode particulière sans se soucier des détails de ses collaborateurs, et peut être utile pour trouver à quel point dans une méthode les conditions attendues sont violées.
• Étape out produit jusqu'à la prochaine "retour" ou équivalent - c'est à dire jusqu'à ce que le contrôle est retourné à la pile précédente cadre. Ceci est généralement utilisé lorsque vous avez vu tout ce que vous devez à ce point/méthode, et que vous voulez gonfler la pile quelques couches à l'endroit où la valeur est réellement utilisée.

imaginez le code suivant, qui est entré par main() et est maintenant sur la première ligne de bar :

function main() {
   val s = foo();
   bar(s);
}

function foo() {
   return "hi";
}

function bar(s) {
   val t = s + foo(); // Debugger is currently here
   return t;
}

puis:

• l'appel foo , et la ligne courante deviendra alors la ligne return "hi"; à l'intérieur de foo .
• Step over ignorera le fait qu'une autre méthode est invoquée, et passera à la ligne return t; (qui vous permet de voir rapidement ce que t est évalué comme).
• Step out terminera l'exécution du reste de la méthode bar , et le contrôle retournera à la dernière ligne de la méthode main .

• l'Étape En cause le débogueur pour aller dans le prochain appel de la fonction et de repos.

• Step Over va dire au débogueur d'exécuter la fonction suivante et de casser par la suite.

• Step Out va dire au débogueur de terminer la fonction courante et de casser après elle.

la version courte est, step into vous emmène à l'intérieur de la fonction étant appelé sur la ligne courante (en supposant qu'un est appelé), step out vous ramène à l'endroit où vous étiez lorsque vous avez décidé de step into une fonction, et step over se déplace juste à la ligne suivante du code. Par exemple:

window.someFunction = function() {
    var x = 10;    //step over to move to the next line
                   //step out to return to the line after where 'someFunction()' was called
                   //step into not available
    var y = 20;
    return x * y;
};

//set breakpoint here
var x = 7;   //step over to execute this line and move to the 
             //next (step into and step out not available)
x += someFunction();  //step over to move to the next line
                      //step into to move to someFunction() (above)
                      //step out not available
alert(x);    //step over to display the alert
             //step out and (probably) step into not available

• entrez - > allez dans le sous-programme et attendez la prochaine action
• pas au-dessus - > sauter au-dessus du sous-programme sans attendre à nouveau
• step out - > si vous êtes dans le sous-programme, vous le quitterez sans attendre à nouveau