如何将 JSON（字符串数据）传递给 PowerShell？

Question

I'm passing the following as an argument to powershell (v4 on w7):

-debugWrite -fileName SettingsFile -jsonContent { "c": "some setting", "d":  "unknown", "b": "some thing", "a": 1 }

But PS gets hung up on the JSON. I've tried delimiting the \\double-quotes\\ and putting everything after -jsonContent in 'single quotes', but to no avail.

Here is the Windows 7 (PS4) environment PS is running in:

note: "..." obfuscation refers to the same dir. IOW, all files live in the same directory.

A batch file is run, kicking off the whole thing:

    "C:\...\script.bat" > "C:\...\script-output.txt" 2>&1

This runs script.bat and outputs to script-output.txt . script.bat is a long 1-liner:

%WINDIR%\sysnative\windowspowershell\v1.0\powershell.exe -ExecutionPolicy Bypass -File "C:\...\customscript.PS1" --% -fileName DropFileToCreate -jsonContent "{     "c":  "some setting",     "d":  "unknown",     "b":  "some thing",     "a":  1 }" -debugWrite

Legend:

DropFileToCreate - the filename passed to the PS script, used to create a file in same dir.

-jsonContent - A named parameter in the script (see below for header of customscript.PS1 )

In the above example, the JSON is:

"{ "c": "some setting", "d": "unknown", "b": "some thing", "a": 1 }"

-debugWrite - A switch parameter (used here to enable Write-Host debugging)

Finally, a bit of the customscript.PS1 :

Param (
    [Parameter(Mandatory = $True)]
    [String]
    $fileName,
    [Parameter(Mandatory = $True)]
    $jsonContent,
    [Parameter(Mandatory = $False)]
    [Switch]
    $debugWrite = $False
)
[...]

The JSON is easier seen, and spaces explained, if expressed as:

{
 "c": "some setting",
 "d": "unknown",
 "b": "some thing",
 "a": 1 
}

Answer 1

tl;dr

Your overall "..." -enclosed JSON string has embedded " , which must be escaped as \\" (sic; command simplified):

powershell.exe -File "C:\...\customscript.PS1" ... -jsonContent "{ \"c\": \"some setting\", \"d\": \"unknown\", \"b\": \"some thing\", \"a\": 1 }"

Read on for when additional escaping is needed, how -File invocation differs from -Command invocation, and in what way the calling shell (where you call powershell.exe from) matters.

---

Note:

• This answer primarily discusses use of the Windows PowerShell executable, powershell.exe , but it applies analogously to the PowerShell Core executable, pwsh , and there's a section on calling from bash at the bottom.

• The section Calling from PowerShell itself below, specifically the syntax required with -File , applies to passing JSON to other programs such as curl.exe as well.

The required syntax for the PowerShell CLI - that is, invoking powershell.exe with arguments - depends on :

• whether you're calling from cmd.exe (Command Prompt / batch file) or from PowerShell itself (or, in PowerShell Core from a POSIX-like shell such as bash ).

• whether you pass arguments to powershell -Command (inline command) or
  powerShell -File (script path).

Either way, your original attempt could not have worked, because literal { "c": "some setting" ... } cannot be recognized as a single argument , due to containing whitespace and not being enclosed in quotes overall; the command added later, with enclosing "..." , lacks escaping of the embedded " .

The following commands demonstrate the required syntax for the scenarios discussed, using a simplified JSON string.

To make the -File commands runnable, create a script.ps1 file in the current dir. with the following content: ConvertFrom-Json $Args[0]

---

Calling from cmd.exe / a batch file

• Embedded " must be escaped as \\" (even though PowerShell- internally you'd use `" ).

• Important:

  • If the JSON text contains cmd.exe metacharacters (invariably between \\"...\\" runs), you must ^ -escape them individually , because cmd.exe , due to not recognizing \\" as an escaped " , considers these substrings unquoted ; eg, \\"some & setting\\" must be escaped as \\"some ^& setting\\" ; the cmd.exe metacharacters that need escaping here are:
    & | < > ^

• cmd.exe -style environment-variable references such as %USERNAME% are interpolated - cmd.exe has no literal string syntax, it only recognizes "..." , where interpolation does take place, just as in unquoted tokens.
  If you want to pass such a token as-is, ie, to suppress interpolation, the escaping syntax depends on whether you're calling from the command line or a batch file , sadly: use %^USERNAME% from the former, and %%USERNAME%% from the latter - see this answer for the gory details.

• Note how the -Command calls simply add another layer of quoting, by enclosing the "..." string in '...' . This is required, because with -Command PowerShell treats the arguments it receives as PowerShell source code rather than as literal arguments (the latter is what happens with -File ); if it weren't for the enclosing '...' , the overall enclosing "..." would be stripped before interpretation.

With -File :

# With a literal string:
powershell -File ./script.ps1 "{ \"c\": \"some setting\", \"unknown\": \"b\" }"

# With an expandable string (expanded by the caller):
powershell -File ./script.ps1 "{ \"c\": \"some %USERNAME%\", \"unknown\": \"b\" }"

With -Command :

# With a literal string:
powershell -Command ConvertFrom-Json '"{ \"c\": \"some setting\", \"unknown\": \"b\" }"'

# With an expandable string (expanded by the caller):
powershell -Command ConvertFrom-Json '"{ \"c\": \"some %USERNAME%\", \"unknown\": \"b\" }"'

---

Calling from PowerShell itself

• Calling from PowerShell makes the need to escape cmd.exe metacharacters go away, because cmd.exe is not involved.

• PowerShell's string-quoting rules apply, which simplifies matters, although, sadly, you still need to manually \\ -escape embedded " chars. ; see this GitHub issue for background.

  • Update : PowerShell Core 7.2.0-preview.5 introduced an experimental feature , PSNativeCommandArgumentPassing , which obviates the need for this manual \\ -escaping; even though it is very much to be hoped for in this case, experimental features aren't guaranteed to become regular features; as of PowerShell Core 7.2.0-preview.5, the feature is a step in the right direction, but is both buggy and lacks important accommodations for CLIs on Windows - see GitHub issue #15143 .

  • Using outer '...' quoting simplifies the syntax for the embedded quoting, but that limits you to passing literal strings.

  • Using outer "..." allows you to embed variable references and expressions from the caller (which are expanded by the caller , before the argument is passed), but it complicates the syntax, given that an embedded " must then be doubly escaped as \\`" (sic): first with ` to conform to PowerShell- internal syntax, then with \\ to satisfy the PowerShell CLI 's requirements.

  • If your JSON text is not a literal and stored in a variable , you must pass
    $jsonVar -replace '"', '\\"' to perform the necessary escaping - see this answer .

With -File or when calling external programs such as curl.exe :

# With a literal string:
powershell -File ./script.ps1 '{ \"c\": \"some setting\", \"unknown\": \"b\" }'

# With an expandable string (expanded by the caller):
powershell -File ./script.ps1 "{ \`"c\`": \`"some $env:OS\`", \`"unknown\`": \`"b\`" }"

With -Command :

# With a literal string:
powershell -Command ConvertFrom-Json '''"{ \"c\": \"some setting\", \"unknown\": \"b\" }"'''

# With an expandable string (expanded by the caller):
powershell -Command ConvertFrom-Json "'{ \`"c\`": \`"some $env:OS\`", \`"unknown\`": \`"b\`" }'"

---

PowerShell Core : Calling from bash

• Bash, like PowerShell, understands both expanding (interpolating) "..." strings and literal '...' strings.

• Bash, unlike cmd.exe , recognizes \\" as escaped " chars. inside "..." , so there's no need to escape any of Bash's metacharacters.

With -File :

# With a literal string:
pwsh -File ./script.ps1 '{ "c": "some setting", "unknown": "b" }'

# With an expandable string (expanded by the caller):
pwsh -File ./script.ps1 "{ \"c\": \"some $USER\", \"unknown\": \"b\" }"

With -Command :

# With a literal string:
pwsh -Command ConvertFrom-Json \''{ "c": "some setting", "unknown": "b" }'\'

# With an expandable string (expanded by the caller):
pwsh -Command ConvertFrom-Json "'{ \"c\": \"some $USER\", \"unknown\": \"b\" }'"

Answer 2

I would suggest using a variable to pass the string. For the example JSON given, it avoids escaping entirely. ConvertFrom-Json can be used as a test app.

First in PowerShell, observe

PS C:\> $psJson = '{ "c": "some setting", "d": "unknown", "b": "some thing", "a": 1 }'
PS C:\> ConvertFrom-Json $psJson

c            d       b          a
-            -       -          -
some setting unknown some thing 1

From CMD, we can achieve the same result. When PowerShell is opened from a batch, it inherits the environment. Instead of passing the string, set an environment variable and use it like a global

C:\>set dosJson={ "c": "some setting", "d": "unknown", "b": "some thing", "a": 1 }

C:\>powershell -command "& { ConvertFrom-Json $env:dosJson }"

c            d       b          a
-            -       -          -
some setting unknown some thing 1

EDIT:

It should be pointed out that this works for -Command and not -File , because the PowerShell environment is not available to the -File args. Of course you can run a script inside a -Command . Using a trivial test script test.ps1

C:\>type test.ps1
param ([string] $json)
ConvertFrom-Json $json
C:\>powershell -command "& { C:\test.ps1 $env:dosJson }"

c            d       b          a
-            -       -          -
some setting unknown some thing 1

So the script.bat in the question would have to be changed to -Command .