Bash exit status และการต่อคำสั่ง



Bash ไม่มี boolean แบบภาษาอื่น — มันตัดสินใจทุกอย่างจาก exit status ตัวเลขที่คำสั่งทิ้งไว้เมื่อจบ เข้าใจเรื่องนี้แล้ว if, &&, ||, set -e จะเป็นเรื่องเดียวกันหมด

exit status คืออะไร

ทุกคำสั่งเมื่อจบทำงานคืนตัวเลข 0–255 ให้ระบบ

  • 0 = สำเร็จ (จำง่าย ๆ ว่า “zero problems”)
  • ไม่ใช่ 0 = ล้มเหลว ค่าต่างกันบอกสาเหตุต่างกัน
ls /etc >/dev/null
echo $?              # 0 — สำเร็จ

ls /nonexistent 2>/dev/null
echo $?              # 2 — ล้มเหลว

grep "xyz" /etc/hostname
echo $?              # 1 — grep ทำงานได้ แต่ไม่เจอ

$? เก็บ exit status ของคำสั่งที่จบล่าสุด — มันเปลี่ยนทุกคำสั่ง ถ้าจะใช้ต้องเก็บทันที

some_command
rc=$?                # เก็บไว้ก่อนที่คำสั่งอื่นจะทับ
echo "..."
if [[ $rc -ne 0 ]]; then echo "some_command ล้มเหลว (rc=$rc)"; fi

exit — จบสคริปต์พร้อมรหัส

#!/usr/bin/env bash

if [[ ! -f config.ini ]]; then
    echo "ไม่พบ config.ini" >&2
    exit 1                       # จบทันที บอกระบบว่าล้มเหลว
fi

# ... งานหลัก ...

exit 0                           # จบแบบสำเร็จ (จริง ๆ ไม่ใส่ก็ได้ ถ้าคำสั่งสุดท้ายสำเร็จ)
  • exit เฉย ๆ = exit $? (ใช้รหัสของคำสั่งล่าสุด)
  • ถ้าไม่เรียก exit เลย สคริปต์จบด้วยรหัสของคำสั่งสุดท้าย
  • ค่าเกิน 255 จะวนกลับ (exit 256 → 0, exit 257 → 1) — อยู่ในช่วง 0–255 เท่านั้น

true, false, : — คำสั่งที่ไม่ทำอะไรนอกจากคืนรหัส

true;  echo $?        # 0 — คืน 0 เสมอ
false; echo $?        # 1 — คืน 1 เสมอ
:;     echo $?        # 0 — เหมือน true แต่เป็น builtin (no-op)

ใช้ตอนไหน

# loop ที่ต้องวนไปเรื่อย ๆ
while true; do
    check_something || break
    sleep 5
done

# placeholder ในบล็อกที่ยังไม่เขียน (Bash ไม่ยอมให้บล็อกว่าง)
if [[ $debug -eq 1 ]]; then
    :    # TODO: ใส่โค้ด debug ทีหลัง
fi

&& และ || — ต่อคำสั่งตามผล

mkdir build && cd build              # cd เฉพาะเมื่อ mkdir สำเร็จ
ping -c1 host >/dev/null || echo "host ไม่ตอบ"    # echo เฉพาะเมื่อ ping ล้มเหลว
  • A && B → รัน B เฉพาะเมื่อ A สำเร็จ (exit 0)
  • A || B → รัน B เฉพาะเมื่อ A ล้มเหลว (exit ≠ 0)

เรียกว่า short-circuit (ลัดวงจร) — ถ้ารู้ผลแล้วก็ไม่รันตัวถัดไป

ต่อกันเป็นลูกโซ่ได้

command_a && command_b && command_c        # ทำต่อกันจนกว่าจะมีตัวพัง
download && extract && install || echo "ล้มเหลวสักขั้น" >&2

กับดักของ A && B || C

มันไม่เหมือน if A then B else C!

[[ -f file ]] && echo "พบ" || echo "ไม่พบ"

ถ้า file มีจริง แต่ echo "พบ" ดันล้มเหลว (เกิดยาก แต่เป็นไปได้) → echo "ไม่พบ" จะรันด้วย เพราะ || ดูผลของ echo "พบ" ไม่ใช่ของ [[ -f file ]]

ใช้ pattern นี้ได้กับกรณีง่าย ๆ ที่ B ไม่มีทางพลาด แต่ถ้าตรรกะสำคัญ ใช้ if เต็ม

if [[ -f file ]]; then
    echo "พบ"
else
    echo "ไม่พบ"
fi

! — กลับค่า

if ! grep -q "ERROR" app.log; then
    echo "ไม่มี ERROR — ดีมาก"
fi

! command_that_should_fail        # exit 0 ถ้าคำสั่งล้มเหลวจริง

! cmd กลับ exit status: 0→1, ไม่ใช่ 0→0

if ดู exit status ไม่ใช่แค่ [[ ]]

จุดสำคัญที่มือใหม่มองข้าม — if ตามด้วย คำสั่งอะไรก็ได้ ไม่จำเป็นต้องเป็น [[ ]]

if grep -q "pattern" file.txt; then          # ใช้ exit status ของ grep
    echo "เจอ"
fi

if ./deploy.sh; then                          # ใช้ exit status ของสคริปต์
    echo "deploy สำเร็จ"
else
    echo "deploy ล้มเหลว" >&2
    exit 1
fi

if command -v docker >/dev/null; then         # เช็กว่ามี docker ไหม
    echo "มี docker"
fi

[[ ]] เป็นแค่คำสั่งหนึ่งที่คืน exit status ตามผลการทดสอบ (บทที่ 9)

ความหมายมาตรฐานของรหัส

รหัสความหมาย
0สำเร็จ
1ข้อผิดพลาดทั่วไป (catch-all)
2ใช้คำสั่งผิด — option ผิด, อาร์กิวเมนต์ขาด (ธรรมเนียม)
126ไฟล์มีอยู่แต่รันไม่ได้ (ไม่มี execute bit)
127หาคำสั่งไม่เจอ (command not found)
128+Nถูกฆ่าด้วย signal N — เช่น 130 = Ctrl+C (SIGINT=2), 137 = SIGKILL (9)
255exit status นอกช่วง หรือ error ร้ายแรง

ตั้งรหัสของสคริปต์ตัวเองให้มีความหมาย

readonly E_ARGS=2
readonly E_NO_CONFIG=3
readonly E_NETWORK=4

[[ $# -ge 1 ]]        || exit "$E_ARGS"
[[ -f "$config" ]]    || exit "$E_NO_CONFIG"
curl -fsS "$url"      || exit "$E_NETWORK"

คนที่เรียกสคริปต์ของคุณ (cron, CI, สคริปต์อื่น) จะแยกแยะสาเหตุได้จากรหัส

เรื่องที่คนมักพลาด

  • อ่าน $? ช้าไป — คำสั่งอื่นมาทับแล้ว เก็บทันที rc=$?
  • A && B || C = if-then-else — ไม่ใช่ ถ้า B พลาด C ก็รัน ใช้ if เต็มเมื่อตรรกะสำคัญ
  • คิดว่า grep ไม่เจอ = error — grep คืน 1 เมื่อไม่เจอ (ปกติ), คืน 2 เมื่อ error จริง กับ set -e ต้อง grep ... || true
  • exit ในฟังก์ชันที่ตั้งใจแค่ return — exit ปิดทั้งสคริปต์ ในฟังก์ชันใช้ return N
  • if [[ $? -eq 0 ]] หลังคำสั่ง — ยืดยาว เขียน if คำสั่ง; then ตรง ๆ
  • exit code เกิน 255 — exit 300 กลายเป็น exit 44 อยู่ในช่วง 0–255
  • ลืมว่า local x=$(cmd) กลบ exit status — $? กลายเป็นของ local ไม่ใช่ของ cmd (บทที่ 16) แยกเป็น local x; x=$(cmd)

สรุป

  • ทุกคำสั่งคืน exit status 0–255: 0 = สำเร็จ, อื่น = ล้มเหลว — เก็บใน $?
  • exit N จบสคริปต์พร้อมรหัส — ไม่ใส่ = ใช้รหัสคำสั่งสุดท้าย
  • true/false/: = คำสั่งที่คืน 0/1/0 เฉย ๆ (loop, placeholder)
  • A && B รัน B เมื่อ A สำเร็จ, A || B รัน B เมื่อ A ล้มเหลว (short-circuit)
  • A && B || C ไม่ใช่ if-then-else — ใช้ if เต็มเมื่อตรรกะสำคัญ
  • ! cmd กลับ exit status
  • if รับ คำสั่งอะไรก็ได้ — if grep -q ..., if ./script.sh — ไม่จำเป็นต้อง [[ ]]
  • รหัสมาตรฐาน: 1 ทั่วไป, 2 ใช้ผิด, 126 รันไม่ได้, 127 ไม่เจอคำสั่ง, 128+N ถูก signal ฆ่า

จบเฟส 1 — บทถัดไปเข้าเฟส 2 เรื่องตรรกะ เริ่มจาก [ ] กับ [[ ]] ต่างกันอย่างไร และทำไม [[ ]] ปลอดภัยกว่า