Strings, Interpolation, Here-Strings, Formatting, and Encoding

1. A string is text data; quoting decides whether PowerShell expands it

Strings appear everywhere in automation: paths, log messages, HTTP headers, command arguments, configuration values, and file content. PowerShell has two primary quoting styles. A single-quoted string is verbatim for variable expansion: characters such as $ are treated literally. A double-quoted string is expandable: variable references and subexpressions are evaluated before the final string is produced.

$app = 'catalog-api'

'Deploying $app'
"Deploying $app"

Deploying $app
Deploying catalog-api

Choose single quotes when the text should stay literal. Choose double quotes when you intentionally want interpolation. This decision is safer than using double quotes everywhere and escaping every dollar sign you did not mean to expand.

2. Interpolation can insert a variable directly; richer expressions use $()

A simple variable reference can be embedded directly in a double-quoted string. Property access, indexing, arithmetic, or command execution inside a string requires a subexpression, written $(...).

$build = [pscustomobject]@{
    App = 'catalog-api'
    Version = '2.7.1'
    Replicas = 3
}

"App: $($build.App)"
"Release: $($build.App):$($build.Version)"
"Next replica count: $($build.Replicas + 1)"
"Generated at: $(Get-Date -Format 'yyyy-MM-ddTHH:mm:ssK')"

The subexpression is evaluated first, then its result is converted to text and inserted. This lets you keep calculations typed until the exact point where you need a string.

3. Braces separate a variable name from neighboring text

Sometimes PowerShell cannot tell where a variable name should end. Braces make the boundary explicit.

$name = 'worker'
"${name}-blue"
"${HOME}: user home"

The second form matters because a colon immediately after a variable name can be interpreted as part of scope/provider-style variable syntax. Bracing the name says exactly which variable should be expanded.

4. Escape only what must be escaped

The PowerShell escape character is the backtick (`). Inside double-quoted strings it introduces escape sequences such as newline `n, carriage return `r, tab `t, and an escaped dollar sign `$. Single-quoted strings do not interpret these backtick escape sequences.

"first line`nsecond line"
"literal dollar: `$HOME"
'backtick stays literal here: `n'

Do not reach for the backtick first. Often a different quoting style is clearer. If a JSON fragment needs double quotes but no interpolation, place it in a single-quoted PowerShell string. If a message needs apostrophes but interpolation, use double quotes.

$jsonSnippet = '{"mode":"safe","enabled":true}'
$owner = 'platform'
"Owner's deployment: $owner"

5. Here-strings make multi-line text readable

A here-string is one string that spans multiple lines. The delimiter starts with @ plus a quote and ends with the quote plus @ on its own line. Double-quoted here-strings expand variables; single-quoted here-strings preserve them literally.

$app = 'catalog-api'
$version = '2.7.1'

$expanded = @"
application=$app
version=$version
generated=$(Get-Date -Format 'yyyy-MM-dd')
"@

$literal = @'
application=$app
version=$version
'@

$expanded
$literal

Here-strings are useful for templates, test fixtures, help text, and configuration snippets. They are still plain strings; if the target format is JSON, XML, or YAML, prefer structured serializers when possible rather than manually concatenating complex documents.

6. The -f format operator separates a format template from values

The -f operator uses .NET composite formatting. Place numbered placeholders such as {0} and {1} in a format string, then provide values on the right.

$app = 'catalog-api'
$duration = [timespan]::FromSeconds(83.4)
$ratio = 0.7342

'app={0}; elapsed={1:N1}s; success={2:P1}' -f `
    $app, $duration.TotalSeconds, $ratio

The visible numeric rendering can be culture-sensitive because formatting is a human/text concern. For machine contracts, prefer a stable serializer or explicit invariant formatting. The format operator is excellent for log messages and reports where the template is easier to scan than several concatenations.

7. Join-String turns pipeline objects into one intentional string

Join-String combines pipeline input into a single string and can extract a property from each object. It is often clearer than manually building separators in a loop.

$targets = [pscustomobject]@{ Name='api'; Region='eu' },
           [pscustomobject]@{ Name='worker'; Region='us' },
           [pscustomobject]@{ Name='web'; Region='eu' }

$targets | Join-String -Property Name -Separator ', '
$targets | Join-String -Property Region -Separator ' | ' -OutputPrefix '[' -OutputSuffix ']'

api, worker, web
[eu | us | eu]

Remember the object-pipeline rule from Chapter 03: joining is a text boundary. Do it when the next consumer needs a single string, not while downstream commands still need structured properties.

8. Whitespace and newline assumptions can become cross-platform bugs

A string can contain spaces and newline characters that are hard to see on screen. Windows commonly uses carriage-return plus line-feed for text files, while Unix-like systems conventionally use line-feed. PowerShell and .NET provide abstractions so scripts do not need to hard-code every host convention.

$raw = "  api.example.test  `n"
$trimmed = $raw.Trim()

"[$raw]"
"[$trimmed]"
[Environment]::NewLine.Length

Use Trim() only when surrounding whitespace is semantically irrelevant. Do not blindly trim secrets, signatures, or fixed-width text where spaces can be meaningful. When generating platform-neutral protocol data, follow the protocol specification rather than the local OS newline convention.

9. Encoding maps characters to bytes at file and native-tool boundaries

Inside PowerShell/.NET, strings are Unicode text. A file or native process ultimately needs bytes, so an encoding defines how characters map to those bytes. PowerShell 6 and later default text output to UTF-8 without a byte-order mark (BOM), and PowerShell 7 supports explicit encodings such as utf8, utf8BOM, unicode, and ascii. Windows PowerShell 5.1 has different, inconsistent defaults, which is one reason this course treats it as a compatibility environment.

$lab = Join-Path ([IO.Path]::GetTempPath()) 'ps-academy-ch04-l03'
New-Item -ItemType Directory -Path $lab -Force | Out-Null

$path = Join-Path $lab 'message.txt'
"release=2.7.1; note=✓" | Set-Content -LiteralPath $path -Encoding utf8

Get-Content -LiteralPath $path -Raw
Format-Hex -LiteralPath $path | Select-Object -First 4

Specify encoding when another tool or file contract requires one. “It looks correct in my terminal” does not prove the bytes will be interpreted correctly by a CI runner, compiler, legacy Windows utility, or Unix command.

10. Diagnose quote nesting by deciding which parser owns each character

Complex strings become difficult when PowerShell syntax, another language, and a native command all use quotes. Ask which layer is responsible for each quote. If you are creating structured data, prefer a serializer. If you are passing native arguments, keep arguments as separate values as taught in Chapter 02.

# Prefer object -> serializer over hand-built JSON text.
$payload = [pscustomobject]@{
    app = 'catalog-api'
    enabled = $true
}

$json = $payload | ConvertTo-Json -Compress
$json

Manual quote escaping scales poorly because each additional syntax layer adds another set of rules. Preserve structure as long as possible.

11. Lab: produce a readable deployment message and UTF-8 artifact

$lab = Join-Path ([IO.Path]::GetTempPath()) 'ps-academy-ch04-l03'
New-Item -ItemType Directory -Path $lab -Force | Out-Null

$app = 'catalog-api'
$version = [version]'2.7.1'
$targets = 'api-01', 'api-02', 'api-03'
$generated = Get-Date

$targetText = $targets | Join-String -Separator ', '
$report = @"
Application : $app
Version     : $version
Targets     : $targetText
Generated   : $($generated.ToString('yyyy-MM-ddTHH:mm:ssK'))
Message     : Owner's release is ready; literal token = `$DEPLOY_TOKEN
"@

$reportPath = Join-Path $lab 'release-report.txt'
$report | Set-Content -LiteralPath $reportPath -Encoding utf8

Get-Content -LiteralPath $reportPath -Raw
(Get-Item -LiteralPath $reportPath).Length

# Preview cleanup first.
Remove-Item -LiteralPath $lab -Recurse -WhatIf
# After verifying the path, run:
# Remove-Item -LiteralPath $lab -Recurse

12. Knowledge check

13. Summary

String syntax is easiest to reason about when you first decide whether the text should be literal or expandable. Use single quotes for verbatim intent, double quotes for interpolation, $() for richer expressions, braces to make variable boundaries explicit, and here-strings for readable multi-line text. Keep objects structured until text is genuinely required, then choose deliberate formatting and encoding so files, native tools, and CI systems interpret the same bytes you intended.

14. Further reading

• Microsoft Learn — about_Quoting_Rules
• Microsoft Learn — about_Special_Characters
• Microsoft Learn — about_Character_Encoding
• Microsoft Learn — Join-String
• Microsoft Learn — about_Operators (-f operator)