A guide to PowerShell loop through an Array

PowerShell provides several looping constructs that allow you to iterate over arrays and perform operations on each element. This article will explain the various types of PowerShell loop through an array, including the for loop, foreach loop, while loop, do-while loop, and do-until loop. We will explore examples of each loop type to demonstrate their usage and highlight the differences between them.

A guide to PowerShell loop through an Array

Looping with For Loop:

The for loop in PowerShell is used to iterate over an array by defining a variable and a termination condition. Here's an example that demonstrates looping through an array using a for loop:

for ($i = 0; $i -le 5; $i++) 
{     
    Write-Host "Number is: $i" 
}

In this example, the for loop prints numbers from 0 to 5. The variable $i is initialized to 0, and the loop continues as long as $i is less than or equal to 5. In each iteration, the current value of $i is displayed using Write-Host.

To further illustrate the usage of the for loop, consider the following example where we loop through a string array:

$employees = @("Rahul", "Anita", "Bhawna", "Mandy") 
for ($i = 0; $i -lt $employees.Length; $i++) 
{    
  Write-Host $employees[$i] 
}

In the above code, we have an array of employee names. The for loop iterates through the array, accessing each element by using the index $i and displaying it using Write-Host. This loop prints all the names from the array, one by one.

The for loop structure in PowerShell consists of the initialization statement (setting the initial value of the variable), the condition statement (specifying the termination condition), and the iteration statement (updating the variable in each iteration). By adjusting these components, you can control the flow and behavior of the loop.

Looping with Foreach Loop:

The foreach loop is specifically designed for iterating over arrays and collections. It provides a convenient way to loop through each element without the need to explicitly manage an index or counter variable.

Let's take a closer look at the syntax and functionality of the foreach loop in PowerShell:

Syntax:

ForEach (item In collection) 
{
    # code block to be executed for each item
}

In the syntax, "item" represents the loop variable that automatically receives each element from the "collection" in every iteration.

Example 1: Iterating over an array of numbers

$numbers=1,2,3,4,5
foreach ($num in $numbers) 
{
  Write-Host $num
 }

In this example, we have an array called "$numbers" with several numeric values. The foreach loop iterates over each element of the array and assigns it to the loop variable "$num". Inside the loop, we use Write-Host to display the current value of "$num". As a result, each number is printed on a separate line.

Example 2: Iterating over an array of strings

$employees = @("Rahul","Anita","Bhawna","Mandy")
foreach ($emp in $employees) 
{
  Write-Host $emp
 }

In this example, we have an array named "$employees" containing the names of employees. The foreach loop iterates through each element of the array, assigning it to the loop variable "$emp". Inside the loop, we use Write-Host to display each employee's name. As a result, the names are printed one by one.

The foreach loop construct simplifies the process of iterating over arrays and collections. It automatically assigns each element to a loop variable, allowing you to perform operations or execute commands on each item without the need for explicit indexing. By leveraging the foreach loop, you can efficiently process array elements and accomplish various tasks within your PowerShell scripts.

Looping with While Loop

the while loop allows you to repeatedly execute a block of code as long as a specified condition remains true. It checks the condition before each iteration, and if it evaluates to true, the loop block is executed.

Here's an explanation of the while loop in PowerShell:

Syntax:

while (condition) 
{
    # code block to be executed
}

Example: Using a while loop to iterate over an array

$i = 1 while ($i -le 5) 
{     
    Write-Host $i     
    $i++ 
}

In this example, we have a while loop that prints numbers from 1 to 5. The variable "$i" is initially set to 1. The while loop checks the condition ($i -le 5) before each iteration. As long as the condition evaluates to true (i.e., $i is less than or equal to 5), the code block within the loop is executed. Inside the loop block, Write-Host is used to display the current value of "$i". Then, the variable "$i" is incremented using $i++.

The output of the above code will be:

Looping with a Do-while loop

The do-while loop is similar to the while loop, but it executes the loop block at least once before checking the condition. Here's an example:

$i = 1 do 
{     
    Write-Host $i     
    $i++ 
} while ($i -le 5)

In this code snippet, the loop block is executed first, and then the condition ($i -le 5) is checked. If the condition is true, the loop continues to execute. In each iteration, the value of "$i" is displayed using Write-Host, and "$i" is incremented. The loop terminates when the condition becomes false.

The output of the above code will be the same as the previous example:

The while loop provides a way to repeatedly execute a block of code based on a specified condition. It allows you to perform iterative operations until the condition becomes false. Additionally, the do-while loop executes the loop block at least once, ensuring that the code within the block is always executed before the condition check. By utilizing these loop structures, you can handle various scenarios and iterate through arrays effectively in your PowerShell scripts.

Looping with Do-Until loop

The do-until loop is another looping construct that repeatedly executes a block of code until a specified condition becomes true. The key difference between the do-until loop and the do-while loop is that the condition is evaluated at the end of each iteration in the do-until loop.

Let's explore how to use the do-until loop to iterate through a PowerShell array:

$i = 1 do 
{     
    Write-Host $i     
    $i++ 
} until ($i -gt 5)

In this example, we have a do-until loop that prints numbers from 1 to 5. The variable $i is initially set to 1. Inside the loop block, $i is displayed using Write-Host, and then it is incremented using $i++. The condition ($i -gt 5) is evaluated at the end of each iteration. If the condition is false, the loop continues to execute. However, once the condition becomes true (i.e., $i is greater than 5), the loop terminates.

The output of the above code will be:

The do-until loop ensures that the loop block is executed at least once before the condition check. It guarantees that the code within the loop will always run before evaluating the condition.

Conclusion

In this article, we explored various looping constructs in PowerShell to iterate through arrays effectively. The "for" loop, "foreach" loop, "while" loop, "do-while" loop, and "do-until" loop provide different approaches to handle an array element. By understanding these looping techniques, you can write more efficient scripts and perform complex operations on array data.