从cmd.exe命令捕获的输出缺少最后一个换行符

Question

I'm trying to call a built-in cmd command like echo in PowerShell using Invoke-Expression and convert it to a byte array, but the newlines are missing from the command output.

Example:

([Text.Encoding]::ASCII).GetBytes((iex "cmd /c echo."))

It returns nothing instead of a newline sequence (CRLF).

Answer 1

I found a solution. Not perfect but i will write output to file, read it with [System.IO.File]::ReadAllBytes("path_to_the_file") and save to variable

Answer 2

tl;dr:

PS> ([text.encoding]::ASCII).GetBytes(((cmd /c echo.) -join "`r`n") + "`r`n")
13
10

^{As an aside: iex ( Invoke-Expression ) should be avoided .}

Read on for background information and caveats.

---

When PowerShell captures stdout output from an external program such as cmd.exe , it returns an array of output lines , with the trailing newline sequence trimmed from each.

As an aside: It is the character encoding reported by [console]::OutputEncoding that determines how PowerShell interprets the output, which in Windows PowerShell defaults to the legacy system locale's OEM code page, and, as of this writing, also - still -in PowerShell Core on Windows , though that will hopefully change soon , given that PowerShell Core otherwise uses (BOM-less) UTF-8 as the default encoding.

In your case, cmd /c echo. emitted a single Windows newline sequence, CRLF, which, in PowerShell terms, is "`r`n" (you can also use [Environment]::NewLine to obtain a platform-appropriate newline string).

PowerShell interprets that as a single empty line, and, due to not including the trailing newline in the array elements and PowerShell unwrapping a single-element array, you end up with '' , ie, the empty string - this is why the ([text.encoding]::ASCII).GetBytes() call produced no output.

You can reassemble the output-lines array that PowerShell created into a single, multi-line output string by:

• joining the array elements with newlines ( -join "`r`n" )
• appending a final trailing newline ( + "`r`n" )

as shown above.

Caveats : This "reassembly" makes two assumptions that may not always be true:

• That the external program really emitted Windows CRLF sequences and not UNIX LF-only characters.

  • In practice, however, that difference rarely matters in PowerShell, because it accepts both newline forms interchangeably .

• That the external program really emitted a trailing newline - which is typically, but not necessarily true.

If these assumptions are problematic, redirecting the output to a file and reading that - as in your own answer - is the right solution.

Caveat : > in Windows PowerShell creates UTF-16LE files by default (and also invariably appends a newline), so you won't get ASCII bytes; therefore, use cmd 's own redirection to produce the file (which will use the legacy OEM encoding indicated by chcp , which is typically a superset of ASCII):

  # Note that the `>` is *inside the quoted string* to ensure that it is
  # cmd.exe that interprets it.
  # (...) around `echo.` ensures that the space before `>` doesn't become
  # part of the output.
  PS> cmd /c '(echo.) >out.txt'; [IO.File]::ReadAllBytes("$PWD\out.txt")
  13
  10