Bash subshell และการจัดกลุ่มคำสั่ง



“ตั้งตัวแปรใน loop แล้วหายหลัง loop” “cd ในสคริปต์แล้วโฟลเดอร์ไม่เปลี่ยน” — ทั้งหมดคือเรื่อง subshell เข้าใจว่าอะไรสร้าง subshell แล้วบั๊กพวกนี้จะหมดไป

subshell คืออะไร

subshell = process ลูกที่เป็นสำเนาของ shell ปัจจุบัน มันได้ตัวแปร ฟังก์ชัน โฟลเดอร์ปัจจุบันมาทั้งหมด แต่เป็นสำเนา — การเปลี่ยนแปลงข้างในไม่กลับมาที่ shell แม่

x=1
( x=2; echo "ใน subshell: x=$x" )        # ใน subshell: x=2
echo "หลัง subshell: x=$x"                # หลัง subshell: x=1  ← ไม่เปลี่ยน
shell แม่:  x=1, PWD=/home
    │
    ├─ fork → subshell:  x=1 (สำเนา), PWD=/home (สำเนา)
    │           x=2, cd /tmp
    │           echo ...
    │        subshell ตาย
    │
  shell แม่:  x=1, PWD=/home   ← เหมือนเดิม

( ) กับ { } — ต่างกัน

# ( ) — subshell (process ใหม่)
( cd /tmp && rm -rf junk/ )              # cd ไม่กระทบ shell แม่
result=$( echo "hi" )                    # $() ก็คือ subshell

# { } — group (shell เดิม)
{ echo "บรรทัด 1"; echo "บรรทัด 2"; } > out.txt      # redirect ทั้งกลุ่ม
{ cmd1; cmd2; } && echo "ทั้งคู่สำเร็จ"
( ... ){ ...; }
processลูกใหม่ (subshell)shell เดิม
ตัวแปร/cd ข้างในไม่รอดออกมารอด (เปลี่ยนจริง)
syntaxไม่ต้องมี ; ก่อนปิดต้องมี ; (หรือ newline) ก่อน } และช่องว่างหลัง {
ต้นทุนfork process (ช้ากว่า)เกือบฟรี
ใช้ตอนจำกัดผลข้างเคียงจัดกลุ่มเพื่อ redirect/&&

อะไรสร้าง subshell โดยไม่รู้ตัว

  1. ทุกฝั่งของ pipe |
count=0
seq 5 | while read -r n; do (( count++ )); done
echo "$count"        # 0 — while อยู่ใน subshell
  1. command substitution $(...) และ `...`
files=$( cd /data; ls )      # cd อยู่ใน subshell — shell แม่ไม่ย้าย
  1. background &
{ sleep 5; echo done; } &    # กลุ่มนี้รันใน subshell เบื้องหลัง
  1. ( ... ) ที่เขียนเอง
  1. process substitution <(...) >(...)

ไม่สร้าง subshell: { }, ฟังก์ชัน (รันใน shell เดิม), source, loop ธรรมดา (ที่ไม่ได้อยู่หลัง |)

ใช้ subshell จำกัดผลข้างเคียง

จำกัด cd

# ต้องการ tar โฟลเดอร์ปลายทาง โดยไม่ย้าย PWD ของสคริปต์
( cd "$build_dir" && tar -czf "$OLDPWD/release.tar.gz" . )
echo "ยังอยู่ที่ $PWD"        # ไม่เปลี่ยน

# เทียบกับต้องจำ cd กลับเอง
cd "$build_dir" && tar ... && cd -    # เปราะ — ถ้า tar พัง cd - ไม่รัน

จำกัดการเปลี่ยน environment / set

# รันบางอย่างด้วย IFS/option ที่ต่าง โดยไม่กระทบส่วนอื่น
(
    set +e                    # ปิด set -e เฉพาะในนี้
    IFS=,
    export DEBUG=1
    run_flaky_thing
)
# ออกมาแล้ว set -e, IFS, DEBUG กลับเป็นเดิมหมด

รันกลุ่มงานเบื้องหลัง

(
    echo "งานยาว เริ่ม $(date)"
    long_task
    echo "งานยาว จบ $(date)"
) > task.log 2>&1 &

echo "งานเบื้องหลัง PID=$!"

{ } สำหรับ redirect และ && หลายคำสั่ง

# redirect หลายคำสั่งพร้อมกัน
{
    echo "=== รายงาน $(date) ==="
    echo "ดิสก์:"
    df -h
    echo "หน่วยความจำ:"
    free -h
} > report.txt

# die pattern
[[ -f "$config" ]] || { echo "ไม่พบ $config" >&2; exit 1; }

# เงื่อนไขหลายคำสั่ง
if [[ $mode == deploy ]]; then
    { build && test && upload; } || { echo "ขั้นตอนใดล้มเหลว" >&2; exit 1; }
fi

อย่าลืม ; ก่อน } และช่องว่างหลัง { — { echo hi } (ไม่มี ;) จะ error หรือทำงานผิด

exit และ set -e ใน subshell

# exit ใน subshell ออกแค่ subshell ไม่ออกทั้งสคริปต์
( check || exit 1 )
echo "ยังทำงานต่อ"           # ← ถึงตรงนี้แม้ subshell exit 1

# แต่เช็ก exit status ของ subshell ได้
if ( run_isolated_check ); then
    echo "ผ่าน"
fi

# set -e ไม่ inherit เข้า subshell แบบ 100% — พฤติกรรมต่างตามเวอร์ชัน
set -e
( false; echo "อาจถึงหรือไม่ถึงตรงนี้" )     # ขึ้นกับบริบท — อย่าพึ่งพา

ต้นทุนของ subshell

fork process มีราคา — ใน loop ที่วนหมื่นรอบ การมี $(...) หรือ ( ) ทุกรอบทำให้ช้าอย่างเห็นได้ (บทที่ 40)

# ช้า — subshell ทุกรอบ
for f in *.txt; do
    base=$(basename "$f" .txt)
done

# เร็ว — parameter expansion ในตัว
for f in *.txt; do
    base=${f%.txt}
done

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

  • ตั้งตัวแปรใน cmd | while แล้วหาย — pipe = subshell ใช้ < <(cmd) (บทที่ 15)
  • cd ใน $(...) คาดว่า shell ย้ายตาม — ไม่ $() เป็น subshell
  • { cmd1; cmd2 } ลืม ; ก่อน } หรือช่องว่างหลัง { — syntax error หรือทำงานผิด
  • ( exit 1 ) คาดว่าจบสคริปต์ — ออกแค่ subshell ใช้ || exit 1 ข้างนอก หรือไม่ใช้ subshell
  • ใช้ ( ) แทน { } เพื่อ group — เสีย performance โดยไม่จำเป็น ใช้ { } ถ้าไม่ต้องการ isolation
  • พึ่งพา set -e ให้ทำงานใน subshell เหมือน shell หลัก — พฤติกรรมต่างตามเวอร์ชัน เช็ก exit status ชัด ๆ
  • ( cd x; ...) ไม่มี && — ถ้า cd พัง คำสั่งถัดไปรันใน PWD ผิด ใช้ ( cd x && ... )

สรุป

  • ( ... ) = subshell — process ลูก ตัวแปร/cd/set/export ข้างในไม่รอดออกมา
  • { ...; } = group — shell เดิม การเปลี่ยนแปลงมีผลจริง ต้องมี ; ก่อน } + ช่องว่างหลัง {
  • สร้าง subshell โดยไม่รู้ตัว: ทุกฝั่งของ |, $(...), &, <(...)
  • ไม่สร้าง: { }, ฟังก์ชัน, source, loop ที่ไม่ได้อยู่หลัง pipe
  • ใช้ ( ) จำกัดผล: ( cd dir && cmd ) ไม่ย้าย PWD, ( set +e; IFS=,; ... ) ไม่กระทบส่วนอื่น
  • ใช้ { } เพื่อ redirect หลายคำสั่ง และ || { echo; exit 1; } (die pattern)
  • exit ใน subshell ออกแค่ subshell — subshell มีต้นทุน fork (เลี่ยงใน loop ใหญ่)

บทถัดไปว่าด้วย job control — &, jobs, fg/bg, wait และการรันงานหลายอย่างขนานกัน