'break' & 'continue' statements

-

Introduction

In JavaScript, the `break` and `continue` statements are used to control the flow of loops. They are often used inside loops to change the normal execution behavior.

The `break` statement is used to exit a loop completely, while the `continue` statement is used to skip the current iteration of a loop and continue to the next iteration. These statements are particularly useful in situations where you need to terminate a loop prematurely or skip certain iterations based on certain conditions.

The `break` Statement

The `break` statement is used to exit a loop prematurely. When the `break` statement is encountered inside a loop, the loop immediately terminates and the program execution continues with the next statement after the loop.

Here's a basic example that uses the `break` statement in a while loop:

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

In this example, the loop will execute until `i` is equal to 5. When `i` becomes 5, the `break` statement is encountered, and the loop is terminated. Therefore, only the numbers 0, 1, 2, 3, and 4 will be logged to the console.

The `continue` Statement

The `continue` statement is used to skip the current iteration of a loop and proceed with the next iteration. When the `continue` statement is encountered inside a loop, the remaining code in the loop body for the current iteration is skipped, and the loop immediately jumps to the next iteration.

Here's an example that uses the `continue` statement in a for loop:

for (let i = 0; i < 5; i++) {
 
  if (i === 2) {
 
    continue;
 
  }
 
  console.log(i);
 
}

In this example, the loop will execute five times, but when `i` is equal to 2, the `continue` statement is encountered. As a result, the code inside the loop body for that iteration is skipped, and the loop proceeds to the next iteration. Therefore, the output will be 0, 1, 3, and 4.

Nesting Loops and Using `break` and `continue`

The `break` and `continue` statements can also be used with nested loops. When used within nested loops, the `break` statement terminates the innermost loop it is inside, while the `continue` statement skips the remaining code for the current iteration in the innermost loop.

Here's an example that demonstrates the use of `break` and `continue` statements in nested loops:

for (let i = 0; i < 3; i++) {
  console.log("Outer loop: " + i);
 
  for (let j = 0; j < 3; j++) {
    if (j === 1) {
      continue;
    }
 
    if (i === 2 && j === 2) {
      break;
    }
 
    console.log("Inner loop: " + j);
  }
}

In this example, there are two nested loops. The inner loop skips the iteration when `j` is equal to 1 using the `continue` statement. The outer loop terminates completely when `i` is equal to 2 and `j` is equal to 2 using the `break` statement. Therefore, the output will be:

Outer loop: 0
Inner loop: 0
Inner loop: 2
Outer loop: 1
Inner loop: 0
Inner loop: 2

Key Takeaways

  • The `break` statement is used to immediately terminate a loop and continue with the next statement after the loop.

  • The `continue` statement is used to skip the current iteration of a loop and proceed with the next iteration.

  • The `break` and `continue` statements can be used with nested loops to control the flow of execution.

  • The `break` statement terminates the innermost loop it is inside, while the `continue` statement only skips the remaining code for the current iteration in the innermost loop.

Comments

Post a Comment

Popular posts from this blog

Limitations of JavaScript

-
Introduction to Limitations of JavaScript JavaScript is a widely used programming language that runs on all major web browsers. It is known for its versatility and ability to create dynamic and interactive web pages. However, like any programming language, JavaScript has its limitations. In this learning guide, we will explore the limitations of JavaScript to help you better understand its strengths and weaknesses. 1. Performance Limitations JavaScript is an interpreted language , which means that it is executed line by line at run-time. This can result in slower performance compared to compiled languages like C++ or Java. Additionally, JavaScript is a single-threaded language , meaning that it can only execute one operation at a time. This can lead to performance bottlenecks when dealing with computationally intensive tasks or handling large amounts of data. // Example of slow performance in JavaScript for ( var i = 0 ; i < 1000000000 ; i ++ ) { // Perform some computati...
Read more

'for in' Loop

-
Introduction to JavaScript 'for in' Loop The `for in` loop is a type of loop in JavaScript that is used to iterate over the properties of an object. It is often used when you need to loop through the keys or properties of an object and perform some action on each one. Unlike other loops like `for` and `while`, the `for in` loop is specifically designed to work with objects. Syntax The syntax for the `for in` loop is as follows: for   ( variable  in  object )   {    // code to be executed } The `variable` represents a temporary variable that will hold the key of each property in the object. The `object` is the object that you want to iterate over. Example Let's take a look at an example to understand how the `for in` loop works: const  person  =   {   name :   'John' ,   age :   30 ,   gender :   'male' } ;   for ...
Read more

What is JIT compiler? Is JavaScript compiled or interpreted or both?

-
What is JIT compiler? A Just-In-Time (JIT) compiler is a type of compiler that dynamically converts programming code into machine code at runtime, just before the code is executed. Unlike traditional compilers that convert the entire program ahead of time, a JIT compiler optimizes and compiles code on-the-fly, as it is needed. The primary advantage of a JIT compiler is that it can make the execution of code significantly faster compared to an interpreter. It achieves this by analyzing the code at runtime, identifying hotspots (frequently executed portions of code), and applying various optimization techniques to generate highly efficient machine code specific to the underlying hardware. JIT compilers are commonly used in programming languages such as Java and JavaScript, where the execution speed of the code is crucial. So is JavaScript Compiled or Interpreted? JavaScript is generally considered an interpreted language . Traditionally, JavaScript code is executed by an interpreter, wh...
Read more