This is where loops come in. In this article, you’ll learn:

• How to create your first loop

• Benefits and caveats of using loops

• The different types of loops in C# and how to use them

• When it’s best to use each one

Table of Contents

• How to Use a For Loop in C

• How to Use a ForEach Loop in C

• How to Use a Do..While Loop in C

• How to Use a While Loop in C

• Final Thoughts: Choosing the Right Loop

Let’s get started. Open your preferred IDE or coding editor and create a new Console Application in .Net 8+.

How to Use a For Loop in C

A for loop repeats a block of code a set number of times by:

• Initialising a loop variable.

• Checking a condition before each iteration.

• Updating the loop variable after each iteration.

You can create a for loop with the code below:

// number of iterations
var totalIterations = 5

// the loop
for(int i = 0; i <= totalIterations; i++){
   Console.Write($"{i},");
}

// Output
0,1,2,3,4,5,

Breaking it down:

• for — declares the loop

• int i = 0; — sets the starting point for the loop variable i

• i <= totalIterations; — the condition to keep looping. The code inside the loop runs only if this is true.

• i++ — shorthand for “increase i by 1” after each iteration

Iterations and Zero

Why does the example print six numbers when totalIterations is 5? C# uses zero-based indexing. Counting from 0 → 5 includes six numbers: 0,1,2,3,4,5.

If you want to print 1 → 5 instead, start i at 1:

var totalIterations = 5;
for (int i = 1; i <= totalIterations; i++)
{
    Console.Write($"{i},");
}
// Output: 1,2,3,4,5

Tip:
In general, for loops are used for indexing/accessing elements in collections, so it’s common practice to start your loop variable at 0 and use < (less than) a given number or length of the collection.

Reversal of Direction

You can reverse a for loop by starting at the end and decrementing i:

for (int i = 5; i > 0; i--)
{
    Console.Write($"{i},");
}
// Output: 5,4,3,2,1

The loop checks if i > 0. After each iteration, i decreases by 1, printing numbers in descending order.

Other Uses of For Loops

Let’s say you want to access every other item in a list. This is where the power of for loops come in, and we can maximise our loop variable, using it as an index accessor.

public class Address
{
    public string Name { get; set; } = string.Empty;
    public string AddressLineOne { get; set; } = string.Empty;
    public int HouseNumber { get; set; } = default;
    public string PostCode { get; set; } = string.Empty;
    public string Telephone { get; set; } = string.Empty;
}

internal class Program
{
    public static void Main()
    {
        var addressBook = new List<Address>
        {
            new Address
            {
                Name = "Grant", AddressLineOne = "Developer Avenue", HouseNumber = 1, PostCode = "DV19 8EP",
                Telephone = "0102919 93020-92019"
            },
            new Address
            {
                Name = "Bill", AddressLineOne = "Developer Avenue", HouseNumber = 19, PostCode = "DV19 8EP",
                Telephone = "0102919 93020-92019"
            },
            new Address
            {
                Name = "Rebecca", AddressLineOne = "Developer Avenue", HouseNumber = 4, PostCode = "DV19 8EP",
                Telephone = "0102919 93020-92019"
            },
            new Address
            {
                Name = "Amy", AddressLineOne = "Rower Avenue", HouseNumber = 1, PostCode = "DV19 8EP",
                Telephone = "0102919 93020-92019"
            },
            new Address
            {
                Name = "Joe", AddressLineOne = "Olympic Drive", HouseNumber = 1, PostCode = "DV19 10E",
                Telephone = "0102919 93020-92019"
            }
        };

        for (var i = 0; i < addressBook.Count; i += 2)
        {
            Console.WriteLine($"Name: {addressBook[i].Name}, PostCode: {addressBook[i].PostCode}");
        }
    }
}

/* Ouput:
Name: Grant, PostCode: DV19 8EP
Name: Rebecca, PostCode: DV19 8EP
Name: Joe, PostCode: DV19 10E
*/

What’s Happening:

• i starts at 0 and increases by 2 (i += 2) each iteration

• addressBook[i] now accesses every other item

• This shows the power of using i as an index

So far we’ve seen how for loops give control over indexes and step sizes.

But sometimes you just want to loop through every item in a collection, without worrying about indexes. That’s where the foreach loop shines.

How to Use a ForEach Loop in C

A foreach loop iterates over any object that inherits from IEnumerable (lists, arrays, collections). It automatically accesses each item in order, so you don’t need an index.

How To Write a ForEach Loop

var characters = new List<string>{"Batman", "CatWoman", "The Joker","Harley Quinn"};

foreach(var character in characters){
    Console.WriteLine(character);
}

/* Output:
Batman
CatWoman
The Joker
Harley Quinn
*/

Key points:

• No need for indexes

• Works with any enumerable collection

• Cleaner, more expressive code

Caveats of ForEach Loop

No Indexing

You can’t directly access items with addressBook[i] inside a foreach. That’s because foreach works on IEnumerable, which doesn’t expose indexes.

Performance

A foreach loop has a small overhead compared to a for loop. In most cases this won’t matter, but in performance-critical code, a for loop may be faster.

Modifying Items

foreach gives you a copy of the current item, not a direct reference. That means you can’t reassign values to the list items inside the loop.

• You can read properties.

• You can’t update the items themselves (use a for loop for that).

foreach is ideal when you want to visit every item, but not control the number of iterations.

How to Use a Do..While Loop in C

do..while loops run code at least once, then repeat while a condition is true:

int num;
do {
    Console.Write("Enter a positive number: ");
    num = int.Parse(Console.ReadLine());
} while (num <= 0);

Console.WriteLine(num);

The above code requests a number to be entered within the console application if the condition is met. That is, if a positive number is provided, the code will not ask for another, exiting the loop.

Should the user enter a negative number, it would continue to loop, requesting a positive number to be entered.

What if you didn’t want the code to run at least once, and only if a condition is met? This where you can use a while loop.

How to Use a While Loop in C

while loops repeat code as long as a condition is true, but the body may never run if the condition is initially false:

We can use an example of a darts score board:

var sum = 0;
var dartsThrown = 0;
var random = new Random();

while (sum < 180 && dartsThrown < 3)
{
    var dartScore = random.Next(61); // 0–60
    sum += dartScore;
    dartsThrown++;
}

Console.WriteLine("Your score is " + sum);

While the player has darts to throw, the code will pick a number at random and increase their score.

Tip: Always include code that changes the condition, or you risk creating an infinite loop. An infinite loop, is a loop which never stops, and causes your application to break.

You’ve seen four different ways to repeat code in C#: for, foreach, do..while, and while. Let’s summarise when to use each one.

Final Thoughts: Choosing the Right Loop

C# gives us several types of loops. Choosing the right one makes your code readable, efficient, and intentional.

• For Loop: Use when you know how many times to run something, or when you need an index, like using arrays, skipping items. Use a for loop when you need more control over the iterative nature of the loop.

• ForEach Loop: Use when you want to iterate through every item in a collection without worrying about indexes.

• While Loop: Use when you don’t know in advance how many times to run the code, but a condition drives the loop.

• Do..While Loop: Use when the loop body must run at least once, such as for user input or retry logic.

By matching the loop type to your intent, your code will be correct, readable, and maintainable.

I hope this tutorial was useful, and as always I’d love to hear your thoughts and discuss further on social media. You can find me on twitter/x.

In this article, we will learn about infinite loops in C++, their types and causes, and their applications.

Here’s what we’ll cover:

1. What is an Infinite Loop in C++?

2. Types of Infinite Loops in C++

3. Common Causes of Accidental Infinite Loops in C++

4. Applications of Infinite Loops in C++

5. Using Infinite Loops To Take User Input in C++

6. Conclusion

What is an Infinite Loop in C++?

An infinite loop is any loop in which the loop condition is always true, leading to the given block of code being executed an infinite number of times. They can also be called endless or non-terminating loops, which will run until the end of the program’s life.

Infinite loops are generally accidental and occur due to some mistake by the programmer. But they are pretty useful, too, in different kinds of applications, such as creating a program that does not terminate until a specific command is given.

Types of Infinite Loops in C++

There are several ways to create an infinite loop in C++, using different loop constructs such as while, for, and do-while loops. Here, we will explore each method and provide examples.

• Infinite While Loops

• Infinite For Loops

• Infinite do-while Loops

1. Infinite Loop using While Loop

This is the most popular type of while loop due to its simplicity. You just pass the value that will result in true as the condition of the while loop.

Syntax:

while(1)
    or
while(true)

Example Code:

// Example of Infinite loop in C++ using for loop
#include <iostream>
using namespace std;

int main() {
    // Infinite loop using while
    while (true) {
        cout << "This is an infinite loop." << endl;
    }
    return 0;
}

Output:

This is an infinite loop.

This is an infinite loop.

This is an infinite loop.

This is an infinite loop.

This is an infinite loop.

This is an infinite loop.

………………….

Infinite Loop using For Loop

In a for loop, if we remove the initialization, comparison, and update conditions, then it will result in an infinite loop.

Syntax:

for(;;)

Example Code:

//Example of Infinite loop in C++ using for loop

#include <iostream>
using namespace std;

int main() {
    // Infinite loop using for loop
    for (;;) {
        cout << "This is an infinite loop." << endl;
    }
    return 0;
}

Output:

This is an infinite loop.

This is an infinite loop.

This is an infinite loop.

This is an infinite loop.

This is an infinite loop.

This is an infinite loop.

This is an infinite loop.

……………………….

Infinite Loop using do-while Loop

Just like the other two loops discussed above, we can also create an infinite loop using a do-while loop. Although this loop is not preferred much due to its longer syntax.

Syntax:

do{
}while(1)

Example Code:

// Infinite loop in C++ using do-while loop

#include <iostream>
using namespace std;

int main() {
   // infinite do-while loop
    do {
        cout << "This is an infinite loop." << endl;
    } while (true);

    return 0;
}

Output:

This is an infinite loop.

This is an infinite loop.

This is an infinite loop.

This is an infinite loop.

This is an infinite loop.

This is an infinite loop.

This is an infinite loop.

……………………….

Common Causes of Accidental Infinite Loops in C++

Infinite loops can be both intentional and accidental. Accidental infinite loops are those which were not intended by the programmer but are caused due to some error in the program.

Following are some of the errors that may cause infinite loops in your programs unintentionally:

1. Missing Update Statements

Infinite loops are caused when you forget to add an update condition inside the loop, which will terminate the loop in the future. The following program illustrates such a scenario:

Example Code:

// Infinite loop caused due to missing update statement

#include <iostream>
using namespace std;

int main() {
    int i = 3;
    while (i < 5) {
        cout << i <<endl;
        // Missing update: i++;
    }
    return 0;
}

Output:

3

3

3

3

3

3

3

……………………

To fix the above code, we can add an update condition inside the loop like this:

// fixed code

#include<iostream>
using namespace std ;

int main() {
int i = 3;
while (i < 5) {
    cout << i << endl;
    i++; // add the condition
}

return 0 ; 

}

Output:

3

4

Incorrect Loop Conditions

The conditions mentioned inside the loop body are crucial to terminate a loop. An incorrect loop condition can result in an infinite loop. The following program illustrates such a scenario:

Example Code:

// Infinite loop caused due to incorrect loop conditions

#include <iostream>
using namespace std;

int main() {
    int i = 2;
    while (i >= 0) {  
        cout << "Hello AnshuAyush " << endl;

    }
    return 0;
}

Output:

Hello AnshuAyush

Hello AnshuAyush

Hello AnshuAyush

Hello AnshuAyush

Hello AnshuAyush

……………………..

To fix the above code, we can update i inside the loop to eventually make the condition false:

// fixed code 

#include<iostream>
using namespace std ;

int main() {
int i = 2;
while (i >= 0) {  
    cout << "Hello AnshuAyush" << endl;
    i--; // loop will stop
}

return 0 ; 

}

Ouptut:

Hello AnshuAyush

Hello AnshuAyush

Hello AnshuAyush

Logical Errors in the Loop

In many scenarios, infinite loops are caused by small logical errors in the code. The following program illustrates such a scenario:

Example Code:

#include <iostream>
using namespace std;

int main() {
    for (int i = 3; i >2; i += 2) {  
        cout <<"This is an infinite loop" << endl;
    }
    return 0;
}

Output:

This is an infinite loop.

This is an infinite loop.

This is an infinite loop.

This is an infinite loop.

This is an infinite loop.

This is an infinite loop.

This is an infinite loop.

……………………….

To fix the above code, we can either use a decreasing condition or use an incrementing loop condition.

Decreasing condition:

for (int i = 3; i > 0; i--) {
    cout <<"This is NOT an infinite loop" << endl;
}

Increasing condition:

for (int i = 3; i < 10; i += 2) {
    cout <<"Loop will end when i reaches 10" << endl;
}

Applications of Infinite Loops in C++

Infinite loops do not only occur by accident, as I mentioned above. You can also create them on purpose for different use cases. The following are some of the common applications where you might use infinite loops intentionally:

• Event loops: Many Graphical User Interfaces (GUIs) use infinite loops to keep the program running and responsive to user actions.

• Server applications: Web servers use infinite loops to continuously listen to client connections or requests.

• Embedded systems: Embedded systems, such as microcontrollers, frequently use infinite loops as their main program loops to continuously respond to external events.

• User inputs: Infinite loops are also used to wait for valid user inputs. The loop keeps running until a valid input is provided by the user. We’ll look at an example of this one.

Using Infinite Loops to Take User Input in C++

Infinite loops are commonly used in scenarios where a program needs to continuously take user input until a specific condition is met, such as exiting the program or getting a valid user input. The following program demonstrates how we can take user input from the user until a specific condition is met:

Example Code:

// C++ Program to take user input from users using infinite loops

#include <iostream>
#include <string>
using namespace std;

int main() {
    string input;

    while (true) {
        cout << "Enter a command (type 'exit' to quit): ";
        getline(cin, input);

        if (input == "exit") {
        // Exit the loop if the user types 'exit'
            break; 
        }

        cout << "You entered: " << input << endl;
        // Process the input
    }
    cout << "Program exited." << endl;
    return 0;
}

Output:

Enter a command (type 'exit' to quit): Anshu

You entered: Anshu

Enter a command (type 'exit' to quit): Ayush

You entered: Ayush

Enter a command (type 'exit' to quit): exit

Program exited.

Conclusion

Infinite loops aren’t always dangerous. They can be very useful when used with proper control, like break statements or condition checks. But if you use them carelessly, they can crash your program.

So just make sure you check your loop conditions and test your code using print statements between the programs to discover any unexpected behavior. In sum, infinite loops can be very powerful when handled carefully but can be very risky if left unchecked.

And if you'd like to support me and my work directly so I can keep creating these tutorials, you can do so here. Thank you!

If you’ve programmed in Python, you may have used the for loop to iterate over items in iterables such as lists. But for some use cases, using the for loop in conjunction with the else clause can be helpful.

In this tutorial, we’ll learn how to use for-else loops by coding a couple of examples to understand how they work.

Syntax of the for-else Loop in Python

In Python, the for-else loop is a construct that combines a for loop with an else clause.

The loop body typically checks for a condition. If the condition is True, the control breaks out of the loop. The else block will execute only when the for loop completes normally without encountering a break statement.

Let's look at a generic for-else loop construct:

for item in iterable:
    # loop body
    if condition:
        break
else:
    # else body

Here's a breakdown of how this works:

• The for loop iterates over each item in the iterable.
• If the condition is True and the control breaks out of the loop, the else block is skipped.
• If the for loop iterates over all items in the iterable—without meeting the condition to break out of the loop—the else block is executed.

Now let's code a couple of examples.

Example 1: Finding a Prime Number

Let's use the for-else loop to check if a number is prime. As you may recall, a number is prime if it is divisible only by 1 and itself and has no other factors.

Look at the code snippet below:

import math

def is_prime(n):
    if n <= 1:
        return False

    for i in range(2, int(math.sqrt(n))+ 1):
        if n % i == 0:
            print(f"{n} is divisible by {i}. Not a prime number.")
            break
    else:
        # This block executes if the loop did not encounter a break statement
        print(f"{n} is a prime number.")
        return True

Here, the is_prime() function first checks if the input number n is less than or equal to 1. If so, it returns False since prime numbers are greater than 1. Remember, the smallest prime number is 2.

We use the for loop to iterate over the range of numbers from 2 to the square root of n (inclusive).

• If n is divisible by any i in this range (2, √n), it means n is not a prime number, as we've found a factor. The function prints a message and breaks out of the loop. And the else block is skipped.
• If the loop completes without finding any factors—without hitting a break statement—the else block executes. The function prints that n is a prime number and returns True.

You can verify that the is_prime() function works as expected with a few function calls:

# Test with a non-prime number
is_prime(10) 
# Output: 10 is divisible by 2. Not a prime number.


# Test with a prime number
is_prime(13) 
# Output: 13 is a prime number.

📑 A Note on Checking for Prime Numbers

You’d probably run the loop over all the numbers from 2 to n to check if there’s a factor. But it actually suffices to iterate up to the square root of n. Why?

Recall that if p is a factor, you can always find a q such that p x q = n:

• If n is a perfect square, then p = q.
• If n is not a perfect square, you have the following. If p is less than √n, q is greater than √n. And if q is greater than √n, p is less than √n.

💡 So if you don't find a factor up to √n, you cannot find one beyond √n either.

Example 2: Searching for an Item in a List

Let's take another example where the for-else loop is helpful.

The following search item() function takes in a list and an item. The goal is to loop over the items in the list and check if the item exists. For this problem you can use the for-else loop construct like so:

def search_item(lst, item):
    for i in lst:
        if i == item:
            print(f"Found {item} in the list.")
            break
    else:
        print(f"{item} is not in the list.")

If the item is found the control breaks out of the loop. The else block is triggered only if the item is not found in the list.

Let’s verify with a few calls to the function:

# Test with a list containing the item
search_item([1, 2, 3, 4, 5], 3)  
# Output: Found 3 in the list.

# Test with a list not containing the item
search_item([1, 2, 3, 4, 5], 6)  
# Output: 6 is not in the list.

Wrapping Up

I hope you found this tutorial on the for-else loop construct in Python helpful.

This can come in handy especially when exiting the loop after iterating over all items—without breaking out of the loop earlier—is of interest. That said, if you don't need to conditionally break out of the loop, you don't need a for-else loop, and a simple for loop will suffice.

Keep coding. Until the next tutorial!

Python provides some built-in control statements that let you change the behavior of a loop. Some of these control statements include continue, break, pass, and else.

In this article, you'll learn how to terminate the current loop or a switch statement using the break statement.

How to Use the break Statement in a Python for Loop

Consider the Python list below:

usernames = ["Jade", "John", "Jane", "Doe"]

You can use a for loop to iterate through and print the elements of the usernames list:

usernames = ["Jade", "John", "Jane", "Doe"]

for i in usernames:
    print(i)
# Jade
# John
# Jane
# Doe

But what if you want to stop the loop when a particular username is found? You can do this using the break statement.

Here's an example:

usernames = ["Jade", "John", "Jane", "Doe"]

for i in usernames:
    print(i)
    if i == "John":
        break
# Jade
# John

In the code above, we created an if statement that checks whether the current value of i is "John": if i == "John".

In the body of the if statement, we used the break statement. So the loop will stop when it finds an element in the list with the value of "John".

So instead of printing the whole list ("Jade", "John", "Jane", "Doe"), "Jade" and "John" were printed because the loop stopped immediately after it found "John".

How to Use the break Statement in a Python while Loop

You can terminate a while loop using the break statement:

usernames = ["Jade", "John", "Jane", "Doe"]

i = 0
while i < len(usernames):
    print(usernames[i])
    if usernames[i] == "John":
        break
    i += 1

Just like we did in the for loop example, we created a usernames list with four elements: ["Jade", "John", "Jane", "Doe"].

Using an if statement in the while loop, we checked when the current loop was at the index with a value "John". When that happens, the loop is terminated.

Once again, "Jade" and "John" were printed because the loop stops when "John" is found.

Conclusion

In this article, you learned to use the break statement in Python. You can use it to terminate the current loop when a condition is met.

From the above examples, you learned how to use the break statement to terminate for and while loops in Python.

Happy coding!

The useEffect hook in React has become a common tool for managing side effects in functional components. But there's a common pitfall when using it: the potential for infinite loops. These can cause performance issues and disrupt the intended behavior of components.

In this tutorial, we will explore how to prevent infinite loops when using useEffect in React.

You use the useEffect hook in functional components in React to manage side effects, such as fetching data from an API, updating the DOM, or subscribing to events that are external to React.

Situations that Cause Infinite Loops

Missing Dependencies

One common mistake that can cause infinite loops is not specifying a dependency array. useEffect checks if the dependencies have changed after every render of the component.

So, when no dependencies are provided, the effect will run after every single render, which can lead to a continuous loop of updates if state is being updated.

For example, consider the following code:

function ExampleComponent(){
    const [count, setCount] = useState(0);

    useEffect(() => {
        setCount((count) => count+1);
    });
}

In this example, the following occurs:

• When the component initially renders, the effect will run.
• When the effect is run, it updates a count state, resulting in the component being re-rendered.
• Since the component is re-rendered, it causes the useEffect to run again.
• This causes the count state to update again, and goes on forever.

Animation showing process of an infinite loop caused by useEffect

This happened because there isn't any dependency array specified, indicating that the effect should be run every time after the component re-renders.

To avoid this, add an empty dependency array:

function ExampleComponent(){
    const [count, setCount] = useState(0);

    useEffect(() => {
        setCount((count) => count+1);
    }, []);
}

This will ensure that the effect is only executed after the initial rendering of the component.

Alternatively, if your effect depends on a certain state, remember to add it as a dependency:

function ExampleComponent(){
    const [isLoggedIn, setIsLoggedIn] = useState(false);

    useEffect(() => {
        // logic
    }), [isLoggedIn];
}

That way, the effect is only run initially and when the dependency has changed after the component has re-rendered.

Using References as Dependencies

In JavaScript, data types can be categorized as being reference values or primitive values.

Primitive values are basic data types such as Strings, Booleans, Numbers, Null and Undefined.

On the other hand, reference values are more complex data types such as Arrays and Objects.

Types of primitive and reference values in JavaScript

When a reference value is assigned to a variable, the value and location to that value is stored and the variable will only point to that location.

Whereas with a primitive value, the variable is directly assigned to the primitive's value. The value is stored on a stack, a data structure used to store static data.

With reference values such as Functions and Objects, they are stored in a heap, a data structure used for dynamic memory allocation, which is useful when storing complex data types.

The variable is then assigned to the location in the stack, which points to the reference value in the heap.

A Heap is a data structure used to store reference values

This is helps make our applications more efficient. Imagine having to create a duplicate of a complex object every time it is re-assigned to a new variable! Instead, the new variable can just point to the same location in the heap.

As useful as it is, reference values can be problematic when used as a dependency. This is because React will compare the location of the reference value if it is used as a dependency instead of the value's contents.

For example, consider the component:

function ExampleComponent(props){
    const [count, setCount] = useState(1);
    let data = {
        a: 1,
        b: 2
    };
    useEffect(() => {
        setCount((count) => count+1);
        //other logic
    }, [data]);
}

In this case, the following occurs:

• When the component initially renders, the effect is run
• When the effect is run, the state is updated. This causes the component to be re-rendered
• When the component is re-rendered, a new data object is created, so its reference location is different from the previous
• This causes the effect to run again since the dependency data object has changed
• The cycle repeats, causing an infinite loop

To prevent this from happening, we can use the useRef hook. It allows us to re-use the same value between re-renders.

This hook allows us to store values that will persist between renders, so the object's reference location will be the same throughout all render cycles.

function ExampleComponent(props){
    const [count, setCount] = useState(1);
    const data = useRef({
        a: 1,
        b: 2,
    });
    useEffect(() => {
        setCount((count) => count+1);
        // logic
    }, [data.current]);

    // rest of component
}

The useRef hook takes in an initial value and returns a single object with a property called current.

The current property will be the value passed into the useRef hook, and will be the same throughout all renders of the component.

This ensures the effect doesn't run in an infinite loop since the dependency in the useEffect hook will no longer change with each render of the component.

Note that you can also change the value of the data.current property. For example:

data.current = {c: 3, d: 4}

By changing the value of data.current, it will not trigger the component to re-render and React is not aware of this change.

Using Functions as Dependencies

Another reason that useEffect may be causing an infinite loop is if you use a function as a dependency.

Since a function is a reference value in JavaScript, we encounter the same issue with using objects as dependencies.

For example, if we have a function in our component, the function will be re-created every time the component is re-rendered:

function ExampleComponent(props){
    const [count, setCount] = useState(1);
    const submitForm = (event) => {
        // logic
    };
    useEffect(() => {
        setCount((count) => count+1);
        // logic
    }, [submitForm]);

    // rest of component
}

So when the component initially renders:

• The effect is run initially, causing the count state to update
• Since the state has been updated, the component re-renders, causing the submitForm function to be re-created
• The effect will run again as the submitForm dependency of the useEffect hook has changed
• When the effect runs again, the count state is updated and the loop goes on

To avoid the function from being re-created every time the component is re-rendered, we can use the useCallback hook:

function ExampleComponent(props){
    const [count, setCount] = useState(1);
    const submitForm = useCallback((event) => {
        // logic
    }, []);
    useEffect(() => {
        setCount((count) => count++);
        // logic
    }, [submitForm]);

    // rest of component
}

The useCallback hook also accepts two arguments, the first being the function that needs to be cached and stored without changing between renders, and the second being a dependency array. If the dependencies in the useCallback hook changes, the function is re-created.

So, similar to using useEffect, we can use an empty dependency array to ensure the function isn't being re-created between renders.

This prevents the effect from running in an infinite loop when a function is used as a dependency.

Summary

The useEffect hook in React is necessary when working with side effects in your React components. But even with experience, common mistakes can lead to infinite loops in your components. Be sure to watch out for missing dependencies, and using references or functions as dependencies when that happens.

We also took a look at how to use the useRef and useCallback hooks to prevent objects from being re-created in between renders.

If you enjoy my writing, consider checking out my YouTube channel for more.

Happy coding!

Python offers two types of loops: for and while loops. In this article, we will explore both of these loop types and provide examples of how to use them in your Python code.

How to Use For Loops in Python

You'll use a for loop when you want to iterate over a collection of items or when you know the exact number of times you want to execute a block of code.

Here's the code for a for loop in Python:

for variable in iterable:
    # code to execute

• variable is a variable that represents the current item in the iterable that we're iterating over.

• iterable is a collection of items that we want to iterate over, such as a list, tuple, string, or range.

For example, let's say we have a list of numbers and we want to print each number:

numbers = [1, 2, 3, 4, 5]
for num in numbers:
    print(num)

Output

1
2
3
4
5

We can also use the range() function to specify a range of numbers to iterate over:

for num in range(1, 6):
    print(num)

Output:

1
2
3
4
5

The range() function takes two arguments: the starting number and the ending number (exclusive). In this case, the loop will iterate over the numbers from 1 to 5.

How to Use While Loops in Python

You'll use a while loop when you want to execute a block of code repeatedly based on a condition.

Here's the syntax for a while loop in Python:

while condition:
    # code to execute

condition is a boolean expression that determines whether the loop should continue or not.

For example, let's say we want to print the numbers from 1 to 5 using a while loop:

num = 1
while num <= 5:
    print(num)
    num += 1

In this example, we initialize the num variable to 1 and then execute the loop as long as num is less than or equal to 5. Inside the loop, we print the current value of num and then increment it by 1.

We can also use a while loop to keep asking the user for input until they enter a valid response:

valid_response = False
while not valid_response:
    response = input("Enter 'yes' or 'no': ")
    if response.lower() == 'yes' or response.lower() == 'no':
        valid_response = True
    else:
        print("Invalid response. Please enter 'yes' or 'no'.")

Let's take a look at some advanced uses of loops in Python.

How to Use Nested Loops in Python

Nested loops are loops that are contained inside other loops. They allow us to iterate over a collection of items multiple times and are useful for tasks such as generating all possible combinations of items.

Here's an example of how to use nested loops to generate all possible pairs of numbers from two lists:

list1 = [1, 2, 3]
list2 = [4, 5, 6]

for num1 in list1:
    for num2 in list2:
        print(num1, num2)

Output:

1 4
1 5
1 6
2 4
2 5
2 6
3 4
3 5
3 6

In this example, we use a nested for loop to iterate over each item in list1 and list2, and print out all possible pairs of numbers.

List Comprehension in Python

List comprehensions are a concise way to create lists based on existing lists or other iterable objects. They use a for loop and an optional conditional statement to generate the new list.

Here's an example of how to use list comprehension to create a new list of even numbers from an existing list:

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even_numbers = [num for num in numbers if num % 2 == 0]
print(even_numbers)

Output:

[2, 4, 6, 8, 10]

In this example, we use a list comprehension to iterate over each number in the numbers list and add it to the even_numbers list if it is even (that is, the remainder when divided by 2 is 0).

How to Iterate Over a Dictionary in Python

In Python, we can iterate over the keys, values, or items (key-value pairs) of a dictionary using a for a loop.

Here's an example of how to iterate over the items of a dictionary and print out the key-value pairs:

fruits = {'apple': 'red', 'banana': 'yellow', 'orange': 'orange'}

for fruit, color in fruits.items():
    print(f"The {fruit} is {color}.")

Output:

The apple is red.
The banana is yellow.
The orange is orange.

In this example, we use the items() method of the fruits dictionary to iterate over each key-value pair, and then print out a formatted string that includes the fruit and its corresponding color.

Conclusion

Loops are an essential part of programming in Python. They allow us to automate repetitive tasks and manipulate data in powerful ways.

By understanding the basics of for and while loops, as well as more advanced concepts such as nested loops and list comprehensions, you'll be able to write efficient and effective code in Python.

Let’s connect on Twitter and Linkedin

Enhanced loops simplify the way you create for loops. They are mostly used to iterate through an array or collection of variables.

In this tutorial, you'll learn the syntax and how to use the for-each loop (enhanced loop) in Java.

Java For-Each Loop Syntax

Here's what the syntax of a for-each loop in Java looks like:

for(dataType variable : array) {
    // code to be executed
}

In the syntax above:

• dataType denotes the data type of the array.
• variable denotes a variable assigned to each element in the array during the iteration (you'll understand this through the examples that follow).
• array denotes the array to be looped through.

Java For-Each Loop Example

Let's take a look at some examples to help you understand how a for-each loop works.

Java For-Each Loop Example #1

class ForEachExample {
    public static void main(String[] args) {

        int[] even_numbers = { 2, 4, 6, 8 };

        for(int number : even_numbers){
           System.out.println(number);
           // 2
           // 4
           // 6
           // 8
        }

    }
}

In the code above, we created an array called even_numbers.

To loop through and print all the numbers in the array, we made use of a for-each loop: for(int number : even_numbers){...}.

In the parenthesis for the loop, we created an integer variable called number which would be used to loop through the even_numbers array.

So, for:

Iteration #1

number = first element in the array (2). This gets printed out.

Iteration #2

number = second element in the array (4). This current value gets printed out.

Iteration #3

number = third element in the array (6). This current value gets printed out.

Iteration #4

number = fourth element in the array (8). This current value gets printed out.

The value of number keeps changing to the current index during the iteration process until it gets to the end of the array. After each index is printed out, it moves to the next index.

You can also see it this way: "For every number in the even_numbers array, print number)".

Java For-Each Loop Example #2

class ForEachExample {
    public static void main(String[] args) {

        int[] even_numbers = { 2, 4, 6, 8 };

        for(int number : even_numbers){
            number = number*2;
            System.out.println(number);
        }

    }
}

In the code above, we're multiplying the value of each element by two using the number variable: number = number*2;.

The process here is the same with the last example. When number becomes an element in the array, it doubles the element's value and prints it to the console.

Summary

You can use for-each loops in Java to iterate through elements of an array or collection.

They simplify how you create for loops. For instance, the syntax of a for loop requires that you create a variable, a condition that specifies when the loop should terminate, and an increment/decrement value.

With for-each loops, all you need is a variable and the array to be looped through.

But this doesn't mean that you should always go for for-each loops.

for loops give you more control over what happens during the iteration process – controlling and tracking what happens at every index or some indexes.

On the other hand, for-each loops can be used when you have no use for tracking each index. The code just runs through for every element in the array.

You can learn more about for loops in Java by reading this article.

Happy coding!

A loop is an instruction in computer programming that allows an application to repeat a process until a specific condition is met.

For example, say you want to run through a list of names and output each name on your screen. If you didn't use a loop, you'd end up repeating code to output each name. But with a loop, you're able to output each name individually without repeating any code.

This article will walk you through the process of how you can loop through an array using the five most common loops in JavaScript.

What Is an Array in JavaScript?

An array in JavaScript is a variable that you can use to store multiple elements. It is usually in the form of square brackets that contain different elements, strings, and integers (or both strings and integers).

What Is a Loop in JavaScript?

A loop is a conditional statement used to run a sequence of instructions until a specified condition is met. It is given a statement that repeats the execution of a block of code and ends the execution once the stated condition is met.

Let's loop through this array – let name = ['Dennis', 'Precious', 'Evelyn'], – using one of the most commonly used loops in JavaScript.

How to Loop Through an Array with a For Loop in JavaScript

A for loop is a statement that repeats the execution of a block of code when the condition has not been met and terminates the execution when the condition has been met.

Let's now loop through an array using the for loop method.

I advise that you go through this article carefully to not miss vital details along the way. But in case you are in a hurry to loop through an array using the for loop statement, you can check out the syntax below.

Quick for loop explanation:

This is the fast route to looping through an array using the for loop statement with an example.

Syntax:

let name = ['Dennis', 'Precious', 'Evelyn'];
for (let i = 0; i < name.length; i++)
 {    
     console.log(name[i]);
}

And here's the output:

Dennis
Precious
Evelyn

How for loops work – in more detail

Here we will get to understand what a for loop is and how to use this statement to loop through an array with an example.

To run a for loop statement, you must know that it always needs to have three primary expressions that are always separated by a semicolon.

Syntax:

for (expression1; expression2; expression3)
 {  
  //code to be executed
}

• expression1: This is the initialization expression, which you use to declare a for loop counter variable with either the var or let keywords, such as var i = 0 or let i = 0.
• expression2: This is the condition expression, which either returns true or false. It determines whether the for loop should continue the execution or end the execution.

Remember that a for loop statement continues executing a block of code when the condition has not been met, it only terminates the loop when the condition has been met.

• expression3: This is the update expression, which is usually used to increment (++i) or decrement (--i) the for loop counter variable whenever the for loop condition has been met.

Now that we understand the for loop statement expressions, let's work with an example.

Syntax:

const arrayName = ['Dennis', 'Precious', 'Evelyn']
for (let i = 0; i < arrayName.length; i++) {
    console.log(arrayName[i]);
}

This syntax above loops through the name array and console.log () the strings in the array as long as the condition has not been met.

From the syntax above:

• We first initialized the counter variable, let i = 0;.
• Then we gave the loop a condition to terminate the loop once the value of the counter variable (i) is less than (<) the length of the name (name.length;).
• You use the keyword length to check the length of a string.

Here's the output:

Dennis
Precious
Evelyn

Conclusion

In this tutorial, we discussed the fundamentals of a for loop in JavaScript as well as the definition of an array. We also learned how to use the JavaScript 'for' loop statement to loop through an array.

Thanks for reading.

In programming, iteration (commonly known as looping) is a process where a step is repeated n number of times until a specific condition is met.

Just like every other programming language, Golang has a way of iterating through different data structures and data types like structs, maps, arrays, strings, and so on.

In this article you will learn:

• How to loop through arrays
• How to loop through strings
• How to loop through maps
• How to loop through structs

How to Loop Through Arrays and Slices in Go

Arrays are powerful data structures that store similar types of data. You can identify and access the elements in them by their index.

In Golang, you can loop through an array using a for loop by initialising a variable i at 0 and incrementing the variable until it reaches the length of the array.

They syntax is shown below:

for i := 0; i < len(arr); i++ {
    // perform an operation
}

As an example, let's loop through an array of integers:

package main

import (
    "fmt"
)

func main() {
    numbers := []int{7, 9, 1, 2, 4, 5}

    for i := 0; i < len(numbers); i++ {
        fmt.Println(numbers[i])

    }
}

In the code above, we defined an array of integers named numbers and looped through them by initialising a variable i . We then printed out the value of each index of the array while incrementing i .

The code above outputs the following:

7
9
1
2
4
5

We can also loop through an array using the range keyword which iterates through the entire length of an array.

The syntax is shown below:

for index, arr := range arr {
  // perform an operation    
}

For example:

package main

import (
    "fmt"
)

func main() {
    arr := []string{"a", "b", "c", "d", "e", "f"}

    for index, a := range arr {
        fmt.Println(index, a)
    }

}

In the code above, we defined an array of strings and looped through both its index and value using the for..range keyword.

The for...range is more simpler in syntax and easier to understand. You use it to iterate different data structures like arrays, strings, maps, slices, and so on.

This outputs the following:

0 a
1 b
2 c
3 d
4 e
5 f

Assuming we were to ignore the index and simply print out the elements of the array, you just replace the index variable with an underscore.

For example:

package main

import (
    "fmt"
)

func main() {
    arr := []string{"a", "b", "c", "d", "e", "f"}

    for _, a := range arr {
        fmt.Println(a)
    }

}

In the code above, we modified the previous example and replaced the index variable with an underscore. We did this to ignore the index and output the elements of the array instead.

This outputs the following:

a
b
c
d
e
f

How to Loop Through Strings in Go

Strings in programming are immutable – this means you can't modify them after you create them. They're ordered sequences of one or more characters (like letters, numbers, or symbols) that can either be a constant or a variable.

In Golang, strings are different from other languages like Python or JavaScript. They are represented as a UTF-8 sequence of bytes and each element in a string represents a byte.

You loop through strings using the for...range loop or using a regular loop.

For example:

package main

import (
    "fmt"
)

func main() {
    word := "Ab$du"

    for index, a := range word {
        fmt.Println(index, string(a))
    }
}

In the code above, we defined a string containing different characters and looped through its entries. Strings are represented as bytes in Golang, which is why we needed to convert each value to the type string when printing them out.

This outputs:

0 A
1 b
2 $
3 d
4 u

If we hadn't converted each entry to a string, Golang would print out the byte representation instead.

For example:

package main

import (
    "fmt"
)

func main() {
    word := "Ab$du"

    for index, a := range word {
        fmt.Println(index, a)
    }
}

The outputs:

0 65
1 98
2 36
3 100
4 117

We can also iterate through the string by using a regular for loop.

package main

import (
    "fmt"
)

func main() {
    word := "ab$du"

    for i := 0; i < len(word); i++ {
        fmt.Println(i, string(word[i]))
    }
}

How to Loop Through Maps in Go

In Golang, a map is a data structure that stores elements in key-value pairs, where keys are used to identify each value in a map. It is similar to dictionaries and hashmaps in other languages like Python and Java.

You can iterate through a map in Golang using the for...range statement where it fetches the index and its corresponding value.

For example:

package main

import (
    "fmt"
)

func main() {
    books := map[string]int{
        "maths":     5,
        "biology":   9,
        "chemistry": 6,
        "physics":   3,
    }
    for key, val := range books {
        fmt.Println(key, val)
    }
}

In the code above, we defined a map storing the details of a bookstore with type string as its key and type int as its value. We then looped through its keys and values using the for..range keyword.

Iterating through a map in Golang doesn't have any specified order, and we shouldn't expect the keys to be returned in the order we defined when we looped through.

This code outputs:

physics 3
maths 5
biology 9
chemistry 6

If we don't want to specify the values and return just the keys instead, we simply don't define a value variable and define a key variable only.

For example:

package main

import (
    "fmt"
)

func main() {
    books := map[string]int{
        "maths":     5,
        "biology":   9,
        "chemistry": 6,
        "physics":   3,
    }
    for key := range books {
        fmt.Println(key)
    }
}

This outputs the following:

maths
biology
chemistry
physics

Likewise, if we aren't interested in the keys of a map, we use an underscore to ignore the keys and define a variable for the value.

For example:

package main

import (
    "fmt"
)

func main() {
    books := map[string]int{
        "maths":     5,
        "biology":   9,
        "chemistry": 6,
        "physics":   3,
    }
    for _, val := range books {
        fmt.Println(val)
    }
}

This outputs:

5
9
6
3

How to Loop Through Structs in Go

Struct is a data structure in Golang that you use to combine different data types into one. Unlike an array, a struct can contain integers, strings, booleans and more – all in one place.

Unlike a map, where we can easily loop through its keys and values, looping through a struct in Golang requires that you use a package called reflect. This allows us you modify an object with an arbitrary type.

For example, let's create a struct and loop through it:

package main

import (
    "fmt"
    "reflect"
)

type Person struct {
    Name   string
    Age    int
    Gender string
    Single bool
}

func main() {
    ubay := Person{
        Name:   "John",
        Gender: "Female",
        Age:    17,
        Single: false,
    }
    values := reflect.ValueOf(ubay)
    types := values.Type()
    for i := 0; i < values.NumField(); i++ {
        fmt.Println(types.Field(i).Index[0], types.Field(i).Name, values.Field(i))
    }
}

This outputs:

0 Name John
1 Age 17
2 Gender Female
3 Single false

In the code above, we defined a struct named Person with different attributes and created a new instance of the struct. We then used the reflect package to get the values of the struct and its type.

By using the regular for loop, we incremented the initialised variable i until it reached the length of the struct.

We use the NumField method to get the total number of fields in the struct. The types.Field(i).Index method returns the index of each key in a struct. The types.Field(i).Name method returns the field name for each key in the struct. And the values.Field(i) returns the value for each key in the struct.

You can learn more about the reflect package in this article:

Conclusion

In this article, we have explored how to perform iteration on different data types in Golang.

While you can loop through arrays, maps, and strings using a for loop or for..range loop, structs require an additional package called reflect to loop through their keys and values.

I hope this article helps you understand iteration in Golang better.

Thanks for reading.

It is an ordered list of values, and each value is referred to as an element, which is specified by an index.

Knowing that these single variables contain a list of elements, you might want to create a list of these elements so that you can perform individual functions with them and much more. This is where the loop comes into play.

Here's an interactive scrim about how to loop through an array in JavaScript:

What are Loops in JavaScript?

A loop is a type of computer program that allows us to repeat a specific operation a predetermined number of times without having to write that operation individually.

For example, if we have an array and want to output each element in the array, rather than using the index number to do so one by one, we can simply loop through and perform this operation once.

There are numerous methods for looping through an array in JavaScript. In this article, we will go over the most commonly used so you can learn different approaches and understand how they work.

We will use the following array for this article:

const scores = [22, 54, 76, 92, 43, 33];

How to Loop Through an Array with a While Loop in JavaScript

You can use a while loop to evaluate a condition that is enclosed in parenthesis (). If the condition is true, the code inside the while loop is executed. If it is false, the loop is terminated.

If we want to loop through an array, we can use the length property to specify that the loop should continue until we reach the last element of our array.

Let's now use the while loop method to loop through the array:

let i = 0;

while (i < scores.length) {
    console.log(scores[i]);
    i++;
}

This will return each element in our array one after the other:

22
54
76
92
43
33

In the loop above, we first initialized the index number so that it begins with 0. Then the number will continue to increase and output each element until the condition we set returns false, indicating that we have reached the end of the array. When i = 6, the condition will no longer be executed because the array's last index is 5.

How to Loop Through an Array with a do…while Loop in JavaScript

The do...while loop is nearly identical to the while loop, except that it executes the body first before evaluating the condition for subsequent executions. This means that the loop's body is always executed at least once.

Let’s perform the same loop with the do…while loop to see how it works:

let i = 0;

do {
    console.log(scores[i]);
    i++;
} while (i < scores.length);

This will return each element in our array:

22
54
76
92
43
33

As previously stated, this will always run once before evaluating any condition set. For example, if we set the index i to 6 and it is no longer less than scores.length, the body of the loop will run first before checking the condition:

let i = 6;

do {
    console.log(scores[i]);
    i++;
} while (i < scores.length);

This will return a single undefined because we do not have an element in the array of index 6 but as you can see it ran once before stopping.

How to Loop Through an Array with a for Loop in JavaScript

The for loop is an iterative statement that checks for certain conditions and then executes a block of code repeatedly as long as those conditions are met.

We don't need to initialize the index first when using the for loop method because the initialization, condition, and iteration are all handled in the bracket, as shown below:

for (let i = 0; i < scores.length; i++) {
    console.log(scores[i]);
}

This will return all the elements as other methods have done:

22
54
76
92
43
33

How to Loop Through an Array with a for…in Loop in JavaScript

The for…in loop is an easier way to loop through arrays as it gives us the key which we can now use to get the values from our array this way:

for (i in scores) {
    console.log(scores[i]);
}

This will output all the elements in our array:

22
54
76
92
43
33

How to Loop Through an Array with a for…of Loop in JavaScript

The for...of Loop iterates over iterable objects such as arrays, sets, maps, strings, and so on. It has the same syntax as the for...in loop, but instead of getting the key, it gets the element itself.

This is one of the easiest methods for looping through an array and was introduced in later versions of JavaScript ES6.

for (score of scores) {
    console.log(score);
}

This gets each element of our array and we no longer need to make use of the index to get each element of our array:

22
54
76
92
43
33

How to Loop Through an Array with a forEach Loop in JavaScript

The array method forEach() loop's through any array, executing a provided function once for each array element in ascending index order. This function is known as a callback function.

This is a more advanced method that can do much more than simply loop through each element, but you can also use it to loop through this way:

scores.forEach((score) => {
    console.log(score);
});

You can write this in one line this way:

scores.forEach((score) => console.log(score));

And this will give us the same output as all previous methods:

22
54
76
92
43
33

Wrapping Up

In this article, we looked at six different/standard methods for looping through an array.

It is critical that you understand all of these methods and then determine which method is preferable for you, cleaner to use, and easier to read.

Embark on a journey of learning! Browse 200+ expert articles on web development. Check out my blog for more captivating content from me.

These arrays can hold any datatype, including objects, numbers, strings, and many others.

In this article, we'll look at how you can use the JavaScript forEach() array method to loop through all types of arrays, as well as how it differs from the for loop method.

There are many iteration methods in JavaScript, including the forEach() method, and they almost all perform the same function with minor differences. It is entirely up to you whether or not to use a specific loop method, but it is important that we understand each of them and how they work.

JavaScript forEach()

The forEach() array method loops through any array, executing a provided function once for each array element in ascending index order. This function is referred to as a callback function.

Note: Arrays are collections of elements that can be of any datatype.

Syntax and Parameters of a forEach() Loop

Here are the standard ways of writing the forEach Loop:

array.forEach(callbackFunction);
array.forEach(callbackFunction, thisValue);

The callback function can accept up to three different arguments, though not all of them are required. Here are some examples of forEach() loops that use both the normal function and the ES6 method to declare the callback function:

// Using only Current Element
array.forEach((currentElement) => { /* ... */ })
array.forEach(function(currentElement) { /* ... */ })

// Using only Current Element and Index
array.forEach((currentElement, index) => { /* ... */ })
array.forEach(function(currentElement, index) { /* ... */ })

// Using only Current Element, Index and array
array.forEach((currentElement, index, array) => { /* ... */ })
array.forEach(function(currentElement, index, array){ /* ... */ })

// Using all parameters with thisValue (value of this in the callback) 
array.forEach((currentElement, index, array) => { /* ... */ }, thisValue)
array.forEach(function(currentElement, index, array) { /* ... */ }, thisValue)

The syntax above may appear confusing, but it is the general syntax for writing a forEach loop depending on the value you want to use. Let's go over all of the parameters that we used:

• callbackFunction: The callback function is a function that is executed only once for each element and can accept the following arguments to be used within the callback function:

1. currentElement: The current element, as the name implies, is the element in the array that is being processed at the time the loop occurs. It is the only necessary argument.

2. index: index is an optional argument that carries the index of the currentElement.

3. array: The array is an optional argument that returns the array that was passed to the forEach() method.

• thisValue: This is an optional parameter that specifies the value that will be used in the callback function.

In summary, the forEach() array iteration method accepts a callback function that holds arguments that can be used within the callback function for each array item, such as the array item, the index of the item, and the entire array.

forEach() Examples in JavaScript

Before we look at other possible examples, let's look at all of the arguments we passed into the callback function and what they could be used for.

How to use the currentElement Argument

Assume we have an array of employee details that includes their names, age, salary amount, and currency:

const staffsDetails = [
  { name: "Jam Josh", age: 44, salary: 4000, currency: "USD" },
  { name: "Justina Kap", age: 34, salary: 3000, currency: "USD" },
  { name: "Chris Colt", age: 37, salary: 3700, currency: "USD" },
  { name: "Jane Doe", age: 24, salary: 4200, currency: "USD" }
];

If we want to display all of the names individually with some words around them, we can use the forEach() method as follows:

staffsDetails.forEach((staffDetail) => {
  let sentence = `I am ${staffDetail.name} a staff of Royal Suites.`;
  console.log(sentence);
});

Output:

"I am Jam Josh a staff of Royal Suites."
"I am Justina Kap a staff of Royal Suites."
"I am Chris Colt a staff of Royal Suites."
"I am Jane Doe a staff of Royal Suites."

Note: We could also destructure the currentElement value in case it’s an object that contains key/value pairs this way:

staffsDetails.forEach(({ name }, index) => {
  let sentence = `I am ${name} a staff of Royal Suites.`;
  console.log(sentence);
});

How to use the index Argument

We could also get the index of each array item by just making use of the unbuilt index argument this way:

staffsDetails.forEach((staffDetail, index) => {
  let sentence = `index ${index} : I am ${staffDetail.name} a staff of Royal Suites.`;
  console.log(sentence);
});

Output:

"index 0 : I am Jam Josh a staff of Royal Suites."
"index 1 : I am Justina Kap a staff of Royal Suites."
"index 2 : I am Chris Colt a staff of Royal Suites."
"index 3 : I am Jane Doe a staff of Royal Suites."

How to use the array Argument

The array argument is the third argument which holds the original array that is being iterated over. For example, we could try displaying the value in our console this way:

staffsDetails.forEach((staffDetail, index, array) => {
  console.log(array);
});

This would output the entire array 4 times since we have 4 items and the iteration runs 4 times. Let’s do it for an array with a few values so I can add the output here:

let scores = [12, 55, 70];

scores.forEach((score, index, array) => {
  console.log(array);
});

Output:

[12,55,70]
[12,55,70]
[12,55,70]

So far, we've used every argument of the callback function. Let's look at some other examples to fully understand how it works before doing a quick comparison with the for loop method.

How to Add All Values in An Array of Numbers with forEach()

Suppose we have an array of scores. We could use the forEach() array method to loop through and help add up these numbers:

const scores = [12, 55, 70, 47];

let total = 0;
scores.forEach((score) => {
  total += score;
});

console.log(total);

Recall that earlier on, we were making use of an array of staff details. Now let’s try adding all the staff member's salaries together to see how it works with objects:

let totalSalary = 0;
staffsDetails.forEach(({salary}) => {
  totalSalary += salary;
});

console.log(totalSalary + " USD"); // "14900 USD"

Note: We destructed the currentElement’s Object.

How to Use Conditionals in a forEach() Callback Function

When looping through arrays, we may want to check for specific conditions, as is commonly done with the for loop method. We can pass these conditions into our callback function or any other operation we want to run on each array item.

For example, if we only want to show the names of people whose salaries are greater than or equal to 4000 from the array of staff details we declared earlier, we can do the following:

staffsDetails.forEach(({name, salary}) => {
  if(salary >= 4000){
    console.log(name);
  }
});

Output:

"Jam Josh"
"Jane Doe"

Comparing forEach() with a for Loop

The for loop is very similar to the forEach method, but each possess some features that are unique to them such as:

Break out and continue in a Loop

When looping through an array, we may want to either break out or continue the loop when a certain condition is met (meaning we skip). This is possible with the break and continue instruction, but it does not work with the forEach() method, as shown below:

const scores = [12, 55, 70, 47];

scores.forEach((score) => {
  console.log(score);

  if (score === 70) 
    break;
});

This will throw a syntax error of Illegal break statement. This applies also to the continue instruction which would also throw an Illegal continue statement: no surrounding iteration statement.

const scores = [12, 55, 70, 47];

scores.forEach((score) => {
  if (score === 70) 
    continue;

  console.log(score);
});

But fortunately this works with the for loop method perfectly:

const scores = [12, 55, 70, 47];

for (i = 0; i < scores.length; i++) {
  console.log(scores[i]);

  if (scores[i] === 70) 
    break;
}

Output:

12
55
70

And the same with the continue instruction:

const scores = [12, 55, 70, 47];

for (i = 0; i < scores.length; i++) {
  if (scores[i] === 70) 
    continue;

  console.log(scores[i]);
}

Output:

12
55
47

Array with Missing elements

Another important comparison to make is in a situation whereby the array we are iterating over has some missing values/array items as seen below:

const studentsScores = [70, , 12, 55, , 70, 47];

This could be due to a developer error or something else, but these two methods take two different approaches to looping through these types of arrays. The for loop returns undefined where there are missing values, whereas the forEach() method skips them.

For Loop

const studentsScores = [70, , 12, 55, , 70, 47];

for (i = 0; i < studentsScores.length; i++) {
  console.log(studentsScores[i]);
}

Output:

70
undefined
12
55
undefined
70
47

forEach()

const studentsScores = [70, , 12, 55, , 70, 47];

studentsScores.forEach((stundentScore) => {
  console.log(stundentScore);
});

Output:

70
12
55
70
47

Note: Async/Await does not work with the forEach() array method but works with the for loop method.

Conclusion

In this article, we learned how to use the forEach() array method, which allows us to loop through an array of any type of item. It also allows us to write cleaner, more readable code than the for loop.

And many developers are familiar with loops, but not everyone understands how they work and why or when they should use a specific type of loop.

In this article, we will learn what for loops are, how they work, and why we use them. We'll also keep in mind that there are several types of loops, each of which performs a specific function even though they can almost all perform the same common function.

What are Loops?

Loops are computer programs that execute a set of instructions or a block of code a certain number of times without having to write it again until a certain condition is met. In other words, loops let your code execute one or more statements as many times as desired.

Again, there are many types of loops, but we will only look at the for loop in this article.

Almost every high-level programming language, including JavaScript, has a for loop. We're only going to look at JavaScript in this article, and we'll look at its syntax and some examples.

For Loops in JavaScript

The for loop is an iterative statement which you use to check for certain conditions and then repeatedly execute a block of code as long as those conditions are met.

Flowchart for the for loop

Syntax of a for loop

for (initialExpression; condition; updateExpression) {
    // for loop body: statement
}

The code block above is the standard syntax used by for loop. Let's look at each parameter to see what it means and what it does:

• initialExpression: This is used to set the value of a counter variable, and it is only evaluated once, before the loop starts. Depending on the scope, these counter variables are usually declared with the var or let keywords.

• condition: This is a constant-evaluation expression that determines whether the loop should be executed. In simple terms, if this condition returns true, the for loop's block of code is executed. If it returns false, the for loop is terminated.

• updateExpression: This is commonly used to update or increment the initialExpression counter variable. In other words, when the condition is true, it updates the value of the initialExpression.

In summary, the for loop causes the initialExpression variable, which is set to a starting value, to increase or decrease in response to the updateExpression as long as the condition is met. Finally, the statement, will always be executed if the condition evaluates to true.

For Loop Examples in JavaScript

At this point, we now understand what loops are, so let’s take a look at some examples and see how we can use loops.

How to Display Text Multiple Times

Let’s start by displaying some text several times until our condition is met.

for (var i = 0; i < 3; i++) {
  let name = "John Doe";
  console.log("Hi, my name is " + name);
}

Output:

"Hi, my name is John Doe"
"Hi, my name is John Doe"
"Hi, my name is John Doe"

Here is how the program processed this loop:

Note: The loop is terminated because 3 is not less than 3, so it returned false.

How to Display a Sequence of Numbers with a For Loop

This time around, let’s display a sequence of numbers by displaying the iteration value.

for (let i = 2; i <= 5; i++) {
    console.log(i);  // printing the value of i
}

Output:

2
3
4
5

Here is how the program processed this loop:

Note: The loop is terminated because 6 is not less than or equal to 5, so the condition returns false.

How to Display a Sequence of Even Numbers

Let’s now display a sequence of even numbers only by displaying the iteration value:

for (let i = 2; i <= 10; i+=2) {
    console.log(i);  // printing the value of i
}

Output:

2
4
6
8
10

Here is how the program processed this loop:

Suppose we want to obtain the odd numbers. All we have to do is change the initialExpression to equal 1 or any odd number we wish to start from as seen below

for (let i = 1; i <= 10; i+=2) {
    console.log(i);  // printing the value of i
}

How to Break a For Loop Operation

So far, we have seen how to create a for loop, but it’s also important to mention that we can break out of a loop using break. The break statement is used to terminate the loop immediately when it is encountered.

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

Output:

1
2
3
4

How to Display the Sum of Natural Numbers

Let’s now loop from 1-10 and then add these numbers together as the iteration is increased:

let sum = 0;

for (let i = 1; i <= 10; i++) {
    sum += i;  // This is same as: sum = sum + i
}

console.log('The sum of 1 to 10 is: ', sum); // "The sum of 1 to 10 is:  55"

Note: We are adding console.log(…) outside the loop, so it only gives us the final output when the loop is terminated.

We can also decide to use variables to set the max number of our condition this way:

let sum = 0;
let n = 10;

for (let i = 1; i <= n; i++) {
    sum += i;  // this is same as: sum = sum + i
}

console.log('The sum of 1 to 10 is: ', sum); // "The sum of 1 to 10 is:  55"

How to Perform Infinite Loops with a For Loop

This can hang your system, because it continues to run until the memory is full, since the condition always evaluates as true.

for(let i = 1; i > 0; i++) {
    // block of code
}

How to Loop Through an Array to Check for Odd and Even Numbers

Most times you will be working with arrays, so let’s see how we can loop through an array of numbers to output all odd and even numbers:

var numbers = [1, 4, 44, 64, 55, 24, 32, 55, 19, 17, 74, 22, 23];
var evenNumbers = [];
var oddNumbers = [];

for (var i = 0; i < numbers.length; i++) {
    if (numbers[i] % 2 != 1) {
        evenNumbers.push(numbers[i]);
    } else {
        oddNumbers.push(numbers[i]);
    }
}

console.log("The even numbers are: " + evenNumbers); // "The even numbers are: 4,44,64,24,32,74,22"
console.log("The odd numbers are: " + oddNumbers); // "The odd numbers are: 1,55,55,19,17,23"

How to Loop Through an Array of Numbers to Get the Maximum and Minimum Number

Finally, before we round up this article, let’s see how to get the maximum and minimum number from an array with for loop:

Maximum:

var numbers = [1, 4, 44, 64, 55, 24, 32, 55, 19, 17, 74, 22, 23];
var max = 0;

for (var i = 0; i < numbers.length; i++) {
    if (numbers[i] > max) {
        max = numbers[i];
    }
}

console.log(max); // 74

Minimum:

var numbers = [4, 44, 64, 55, 24, 32, 55, 19, 17, 74, 22, 23];
var min = numbers[0];

for (var i = 0; i < numbers.length; i++) {
    if (numbers[i] < min) {
        min = numbers[i];
    }
}

console.log(min); // 4

Conclusion

In this article, we learned what a JavaScript loop is and looked at some examples.

It is important to understand that there are many other types of loops, including the while loop, which is best used when you don't know the number of iterations. Otherwise, always use the for loop when you do know the number of iterations.

In the Python programming language, for loops are also called “definite loops” because they perform the instruction a certain number of times.

This is in contrast to while loops, or indefinite loops, which execute an action until a condition is met and they are told to stop.

For loops are useful when you want to execute the same code for each item in a given sequence. With a for loop, you can iterate over any iterable data such as lists, sets, tuples, dictionaries, ranges, and even strings.

In this article, I will show you how the for loop works in Python. You will also learn about the keyword you can use while writing loops in Python.

Basic Syntax of a For Loop in Python

The basic syntax or the formula of for loops in Python looks like this:

for i in data:
    do something

• i stands for the iterator. You can replace it with anything you want
• data stands for any iterable such as lists, tuples, strings, and dictionaries
• The next thing you should do is type a colon and then indent. You can do this with a tab or press the spacebar 4 times.

Python For Loop Example

As I mentioned above, you can iterate over any iterable data with a for loop.

How to Iterate Over a String with a For Loop

You can iterate over string as shown below:

name = "freeCodeCamp"

for letter in name:
    print(letter)

This will print all the letters in the string individually:

# Output: 
# f
# r
# e
# e
# C
# o
# d
# e
# C
# a
# m
# p

What if you want to print the letters in a single line?

You can do that by passing whitespace to the end parameter right inside the print() statement. With this, you tell Python that you want whitespace instead of a new line in the console.

name = "freeCodeCamp"

for letter in name:
    print(letter, end=" ")

# Output: f r e e C o d e C a m p

How to Iterate Over a List with a For Loop

To iterate over a list with the for loop, define the list as separate data and then write the for loop, like this:

lang_list = ["Python", "JavaScript", "PHP", "Rust", "Solidity", "Assembly"]

for lang in lang_list:
    print(lang)

# Output: 
# Python
# JavaScript
# PHP       
# Rust      
# Solidity  
# Assembly

Don’t forget that you can print all the items in one line with the end keyword:

lang_list = ["Python", "JavaScript", "PHP", "Rust", "Solidity", "Assembly"]

for lang in lang_list:
    print(lang, end=" ")

# Output: Python JavaScript PHP Rust Solidity Assembly

How to Iterate Over a Tuple with a For Loop

A tuple is an iterable data type in Python, so you can write a for loop to print the items in it.

footballers_tuple = ("Ronaldo", "Mendy", "Lukaku", "Lampard", "Messi", "Pogba")

for footballer in footballers_tuple:
    print(footballer, end=" ")

# Output: Ronaldo Mendy Lukaku Lampard Messi Pogba

You can get a little more creative by making people know that the names in the tuple represent some active footballers:

footballers_tuple = ("Ronaldo", "Mendy", "Lukaku", "Lampard", "Messi", "Pogba")

for footballer in footballers_tuple:
    print(footballer, "is an active footballer")

# Output: 
# Ronaldo is an active footballer
# Mendy is an active footballer  
# Lukaku is an active footballer 
# Lampard is an active footballer
# Messi is an active footballer  
# Pogba is an active footballer

How to Iterate Over a Set with For Loop

You can print the individual items in a set with the for loop like this:

soc_set = {"Twitter", "Facebook", "Instagram", "Quora"}

for platform in soc_set:
    print(platform, end=" ")

# Output: Twitter Facebook Instagram Quora

You can also get more creative with this. In the example below, with the help of an if statement, I was able to print the platform that is about to be bought by Elon Musk:

soc_set = {"Twitter", "Facebook", "Instagram", "Quora"}

for platform in soc_set:
    if(platform == "Twitter"):
        print(platform, "is about to be bought by Elon Musk.")

# Output: Twitter is about to be bought by Elon Musk.

How to Iterate Over a Dictionary with For Loop

Dictionary is a collection of data in key-value pair form. A dictionary is probably the data type you can do the most with using a for loop.

For example, you can get the keys in a dictionary by looping through it:

fcc_dict = {"name": "freeCodeCamp",
           "type": "non-profit", 
           "mode": "remote", 
           "paid": "no"}

for key in fcc_dict:
    print(key, end=" ")

# Output: name type mode paid

You can also get the values with a for loop:

for values in fcc_dict.values():
    print(values , end=" ")

# Output: freeCodeCamp non-profit remote no

You can get the keys and values in a dictionary with a for loop:

fcc_dict = {"name": "freeCodeCamp",
           "type": "non-profit", 
           "mode": "remote", 
           "paid": "no"}

for key, value in fcc_dict.items():
    print(key, value)

# Output: 
# name freeCodeCamp
# type non-profit
# mode remote
# paid no

I don’t know any other programming language that can do this in such an elegant and clean way!

You can even replace the key, value with anything you want and it’ll still work as expected:

fcc_dict = {"name": "freeCodeCamp",
           "type": "non-profit", 
           "mode": "remote", 
           "paid": "no"}

for a, b in fcc_dict.items():
    print(a, b)

# Output: 
# name freeCodeCamp
# type non-profit
# mode remote
# paid no

You can also execute a particular instruction when the iteration reaches a certain key. In the example below, I printed “freeCodeCamp is a non-profit organization” to the console when the key equals type:

fcc_dict = {"name": "freeCodeCamp",
           "type": "non-profit", 
           "mode": "remote", 
           "paid": "no"}

for a, b in fcc_dict.items():
    # print(a, b)
    if a == "type":
        print("freeCodeCamp is a non-profit organization")

# Output: freeCodeCamp is a non-profit organization

How to Iterate Over Numbers with For Loop by Using the range() Function

Iterating through an integer throws the popular int object not iterable error in Python. But you can get around this by using the range() function to specify that you want to iterate through the numbers between two certain numbers.

The range() function accepts two arguments, so you can loop through the numbers within the two arguments. Example below:

for i in range(1, 10):
    print(i, end="")

# Output: 123456789

You can extract the range to a variable and it would still work:

my_num = range(1, 10)

for i in my_num:
    print(i, end="")

# Output: 123456789

Note that the result is inclusive of the first number but exclusive of the second number.

How to Use the Break Keyword in Python

You can use the break keyword to stop the loop before it ends.

In the example below, the execution did not get to Solidity and Assembly because I broke out of the loop when lang was equal to Rust:

lang_list = ["Python", "JavaScript", "PHP", "Rust", "Solidity", "Assembly"]

for lang in lang_list:
    if lang == "Rust":
        break
    print(lang, end=" ")
# Output: Python JavaScript PHP

How to Use the Continue Keyword in Python

You can use the continue keyword to skip the current iteration and continue with the rest.

In the example below, with the continue keyword, I made the loop skip PHP and continue the loop after it:

lang_list = ["Python", "JavaScript", "PHP", "Rust", "Solidity", "Assembly"]

for lang in lang_list:
    if lang == "PHP":
        continue
    print(lang, end=" ")

# Output: Python JavaScript Rust Solidity Assembly

How to Use the Else Keyword in Python

You can use the else keyword to specify that a block of code should run after the loop is done:

for i in range(10):
    print(i)
else:
    print("Do + ne = Done")

# Output: 
# 1
# 2
# 3
# 4
# 5
# 6
# 7
# 8
# 9
# Do + ne = Done

Conclusion

The for loop in Python doesn’t look as complicated as it is in many other programming languages. But its implementation remains powerful when it runs.

For loop is a very powerful feature of Python with which you can get a lot done.

Thank you for reading. If you find this article helpful, share it with your friends and family!

In this article, we will learn about the for and forEach loops in Java.

Syntax for a for loop in Java

Here is the syntax for creating a for loop:

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

Let's break down some of the keywords above.

for specifies that we are going to create a loop. It is followed by parenthesis nesting everything required for our loop to work.

initialization defines an initial variable as the starting point of the loop, usually an integer (whole number).

condition specifies the number of times the loop is supposed to run.

increment/decrement increases/decreases the value of the initial variable every time the loop runs. As the increment/decrement happens, the variable's value tends towards the specified condition.

Note that each keyword is separated by a semi colon (;).

Here are a few examples:

for(int x = 1; x <=5; x++) {
  System.out.println(x);
}

/*
1
2
3
4
5
*/

In the example above, the initial variable is x with a value of 1. The loop will keep running as long as the value of x is less than or equal to 5 – this is the condition. x++ increases the value of x after each run.

We went on to print the value of x which stops after 5 because the condition has been met. Incrementing to 6 is impossible because it is greater than and not equal to 5.

In the next example, we will use the for loop to print all the values of an array.

int[] randomNumbers = {2, 5, 4, 7};
for (int i = 0; i < randomNumbers.length; i++) {
  System.out.println(randomNumbers[i]);
}

// 2
// 5
// 4
// 7

This is almost the same as the last example. Here, we used the length of the array as the condition and the initial variable's value as zero because the index number of the first element of an array is zero.

Syntax for a forEach loop in Java

You use a forEach loop specifically for looping through the elements of an array. Here is what the syntax looks like:

for (dataType variableName : arrayName) {
  // code to be executed
}

You'll notice that the syntax here is shorter than the for loop's. The forEach loop also starts with the for keyword.

Instead of initializing a variable with a value, we first specify the data type (this must match the array's data type). This is followed by our variable's name and the name of the array separated by a colon.

Here is an example to help you understand the syntax better:

int[] randomNumbers = {2, 5, 4, 7};
for (int x : randomNumbers) {
  System.out.println(x + 1);
}

/*
3
6
5
8
*/

In this example, we looped through each element and increased their initial value by 1.

By default, the loop will stop once it has iterated through all the elements in the array. This means that we are not required to pass any value to our variable or specify any condition to terminate the loop.

Conclusion

In this article, we learned what loops are as well as the syntax for creating a for and forEach loop in Java. We also saw a few examples that helped us understand when and how to use them.

Happy Coding!

These repetitions of the same block of code a certain number of times are called iterations. And there's a looping condition that decides the number of iterations.

The for and the while loops are widely used in almost all programming languages.

In this tutorial, you'll learn about for loops in C. In particular, you'll learn:

• the syntax to use for loops,
• how for loops work in C, and
• the possibility of an infinite for loop.

Let's get started.

C for Loop Syntax and How it Works

In this section, you'll learn the basic syntax of for loops in C.

The general syntax to use the for loop is shown below:

for(initialize; check_condition; update)
    {
        //do this
    }

In the above syntax:

• initialize is the initialization statement – the loop control variable is initialized here.
• check_condition is the condition that determines if the looping should continue.

So long as check_condition is true, the body of the loop is executed.

• The update statement updates the loop control variable after the statements in the loop body are executed.

Control Flow in C for Loops

The control flow is as follows:

1. Initialize the counter – the initialize statement is executed. This happens only once, at the beginning of the loop.
2. Check if the looping condition is true – the expression check_condition is evaluated. If the condition is true, go to step 3. If false, exit the loop.
3. Execute statements in the loop body.
4. Update the counter – the update statement is executed.
5. Go to step 2.

This is also illustrated below:

C For Loop

Now that you have an idea of how for loops work, let's take a simple example to see the for loop in action.

C for Loop Example

Let's write a simple for loop to count up to 10, and print the count value during each pass through the loop.

#include <stdio.h>

int main() 
{
   for(int count = 0; count <= 10; count++)
   {
       printf("%d\n",count);
   }
   return 0;
}

In the above code snippet,

• count is the counter variable, and it's initialized to 0.
• The test condition here is count <= 10. Therefore, count can be at most 10 for looping to continue.
• In the body of the loop, the value of count is printed out.
• And the value of count is increased by 1.
• The control then reaches the condition count <= 10 and the looping continues if the condition evaluates to true.
• In this example, the looping condition count < = 10 evaluates to false when the count value is 11 – and your loop terminates.

And here's the output:

//Output
0
1
2
3
4
5
6
7
8
9
10

When using loops, you should always make sure that your loop does terminate at some point.

You know that the looping continues so long as check_condition is true. And the looping stops once check_condition becomes false. But what happens when your looping condition is always true?

Well, that's when you run into an infinite loop – your loop goes on forever, until your program crashes, or your system powers off.😢

You'll learn more about infinite loops in the next section.

Infinite for Loop

When your loop doesn't stop and keeps running forever, you'll have an infinite loop. Let's take a few examples to understand this.

▶ In the for loop construct, if you don't specify the test condition (check_condition), it's assumed to be true by default.

As a result, your condition never becomes false. And the loop will keep running forever until you force stop the program.

This is shown in the code snippet below:

#include <stdio.h>

int main()
{

    for(int i = 0; ; i++) //test condition is not mentioned
    {
        printf("%d ",i);
    }

    return 0;
}

▶ Here's another example.

You initialize the counter variable i to 10. And i increases by 1 after every iteration.

Notice how the test condition is i > 0. Won't the value of i be always greater than 0?

So you have another infinite loop, as shown:

#include <stdio.h>

int main()
{

    for(int i = 10; i > 0 ; i++) //test condition is always TRUE
    {
        printf("%d ",i);
    }

    return 0;
}

▶ In this example, your counter variable i is initialized to 0. But it decreases by 1 with every iteration.

As a result, i always less than 10. So the condition i < 10 is always true, and you'll have an infinite loop.

#include <stdio.h>

int main()
{

    for(int i = 0; i < 10 ; i--) //test condition is always TRUE
    {
        printf("%d",i);
    }

    return 0;
}

To avoid running into infinite loops, you should define the looping condition correctly.

If you're a beginner, asking yourself the following questions may help.

What do I want this loop to do?
How many times do I want the loop to run?
When should my loop stop?

And then you can go ahead and define your loop construct accordingly. 🙂

Conclusion

I hope you found this tutorial helpful.

To sum up, you've learned the syntax of for loops and how they work. You also know how to anticipate the possibility of infinite for loops and how to avoid them by defining your looping condition carefully.

See you all soon in another tutorial. Until then, happy coding!