Command line arguments with a dollar sign

[Tibblez]

Command line arguments sent to a file do not send in full if the argument contains a dollar sign. I have tried every combination of escape character and quote configuration that I can think of. I am not certain if this is specific to the dollar sign but I was able to use single quotes with an exclamation mark in the argument and that worked fine.

I was not able to find any explanation for this in other open issues or the known issues but I apologize if I'm missing something obvious here.

Steps to reproduce

Create a new ps1 file called test.ps1 with this snippet.

param(
[string]$foo
)
write-host $foo

Then calling it from the command line

powershell ./test.ps1 -foo 'Before$After'

Expected behavior

Before$After

Actual behavior

Before

Environment data

> $PSVersionTable
Name                           Value                                                                           
----                           -----                                                                           
PSVersion                      6.0.0-beta                                                                      
PSEdition                      Core                                                                            
BuildVersion                   3.0.0.0                                                                         
CLRVersion                                                                                                     
GitCommitId                    v6.0.0-beta.2                                                                   
OS                             Linux 3.10.0-514.el7.x86_64 #1 SMP Tue Nov 22 16:42:41 UTC 2016                 
Platform                       Unix                                                                            
PSCompatibleVersions           {1.0, 2.0, 3.0, 4.0...}                                                         
PSRemotingProtocolVersion      2.3                                                                             
SerializationVersion           1.1.0.1                                                                         
WSManStackVersion              3.0                                                                             

[SteveL-MSFT]

I believe this is by design. Solution is to use the backtick to escape:

powershell ./test.ps1 -foo 'Before`$After'

[lzybkr]

I'm not sure it's by design.

Compare:

#1 PS>  ./test.ps1 -foo 'Before$After'
Before$After
#2 PS> echoargs ./test.ps1 -foo 'Before$After'
arg 0: <./test.ps1>
arg 1: <-foo>
arg 2: <Before$After>

CommandLine:
"EchoArgs.exe" ./test.ps1 -foo Before$After

#3 PS> powershell -file  ./test.ps1 -foo 'Before$After'
Before$After
#4 PS> powershell -command  ./test.ps1 -foo 'Before$After'
Before

Notice in 1, 2, and 3, $After is preserved. Only in 4 does $After disappear.

I would say we need some more digging before calling this by design - but it does provide a cleaner workaround - use -file.

[mklement0]

To summarize the difference in behavior:

• -File treats its arguments as literal strings, without further interpretation by PowerShell.

• -Command interprets its arguments as if they'd been specified inside PowerShell.

In the case at hand:

• With -File, Before$After is retained as-is, as a literal string.

  • Currently, this categorically prevents passing Boolean values as arguments, because a [bool] / [switch] parameter doesn't accept string values (e.g., $True is passed as if '$True' had been specified) - see Executing powershell script with bool parameter doesnt work #4036.

• With -Command, Before$After is interpreted as an expandable string - as if you had passed it as an argument in argument mode from within PowerShell - and - given that variable $After is not defined - it expands to just Before.

[SteveL-MSFT]

Getting -File for .ps1 and -Command to parse args the same as -Command (so that variables are string literals) is working. Need to figure out how to get scripts without .ps1 extension to work. With the change I'm proposing, "Before$After" needs to escape the $ otherwise expectation is that PowerShell interprets it as the value of the $After variable.

[mklement0]

@SteveL-MSFT: I think it's vital that we align the behavior of -Command with that of -c in POSIX-like shells, which, in short, means:

• The first argument following -Command should be interpreted like a script.

  • If that script needs access to the subsequent arguments, it must use $args or a param() statement to access them.

    • Note: POSIX-like shells bind the first subsequent argument to $0 (rather than $1), whose PowerShell equivalent would be $MyInvocation.MyCommand.Name, but I think it's sensible not to do that in PowerShell.

  • Note that this is a fundamental, breaking change from how -Command functions today, which basically reassembles a PowerShell command line from all the arguments by mere string concatenation (with spaces) and then invokes the result based on PowerShell rules.

• Any subsequent arguments should be treated as literals - just as with -File.

In other words: what follows an ad-hoc script (-Command) or a script file (-File, or by default), are arguments to pass to that ad-hoc script/script file, and they should be processed the same:

• as literals (after potential up-front expansion, depending on the calling shell) - except that $true and $false must also be recognized as Boolean literals (which is currently not the case - see Executing powershell script with bool parameter doesnt work #4036), just as, say 22 is recognized as an [int], if bound to a parameter of that type.

Conversely, anything that should be interpreted according to PowerShell-internal rules, must go directly into the ad-hoc script passed to -Command.

To illustrate the proposed difference:

# Already works this way.
> powershell -noprofile -command '"$HOME"'
/home/jdoe

# This is how it *should* work (currently breaks).
> powershell -noprofile -command '$args' '$HOME'
$HOME