はい、承知いたしました。PowerShellにおける変数・文字列の結合について、効率的な使い方を含む詳細な説明を約5000語で記述した記事を作成します。記事の内容を直接ここに表示します。

---

PowerShell 変数・文字列の結合 | 効率的な使い方とパフォーマンス徹底解説

はじめに

PowerShellスクリプトを作成する上で、変数や文字列を扱う機会は非常に多いでしょう。ファイルパスを構築したり、ログメッセージを生成したり、ユーザーへの出力を整形したりと、様々な場面で文字列の結合が必要になります。しかし、PowerShellには文字列を結合するための複数の方法が存在し、それぞれに特徴、利点、そしてパフォーマンスの差があります。

単純な文字列結合であればどの方法でも大差ないように思えるかもしれません。しかし、特にスクリプト内で頻繁に文字列結合を行う場合や、大量の文字列を扱う場合には、選択した方法によってスクリプトのパフォーマンスや可読性が大きく変わることがあります。効率的な方法を知っているかどうかで、スクリプトの実行速度が劇的に向上したり、メンテナンス性が向上したりするのです。

この記事では、PowerShellにおける変数と文字列の結合について、基本的な方法から始めて、より効率的な方法、さらにはそれぞれの方法のパフォーマンス特性や内部的な仕組みに至るまで、詳細に解説します。様々なコード例を交えながら、どのような状況でどの方法を選択すべきかを具体的に示し、PowerShellスクリプトをより効果的に記述するための知識を提供します。

この記事を読むことで、あなたは以下のことができるようになります。

• PowerShellにおける文字列の基本（シングルクォートとダブルクォート）を理解する。
• 変数と文字列を結合する様々な方法を知り、使い分けられるようになる。
• 補間文字列（Interpolated String）やJoin-Pathのような便利な機能を活用する。
• 多数の文字列結合におけるパフォーマンスの問題を理解し、[System.Text.StringBuilder]を使った効率的な方法を習得する。
• 各方法のメリット・デメリットを比較し、目的に合った最適な方法を選択する判断力を養う。
• 文字列結合に関するよくある落とし穴とその回避策を知る。

それでは、PowerShellの世界における文字列結合の奥深さを探求していきましょう。

PowerShellにおける文字列の基本

PowerShellで文字列を扱う際には、主にシングルクォート（'）とダブルクォート（"）が使用されます。これらのクォートの種類によって、文字列リテラルの解釈方法が大きく異なります。この違いを理解することは、変数や式を文字列に含める際に非常に重要です。

シングルクォート ('...')

シングルクォートで囲まれた文字列は、「リテラル文字列」として扱われます。これは、クォート内の文字がほぼそのままの意味で解釈されることを意味します。変数やエスケープシーケンス（後述）は展開されず、単なる文字の並びとして扱われます。

例：

powershell
$name = "Alice"
$literalString = 'Hello, $name. How are you?'
Write-Host $literalString

出力：

Hello, $name. How are you?

ご覧の通り、$nameは変数の中身（”Alice”）ではなく、リテラルな文字列「$name」として出力されています。

シングルクォート内で使用できるエスケープシーケンスは限定的で、シングルクォート自身を文字列に含めたい場合に、シングルクォートを二つ続けて記述する（''）ことだけが認められています。

例：

powershell
$singleQuoteInString = 'This is Alice''s book.'
Write-Host $singleQuoteInString

出力：

This is Alice's book.

シングルクォート文字列は、文字列の内容を正確に表現したい場合や、変数展開やエスケープシーケンスの処理オーバーヘッドを避けたい場合に適しています。特にパスやコマンドライン引数など、特殊文字や変数名がそのまま必要な場面で有効です。

ダブルクォート ("...")

ダブルクォートで囲まれた文字列は、「展開可能な文字列（Expandable String）」として扱われます。これにより、文字列の中に変数や式を含めてその値を展開したり、様々なエスケープシーケンスを使用したりすることができます。

例：

powershell
$name = "Alice"
$expandableString = "Hello, $name. How are you?"
Write-Host $expandableString

出力：

Hello, Alice. How are you?

$name変数がその値である”Alice”に展開されていることがわかります。

また、ダブルクォート文字列では、特別な意味を持つ文字を表現するためのエスケープシーケンスが多数使用できます。一般的なエスケープシーケンスには以下のようなものがあります。

• \n: 改行
• \r: キャリッジリターン
• \t: タブ
• \": ダブルクォート自身
• \$: ドル記号自身
• \：バックスラッシュ自身

例：

``powershell
$path = "C:\\Temp\\New Folder" # バックスラッシュをエスケープ
$message = "Column1\tColumn2\nValue1\tValue2" # タブと改行
$quote = "He said, \"Hello!\"" # ダブルクォートをエスケープ
$cost = "The cost is \$10.” # ドル記号をエスケープ (バッククォートを使用)

Write-Host $path
Write-Host “—”
Write-Host $message
Write-Host “—”
Write-Host $quote
Write-Host “—”
Write-Host $cost
“`

出力：

“`
C:\Temp\New Folder

---

Column1 Column2
Value1 Value2

---

He said, “Hello!”

The cost is $10.
“`

ダブルクォート文字列は、変数や式の値を文字列に埋め込みたい場合や、改行、タブ、引用符などの特殊文字を表現したい場合に非常に便利です。文字列結合の多くの場面で利用される基本的な機能と言えます。

変数の周囲の文字と曖昧さの回避

ダブルクォート文字列内で変数を展開する際、変数の直後に英数字などが続く場合、PowerShellが変数名の範囲を正しく判断できないことがあります。このような曖昧さを避けるためには、変数を波括弧 {} で囲むことができます。

例：

“`powershell
$animal = “Fox”
$plural = “es” # ‘Foxes’ と結合したい

間違い（通常はエラーにならないが意図と異なる可能性）

Write-Host “Many $animal$plural” # $animal$plural という変数を探そうとする

正しい方法１：結合演算子を使用

Write-Host “Many ” + $animal + $plural

正しい方法２：波括弧で変数名を明確にする

Write-Host “Many ${animal}${plural}”
“`

出力：

Many Foxes
Many Foxes

波括弧を使う方法は、特に変数名の直後にファイル拡張子を付けたい場合などによく使用されます。例: "log_${hostname}.txt"

$() サブエクスプレッション

ダブルクォート文字列の強力な機能の一つに、$() サブエクスプレッションがあります。これにより、文字列内でPowerShellの任意の式を実行し、その結果を文字列に埋め込むことができます。これは、単なる変数展開だけでなく、コマンドレットの実行、オブジェクトのプロパティ参照、メソッド呼び出しなど、より複雑な値を埋め込むのに役立ちます。

例：

“`powershell
$date = Get-Date
$message = “Current date and time is $((Get-Date -Format ‘yyyy-MM-dd HH:mm:ss’)).”
$computerInfo = Get-ComputerInfo
$osVersion = “Operating System: $($computerInfo.OsName) Build $($computerInfo.OsBuildNumber)”

Write-Host $message
Write-Host $osVersion
“`

出力例：

Current date and time is 2023-10-27 10:30:00.
Operating System: Microsoft Windows 10 Enterprise Build 19045

$(...)の中では、Get-Date -Format '...' のようにコマンドレットを実行したり、$computerInfo.OsName のようにオブジェクトのプロパティにアクセスしたりしています。これらの式の評価結果が文字列に展開されます。

このサブエクスプレッションは非常に柔軟で便利ですが、複雑な式を多用しすぎると文字列の可読性が低下する可能性がある点に注意が必要です。

PowerShell変数

PowerShellの変数は、データを格納するための名前付きの領域です。変数はドル記号（$）で始まり、その後に文字、数字、アンダースコアなどが続きます。PowerShellは動的に型を推論しますが、必要に応じて明示的に型を指定することも可能です。

例：

“`powershell
$myVariable = “Hello” # 文字列型として推論される
$anotherVariable = 123 # 整数型として推論される
$pi = 3.14159 # 浮動小数点型として推論される
$isTrue = $true # 真偽値型として推論される

[int]$explicitInt = “456” # 明示的に整数型を指定
[datetime]$now = Get-Date # 明示的にDateTime型を指定

Write-Host “$myVariable is of type $($myVariable.GetType().Name)”
Write-Host “$explicitInt is of type $($explicitInt.GetType().Name)”
“`

出力例：

Hello is of type String
456 is of type Int32

文字列結合においては、これらの様々な型の変数を文字列と結合することがよくあります。PowerShellは通常、文字列との結合を行う際に、他の型の変数を自動的に文字列に変換します。

例：

powershell
$number = 100
$text = "Value is: "
$combined = $text + $number
Write-Host $combined # 出力: Value is: 100
Write-Host "$text$number" # 出力: Value is: 100

数値型である$numberは、文字列と結合される際に自動的に文字列”100″に変換されています。この自動変換は便利な反面、予期しない結果を招く可能性もあるため、特に数値計算と文字列操作が混在する際には注意が必要です（詳細は後述の「よくある落とし穴」を参照）。

文字列結合の基本的な方法

PowerShellで文字列と変数を結合する基本的な方法をいくつか紹介します。これらは比較的シンプルで、多くの場面で利用されます。

+ 演算子

最も直感的で基本的な文字列結合の方法は、プラス記号（+）演算子を使用することです。複数の文字列リテラル、変数、またはその他の型の値を+演算子で連結することができます。

例：

“`powershell
$firstName = “John”
$lastName = “Doe”
$fullName = $firstName + ” ” + $lastName # 変数とリテラル文字列を結合

$city = “New York”
$state = “NY”
$location = $city + “, ” + $state # 複数の要素を結合

Write-Host $fullName
Write-Host $location

$prefix = “ID-”
$id = 12345
$itemId = $prefix + $id # 文字列と数値を結合
Write-Host $itemId # 出力: ID-12345
“`

+演算子は非常にシンプルで分かりやすいですが、特に多数の文字列を結合する場合や、ループ内で繰り返し使用する場合にはパフォーマンス上の注意が必要です。PowerShell（および基盤となる.NET Framework）では、文字列は変更不可能な（immutable）オブジェクトです。これは、一度作成された文字列の内容を変更することはできず、文字列を結合するたびに、新しい文字列オブジェクトがメモリに作成されることを意味します。例えば、$a + $b + $cという操作は、まず$a + $bで一時的な新しい文字列を作り、次にその一時文字列と$cを結合してさらに新しい文字列を作ります。これを繰り返すと、多数の一時オブジェクトが生成され、メモリの割り当てと解放（ガベージコレクション）が頻繁に発生し、パフォーマンスが低下する可能性があります。

+= 演算子

+= 演算子を使用すると、既存の文字列変数に新しい文字列を追加して、その変数を更新することができます。これは、$variable = $variable + $stringToAdd の短縮形です。

例：

“`powershell
$logMessage = “Starting process…”
$logMessage += ” Phase 1 complete.” # 文字列を追加
$logMessage += ” Phase 2 complete.”
$logMessage += ” Finalizing.”

Write-Host $logMessage
“`

出力：

Starting process... Phase 1 complete. Phase 2 complete. Finalizing.

+= 演算子も内部的には + 演算子と同様に新しい文字列オブジェクトを生成しています。そのため、ループ処理などでこの演算子を繰り返し使用して大きな文字列を構築すると、+ 演算子と同様にパフォーマンスの問題が発生する可能性があります。

配列への追加と Join 演算子 / [string]::Join() メソッド

複数の要素を特定の区切り文字で結合して一つの文字列にしたい場合、文字列の配列を作成し、Join 演算子または [string]::Join() 静的メソッドを使用するのが効率的です。

例：

“`powershell
$parts = @(“Apple”, “Banana”, “Cherry”) # 文字列の配列を作成

Join 演算子を使用

$commaSeparated = $parts -join “,”
Write-Host $commaSeparated # 出力: Apple,Banana,Cherry

[string]::Join() メソッドを使用

$dashSeparated = [string]::Join(“-“, $parts)
Write-Host $dashSeparated # 出力: Apple-Banana-Cherry

$sentenceParts = @(“This”, “is”, “a”, “sentence.”)
$sentence = $sentenceParts -join ” ” # スペースで結合
Write-Host $sentence # 出力: This is a sentence.
“`

この方法は、特にリストや配列の内容を文字列として出力するのに便利です。Join 演算子や [string]::Join() メソッドは、内部で効率的に文字列を結合するための処理を行っているため、要素数が多くても + 演算子を繰り返し使うよりも高速です。

[string]::Join() メソッドは、第一引数に区切り文字、第二引数に結合したい要素の配列（または列挙可能なオブジェクト）を取ります。Join 演算子は、左オペランドに配列、右オペランドに区切り文字を取ります。どちらも結果は同じですが、[string]::Join() の方がより広範なオブジェクト型に対応できる場合があります。

文字列結合の効率的な方法

基本的な方法に加えて、PowerShellにはより効率的であったり、特定の用途に特化していたりする文字列結合の方法があります。これらの方法を適切に使い分けることで、スクリプトのパフォーマンス、可読性、堅牢性を向上させることができます。

補間文字列 (Interpolated String)

前に「PowerShellにおける文字列の基本」で触れたダブルクォート文字列（展開可能な文字列）は、変数や$()サブエクスプレッションを文字列に埋め込むことができるため、実質的に非常に効率的な文字列結合の方法として機能します。特に短い文字列や、少数の変数を埋め込む場合には、+演算子を使うよりも補間文字列の方が推奨されます。

例：

“`powershell
$name = “World”
$greeting = “Hello, $name!” # 変数を直接埋め込み

$count = 5
$item = “files”
$summary = “Found $count $($item).” # 変数とサブエクスプレッションを埋め込み

Write-Host $greeting
Write-Host $summary
“`

出力：

Hello, World!
Found 5 files.

補間文字列の利点はその可読性にあります。結合したい文字列のテンプレートの中に、そのまま変数名や式を埋め込めるため、コードが直感的で分かりやすくなります。また、内部的には+演算子を繰り返し使うよりも効率的な方法（場合によっては後述のStringBuilderに似たメカニズム）で文字列を構築しているため、多くの場合でパフォーマンス上の問題もありません。ただし、非常に多数の変数や式を一つの文字列に埋め込む場合や、巨大な文字列を繰り返し構築するような場面では、後述のStringBuilderの方が優れたパフォーマンスを発揮することがあります。

Join-Path コマンドレット

ファイルシステムパスを構築する際に、オペレーティングシステムによってパス区切り文字（Windowsでは\、LinuxやmacOSでは/）が異なるという問題があります。これらの違いを意識せずに安全にパスを結合したい場合は、Join-Path コマンドレットを使用するのが最適です。

Join-Path は、複数のパスコンポーネントを受け取り、現在のOSに適した形式で結合されたパス文字列を返します。

例：

“`powershell

Windows 環境での実行例

$folder = “C:\Users\Admin\Documents”
$file = “report.txt”
$fullPath = Join-Path -Path $folder -ChildPath $file
Write-Host $fullPath # 出力例: C:\Users\Admin\Documents\report.txt

Linux 環境での実行例 (同じコード)

$folderLinux = “/home/user/data”
$fileLinux = “config.conf”
$fullPathLinux = Join-Path -Path $folderLinux -ChildPath $fileLinux
Write-Host $fullPathLinux # 出力例: /home/user/data/config.conf
“`

Join-Path は、パスコンポーネントの終わりに不要なスラッシュやバックスラッシュがある場合でも適切に処理し、余分な区切り文字が挿入されないようにします。

例：

“`powershell
$base = “C:\Logs\” # 意図的に末尾にバックスラッシュ
$subfolder = “\2023\” # 意図的に両端にバックスラッシュ
$filename = “event.log”

間違いやすい + 演算子での結合（冗長なバックスラッシュ）

$badPath = $base + $subfolder + $filename
Write-Host “Bad Path: $badPath” # 出力: C:\Logs\2023\event.log

Join-Path での結合（適切に処理される）

$goodPath = Join-Path -Path $base -ChildPath $subfolder
$goodPath = Join-Path -Path $goodPath -ChildPath $filename
Write-Host “Good Path: $goodPath” # 出力: C:\Logs\2023\event.log

-AdditionalPaths パラメータで複数要素を一度に結合

$parts = @(“C:”, “Logs”, “2023”, “event.log”)
$combinedPath = Join-Path -Path $parts[0] -AdditionalPaths $parts[1..($parts.Length-1)]
Write-Host “Combined Path: $combinedPath” # 出力: C:\Logs\2023\event.log
“`

Join-Path はパス結合に特化しており、OSの違いを吸収してくれるため、パス関連の文字列操作では積極的に使用すべきです。

[string]::Format() メソッド

.NET Framework の System.String.Format メソッドは、PowerShellの [string]::Format() 静的メソッドとして利用できます。このメソッドは、書式指定子を使用して文字列の中に値を埋め込む強力な機能を提供します。特に、数値や日付の表示形式を細かく制御したい場合や、多数の値を一つの文字列に整形して埋め込みたい場合に便利です。

[string]::Format() の基本的な構文は以下の通りです。

[string]::Format("<フォーマット文字列>", <値1>, <値2>, ...)

フォーマット文字列の中には、{0}, {1}, {2}, … のように、埋め込みたい値のインデックスを示すプレースホルダーを記述します。これらのプレースホルダーには、特定の書式を指定することもできます。

例：

“`powershell
$name = “Alice”
$age = 30
$message = [string]::Format(“Name: {0}, Age: {1}”, $name, $age)
Write-Host $message # 出力: Name: Alice, Age: 30

数値の書式指定

$price = 123.4567
$formattedPrice = [string]::Format(“Price: {0:C2}”, $price) # C2: 通貨、小数点以下2桁
Write-Host $formattedPrice # 出力例 (環境による): Price: $123.46

日付の書式指定

$now = Get-Date
$formattedDate = [string]::Format(“Today is {0:yyyy-MM-dd}, Time is {0:HH:mm:ss}”, $now) # 日付/時刻の書式
Write-Host $formattedDate # 出力例: Today is 2023-10-27, Time is 10:30:00
“`

[string]::Format() は、書式指定によって数値や日付の表示をローカライズしたり、小数点以下の桁数を制御したり、ゼロ詰めを行ったりと、柔軟な文字列整形が可能です。書式指定子の詳細については、.NETの標準数値書式指定文字列や標準日付書式指定文字列のドキュメントを参照してください。

このメソッドは、フォーマット文字列と値のリストが明確に分離されるため、多くの値を埋め込む場合でも比較的コードが読みやすくなります。また、内部的には効率的な文字列構築が行われるため、パフォーマンスも良好です。

[System.Text.StringBuilder] クラス

大量の文字列を、特にループの中で繰り返し結合して大きな一つの文字列を構築する場合、+演算子や+=演算子はパフォーマンス上の大きな問題を引き起こします。前述の通り、これは文字列が変更不可能であるため、結合のたびに新しい文字列オブジェクトが生成されるためです。この問題に対する最も効率的な解決策が、.NET Framework の System.Text.StringBuilder クラスを使用することです。

StringBuilder クラスは、内部的に可変長の文字バッファを持っており、文字列を追加しても新しい文字列オブジェクトを都度生成するのではなく、バッファに文字を追加していくだけです。バッファがいっぱいになった場合にのみ、より大きなバッファを割り当てて内容をコピーしますが、これは文字列結合のたびに新しいオブジェクトを生成するよりはるかに効率的です。

StringBuilder を使う基本的な手順は以下の通りです。

1. New-Object System.Text.StringBuilder または [System.Text.StringBuilder]::new() で StringBuilder オブジェクトを作成します。
2. .Append() メソッドを繰り返し呼び出して、構築したい文字列を追加します。
3. .ToString() メソッドを呼び出して、最終的に結合された文字列を取得します。

例：

“`powershell

パフォーマンスが悪い例 (+演算子をループで使う)

Write-Host “— Using + operator (inefficient for large loops) —”
Measure-Command {
$result = “”
for ($i = 1; $i -le 10000; $i++) {
$result += “Line $i`n”
}
# Write-Host $result # 出力が多すぎるためコメントアウト
}

Write-Host “n--- Using StringBuilder (efficient) ---"
Measure-Command {
$sb = New-Object System.Text.StringBuilder
for ($i = 1; $i -le 10000; $i++) {
$sb.Append("Line $i").Append("n”) # または $sb.AppendLine(“Line $i”)
}
$resultSb = $sb.ToString()
# Write-Host $resultSb # 出力が多すぎるためコメントアウト
}
“`

上記の例で Measure-Command の出力を見ると、ループ回数が多いほど StringBuilder を使用した方が圧倒的に高速であることが確認できます。（10000回程度でも顕著な差が出始め、10万回、100万回となると差は決定的になります）。

.Append() メソッドは StringBuilder オブジェクト自身を返すため、上記の例のようにメソッドチェーンを使って複数の要素を続けて追加することも可能です。

改行を頻繁に追加する場合は、.AppendLine() メソッドが便利です。これは指定した文字列を追加した後、現在の環境に適した改行コード（Windowsでは\r\n、Linuxでは\n）を追加します。

powershell
$sb = New-Object System.Text.StringBuilder
$sb.AppendLine("First line.")
$sb.AppendLine("Second line.")
$finalString = $sb.ToString()
Write-Host $finalString

出力：

First line.
Second line.

StringBuilder は、大量のテキストを動的に生成する場合（例: ログファイルの内容、レポート、巨大なコマンドライン引数など）において、パフォーマンスを最優先したい場合に選ぶべき方法です。欠点としては、他の方法に比べて記述がやや冗長になることですが、パフォーマンスが求められる場面ではその価値は非常に高いです。

Here-Strings (@”…”)

Here-Strings は、複数行にわたる文字列リテラルを簡単に定義するための方法です。@" または '@ で始まり、対応するクォートと @ で終わります。開始マーカーと終了マーカーは、それぞれ行の先頭と行の最後に単独で配置する必要があります。

ダブルクォートHere-String (@"..."@) は、通常のダブルクォート文字列と同様に変数展開とエスケープシーケンス（ただし、\を使ったものは通常通り、Here-String自体をエスケープする方法は異なる）が可能です。

例：

powershell
$name = "Alice"
$message = @"
Hello, $name!
This is a multi-line message.
It can include variables like $name.
It also supports special characters like quotes ("Example") and tabs (`t).
"@
Write-Host $message

出力：

Hello, Alice!
This is a multi-line message.
It can include variables like Alice.
It also supports special characters like quotes ("Example") and tabs ( ).

シングルクォートHere-String (@'...'@) は、通常のシングルクォート文字列と同様に、完全にリテラルとして扱われ、変数展開やエスケープシーケンスは行われません。

例：

powershell
$name = "Alice"
$message = @'
Hello, $name!
This is a multi-line message.
Variables like $name are NOT expanded here.
@'
Write-Host $message

出力：

Hello, $name!
This is a multi-line message.
Variables like $name are NOT expanded here.

Here-Strings は、設定ファイルの内容、スクリプトのヘルプテキスト、SQLクエリ、HTML/XML/JSONのテンプレートなど、まとまったテキストブロックをコード内に埋め込むのに非常に便利です。ダブルクォートHere-Stringを使えば、そのテキストブロックの中に変数や式を埋め込むことができるため、これも一種の文字列結合・整形の方法と言えます。

Here-Stringを使用する際の注意点として、開始マーカー @" または '@ はその行で最初の非空白文字である必要があり、終了マーカー @ もその行で最後の非空白文字である必要があります。また、終了マーカーの後ろにスペースを入れてはいけません。

各方法の比較と選び方

PowerShellにおける文字列結合の様々な方法を見てきました。どの方法を選ぶべきかは、状況によって異なります。考慮すべき主な要素は以下の通りです。

1. シンプルさ・可読性: コードの読みやすさと記述の容易さ。
2. パフォーマンス: 実行速度。特に繰り返し処理や大量の文字列を扱う場合。
3. 機能: 変数展開、書式指定、パス結合など、特定機能の要不要。
4. 文字列のサイズと結合回数: 短い文字列を数回結合するのか、長い文字列を何度も結合するのか。

以下に、各方法の簡単な比較と使い分けの指針を示します。

• + 演算子:

  • 特徴: 最もシンプルで直感的。
  • 利点: 短く記述できる。
  • 欠点: 大量の文字列を繰り返し結合する場合のパフォーマンスが非常に悪い。
  • 使いどころ: 短い文字列を数個結合する場合。単純な固定文字列と変数の結合。

• += 演算子:

  • 特徴: 既存変数への文字列追加。
  • 利点: 変数への追加が明確。
  • 欠点: +演算子と同様にパフォーマンスが悪い。
  • 使いどころ: 短い文字列に少しずつ内容を追加する場合。ただし、ループ内での使用は避けるべき。

• 配列と Join / [string]::Join():

  • 特徴: 複数の要素を区切り文字で結合。
  • 利点: 配列やリストの要素を結合するのに最適。区切り文字の指定が容易。+演算子より効率的。
  • 欠点: 一度配列として要素を用意する必要がある。
  • 使いどころ: 要素のリスト（ファイルリスト、パラメータリストなど）を単一文字列に変換する場合。

• 補間文字列 ("..."内の変数展開/$()):

  • 特徴: ダブルクォート文字列内に変数や式を埋め込み。
  • 利点: 可読性が非常に高い。記述がシンプル。多くの場合でパフォーマンスも良好。$()で複雑な式も展開可能。
  • 欠点: フォーマットの指定は限定的（[string]::Formatほど細かくない）。大量の文字列結合にはStringBuilderが優れる場合がある。
  • 使いどころ: 短い～中程度の文字列に変数や簡単な式の値を埋め込む場合。ログメッセージ、簡単な出力文字列など。最も頻繁に使われる方法の一つ。

• Join-Path:

  • 特徴: パス文字列の結合に特化。
  • 利点: OSに依存しない安全なパス結合。不要な区切り文字を自動調整。堅牢性が高い。
  • 欠点: パス以外の文字列結合には使えない。
  • 使いどころ: ファイルパスやディレクトリパスを構築する場合。

• [string]::Format():

  • 特徴: .NETのString.Formatを利用した書式指定付き結合。
  • 利点: 数値、日付、通貨などの詳細な書式指定が可能。複数の値を埋め込む場合の可読性も悪くない。
  • 欠点: +演算子や補間文字列に比べて記述がやや冗長。
  • 使いどころ: 出力文字列の書式を細かく制御したい場合。レポート生成、表示用文字列の整形など。

• [System.Text.StringBuilder]:

  • 特徴: 多数の文字列を効率的に結合するためのクラス。
  • 利点: 大量の文字列を繰り返し結合する場合に最高のパフォーマンスを発揮。メモリ効率も良い。
  • 欠点: 他の方法に比べて記述が冗長。最終的に.ToString()を呼び出す必要がある。
  • 使いどころ: ループ処理などで大量の文字列を動的に生成・結合する場合。巨大なログファイルや設定ファイルの文字列を構築する場合。

• Here-Strings (@"...@", @'...'@):

  • 特徴: 複数行文字列の定義。
  • 利点: 長文や構造化されたテキストをコード内に分かりやすく埋め込める。ダブルクォート版は変数展開も可能。
  • 欠点: 変数展開や式の評価以外の結合機能は持たない。インデントに注意が必要。
  • 使いどころ: スクリプト内の大きなテキストブロック（ヘルプ、設定ファイル、SQLクエリ、テンプレートなど）を定義する場合。変数展開を利用して簡易的なテンプレートとしても使える。

これらの方法を適切に組み合わせることもよくあります。例えば、補間文字列の中でJoin-Pathの結果を使用したり、StringBuilderで構築した文字列を最終的に[string]::Format()で整形したりといったことが考えられます。

一般的には、以下の流れで選択を検討すると良いでしょう。

1. パス結合が必要か？ -> Join-Path を最優先で検討。
2. 複数行にわたる長文、または構造化されたテキストブロックか？ -> Here-Strings を検討。変数展開が必要ならダブルクォート版。
3. 多数の文字列を繰り返し結合する（特にループ内）か？ -> [System.Text.StringBuilder] を使用。
4. 数値や日付などの詳細な書式指定が必要か？ -> [string]::Format() を検討。
5. 配列やリストの要素を区切り文字で結合したいか？ -> Join 演算子または [string]::Join() を使用。
6. 上記以外の場合 -> 補間文字列 ("...") を検討。ほとんどの日常的な文字列結合で十分な機能とパフォーマンス、高い可読性を提供します。もし非常に単純で変数展開も不要なら、+演算子やシングルクォートも選択肢に入りますが、通常は補間文字列で事足ります。

パフォーマンスに関する詳細

文字列のイミュータブル性（変更不可能性）が、なぜ + 演算子や += 演算子による多数の文字列結合でパフォーマンスの問題を引き起こすのか、そして StringBuilder がなぜ効率的なのかをもう少し掘り下げて説明します。

文字列のイミュータブル性 (System.String)

.NET Framework の System.String クラスで表現される文字列は、イミュータブルな型です。これは、一度文字列オブジェクトが作成されると、その内容（文字の並び）を変更することはできないという意味です。

例えば、$a = "Hello" という文字列があるとします。この文字列に対して $a += " World" という操作を行うと、文字列変数 $a の内容が “Hello World” に変更されたように見えます。しかし内部的には、元の文字列 “Hello” はそのままメモリに残っており、新たに “Hello World” という内容を持つ新しい文字列オブジェクトがメモリに作成され、変数 $a がその新しいオブジェクトを参照するように変更されるのです。元の “Hello” という文字列オブジェクトは、もはやどこからも参照されなくなれば、ガベージコレクションによってメモリから解放される対象となります。

このメカニズムが、ループ内で += 演算子を使って文字列を繰り返し追加する場合に問題となります。ループが1回実行されるごとに、元の文字列と追加する文字列を結合した新しい文字列オブジェクトが生成されます。文字列が長くなるにつれて、この新しいオブジェクトの作成と古いオブジェクトの破棄にかかるコストが増大します。N回の結合を行う場合、合計でN個の新しい文字列オブジェクトと、N-1個の古い文字列オブジェクトが生成・破棄されることになり、オブジェクト生成とガベージコレクションのオーバーヘッドが無視できなくなります。

StringBuilderの仕組み (System.Text.StringBuilder)

一方、System.Text.StringBuilder クラスは、ミュータブルな（変更可能な）文字列を扱います。StringBuilder オブジェクトは、内部に文字を格納するためのバッファ（配列のようなもの）を持っています。このバッファは、必要に応じてサイズを拡張することができます。

.Append() メソッドを呼び出すと、追加したい文字列が内部のバッファの末尾に書き込まれます。バッファに十分な空き領域があれば、この操作は非常に高速で、新しい文字列オブジェクトの生成は伴いません。バッファがいっぱいになった場合は、StringBuilder はより大きなサイズの新しいバッファを内部的に割り当て、既存のバッファの内容を新しいバッファにコピーしてから、新しい文字列を追加します。このバッファの再割り当てとコピーの操作はコストがかかりますが、文字列結合のたびに発生するわけではなく、バッファが満杯になったときだけ発生します。したがって、多数の文字列追加操作を行っても、オブジェクト生成とガベージコレクションの頻度を大幅に減らすことができるため、+ 演算子を使うよりはるかに効率的になります。

デフォルトの初期バッファサイズは小さめですが、事前に必要な文字列のおおよその長さを見積もってコンストラクタで初期容量を指定することで、バッファの再割り当て回数を減らし、さらにパフォーマンスを最適化することも可能です。

例：

“`powershell

10000文字程度の文字列を構築するとわかっている場合

$sb = New-Object System.Text.StringBuilder(10000)

または [System.Text.StringBuilder]::new(10000)

“`

ベンチマーク例

実際のコードで、+ 演算子と StringBuilder のパフォーマンス差を確認してみましょう。ここでは、10000行のテキストを生成する簡単な例で比較します。

“`powershell

ベンチマークの設定

$iterations = 10000 # 繰り返し回数

Write-Host “Measuring performance for $iterations iterations…”
Write-Host “— + Operator —”
$plusTime = Measure-Command {
$result = “”
for ($i = 1; $i -le $iterations; $i++) {
$result += “Line $i`n”
}
}
Write-Host “TotalMilliseconds: $($plusTime.TotalMilliseconds)”

Write-Host “— StringBuilder —”
$sbTime = Measure-Command {
$sb = New-Object System.Text.StringBuilder
for ($i = 1; $i -le $iterations; $i++) {
$sb.Append(“Line $i”).Append(“`n”) # または $sb.AppendLine(“Line $i”)
}
$resultSb = $sb.ToString()
}
Write-Host “TotalMilliseconds: $($sbTime.TotalMilliseconds)”

Write-Host “— [string]::Join —“

Joinで結合するために、要素を先に配列に入れる必要がある

$joinTime = Measure-Command {
$lines = for ($i = 1; $i -le $iterations; $i++) { “Line $i” }
$resultJoin = $lines -join “`n”
}
Write-Host “TotalMilliseconds: $($joinTime.TotalMilliseconds)”

Write-Host “— Interpolated String (simple loop) —“

補間文字列を単純なループで使う場合

$interpTime = Measure-Command {
$result = “”
for ($i = 1; $i -le $iterations; $i++) {
$result += “Line $i`n”
}
}

注：上記のコードは実質的に+演算子と同じ方法で文字列を構築しているため、パフォーマンスも同程度になる。

補間文字列自体が遅いわけではなく、文字列を繰り返し追加するパターンが非効率。

Write-Host “— Interpolated String (pre-build array, then Join) —“

補間文字列で要素を生成し、最後にJoinで結合

$interpJoinTime = Measure-Command {
$lines = for ($i = 1; $i -le $iterations; $i++) { “Line $i” }
$resultInterpJoin = “$($lines -join “n")n” # 補間文字列内でJoinを使用
}
Write-Host “TotalMilliseconds: $($interpJoinTime.TotalMilliseconds)”

注：これも結局Joinを使っているので、Joinのパフォーマンスに近い。

Write-Host “— [string]::Format (simple loop) —“

Formatを単純なループで使う場合

$formatTime = Measure-Command {
$result = “”
for ($i = 1; $i -le $iterations; $i++) {
$result += [string]::Format(“Line {0}`n”, $i)
}
}

注：これも実質的に+演算子と同じ方法で文字列を構築しているため、パフォーマンスも同程度になる。

“`

実行結果の傾向 (環境によって数値は変動します)

方法	100回	1000回	10000回	100000回
+ Operator / += Operator	短い	中程度	長い	非常に長い
StringBuilder	短い	短い	短い	短い
[string]::Join / -join (配列生成含む)	短い	短い	中程度	長い（配列生成のコスト）
補間文字列 (繰り返し追加)	短い	中程度	長い	非常に長い
[string]::Format (繰り返し追加)	短い	中程度	長い	非常に長い

StringBuilder は繰り返し回数が増えても処理時間の増加が比較的緩やかです。一方、+ 演算子や += 演算子、そしてこれらと同様に繰り返し追加を行う補間文字列や[string]::Formatをループ内で使用する方法は、繰り返し回数が増えるにつれて処理時間が急激に増加します。

[string]::Join は、要素を事前に配列に格納するコストがありますが、その後の結合自体は効率的です。要素数が非常に多くなると、配列の構築自体に時間がかかるようになります。

結論として、大量の文字列をループで結合する場合は、迷わず [System.Text.StringBuilder] を使用すべきです。 短い文字列を数回結合する程度であれば、+ 演算子や補間文字列を使うのが最もシンプルで可読性が高いため推奨されます。

実践的な応用例

文字列結合は、PowerShellスクリプトの様々な場面で活用されます。ここでは、いくつかの具体的な応用例を紹介します。

ログメッセージの生成

日時、ログレベル、メッセージ本文などを結合してログファイルに出力する文字列を生成する場合、補間文字列や[string]::Format()が便利です。

“`powershell
function Write-Log {
param(
[string]$Level = “INFO”,
[string]$Message
)
$timestamp = Get-Date -Format “yyyy-MM-dd HH:mm:ss”
# 補間文字列を使用
$logEntry = “$timestamp – [$Level] $Message”

# または [string]::Format を使用
# $logEntry = [string]::Format("{0} - [{1}] {2}", $timestamp, $Level, $Message)

Write-Host $logEntry # 実際には Out-File などに出力

}

Write-Log -Level “INFO” -Message “Application started successfully.”
Write-Log -Level “WARNING” -Message “Disk space low on C: drive.”
Write-Log -Level “ERROR” -Message “Failed to connect to database.”
“`

ファイルパスの構築

ログ出力先や設定ファイルのパスなど、スクリプトが扱うファイルのパスを構築する場合、Join-Pathを使用することでOS間の互換性を保ちつつ安全に結合できます。

“`powershell
$baseDir = “$PSScriptRoot\Logs” # スクリプトがあるディレクトリのLogsフォルダ
$logFileName = “system_$((Get-Date -Format ‘yyyyMMdd’)).log” # 日付入りのファイル名
$logFilePath = Join-Path -Path $baseDir -ChildPath $logFileName

Write-Host “Log file path: $logFilePath”

ディレクトリが存在しない場合は作成

if (-not (Test-Path -Path $baseDir -PathType Container)) {
New-Item -Path $baseDir -ItemType Directory -Force
Write-Host “Created log directory: $baseDir”
}

ログをファイルに追記

“Some log message.” | Out-File -Path $logFilePath -Append -Encoding UTF8

“`

この例では、補間文字列でファイル名の一部を生成し、その結果をJoin-Pathに渡しています。このように複数の方法を組み合わせることも一般的です。

SQLクエリ文字列の構築

データベース操作を行う際に、パラメータを含むSQLクエリ文字列を構築することがあります。Here-Stringを使うと、複数行にわたる長いクエリもコード内に分かりやすく記述できます。ただし、セキュリティ上の理由から、ユーザー入力を直接クエリ文字列に埋め込むことは絶対に避けるべきです（SQLインジェクションの危険）。パラメータ化クエリを使用するのが正しい方法ですが、ここでは文字列結合の例として単純なケースを示します。

“`powershell
$tableName = “Users”
$userId = 101 # ユーザー入力などの可変値

文字列結合でクエリを構築（非推奨！SQLインジェクションの危険あり）

$queryBad = “SELECT * FROM $tableName WHERE UserID = $userId;”
Write-Host “Bad Query: $queryBad”

Here-String と補間文字列でクエリを構築 (パラメータ化クエリの模倣)

実際にはDBコネクタのパラメータ機能を使うべき

$queryGoodTemplate = @”
SELECT
UserID,
UserName,
Email
FROM
$tableName
WHERE
UserID = {0};
“@

$queryGood = [string]::Format($queryGoodTemplate, $userId)
Write-Host “Good Query (using Format):`n$queryGood”
“`

パラメータ化クエリを使用するシステムでは、クエリ文字列のテンプレートとパラメータの値を分離して渡し、データベースAPIが安全にパラメータを処理します。PowerShellからADO.NETなどを利用する場合も、パラメータオブジェクトを使用するのが推奨されます。上記の例はあくまで文字列結合・整形の方法を示すものであり、実際のセキュリティ要件を満たすものではないことに注意してください。

コマンドライン引数の構築

外部プログラムを実行する際に、可変の引数を文字列として渡す必要がある場合があります。引数を配列として準備しておき、Join演算子でスペース区切りに結合するのが一般的です。

“`powershell
$program = “mytool.exe”
$argument1 = “–input”
$value1 = “data.csv”
$argument2 = “–output”
$value2 = “result.txt”
$flags = @(“-verbose”, “-force”)

すべての引数を配列に格納

$arguments = @(
$argument1, $value1,
$argument2, $value2,
$flags # 配列をそのまま追加すると要素が展開される
)

配列の要素をスペースで結合して一つの文字列にする

$argumentString = $arguments -join ” “

Write-Host “Program: $program”
Write-Host “Arguments String: $argumentString”

実際には以下のように外部コマンドを実行

& $program $arguments # 配列のままでも実行できる場合が多いが、文字列として渡す必要がある場合もある

& $program $argumentString

“`

PowerShellの Start-Process や & 呼び出し演算子は、引数を文字列の配列として渡すことを推奨しており、その場合はPowerShellが適切にクォートなどを処理してくれます。しかし、特定の外部プログラムが引数を単一の文字列としてしか受け付けない場合などには、上記のように文字列として結合する必要があります。その際、各引数が適切にクォートされる必要があるかどうかは、実行する外部プログラムの引数解析方法に依存するため注意が必要です。

HTML/XML/JSONなどのデータ生成

スクリプトから簡単なデータファイル（HTML、XML、JSONなど）を文字列として出力する場合、Here-StringやStringBuilderが役立ちます。Here-Stringは構造を分かりやすく記述でき、StringBuilderは大量のデータを効率的に出力するのに適しています。

“`powershell
$data = @(
@{ Name = “ItemA”; Value = 100 },
@{ Name = “ItemB”; Value = 200 }
)

簡単なHTMLテーブルをHere-Stringで生成

$htmlTable = @”

$(
# $() サブエクスプレッションの中でループと文字列結合
$sbBody = New-Object System.Text.StringBuilder
foreach ($item in $data) {
$sbBody.AppendLine(”

“)
$sbBody.AppendLine(”

“)
$sbBody.AppendLine(”

“)
$sbBody.AppendLine(”

“)
}
$sbBody.ToString() # StringBuilderの結果を$()の中に埋め込む
)

Name	Value
$($item.Name)	$($item.Value)

“@
Write-Host $htmlTable
“`

この例では、Here-Stringの中に $() サブエクスプレッションを使い、その中で StringBuilder を利用してテーブルの行を動的に生成しています。このように、複数の強力な機能を組み合わせて使用することで、複雑な文字列生成タスクも効率的に行うことができます。

よくある落とし穴と解決策

文字列結合を行う際に、いくつかのよくある問題や誤解があります。これらを理解しておくことで、意図しない挙動やエラーを防ぐことができます。

シングルクォート内での変数展開の誤解

最もよくある間違いの一つが、シングルクォートで囲まれた文字列内で変数展開が行われると期待してしまうことです。

“`powershell
$userName = “guest”
$path = ‘C:\Users\$userName\Documents’ # 間違い！

Write-Host $path # 出力: C:\Users\$userName\Documents
“`

解決策: 変数を展開したい場合は、ダブルクォート (") を使用するか、文字列結合 (+ や補間文字列) を使用します。

“`powershell
$userName = “guest”
$pathDouble = “C:\Users\$userName\Documents” # ダブルクォートで展開

Write-Host $pathDouble # 出力: C:\Users\guest\Documents

または + 演算子で結合

$pathPlus = ‘C:\Users\’ + $userName + ‘\Documents’
Write-Host $pathPlus # 出力: C:\Users\guest\Documents

または補間文字列として記述

$pathInterpolated = “C:\Users\$userName\Documents”
Write-Host $pathInterpolated # 出力: C:\Users\guest\Documents
“`

パス結合の場合は、Join-Path が最も安全で推奨されます。

“`powershell
$userName = “guest”

env:USERNAME 環境変数を使う方が一般的

$userProfile = Join-Path -Path (Join-Path -Path $env:SystemDrive -ChildPath “Users”) -ChildPath $userName
$documentsFolder = Join-Path -Path $userProfile -ChildPath “Documents”
Write-Host $documentsFolder # 出力例: C:\Users\guest\Documents
“`

変数の周囲の文字との区別（曖昧な変数名）

前に触れたように、ダブルクォート文字列内で変数名の直後に変数名の一部と解釈されうる文字が続く場合、PowerShellが変数名の境界を誤認識することがあります。

“`powershell
$name = “Report”
$extension = “.log”

$name$extension という変数を探そうとする

$fileName = “$name$extension” # 意図しない結果になる可能性

$fileName = “${name}${extension}” # 波括弧で変数名を明確にする
Write-Host $fileName # 出力: Report.log
“`

解決策: 変数を波括弧 {} で囲むことで、PowerShellに変数の範囲を明確に伝えます。${Variablename} の形式を使用します。

NULL値や空文字列の扱い

文字列結合において、結合する変数や式の結果が NULL や空文字列 ("") になる可能性があります。PowerShellでは、NULL や空文字列と他の文字列を結合しても、通常はエラーになりませんが、予期しない結果になることがあります。

“`powershell
$prefix = “ID-”
$id = $null # IDが取得できなかった場合などを想定
$suffix = “-END”

$resultNull = $prefix + $id + $suffix # $null は通常空文字列として扱われる
Write-Host “Result with NULL: ‘$resultNull'” # 出力: Result with NULL: ‘ID–END’

$emptyString = “”
$resultEmpty = $prefix + $emptyString + $suffix
Write-Host “Result with Empty: ‘$resultEmpty'” # 出力: Result with Empty: ‘ID–END’
“`

この例では、$id が NULL の場合、ID--END と、区切り文字のハイフンが連続してしまっています。

解決策: 結合前に変数が NULL でないか、または空でないかを確認し、必要に応じてデフォルト値を設定したり、その部分の結合をスキップしたりするロジックを追加します。

“`powershell
$prefix = “ID-”
$id = $null
$suffix = “-END”

$idString = if ($id -ne $null -and $id -ne “”) { $id } else { “N/A” }
$resultHandled = $prefix + $idString + $suffix
Write-Host “Result Handled: ‘$resultHandled'” # 出力: Result Handled: ‘ID-N/A-END’
“`

または、補間文字列内で条件式やnull合体演算子的なものを使うこともできますが、可読性を損なう場合があります。

“`powershell

(Get-Variable id -ErrorAction SilentlyContinue).Value が null でなければそれを使い、null なら ‘N/A’ を使う

$resultInterpolated = “ID-$(( (Get-Variable id -ErrorAction SilentlyContinue).Value ) -replace ‘^$’, ‘N/A’)-END”

よりシンプルに if で分岐して文字列自体を作る方が現実的

“`

データ型の暗黙的な変換

PowerShellは文字列と他の型の変数を + 演算子で結合する際に、他の型を自動的に文字列に変換します。これは通常便利ですが、数値計算を行うつもりが文字列結合になってしまうなど、意図しない結果を招くことがあります。

“`powershell
$a = 10 # Integer
$b = “20” # String

$c = $a + $b # 数値計算ではなく文字列結合になる
Write-Host “Result of 10 + ’20’: $c (Type: $($c.GetType().Name))” # 出力: Result of 10 + ’20’: 1020 (Type: String)

$d = $a + [int]$b # 明示的に型変換すれば数値計算になる
Write-Host “Result of 10 + (int)’20’: $($d) (Type: $($d.GetType().Name))” # 出力: Result of 10 + (int)’20’: 30 (Type: Int32)
“`

解決策: 数値計算を行いたい場合は、結合演算子ではなく算術演算子 (+, -, *, / など) を使用し、必要であれば明示的な型変換 ([int], [double] など) を行います。文字列として扱いたい場合は、変数展開や文字列結合を使用します。使用する演算子の意味を意識することが重要です。

Here-Stringのインデント

Here-Stringは定義する際にインデントを付けると、そのインデントも文字列の一部として含まれてしまいます。特にコードブロックの中でHere-Stringを定義する場合に問題になります。

“`powershell
function Get-SampleText {
$sampleText = @”
This is a sample text.
It has multiple lines.
“@ # <- この@の後ろにスペースがあるとエラーになる

# 間違い！インデントが文字列に含まれてしまう
$indentedText = @"
This text is indented.
The indentation spaces will be included.

“@
Write-Host “— Raw Indented Text —”
Write-Host $indentedText

# 正しい方法：インデントを削除する
# Replaceメソッドで削除（ただしインデントパターンによる）
# この例では行頭の4つのスペースを削除
$cleanedText = $indentedText -replace "`n {4}", "`n"
$cleanedText = $cleanedText.TrimStart() # 最初の行のインデントを削除

Write-Host "--- Cleaned Text ---"
Write-Host $cleanedText

}
Get-SampleText
“`

解決策:
1. Here-Stringの開始マーカー @" または '@ は、行頭に配置します。
2. Here-Stringの終了マーカー @ も、インデントを付けずに行頭に配置します。
3. 文字列の内容をインデントしたい場合は、Here-Stringの内部でスペースやタブを記述します。
4. コード全体のインデントに合わせてHere-Stringの内容もインデントしつつ、実行時にそのインデントを削除したい場合は、.Trim() や .TrimStart(), .Replace() などの文字列メソッドを使用して後処理を行います。PowerShell Core (v6以降) や PowerShell 7 では、ConvertFrom-StringData や ConvertFrom-Json のようなコマンドレットがHere-String内のインデントを自動的に無視してくれる場合があります。

“`powershell

インデントを考慮したHere-Stringと処理

function Get-CleanedText {
# Here-Stringの内容は通常通りインデントなしで記述
$rawText = @”
This is a sample text.
It has multiple lines.
This line is intentionally indented within the string.
“@
# $rawText を使用する処理…
Write-Host “— Raw Text —”
Write-Host $rawText

# インデント削除の例 (ここでは不要だが、コードブロック内で定義する場合は必要になることがある)
# $cleanedText = $rawText.Trim() # 両端の空白行やスペースを削除
# Write-Host "--- Cleaned Text ---"
# Write-Host $cleanedText

}
Get-CleanedText
“`

まとめ

PowerShellにおける変数と文字列の結合は、スクリプト作成の基礎でありながら、その方法には多様性があり、それぞれに最適な使いどころが存在します。

• 最もシンプルで直感的なのは + 演算子ですが、パフォーマンスに注意が必要です。
• ダブルクォート文字列における補間文字列 ($variable, $() サブエクスプレッション) は、可読性が高く、多くの日常的な場面で効率的です。
• パス結合には、OSの違いを吸収し安全性を高める Join-Path コマンドレットが最適です。
• 書式を細かく制御したい場合は、.NET の機能を利用した [string]::Format() メソッドが強力です。
• 大量の文字列を、特にループの中で繰り返し結合して大きな文字列を構築する場合は、[System.Text.StringBuilder] クラスが最高のパフォーマンスを発揮します。
• 複数行にわたる長文や構造化されたテキストを扱う場合は、Here-Stringsがコードの可読性を高めます。

これらの方法のどれを選ぶかは、結合する文字列の量、結合の頻度、必要な機能（書式、パス処理など）、そしてコードの可読性に関する要求によって判断します。特にパフォーマンスが重要な場面では StringBuilder を積極的に活用し、それ以外の多くの場合ではシンプルで読みやすい補間文字列を選ぶのが良いプラクティスと言えるでしょう。

この記事を通じて、PowerShellでの文字列結合に関する様々な技術とその使い分け、さらにはパフォーマンスの考慮事項について理解を深めていただけたなら幸いです。効果的な文字列操作スキルは、より堅牢で効率的なPowerShellスクリプトを作成するために不可欠です。是非、これらの知識を日々のスクリプト作成に活かしてください。

---