できない.dev

コマンドの終了コードを調べるには

外部コマンドの終了コードを受け取る書き方を各言語で示す。
0 以外で例外になる書き方とならない書き方、シグナルで終わったときの値、256 以上を指定したときに値が丸められる点もまとめる。

公開:

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

Python

import subprocess
 
# 0 以外で終わっても例外にはならず、returncode に入る
result = subprocess.run(["sh", "-c", "exit 3"])
print(result.returncode)  # 3
 
# check=True を付けると、0 以外のときに CalledProcessError になる
try:
    subprocess.run(["sh", "-c", "exit 3"], check=True)
except subprocess.CalledProcessError as e:
    print(e.returncode)  # 3

subprocess.run は 0 以外で終わっても例外にせず、終了コードを returncode に入れて返す。
失敗を例外で扱いたいときは check=True を付けると、0 以外で CalledProcessError になる。

JavaScript

const { spawnSync, execFileSync } = require("node:child_process");
 
// spawnSync は 0 以外でも例外を投げず、status に入る
const result = spawnSync("sh", ["-c", "exit 3"]);
console.log(result.status); // 3
 
// execFileSync は 0 以外で例外を投げ、終了コードは err.status に入る
try {
  execFileSync("sh", ["-c", "exit 3"]);
} catch (err) {
  console.log(err.status); // 3
}

spawnSync は終了コードを status に入れて返し、0 以外でも例外を投げない。
execFileSync と execSync は 0 以外で例外を投げ、終了コードは例外の status に入る。

TypeScript

import { spawnSync, execFileSync } from "node:child_process";
 
// spawnSync は 0 以外でも例外を投げず、status に入る(シグナルで終わると null)
const result = spawnSync("sh", ["-c", "exit 3"]);
const code: number | null = result.status;
console.log(code); // 3
 
// execFileSync は 0 以外で例外を投げる。catch の err は unknown なので絞り込む
try {
  execFileSync("sh", ["-c", "exit 3"]);
} catch (err) {
  if (err instanceof Error && "status" in err) {
    console.log(err.status); // 3
  }
}

catch で受け取る値は unknown 型なので、instanceof Error と "status" in err で絞り込んでから status を読む。
spawnSync の status は number | null で、シグナルで終わったときは null になる。

Go

package main
 
import (
	"errors"
	"fmt"
	"log"
	"os/exec"
)
 
func main() {
	err := exec.Command("sh", "-c", "exit 3").Run()
 
	// 0 以外で終わると Run は *exec.ExitError を返す
	var exitErr *exec.ExitError
	if errors.As(err, &exitErr) {
		fmt.Println(exitErr.ExitCode()) // 3
	} else if err != nil {
		log.Fatal(err) // コマンドが見つからないなど、起動できなかった
	} else {
		fmt.Println(0)
	}
}

Run は 0 以外で終わると *exec.ExitError を返すので、errors.As で取り出して ExitCode を読む。
ExitError 以外のエラーは、コマンドが見つからないなど起動そのものの失敗である。

Rust

use std::process::Command;
 
fn main() -> std::io::Result<()> {
    // 0 以外で終わっても Err にはならず、ExitStatus で受け取る
    let status = Command::new("sh").args(["-c", "exit 3"]).status()?;
 
    println!("{}", status.success()); // false
    match status.code() {
        Some(code) => println!("{}", code), // 3
        None => println!("シグナルで終了した"),
    }
    Ok(())
}

status は 0 以外で終わっても Err にはならず、ExitStatus を返す。
code は Option<i32> で、Unix でシグナルによって終わったときは None になる。

Java

public class Main {
    public static void main(String[] args) throws Exception {
        Process p = new ProcessBuilder("sh", "-c", "exit 3").inheritIO().start();
 
        // waitFor は終了を待って終了コードを返す。0 以外でも例外にはならない
        int code = p.waitFor();
        System.out.println(code); // 3
    }
}

waitFor は終了を待って終了コードを返す。
終了前に exitValue を呼ぶと IllegalThreadStateException になるので、先に waitFor で待つ。

C#

using System.Diagnostics;
 
var psi = new ProcessStartInfo("sh") { ArgumentList = { "-c", "exit 3" } };
using var p = Process.Start(psi)!;
 
// 終了を待ってから ExitCode を読む。0 以外でも例外にはならない
p.WaitForExit();
Console.WriteLine(p.ExitCode); // 3

WaitForExit で終了を待ってから ExitCode を読む。
終了前に読むと InvalidOperationException になる。

0 以外で例外になる書き方とならない書き方

sh -c "exit 3" を実行したとき、例外やエラーになるかは言語と書き方で分かれた。

  • Python の subprocess.run は例外にならず、check=True を付けると CalledProcessError になった。
  • Node.js の spawnSync は例外にならず、execSync・execFileSync は例外を投げた。
  • Go の Run は *exec.ExitError をエラーとして返した。
  • Rust・Java・C# は例外にもエラーにもならず、終了コードを自分で調べる。

例外にならない書き方では、終了コードを見ないと失敗に気づかない。
コマンドの失敗で処理を止めたいなら、例外になる書き方を選ぶか、0 かどうかを必ず確かめる。

シグナルで終わったときの値は言語ごとに違う

sh -c 'kill -9 $$' で、シェル自身を SIGKILL で終わらせて比べた。

  • Python の returncode は -9(シグナル番号の負の値)だった。
  • Node.js の status は null で、signal に 'SIGKILL' が入った。execFileSync が投げた例外も status が null だった。
  • Go の ExitCode は -1 で、エラーの文言は signal: killed だった。
  • Rust の code は None だった。
  • Java と C# は 137(128 と 9 の和)だった。

SIGTERM(15)で終わらせると、Python は -15、Java と C# は 143 になった。
0 かどうかだけを見る書き方なら、どの言語でも失敗として扱える。
値で原因を分けるときは、この違いに注意する。

256 以上の終了コードは下位 8 ビットに丸められる

終了コードは 0〜255 の範囲でしか親に届かない。
sh -c "exit 256" は 7 言語とも 0(成功)になり、exit 300 は 44(300 から 256 を引いた値)になった。

Go では exit 256 のときに Run がエラーを返さず、成功として扱われた。
自分のプログラムで終了コードを決めるときは 1〜255 の範囲で選ぶ。

シェル経由のパイプは最後のコマンドの終了コードになる

シェル経由でパイプをつなぐと、返る終了コードは最後のコマンドのものになる。
Python の subprocess.run(..., shell=True) で試した。

  • false | true は 0 だった。
  • nosuchcmd | cat も 0 で、コマンドが無いことに気づけなかった。
  • true | false は 1 だった。

途中の失敗も拾いたいときは、bash を使って pipefail を有効にする。
["bash", "-o", "pipefail", "-c", "false | true"] は 1 になった。