Jump statements in Javascript with examples

Jumps are control structures that cause a jump to another part of the program. Break, continue, labeled, return, try/catch/finally statements are examples of jumps in javascript. 

Break

The break statement is used to terminate the loop immediately when it is encountered. The break statement terminates the current loop, switch, or label statement

Syntax

        
break [label];        
    

Example 1: break with for Loop

Program to print the value of i

        
for (let i = 1; i <= 5; i++) {
    // break condition     
    if (i == 3) {
        break;
    }
    console.log(i);
}

//Output : 
1
2        
    

In the above program, the for loop is used to print the value of i in each iteration. This means, that when i is equal to 3, the break statement terminates the loop. Hence, the output doesn't include values greater than or equal to 3.

Example 2: break with while Loop

        
let i = 0;
while (i < 5) {
  i++;
  console.log(i);
  if (i == 3) {
    break;
  }
}

//Output : 
1
2
3        
    

In this example, when the current value of i is 3, the break statement terminates the loop. Therefore, you see only three numbers in the output.

Example 3: break with do while Loop

        
let i = 0;

do {
  i++;
  console.log(i);
  if (i == 3) {
    break;
  }
} while (i < 5);

//Output : 
1
2
3        
    

Continue

The continue statement terminates execution of the statements in the current iteration of the current or labeled loop and continues execution of the loop with the next iteration.

Syntax

        
continue [label];        
    

Example

        
var i;
for (i = 1; i < 5; i++) {
    if (i === 3) {
        continue;
    }
   console.log(i);
}

//Output : 
1
2
4        
    

In the above program, for loop is used to print the value of i in each iteration.

Notice the continued statement inside the loop.

When i is equal to 3, the continue statement skips the third iteration.

Then, I become 4, and the test condition and continue statement is evaluated again.

Hence, 4 is printed in the next iterations.

Example 2

        
for (var i = 1; i <= 10; i++) {
    if (i % 2 === 0) {
        continue;
    }
    console.log(i);
}

//Output : 
1
3
5
7
9        
    

In the above example, when i%2==0 then it skips that iteration and continues with the next iteration. So every time only even value is printed.

Example 3

        
let i = 0;

do {
  i++;
  
  if (i === 3) {
    continue;
  }
  console.log(i);
} while (i < 5);

//Output : 
1
2
4
5
             
    

In the above example, the first value of i is incremented. When the value of I becomes 3 then it skips iteration because of the continued statement. Then next iteration will continue. 

Labeled Statement

JavaScript label statements are used to prefix a label to an identifier. A label can be used with a break and continue statement to control the flow more precisely. A label is simply an identifier followed by a colon (:) that is applied to a statement or a block of code.

A label can be used with a break or continue statement to control the flow of the code more precisely. The label is applied to a block of code or a statement.

Label: A unique string that is Used to define the name of the block or loop.

Syntax

Label: statement

Example 1

        
        
let str = '';

loop1:
for (let i = 0; i < 5; i++) {
  if (i === 1) {
    continue loop1;
  }
  str = str + i;
}

console.log(str);

// Output : "0234"        
    

You can use a label to identify a loop, and then use the break or continue statements to indicate whether a program should interrupt the loop or continue its execution.

Example 2

        
for (var i = 1; i <= 10; i++) {
    if (i % 2 === 0) {
        continue loop1;
    }
    console.log(i);
}

//Output : 
 1
 3 
 5
 7 
 9        
    

Return 

The return statement stops the execution of a function and returns a value. When a return statement is called in a function, the execution of this function is stopped. If specified, a given value is returned to the function caller. If the expression is omitted, undefined is returned instead.

We can return primitive values (such as Boolean, number, string, etc.) and Object types (such as functions, objects, arrays, etc.) by using the return statement.

Syntax

return expression;  

Example 1

        
function square(x) {
    return x * x;
}
    
let squared2 = square(3); 
console.log(squared2);

// Output : 9        
    

Example 2

        
function func(x) {
       let y = x * x;
}

let res = func(2);
console.log(`result: ${res}`);

// Output : "result: undefined"             
    

In the above program, we can see that the function has no return statement in the function with the name “func”, which is calculating the product of the square of a number. It will not return the value of the expression but will print undefined as there is no return keyword specified before the expression. Therefore the function will return “undefined” instead of returning the exact value of the square of a number.

Try catch finally

The try, catch and finally, blocks are used to handle exceptions (a type of an error). 

In programming, there are two types of error.

Syntax Error: Error in the syntax. For example, if you write consol.log('your result');,  the above program throws a syntax error. The spelling of console is a mistake in the above code.

Runtime Error: This type of error occurs during the execution of the program.

Syntax

        
try {
   // try_statements
} 
catch(error) {
   // catch_statements  
}
finally() {
   // codes that gets executed anyway
}
        
    

You can also use the try...catch...finally statement to handle exceptions. The final block executes both when the code runs successfully or if an error occurs.

Example 1

        
const x= 100, y = 'a';

try {
   console.log(x/y);
   console.log(a);
}
catch(error) {
   console.log('Error message: ' + error);  
}
finally {
   console.log('Programs runs successfully');
}

//Output : 
NaN
"Error message: ReferenceError: a is not defined"
"Programs runs successfully"        
    

In the above program, an error occurs and that error is caught by the catch block. The finally block will execute in any situation

Example 2

        
function welcome(){
    console.log("Hello world!");
}
    
try{
    welcome()
    hello()
}
    catch(e){
    console.log(" " + e);
}
   
//Output : 
"Hello world!"
" ReferenceError: hello is not defined"        
    

In the above program try section runs successfully. Catch section caught errors and display errors.

Example 3

We can also skip catch block

        
function welcome(){
    console.log("Hello world!");
}
function bye(){
    console.log("bye");
}
    
try{
    welcome()
}
finally{
    bye()
}

//Output : 
"Hello world!"
"Bye"        
    

We can see the welcome function display messages. Finally, blocks run code if the programs run successfully or not.

Posted in

Ankit Patel

Leave a Comment

Your email address will not be published.

Scroll to Top