はい、承知いたしました。PowerShellの繰り返し（ループ）について、基本から応用、実践的な使用例、パフォーマンスに関する考慮事項、デバッグ方法までを網羅した詳細な解説記事を作成します。約5000語のボリュームを目指し、読みやすく、実践に役立つ内容となるように記述します。

以下が記事本文です。

---

PowerShellで繰り返し（ループ）をマスター！基本から応用まで徹底解説

PowerShellは、Windowsシステムの管理や自動化に欠かせない強力なツールです。日々の運用業務、データ処理、設定変更など、繰り返し行われるタスクを効率化するためには、「ループ」の概念と使い方を習得することが不可欠です。

手作業であれば何時間、何日とかかるような作業も、ループを使えば一瞬で完了させることができます。本記事では、PowerShellにおけるさまざまなループ構造の基本から、応用的な使い方、さらにはパフォーマンスに関する考慮事項やデバッグ方法まで、網羅的に解説します。

この記事を読み終える頃には、あなたはPowerShellで自信を持って繰り返し処理を記述できるようになっているでしょう。

はじめに：なぜPowerShellでループが必要なのか？

システム管理やデータ処理の現場では、同じような作業を何度も繰り返す場面が頻繁にあります。例えば：

• ネットワーク上のすべてのコンピューターに対して特定のコマンドを実行したい
• 特定のフォルダ内の全ファイル名を変更したい
• イベントログから特定のエラーメッセージを抽出したい
• Active Directoryの全ユーザーに対してプロパティを変更したい
• 大量のデータを整形・集計したい

これらのタスクを手作業で行うのは非現実的ですし、人的ミスも発生しやすくなります。ここで「ループ」の出番です。ループを使えば、「この一連の操作を、リストアップしたそれぞれの対象に対して実行しなさい」あるいは「この条件が満たされなくなるまで、この操作を繰り返えしなさい」といった指示をスクリプトとして記述できます。

PowerShellには、目的や状況に応じて使い分けられるいくつかのループ構造が用意されています。それぞれの特性を理解し、適切に使い分けることが効率的なスクリプト開発の鍵となります。

本記事では、以下の主要なループ構造について詳しく解説します。

1. For ループ: カウンターを使った固定回数の繰り返しや、数値インデックスによる処理に適しています。
2. ForEach ループ: コレクション（配列、リストなど）の各要素を処理する場合に最も直感的でよく使われます。
3. ForEach-Object コマンドレット: パイプラインで渡されたオブジェクトを処理する際に使用され、大量データ処理に特に有効です。
4. While ループ: 特定の条件が真である間、繰り返し処理を実行します。
5. Do-While / Do-Until ループ: 最初に一度処理を実行し、その後に条件に基づいて繰り返すかどうかを判断します。

これらの基本に加え、ループの途中で処理の流れを変える「ループ制御ステートメント」(Break, Continue)や、複数のループを組み合わせる「ネストされたループ」、さらにはパフォーマンスに関する考慮事項やデバッグ方法についても掘り下げていきます。

PowerShellのバージョンについて：本記事で解説する内容は、Windows PowerShell 5.1およびPowerShell 7以降のどちらでも基本的な部分は同様に動作します。ただし、一部の応用的な機能（例：ForEach-Object -Parallel）は新しいバージョンでのみ利用可能です。

さあ、PowerShellのループの世界へ飛び込み、スクリプトの可能性を広げましょう！

ループの基本構造を理解する

PowerShellには、繰り返し処理を行うためのいくつかのキーワードやコマンドレットが用意されています。まずは、それぞれの基本的な構文と使い方を見ていきましょう。

1. For ループ：カウンターを使った繰り返し

For ループは、特定の回数を繰り返したい場合や、数値のカウンターに基づいて処理を進めたい場合に適しています。C言語やJavaなどの他のプログラミング言語に慣れている方には馴染み深い形式かもしれません。

For ループの構文は以下のようになります。

powershell
For (初期化; 条件; 繰り返し処理) {
# 繰り返したい処理をここに記述
# 条件が真である間、このブロックが繰り返し実行される
}

各部分の役割を詳しく見てみましょう。

• 初期化: ループが開始される前に一度だけ実行される処理です。通常、ループのカウンターとなる変数をここで定義・初期化します。例: $i = 1
• 条件: 各繰り返し処理の開始前に評価される論理式です。この条件式が $true (真) である間、ループ内のブロックが実行されます。条件式が $false (偽) になった時点でループは終了します。例: $i -le 10
• 繰り返し処理: 各繰り返し処理が終了した後に実行される処理です。通常、カウンター変数を更新します（増減させるなど）。例: $i++ ($i を1増やす)

では、簡単な例を見てみましょう。1から10までの数値を順番に表示する例です。

powershell
For ($i = 1; $i -le 10; $i++) {
Write-Host "現在の数値: $i"
}

解説:

1. $i = 1: ループ開始前に、変数 $i を 1 で初期化します。
2. $i -le 10: 各繰り返し処理の前に $i が 10 以下であるかを確認します。最初の繰り返しでは $i は 1 なので真 ($true) です。
3. Write-Host "現在の数値: $i": 条件が真なので、このブロック内の処理が実行され、現在の数値: 1 と表示されます。
4. $i++: 繰り返し処理が終了した後、$i が 1 増加して 2 になります。
5. 再び $i -le 10 が評価されます。$i は 2 なので真です。
6. このプロセスが繰り返され、$i が 10 になったときも条件 $i -le 10 は真なのでブロックが実行されます。
7. ブロック実行後 $i++ で $i は 11 になります。
8. 次に $i -le 10 が評価される際、$i は 11 なので条件は偽 ($false) となり、ループは終了します。

For ループは、配列の要素にインデックスを使ってアクセスしたい場合にも便利です。

“`powershell
$colors = “Red”, “Green”, “Blue”, “Yellow”

For ($i = 0; $i -lt $colors.Count; $i++) {
Write-Host “要素 $i: $($colors[$i])”
}
“`

解説:

• 配列のインデックスは通常 0 から始まるため、初期化は $i = 0 とします。
• 条件式は $i -lt $colors.Count となります。$colors.Count は配列の要素数です。配列の最後の要素のインデックスは要素数より1つ小さいため、< (-lt) 演算子を使用します。
• 繰り返し処理では $i++ でインデックスを増やします。
• ループ内で $colors[$i] を使うことで、現在のインデックスの要素にアクセスできます。

For ループの繰り返し処理部分は、単純な $i++ だけでなく、$i = $i + 2 のように複数のステップで増加させたり、$i-- のように減少させたりすることも可能です。

2. ForEach ループ：コレクションの各要素を処理

ForEach ループは、配列、リスト、ハッシュテーブルの値、コマンドレットの出力など、複数の要素を持つ「コレクション」を処理する際に最も直感的でよく使われます。コレクション内の各要素を順番に取り出し、それぞれの要素に対して同じ処理を実行します。

ForEach ループの構文は以下のようになります。

powershell
ForEach ($単数形の変数 in $コレクション) {
# コレクションから取り出された各要素 ($単数形の変数) に対して行いたい処理をここに記述
}

各部分の役割を詳しく見てみましょう。

• $単数形の変数: コレクションから取り出された現在の要素を一時的に格納するための変数です。任意の名前を付けることができます（例: $item, $file, $service）。この変数には、ループが1回実行されるごとにコレクションの次の要素が代入されます。
• $コレクション: 処理対象となるオブジェクトの集まりです。配列や、Get-Process、Get-ChildItem などのコマンドレットの出力結果などが $コレクション に相当します。

簡単な例を見てみましょう。文字列の配列の各要素を表示する例です。

“`powershell
$fruits = @(“Apple”, “Banana”, “Cherry”, “Date”)

ForEach ($fruit in $fruits) {
Write-Host “果物の名前: $fruit”
}
“`

解説:

1. $fruits という配列を定義します。
2. ForEach ($fruit in $fruits): $fruits 配列から要素を一つずつ取り出し、それを一時的に $fruit という変数に格納します。
3. 最初の繰り返しでは、配列の最初の要素である "Apple" が $fruit に格納されます。
4. Write-Host "果物の名前: $fruit": $fruit の値（”Apple”）が表示されます。
5. 次の繰り返しでは、配列の次の要素である "Banana" が $fruit に格納され、同様に表示されます。
6. これが配列の最後の要素（”Date”）まで繰り返されます。
7. 配列の要素をすべて処理し終えると、ループは終了します。

ForEach ループは、コマンドレットの出力結果を直接処理するのに非常に便利です。

“`powershell

実行中の全プロセスを取得し、それぞれの名前とIDを表示

$processes = Get-Process

ForEach ($process in $processes) {
Write-Host “プロセス名: $($process.Name), ID: $($process.Id)”
}
“`

解説:

• Get-Process コマンドレットは、実行中のプロセスの情報をオブジェクトのコレクションとして出力します。
• このコレクションが $processes 変数に格納されます。
• ForEach ループは $processes コレクションからプロセスオブジェクトを一つずつ取り出し、それを $process 変数に格納します。
• ループ内で $process.Name や $process.Id のようにプロパティにアクセスすることで、個々のプロセスの情報を取得できます。

ForEach ループはシンプルで読みやすいため、コレクション処理のほとんどの場面で最初に検討すべきループ構造と言えます。

3. ForEach-Object コマンドレット：パイプラインとの連携

ForEach ループと名前が似ていますが、ForEach-Object は全く異なる性質を持つ「コマンドレット」です。これはPowerShellの強力な機能である「パイプライン」と組み合わせて使用することを前提としています。

パイプラインとは、あるコマンドレットの出力を次のコマンドレットの入力として渡す仕組みです。ForEach-Object は、パイプラインから渡されてくるオブジェクトを一つずつ受け取り、それぞれのオブジェクトに対してスクリプトブロック ({ ... }) で定義された処理を実行します。

ForEach-Object コマンドレットの基本的な構文は以下のようになります。

powershell
コマンドレットA | コマンドレットB | ForEach-Object {
# パイプラインから渡された現在のオブジェクトに対して行いたい処理
# 現在のオブジェクトは自動変数 `$_` または `$PSItem` に格納される
}

• $_ または $PSItem: ForEach-Object のスクリプトブロック内で自動的に利用できる変数です。パイプラインから渡されてきた現在のオブジェクトを保持しています。

簡単な例を見てみましょう。Get-Service の出力結果をパイプラインで受け取り、各サービスの名前を表示する例です。

powershell
Get-Service | ForEach-Object {
Write-Host "サービス名: $($_.Name)"
}

解説:

1. Get-Service コマンドレットは、システム上の全サービスに関するオブジェクトのコレクションを出力します。
2. この出力はパイプライン (|) を通じて ForEach-Object コマンドレットに渡されます。
3. ForEach-Object はパイプラインからサービスオブジェクトを一つずつ受け取ります。
4. 受け取った現在のサービスオブジェクトは自動変数 $_ に格納されます。
5. スクリプトブロック { Write-Host "サービス名: $($_.Name)" } が実行され、$_ に格納されているサービスオブジェクトの Name プロパティの値が表示されます。
6. これがパイプラインから渡されてきた全サービスオブジェクトに対して繰り返されます。

ForEach-Object は、特定のプロパティだけを抽出したり、オブジェクトのプロパティを変更したり、他のコマンドレットに渡す前に何らかの前処理を行ったりするのに非常に便利です。

例えば、実行中のプロセスの中から、特定の名前（例: “svchost”）を含むものだけを抽出し、それらを停止する処理を考えてみましょう。（注意：この例はシステムに影響を与える可能性があります）

powershell
Get-Process | Where-Object { $_.ProcessName -like "*svchost*" } | ForEach-Object {
Write-Host "停止対象のプロセス: $($_.ProcessName) (ID: $($_.Id))"
# Stop-Process -Id $_.Id -Force # 実際に停止する場合はこの行を有効にする
}

解説:

1. Get-Process で全プロセスオブジェクトを取得します。
2. Where-Object { $_.ProcessName -like "*svchost*" } で、プロセス名に “svchost” を含むオブジェクトだけをフィルタリングします。
3. フィルタリングされたオブジェクトが ForEach-Object に渡されます。
4. ForEach-Object の中で、それぞれのプロセスオブジェクトに対して表示処理や停止処理（コメントアウト部分）を行います。

ForEach と ForEach-Object の使い分けとパフォーマンス

ForEach ステートメントと ForEach-Object コマンドレットは、どちらもコレクションの要素に対して処理を行いますが、内部的な動作と得意な状況が異なります。

• ForEach ステートメント:

  • 処理を開始する前に、コレクション全体をメモリにロードします。
  • 一般的に ForEach-Object よりも高速です。
  • 小規模から中規模のコレクションの処理に適しています。
  • コレクション全体を一度に扱えるため、処理中にコレクション内の他の要素を参照したり、事前にコレクションをソートしたりする場合に便利です。

• ForEach-Object コマンドレット:

  • パイプラインからオブジェクトを一つずつ受け取り、順次処理します（ストリーミング処理）。
  • 大規模なコレクションや、メモリに一度にロードできないような大量のデータを扱う場合に、メモリ効率が優れています。
  • パイプライン処理の一部として自然に組み込めます。
  • PowerShell 7以降では -Parallel パラメータを使って並列処理を行うことができます（後述の応用で解説）。

どちらを使うべきかは状況によりますが、一般的には以下のガイドラインが考えられます。

• 配列や変数に格納済みのコレクションをシンプルに処理する場合: ForEach ステートメントが直感的で高速です。
• コマンドレットの出力結果をパイプラインで次々と処理したい場合: ForEach-Object コマンドレットが適切です。メモリ効率が必要な大規模データや、並列処理を行いたい場合もこちらを選択します。

厳密なパフォーマンスを求める場合は、両者でテストして比較検討することも有効です。

ForEach-Object の Begin, Process, End ブロック

ForEach-Object コマンドレットは、より複雑な処理を行うために Begin, Process, End という3つの特別なスクリプトブロックを持つことができます。

powershell
コマンドレット | ForEach-Object {
Begin {
# パイプラインから最初のオブジェクトを受け取る前に一度だけ実行
# 変数の初期化などに使う
}
Process {
# パイプラインからオブジェクトを受け取るたびに実行
# 現在のオブジェクトは $_ に格納される
# メインの繰り返し処理
}
End {
# パイプラインからのオブジェクト処理がすべて終わった後に一度だけ実行
# 結果の集計や最終的な出力などに使う
}
}

例として、ファイルサイズの合計を計算してみましょう。

powershell
Get-ChildItem *.txt | ForEach-Object {
Begin {
# 合計サイズを保持する変数を初期化
$totalSize = 0
Write-Verbose "ファイルサイズの集計を開始します。" -Verbose
}
Process {
# 各ファイルのサイズ (Lengthプロパティ) を合計に追加
$totalSize += $_.Length
Write-Verbose "ファイル: $($_.Name), サイズ: $($_.Length) バイト" -Verbose
}
End {
# 全ファイルの処理が終了したら合計サイズを表示
Write-Host "`n合計ファイルサイズ: $totalSize バイト"
}
}

解説:

• Begin ブロックで合計サイズを保持する $totalSize 変数を 0 に初期化します。この処理はパイプラインからのオブジェクト処理が始まる前に一度だけ実行されます。
• Process ブロックで、パイプラインから渡されてきた各ファイルオブジェクト ($_) の Length プロパティ（ファイルサイズ）を取得し、$totalSize に加算します。これはファイルが見つかるたびに繰り返し実行されます。
• End ブロックで、すべてのファイルオブジェクトの処理が完了した後に、最終的な $totalSize の値を表示します。

Begin、Process、End ブロックを使うことで、ループ処理の前後に必要な準備や後処理を効率的に記述できます。Process ブロックのみを使用する場合が最も一般的ですが、複雑な集計や処理を行う際にはこれらのブロックが役立ちます。

4. While ループ：条件が真の間繰り返す

While ループは、特定の条件式が $true (真) である間、繰り返し処理を実行します。繰り返し回数が事前に決まっていない場合や、外部の要因（例: ユーザー入力、ファイル存在、サービスのステータスなど）に基づいてループを続けたい場合に適しています。

While ループの構文は以下のようになります。

powershell
While (条件) {
# 条件が真である間、繰り返し実行される処理
}

• 条件: 各繰り返し処理の開始前に評価される論理式です。この条件式が $true である間、ループ内のブロックが実行されます。条件式が $false になった時点でループは終了します。

簡単な例を見てみましょう。カウンター変数を使い、特定のしきい値に達するまで繰り返す例です。

“`powershell
$counter = 0

While ($counter -lt 5) {
Write-Host “カウンター: $counter”
$counter++ # カウンターを増加させないと無限ループになる可能性がある！
Start-Sleep -Seconds 1 # 1秒待機
}

Write-Host “ループが終了しました。最終的なカウンターの値: $counter”
“`

解説:

1. $counter 変数を 0 で初期化します。
2. While ($counter -lt 5): $counter が 5 より小さいかを確認します。最初は 0 なので真です。
3. ブロック内の処理が実行され、カウンターの値が表示され、$counter が1増加して 1 になります。Start-Sleep は処理を一時停止させるコマンドレットです。
4. 再び条件 $counter -lt 5 が評価されます。$counter は 1 なので真です。
5. このプロセスが繰り返され、$counter が 4 になったときも条件は真なのでブロックが実行され、$counter は 5 になります。
6. 次に条件 $counter -lt 5 が評価される際、$counter は 5 なので条件は偽 ($false) となり、ループは終了します。
7. ループ終了後のメッセージが表示されます。

無限ループの可能性と注意点:

While ループを使用する際は、ループ内の処理で必ず条件がいつか偽になるように変更される必要がある点に注意してください。上記の例では $counter++ がそれに該当します。もしこの行がなければ、$counter は常に 0 のままで条件 $counter -lt 5 は常に真となり、スクリプトは無限に実行され続けてしまいます（無限ループ）。

無限ループに陥ってしまった場合は、通常 Ctrl + C キーを押すことでスクリプトの実行を強制的に中断できます。

While ループは、ユーザーからの特定の入力を待つ場合や、ネットワークリソースが利用可能になるまで待機する場合など、繰り返し回数が事前に分からないシナリオで特に役立ちます。

“`powershell

ユーザーが “quit” と入力するまで入力を受け付ける例

$inputString = “”
While ($inputString -ne “quit”) {
$inputString = Read-Host “何か入力してください (‘quit’で終了)”
Write-Host “入力された文字列: $inputString”
}
Write-Host “終了します。”
“`

5. Do-While および Do-Until ループ：最低1回の実行を保証

Do-While ループと Do-Until ループは、While ループと似ていますが、最初に一度だけループ内のブロックを無条件に実行し、その後に条件を評価して繰り返しを行うかどうかを判断します。このため、ループ内の処理を最低1回は実行したい場合に適しています。

Do-While ループ：条件が真の間繰り返す（初回無条件実行）

Do-While ループの構文は以下のようになります。

powershell
Do {
# 繰り返し実行したい処理
# このブロックは最低でも一度は実行される
} While (条件)

• 条件: ループ内のブロックが一度実行された後、繰り返しを行うべきかを判断するために評価される論理式です。この条件式が $true である間、ループが繰り返されます。

例を見てみましょう。While ループと同じカウンターの例ですが、最初に一度は表示される点に注目してください。

“`powershell
$counter = 0

Do {
Write-Host “カウンター: $counter”
$counter++
Start-Sleep -Seconds 1
} While ($counter -lt 5)

Write-Host “ループが終了しました。最終的なカウンターの値: $counter”
“`

この例では、$counter が最初は 0 なので、条件 $counter -lt 5 は真です。しかし、Do-While はまずブロックを実行するため、最初の出力は カウンター: 0 となります。その後 $counter が 1 になり、条件が評価されます。

Do-While ループが While ループと異なるのは、もし最初の時点で条件が偽だった場合でも、Do-While ならブロックは一度実行されるという点です。

“`powershell

初期値で条件が偽となる場合

$counter = 5 # 初期値が5

While ($counter -lt 5) {
# 条件が偽なので、このブロックは一度も実行されない
Write-Host “(While) カウンター: $counter”
$counter++
}
Write-Host “(While) ループ終了” # こちらだけが表示される

Do {
# 条件が偽でも、このブロックは一度は実行される
Write-Host “(Do-While) カウンター: $counter” # これが表示される
$counter++
} While ($counter -lt 5) # $counterは6になっているため、条件は偽となりループは終了
Write-Host “(Do-While) ループ終了” # こちらも表示される
“`

この例から、Do-While は少なくとも1回の実行を保証したいシナリオ（例: ユーザーに一度は入力を求める、最低1回は処理を試みる）で役立つことがわかります。

Do-Until ループ：条件が真になるまで繰り返す（初回無条件実行）

Do-Until ループは Do-While ループとよく似ていますが、繰り返しを行う条件が逆になります。条件式が $false (偽) である間ループを続け、条件式が $true (真) になった時点でループを終了します。

Do-Until ループの構文は以下のようになります。

powershell
Do {
# 繰り返し実行したい処理
# このブロックは最低でも一度は実行される
} Until (条件)

• 条件: ループ内のブロックが一度実行された後、繰り返しを行うべきかを判断するために評価される論理式です。この条件式が $false である間、ループが繰り返されます。条件式が $true になった時点でループは終了します。

例を見てみましょう。特定のサービスが「Running」状態になるまで待機する例です。

“`powershell
$serviceName = “Spooler” # サービス名を指定 (例: Print Spooler)
$service = Get-Service -Name $serviceName

Write-Host “サービス [$serviceName] の状態を確認しています…”

Do {
# サービスの現在の状態を取得
$serviceStatus = (Get-Service -Name $serviceName).Status

Write-Host "現在の状態: $serviceStatus"

if ($serviceStatus -ne "Running") {
    Write-Host "Waiting..."
    Start-Sleep -Seconds 2 # 2秒待機
}

} Until ($serviceStatus -eq “Running”) # 状態が “Running” になるまで繰り返す

Write-Host “サービス [$serviceName] が Running 状態になりました。”
“`

解説:

1. 最初に指定されたサービスの状態を取得します。
2. Do ブロックに入り、無条件に一度目の状態確認と表示を行います。
3. Until ($serviceStatus -eq "Running") で、取得したサービスの状態が “Running” と等しいか（真か）を評価します。
4. もし状態が “Running” でなければ（条件が偽）、ループは繰り返されます。
5. 状態が “Running” になると（条件が真）、ループは終了します。

Do-Until は「〜になるまで繰り返す」という日本語の表現に近く、特定の状態遷移を待つようなシナリオで分かりやすく記述できます。

ループ制御ステートメント：ループの流れを変える

PowerShellのループ構造では、デフォルトではコレクションの全要素を処理したり、条件が偽になるまで処理を続けたりしますが、特定の状況でループの通常の流れを変更したい場合があります。そのために「ループ制御ステートメント」が用意されています。主なものは Break と Continue です。

1. Break：ループの即時終了

Break ステートメントは、現在実行中のループ（For, ForEach, While, Do-While, Do-Until）または Switch ステートメントを即座に終了させます。Break が実行されると、ループ内の残りの処理や、後続の繰り返し処理はすべてスキップされ、ループの直後の処理へと制御が移ります。

例を見てみましょう。配列の中から特定の要素が見つかったら、それ以降の検索を中止する例です。

“`powershell
$names = @(“Alice”, “Bob”, “Charlie”, “David”, “Eve”)
$targetName = “Charlie”
$found = $false

ForEach ($name in $names) {
Write-Host “Checking: $name”
if ($name -eq $targetName) {
Write-Host “Target ‘$targetName’ found!”
$found = $true
Break # ループをここで終了
}
}

if (-not $found) {
Write-Host “Target ‘$targetName’ was not found.”
}
“`

解説:

1. $names 配列を順番に処理します。
2. ループが "Charlie" に到達すると、if ($name -eq $targetName) の条件が真になります。
3. ターゲットが見つかった旨を表示し、$found フラグを $true に設定します。
4. Break ステートメントが実行され、ForEach ループは即座に終了します。
5. "David" や "Eve" は処理されません。
6. ループ終了後の if (-not $found) の評価に移ります（この例では $found が $true なのでブロックは実行されません）。

Break は、検索処理で最初の目的の要素が見つかった場合や、何らかのエラーが発生してそれ以上処理を続行できない場合などに便利です。

2. Continue：現在のイテレーションをスキップ

Continue ステートメントは、現在実行中のループ（For, ForEach, While, Do-While, Do-Until）の現在の繰り返し処理をスキップし、直ちに次の繰り返し処理へと移ります。ループ自体は終了せず、次の要素や次の条件評価から処理が再開されます。

例を見てみましょう。配列の中から特定の要素だけをスキップして表示する例です。

“`powershell
$numbers = 1, 2, 3, 4, 5, 6, 7, 8, 9, 10

ForEach ($number in $numbers) {
if ($number % 2 -eq 0) { # もし偶数なら
Write-Host “Skipping even number: $number”
Continue # このイテレーションの残りをスキップし、次の数値へ
}
# 奇数のみがここに到達
Write-Host “Processing odd number: $number”
}
“`

解説:

1. $numbers 配列を順番に処理します。
2. ループが 1 の場合、if ($number % 2 -eq 0) は偽なので、次の Write-Host が実行され "Processing odd number: 1" と表示されます。
3. ループが 2 の場合、条件は真なので "Skipping even number: 2" が表示され、Continue ステートメントが実行されます。
4. Continue が実行されると、現在の繰り返し処理（$number が 2 の場合の処理）はそこで中断され、直ちに次の繰り返し処理（$number が 3 の場合）へと移ります。"Processing odd number: 2" は表示されません。
5. このプロセスが繰り返され、偶数はスキップされ、奇数のみが「Processing odd number: …」として表示されます。

Continue は、特定の条件を満たさない要素や状況を無視して、残りの要素の処理を続けたい場合に役立ちます。

3. Return：関数またはスクリプト全体の終了

Return ステートメントは、関数またはスクリプトの実行を終了し、呼び出し元に値を返します。ループ内で Return を使用すると、ループだけでなく、そのループが含まれる関数やスクリプト全体の実行が終了してしまう点に注意が必要です。これは Break とは異なる挙動です。

“`powershell
function Find-FirstEvenNumber {
param (
[int[]]$Numbers
)

foreach ($number in $Numbers) {
    Write-Host "Checking: $number"
    if ($number % 2 -eq 0) {
        Write-Host "First even number found: $number"
        Return $number # 関数を終了し、見つかった偶数を返す
    }
}

Write-Host "No even numbers found."
Return $null # 偶数が見つからなかった場合はnullを返す

}

$myNumbers = 1, 3, 5, 7, 8, 10
$firstEven = Find-FirstEvenNumber -Numbers $myNumbers

Write-Host “Function returned: $firstEven”

8と10は処理されずに関数が終了していることがわかる

“`

この例では、8 が見つかった時点で Return $number が実行され、Find-FirstEvenNumber 関数の実行が終了します。そのため、10 は処理されません。ループだけを抜けたい場合は Break を使用します。

入れ子になったループでの Break と Continue、そしてラベル

複数のループを組み合わせる「ネストされたループ」（後述）の場合、Break や Continue はデフォルトでは最も内側のループに対して作用します。

例：

powershell
For ($i = 1; $i -le 3; $i++) {
Write-Host "Outer loop: $i"
For ($j = 1; $j -le 3; $j++) {
Write-Host " Inner loop: $j"
if ($j -eq 2) {
Break # 内側のループ ($j) を終了
}
}
Write-Host "Outer loop continues after inner loop break."
}

このコードを実行すると、内側のループは $j が 2 になった時点で終了し、外側のループの次のイテレーションに移ります。

特定の外側のループから抜け出したい場合など、デフォルトの挙動を変えたい場合は「ラベル」を使用します。ラベルはコロン : で始まり、ループの直前に記述します。Break や Continue の後にラベル名を指定することで、そのラベルが付いたループに対して作用させることができます。

powershell
:outerLoop For ($i = 1; $i -le 3; $i++) {
Write-Host "Outer loop: $i"
For ($j = 1; $j -le 3; $j++) {
Write-Host " Inner loop: $j"
if ($i -eq 2 -and $j -eq 2) {
Write-Host " Breaking out of outer loop from inner loop."
Break outerLoop # ラベル付きブレーク！外側のループから抜ける
}
}
}
Write-Host "Script continues after labeled break."

この例では、$i が 2、$j が 2 の場合に Break outerLoop が実行され、外側の :outerLoop とラベル付けされたループ全体から抜け出します。スクリプトはループ全体を抜けた後の処理に移ります。ラベル付きブレーク/コンティニューはやや高度なテクニックですが、複雑なネスト構造で特定のループを制御したい場合に役立ちます。

ループの応用と実践

基本となるループ構造と制御ステートメントを理解したところで、より実践的な応用例を見ていきましょう。

1. ネストされたループ（入れ子）

ネストされたループとは、あるループのブロックの中に別のループが含まれている構造です。これは、二次元的なデータ構造を扱ったり、組み合わせを生成したりする場合によく使われます。

例として、簡単な九九の表を表示してみましょう。

powershell
For ($i = 1; $i -le 9; $i++) {
# 外側のループ (掛けられる数)
For ($j = 1; $j -le 9; $j++) {
# 内側のループ (掛ける数)
$result = $i * $j
Write-Host "$i x $j = $result" -NoNewline # -NoNewline で改行しない
if ($j -lt 9) {
Write-Host "`t" -NoNewline # タブで区切り
}
}
Write-Host "" # 内側のループが終わるごとに改行
}

解説:

• 外側のループは $i を 1から9まで変化させます。
• 内側のループは $j を 1から9まで変化させます。
• 外側のループが1回実行されるごとに、内側のループは9回実行されます。
• $i が 1 のとき、内側のループで $j が 1 から 9 まで変化し、「1×1=1 1×2=2 … 1×9=9」と表示されます。
• 内側のループが完了すると改行され、外側のループが $i を 2 に増やし、再び内側のループが最初から実行されます。

このようにネストされたループを使うことで、格子状のデータや、複数のリストからの組み合わせなどを効率的に処理できます。

2. パイプライン処理と ForEach-Object の詳細

前述しましたが、ForEach-Object コマンドレットはPowerShellのパイプライン処理と深く連携しています。パイプラインは、コマンドレットがオブジェクトをストリームとして渡す仕組みであり、大規模なデータセットを処理する際にメモリ効率が良いという大きな利点があります。

ForEach-Object は、パイプラインから流れてくる各オブジェクトに対して、定義されたスクリプトブロック ({ ... }) を実行します。スクリプトブロック内では、自動変数 $_ (または $PSItem) を使って現在のオブジェクトを参照できます。

パイプライン処理の利点

1. メモリ効率: 大量のオブジェクトを一度にメモリにロードする必要がなく、一つずつ処理できるため、メモリ使用量を抑えられます。これは数十万、数百万といったファイルを扱う場合などに特に重要です。
2. 即時性: パイプラインの最初のコマンドレットがオブジェクトを出力すると、次のコマンドレットはそれを受け取ってすぐに処理を開始できます。すべてのデータが生成されるのを待つ必要がありません（遅延評価）。
3. 柔軟性: 複数のコマンドレットを | でつなげることで、複雑な処理を組み立てることができます。

ForEach と ForEach-Object の使い分けに関する補足

• ForEach (ステートメント):
  • 利点: シンプルなコレクション処理では高速。コレクション全体を一度に扱える。
  • 欠点: 大規模データではメモリを大量消費する可能性がある。パイプラインの途中に組み込むのが不自然。
• ForEach-Object (コマンドレット):
  • 利点: 大規模データに強い（メモリ効率）。パイプラインとの親和性が高い。PSv7+で並列処理が可能。
  • 欠点: 単体のコレクション処理では ForEach よりわずかにオーバーヘッドが大きいことがある。

基本的なコレクション処理には ForEach を使い、パイプラインでデータをフィルタリングしたり変換したりしながら処理する場合は ForEach-Object を使う、という使い分けが一般的です。

PowerShell 7+ での並列処理 (-Parallel)

PowerShell 7以降では、ForEach-Object に -Parallel パラメータが追加されました。これにより、複数のスレッドを使ってコレクションの要素を並列に処理することが可能になり、処理時間を大幅に短縮できる場合があります。特に、各要素に対する処理に時間がかかる場合（例: ネットワーク通信、ファイルI/O、複雑な計算）に効果を発揮します。

“`powershell

PowerShell 7 以降で実行可能

$computerNames = “Server01”, “Server02”, “Server03”, “Server04”, “Server05”

各サーバーに対してPingを実行（時間がかかる処理を想定）

$computerNames | ForEach-Object -Parallel {
$hostname = $ # $ に現在のコンピューター名が入る
Write-Host “Checking $hostname…”
# Pingを実行し、結果を返す (Test-Connectionはオブジェクトを返す)
Test-Connection -ComputerName $hostname -Count 1 -ErrorAction SilentlyContinue | Select-Object -ExpandProperty Ipv4Address
} -ThrottleLimit 4 # 同時に実行するスレッド数を制限

Write-Host “`nParallel processing complete.”
“`

解説:

• $computerNames というコンピューター名の配列を定義します。
• これをパイプラインで ForEach-Object -Parallel に渡します。
• -Parallel パラメータを指定することで、PowerShellは配列の各要素を複数のスレッドに分散して処理させようとします。
• スクリプトブロック { ... } 内の処理が各コンピューター名に対して並列に実行されます。
• -ThrottleLimit 4 は、同時に最大4つのスレッドを実行するように制限します。これにより、システムリソースを過度に消費するのを防ぎます。適切な ThrottleLimit の値は、実行環境や処理内容によって調整が必要です。

並列処理は非常に強力ですが、デバッグが難しくなったり、共有リソースへのアクセス管理（排他制御）が必要になる場合があるなど、複雑さも伴います。シンプルな処理であれば、まずは通常のループから検討するのが良いでしょう。

3. 条件付きループ処理

ループ内で If ステートメントを使って、特定の条件を満たす要素だけを処理したり、ループの挙動を変えたりすることは一般的です。前述の Continue を使う例もこれに該当します。

また、パイプライン処理では Where-Object コマンドレットと組み合わせてループに入る前にフィルタリングを行うことも非常に重要です。

“`powershell

フォルダ内のファイルのうち、特定の拡張子 (例: .log) かつサイズが1MBを超えるものをリストアップ

Get-ChildItem -Path “C:\Logs” -File | # -File でファイルのみ取得
Where-Object { $.Extension -eq “.log” -and $.Length -gt 1MB } | # 条件でフィルタリング
ForEach-Object {
# フィルタリングされたファイルオブジェクトに対して処理を実行
Write-Host “対象ファイル: $($.FullName), サイズ: $($.Length / 1MB) MB”
# 例: Copy-Item $_.FullName -Destination “C:\Archive”
}
“`

この例では、Where-Object を使って ForEach-Object に渡される前にファイルオブジェクトをフィルタリングしています。これにより、ループ内で全てのオブジェクトに対して条件判定を行うよりも効率的になることがあります。特に、元のコレクションが大きい場合にフィルタリングが効果を発揮します。

実践的なループ例

これまでに学んだループ構造を使って、具体的なシステム管理タスクを自動化する例を見てみましょう。

例1：特定のフォルダ内のファイル処理

指定したフォルダ内の .txt ファイルを検索し、それぞれのファイル名と最終更新日時を表示するスクリプトです。

“`powershell
$folderPath = “C:\Temp\MyDocuments” # 処理したいフォルダパスを指定

フォルダが存在するか確認

if (Test-Path -Path $folderPath -PathType Container) {
# Get-ChildItemで指定フォルダ内の.txtファイルを検索 (-Filterを使用すると高速)
$txtFiles = Get-ChildItem -Path $folderPath -Filter “*.txt” -File

if ($txtFiles.Count -gt 0) {
    Write-Host "以下の.txtファイルを処理します："
    Write-Host "---------------------------------"

    # Foreachループで各ファイルオブジェクトを処理
    ForEach ($file in $txtFiles) {
        # ファイル名 (BaseName) と最終更新日時 (LastWriteTime) を表示
        Write-Host "ファイル名: $($file.BaseName), 更新日時: $($file.LastWriteTime)"

        # ここにファイルに対する追加の処理を記述可能
        # 例：ファイルの内容を読む Get-Content -Path $file.FullName
        # 例：ファイルを移動する Move-Item -Path $file.FullName -Destination "C:\Archive"
    }

    Write-Host "---------------------------------"
    Write-Host "全ファイルの処理が完了しました。"
} else {
    Write-Host "指定されたフォルダに.txtファイルは見つかりませんでした。"
}

} else {
Write-Host “エラー：指定されたフォルダパス [$folderPath] が見つかりません。”
}
“`

ポイント:

• Get-ChildItem はファイルやフォルダのオブジェクトを返します。-Filter "*.txt" や -File パラメータを使うことで、取得するオブジェクトを絞り込み、効率を高めています。
• 取得したファイルオブジェクトのコレクションを $txtFiles に格納し、ForEach ループで一つずつ処理しています。
• ループ内で $file.BaseName や $file.LastWriteTime のように、ファイルオブジェクトのプロパティにアクセスして情報を取得しています。

例2：CSVファイルからユーザーリストを読み込み処理

CSVファイルに記載されたユーザー名リストを読み込み、各ユーザーに対して操作を実行するスクリプトの雛形です。Active Directoryのユーザー管理などで応用できます。

例えば、以下のようなCSVファイル (users.csv) があるとします。

csv
UserName,DisplayName,Department
user1,User One,IT
user2,User Two,Sales
user3,User Three,Marketing

このCSVを読み込んで各ユーザー情報を表示します。

“`powershell
$csvFilePath = “C:\Scripts\users.csv” # CSVファイルのパスを指定

CSVファイルが存在するか確認

if (Test-Path -Path $csvFilePath -PathType Leaf) {

Write-Host "CSVファイル [$csvFilePath] を読み込んでいます..."

# Import-CsvコマンドレットでCSVファイルを読み込む
# 各行がオブジェクトになり、列ヘッダーがプロパティ名になる
$users = Import-Csv -Path $csvFilePath

if ($users.Count -gt 0) {
    Write-Host "以下のユーザーを処理します："
    Write-Host "---------------------------------"

    # ForEachループで各ユーザーオブジェクトを処理
    ForEach ($user in $users) {
        # CSVの列名がプロパティとしてアクセスできる
        $username = $user.UserName
        $displayName = $user.DisplayName
        $department = $user.Department

        Write-Host "処理中のユーザー: $username"
        Write-Host "  表示名: $displayName"
        Write-Host "  部署: $department"

        # ここに各ユーザーに対する実際の処理を記述
        # 例：Get-ADUser -Identity $username | Set-ADUser -Department $department
        # 例：New-LocalUser -Name $username -FullName $displayName ...

        Write-Host "" # 各ユーザー情報の後に改行
    }

    Write-Host "---------------------------------"
    Write-Host "全ユーザーの処理が完了しました。"
} else {
    Write-Host "CSVファイルにデータ行が見つかりませんでした。"
}

} else {
Write-Host “エラー：指定されたCSVファイルパス [$csvFilePath] が見つかりません。”
}
“`

ポイント:

• Import-Csv コマンドレットは、CSVファイルの各行をオブジェクトに変換して出力します。CSVのヘッダー行がオブジェクトのプロパティ名として利用できます。
• ForEach ループで、Import-Csv が生成したオブジェクトのコレクションを処理します。
• ループ内の $user 変数には、現在のユーザーに対応するオブジェクトが格納されており、$user.UserName, $user.DisplayName のようにプロパティとして値にアクセスできます。
• このテンプレートに、Get-ADUser, Set-ADUser, New-LocalUser, Set-Mailbox などのコマンドレットを組み合わせることで、様々なユーザー管理タスクを自動化できます。

例3：ネットワーク上のコンピューターリストに対する操作

テキストファイルに記載されたコンピューター名リストを読み込み、各コンピューターに対して操作（例: Pingテスト）を実行するスクリプトの雛形です。

例えば、以下のようなテキストファイル (computers.txt) があるとします。

Server01
Server02
Workstation10
Server99

このリストを読み込み、各コンピューターにPingを実行します。

“`powershell
$computerListFile = “C:\Scripts\computers.txt” # コンピューターリストファイルのパスを指定

ファイルが存在するか確認

if (Test-Path -Path $computerListFile -PathType Leaf) {

Write-Host "コンピューターリストファイル [$computerListFile] を読み込んでいます..."

# Get-Contentでファイル内容を読み込む (各行が文字列の要素となる配列になる)
$computerNames = Get-Content -Path $computerListFile | Where-Object { $_.Trim() -ne "" } # 空行をスキップ

if ($computerNames.Count -gt 0) {
    Write-Host "以下のコンピューターを処理します："
    Write-Host "---------------------------------"

    # ForEachループで各コンピューター名を処理
    ForEach ($computerName in $computerNames) {
        Write-Host "処理中のコンピューター: $computerName"

        # ここに各コンピューターに対する実際の処理を記述
        # 例：Pingテスト
        if (Test-Connection -ComputerName $computerName -Count 1 -Quiet -ErrorAction SilentlyContinue) {
            Write-Host "  - 応答あり" -ForegroundColor Green
            # 例：リモートコマンド実行 Invoke-Command -ComputerName $computerName -ScriptBlock { Get-Service BITS }
        } else {
            Write-Host "  - 応答なし" -ForegroundColor Red
        }

        Write-Host "" # 各コンピューター処理の後に改行
    }

    Write-Host "---------------------------------"
    Write-Host "全コンピューターの処理が完了しました。"
} else {
    Write-Host "リストファイルにコンピューター名が見つかりませんでした。"
}

} else {
Write-Host “エラー：指定されたコンピューターリストファイルパス [$computerListFile] が見つかりません。”
}
“`

ポイント:

• Get-Content はテキストファイルの各行を文字列要素として配列で返します。
• Where-Object { $_.Trim() -ne "" } をパイプラインで繋ぐことで、空白行をフィルタリングしています。
• ForEach ループで、取得したコンピューター名の配列を処理します。
• ループ内で $computerName 変数を使って現在のコンピューター名にアクセスし、Test-Connection などのリモート操作コマンドレットに渡しています。
• Test-Connection -Quiet は成功/失敗を $true/$false で返すため、条件分岐に便利です。

これらの例はあくまで基本的なフレームワークですが、ここに PowerShell の豊富なコマンドレットを組み合わせることで、様々な自動化シナリオに対応できるようになります。

パフォーマンスに関する考慮事項

PowerShellで大規模なデータや多数のオブジェクトをループ処理する場合、パフォーマンスが重要になることがあります。非効率なスクリプトは実行に時間がかかったり、システムリソースを過度に消費したりする可能性があります。

パフォーマンスを向上させるための主な考慮事項は以下の通りです。

1. ループに入る前にフィルタリングする: Get-ChildItem の -Filter や -Include/-Exclude、Get-Process の -Name など、コマンドレット自体が持つフィルタリング機能は非常に効率的です。可能な限り、これらのパラメータを使って取得するオブジェクトの数を減らしてからループ処理に入りましょう。Where-Object はパイプラインでフィルタリングを行いますが、可能であればコマンドレット組み込みのフィルターの方が通常高速です。

   “`powershell

   効率的: Get-ChildItem の -Filter を使う

   Get-ChildItem -Path “C:\Logs” -Filter “*.log” | ForEach-Object { … }

   やや非効率 (ただし、Filterパラメータがないコマンドレットの場合は有効): Where-Object で後からフィルタリング

   Get-ChildItem -Path “C:\Logs” | Where-Object { $_.Extension -eq “.log” } | ForEach-Object { … }

   “`

2. ForEach と ForEach-Object の使い分け: 前述の通り、小規模な固定コレクションには ForEach が高速ですが、大規模なストリームデータにはメモリ効率の良い ForEach-Object が適しています。状況に応じて使い分けましょう。

3. 不必要なオブジェクトの生成を避ける: ループ内で繰り返し同じコマンドレットを呼び出す場合、そのコマンドレットが大量のオブジェクトを生成する場合はオーバーヘッドが大きくなります。必要に応じて、ループに入る前に一度データを取得して変数に格納し、その変数をループで処理する方が効率的な場合があります。

4. パイプライン処理の活用: パイプラインは遅延評価（ストリーミング）の特性を持つため、メモリ使用量を抑えつつ処理を継続できます。大規模データを扱う場合はパイプラインと ForEach-Object を積極的に活用しましょう。

5. 文字列操作の効率化: ループ内で大量の文字列連結を行う場合、PowerShellでは + 演算子よりも [System.Text.StringBuilder] クラスを使用する方が高速です。

   “`powershell

   非効率な文字列連結（特に長い文字列や多数回の場合）

   $longString = “”
   For ($i = 0; $i -lt 1000; $i++) {
   $longString += “Iteration $i`n”
   }

   効率的な文字列連結 (StringBuilder)

   $sb = New-Object System.Text.StringBuilder
   For ($i = 0; $i -lt 1000; $i++) {
   $sb.AppendLine(“Iteration $i”) | Out-Null # Out-Null で余計な出力を抑制
   }
   $longString = $sb.ToString()
   “`

6. -ErrorAction SilentlyContinue や Try-Catch によるエラー処理: ループ内でエラーが発生した場合、デフォルトではスクリプトが停止することがあります。エラーを無視して処理を続けたい場合は -ErrorAction SilentlyContinue や Try-Catch ブロックを使用しますが、頻繁なエラー処理はわずかにオーバーヘッドを増加させる可能性があります。適切なエラー処理戦略を選択しましょう。

7. PowerShell 7+ の並列処理 (-Parallel): 各要素に対する処理に時間がかかる場合は、並列処理によって全体の実行時間を短縮できる可能性があります。ただし、並列化によるオーバーヘッドも考慮する必要があります。

パフォーマンスチューニングは常に状況依存であり、ボトルネックとなっている箇所を見極めることが重要です。Measure-Command コマンドレットを使って異なる実装の実行時間を比較検討することも有効な手段です。

デバッグとトラブルシューティング

ループを含むスクリプトを作成する際、予期せぬ動作をしたり、エラーが発生したりすることがあります。特に無限ループや、ループ内の変数の値が期待通りにならないといった問題はよく遭遇します。

ここでは、ループのデバッグやトラブルシューティングに役立つ方法をいくつか紹介します。

1. 無限ループの検出と停止:

   • スクリプトが実行され続けて終わらない、CPU使用率が高いままになっている、といった場合は無限ループに陥っている可能性があります。
   • 停止方法: スクリプトを実行しているPowerShellコンソールやISE、VS Codeターミナルで Ctrl + C キーを押すことで、通常はスクリプトの実行を強制的に中断できます。

2. ループ内の変数の値を確認する:

   • ループの各イテレーションで変数の値がどう変化しているかを確認することは、問題を特定する上で非常に有効です。
   • Write-Host コマンドレットを使って、ループの各ステップで変数やオブジェクトのプロパティの値をコンソールに表示させましょう。

   “`powershell
   For ($i = 0; $i -lt 10; $i++) {
   Write-Host “Debug: \$i の現在の値は $i です。”
   # 他の処理…
   }

   ForEach ($file in $files) {
   Write-Host “Debug: 処理中のファイル: $($file.Name)”
   # 他の処理…
   }
   “`

   • Write-Verbose や Write-Debug を使用することもできます。これらのコマンドレットによる出力は、スクリプト実行時に -Verbose や -Debug パラメータを指定しないと表示されないため、デバッグ用のメッセージと通常の出力を分けるのに便利です。

   “`powershell

   スクリプトの先頭などで $VerbosePreference = “Continue” とする

   または、スクリプト実行時に -Verbose パラメータを付ける

   ForEach ($item in $collection) {
   Write-Verbose “処理中のアイテム: $($item.Id)”
   # 他の処理…
   }
   “`

3. ステップ実行（デバッガーの使用）：

   • PowerShell Integrated Scripting Environment (ISE) や Visual Studio Code のPowerShell拡張機能には、デバッガー機能が搭載されています。
   • スクリプトにブレークポイント（処理を一時停止させたい場所）を設定し、ステップ実行することで、一行ずつ処理を進めながら変数やステータスを確認できます。
   • Set-PSBreakpoint コマンドレットを使ってプログラム的にブレークポイントを設定することも可能ですが、通常はIDEのGUI機能を使うのが便利です。

   “`powershell

   例：特定の行にブレークポイントを設定

   Set-PSBreakpoint -Path “C:\Scripts\MyScript.ps1” -Line 15

   または、特定の変数への書き込み時にブレークポイントを設定

   Set-PSBreakpoint -Variable myVariable -Action { Write-Host “myVariableが変更されました” }

   デバッグを開始

   Debug-RunSpace -FilePath “C:\Scripts\MyScript.ps1”
   “`

4. エラーメッセージの確認:

   • エラーが発生した場合は、PowerShellが表示するエラーメッセージをよく確認しましょう。エラーの種類、発生した行番号、エラーの内容などが含まれており、原因究明の手がかりになります。
   • $LASTERROR 自動変数や Get-Error コマンドレット（PSv7+）を使うと、直近のエラーの詳細を確認できます。

5. 小さな単位でテストする:

   • 複雑なループ処理を一度に記述するのではなく、まずはコレクションの最初の数要素だけでテストしてみる、ループ内の処理をシンプルな表示に変えてみるなど、問題を切り分けながら開発・テストを進めましょう。

デバッグはスクリプト開発において避けて通れないプロセスです。これらのテクニックを習得することで、ループ処理を含むスクリプトの問題を効率的に解決できるようになります。

まとめ

PowerShellにおける繰り返し（ループ）処理は、システム管理や自動化スクリプトを作成する上で非常に重要な要素です。本記事では、主要な5つのループ構造（For, ForEach, ForEach-Object, While, Do-While/Do-Until）について、それぞれの基本的な構文、使い分け、そして実践的な応用例を解説しました。

• 繰り返し回数が決まっている場合や数値インデックスが必要な場合は For ループ。
• 配列やコマンドレットの出力などのコレクションの各要素をシンプルに処理したい場合は ForEach ステートメント。
• パイプラインで渡されるオブジェクトを一つずつ処理したい場合や、大規模データを効率的に扱いたい場合は ForEach-Object コマンドレット（必要に応じて Begin, Process, End ブロックや -Parallel パラメータも活用）。
• 特定の条件が満たされている間、繰り返し回数不定で処理を続けたい場合は While ループ。
• 最低1回は処理を実行し、その後に条件に基づいて繰り返したい場合は Do-While または Do-Until ループ。

これらのループ構造を使い分けることで、様々な繰り返しタスクをPowerShellで実現できます。

また、ループの途中で処理の流れを制御する Break や Continue といったステートメント、複数のループを組み合わせるネストされたループ、そしてパフォーマンスに関する考慮事項やデバッグ方法についても学びました。

ループは、手作業では困難あるいは非現実的な大量の繰り返し作業を自動化し、時間と労力を節約する上で絶大な効果を発揮します。ぜひ、この記事で学んだ知識を活かして、日々の業務における様々なタスクを自動化するスクリプトを作成してみてください。

PowerShellの学習は継続が鍵です。公式ドキュメントやオンラインコミュニティも活用しながら、さらに深い知識や新しいテクニックを習得していきましょう。

PowerShellでのループ処理マスターへの旅はまだ始まったばかりです。実践を通じて、さらに多くのことを学んでいってください。

---