PowerShell string interpolation syntax

I always used the following syntax to be sure that variable were expanded in a string:

"my string with a $($variable)"

I recently ran into the following syntax:

"my string with a ${variable}"

Are they equivalent? Any difference?

3 Answers

To complement marsze's helpful answer:

${...} (enclosing the variable name in { and }) is indeed always necessary if a variable name contains special characters, such as spaces, ., or -.

• Not special are _ and - surprisingly and problematically - ?.
• Note: : is invariably interpreted as terminating a PowerShell drive reference, in the context of namespace variable notation, irrespective of whether {...} enclosure is used or required (e.g., in $env:USERNAME or ${env:USERNAME}, env refers to the PowerShell drive representing all environment variables).

In the context of string expansion (interpolation) inside "...", there is another reason to use ${...}, even if the variable name itself doesn't need it:

If you need to delineate the variable name from directly following non-whitespace characters, notably including ::

$foo = 'bar' # example variable # INCORRECT: PowerShell assumes that the variable name is 'foobarian', not 'foo' PS> "A $foobarian." A . # Variable $foobarian doesn't exist -> reference expanded to empty string. # CORRECT: Use {...} to delineate the variable name: PS> "A ${foo}barian." A barbarian. # INCORRECT: PowerShell assumes that 'foo:' is a *namespace* (drive) reference # (such as 'env:' in $env:PATH) and FAILS: PS> "$foo: bar" Variable reference is not valid. ':' was not followed by a valid variable name character. Consider using ${} to delimit the name. # CORRECT: Use {...} to delineate the variable name: PS> "${foo}: bar" bar: bar 

See this answer for a comprehensive overview of PowerShell string-expansion rules.

Note that you need the same technique when string expansion is implicitly applied, in the context of passing an unquoted argument to a command; e.g.:

# INCORRECT: The argument is treated as if it were enclosed in "...", # so the same rules apply. Write-Output $foo:/bar # CORRECT Write-Output ${foo}:/bar 

Finally, a somewhat obscure alternative is to `-escape the first character after the variable name, but the problem is that this only works as expected with characters that aren't part of escape sequences (see about_Special_Characters):

# OK: because `: is not an escape sequence. PS> "$foo`: bar" bar: bar # NOT OK, because `b is the escape sequence for a backspace character. PS> "$foo`bar" baar # The `b "ate" the trailing 'r' of the variable value # and only "ar" was the literal part. 

${variable} is the syntax for variable names that include special characters.

(See about_Variables -> Variable names that include special characters )

Example:

${var with spaces} = "value" "var with spaces: ${var with spaces}" 

So in your case it's basically the same as simply writing $variable

Note that $() is helpful for json objects:

"My json property is $($jsonObj.property)"