javascript - tools - firefox developer edition español

¿Qué es paso adentro, paso y paso en Firebug?

Question

Esta pregunta ya tiene una respuesta aquí:

• ¿Cómo usar las funciones de depurador de Firebug? 1 respuesta

Soy nuevo en FireBug Debugger ¿alguien puede decir qué es paso, paso y salir

Answer 1

La versión corta es, step into lleva dentro de la función que se está llamando en la línea actual (suponiendo que se está llamando), el step out lleva de vuelta a donde estaba cuando decidió step into una función, y step over movimientos a la siguiente línea de código. Por ejemplo:

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

Answer 2

• Ingresar hará que el depurador descienda a cualquier llamada de método en la línea actual. Si hay varias llamadas a métodos, se visitarán en orden de ejecución; si no hay llamadas de método, esto es lo mismo que un paso más. Esto es en general equivalente a seguir cada línea de ejecución individual como lo vería el intérprete.
• Paso pasa a la siguiente línea en su alcance actual (es decir, va a la siguiente línea), sin descender a ninguna llamada de método en el camino. Esto generalmente se usa para seguir la lógica a través de un método particular sin preocuparse por los detalles de sus colaboradores, y puede ser útil para encontrar en qué punto de un método se violan las condiciones esperadas.
• Salir continúa hasta el próximo "retorno" o equivalente, es decir, hasta que el control haya regresado al marco de pila anterior. Esto generalmente se usa cuando ha visto todo lo que necesita en este punto / método, y desea subir la pila unas cuantas capas hasta donde realmente se usa el valor.

Imagine el siguiente código, que ingresó a través de main() y ahora está en la primera línea de la 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;
}

Entonces:

• Ingrese procederá a la llamada foo , y la línea actual se convertirá en la return "hi"; línea dentro de foo .
• Paso ignorará el hecho de que se está invocando otro método, y procederá al return t; línea (que le permite ver rápidamente cómo t se evalúa).
• Salir terminará la ejecución del resto del método de bar , y el control volverá a la última línea del método main .

Answer 3

• ingrese en -> ingrese a la subrutina y espere la siguiente acción
• paso -> salta sobre la subrutina sin esperar otra vez
• salga -> si está en la subrutina, la dejará sin esperar otra vez

Answer 4

• Step Into hará que el depurador entre en la siguiente llamada de función y se interrumpa allí.

• Step Over le dirá al depurador que ejecute la siguiente función y se rompa después.

• Step Out le dirá al depurador que termine la función actual y la rompa después.