当前位置：文江博客话题详情

调试器中的 Step Into 和 Step Over 有什么区别

发布于 2024-09-16 01:32:21 字数 83 浏览 2 评论 0原文

我想调试（Java）程序的整个流程。我看到有几个选项可以单步执行我的程序。步入和跨过有什么区别？

原文

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

遥远的绿洲 2024-09-23 01:32:22

设置：

func aa() {
   a1()
}

func bb() {
   b1()
}

func cc() {
   c1()
}

执行：

Setup:

func aa() {
   a1()
}

func bb() {
   b1()
}

func cc() {
   c1()
}

Execution:

???? annotates lines you have your breakpoints on.

1: ????aa() 
2:   bb()
3: ????cc()

Here's what happens:

Continue:
Continues with the app flow. Will stop at the next breakpoint. In this case it will stop at Line 3.

Step Over:
Will move onto the next line. In this case it will stop at Line 2

Step Into:
Will go into the aa() function. Will Stop at line a1()

Step Out:
If you did step into, then step out, will take you back to Line 1

If you want to visualize this more:

Continue: Just jumps
Step Over: Moves Down
Step Into: Moves Right
Step Over: Moves Left

The directions above correlate more or less with the direction that you read your code. Or how you read a book (or watch a movie). Continue jumps to a specific page of the book. Step Over, moves to the next chapter of the book. Doesn't care what's inside the chapter. Step Into moves within the chapter. Step out, gets back to the previous hierarchical level you were at.

Why are there so much differences?

Essentially any time you hit a breakpoint you could be like:

Jump to another breakpoint ==> "Got it. Let's move on"
Step Over ==> "Ok I have a decent understanding of what's happening, but let's just see what happens next
Step Into ==> "Hmmm...let's just see what this function is doing things internally
Step Out ==> "Ahhh I see what this function is doing, "let's get out of this function and just go back where we were and navigate around again"

回复收藏 0 原文

静谧 2024-09-23 01:32:21

请考虑在 g 中的 f(x) 行处使用当前指令指针（接下来将执行的行，由 -> 指示）的以下代码()，已被 main() 中的 g(2) 行调用：

public class testprog {
    static void f (int x) {
        System.out.println ("num is " + (x+0)); // <- STEP INTO
    }

    static void g (int x) {
->      f(x); //
        f(1); // <----------------------------------- STEP OVER
    }

    public static void main (String args[]) {
        g(2);
        g(3); // <----------------------------------- STEP OUT OF
    }
}

如果您要单步进入此时，您将移至 f() 中的 println() 行，单步执行函数调用。您可以单步执行您准备调用的任何函数。

如果您要在此时单步执行，您将移至 g() 中的 f(1) 行，单步执行该函数称呼。

请注意，如果您要执行的代码不是某种函数调用，那么单步执行和单步执行之间没有真正的区别。例如，它们都将简单地执行语句xyzzy = 42;，然后继续执行下一条语句。

调试器的另一个有用功能是“退出”步骤或“返回”步骤。在这种情况下，它基本上会运行当前函数，直到返回上一级。换句话说，它将逐步执行 f(x) 和 f(1)，然后返回到调用函数，最终到达 g(3)在main()中。

Consider the following code with your current instruction pointer (the line that will be executed next, indicated by ->) at the f(x) line in g(), having been called by the g(2) line in main():

public class testprog {
    static void f (int x) {
        System.out.println ("num is " + (x+0)); // <- STEP INTO
    }

    static void g (int x) {
->      f(x); //
        f(1); // <----------------------------------- STEP OVER
    }

    public static void main (String args[]) {
        g(2);
        g(3); // <----------------------------------- STEP OUT OF
    }
}

If you were to step into at that point, you will move to the println() line in f(), stepping into the function call. You step into any function that you're ready to call.

If you were to step over at that point, you will move to the f(1) line in g(), stepping over the function call.

Note that there is no real difference between step-into and step-over if the code you're about to execute is not a function invocation of some sort. For example, both of them would simply execute the statement xyzzy = 42; and move on to the next statement.

Another useful feature of debuggers is the step out of or step return. In that case, it will basically run you through the current function until you go back up one level. In other words, it will step through f(x) and f(1), then back out to the calling function to end up at g(3) in main().

回复收藏 0 原文

ぶ宁プ宁ぶ 2024-09-23 01:32:21

调试代码行时，常见的情况如下：

单步执行

一个方法即将被调用，并且您想要调试到该方法的代码中，因此下一步就是进入该方法方法并继续逐步调试。

单步执行

即将调用一个方法，但您对调试此特定调用不感兴趣，因此您希望调试器将该方法作为一个完整步骤完全执行。

单步返回

您已经完成了该方法的逐步调试，您只希望调试器运行整个方法，直到它作为一个完整的步骤返回。

恢复

您希望调试器恢复“正常”执行，而不是逐步执行

行断点

您不关心它是如何到达那里的，但如果执行到达特定的行代码时，您希望调试器暂时暂停执行，以便您可以决定要做什么。

Eclipse 还有其他高级调试功能，但这些是基本原理。

另请参阅

免费视频教程：Eclipse 和 Java：使用调试器
IBM/DeveloperWorks/使用 Eclipse 平台进行调试
< a href="https://web.archive.org/web/20070208050120/http://www-128.ibm.com/developerworks/web/library/wa-debug.html" rel="noreferrer">IBM/ DeveloperWorks/了解调试要点