for Loop

-

'for' Loop

The `for` loop is a control flow statement that allows you to repeatedly execute a block of code a specific number of times. It is commonly used when you know beforehand how many times the loop should iterate. The `for` loop consists of three main parts: initialization, condition, and increment/decrement.

Syntax

for (initialization; condition; increment/decrement) {
  // code to be executed

}

The `initialization` statement is executed before the loop starts and is used to initialize variables or set their initial values. The `condition` is evaluated before each iteration, and if it evaluates to `true`, the loop body is executed. The `increment/decrement` statement is executed after each iteration and is generally used to update the loop counter.

Example

Let's look at an example that demonstrates the usage of a `for` loop to print the numbers from 1 to 5:

for (let i = 1; i <= 5; i++) {
  console.log(i);
}

In this example, the `initialization` statement `let i = 1` initializes the loop counter `i` to 1. The `condition` `i <= 5` checks if `i` is less than or equal to 5. If it is true, the loop body is executed, which logs the value of `i` to the console. The `increment/decrement` statement `i++` increases the value of `i` by 1 after each iteration. The loop continues as long as the condition is true, and in this case, it will print the numbers 1 to 5.

Break Statement

Inside a `for` loop, you can use the `break` statement to terminate the loop prematurely. This can be useful when you want to stop the loop based on a certain condition instead of waiting for the loop condition to become `false`.

Here's an example that demonstrates the usage of `break` statement within a `for` loop:

for (let i = 1; i <= 10; i++) {
  if (i === 6) {
    break;
  }
  console.log(i);
}

In this example, the loop will iterate from 1 to 10. However, when the loop counter `i` becomes 6, the `break` statement is encountered, and the loop is terminated, even though the condition `i <= 10` is still true. As a result, only the numbers 1 to 5 will be logged to the console.

Continue Statement

The `continue` statement is another control flow statement that allows you to skip the rest of the code inside the loop for the current iteration and move on to the next iteration.

Here's an example that demonstrates the usage of `continue` statement within a `for` loop:

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

In this example, when the value of `i` is 3, the `continue` statement is encountered, and the rest of the loop body is skipped for that iteration. As a result, the number 3 is not logged to the console, and the loop continues with the next iteration.

Nested `for` Loops

The `for` loop can also be nested, which means you can have one `for` loop inside another `for` loop. This is especially useful when you need to iterate over a multi-dimensional array or when you want to perform a certain action for every combination of two or more variables.

Here's an example that demonstrates the usage of nested `for` loops to print a pattern:

for (let i = 1; i <= 5; i++) {
  let pattern = '';
  for (let j = 1; j <= i; j++) {
    pattern += '*';
  }
  console.log(pattern);
}

In this example, the outer `for` loop is responsible for controlling the number of rows, while the inner `for` loop is responsible for controlling the number of columns in each row. The `pattern` variable is used to build the string pattern for each row, adding an asterisk symbol `*` in each iteration of the inner loop. The result is a pattern of asterisks, where each row has an increasing number of asterisks.

Key Takeaways

  • The `for` loop allows you to repeatedly execute a block of code a specific number of times.

  • It consists of three parts: initialization, condition, and increment/decrement.

  • You can use the `break` statement to terminate the loop prematurely.

  • The `continue` statement allows you to skip the rest of the code inside the loop for the current iteration.

  • `for` loops can be nested to perform actions for every combination of two or more variables.

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