できない.dev

コマンドの標準出力を受け取るには

外部コマンドの標準出力を変数に受け取る書き方を各言語で示す。
末尾に改行が付いたまま返る点、バイト列で返る言語と文字コードの指定、標準エラー出力の扱い、パイプを読む順番で処理が止まる例もまとめる。

公開:

選んだ言語は、ほかのサンプルコードを開いたときも最初に表示する。

Python

import subprocess
 
result = subprocess.run(
    ["echo", "こんにちは"],
    capture_output=True,  # 標準出力と標準エラー出力を受け取る
    encoding="utf-8",  # bytes ではなく str で受け取る
)
 
print(repr(result.stdout))  # 'こんにちは\n'
print(result.stdout.strip())  # こんにちは

capture_output=True を付けると、標準出力が result.stdout に入る。
encoding="utf-8" を指定すると bytes ではなく str で受け取れ、文字コードも OS の既定に左右されない。

JavaScript

const { execFileSync } = require("node:child_process");
 
// encoding を付けると文字列で返る(付けないと Buffer)
const out = execFileSync("echo", ["こんにちは"], { encoding: "utf8" });
 
console.log(JSON.stringify(out)); // "こんにちは\n"
console.log(out.trim()); // こんにちは

execFileSync は終了を待って標準出力を返す。
encoding を付けないと Buffer で返るので、文字列で扱うなら "utf8" を指定する。
末尾の改行は trim で落とす。

TypeScript

import { execFileSync } from "node:child_process";
 
// encoding を付けると戻り値の型が string になる(付けないと Buffer)
const out: string = execFileSync("echo", ["こんにちは"], { encoding: "utf8" });
 
console.log(JSON.stringify(out)); // "こんにちは\n"
console.log(out.trim()); // こんにちは

encoding を指定した呼び出しは戻り値の型が string になり、指定しないと Buffer の型になる。
付け忘れたまま string の変数に入れるとコンパイルエラーになるので、型で気づける。

Go

package main
 
import (
	"fmt"
	"log"
	"os/exec"
	"strings"
)
 
func main() {
	// Output は標準出力を []byte で返す
	out, err := exec.Command("echo", "こんにちは").Output()
	if err != nil {
		log.Fatal(err)
	}
 
	fmt.Printf("%q\n", out)                     // "こんにちは\n"
	fmt.Println(strings.TrimSpace(string(out))) // こんにちは
}

Output は終了を待ち、標準出力を []byte で返す。
文字列にするには string(out) で変換し、末尾の改行は strings.TrimSpace で落とす。

Rust

use std::process::Command;
 
fn main() -> std::io::Result<()> {
    // output() は終了を待ち、標準出力と標準エラー出力を Vec<u8> で返す
    let output = Command::new("echo").arg("こんにちは").output()?;
    let stdout = String::from_utf8(output.stdout).expect("UTF-8 ではない出力");
 
    println!("{:?}", stdout); // "こんにちは\n"
    println!("{}", stdout.trim_end()); // こんにちは
    Ok(())
}

output は終了を待ち、標準出力と標準エラー出力を Vec<u8> で返す。
String::from_utf8 で文字列に直し、UTF-8 として読めないときは Err になる。

Java

import java.nio.charset.StandardCharsets;
 
public class Main {
    public static void main(String[] args) throws Exception {
        Process p = new ProcessBuilder("echo", "こんにちは").start();
 
        // 標準出力を最後まで読んでから終了を待つ
        String out = new String(p.getInputStream().readAllBytes(), StandardCharsets.UTF_8);
        p.waitFor();
 
        System.out.println(out.length()); // 6(末尾の改行を含む)
        System.out.println(out.strip()); // こんにちは
    }
}

getInputStream で子の標準出力を読む。
readAllBytes で最後まで読み切ってから waitFor で終了を待ち、文字コードは StandardCharsets.UTF_8 のように明示する。

C#

using System.Diagnostics;
using System.Text;
 
var psi = new ProcessStartInfo("echo")
{
    ArgumentList = { "こんにちは" },
    RedirectStandardOutput = true, // 画面に出さずに受け取る
    StandardOutputEncoding = Encoding.UTF8,
};
 
using var p = Process.Start(psi)!;
string output = p.StandardOutput.ReadToEnd(); // 先に読み切る
p.WaitForExit();
 
Console.WriteLine(output.Length); // 6(末尾の改行を含む)
Console.WriteLine(output.Trim()); // こんにちは

RedirectStandardOutput = true を付けると、標準出力が画面ではなく StandardOutput に流れる。
ReadToEnd で先に読み切ってから WaitForExit を呼ぶ。

末尾の改行が付いたまま返る

echo などのコマンドは最後に改行を出すので、受け取った文字列の末尾にも改行が残る。
echo こんにちは の出力は、Python の repr で 'こんにちは\n' になり、Java と C# では長さが 6(5 文字と改行)だった。

比較やファイル名に使う前に、strip・trim・strings.TrimSpace などで落とす。
これらは前後の空白も一緒に消すので、空白に意味がある出力では末尾の改行だけを落とす(Python なら rstrip("\n"))。

バイト列で返るか文字列で返るか

受け取った出力がバイト列か文字列かは、言語と書き方で分かれる。

  • Python は encoding も text=True も付けないと、b'hi\n' のような bytes になった。
  • Node.js は encoding を付けないと <Buffer 68 69 0a> になった。
  • Go は []byte、Rust は Vec<u8> で返り、Java は InputStream から読んだバイト列を自分で文字列にする。
  • C# の StandardOutput は文字列で読め、文字コードは StandardOutputEncoding で指定できる。

Python の text=True は OS の既定の文字コードで読む。
Windows 11(既定の文字コードが cp932)の Python 3.12 で、UTF-8 で出力する node -e "console.log('こんにちは')" を text=True で受け取ると 縺薙s縺ォ縺。縺ッ に化けた。
encoding="utf-8" を指定すると正しく読めた。
子の出力の文字コードが分かっているなら、text=True ではなく encoding で明示する。

標準エラー出力は標準出力に入らない

標準出力を受け取る書き方では、標準エラー出力は別に扱われる。
sh -c "echo out; echo err >&2" で比べた。

  • Python で stdout=subprocess.PIPE だけを付けると、stdout は 'out\n' になり、err は画面にそのまま出た。capture_output=True なら stderr に 'err\n' が入る。
  • Python で stderr=subprocess.STDOUT を付けると、両方が stdout にまとまって 'out\nerr\n' になった。
  • Node.js の execFileSync は既定で err を画面に出し、戻り値は "out\n" だけだった。
  • Go の Output は "out\n" だけを返した。コマンドが 0 以外で終わったときは、標準エラー出力が *exec.ExitError の Stderr に入っていた。両方をまとめて受け取るなら CombinedOutput を使う。

エラーの理由はたいてい標準エラー出力に出るので、失敗したときに表示できるよう受け取っておく。

標準出力と標準エラー出力を順に読むと止まることがある

標準出力と標準エラー出力の両方をパイプにして、片方を最後まで読んでからもう片方を読むと、処理が止まることがある。
子が標準エラー出力にたくさん書くとパイプが一杯になり、子は空きができるまで待つ。
親は標準出力の終わりを待っているので、どちらも進まなくなる。

子が標準エラー出力に書く量を変えて、Docker 上で試した。

  • Java 21 で getInputStream を先に読み切る書き方は、1024 KB までは最後まで読めたが、1025 KB と 2048 KB では止まり、15〜20 秒待っても終わらなかった。
  • C#(.NET 10)で両方をリダイレクトして StandardOutput.ReadToEnd を先に呼ぶ書き方も、2048 KB で 15 秒待っても終わらなかった。
  • Python の subprocess.run(..., capture_output=True) は両方を並行して読むので、2048 KB でも止まらなかった。

止まり始める量は試した環境での値であり、出力が少ないうちは気づきにくい。
標準エラー出力が要らなければパイプにしないか、Java なら redirectErrorStream(true) で標準出力にまとめる(2048 KB でも止まらなかった)。
両方を別々に受け取るなら、並行して読む。