Bash เงื่อนไขและการทดสอบ ([ ] vs [[ ]])



“ถ้าไฟล์นี้มีอยู่” “ถ้าตัวแปรว่าง” “ถ้าเลขนี้มากกว่า 10” — ทั้งหมดคือการทดสอบที่คืน exit status ให้ if เอาไปใช้ Bash มีเครื่องมือทดสอบสามแบบ บทนี้บอกว่าใช้อันไหนและทำไม

test, [ ], [[ ]] — สามพี่น้อง

test -f /etc/hostname          # test เป็นคำสั่ง คืน 0 ถ้าจริง
[ -f /etc/hostname ]           # [ คือชื่ออีกอันของ test — ต้องปิดด้วย ]
[[ -f /etc/hostname ]]         # [[ เป็น keyword ของ bash — ฉลาดกว่า
  • test / [ ] — เป็นคำสั่ง (POSIX มาตรฐาน) [ เป็นโปรแกรม/builtin ที่ชื่อ [ จริง ๆ และ ] เป็นแค่อาร์กิวเมนต์สุดท้ายที่มันต้องการ เพราะเป็นคำสั่งธรรมดา จึงโดน word splitting และ glob เหมือนคำสั่งอื่น
  • [[ ]] — เป็น keyword พิเศษของ bash (ไม่ใช่คำสั่ง) Bash parse มันแบบพิเศษ ไม่ทำ word splitting กับ glob ข้างใน ปลอดภัยกว่ามาก

ทำไม [[ ]] ปลอดภัยกว่า

file=""
[ -f $file ]              # กลายเป็น [ -f ]  → "unary operator expected" (พัง)
[ -f "$file" ]            # [ -f "" ]  → เท็จ (โอเค แต่ต้องครอบ quote เอง)
[[ -f $file ]]            # [[ -f "" ]]  → เท็จ (ไม่ต้องครอบ quote — bash จัดการให้)

name="a b"
[ "$name" = "a b" ]      # ต้องครอบ ไม่งั้น [ a b = a b ] พัง
[[ $name = "a b" ]]      # ปลอดภัยไม่ต้องครอบฝั่งซ้าย

คำแนะนำ: ใช้ [[ ]] เสมอในสคริปต์ bash ใช้ [ ] เฉพาะเมื่อต้องเขียนให้พกพาไป #!/bin/sh (dash)

ทดสอบไฟล์

[[ -e path ]]      # มีอยู่ (ไฟล์ โฟลเดอร์ อะไรก็ได้)
[[ -f path ]]      # มีอยู่ และเป็นไฟล์ปกติ
[[ -d path ]]      # มีอยู่ และเป็นโฟลเดอร์
[[ -L path ]]      # เป็น symbolic link
[[ -r path ]]      # อ่านได้
[[ -w path ]]      # เขียนได้
[[ -x path ]]      # รัน/เข้าได้
[[ -s path ]]      # มีอยู่ และขนาดไม่เป็นศูนย์
[[ path1 -nt path2 ]]   # path1 ใหม่กว่า path2 (newer than)
[[ path1 -ot path2 ]]   # path1 เก่ากว่า path2 (older than)
if [[ -f "$config" && -r "$config" ]]; then
    source "$config"
else
    echo "ไม่พบหรืออ่าน $config ไม่ได้" >&2
    exit 1
fi

# build ใหม่เฉพาะเมื่อ source เปลี่ยน
if [[ src/main.c -nt build/main.o ]]; then
    gcc -c src/main.c -o build/main.o
fi

ทดสอบสตริง

[[ -z "$str" ]]         # ว่าง (zero length)
[[ -n "$str" ]]         # ไม่ว่าง
[[ "$a" == "$b" ]]      # เท่ากัน (ใน [[ ]] ใช้ = หรือ == ก็ได้)
[[ "$a" != "$b" ]]      # ไม่เท่ากัน
[[ "$a" < "$b" ]]       # เรียงก่อน (ตามลำดับตัวอักษร ASCII)

ระวัง: ใน [ ] ต้อง escape < เป็น \< (ไม่งั้นมันเป็น redirection) — อีกเหตุผลที่ [[ ]] ดีกว่า

read -r -p "ดำเนินการต่อ? " ans
if [[ -z "$ans" ]]; then
    echo "ไม่ตอบ — ยกเลิก"
    exit 0
fi

ทดสอบตัวเลข

คนละตัวดำเนินการกับสตริง — ตัวเลขใช้ตัวย่อภาษาอังกฤษ

ตัวเลขสตริงความหมาย
-eq==เท่ากัน
-ne!=ไม่เท่ากัน
-lt<น้อยกว่า
-leน้อยกว่าหรือเท่ากับ
-gt>มากกว่า
-geมากกว่าหรือเท่ากับ
count=5
[[ $count -gt 3 ]]           # จริง
[[ $count -eq 5 ]]           # จริง

[[ "$count" > "3" ]]         # จริง — แต่นี่เทียบ *สตริง*! "10" > "3" เป็น เท็จ (1 < 3 ตามตัวอักษร)

ทางเลือกที่อ่านง่ายกว่าสำหรับตัวเลข: (( )) (บทที่ 11)

if (( count > 3 && count < 100 )); then
    echo "อยู่ในช่วง"
fi

จับคู่ pattern ด้วย == ใน [[ ]]

ฝั่งขวาของ == ใน [[ ]] ที่ ไม่ครอบ quote เป็น glob pattern

file="report.txt"

[[ $file == *.txt ]]         # จริง — *.txt คือ pattern
[[ $file == "*.txt" ]]       # เท็จ — ครอบ quote = เทียบตรงตัวกับสตริง "*.txt"
[[ $file == report.* ]]      # จริง
[[ $url == https://* ]]      # เช็ก prefix
[[ $name == [A-Z]* ]]        # ขึ้นต้นด้วยตัวพิมพ์ใหญ่

จำ: ครอบ quote ฝั่งซ้าย (ค่า) แต่ไม่ครอบฝั่งขวา (pattern)

regex ด้วย =~ ใน [[ ]]

if [[ "$email" =~ ^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$ ]]; then
    echo "รูปแบบอีเมลถูกต้อง"
fi

version="v2.14.3"
if [[ "$version" =~ ^v([0-9]+)\.([0-9]+)\.([0-9]+)$ ]]; then
    echo "major=${BASH_REMATCH[1]} minor=${BASH_REMATCH[2]} patch=${BASH_REMATCH[3]}"
fi
major=2 minor=14 patch=3
  • ใช้ ERE (extended regex) — + ? | () {} ใช้ได้เลยไม่ต้อง escape
  • BASH_REMATCH[0] = ทั้งส่วนที่ match, [1], [2], … = กลุ่มในวงเล็บ
  • ห้ามครอบ regex ด้วย quote — [[ $x =~ "^[0-9]+$" ]] กลายเป็นเทียบตรงตัว เก็บ regex ในตัวแปรแทนถ้าซับซ้อน:
re='^v([0-9]+)\.([0-9]+)$'
[[ "$version" =~ $re ]]           # ตัวแปร ไม่ครอบ quote

รายละเอียด regex เต็ม ๆ อยู่ในบทที่ 23

รวมเงื่อนไข

[[ -f "$f" && -s "$f" ]]              # และ
[[ "$x" == a || "$x" == b ]]          # หรือ
[[ ! -d "$dir" ]]                     # ไม่
[[ ( "$a" == x || "$a" == y ) && -n "$b" ]]    # จัดกลุ่มด้วย ( )

ใน [[ ]] ใช้ && || ! ( ) ได้ตรง ๆ ใน [ ] ต้องใช้ -a -o \( \) ซึ่ง เลิกใช้แล้ว (deprecated, กำกวม) — เขียนแยกเป็นหลาย [ ] ต่อด้วย &&/|| แทน

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

  • ใช้ -gt กับสตริง / > กับตัวเลข — [[ "10" > "9" ]] เป็น เท็จ (เทียบตัวอักษร) ตัวเลขใช้ -gt หรือ (( ))
  • ลืมช่องว่างใน [ ] — [$x = y] พัง ต้อง [ $x = y ] มีช่องว่างหลัง [ และก่อน ]
  • ครอบ pattern/regex ด้วย quote — [[ $f == "*.txt" ]] และ [[ $x =~ "^[0-9]" ]] กลายเป็นเทียบตรงตัว อย่าครอบฝั่งขวา
  • ใช้ [ ] แล้วตัวแปรว่างทำพัง — [ -n $x ] เมื่อ x ว่าง → [ -n ] → จริงเสมอ! ครอบ "$x" หรือใช้ [[ ]]
  • = กับ == ใน [ ] — POSIX [ ] ใช้ = เท่านั้น, [[ ]] ใช้ได้ทั้งคู่
  • -a -o ใน [ ] — deprecated และกำกวมกับ -a (ทดสอบไฟล์มีอยู่) แยกเป็นหลาย test
  • คิดว่า [[ ]] เป็น POSIX — ไม่ ถ้าสคริปต์ต้องรันบน sh ต้องใช้ [ ]

สรุป

  • สามแบบ: test / [ ] (POSIX, เป็นคำสั่ง โดน splitting+glob) และ [[ ]] (keyword ของ bash, ปลอดภัยกว่า)
  • ใช้ [[ ]] เสมอ ในสคริปต์ bash — ใน [[ ]] ไม่ต้องครอบ "$var" ฝั่งซ้าย
  • ไฟล์: -e -f -d -L -r -w -x -s, -nt/-ot (ใหม่/เก่ากว่า)
  • สตริง: -z (ว่าง) -n (ไม่ว่าง) == !=
  • ตัวเลข: -eq -ne -lt -le -gt -ge (ไม่ใช่ == < > ซึ่งเป็นการเทียบสตริง) — หรือใช้ (( ))
  • [[ $x == pat ]] จับ glob pattern (ไม่ครอบฝั่งขวา), [[ $x =~ re ]] จับ regex → BASH_REMATCH
  • รวมเงื่อนไขใน [[ ]] ด้วย && || ! ( ) — -a/-o ใน [ ] เลิกใช้แล้ว

บทถัดไปนำ [[ ]] มาประกอบกับ if/elif/else และเทคนิคการเขียนเงื่อนไขให้อ่านง่าย