6. Shell Script in Linux

Shell Script คือเครื่องมือทรงพลังสำหรับการอัตโนมัติงาน (Automation) บนระบบ Linux/Unix โดยใช้ภาษา Shell สั่งงานผ่าน Command Interpreter เพื่อรวมคำสั่งหลาย ๆ คำสั่งเข้าด้วยกันให้ทำงานเป็นโปรแกรมเดียว ตั้งแต่งานง่าย ๆ เช่น สำรองไฟล์ ไปจนถึงระบบ Deployment และ Monitoring ที่ซับซ้อน บทนี้จะกล่าวถึงพื้นฐานการเขียน Shell Script ตั้งแต่โครงสร้างพื้นฐาน ตัวแปร เงื่อนไข วนซ้ำ ฟังก์ชัน ไปจนถึงเทคนิคขั้นสูง การจัดการข้อผิดพลาด และตัวอย่างประยุกต์ใช้งานจริง โดยเน้น Bash ซึ่งเป็น Shell ที่ใช้กันแพร่หลายที่สุด

6.1 พื้นฐาน Shell Scripting (Shell Scripting Fundamentals)

Shell Script คือไฟล์ข้อความ (Text File) ที่เก็บคำสั่ง Shell หลายคำสั่งเรียงต่อกัน เพื่อให้ Shell อ่านและประมวลผลตามลำดับ เปรียบเสมือนการเขียน "โปรแกรม" ด้วยภาษาที่ Shell เข้าใจ ข้อดีหลักของ Shell Script คือสามารถนำคำสั่ง CLI ที่ใช้บ่อย ๆ มารวมกันเป็นชุดคำสั่งอัตโนมัติได้ทันทีโดยไม่ต้องคอมไพล์

flowchart LR
    A[ผู้ใช้ User] -->|พิมพ์คำสั่ง
type command| B[Shell
ตัวแปลคำสั่ง]
    B -->|Parse + Expand| C{ประเภท
type?}
    C -->|Builtin| D[ทำงานในตัว Shell
builtin command]
    C -->|External| E[เรียก fork+exec
spawn process]
    C -->|Script File| F[อ่านบรรทัดต่อบรรทัด
read line by line]
    F --> B
    D --> G[ผลลัพธ์
output]
    E --> G

6.1.1 Shell ที่นิยมใช้งาน (Popular Shells)

Shell แต่ละตัวมีไวยากรณ์และความสามารถแตกต่างกัน การเลือกใช้ Shell ขึ้นอยู่กับ Use Case เช่น สคริปต์ที่ต้องพกพาไปใช้หลายระบบ (Portability) ควรใช้ POSIX sh แต่ถ้าใช้งานส่วนตัวเน้นความสะดวกอาจเลือก zsh หรือ fish

ตรวจสอบ Shell ที่ใช้อยู่ปัจจุบันและที่ติดตั้งในระบบ:

# ตรวจสอบ Shell ที่กำลังใช้งานอยู่ check current shell
echo "$SHELL"          # ตัวแปร environment ของ login shell
echo "$0"              # process ตัวที่กำลังรัน

# ดู Shell ที่ติดตั้งทั้งหมดในระบบ list available shells
cat /etc/shells

# เปลี่ยน default shell สำหรับ user (ต้อง logout/login ใหม่)
chsh -s /usr/bin/zsh   # เปลี่ยนเป็น zsh

6.1.2 Shebang (Hash-Bang)

Shebang คืออักขระสองตัวแรกของไฟล์สคริปต์ที่ขึ้นต้นด้วย #! ตามด้วย path ของ interpreter ที่จะใช้รันสคริปต์นี้ Kernel จะอ่าน 2 byte แรก (magic number 0x23 0x21) เมื่อเรียกไฟล์เป็น executable แล้วใช้ interpreter ที่ระบุไว้ในการประมวลผล

#!/bin/bash                    # ใช้ bash โดยตรง path คงที่
#!/usr/bin/env bash            # ค้นหา bash จาก PATH (ยืดหยุ่นกว่า portable)
#!/usr/bin/env -S bash -e      # -S อนุญาต option ผ่าน env (Linux เท่านั้น)
#!/bin/sh                      # POSIX shell (สูงสุดในความ portable)
#!/usr/bin/env python3         # ใช้ Python เป็น interpreter ก็ได้

ความแตกต่างระหว่าง #!/bin/bash กับ #!/usr/bin/env bash:

• #!/bin/bash — ใช้ bash จาก path เฉพาะ ถ้าเครื่องไม่ใช้ bash ที่ /bin/bash (เช่น FreeBSD ที่ติดตั้ง bash จาก ports จะอยู่ที่ /usr/local/bin/bash) สคริปต์จะรันไม่ได้
• #!/usr/bin/env bash — ใช้คำสั่ง env ค้นหา bash จาก $PATH ทำให้พกพาได้ดีกว่า เป็น Best Practice ของสคริปต์สมัยใหม่

6.1.3 การกำหนดสิทธิ์ Execute (Execute Permission)

ก่อนรันสคริปต์ด้วย ./script.sh ต้องตั้งสิทธิ์ execute ให้กับไฟล์ก่อน เพราะ Linux จะตรวจสอบ permission bit x ก่อนอนุญาตให้รันไฟล์เป็นโปรแกรม

# สร้างสคริปต์ตัวอย่าง create example script
cat > hello.sh <<'EOF'
#!/usr/bin/env bash
echo "สวัสดี $USER, วันนี้วันที่ $(date +%Y-%m-%d)"
EOF

# ตรวจสอบ permission ก่อน check current permission
ls -l hello.sh
# ผลลัพธ์: -rw-r--r-- 1 user user 78 ... hello.sh

# ใส่สิทธิ์ execute ให้เจ้าของไฟล์ add execute permission
chmod +x hello.sh
# หรือเฉพาะ owner เท่านั้น
chmod u+x hello.sh
# หรือใช้ octal
chmod 755 hello.sh

ls -l hello.sh
# ผลลัพธ์: -rwxr-xr-x 1 user user 78 ... hello.sh

# รันสคริปต์
./hello.sh

6.1.4 วิธีการรันสคริปต์ (Methods to Run Scripts)

มี 3 วิธีหลักในการรันสคริปต์ ซึ่งให้ผลลัพธ์ต่างกันด้านการ Spawn Process และการแชร์ Environment Variable

flowchart TD
    P[Parent Shell
เปิดอยู่] --> M{วิธีรัน
method?}
    M -->|./script.sh| S1[Spawn Subshell
fork + exec]
    M -->|bash script.sh| S2[Spawn Subshell
ระบุ interpreter]
    M -->|source script.sh
หรือ . script.sh| S3[รันใน Shell ปัจจุบัน
ไม่ fork]
    S1 --> R1[Variable ในสคริปต์
หายไปเมื่อจบ]
    S2 --> R1
    S3 --> R2[Variable คงอยู่
ใน Shell หลัก]

# ----- วิธีที่ 1: ./script.sh -----
# ต้องมี shebang และ executable permission
# จะ spawn subshell ใหม่
./hello.sh

# ----- วิธีที่ 2: bash script.sh -----
# ไม่ต้องมี shebang หรือ executable permission
# ระบุ interpreter ตอนเรียก ใช้ทดสอบสคริปต์ได้
bash hello.sh
sh hello.sh        # รันด้วย POSIX sh

# ----- วิธีที่ 3: source script.sh หรือ . script.sh -----
# รันในกระบวนการ shell ปัจจุบัน (ไม่ spawn subshell)
# ใช้สำหรับโหลดตัวแปร, function เข้า shell ปัจจุบัน
source ~/.bashrc
. ~/.bashrc          # ตัวจุด . เทียบเท่า source แต่ POSIX

# ตัวอย่างความแตกต่าง difference example
cat > setvar.sh <<'EOF'
#!/usr/bin/env bash
export MYVAR="Hello"
EOF
chmod +x setvar.sh

./setvar.sh ; echo "$MYVAR"     # ว่างเปล่า: subshell หายไปแล้ว
source setvar.sh ; echo "$MYVAR" # แสดง "Hello": รันใน shell เดิม

6.1.5 Comment และการเขียน Header

Comment ใน Shell Script ขึ้นต้นด้วยเครื่องหมาย # (ยกเว้นบรรทัดแรกที่เป็น Shebang) Shell จะข้ามทุกอย่างหลัง # ในบรรทัดนั้น การเขียน Header ที่ดีช่วยให้ผู้อื่นเข้าใจวัตถุประสงค์ ผู้เขียน วันที่ และวิธีใช้งาน

#!/usr/bin/env bash
#===============================================================================
# ชื่อสคริปต์   : backup_home.sh
# คำอธิบาย     : สำรองข้อมูล home directory ไปยัง external drive
# Author       : อรรถพล คงหวาน <attapon@example.com>
# วันที่สร้าง   : 2026-04-25
# Version      : 1.2.0
# Usage        : ./backup_home.sh [destination]
# Dependencies : tar, gzip, rsync
# Exit Code    : 0=สำเร็จ, 1=Argument ผิด, 2=Destination ไม่พบ
#===============================================================================

# ----- ส่วนของการประกาศตัวแปร global -----
SOURCE_DIR="$HOME"            # ต้นทางที่จะสำรอง source directory
DEST_DIR="${1:-/mnt/backup}"  # ปลายทาง รับจาก arg ตัวที่ 1

# Multi-line comment (ไม่มีในตัว แต่ใช้ : (no-op) + heredoc แทนได้)
: <<'BLOCK_COMMENT'
นี่คือคอมเมนต์หลายบรรทัด
ใช้คำสั่ง : (no-op) ร่วมกับ heredoc
ที่ไม่ทำอะไรเลย ใช้แทน /* ... */ ของภาษา C
BLOCK_COMMENT

# TODO: เพิ่มการตรวจสอบเนื้อที่ disk ก่อนสำรอง
# FIXME: บั๊กเรื่อง symlink ลึกซ้อน

echo "เริ่มต้นสำรอง $SOURCE_DIR -> $DEST_DIR"

ระบบ Tag ที่นิยมในคอมเมนต์: TODO: (สิ่งที่ต้องทำต่อ), FIXME: (จุดที่มีบั๊ก), NOTE: (หมายเหตุสำคัญ), HACK: (วิธีแก้ปัญหาชั่วคราว), XXX: (จุดอันตราย)

6.2 ตัวแปร (Variables)

ตัวแปรใน Shell ใช้เก็บค่าข้อมูลที่จะนำมาใช้ในสคริปต์ ตัวแปรใน Shell เป็น untyped (ไม่มีชนิดข้อมูลตายตัว) ทุกตัวแปรเก็บเป็น string โดยปริยาย แต่สามารถใช้ในบริบท arithmetic เพื่อตีความเป็นตัวเลขได้

6.2.1 การประกาศและเรียกใช้ตัวแปร (Variable Declaration & Reference)

#!/usr/bin/env bash

# ----- การประกาศตัวแปร declaration -----
# กฎสำคัญ: ห้ามมีช่องว่างรอบ = อย่างเด็ดขาด
name="Moo"               # ถูกต้อง correct
age=42                   # ถูกต้อง correct
# name = "Moo"           # ❌ ผิด: shell จะคิดว่า name คือคำสั่ง

# ----- การเรียกใช้ reference -----
echo $name               # Moo
echo "$name"             # Moo (แนะนำ ใส่ double-quote ป้องกัน word splitting)
echo "${name}"           # Moo (รูปแบบเต็ม unambiguous)
echo "${name}_suffix"    # Moo_suffix (ต้องใช้ {} เมื่อต่อกับตัวอักษร)
echo '$name'             # $name (single-quote ไม่ขยายตัวแปร no expansion)

# ----- ตัวแปรที่ยังไม่ได้กำหนดค่า unset variable -----
echo "$undef"            # ว่างเปล่า empty string
echo "${undef:-default}" # default (ถ้าว่าง ใช้ค่า default)
echo "${undef:=default}" # กำหนดค่า default ให้ตัวแปรด้วย assign
echo "${undef:?error}"   # ถ้าว่าง พิมพ์ error และออก exit
echo "${undef:+alt}"     # ถ้าไม่ว่าง คืน alt มิฉะนั้นว่าง

ตารางสรุป Parameter Expansion พื้นฐาน:

6.2.2 Local vs Global Variable

ตัวแปรที่ประกาศนอก function หรือใน global scope จะเป็น global เข้าถึงได้ทุกที่ในสคริปต์ ส่วน local ใช้ในฟังก์ชันเพื่อจำกัด scope ให้อยู่ในฟังก์ชันนั้น ๆ ป้องกันการชนกับตัวแปรชื่อเดียวกันภายนอก

#!/usr/bin/env bash

# ตัวแปร global ใช้ได้ทั้งสคริปต์
counter=0

increment() {
    local counter=10        # ตัวแปร local เฉพาะใน function
    counter=$((counter + 1))
    echo "ภายใน function: $counter"   # 11
}

increment
echo "ภายนอก function: $counter"      # 0 (ไม่ถูกแก้ไข)

# ตัวอย่างที่ไม่มี local อันตราย
without_local() {
    counter=99              # แก้ตัวแปร global โดยไม่ตั้งใจ!
}
without_local
echo "หลังเรียก without_local: $counter"  # 99 (ถูกแก้ไข)

คำแนะนำ: ใช้ local กับตัวแปรในฟังก์ชันเสมอ เพื่อป้องกัน Side Effect ที่ไม่คาดคิด นี่เป็น Best Practice ที่สำคัญมาก

6.2.3 Environment Variables (ตัวแปรสภาพแวดล้อม)

Environment Variable คือตัวแปรที่ส่งต่อจาก Process แม่ไปยัง Process ลูก ใช้คำสั่ง export เพื่อทำให้ตัวแปร global นั้นเข้าถึงได้จาก subshell และโปรแกรมที่เรียกขึ้นมา

# ----- ตัวแปร environment ที่สำคัญ important env variables -----
echo "$HOME"     # /home/moo - home directory ของผู้ใช้
echo "$USER"     # moo - ชื่อผู้ใช้ปัจจุบัน
echo "$PWD"      # /current/dir - working directory ปัจจุบัน
echo "$OLDPWD"   # directory ก่อนหน้า cd
echo "$SHELL"    # /bin/bash - login shell
echo "$PATH"     # /usr/local/bin:/usr/bin:... - paths สำหรับค้นคำสั่ง
echo "$LANG"     # th_TH.UTF-8 - locale ระบบ
echo "$EDITOR"   # /usr/bin/nvim - editor default
echo "$TERM"     # xterm-256color - ประเภท terminal
echo "$HOSTNAME" # ชื่อเครื่อง

# ----- การสร้าง environment variable -----
export MY_API_KEY="sk-1234567890"        # ส่งไปยัง subprocess ได้
MY_LOCAL=just-here                       # เฉพาะ shell ปัจจุบัน

# ดูตัวแปร environment ทั้งหมด list all env vars
env
printenv
printenv HOME       # ดูเฉพาะ HOME

# ลบตัวแปร remove
unset MY_API_KEY

การเพิ่ม path เข้า PATH (รูปแบบที่ปลอดภัย):

# ใส่ path ใหม่ไว้ข้างหน้า (ความสำคัญสูง)
export PATH="$HOME/.local/bin:$PATH"

# ใส่ต่อท้าย (ความสำคัญต่ำ)
export PATH="$PATH:/opt/myapp/bin"

6.2.4 Special Variables (ตัวแปรพิเศษ)

Bash มีตัวแปรพิเศษที่ Shell กำหนดให้อัตโนมัติ ใช้เข้าถึงข้อมูลเกี่ยวกับสคริปต์และกระบวนการ

#!/usr/bin/env bash
# ทดสอบ: ./args.sh apple "banana split" cherry

echo "ชื่อสคริปต์    : $0"          # ./args.sh
echo "จำนวน arg     : $#"           # 3
echo "arg ตัวที่ 1   : $1"           # apple
echo "arg ตัวที่ 2   : $2"           # banana split
echo "arg ตัวที่ 3   : $3"           # cherry
echo "arg ทั้งหมด @ : $@"           # apple banana split cherry
echo "arg ทั้งหมด *  : $*"           # apple banana split cherry
echo "PID           : $$"           # เช่น 12345
echo "บรรทัดนี้     : $LINENO"

# ความแตกต่าง $@ vs $* เมื่อใส่ double quote
for arg in "$@"; do echo "@: [$arg]"; done
# @: [apple]
# @: [banana split]
# @: [cherry]

for arg in "$*"; do echo "*: [$arg]"; done
# *: [apple banana split cherry]   ← รวมเป็นตัวเดียว

# ตรวจสอบ exit code
ls /nonexistent 2>/dev/null
echo "exit code: $?"   # 2 (ไม่พบไฟล์)
ls / >/dev/null
echo "exit code: $?"   # 0 (สำเร็จ)

6.2.5 Read-only Variable (ตัวแปรอ่านอย่างเดียว)

ใช้ readonly หรือ declare -r เพื่อทำให้ตัวแปรเปลี่ยนค่าไม่ได้อีก เหมาะสำหรับค่าคงที่ (Constant) เช่น path สำคัญ, version number, configuration

#!/usr/bin/env bash

readonly VERSION="1.0.0"
readonly LOG_DIR="/var/log/myapp"
declare -r MAX_RETRY=3              # เทียบเท่า readonly

echo "Version: $VERSION"

# พยายามแก้ไข จะ error
VERSION="2.0.0"
# bash: VERSION: readonly variable

# ดูตัวแปร readonly ทั้งหมด list readonly variables
readonly -p
declare -r

6.2.6 Array (อาเรย์)

Bash รองรับ Array สองแบบ: Indexed Array (ดัชนีเป็นตัวเลข เริ่มจาก 0) และ Associative Array (ดัชนีเป็น string คล้าย Hash Map ของ Python หรือ Map ของ JavaScript)

#!/usr/bin/env bash

# ----- Indexed Array -----
fruits=("apple" "banana" "cherry" "durian")

# เข้าถึง element
echo "${fruits[0]}"        # apple (index เริ่มจาก 0)
echo "${fruits[2]}"        # cherry

# เข้าถึงทั้งหมด
echo "${fruits[@]}"        # apple banana cherry durian
echo "${fruits[*]}"        # apple banana cherry durian
echo "${#fruits[@]}"       # 4 (จำนวน element)

# index ทั้งหมด indices
echo "${!fruits[@]}"       # 0 1 2 3

# Slice (เริ่ม:จำนวน)
echo "${fruits[@]:1:2}"    # banana cherry

# เพิ่ม element
fruits+=("elderberry")     # ต่อท้าย
fruits[10]="fig"           # เพิ่มที่ index 10 (ระหว่างจะ sparse)

# ลบ element
unset 'fruits[1]'          # ลบ index 1 (ส่วนที่เหลือไม่ shift)

# วน loop ผ่าน array
for fruit in "${fruits[@]}"; do
    echo "ผลไม้: $fruit"
done

# ----- Associative Array (Bash 4+) -----
declare -A capital
capital["Thailand"]="Bangkok"
capital["Japan"]="Tokyo"
capital["France"]="Paris"

# หรือประกาศพร้อมค่าเริ่มต้น
declare -A scores=(
    ["math"]=85
    ["english"]=72
    ["thai"]=90
)

echo "${capital[Thailand]}"          # Bangkok
echo "${!scores[@]}"                 # math english thai (keys)
echo "${scores[@]}"                  # 85 72 90 (values)

# วน loop ผ่าน associative array
for subject in "${!scores[@]}"; do
    echo "$subject = ${scores[$subject]}"
done

# ตรวจสอบว่ามี key หรือไม่
if [[ -v capital["Thailand"] ]]; then
    echo "มี key Thailand"
fi

6.2.7 การรับค่าจากผู้ใช้ (User Input with read)

คำสั่ง read ใช้รับ input จากผู้ใช้ผ่าน stdin บรรจุลง variable

#!/usr/bin/env bash

# ----- รับค่าง่าย ๆ -----
echo -n "ชื่อของคุณ: "
read name
echo "สวัสดี $name"

# ----- รับค่าพร้อม prompt (-p) -----
read -p "อายุของคุณ: " age
echo "อายุ $age ปี"

# ----- ซ่อนการพิมพ์ (-s) เหมาะกับ password -----
read -sp "รหัสผ่าน: " password
echo                          # ขึ้นบรรทัดใหม่ (เพราะ -s ไม่พิมพ์ newline)
echo "ยาว ${#password} ตัวอักษร"

# ----- กำหนด timeout (-t วินาที) -----
if read -t 5 -p "ตอบใน 5 วินาที: " answer; then
    echo "คำตอบ: $answer"
else
    echo
    echo "หมดเวลา timeout"
fi

# ----- จำกัดจำนวนตัวอักษร (-n) -----
read -n 1 -p "กด y เพื่อยืนยัน: " confirm
echo
[[ "$confirm" == "y" ]] && echo "ยืนยัน" || echo "ยกเลิก"

# ----- รับหลายตัวแปรพร้อมกัน (แยกด้วย IFS) -----
read -p "ชื่อ-นามสกุล: " first last
echo "ชื่อ: $first | นามสกุล: $last"

# ----- รับเป็น array (-a) -----
read -p "ใส่หลายค่าเว้นวรรค: " -a items
echo "ได้ ${#items[@]} ค่า: ${items[@]}"

# ----- รับจาก file ทีละบรรทัด -----
while IFS= read -r line; do
    echo "บรรทัด: $line"
done < /etc/hostname

ตารางสรุป option ของ read:

6.3 การดำเนินการและการคำนวณ (Operations & Computation)

6.3.1 Arithmetic Expansion (การคำนวณตัวเลข)

Bash รองรับการคำนวณ integer ในตัว ผ่าน 3 รูปแบบ: $((...)) (แนะนำ), let และ expr (เก่า)

#!/usr/bin/env bash

# ----- รูปแบบที่แนะนำ: $((...))  -----
a=10
b=3

echo $((a + b))     # 13 บวก
echo $((a - b))     # 7  ลบ
echo $((a * b))     # 30 คูณ
echo $((a / b))     # 3  หาร (integer division ตัดทศนิยม)
echo $((a % b))     # 1  modulo
echo $((a ** b))    # 1000 ยกกำลัง

# ใช้ตัวแปรโดยตรงไม่ต้องใส่ $
echo $((a + 5))     # 15
echo $(((a + b) * 2))  # 26

# ----- bitwise operators -----
echo $((5 & 3))     # 1   AND
echo $((5 | 3))     # 7   OR
echo $((5 ^ 3))     # 6   XOR
echo $((~5))        # -6  NOT
echo $((5 << 1))    # 10  shift left
echo $((20 >> 2))   # 5   shift right

# ----- comparison ใน arithmetic context (คืน 1=true, 0=false) -----
echo $((a > b))     # 1
echo $((a == b))    # 0

# ----- compound assignment -----
((counter++))       # increment เพิ่มทีละ 1
((counter--))       # decrement
((counter += 5))    # counter = counter + 5
((counter *= 2))    # counter = counter * 2

# ----- let -----
let result=10*5+2
echo "$result"      # 52

# ----- expr (รูปแบบเก่า ต้องเว้นวรรค) -----
result=$(expr 10 + 5)
echo "$result"      # 15
result=$(expr 10 \* 5)   # ต้อง escape * เพราะ shell ตีความเป็น glob
echo "$result"      # 50

# ----- ทศนิยม: ใช้ bc หรือ awk -----
echo "scale=4; 10/3" | bc            # 3.3333
awk 'BEGIN { printf "%.4f\n", 10/3 }' # 3.3333

# function สำหรับคำนวณทศนิยม
calc() { awk "BEGIN { print $* }"; }
calc "1.5 * 2.7"      # 4.05
calc "sqrt(16)"       # 4

สมการตัวอย่าง: ค่าเฉลี่ยเลขคณิต (Arithmetic Mean)

โดย $\bar{x}$ คือค่าเฉลี่ย, $n$ คือจำนวนข้อมูล, และ $x_i$ คือค่าข้อมูลตัวที่ $i$

# implement สูตรค่าเฉลี่ยใน shell
calc_mean() {
    local sum=0
    local count=$#
    for n in "$@"; do
        sum=$((sum + n))
    done
    awk "BEGIN { printf \"%.2f\n\", $sum/$count }"
}
calc_mean 85 72 90 78 95   # 84.00

6.3.2 String Manipulation (การจัดการสตริง)

Bash มี Parameter Expansion สำหรับจัดการสตริงได้หลากหลายโดยไม่ต้องเรียกโปรแกรมนอก เช่น sed หรือ awk ทำให้สคริปต์เร็วขึ้น

#!/usr/bin/env bash

s="Hello World, Linux is Awesome"

# ความยาว length
echo "${#s}"              # 29

# substring
echo "${s:0:5}"           # Hello (เริ่ม 0 ยาว 5)
echo "${s:6}"             # World, Linux is Awesome (จาก index 6 ถึงท้าย)
echo "${s:6:5}"           # World
echo "${s: -7}"           # Awesome (negative ต้องมีเว้นวรรค)
echo "${s: -7:3}"         # Awe

# replace
echo "${s/World/Earth}"   # Hello Earth, Linux is Awesome (ครั้งแรก)
echo "${s//o/0}"          # Hell0 W0rld, Linux is Awes0me (ทั้งหมด)
echo "${s/#Hello/Hi}"     # Hi World, Linux is Awesome (ขึ้นต้นเท่านั้น)
echo "${s/%some/SOME}"    # Hello World, Linux is AweSOME (ลงท้ายเท่านั้น)

# ตัดส่วนนำหน้า (prefix removal)
file="image.tar.gz"
echo "${file#*.}"         # tar.gz   (สั้นสุด)
echo "${file##*.}"        # gz       (ยาวสุด - extension)

# ตัดส่วนท้าย (suffix removal)
echo "${file%.*}"         # image.tar (สั้นสุด)
echo "${file%%.*}"        # image     (ยาวสุด - basename ไม่มี ext)

# upper/lower case
name="moo"
echo "${name^}"           # Moo
echo "${name^^}"          # MOO
echo "${name~}"           # toggle case
greeting="HELLO"
echo "${greeting,}"       # hELLO
echo "${greeting,,}"      # hello

# ตัวอย่างจริง: แยก path
path="/home/moo/projects/script.sh"
echo "directory: ${path%/*}"    # /home/moo/projects
echo "filename:  ${path##*/}"   # script.sh
echo "extension: ${path##*.}"   # sh
echo "basename:  ${path##*/}"
basename="${path##*/}"
echo "name:      ${basename%.*}"  # script

6.3.3 Quoting (การใส่เครื่องหมายคำพูด)

การ Quote เป็นเรื่องสำคัญที่สุดเรื่องหนึ่งใน Shell เพราะส่งผลต่อ Word Splitting, Globbing, Expansion ใช้ผิดอาจทำให้สคริปต์มีบั๊กที่หายาก

#!/usr/bin/env bash

name="Linus Torvalds"

# ไม่มี quote — อันตราย
echo Hello $name        # Hello Linus Torvalds (แต่ถ้า name="*" จะ glob!)
mkdir test\ dir         # ต้อง escape ช่องว่าง

# Double quote — ใช้บ่อยที่สุด แนะนำ
echo "Hello $name"      # Hello Linus Torvalds (ตัวแปรขยาย)
echo "Path: $HOME"      # Path: /home/moo
echo "Today: $(date)"   # Today: ... (command substitution ทำงาน)
echo "Escape: \$name"   # Escape: $name (\$ ไม่ขยาย)
echo "Newline: line1\nline2"  # ไม่ขึ้นบรรทัด — \n ไม่ทำงานใน double-quote!

# Single quote — literal สมบูรณ์
echo 'Hello $name'      # Hello $name (ตัวแปรไม่ขยาย)
echo 'Cost: $5'         # Cost: $5
# echo 'It\'s'          # ❌ ผิด: ไม่สามารถ escape ใน single-quote
echo "It's"             # It's (ใช้ double-quote แทน)
echo 'It'\''s'          # It's (ปิด-escape-เปิด ใหม่)

# ANSI-C quote $'...' — รองรับ escape
echo $'Line1\nLine2'    # Line1
                        # Line2
echo $'Tab\there'       # Tab     here
echo $'\u00e9'          # é (Unicode)
echo $'\x41'            # A (hex)

# ตัวอย่างที่สำคัญ — ใส่ quote เสมอเมื่อใช้กับ filename
file="my document.txt"
# ผิด: ls $file → ls my document.txt (มอง 2 args)
ls "$file"              # ถูกต้อง

# array ก็เช่นกัน
items=("a b" "c" "d e")
for x in ${items[@]}; do echo "ผิด: [$x]"; done   # 4 รอบ!
for x in "${items[@]}"; do echo "ถูก: [$x]"; done # 3 รอบ

กฎทอง: ใส่ "..." รอบตัวแปรเสมอ ยกเว้นกรณีที่ต้องการ word splitting หรือ globbing โดยตั้งใจจริง ๆ

6.4 Conditional Statements (คำสั่งเงื่อนไข)

คำสั่งเงื่อนไขช่วยให้สคริปต์ตัดสินใจการทำงานตามค่าที่ตรวจสอบ Bash มีโครงสร้างเงื่อนไขแบบ if/elif/else, case, และ short-circuit operators

flowchart TD
    Start([เริ่ม start]) --> C{เงื่อนไข
condition}
    C -->|true
exit code 0| T[คำสั่งใน then
then block]
    C -->|false
non-zero| E[คำสั่งใน else
else block]
    T --> End([จบ end])
    E --> End

6.4.1 if / elif / else / fi

โครงสร้างพื้นฐานของ if เช็คเงื่อนไขจาก exit code ของคำสั่ง: 0 = true, อื่น ๆ = false ซึ่งต่างจากภาษาทั่วไปที่ใช้ boolean

#!/usr/bin/env bash

# โครงสร้างพื้นฐาน basic structure
if condition; then
    # ทำเมื่อ true
elif another_condition; then
    # ทำเมื่อ another true
else
    # ทำเมื่อทั้งหมด false
fi

# ----- ตัวอย่างที่ใช้งานจริง -----
score=85

if [[ $score -ge 80 ]]; then
    grade="A"
elif [[ $score -ge 70 ]]; then
    grade="B"
elif [[ $score -ge 60 ]]; then
    grade="C"
elif [[ $score -ge 50 ]]; then
    grade="D"
else
    grade="F"
fi
echo "คะแนน $score ได้เกรด $grade"

# ----- ใช้ exit code โดยตรง -----
if grep -q "ERROR" /var/log/syslog; then
    echo "พบ error ใน log"
fi

# กลับเงื่อนไข negate ด้วย !
if ! ping -c 1 -W 1 8.8.8.8 &>/dev/null; then
    echo "ไม่มี internet"
fi

# ----- One-line if ใช้ ; แยก -----
if [[ -d /tmp ]]; then echo "มี /tmp"; fi

6.4.2 Test File (การทดสอบไฟล์)

#!/usr/bin/env bash

target="/etc/hosts"

# ตรวจสอบประเภทและสิทธิ์ check type & permission
if [[ -e "$target" ]]; then
    echo "✓ มีไฟล์อยู่"
fi

if [[ -f "$target" ]]; then
    echo "✓ เป็น regular file"
elif [[ -d "$target" ]]; then
    echo "✓ เป็น directory"
elif [[ -L "$target" ]]; then
    echo "✓ เป็น symlink"
fi

# ตรวจสอบสิทธิ์
[[ -r "$target" ]] && echo "อ่านได้"
[[ -w "$target" ]] && echo "เขียนได้"
[[ -x "$target" ]] && echo "execute ได้"

# ตรวจสอบขนาด
if [[ -s "$target" ]]; then
    size=$(stat -c%s "$target")
    echo "ไฟล์มีขนาด $size byte"
else
    echo "ไฟล์ว่าง หรือไม่มี"
fi

# เปรียบเทียบเวลา compare timestamps
src="/tmp/source.txt"
dst="/tmp/backup.txt"
touch "$src"; sleep 1; touch "$dst"
if [[ "$src" -nt "$dst" ]]; then
    echo "$src ใหม่กว่า $dst — ต้องสำรองใหม่"
elif [[ "$dst" -nt "$src" ]]; then
    echo "$dst ใหม่กว่า — ทันสมัยแล้ว"
fi

6.4.3 Test String (การทดสอบสตริง)

#!/usr/bin/env bash

name=""
[[ -z "$name" ]] && echo "ชื่อว่าง"     # true
[[ -n "$name" ]] || echo "ชื่อว่าง"     # true (! -n เทียบเท่า -z)

name="moo"
if [[ "$name" == "moo" ]]; then
    echo "ใช่ moo"
fi

# Pattern matching ใน [[ ]] (ไม่ต้องใช้ regex)
filename="report.pdf"
if [[ "$filename" == *.pdf ]]; then
    echo "เป็น PDF"
fi
if [[ "$filename" == report.* ]]; then
    echo "ขึ้นต้นด้วย report"
fi

# Regular expression =~
email="user@example.com"
if [[ "$email" =~ ^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$ ]]; then
    echo "อีเมลถูกต้อง"
    echo "ชื่อ: ${BASH_REMATCH[0]}"  # match เต็ม
fi

# เปรียบเทียบ lexicographic
if [[ "apple" < "banana" ]]; then
    echo "apple มาก่อน banana"
fi

# Capture group ใน regex
date_str="2026-04-25"
if [[ "$date_str" =~ ^([0-9]{4})-([0-9]{2})-([0-9]{2})$ ]]; then
    year="${BASH_REMATCH[1]}"
    month="${BASH_REMATCH[2]}"
    day="${BASH_REMATCH[3]}"
    echo "ปี $year เดือน $month วัน $day"
fi

6.4.4 Test Number (การทดสอบตัวเลข)

#!/usr/bin/env bash

a=10
b=20

# ใช้ใน [ ] หรือ [[ ]] — ใช้ -eq, -ne, -lt, ...
if [[ $a -lt $b ]]; then echo "a น้อยกว่า b"; fi
if [[ $a -eq 10 ]]; then echo "a เท่ากับ 10"; fi
if [[ $a -ne $b ]]; then echo "ไม่เท่ากัน"; fi

# ใช้ใน (( )) — ใช้ ==, !=, <, > ได้เลย
if (( a < b )); then echo "a < b"; fi
if (( a == 10 )); then echo "a == 10"; fi
if (( a + 5 == 15 )); then echo "a+5 = 15"; fi

# ⚠️ ระวัง: ใน [[ ]] ห้ามใช้ < > กับตัวเลข เพราะจะเปรียบเทียบเป็น string!
[[ "10" < "9" ]] && echo "ผิด: 10 < 9 เพราะ '1' < '9' lexicographic"
(( 10 < 9 )) || echo "ถูกต้อง: 10 ไม่น้อยกว่า 9"

6.4.5 [[ ... ]] vs [ ... ] vs test

test, [ ] เป็นคำสั่งภายนอก/builtin POSIX ดั้งเดิม ส่วน [[ ]] เป็น keyword ของ Bash ที่มี Feature เพิ่ม เช่น regex, pattern matching, ไม่ต้องใส่ quote ตัวแปร

#!/usr/bin/env bash

var=""

# [ ] — ต้อง quote เพื่อกัน error
if [ -z "$var" ]; then echo "ว่าง [ ]"; fi
# ถ้าไม่ใส่ quote: [ -z ] → error เพราะ var ขยายเป็นว่าง

# [[ ]] — ไม่ต้อง quote ก็ทำงาน (แต่ยังควร quote)
if [[ -z $var ]]; then echo "ว่าง [[ ]]"; fi

# Logical ใน [ ] — ใช้ -a, -o (deprecated) หรือเชื่อมด้วย && ||
if [ "$a" -gt 0 ] && [ "$a" -lt 100 ]; then echo "อยู่ใน 0-100"; fi

# Logical ใน [[ ]] — ใช้ && || ภายในได้เลย
if [[ $a -gt 0 && $a -lt 100 ]]; then echo "อยู่ใน 0-100"; fi

# คำแนะนำ: ใน Bash ใช้ [[ ]] เสมอ ปลอดภัยกว่า
# ใน sh script (POSIX) ใช้ [ ] เพื่อ portability

6.4.6 Logical Operator (ตัวดำเนินการตรรกะ)

#!/usr/bin/env bash

# ----- Short-circuit evaluation -----
# &&  : AND (รันคำสั่งถัดไปเมื่อตัวแรกสำเร็จ exit 0)
# ||  : OR  (รันคำสั่งถัดไปเมื่อตัวแรกล้มเหลว exit non-0)

# ตัวอย่างการใช้แทน if สั้น ๆ
[[ -d /tmp ]] && echo "มี /tmp"
[[ -d /nonexistent ]] || echo "ไม่มี /nonexistent"

# pattern: command1 && command2 || command3
# ⚠️ ระวัง: ไม่เทียบเท่า if/else เสมอ
mkdir backup && echo "สร้างสำเร็จ" || echo "สร้างไม่สำเร็จ"

# ใช้ใน [[ ]]
age=25
if [[ $age -ge 18 && $age -le 60 ]]; then
    echo "อายุทำงาน"
fi

if [[ $name == "admin" || $name == "root" ]]; then
    echo "บัญชีพิเศษ"
fi

# Negation
if ! command -v docker &>/dev/null; then
    echo "ไม่ได้ติดตั้ง docker"
fi

# ----- ตัวอย่างใช้งานจริง -----
# ตรวจสอบ + ติดตั้งถ้าไม่มี check & install if missing
command -v jq &>/dev/null || sudo apt install -y jq

# สร้างไดเรกทอรีถ้ายังไม่มี
[[ -d ~/backup ]] || mkdir -p ~/backup

# Run only as root
[[ $EUID -eq 0 ]] || { echo "กรุณารันด้วย root"; exit 1; }

6.4.7 case / esac

case เหมาะกับการเปรียบเทียบค่าเดียวกับหลาย pattern เป็นตัวเลือกที่อ่านง่ายกว่า if/elif หลายชั้น และรองรับ glob pattern

#!/usr/bin/env bash

# โครงสร้าง case
case "$VARIABLE" in
    pattern1)
        # คำสั่ง
        ;;
    pattern2 | pattern3)    # หลาย pattern คั่นด้วย |
        # คำสั่ง
        ;;
    *)                       # default (ใช้ * เพราะ glob)
        # คำสั่งเริ่มต้น
        ;;
esac

# ----- ตัวอย่าง: เมนูเลือกการกระทำ -----
read -p "เลือก [s]tart, [r]estart, [q]uit: " action

case "$action" in
    s | start)
        echo "เริ่มต้นบริการ..."
        systemctl start nginx
        ;;
    r | restart)
        echo "รีสตาร์ทบริการ..."
        systemctl restart nginx
        ;;
    q | quit | exit)
        echo "ลาก่อน"
        exit 0
        ;;
    *)
        echo "คำสั่งไม่ถูกต้อง"
        exit 1
        ;;
esac

# ----- ตัวอย่าง: จำแนกไฟล์ตาม extension -----
process_file() {
    local file="$1"
    case "$file" in
        *.jpg | *.jpeg | *.png | *.gif | *.webp)
            echo "$file: รูปภาพ image"
            ;;
        *.mp4 | *.mkv | *.avi | *.mov)
            echo "$file: วิดีโอ video"
            ;;
        *.tar.gz | *.tgz | *.tar.bz2 | *.tar.xz | *.zip)
            echo "$file: archive"
            ;;
        *.sh | *.bash | *.zsh)
            echo "$file: shell script"
            ;;
        *)
            echo "$file: ประเภทอื่น unknown"
            ;;
    esac
}

process_file "photo.jpg"      # รูปภาพ
process_file "movie.mp4"      # วิดีโอ
process_file "archive.tar.gz" # archive

# ----- ตัวอย่าง: ตรวจสอบ OS -----
case "$(uname -s)" in
    Linux*)   os="Linux";;
    Darwin*)  os="macOS";;
    CYGWIN* | MINGW* | MSYS*) os="Windows";;
    FreeBSD*) os="FreeBSD";;
    *)        os="Unknown";;
esac
echo "ระบบปฏิบัติการ: $os"

# ----- ใน Bash 4+ สามารถ fall-through ได้ด้วย ;& และ ;;& -----
case "$x" in
    pattern1)
        echo "p1"
        ;&             # fall-through ไป pattern ถัดไป
    pattern2)
        echo "p2"      # ทำต่อโดยไม่ตรวจ pattern2
        ;;
    pattern3)
        echo "p3"
        ;;&            # ตรวจ pattern ถัดไปอีก
esac

6.5 Loops (วนซ้ำ)

วนซ้ำเป็นโครงสร้างพื้นฐานในการทำงานซ้ำ ๆ Bash มีลูป 3 แบบหลัก: for, while, until พร้อมคำสั่งควบคุม break และ continue

flowchart TD
    subgraph FOR["for loop"]
        F1[เริ่ม init] --> F2{มี item
ถัดไปไหม?}
        F2 -->|ใช่ yes| F3[ทำคำสั่ง
do block]
        F3 --> F2
        F2 -->|ไม่ no| F4[จบ end]
    end
    subgraph WHILE["while loop"]
        W1[เริ่ม init] --> W2{เงื่อนไข
true?}
        W2 -->|ใช่ yes| W3[ทำคำสั่ง]
        W3 --> W2
        W2 -->|ไม่ no| W4[จบ]
    end
    subgraph UNTIL["until loop"]
        U1[เริ่ม init] --> U2{เงื่อนไข
true?}
        U2 -->|ไม่ no| U3[ทำคำสั่ง]
        U3 --> U2
        U2 -->|ใช่ yes| U4[จบ]
    end
    FOR ~~~ WHILE ~~~ UNTIL

6.5.1 for loop

#!/usr/bin/env bash

# ----- รูปแบบที่ 1: list-style -----
for fruit in apple banana cherry; do
    echo "ผลไม้: $fruit"
done

# วนผ่าน array
fruits=("apple" "banana" "cherry")
for fruit in "${fruits[@]}"; do
    echo "$fruit"
done

# วนผ่าน argument
for arg in "$@"; do
    echo "argument: $arg"
done

# วนผ่านไฟล์ใน directory (glob)
for f in /etc/*.conf; do
    [[ -f "$f" ]] || continue       # ข้ามถ้าไม่มี match
    echo "config: $f"
done

# วนผ่านบรรทัดในไฟล์
while IFS= read -r line; do
    echo "บรรทัด: $line"
done < /etc/hostname

# range expansion (Bash 3+)
for i in {1..5}; do
    echo "ครั้งที่ $i"
done

# range พร้อม step (Bash 4+)
for i in {0..20..2}; do
    echo "$i"   # 0 2 4 6 ... 20
done

# range ตัวอักษร
for c in {a..e}; do
    echo "$c"   # a b c d e
done

# ----- รูปแบบที่ 2: C-style -----
for ((i = 0; i < 10; i++)); do
    echo "i = $i"
done

# C-style พร้อม step
for ((i = 100; i > 0; i -= 10)); do
    echo "$i"   # 100 90 80 ... 10
done

# Multiple variable
for ((i = 0, j = 10; i < 5; i++, j--)); do
    echo "i=$i  j=$j"
done

# ----- ตัวอย่างใช้งานจริง: process หลายไฟล์ -----
for img in *.jpg; do
    [[ -f "$img" ]] || continue
    out="${img%.jpg}.webp"
    echo "Converting $img -> $out"
    # convert "$img" "$out"     # ใช้ ImageMagick
done

# วนผ่าน user ในระบบ
for user in $(awk -F: '$3 >= 1000 {print $1}' /etc/passwd); do
    echo "Regular user: $user"
done

6.5.2 while loop

#!/usr/bin/env bash

# ----- พื้นฐาน basic -----
counter=1
while [[ $counter -le 5 ]]; do
    echo "ครั้งที่ $counter"
    ((counter++))
done

# ----- อ่านไฟล์ทีละบรรทัด — pattern ที่ใช้บ่อย -----
while IFS= read -r line; do
    echo "Got: $line"
done < /etc/hosts

# ----- อ่าน command output -----
ls /tmp | while IFS= read -r f; do
    echo "พบไฟล์: $f"
done
# ⚠️ pipe สร้าง subshell — ตัวแปรแก้ไม่กลับ
# ใช้ Process Substitution แทนถ้าต้องแก้ตัวแปร

count=0
while IFS= read -r f; do
    ((count++))
done < <(ls /tmp)
echo "นับได้ $count ไฟล์"

# ----- ลูปไม่รู้จบ — ระวังใช้ -----
while true; do
    echo "ทำงานทุก 5 วินาที..."
    sleep 5
    [[ -f /tmp/stop ]] && break    # หยุดเมื่อมีไฟล์ flag
done

# ----- รอจน service พร้อม wait until ready -----
while ! curl -s -o /dev/null http://localhost:8080/health; do
    echo "รอ service..."
    sleep 2
done
echo "Service พร้อมแล้ว!"

# ----- หลายเงื่อนไข -----
attempt=0
max=5
while [[ $attempt -lt $max ]] && ! ping -c1 -W1 8.8.8.8 &>/dev/null; do
    ((attempt++))
    echo "ลองครั้งที่ $attempt..."
    sleep 2
done

6.5.3 until loop

until ตรงข้ามกับ while — วนต่อเมื่อเงื่อนไข false หยุดเมื่อ true

#!/usr/bin/env bash

# until = while NOT
counter=1
until [[ $counter -gt 5 ]]; do
    echo "$counter"
    ((counter++))
done

# ----- รอจนกว่าไฟล์จะถูกสร้าง -----
until [[ -f /tmp/done.flag ]]; do
    echo "รอไฟล์ /tmp/done.flag ..."
    sleep 1
done
echo "พบไฟล์แล้ว!"

# ----- รอจน service พร้อม (เทียบเท่า while ! ...) -----
until curl -s http://localhost:8080/health &>/dev/null; do
    sleep 2
done

6.5.4 break และ continue

#!/usr/bin/env bash

# ----- break: ออกจากลูปทันที -----
for i in {1..10}; do
    if [[ $i -eq 5 ]]; then
        break       # ออกที่ 5
    fi
    echo "$i"
done    # พิมพ์ 1 2 3 4

# ----- continue: ข้าม iteration ปัจจุบัน -----
for i in {1..10}; do
    if (( i % 2 == 0 )); then
        continue    # ข้ามเลขคู่
    fi
    echo "$i"
done    # พิมพ์ 1 3 5 7 9

# ----- break/continue หลายชั้น -----
for i in {1..3}; do
    for j in {1..3}; do
        if [[ $i -eq 2 && $j -eq 2 ]]; then
            break 2     # ออก 2 ลูป (ทั้ง outer ด้วย)
        fi
        echo "i=$i j=$j"
    done
done

# ----- continue ลูปนอก -----
for i in {1..3}; do
    for j in {1..3}; do
        if [[ $j -eq 2 ]]; then
            continue 2  # ข้ามไป iteration ถัดไปของ outer
        fi
        echo "i=$i j=$j"
    done
done

6.5.5 seq และ Brace Expansion

#!/usr/bin/env bash

# ----- seq command -----
seq 5                  # 1 2 3 4 5
seq 1 5                # 1 2 3 4 5
seq 1 2 10             # 1 3 5 7 9 (step 2)
seq -w 1 10            # 01 02 ... 10 (zero-padded)
seq -s, 1 5            # 1,2,3,4,5

# ใช้กับ for
for i in $(seq 1 10); do echo "$i"; done

# ----- brace expansion (เร็วกว่า seq เพราะ built-in) -----
echo {1..5}            # 1 2 3 4 5
echo {01..05}          # 01 02 03 04 05
echo {10..1}           # 10 9 8 ... 1 (descending)
echo {1..10..2}        # 1 3 5 7 9 (step, Bash 4+)
echo {a..e}            # a b c d e
echo {Z..A}            # Z Y X ... A

# nested + cartesian product
echo file{1,2,3}.{txt,log}
# file1.txt file1.log file2.txt file2.log file3.txt file3.log

mkdir -p project/{src,test,docs,build}/{main,sub}
# สร้าง 8 directory พร้อมกัน

6.5.6 Infinite Loop และ Polling Pattern

#!/usr/bin/env bash

# ----- รูปแบบ infinite loop -----
while true; do
    # ทำงาน
    sleep 1
done

while :; do                  # : เทียบเท่า true แต่ built-in
    sleep 1
done

for ((;;)); do
    sleep 1
done

# ----- Polling Pattern: ตรวจสอบเงื่อนไขเป็นระยะ -----
poll_log() {
    local logfile="$1"
    local pattern="$2"
    local interval="${3:-5}"

    while true; do
        if grep -q "$pattern" "$logfile" 2>/dev/null; then
            echo "พบ pattern '$pattern' ใน $logfile!"
            return 0
        fi
        sleep "$interval"
    done
}

# poll_log /var/log/nginx/access.log "ERROR" 10

# ----- จับ signal เพื่อออกอย่างสง่างาม graceful shutdown -----
shutdown=0
trap 'shutdown=1' SIGTERM SIGINT

while [[ $shutdown -eq 0 ]]; do
    echo "$(date) — ทำงานอยู่"
    sleep 5
done
echo "ได้รับสัญญาณ shutdown — ปิดงานเรียบร้อย"

# ----- Watch loop พร้อม timestamp -----
monitor_disk() {
    while true; do
        local usage
        usage=$(df -h / | awk 'NR==2 {print $5}' | tr -d '%')
        echo "[$(date +%T)] disk usage: ${usage}%"

        if [[ $usage -gt 80 ]]; then
            echo "⚠️ ใกล้เต็ม alert!"
        fi
        sleep 10
    done
}

สมการ: เวลาที่ใช้ในการ Polling เฉลี่ย (Average Polling Wait Time)

โดย $P$ คือ Polling Interval (วินาที) และ $E\left[T_{wait}\right]$ คือเวลารอเฉลี่ยจนเหตุการณ์ถูกตรวจพบ — ดังนั้น Polling ที่บ่อยขึ้นย่อมตอบสนองเร็วขึ้นแต่ใช้ทรัพยากรมากขึ้น เป็น Trade-off ที่สำคัญ

6.6 Functions (ฟังก์ชัน)

ฟังก์ชันคือบล็อกของคำสั่งที่ตั้งชื่อไว้และเรียกใช้ซ้ำได้ ช่วยให้สคริปต์เป็นระบบ อ่านง่าย และนำกลับมาใช้ใหม่ (DRY — Don't Repeat Yourself)

6.6.1 การประกาศ Function

#!/usr/bin/env bash

# ----- รูปแบบที่ 1: POSIX-style (แนะนำ - portable) -----
greet() {
    echo "สวัสดี"
}

# ----- รูปแบบที่ 2: Bash keyword (แนะนำ POSIX มากกว่า) -----
function greet2 {
    echo "Hi"
}

# ----- รูปแบบที่ 3: รวมทั้งสอง (ไม่จำเป็น) -----
function greet3() {
    echo "Hello"
}

# เรียกใช้ — ไม่ต้องมีวงเล็บ
greet
greet2

# ฟังก์ชันต้องประกาศก่อนเรียกใช้
# main() ต้องอยู่ท้ายไฟล์ หรือเรียกหลังประกาศ

6.6.2 การส่งและรับพารามิเตอร์

ฟังก์ชันรับ argument ผ่านตัวแปรพิเศษเหมือนสคริปต์: $1, $2, ..., $@, $# ($0 ยังคงเป็นชื่อสคริปต์ ไม่ใช่ชื่อฟังก์ชัน)

#!/usr/bin/env bash

# ฟังก์ชันรับ 2 argument
add() {
    local a="$1"
    local b="$2"
    echo $((a + b))
}

result=$(add 5 3)
echo "5 + 3 = $result"     # 8

# ฟังก์ชันรับจำนวน argument ไม่จำกัด
sum_all() {
    local total=0
    for n in "$@"; do
        total=$((total + n))
    done
    echo "$total"
}

echo "Sum: $(sum_all 1 2 3 4 5)"     # 15
echo "Sum: $(sum_all 10 20 30)"      # 60

# ตรวจสอบจำนวน argument
greet() {
    if [[ $# -lt 1 ]]; then
        echo "Usage: greet NAME [GREETING]" >&2
        return 1
    fi
    local name="$1"
    local greeting="${2:-Hello}"      # default Hello
    echo "$greeting, $name!"
}

greet "Moo"            # Hello, Moo!
greet "Moo" "สวัสดี"   # สวัสดี, Moo!
greet                  # error และ return 1

6.6.3 Return Value (ค่าส่งกลับ)

Bash function "return" 2 แบบ: exit code (0-255) ผ่าน return หรือ string output ผ่าน echo/printf แล้วใช้ command substitution $(...) รับค่า

#!/usr/bin/env bash

# ----- return เป็น exit code (0-255) -----
is_even() {
    local n="$1"
    if (( n % 2 == 0 )); then
        return 0       # 0 = สำเร็จ = true
    else
        return 1       # อื่น = ผิดพลาด = false
    fi
}

if is_even 10; then echo "10 is even"; fi
if is_even 7; then echo "7 is even"; else echo "7 is odd"; fi

# ----- return ค่าจริง ๆ ใช้ echo + command substitution -----
square() {
    local n="$1"
    echo $((n * n))
}

result=$(square 5)
echo "5² = $result"       # 25

# ใช้ใน expression
total=$(($(square 3) + $(square 4)))
echo "3² + 4² = $total"   # 25

# ----- กรณีต้องการคืนค่าหลายตัว ใช้ array หรือ global -----
parse_url() {
    local url="$1"
    # ตั้งตัวแปร global (หรือ caller สามารถ declare ก่อน)
    URL_PROTO="${url%%://*}"
    URL_REST="${url#*://}"
    URL_HOST="${URL_REST%%/*}"
    URL_PATH="/${URL_REST#*/}"
}

parse_url "https://example.com/path/to/page"
echo "proto: $URL_PROTO"  # https
echo "host:  $URL_HOST"   # example.com
echo "path:  $URL_PATH"   # /path/to/page

# ----- Pattern: ใช้ nameref (Bash 4.3+) คืนค่าผ่านชื่อตัวแปร -----
get_user_info() {
    local -n result_ref=$1     # nameref
    result_ref[name]="$USER"
    result_ref[home]="$HOME"
    result_ref[shell]="$SHELL"
}

declare -A info
get_user_info info
echo "name=${info[name]}, home=${info[home]}"

6.6.4 Local Variable ภายใน Function

ตัวแปรภายในฟังก์ชันโดยปริยายเป็น global การใช้ local ป้องกัน Side Effect

#!/usr/bin/env bash

x=10

# ❌ ไม่ใช้ local — แก้ x global โดยไม่ตั้งใจ
bad_func() {
    x=99
    echo "in func: $x"
}

bad_func           # 99
echo "after: $x"   # 99 — เปลี่ยนแล้ว!

# ✅ ใช้ local — ปลอดภัย
x=10
good_func() {
    local x=99
    echo "in func: $x"
}

good_func          # 99
echo "after: $x"   # 10 — ไม่เปลี่ยน

# local รองรับ option เหมือน declare
demo() {
    local -i num=42       # integer
    local -r CONST=100    # readonly
    local -a arr=(1 2 3)  # array
    local -A map          # associative array

    echo "num=$num, CONST=$CONST"
    echo "arr=${arr[@]}"
}
demo

6.6.5 Recursion

Bash รองรับ recursion แต่ระวัง stack depth (default ~1000 ซ้อน) และไม่มี tail call optimization จึงใช้กับงานเชิงวิเคราะห์ขนาดเล็กดีกว่า

#!/usr/bin/env bash

# ----- Factorial: n! -----
factorial() {
    local n="$1"
    if (( n <= 1 )); then
        echo 1
    else
        local prev
        prev=$(factorial $((n - 1)))
        echo $((n * prev))
    fi
}

echo "5! = $(factorial 5)"     # 120
echo "10! = $(factorial 10)"   # 3628800

# ----- Fibonacci -----
fib() {
    local n="$1"
    if (( n < 2 )); then
        echo "$n"
    else
        echo $(( $(fib $((n - 1))) + $(fib $((n - 2))) ))
    fi
}

for i in {0..10}; do
    echo "fib($i) = $(fib $i)"
done

# ----- ค้นหาไฟล์แบบ recursive (เลียนแบบ find) -----
walk() {
    local dir="$1"
    local indent="${2:-}"

    for entry in "$dir"/*; do
        [[ -e "$entry" ]] || continue
        echo "${indent}$(basename "$entry")"

        if [[ -d "$entry" ]]; then
            walk "$entry" "  $indent"
        fi
    done
}

walk /etc/nginx

สมการ: Factorial นิยามแบบ Recursive

โดย $n!$ เรียกตัวเองด้วย $(n-1)!$ จนถึง base case

6.7 Arrays (อาเรย์เชิงลึก)

ส่วนนี้ขยายความเรื่อง Array ที่ได้กล่าวเบื้องต้นใน 6.2.6 ลงรายละเอียดการใช้งานขั้นสูง การวนซ้ำ และตัวอย่างการประยุกต์

6.7.1 Indexed Array

Indexed Array คือ array ที่ใช้เลขจำนวนเต็มเป็น index เริ่มจาก 0 และอนุญาตให้เป็น sparse (มีช่องว่าง)

#!/usr/bin/env bash

# ----- การประกาศ declaration -----
fruits=("apple" "banana" "cherry")
declare -a numbers=(10 20 30 40 50)         # ระบุชนิดชัดเจน
nums[0]=1; nums[5]=99                       # sparse — มี gap

# กำหนดทีละ element
arr=()                # array ว่าง
arr[0]="zero"
arr[1]="one"
arr[2]="two"

# ----- การเข้าถึง access -----
echo "${fruits[0]}"           # apple (index 0)
echo "${fruits[-1]}"          # cherry (index ลบ Bash 4.3+)
echo "${fruits[@]}"           # apple banana cherry (all elements)
echo "${fruits[*]}"           # apple banana cherry
echo "${#fruits[@]}"          # 3 (length)
echo "${#fruits[0]}"          # 5 (length ของ "apple")

# ----- index ที่มีอยู่ -----
echo "${!fruits[@]}"          # 0 1 2

# ----- slice -----
arr=(a b c d e f g h)
echo "${arr[@]:2}"            # c d e f g h (จาก 2 ถึงท้าย)
echo "${arr[@]:2:3}"          # c d e (จาก 2 ยาว 3)
echo "${arr[@]: -2}"          # g h (2 ตัวสุดท้าย — เว้นวรรคก่อน -)

# ----- เพิ่ม element -----
fruits+=("durian")            # ต่อท้าย
fruits+=("elderberry" "fig")  # หลายตัว
fruits[10]="grape"            # เฉพาะตำแหน่ง

# ----- ลบ element -----
unset 'fruits[1]'             # ลบ index 1 (sparse — index 0,2,3,...)
unset fruits                  # ลบทั้ง array

6.7.2 Associative Array

Associative Array (Bash 4+) ใช้ string เป็น key คล้าย Hash Map / Dictionary

#!/usr/bin/env bash

# ต้องประกาศด้วย declare -A ก่อน
declare -A user_info

# กำหนดค่า
user_info["name"]="Moo"
user_info["age"]=42
user_info["email"]="moo@example.com"
user_info["role"]="lecturer"

# หรือสร้างพร้อมค่าเริ่มต้น
declare -A config=(
    [host]="localhost"
    [port]=8080
    [protocol]="https"
    [timeout]=30
)

# ----- เข้าถึง access -----
echo "${user_info[name]}"        # Moo
echo "${config[port]}"           # 8080

# ทุก key
echo "${!user_info[@]}"          # name age email role (ไม่เรียงลำดับ)

# ทุกค่า
echo "${user_info[@]}"           # Moo 42 moo@example.com lecturer

# จำนวน
echo "${#user_info[@]}"          # 4

# ----- ตรวจสอบว่ามี key หรือไม่ -----
if [[ -v user_info[name] ]]; then
    echo "มี key 'name'"
fi
# หรือ
if [[ ${user_info[unknown]+x} ]]; then
    echo "มี key unknown"
else
    echo "ไม่มี key unknown"
fi

# ----- ลบ key -----
unset 'user_info[email]'

# ----- วนผ่าน iterate -----
for key in "${!user_info[@]}"; do
    echo "$key = ${user_info[$key]}"
done

# เรียงลำดับ key
for key in $(echo "${!user_info[@]}" | tr ' ' '\n' | sort); do
    echo "$key = ${user_info[$key]}"
done

6.7.3 การเข้าถึง Element

#!/usr/bin/env bash

arr=(a b c d e f g)

# === การเข้าถึงค่า value ===
echo "${arr[0]}"           # a
echo "${arr[3]}"           # d
echo "${arr[-1]}"          # g (Bash 4.3+)

# === ทุกค่า all values ===
echo "${arr[@]}"           # a b c d e f g
printf '%s\n' "${arr[@]}"  # ทีละบรรทัด

# === ทุก index all keys ===
echo "${!arr[@]}"          # 0 1 2 3 4 5 6

# === ความยาว length ===
echo "${#arr[@]}"          # 7 (จำนวน element)
echo "${#arr[2]}"          # 1 (ความยาวของ arr[2]="c")

# === ความแตกต่าง @ vs * ===
arr=("hello world" "foo bar" "baz")

for x in "${arr[@]}"; do echo "[$x]"; done
# [hello world]
# [foo bar]
# [baz]

for x in "${arr[*]}"; do echo "[$x]"; done
# [hello world foo bar baz]   ← รวมเป็น string เดียว

IFS='|'
for x in "${arr[*]}"; do echo "[$x]"; done
# [hello world|foo bar|baz]   ← ใช้ IFS เชื่อม

# === Slice ===
echo "${arr[@]:1}"          # foo bar baz (จาก index 1)
echo "${arr[@]:0:2}"        # hello world foo bar (2 ตัวแรก)

# === Search/Replace ===
arr=(apple banana cherry)
echo "${arr[@]/an/AN}"      # apple bANana cherry → ผิด: ทำ subst ทุกตัว
# → apple bANana cherry (เปลี่ยนใน element ที่มี match)

# === ลบ element ===
unset 'arr[1]'              # ลบ banana → array sparse
echo "${arr[@]}"            # apple cherry

# Compact (ลบ gap)
arr=("${arr[@]}")           # rebuild
echo "${!arr[@]}"           # 0 1 (ไม่ใช่ 0 2)

6.7.4 การวนซ้ำผ่าน Array

#!/usr/bin/env bash

# ===== Indexed Array =====
fruits=("apple" "banana" "cherry" "durian")

# วิธีที่ 1: วนผ่านค่า by value
for fruit in "${fruits[@]}"; do
    echo "fruit: $fruit"
done

# วิธีที่ 2: วนผ่าน index by index
for i in "${!fruits[@]}"; do
    echo "$i: ${fruits[$i]}"
done

# วิธีที่ 3: C-style ใช้ index ตัวเลข
for ((i = 0; i < ${#fruits[@]}; i++)); do
    echo "$i: ${fruits[$i]}"
done

# ===== Associative Array =====
declare -A scores=(
    [math]=85
    [english]=72
    [thai]=90
    [science]=88
)

# วนผ่าน key + value
for subject in "${!scores[@]}"; do
    echo "$subject: ${scores[$subject]}"
done

# ===== ตัวอย่าง: หาคะแนนสูงสุด -----
max_subject=""
max_score=0
for subject in "${!scores[@]}"; do
    if (( scores[$subject] > max_score )); then
        max_score=${scores[$subject]}
        max_subject=$subject
    fi
done
echo "วิชาคะแนนสูงสุด: $max_subject ($max_score)"

# ===== ตัวอย่าง: นับความถี่ของคำ -----
declare -A word_count
text="the quick brown fox jumps over the lazy dog the end"
for word in $text; do
    ((word_count[$word]++))
done

for w in "${!word_count[@]}"; do
    echo "$w: ${word_count[$w]}"
done

# ===== ตัวอย่าง: parallel arrays -----
names=("Alice" "Bob" "Charlie")
ages=(30 25 35)
roles=("admin" "user" "user")

for i in "${!names[@]}"; do
    printf "%-10s | %2d ปี | %s\n" \
        "${names[$i]}" "${ages[$i]}" "${roles[$i]}"
done

6.8 Input/Output ขั้นสูง (Advanced I/O)

6.8.1 Here Document (<<EOF)

Here Document คือการส่ง multiline string เข้าทาง stdin ของคำสั่ง ใช้บ่อยกับการสร้างไฟล์ config, การส่ง SQL/SSH command, หรือการเขียนไฟล์ template

#!/usr/bin/env bash

# ----- รูปแบบพื้นฐาน -----
cat <<EOF
สวัสดีทุกคน
ฉันคือบรรทัดที่สอง
$(date)                           # คำสั่งจะถูกขยาย
ผู้ใช้ปัจจุบันคือ $USER             # ตัวแปรขยาย
EOF

# ----- ปิดการขยายตัวแปร — ใส่ quote รอบ delimiter -----
cat <<'EOF'
ตัวแปร $USER จะไม่ถูกขยาย
$(date) ก็ไม่ทำงาน
ใช้สำหรับเขียน script template
EOF

# ----- ตัด tab นำหน้าด้วย <<- (สำหรับ indent) -----
if true; then
	cat <<-EOF
	บรรทัดนี้มี tab นำหน้า
	แต่ <<- จะตัดออก ทำให้ output ดู clean
	หมายเหตุ: ตัดเฉพาะ tab ไม่ตัด space
	EOF
fi

# ----- ใช้สร้างไฟล์ -----
cat > /tmp/config.yaml <<EOF
server:
  host: localhost
  port: 8080
  user: $USER
  pid: $$
EOF

# ----- ใช้ส่งคำสั่ง SSH -----
ssh user@remote-host <<'ENDSSH'
echo "ผมอยู่บน $(hostname)"
uptime
df -h /
ENDSSH

# ----- ใช้กับ SQL -----
mysql -u root -p"$DB_PASS" <<SQL
USE myapp;
SELECT COUNT(*) FROM users WHERE active = 1;
UPDATE settings SET value = 'true' WHERE key = 'maintenance';
SQL

# ----- เขียนสคริปต์ Python ใน Bash -----
python3 <<'PYEOF'
import sys
print("Python within Bash!")
print(f"sys.argv: {sys.argv}")
PYEOF

# ----- เก็บลงตัวแปร -----
my_text=$(cat <<EOF
บรรทัดที่ 1
บรรทัดที่ 2
บรรทัดที่ 3
EOF
)
echo "$my_text"

6.8.2 Here String (<<<)

Here String ส่งข้อความบรรทัดเดียวเข้า stdin (เปรียบเหมือน echo "..." | cmd แต่เร็วกว่าและไม่ fork)

#!/usr/bin/env bash

# ส่ง string เข้า stdin
grep "moo" <<< "moo is awesome"            # match
wc -w <<< "นับ คำ ใน ข้อความ"               # 4

# เทียบกับ pipe — here string ไม่สร้าง subshell
echo "hello" | read x
echo "$x"      # ว่าง! เพราะ read ทำใน subshell

read x <<< "hello"
echo "$x"      # hello — read ทำใน shell ปัจจุบัน

# ส่ง output ของคำสั่ง
read -r host <<< "$(hostname)"
echo "Host: $host"

# ----- ใช้กับ regex -----
phone="081-234-5678"
[[ "$phone" =~ ^([0-9]{3})-([0-9]{3})-([0-9]{4})$ ]] \
    && echo "valid phone: ${BASH_REMATCH[0]}"

# ตัดส่วนของ string เข้า array
input="apple,banana,cherry"
IFS=',' read -ra fruits <<< "$input"
for f in "${fruits[@]}"; do
    echo "fruit: $f"
done