できない.dev

シェルコマンドを実行するには

外部のコマンドを起動して終了まで待つ書き方を各言語で示す。
引数を配列で渡す書き方とシェルを通す書き方の違い、コマンドが見つからないときの結果、Windows で echo が見つからない理由もまとめる。

公開:

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

Python

import subprocess
 
# 引数をリストで渡す(シェルを通さない)。子の出力はそのまま画面に出る
result = subprocess.run(["echo", "hello", "world"])  # hello world
print(result.returncode, flush=True)  # 0(flush しないと子の出力と順番が入れ替わることがある)
 
# パイプを使うときは shell=True でシェルを通す
subprocess.run("echo one two three | wc -w", shell=True)  # 3

subprocess.run に引数をリストで渡すと、シェルを通さずにコマンドを起動して終了まで待つ。
パイプ(|)のようなシェルの機能を使うときだけ、shell=True を付けて 1 本の文字列で渡す。

JavaScript

const { spawnSync, execSync } = require("node:child_process");
 
// 引数を配列で渡す(シェルを通さない)。stdio: "inherit" で子の出力を画面に出す
const result = spawnSync("echo", ["hello", "world"], { stdio: "inherit" }); // hello world
console.log(result.status); // 0
 
// パイプを使うときは execSync でシェルを通す
execSync("echo one two three | wc -w", { stdio: "inherit" }); // 3

spawnSync は引数を配列で受け取り、シェルを通さずにコマンドを起動する。
stdio: "inherit" を付けると子の出力が親の画面にそのまま出る。
パイプを使うときは、文字列をシェルに渡す execSync を使う。

TypeScript

import { spawnSync, execSync } from "node:child_process";
 
// 引数を配列で渡す(シェルを通さない)。stdio: "inherit" で子の出力を画面に出す
const result = spawnSync("echo", ["hello", "world"], { stdio: "inherit" }); // hello world
const code: number | null = result.status; // シグナルで終わると null
console.log(code); // 0
 
// パイプを使うときは execSync でシェルを通す
execSync("echo one two three | wc -w", { stdio: "inherit" }); // 3

書き方は JavaScript と同じで、node:child_process から spawnSync と execSync を import する。
status の型は number | null で、シグナルで終わったときは null になる。

Go

package main
 
import (
	"fmt"
	"log"
	"os"
	"os/exec"
)
 
func main() {
	// 引数を個別に渡す(シェルを通さない)。Stdout を指定しないと出力は捨てられる
	cmd := exec.Command("echo", "hello", "world")
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr
	if err := cmd.Run(); err != nil { // hello world
		log.Fatal(err)
	}
	fmt.Println(cmd.ProcessState.ExitCode()) // 0
 
	// パイプを使うときは sh -c でシェルを通す
	sh := exec.Command("sh", "-c", "echo one two three | wc -w")
	sh.Stdout = os.Stdout
	sh.Stderr = os.Stderr
	if err := sh.Run(); err != nil { // 3
		log.Fatal(err)
	}
}

exec.Command に実行ファイル名と引数を別々に渡し、Run で終了まで待つ。
Stdout と Stderr を指定しないと子の出力は捨てられるので、画面に出したいときは os.Stdout と os.Stderr をつなぐ。

Rust

use std::process::Command;
 
fn main() -> std::io::Result<()> {
    // 引数を個別に渡す(シェルを通さない)。status() は子の出力を画面にそのまま出す
    let status = Command::new("echo").args(["hello", "world"]).status()?; // hello world
    println!("{}", status.code().unwrap_or(-1)); // 0
 
    // パイプを使うときは sh -c でシェルを通す
    Command::new("sh")
        .args(["-c", "echo one two three | wc -w"])
        .status()?; // 3
    Ok(())
}

std::process::Command に args で引数を渡し、status で終了まで待つ。
status は子の標準出力と標準エラー出力を親から引き継ぐので、出力はそのまま画面に出る。

Java

public class Main {
    public static void main(String[] args) throws Exception {
        // 引数を個別に渡す(シェルを通さない)。inheritIO で子の出力を画面に出す
        Process p = new ProcessBuilder("echo", "hello", "world").inheritIO().start(); // hello world
        System.out.println(p.waitFor()); // 0
 
        // パイプを使うときは sh -c でシェルを通す
        new ProcessBuilder("sh", "-c", "echo one two three | wc -w")
                .inheritIO()
                .start()
                .waitFor(); // 3
    }
}

ProcessBuilder に実行ファイル名と引数を別々に渡して start で起動し、waitFor で終了を待つ。
inheritIO を付けないと子の出力はパイプに流れ、画面には出ない。

C#

using System.Diagnostics;
 
// 引数を ArgumentList で個別に渡す(シェルを通さない)。子の出力はそのまま画面に出る
var psi = new ProcessStartInfo("echo") { ArgumentList = { "hello", "world" } };
using (var p = Process.Start(psi)!)
{
    p.WaitForExit(); // hello world
    Console.WriteLine(p.ExitCode); // 0
}
 
// パイプを使うときは sh -c でシェルを通す
var sh = new ProcessStartInfo("sh") { ArgumentList = { "-c", "echo one two three | wc -w" } };
using (var p = Process.Start(sh)!)
{
    p.WaitForExit(); // 3
}

ProcessStartInfo の ArgumentList に引数を 1 つずつ足すと、空白や ' を含む値もそのまま 1 つの引数として渡る。
.NET 10 では UseShellExecute の既定が false で、子の出力は親の画面にそのまま出た。

シェルを通すと、埋め込んだ値もコマンドとして解釈される

シェル経由(Python の shell=True、Node.js の execSync、sh -c)では、渡した文字列の全体をシェルが解釈する。
外から受け取った値を文字列に埋め込むと、その中の ; や | もシェルの記号として働く。

Python で name = "report.txt; echo injected" を埋め込んで比べた。

  • subprocess.run(f"echo {name}", shell=True) は report.txt と injected の 2 行を出した。echo injected が別のコマンドとして実行されている。
  • subprocess.run(["echo", name]) は report.txt; echo injected を 1 行で出した。値は 1 つの引数としてそのまま渡る。
  • shlex.quote(name) で囲んでから埋め込むと、シェル経由でも 1 行で出た。

空白も同じで、my file.txt を配列で渡すと 1 つの引数になるが、シェル経由でクォートせずに書くと my と file.txt の 2 つに分かれた。
外から来る値を渡すときは配列で渡し、シェルはパイプなどが本当に要るときだけ使う。

Node.js で shell: true と引数の配列を一緒に渡すと連結される

Node.js の spawnSync に shell: true を付けて引数の配列も渡すと、配列の要素はエスケープされずに空白でつながれてシェルに渡る。
spawnSync("echo", ["a;", "echo", "b"], { shell: true }) は a と b を別々の行に出し、; で区切られた 2 つのコマンドとして実行された。

Node.js 24 では、この組み合わせで [DEP0190] DeprecationWarning の警告も出た。
シェルを通すなら 1 本の文字列で渡し、配列で渡すなら shell を付けない。

コマンドが見つからないときは終了コードではなく起動の失敗になる

配列で渡した実行ファイルが見つからないと、終了コードではなく起動の失敗として返る。
存在しない nosuchcmd を起動した結果は次のとおりだった。

  • Python は FileNotFoundError を投げた。
  • Node.js の spawnSync は例外を投げず、status が null になり、error に ENOENT が入った。execFileSync は例外を投げた。
  • Go の Run は *exec.Error(executable file not found in $PATH)を返した。
  • Rust の status は ErrorKind::NotFound の Err を返した。
  • Java は IOException を、C# は Win32Exception を投げた。

シェル経由で同じコマンドを打つと、シェル自体は起動できるので例外にはならない。
/bin/sh: 1: nosuchcmd: not found が標準エラー出力に出て、終了コード 127 が返った。
終了コードだけを見ていると、コマンドが無いのか、コマンドが失敗したのかを取り違えやすい。

Windows では echo が実行ファイルとして存在しない

このページのコードは Linux(Docker の公式イメージ)で実行して確かめたものである。
Windows では echo や dir はコマンドプロンプト(cmd.exe)の内部コマンドで、単独の実行ファイルとしては存在しない。

  • Windows 11 の Python 3.12 で subprocess.run(["echo", "hello"]) は FileNotFoundError([WinError 2])になった。shell=True を付けるか、["cmd", "/c", "echo", "hello"] と書くと hello が出た。
  • Node.js 24 の spawnSync("echo", ["hello"]) も ENOENT で失敗し、execSync("echo hello") は通った。
  • PowerShell の ls や cat も Get-ChildItem・Get-Content のエイリアスで、実行ファイルではない。

Windows で動かすときは、実在する実行ファイルを呼ぶか、cmd /c を通す。

親の出力と子の出力の順番が入れ替わることがある

Python で print("before")、subprocess.run(["echo", "child"])、print("after") の順に実行すると、端末では before、child、after の順に出た。
出力をパイプに流すと(Docker を -t なしで動かした場合)、child、before、after の順になった。

親の print は出力先が端末でないとバッファにたまり、子は自分で直接書き出すためである。
順番が要るときは、子を起動する前に print(..., flush=True) や sys.stdout.flush() で親のバッファを書き出しておく。