Windows 10批处理：如何将持续运行程序的输出写入变量

Got it, let's break this down. The standard for /f loop approach for reading program output line-by-line into variables works perfectly for programs that terminate or have a fixed set of output lines—but it won't cut it for your long-running example.exe that keeps spitting out data indefinitely. Here are two solid solutions tailored to your scenario:

Pure Batch Script Approach #

This method uses a loop with set /p to capture each line of output in real time, without waiting for the program to terminate. We'll enable delayed expansion to handle variables correctly within the pipeline:

@echo off
setlocal enabledelayedexpansion

:: Launch example.exe with your passed arguments, pipe output to our loop
example.exe %* | (
    :read_loop
    set "captured_line="
    :: Read one line of output into the captured_line variable
    set /p captured_line=
    if defined captured_line (
        :: Do whatever you need with the variable here—print it, store it, etc.
        echo Just captured: !captured_line!
        :: Jump back to read the next line
        goto read_loop
    )
)

endlocal

Key Notes: #

• Delayed Expansion: Critical here because variables inside the pipe run in a subshell—!captured_line! ensures we access the most up-to-date value.
• Empty Lines: set /p skips empty lines. If you need to handle empty output lines, you'll need a workaround (like checking for the presence of a prompt character, but that's case-specific).
• Non-Line-Buffered Output: If example.exe outputs data without newlines, this method won't capture it until a newline is sent. Most console apps line-buffer by default, but keep this in mind.

PowerShell-Assisted Approach (More Reliable) #

Batch has limitations with real-time output handling, so pairing it with PowerShell can give you more flexibility, especially for edge cases like empty lines or non-line-buffered output:

# Launch example.exe with arguments, redirect output to a temp file
$process = Start-Process -FilePath "example.exe" -ArgumentList $args -NoNewWindow -PassThru -RedirectStandardOutput "temp_output.txt"

# Continuously read the temp file as new lines are added
Get-Content "temp_output.txt" -Wait | ForEach-Object {
    $capturedLine = $_
    # Process the variable here—example: log to console or write to another file
    Write-Host "Captured line: $capturedLine"
}

# Clean up the temp file once the process ends
Remove-Item "temp_output.txt"

Why This Works Better: #

• Get-Content -Wait monitors the temp file for new content, so you get real-time updates even if the program doesn't flush lines immediately.
• Handles empty lines and non-standard output formatting more gracefully than pure batch.
• You can easily extend this to store lines in an array or send them to another script/process.

Pick the approach that fits your environment—if you need strict batch compatibility, go with the first option. If you can leverage PowerShell (which is available on all modern Windows systems), the second method is more robust.

内容的提问来源于stack exchange，提问作者Jeffrey