PowerShell for 循环 1 至 10 [3 种方式]

使用传统的 for 循环

使用传统的 for 循环在 PowerShell 控制台上从 1 打印到 10。

使用传统的 for 循环：

for ($i = 1; $i -le 10; $i++) {
    Write-Host "The Iteration Number is: $i"
}

输出 ：

The Iteration Number is: 1
The Iteration Number is: 2
The Iteration Number is: 3
The Iteration Number is: 4
The Iteration Number is: 5
The Iteration Number is: 6
The Iteration Number is: 7
The Iteration Number is: 8
The Iteration Number is: 9
The Iteration Number is: 10

在上面的示例中，我们使用传统的 for 循环从 1 迭代到 10。 for 循环的标头由用分号 (;) 分隔的三个部分组成。第一部分是初始化占位符，第二部分称为条件或测试表达式，第三部分是重复 。所有三个部分都括在括号 (()) 中，后跟 for 关键字。下面我们来了解一下它们：

Initialization 占位符由一个或多个在 for 循环开始之前运行的命令组成。它用于定义变量并使用初始值对其进行初始化。例如，在上面的代码中，$i=1表达式是初始化部分，其中i变量最初设置为1。该变量负责保存从 1 到 10 的值（一次一个）。请注意，在 PowerShell 中变量以 $ 为前缀。

Condition 或 Test Expression 占位符在每次循环迭代中返回布尔值 (True/False)。 我们这里也可以有多个条件。根据上面的代码片段，$i -le 10 是条件，它确定$i 的值是否小于或使用-le 运算符等于10。请注意，在循环的每次迭代中都会评估条件，直到其变为 False。如果此测试表达式返回 True，则执行 for 循环体（包含在 {} 内）；否则，它不会。

Repeat占位符代表一个或多个以逗号分隔的命令（,）；它用于更新变量的值，该值在循环的测试表达式部分（也称为条件部分）内进行检查。考虑上面的代码示例，$i++ 是重复部分，它使用 表示的增量运算符将 $i 的值增加 1 >++。请记住，我们也可以编写 $i=$i+1 而不是 $i++，但 $i++ 看起来更简单、读者友好且专业。

我们使用 Write-Host cmdlet 通过自定义消息打印 $i 的值。因此，上面的 for 循环开始从 1 打印到 10，并在 i=11 时退出循环>。那么，for循环的执行流程是怎样的呢？

1. 将执行初始化部分。
2. 将评估病情。
3. 如果条件为 true，则将执行脚本块（for 循环的主体）。
4. 将执行重复部分。
5. 将通过指定的条件检查更新的值。
6. 现在，将重复步骤 3、4 和 5，直到条件变为 false。

有一种使用传统 for 循环的替代语法，如下所示：

使用传统的 for 循环：

for ($i = 1
$i -le 10
$i++) {
    Write-Host "The Iteration Number is: $i"
}

输出 ：

The Iteration Number is: 1
The Iteration Number is: 2
The Iteration Number is: 3
The Iteration Number is: 4
The Iteration Number is: 5
The Iteration Number is: 6
The Iteration Number is: 7
The Iteration Number is: 8
The Iteration Number is: 9
The Iteration Number is: 10

我们将上面的代码片段中的 ; 替换为新行。

在 for 循环头中使用多个命令

在传统 for 循环的标头中使用多个命令，迭代 10 次并在 PowerShell 控制台上打印自定义消息。

在传统 for 循环中使用多个命令：

for (($i = 0), ($j = 1); $i -lt 10 -and $j -le 10; $i++, $j++) {
    Write-Host "i = $i, j = $j"
}

输出 ：

i = 0, j = 1
i = 1, j = 2
i = 2, j = 3
i = 3, j = 4
i = 4, j = 5
i = 5, j = 6
i = 6, j = 7
i = 7, j = 8
i = 8, j = 9
i = 9, j = 10

此示例与上一个示例类似，但我们涉及两个变量，i 和 j，以便在 for 的每个部分中使用多个命令环形。我们还可以在 for 循环之外进行初始化，如下所示：

在传统 for 循环中使用多个命令：

$i = 0
$j = 1
for (; $i -lt 10 -and $j -le 10; $i++, $j++) {
    Write-Host "i = $i, j = $j"
}

输出 ：

i = 0, j = 1
i = 1, j = 2
i = 2, j = 3
i = 3, j = 4
i = 4, j = 5
i = 5, j = 6
i = 6, j = 7
i = 7, j = 8
i = 8, j = 9
i = 9, j = 10

同样，我们可以在脚本块中执行Repeat部分；请参见以下示例。

在传统 for 循环中使用多个命令：

$i = 0
$j = 1
for (; $i -lt 10 -and $j -le 10; ) {
    Write-Host "i = $i, j = $j"
    $i++
    $j++
}

输出 ：

i = 0, j = 1
i = 1, j = 2
i = 2, j = 3
i = 3, j = 4
i = 4, j = 5
i = 5, j = 6
i = 6, j = 7
i = 7, j = 8
i = 8, j = 9
i = 9, j = 10

我们还可以无限期地为循环的每次迭代显示一个常量值或字符串（不会改变），直到用户停止为止。请参阅以下示例。

使用 for 循环进行无限迭代

省略传统 for 循环标头中的所有命令以无限迭代。

使用传统的 for 循环进行无限迭代：

for (;;) {
    Write-Host "Welcome to Java2Blog!"
}

输出 ：

Welcome to Java2Blog!
Welcome to Java2Blog!
Welcome to Java2Blog!
Welcome to Java2Blog!
Welcome to Java2Blog!
Welcome to Java2Blog!
...
...
...

这次，除了两个分号之外，我们没有在 () 中包含任何命令，这会导致无限执行由 {} 包裹的脚本块。它将继续打印 Welcome to Java2Blog! 直到用户按下 Ctrl + C。

让我们看另一个示例，其中值随着每次迭代而变化，但仍然无限次运行，直到用户按下 Ctrl + C。

使用传统的 for 循环进行无限迭代：

$i = 1
for (;;$i++ ) {
    Write-Host "i = $i"
}

输出 ：

i = 1
i = 2
i = 3
i = 4
i = 5
i = 6
i = 7
i = 8
i = 9
i = 10
i = 11
i = 12
i = 13
i = 14
...
...
...

使用 ForEach 循环

使用 ForEach 循环在 PowerShell 控制台上打印从 1 到 10 的值。

使用 ForEach 循环：

$array = @(1,2,3,4,5,6,7,8,9,10)
ForEach($i in $array){
    Write-Host $i
}

输出 ：

1
2
3
4
5
6
7
8
9
10

首先，我们使用数组运算符 (@()) 创建一个包含 10 整数值（一到十）的数组，我们将其分配给 $array 变量。接下来，我们使用 ForEach 循环遍历 $array。最后，我们在每次迭代中使用 Write-Host cmdlet 来打印 $array 中的当前值。

请记住，ForEach 循环（又名 ForEach 语句）也用于传统的循环结构，用于单步执行集合中的项目，例如数组。 ForEach 循环有两个部分包含在 () 内。第一部分，当PowerShell运行ForEach语句时，会自动创建一个变量；在上面的代码中，它是$i。第二部分是循环将在其上迭代的集合 ($array)。

与 for 循环不同，我们不能直接在 ForEach 标头的每个部分中使用多个命令来处理各种数组或集合，但还有另一种方法。那么让我们看看如何做到这一点。

使用 ForEach 循环处理多个数组

使用 Zip() 方法在 ForEach 循环中处理多个数组并迭代 10 次。

使用 ForEach 处理多个数组：

$names = @("John", "Tony", "Andy", "Adam", "Henry", "Martin", "Sam", "Stoyan", "Nancy", "Paul")
$ages = @(50, 30, 35,23,45,34,56,22,34,25)
$zipped = [System.Linq.Enumerable]::Zip($names,
                                        $ages,
                                        [System.Func[object,object,object]]{
                                            [Tuple]::Create($args[0], $args[1]) 
                                        })
foreach ($tuple in $zipped) {
    Write-Host "$($tuple.Item1) is $($tuple.Item2) years old"
}

输出 ：

John is 50 years old
Tony is 30 years old
Andy is 35 years old
Adam is 23 years old
Henry is 45 years old
Martin is 34 years old
Sam is 56 years old
Stoyan is 22 years old
Nancy is 34 years old
Paul is 25 years old

首先，我们创建了两个数组，$names 包含姓名，$ages 包含学生的年龄。然后，我们必须压缩这两个数组，以便在 ForEach 中处理 $names 和 $ages 。我们为什么要压缩它们？因为我们不能在 ForEach 标头中使用多个命令来迭代 $names 和 $ages。因此，我们使用 System.Linkq.Enumerable 类的 Zip() 方法将 $names 和 $ages 组合成元组。请注意，压缩两个数组不会修改原始数组。

Zip() 方法采用三个参数，下面依次给出其简要描述：

1. 我们想要与第二个数组一起压缩的 $names 数组。
2. 我们想要与第一个数组一起压缩的 $ages 数组。
3. 此参数是一个委托，指定如何组合 $names 和 $ages。在上面的代码中，它是使用 [System.Func[object, object, object]] 类型定义的，表示它将接受两个 object 参数并返回一个 对象。它创建一个带有两个参数（$args[0] 和 $args[1]）的 Tuple 对象，对应于两个数组的项目被拉上拉链。

我们将 Zip() 方法返回的元组存储在 $zipped 变量中，该变量进一步传递给 ForEach。然后，在 ForEach 内，我们使用 Write-Host cmdlet 来打印自定义消息。

通过管道输入到 ForEach 循环

通过管道输入到 ForEach 循环，以在 PowerShell 中从 1 迭代到 10。

将 ForEach 循环与管道结合使用：

$ages = @(1,2,3,4,5,6,7,8,9,10)
$ages | ForEach{
    Write-Host $_
}

输出 ：

1
2
3
4
5
6
7
8
9
10

或者，如果不强制创建数组，我们可以按如下方式执行上面的示例。

将 ForEach 循环与管道结合使用：

$ages = 1..10
$ages | ForEach{
    Write-Host $_
}

输出 ：

1
2
3
4
5
6
7
8
9
10

.. 用于在 PowerShell 中创建一系列数字。

使用 ForEach 循环进行无限迭代

没有直接的方法可以使用 ForEach 进行无限迭代，但是我们可以使用 while 和 ForEach 进行无限迭代；否则，传统的 for 循环可用于此特定场景（我们在第一部分中学习了传统的 for）。

在 while 循环中使用 ForEach 循环：

$ages = @(50, 30, 35,23,45,34,56,22,34,25)
while($true){
    $ages | ForEach{
        Write-Host $_
    }
}

输出 ：

50
30
35
23
45
34
56
22
34
25
50
30
35
23
45
34
56
22
34
25
...
...
...

这里，我们没有指定 while 循环结束的测试条件，而是在 () 中提到了 $true，这意味着 >while 循环始终为 True 并导致 ForEach 循环无限次执行，直到用户按下 Ctrl+ C。

for 和 ForEach 循环都是传统的循环结构，但 ForEach 是循环集合的最简单方法，并且可以与管道。另一方面，在处理多个数组或命令时，使用传统的 for 比 ForEach 更简单。

使用 ForEach-Object Cmdlet

使用 ForEach-Object cmdlet 在 PowerShell 中从 1 循环到 10。

使用 ForEach-Object Cmdlet：

$range = 1..10
$range | ForEach-Object {
    Write-Host $_
}

输出 ：

1
2
3
4
5
6
7
8
9
10

首先，我们在 .. 运算符之前指定了一个较小的数字，在其之后指定了一个较大的数字。然后，我们将这一数字范围存储在 $range 变量中，并使用 ForEach-Object cmdlet 进行管道传输以对其进行迭代，并使用 在每次迭代中显示一个元素>Write-Host cmdlet。 ForEach-Object cmdlet 对输入对象集合的每个元素执行给定的操作。

或者，我们可以这样做：

使用 ForEach-Object Cmdlet：

1..10 | % { Write-Host $_ }

输出 ：

1
2
3
4
5
6
7
8
9
10

这里，% 表示给定范围内的每个对象，即 1..10。

请记住，ForEach-Object 仅在输入数据通过管道传输到它时才使用。

使用 ForEach-Object Cmdlet 处理多个数组

使用带有 -Begin 和 -Process 参数的 ForEach-Object cmdlet 来处理多个数组并迭代 10代码>次。

使用 ForEach-Object 处理多个数组：

$names = @("John", "Tony", "Andy", "Adam", "Henry", "Martin", "Sam", "Stoyan", "Nancy", "Paul")
$ages = @(50, 30, 35,23,45,34,56,22,34,25)
$names | ForEach-Object -Begin {
    $i = 0
} -Process {
    Write-Host "$($_) is $($ages[$i]) years old"
    $i++
}

输出 ：

John is 50 years old
Tony is 30 years old
Andy is 35 years old
Adam is 23 years old
Henry is 45 years old
Martin is 34 years old
Sam is 56 years old
Stoyan is 22 years old
Nancy is 34 years old
Paul is 25 years old

创建 $names 和 $ages 数组后，我们将 $names 通过管道传输到 ForEach-Object cmdlet 并使用-Begin 和 -Process 参数同时迭代两个数组（$names 和 $ages）。

在 -Begin 块内，我们将 $i 设置为 0。然后，在 -Process 块中，使用 $_ 在管道中访问 $names 数组中的当前元素以及相应的年龄$ages 使用 $i 变量。最后，我们使用 Write-Host 在 PowerShell 控制台上打印这些内容。

使用 ForEach-Object Cmdlet 进行无限迭代

与 ForEach 循环不同，没有直接的方法可以使用 ForEach-Object 进行无限迭代，但我们可以将 while 与 ForEach-Object 进行无限迭代；否则，传统的 for 循环可用于此用例。

在 while 循环中使用 ForEach-Object：

$ages = @(50, 30, 35,23,45,34,56,22,34,25)
while($true){
    $ages | ForEach-Object{
        Write-Host $_
    }
}

输出 ：

50
30
35
23
45
34
56
22
34
25
50
30
35
23
45
34
56
22
34
25
...
...
...

仅当用户从键盘上按 Ctrl+C 时，此循环才会结束。

这就是 PowerShell for 循环 1 到 10 的全部内容。