What is the difference between Step Into and Step Over in a debugger

Question

I want to debug the whole flow of a (Java) program. I see there are several options for stepping through my program. What is the difference between step into and step over?

score 379 · Accepted Answer · edited Jan 12 '21 at 12:14

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.

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

Another useful feature of debuggers is the step out of or step return. In that case, a step return 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().

"then back out to the calling function to end up at `g(3)`; in `main()`" **<--** Are you assuming that you got to your *current location* from `g(2)` and once you're all done you *return* to its next line `g(3)`? — mfaani, Mar 13 '17 at 20:15
@Honey, yes, there was some ambiguity there (whether `g(2)` or `g(3)` call is currently active) so I've cleared that in the first paragraph. Thanks for the heads up. — paxdiablo, Mar 14 '17 at 00:11

score 216 · Answer 2 · edited Oct 22 '21 at 16:57

When debugging lines of code, here are the usual scenarios:

Step Into

A method is about to be invoked, and you want to debug into the code of that method, so the next step is to go into that method and continue debugging step-by-step.

Step Over

A method is about to be invoked, but you're not interested in debugging this particular invocation, so you want the debugger to execute that method completely as one entire step.

Step Return

You're done debugging this method step-by-step, and you just want the debugger to run the entire method until it returns as one entire step.

Resume

You want the debugger to resume "normal" execution instead of step-by-step

Line Breakpoint

You don't care how it got there, but if execution reaches a particular line of code, you want the debugger to temporarily pause execution there so you can decide what to do.

Eclipse has other advanced debugging features, but these are the basic fundamentals.

You can't go through the details of the method by using the step over. If you want to skip the current line, you can use step over, then you only need to press the F6 for only once to move to the next line. And if you think there's someting wrong within the method, use F5 to examine the details.

edited Jun 27 '16 at 10:53

mtb

1,350
16
32

answered Aug 27 '10 at 09:18

wanana

361
1
9

So if I do step over and if function contains some print statement will the printing happen or not? – username_4567 Sep 05 '12 at 12:37

score 4 · Answer 6 · answered Jul 08 '14 at 13:41

Step Into The next expression on the currently-selected line to be executed is invoked, and execution suspends at the next executable line in the method that is invoked.

Step Over The currently-selected line is executed and suspends on the next executable line.

score 0 · Answer 7 · answered Mar 07 '23 at 20:47

Image you have the following functions:

func aa() {
   a1()
}
func bb() {
   b1()
}

And execute them in the following order. The annotates the lines that you have your breakpoints on.

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

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 just jumps to a specific page of the book. Step Over, just moves to the next chapter of the book. Step Into moves within the chapter. Step out, gets back at the previous hierarchical level you were at.

What are there so much differences?

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

Jump to another breakpoint ==> "I don't care about this. 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"

What is the difference between Step Into and Step Over in a debugger

7 Answers7

See also

If you want to visualize this more:

What are there so much differences?

Linked

Related