Bash อ่านและรันบรรทัดคำสั่งอย่างไร



บั๊กสคริปต์ของมือใหม่เกือบทั้งหมดมาจากความไม่เข้าใจว่า Bash “อ่าน” บรรทัดหนึ่ง ๆ อย่างไร โดยเฉพาะเรื่องช่องว่าง บทนี้จะทำให้คุณเห็นภาพว่าเกิดอะไรขึ้นระหว่างที่คุณกด Enter กับตอนที่โปรแกรมเริ่มทำงาน

บรรทัดคำสั่ง = คำแรก + อาร์กิวเมนต์

เมื่อคุณพิมพ์บรรทัดหนึ่งแล้วกด Enter Bash จะ แบ่งบรรทัดออกเป็นคำ ๆ ด้วยช่องว่าง (เรียกว่า word splitting) แล้ว

  • คำแรก = ชื่อสิ่งที่จะรัน (โปรแกรม, builtin, ฟังก์ชัน, alias)
  • คำที่เหลือ = อาร์กิวเมนต์ ส่งต่อให้สิ่งนั้นเป็นรายการสตริง
cp   report.txt   /backup/

Bash เห็นเป็น: รันโปรแกรม cp โดยส่งอาร์กิวเมนต์ 2 ตัว → ["report.txt", "/backup/"]

จำนวนช่องว่างระหว่างคำไม่สำคัญ — หนึ่งช่องหรือสิบช่องก็ได้ผลเหมือนกัน เพราะ Bash ยุบช่องว่างที่ไม่ได้ครอบ quote

พิมพ์:   cp     a.txt      b.txt
Bash เห็น:  [cp] [a.txt] [b.txt]     ← ช่องว่างส่วนเกินหายไป

ทำไมช่องว่างถึงเป็นเรื่องใหญ่

เพราะช่องว่างคือ ตัวแบ่งอาร์กิวเมนต์ ถ้าค่าของคุณมีช่องว่างอยู่ข้างใน Bash จะแบ่งมันเป็นหลายคำโดยไม่ตั้งใจ

file="my report.txt"
rm $file            # Bash เห็น: rm [my] [report.txt]  — ลบผิดไฟล์! (หรือ error)
rm "$file"          # Bash เห็น: rm [my report.txt]     — ถูกต้อง

นี่คือเหตุผลที่ทั้งซีรีส์จะย้ำ ครอบ "$var" ด้วยเครื่องหมายคำพูดคู่เสมอ (บทที่ 5 เจาะลึก) — มันหยุด Bash ไม่ให้แบ่งค่าของคุณเป็นคำ

เช่นเดียวกับตอนตั้งตัวแปร ช่องว่างรอบ = ทำให้พังทันที

name="Somchai"      # ถูก
name = "Somchai"     # ผิด — Bash เห็น: รันโปรแกรมชื่อ `name` ด้วยอาร์กิวเมนต์ `=` และ `Somchai`
name: command not found

ตัวคั่นคำสั่ง: newline, ;, และการต่อบรรทัด

หนึ่งบรรทัด = หนึ่งคำสั่ง (โดยปริยาย) แต่ควบคุมได้

mkdir build          # ขึ้นบรรทัดใหม่ = จบคำสั่ง
cd build

mkdir build; cd build            # ; = คั่นสองคำสั่งในบรรทัดเดียว (เหมือนขึ้นบรรทัดใหม่)

# บรรทัดยาว — ต่อด้วย \ ที่ท้ายบรรทัด (ห้ามมีช่องว่างหลัง \)
tar -czf backup.tar.gz \
    --exclude='*.log' \
    --exclude='node_modules' \
    /var/www/myapp

\ + Enter บอก Bash ว่า “บรรทัดยังไม่จบ ต่อกันเลย” มีประโยชน์มากเวลาคำสั่งมี option เยอะ ทำให้อ่านง่ายและ diff สวยใน git

บางที Bash รู้เองว่าคำสั่งยังไม่จบ เช่นหลัง |, &&, || หรือใน if/for ที่ยังไม่ปิด — ไม่ต้องใส่ \

cat access.log |
    grep 404 |
    wc -l

รันเบื้องหลังด้วย &

& ต่อท้ายคำสั่งสั่งให้รันเบื้องหลัง shell ไม่รอ ให้ prompt กลับมาทันที

long-running-task &          # รันไป prompt กลับมาเลย
echo "task started, PID = $!"

; กับ & ต่างกัน: ; รอให้เสร็จก่อนทำอันต่อไป, & ไม่รอ (บทที่ 28 ว่าด้วย job control)

builtin กับโปรแกรมภายนอก

“คำสั่ง” ที่คุณพิมพ์มีที่มาต่างกัน เรียงตามลำดับที่ Bash ค้นหา

  1. alias — ชื่อย่อที่คุณตั้งเอง (alias ll='ls -l')
  2. ฟังก์ชัน — นิยามในสคริปต์หรือ .bashrc
  3. builtin — คำสั่งที่อยู่ใน bash เอง ไม่ต้องเรียก process ใหม่ (cd, echo, read, test, [, [[, pwd, export)
  4. โปรแกรมภายนอก — ไฟล์ใน $PATH (ls, grep, cp อยู่ที่ /usr/bin/...)

เช็กว่าอันไหนเป็นอะไรด้วย type

type cd
type ls
type -a echo        # -a = แสดงทุกที่ที่เจอชื่อนี้
command -v grep     # แสดงแค่ path (เหมาะใช้ในสคริปต์เช็กว่ามีคำสั่งไหม)
cd is a shell builtin
ls is aliased to `ls --color=auto'
echo is a shell builtin
echo is /usr/bin/echo
/usr/bin/grep

ทำไมต้องรู้: cd ต้อง เป็น builtin — ถ้ามันเป็นโปรแกรมภายนอก มันจะ cd ใน process ลูกแล้วลูกก็ตาย โฟลเดอร์ของ shell คุณไม่เปลี่ยน builtin กับ external บางตัวชื่อซ้ำกัน (echo, test, kill, printf) และมีพฤติกรรมต่างกันนิด ๆ — ในสคริปต์ builtin จะถูกใช้ก่อน

exit status — คำสั่งบอกว่าสำเร็จหรือไม่

ทุกคำสั่งเมื่อจบจะทิ้ง exit status เป็นตัวเลข 0–255

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

ls /ไม่มีจริง 2> /dev/null
echo $?              # 2

$? เก็บ exit status ของคำสั่งล่าสุด นี่คือหัวใจของการตัดสินใจใน bash — if, &&, ||, set -e ทั้งหมดดูที่ตัวเลขนี้ (บทที่ 8 เจาะลึก)

Bash ประมวลผลบรรทัดตามลำดับนี้

พอกด Enter Bash ทำหลายขั้นก่อนรันจริง (บทที่ 5, 22, 24 จะลงรายละเอียด) คร่าว ๆ คือ

บรรทัดที่พิมพ์
   ↓ แยก token, ดูโครงสร้าง (|  &&  ;  ( ))
   ↓ brace expansion      {a,b}     → a b
   ↓ tilde expansion      ~         → /home/somchai
   ↓ parameter expansion  $var      → ค่าของมัน
   ↓ command substitution $(cmd)    → ผลลัพธ์ของ cmd
   ↓ arithmetic           $((1+2))  → 3
   ↓ word splitting       แบ่งผลลัพธ์ที่ไม่ได้ครอบ quote ด้วย IFS
   ↓ pathname expansion   *.txt     → รายชื่อไฟล์
   ↓ ลบ quote ออก
   → รันคำสั่งด้วยอาร์กิวเมนต์สุดท้าย

จำลำดับนี้ไว้ในหัว แล้วบั๊กแปลก ๆ จะเข้าใจได้เกือบหมด เช่น “ทำไมใส่ quote รอบ * แล้วมันไม่ขยาย” (เพราะ pathname expansion ไม่ทำงานในสิ่งที่ครอบ quote)

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

  • ช่องว่างรอบ = — x = 5 ผิด Bash หาโปรแกรมชื่อ x ต้อง x=5 ติดกัน
  • ไม่ครอบ "$var" — ค่าที่มีช่องว่างจะถูกแบ่งเป็นหลายอาร์กิวเมนต์ ครอบ quote เสมอ
  • มีช่องว่างหลัง \ ตอนต่อบรรทัด — \ จะ escape ช่องว่างแทนที่จะ escape newline บรรทัดไม่ต่อ ตรวจให้ \ เป็นตัวสุดท้ายจริง ๆ
  • คิดว่า ; กับ & เหมือนกัน — ; รอให้เสร็จ, & ไม่รอ (รันเบื้องหลัง)
  • งงว่าทำไม alias ไม่ทำงานในสคริปต์ — โดยปริยาย alias ไม่ถูกขยายในสคริปต์ที่ไม่ใช่ interactive ใช้ฟังก์ชันแทน
  • which ในสคริปต์ — which เป็นโปรแกรมภายนอกที่พฤติกรรมไม่แน่นอนข้ามระบบ ใช้ command -v (builtin) เช็กว่ามีคำสั่งไหม

สรุป

  • Bash แบ่งบรรทัดเป็นคำด้วยช่องว่าง: คำแรก = ชื่อโปรแกรม, ที่เหลือ = อาร์กิวเมนต์
  • ช่องว่างที่ไม่ครอบ quote = ตัวแบ่งอาร์กิวเมนต์ → ครอบ "$var" เสมอ กัน word splitting
  • ตั้งตัวแปรห้ามมีช่องว่างรอบ =
  • คั่นคำสั่ง: newline หรือ ; — ต่อบรรทัดยาวด้วย \ (ห้ามมีอะไรตามหลัง)
  • & = รันเบื้องหลังไม่รอ, ; = รอให้เสร็จ
  • ลำดับค้นหาชื่อคำสั่ง: alias → ฟังก์ชัน → builtin → โปรแกรมภายนอกใน $PATH — เช็กด้วย type / command -v
  • ทุกคำสั่งทิ้ง exit status (0 = สำเร็จ) เก็บใน $?
  • Bash ทำ expansion หลายขั้น (brace → tilde → $var → $(...) → splitting → glob) ก่อนรันจริง

บทถัดไปว่าด้วยตัวแปร — วิธีตั้ง อ้างถึง และเข้าใจว่าทำไมใน Bash ทุกอย่างคือสตริง