reveal.js

# Shell Script in Linux
**ผู้จัดทํา:** อรรถพล คงหวาน

---

# Outline

1. พื้นฐาน Shell Scripting (Shell Scripting Fundamentals)
2. ตัวแปร (Variables)
3. การดำเนินการและการคำนวณ (Operations & Computation)
4. Conditional Statements (คำสั่งเงื่อนไข)
5. Loops (วนซ้ำ)
6. Functions (ฟังก์ชัน)
7. Arrays (อาเรย์เชิงลึก)
8. Input/Output ขั้นสูง (Advanced I/O)
9. การจัดการข้อผิดพลาด (Error Handling)
10. Best Practices (แนวปฏิบัติที่ดี)
11. ตัวอย่างการประยุกต์ใช้งาน (Practical Applications)

---

# บทนำ

Shell Script คือเครื่องมือทรงพลังสำหรับการอัตโนมัติงาน (Automation) บนระบบ Linux/Unix โดยใช้ภาษา Shell สั่งงานผ่าน Command Interpreter เพื่อรวมคำสั่งหลาย ๆ คำสั่งเข้าด้วยกันให้ทำงานเป็นโปรแกรมเดียว

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

---

# 6.1 พื้นฐาน Shell Scripting
## Shell Scripting Fundamentals

---

## 6.1 พื้นฐาน Shell Scripting

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

ข้อดีหลักของ Shell Script คือสามารถนำคำสั่ง CLI ที่ใช้บ่อย ๆ มารวมกันเป็นชุดคำสั่งอัตโนมัติได้ทันทีโดยไม่ต้องคอมไพล์

---

## การทำงานของ Shell

<pre class="mermaid">
%%{init: {'theme':'base', 'themeVariables': {
  'primaryColor': '#3c3836', 'primaryTextColor': '#ebdbb2',
  'primaryBorderColor': '#928374', 'lineColor': '#a89984',
  'secondaryColor': '#504945', 'tertiaryColor': '#665c54',
  'background': '#282828', 'mainBkg': '#3c3836',
  'secondBkg': '#504945', 'tertiaryBkg': '#665c54'
}}}%%
flowchart LR
    A[ผู้ใช้ User] -->|พิมพ์คำสั่ง| B[Shell ตัวแปลคำสั่ง]
    B -->|Parse + Expand| C{ประเภท?}
    C -->|Builtin| D[ทำงานในตัว Shell]
    C -->|External| E[fork+exec]
    C -->|Script File| F[อ่านบรรทัดต่อบรรทัด]
    F --> B
    D --> G[ผลลัพธ์]
    E --> G
</pre>

---

## 6.1.1 Shell ที่นิยมใช้งาน

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

---

## ตารางเปรียบเทียบ Shell

| Shell | จุดเด่น | จุดด้อย |
| --- | --- | --- |
| **bash** | Feature ครบ ใช้แพร่หลาย เอกสารเยอะ | ช้ากว่า dash |
| **zsh** | Auto-completion ดีเยี่ยม, default macOS | ไม่ได้ติดตั้งทุก distro |
| **sh** (POSIX) | Portable สูงสุด, เร็ว | Feature น้อย ไม่มี array |
| **dash** | เร็ว ขนาดเล็ก เหมาะกับ boot | ไม่เหมาะ interactive |
| **ksh** | เร็ว เหมาะ Enterprise | ความนิยมลดลง |
| **fish** | Auto-suggestion ฉลาด | ไม่ POSIX-compatible |

---

## ตรวจสอบ Shell ที่ใช้

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

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

# เปลี่ยน default shell สำหรับ user
chsh -s /usr/bin/zsh
```

---

## 6.1.2 Shebang (Hash-Bang)

**Shebang** คืออักขระสองตัวแรกของไฟล์สคริปต์ที่ขึ้นต้นด้วย `#!` ตามด้วย path ของ interpreter ที่จะใช้รันสคริปต์นี้

Kernel จะอ่าน 2 byte แรก (magic number `0x23 0x21`) เมื่อเรียกไฟล์เป็น executable แล้วใช้ interpreter ที่ระบุไว้ในการประมวลผล

---

## รูปแบบ Shebang

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

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

---

## 6.1.3 การกำหนดสิทธิ์ Execute

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

```bash
# สร้างสคริปต์ตัวอย่าง
cat > hello.sh <<'EOF'
#!/usr/bin/env bash
echo "สวัสดี $USER"
EOF

chmod +x hello.sh    # ใส่สิทธิ์ execute
./hello.sh           # รันสคริปต์
```

---

## 6.1.4 วิธีการรันสคริปต์

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

<pre class="mermaid">
%%{init: {'theme':'base', 'themeVariables': {
  'primaryColor': '#3c3836', 'primaryTextColor': '#ebdbb2',
  'primaryBorderColor': '#928374', 'lineColor': '#a89984',
  'secondaryColor': '#504945', 'tertiaryColor': '#665c54',
  'background': '#282828', 'mainBkg': '#3c3836'
}}}%%
flowchart TD
    P[Parent Shell] --> M{วิธีรัน?}
    M -->|./script.sh| S1[Spawn Subshell]
    M -->|bash script.sh| S2[Spawn Subshell ระบุ interpreter]
    M -->|source script.sh| S3[รันใน Shell ปัจจุบัน]
    S1 --> R1[Variable หายไปเมื่อจบ]
    S2 --> R1
    S3 --> R2[Variable คงอยู่ใน Shell หลัก]
</pre>

---

## ตัวอย่าง 3 วิธีการรัน

```bash
# วิธีที่ 1: ./script.sh - ต้องมี shebang + executable
./hello.sh

# วิธีที่ 2: bash script.sh - ไม่ต้องมี shebang/permission
bash hello.sh
sh hello.sh        # รันด้วย POSIX sh

# วิธีที่ 3: source script.sh - รันใน shell ปัจจุบัน
source ~/.bashrc
. ~/.bashrc          # ตัวจุด . เทียบเท่า source (POSIX)
```

---

## ความแตกต่างของวิธีรัน

```bash
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 ที่ดีช่วยให้ผู้อื่นเข้าใจวัตถุประสงค์ ผู้เขียน วันที่ และวิธีใช้งาน

---

## ตัวอย่าง Header ที่ดี

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

---

## Multi-line Comment และ Tags

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

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

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

---

# 6.2 ตัวแปร
## Variables

---

## 6.2 ตัวแปร (Variables)

ตัวแปรใน Shell ใช้เก็บค่าข้อมูลที่จะนำมาใช้ในสคริปต์

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

---

## 6.2.1 การประกาศและเรียกใช้ตัวแปร

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

# การเรียกใช้
echo $name               # Moo
echo "$name"             # Moo (แนะนำ ใส่ double-quote)
echo "${name}"           # Moo (รูปแบบเต็ม)
echo "${name}_suffix"    # Moo_suffix (ต้องใช้ {})
echo '$name'             # $name (single-quote ไม่ขยาย)
```

---

## ตัวแปรที่ยังไม่ได้กำหนดค่า

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

---

## ตารางสรุป Parameter Expansion

| รูปแบบ | ความหมาย |
| --- | --- |
| `${var}` | ค่าของ var (รูปแบบเต็ม) |
| `${var:-default}` | ใช้ default ถ้า var ว่างหรือไม่ตั้ง |
| `${var:=default}` | กำหนด default ให้ var เลย ถ้าว่าง |
| `${var:?msg}` | error และ exit ถ้า var ว่าง |
| `${var:+alt}` | ใช้ alt ถ้า var ไม่ว่าง |

---

## 6.2.2 Local vs Global Variable

ตัวแปรที่ประกาศนอก function หรือใน global scope จะเป็น **global** เข้าถึงได้ทุกที่ในสคริปต์

ส่วน `local` ใช้ในฟังก์ชันเพื่อจำกัด scope ให้อยู่ในฟังก์ชันนั้น ๆ ป้องกันการชนกับตัวแปรชื่อเดียวกันภายนอก

---

## ตัวอย่าง Local Variable

```bash
counter=0

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

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

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

---

## 6.2.3 Environment Variables

**Environment Variable** คือตัวแปรที่ส่งต่อจาก Process แม่ไปยัง Process ลูก

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

---

## ตัวแปร Environment ที่สำคัญ

```bash
echo "$HOME"     # home directory ของผู้ใช้
echo "$USER"     # ชื่อผู้ใช้ปัจจุบัน
echo "$PWD"      # working directory ปัจจุบัน
echo "$SHELL"    # login shell
echo "$PATH"     # paths สำหรับค้นคำสั่ง
echo "$LANG"     # locale ระบบ
echo "$HOSTNAME" # ชื่อเครื่อง
```

---

## การสร้างและจัดการ Environment Variable

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

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

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

---

## การเพิ่ม Path เข้า PATH

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

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

---

## 6.2.4 Special Variables

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

| ตัวแปร | ความหมาย |
| --- | --- |
| `$0` | ชื่อสคริปต์ |
| `$1, $2, ...` | argument ตำแหน่งที่ 1-9 |
| `$#` | จำนวน argument ทั้งหมด |
| `$@` | argument ทั้งหมด แยกแต่ละตัว |
| `$*` | argument รวมเป็น string เดียว |

---

## Special Variables (ต่อ)

| ตัวแปร | ความหมาย |
| --- | --- |
| `$?` | exit code ของคำสั่งล่าสุด |
| `$$` | PID ของ shell ปัจจุบัน |
| `$!` | PID ของ background job ล่าสุด |
| `$_` | argument สุดท้ายของคำสั่งก่อน |
| `$IFS` | Internal Field Separator |
| `$RANDOM` | ตัวเลขสุ่ม 0-32767 |
| `$LINENO` | หมายเลขบรรทัดปัจจุบัน |
| `$SECONDS` | จำนวนวินาทีที่ shell รันมาแล้ว |

---

## ตัวอย่างการใช้ Special Variables

```bash
#!/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 ทั้งหมด @ : $@"
echo "PID           : $$"
```

---

## ความแตกต่าง $@ vs $*

```bash
# กับ argument: apple "banana split" cherry

for arg in "$@"; do echo "@: [$arg]"; done
# @: [apple]
# @: [banana split]
# @: [cherry]

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

---

## 6.2.5 Read-only Variable

ใช้ `readonly` หรือ `declare -r` เพื่อทำให้ตัวแปรเปลี่ยนค่าไม่ได้อีก

เหมาะสำหรับค่าคงที่ (Constant) เช่น path สำคัญ, version number, configuration

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

VERSION="2.0.0"
# bash: VERSION: readonly variable
```

---

## 6.2.6 Array (อาเรย์)

Bash รองรับ Array สองแบบ:

- **Indexed Array** — ดัชนีเป็นตัวเลข เริ่มจาก 0
- **Associative Array** — ดัชนีเป็น string คล้าย Hash Map ของ Python หรือ Map ของ JavaScript

---

## Indexed Array

```bash
fruits=("apple" "banana" "cherry" "durian")

# เข้าถึง element
echo "${fruits[0]}"        # apple (index เริ่มจาก 0)
echo "${fruits[2]}"        # cherry
echo "${fruits[@]}"        # ทั้งหมด
echo "${#fruits[@]}"       # 4 (จำนวน element)
echo "${!fruits[@]}"       # 0 1 2 3 (indices)
echo "${fruits[@]:1:2}"    # banana cherry (slice)

fruits+=("elderberry")     # เพิ่มต่อท้าย
unset 'fruits[1]'          # ลบ index 1
```

---

## Associative Array (Bash 4+)

```bash
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[@]}"          # keys
```

---

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

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

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

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

# ซ่อนการพิมพ์ (-s) เหมาะกับ password
read -sp "รหัสผ่าน: " password
```

---

## Option ของ read

| Option | ความหมาย |
| --- | --- |
| `-p TEXT` | แสดง prompt |
| `-s` | silent ไม่แสดง input (password) |
| `-t SEC` | timeout ในหน่วยวินาที |
| `-n N` | อ่านแค่ N ตัวอักษร |
| `-r` | raw mode ไม่ตีความ backslash |
| `-a NAME` | อ่านเข้า array |
| `-d DELIM` | ใช้ DELIM เป็นตัวหยุด |

---

## ตัวอย่าง read ขั้นสูง

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

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

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

---

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

---

## 6.3.1 Arithmetic Expansion

Bash รองรับการคำนวณ integer ในตัว ผ่าน 3 รูปแบบ:

- `$((...))` — แนะนำ
- `let` — สั้นกว่า
- `expr` — รูปแบบเก่า

---

## ตัวอย่าง $((...))

```bash
a=10
b=3

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

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

---

## Bitwise และ Compound Operators

```bash
# bitwise operators
echo $((5 & 3))     # 1   AND
echo $((5 | 3))     # 7   OR
echo $((5 ^ 3))     # 6   XOR
echo $((5 << 1))    # 10  shift left

# compound assignment
((counter++))       # increment
((counter--))       # decrement
((counter += 5))    # counter = counter + 5
((counter *= 2))    # counter = counter * 2
```

---

## let และ expr

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

# expr (รูปแบบเก่า ต้องเว้นวรรค)
result=$(expr 10 + 5)
echo "$result"      # 15
result=$(expr 10 \* 5)   # ต้อง escape *
echo "$result"      # 50
```

---

## ทศนิยม: ใช้ bc หรือ awk

```bash
# bc
echo "scale=4; 10/3" | bc            # 3.3333

# awk
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
```

---

## สมการ: ค่าเฉลี่ยเลขคณิต

โดย <math xmlns="http://www.w3.org/1998/Math/MathML"><mover><mi>x</mi><mo>‾</mo></mover></math> คือค่าเฉลี่ย, <math xmlns="http://www.w3.org/1998/Math/MathML"><mi>n</mi></math> คือจำนวนข้อมูล, <math xmlns="http://www.w3.org/1998/Math/MathML"><msub><mi>x</mi><mi>i</mi></msub></math> คือค่าข้อมูลตัวที่ <math xmlns="http://www.w3.org/1998/Math/MathML"><mi>i</mi></math>

---

## Implement สูตรค่าเฉลี่ย

```bash
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` ทำให้สคริปต์เร็วขึ้น

---

## ตารางการจัดการ String

| รูปแบบ | ความหมาย |
| --- | --- |
| `${#var}` | ความยาว string |
| `${var:offset}` | ตัดตั้งแต่ offset |
| `${var:offset:length}` | substring |
| `${var/pattern/repl}` | แทนที่ครั้งแรก |
| `${var//pattern/repl}` | แทนที่ทั้งหมด |
| `${var#pattern}` | ตัด prefix สั้นสุด |
| `${var##pattern}` | ตัด prefix ยาวสุด |

---

## ตารางการจัดการ String (ต่อ)

| รูปแบบ | ความหมาย |
| --- | --- |
| `${var%pattern}` | ตัด suffix สั้นสุด |
| `${var%%pattern}` | ตัด suffix ยาวสุด |
| `${var^}` | upper ตัวแรก |
| `${var^^}` | upper ทั้งหมด |
| `${var,}` | lower ตัวแรก |
| `${var,,}` | lower ทั้งหมด |

---

## ตัวอย่าง String Manipulation

```bash
s="Hello World, Linux is Awesome"

echo "${#s}"              # 29 (ความยาว)
echo "${s:0:5}"           # Hello (substring)
echo "${s:6}"             # World, Linux is Awesome
echo "${s/World/Earth}"   # Hello Earth, Linux...
echo "${s//o/0}"          # แทนที่ทั้งหมด

# upper/lower case
name="moo"
echo "${name^}"           # Moo
echo "${name^^}"          # MOO
```

---

## ตัวอย่างจริง: แยก Path

```bash
file="image.tar.gz"
echo "${file#*.}"         # tar.gz   (สั้นสุด)
echo "${file##*.}"        # gz       (ยาวสุด - extension)
echo "${file%.*}"         # image.tar (สั้นสุด)
echo "${file%%.*}"        # image    (ยาวสุด - basename)

path="/home/moo/projects/script.sh"
echo "directory: ${path%/*}"    # /home/moo/projects
echo "filename:  ${path##*/}"   # script.sh
echo "extension: ${path##*.}"   # sh
```

---

## 6.3.3 Quoting

การ Quote เป็นเรื่องสำคัญที่สุดเรื่องหนึ่งใน Shell เพราะส่งผลต่อ Word Splitting, Globbing, Expansion

ใช้ผิดอาจทำให้สคริปต์มีบั๊กที่หายาก

---

## ตารางเปรียบเทียบ Quote

| รูปแบบ | ขยาย $var | Word splitting | Glob |
| --- | --- | --- | --- |
| ไม่มี quote | ✅ | ✅ | ✅ |
| `"..."` (double) | ✅ | ❌ | ❌ |
| `'...'` (single) | ❌ | ❌ | ❌ |
| `$'...'` (ANSI-C) | ❌ | ❌ | ❌ |

---

## ตัวอย่าง Double Quote

```bash
name="Linus Torvalds"

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

---

## ตัวอย่าง Single Quote และ ANSI-C

```bash
# Single quote — literal สมบูรณ์
echo 'Hello $name'      # Hello $name (ไม่ขยาย)
echo 'Cost: $5'         # Cost: $5

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

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

---

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

---

## 6.4 Conditional Statements

คำสั่งเงื่อนไขช่วยให้สคริปต์ตัดสินใจการทำงานตามค่าที่ตรวจสอบ

Bash มีโครงสร้างเงื่อนไขแบบ `if/elif/else`, `case`, และ short-circuit operators

---

## โครงสร้างเงื่อนไข

---

## 6.4.1 if / elif / else / fi

โครงสร้างพื้นฐานของ if เช็คเงื่อนไขจาก **exit code** ของคำสั่ง: 0 = true, อื่น ๆ = false

ซึ่งต่างจากภาษาทั่วไปที่ใช้ boolean

```bash
if condition; then
    # ทำเมื่อ true
elif another_condition; then
    # ทำเมื่อ another true
else
    # ทำเมื่อทั้งหมด false
fi
```

---

## ตัวอย่าง if ใช้งานจริง

```bash
score=85

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

---

## if ขั้นสูง

```bash
# ใช้ 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

| Test | คำอธิบาย |
| --- | --- |
| `-e FILE` | มีอยู่ (existent) |
| `-f FILE` | เป็น regular file |
| `-d FILE` | เป็น directory |
| `-L FILE` | เป็น symlink |
| `-r FILE` | อ่านได้ |
| `-w FILE` | เขียนได้ |
| `-x FILE` | execute ได้ |
| `-s FILE` | มีขนาดมากกว่า 0 byte |

---

## Test File เพิ่มเติม

| Test | คำอธิบาย |
| --- | --- |
| `-b FILE` | block device |
| `-c FILE` | character device |
| `-p FILE` | named pipe (FIFO) |
| `-S FILE` | socket |
| `-O FILE` | เจ้าของเป็นผู้ใช้ปัจจุบัน |
| `FILE1 -nt FILE2` | newer than |
| `FILE1 -ot FILE2` | older than |
| `FILE1 -ef FILE2` | inode เดียวกัน |

---

## ตัวอย่าง Test File

```bash
target="/etc/hosts"

if [[ -e "$target" ]]; then
    echo "✓ มีไฟล์อยู่"
fi

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

[[ -r "$target" ]] && echo "อ่านได้"
[[ -w "$target" ]] && echo "เขียนได้"
```

---

## 6.4.3 Test String

| Test | ความหมาย |
| --- | --- |
| `-z STR` | ว่างเปล่า (zero length) |
| `-n STR` | ไม่ว่าง (non-zero length) |
| `STR1 == STR2` | เท่ากัน (Bash) |
| `STR1 != STR2` | ไม่เท่ากัน |
| `STR1 < STR2` | น้อยกว่า (lexicographic) |
| `STR =~ regex` | ตรงกับ regex |

---

## ตัวอย่าง Test String

```bash
name=""
[[ -z "$name" ]] && echo "ชื่อว่าง"     # true

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

# Pattern matching ใน [[ ]]
filename="report.pdf"
if [[ "$filename" == *.pdf ]]; then
    echo "เป็น PDF"
fi
```

---

## Regular Expression ใน Bash

```bash
email="user@example.com"
if [[ "$email" =~ ^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$ ]]; then
    echo "อีเมลถูกต้อง"
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

| Operator | ความหมาย | สัญลักษณ์ |
| --- | --- | --- |
| `-eq` | equal | `==` |
| `-ne` | not equal | `!=` |
| `-lt` | less than | `<` |
| `-le` | less than or equal | `<=` |
| `-gt` | greater than | `>` |
| `-ge` | greater than or equal | `>=` |

---

## ตัวอย่าง Test Number

```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 < b )); then echo "a < b"; fi
if (( a == 10 )); then echo "a == 10"; fi

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

---

## 6.4.5 [[ ]] vs [ ] vs test

`test`, `[ ]` เป็นคำสั่งภายนอก/builtin POSIX ดั้งเดิม

ส่วน `[[ ]]` เป็น keyword ของ Bash ที่มี Feature เพิ่ม เช่น regex, pattern matching, ไม่ต้องใส่ quote ตัวแปร

---

## เปรียบเทียบ [[ ]] vs [ ]

| คุณสมบัติ | `[ ]` / test | `[[ ]]` |
| --- | --- | --- |
| POSIX | ✅ | ❌ Bash/zsh |
| ต้อง quote ตัวแปร | ✅ | ❌ |
| Word splitting | ✅ | ❌ |
| Pattern match `==` | ❌ | ✅ |
| Regex `=~` | ❌ | ✅ |
| Logic `&&` `\|\|` | ❌ ใช้ `-a` `-o` | ✅ |

**คำแนะนำ:** ใน Bash ใช้ `[[ ]]` เสมอ ปลอดภัยกว่า

---

## 6.4.6 Logical Operator

```bash
# Short-circuit evaluation
# &&  : AND (รันต่อเมื่อตัวแรกสำเร็จ)
# ||  : OR  (รันต่อเมื่อตัวแรกล้มเหลว)

[[ -d /tmp ]] && echo "มี /tmp"
[[ -d /nonexistent ]] || echo "ไม่มี"

# pattern: command1 && command2 || command3
mkdir backup && echo "สำเร็จ" || echo "ล้มเหลว"

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

---

## ตัวอย่าง Logical Operator ใช้งานจริง

```bash
# ตรวจสอบ + ติดตั้งถ้าไม่มี
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; }

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

---

## 6.4.7 case / esac

`case` เหมาะกับการเปรียบเทียบค่าเดียวกับหลาย pattern

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

```bash
case "$VARIABLE" in
    pattern1)
        # คำสั่ง
        ;;
    pattern2 | pattern3)
        # คำสั่ง
        ;;
    *)  # default
        ;;
esac
```

---

## ตัวอย่าง case: เมนู

```bash
read -p "เลือก [s]tart, [r]estart, [q]uit: " action

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

---

## ตัวอย่าง case: จำแนกไฟล์

```bash
process_file() {
    local file="$1"
    case "$file" in
        *.jpg | *.jpeg | *.png | *.gif)
            echo "$file: รูปภาพ"
            ;;
        *.mp4 | *.mkv | *.avi)
            echo "$file: วิดีโอ"
            ;;
        *.tar.gz | *.zip)
            echo "$file: archive"
            ;;
        *.sh | *.bash)
            echo "$file: shell script"
            ;;
    esac
}
```

---

## ตัวอย่าง case: ตรวจ OS

```bash
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 ด้วย ;& และ ;;&
```

---

# 6.5 Loops
## วนซ้ำ

---

## 6.5 Loops (วนซ้ำ)

วนซ้ำเป็นโครงสร้างพื้นฐานในการทำงานซ้ำ ๆ

Bash มีลูป 3 แบบหลัก:
- `for` — วนตามรายการ
- `while` — วนเมื่อเงื่อนไข true
- `until` — วนเมื่อเงื่อนไข false

พร้อมคำสั่งควบคุม `break` และ `continue`

---

## แผนผังการทำงานของ Loop

<pre class="mermaid">
%%{init: {'theme':'base', 'themeVariables': {
  'primaryColor': '#3c3836', 'primaryTextColor': '#ebdbb2',
  'primaryBorderColor': '#928374', 'lineColor': '#a89984',
  'secondaryColor': '#504945', 'background': '#282828',
  'mainBkg': '#3c3836'
}}}%%
flowchart TD
    F1[เริ่ม init] --> F2{มี item ถัดไป?}
    F2 -->|ใช่| F3[ทำคำสั่ง]
    F3 --> F2
    F2 -->|ไม่| F4[จบ]
</pre>

---

## 6.5.1 for loop: list-style

```bash
# วนตามรายการ
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
```

---

## for loop: range

```bash
# 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
```

---

## for loop: C-style

```bash
# 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"
done

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

---

## ตัวอย่าง for ใช้งานจริง

```bash
# process หลายไฟล์
for img in *.jpg; do
    [[ -f "$img" ]] || continue
    out="${img%.jpg}.webp"
    echo "Converting $img -> $out"
done

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

# วนผ่านไฟล์ใน directory
for f in /etc/*.conf; do
    [[ -f "$f" ]] || continue
    echo "config: $f"
done
```

---

## 6.5.2 while loop พื้นฐาน

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

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

---

## while loop ขั้นสูง

```bash
# อ่าน command output (ระวัง subshell)
count=0
while IFS= read -r f; do
    ((count++))
done < <(ls /tmp)
echo "นับได้ $count ไฟล์"

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

# ลูปไม่รู้จบ
while true; do
    sleep 5
    [[ -f /tmp/stop ]] && break
done
```

---

## 6.5.3 until loop

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

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

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

---

## 6.5.4 break และ continue

```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 หลายชั้น

```bash
# break N: ออก N ลูป
for i in {1..3}; do
    for j in {1..3}; do
        if [[ $i -eq 2 && $j -eq 2 ]]; then
            break 2     # ออก 2 ลูป
        fi
        echo "i=$i j=$j"
    done
done

# continue N: ข้ามไป iteration ถัดไปของ outer
for i in {1..3}; do
    for j in {1..3}; do
        [[ $j -eq 2 ]] && continue 2
        echo "i=$i j=$j"
    done
done
```

---

## 6.5.5 seq และ Brace Expansion

```bash
# seq command
seq 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

# 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
echo {1..10..2}        # 1 3 5 7 9
echo {a..e}            # a b c d e
```

---

## Brace Expansion ขั้นสูง

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

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

---

## 6.5.6 Infinite Loop และ Polling

```bash
# รูปแบบ infinite loop
while true; do
    sleep 1
done

while :; do                # : เทียบเท่า true
    sleep 1
done

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

---

## Polling Pattern

```bash
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!"
            return 0
        fi
        sleep "$interval"
    done
}
```

---

## Graceful Shutdown

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

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

---

## สมการ: Polling Wait Time

โดย <math xmlns="http://www.w3.org/1998/Math/MathML"><mi>P</mi></math> คือ Polling Interval (วินาที) และ <math xmlns="http://www.w3.org/1998/Math/MathML"><mi>E</mi><mo>[</mo><msub><mi>T</mi><mrow><mi>w</mi><mi>a</mi><mi>i</mi><mi>t</mi></mrow></msub><mo>]</mo></math> คือเวลารอเฉลี่ยจนเหตุการณ์ถูกตรวจพบ

**Trade-off:** Polling ที่บ่อยขึ้นย่อมตอบสนองเร็วขึ้นแต่ใช้ทรัพยากรมากขึ้น

---

# 6.6 Functions
## ฟังก์ชัน

---

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

ฟังก์ชันคือบล็อกของคำสั่งที่ตั้งชื่อไว้และเรียกใช้ซ้ำได้

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

---

## 6.6.1 การประกาศ Function

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

# รูปแบบที่ 2: Bash keyword
function greet2 {
    echo "Hi"
}

# รูปแบบที่ 3: รวมทั้งสอง
function greet3() {
    echo "Hello"
}

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

---

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

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

(`$0` ยังคงเป็นชื่อสคริปต์ ไม่ใช่ชื่อฟังก์ชัน)

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

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

---

## รับ Argument ไม่จำกัด

```bash
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

```bash
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` — สำหรับ true/false
- **String output** ผ่าน `echo`/`printf` แล้วใช้ command substitution `$(...)` รับค่า

---

## Return เป็น Exit Code

```bash
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

```bash
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
```

---

## คืนค่าหลายตัว: ตัวแปร Global

```bash
parse_url() {
    local url="$1"
    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
```

---

## Nameref (Bash 4.3+)

```bash
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

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

```bash
x=10

# ❌ ไม่ใช้ local — แก้ x global โดยไม่ตั้งใจ
bad_func() {
    x=99
    echo "in func: $x"
}
bad_func           # 99
echo "after: $x"   # 99 — เปลี่ยนแล้ว!
```

---

## ใช้ Local อย่างปลอดภัย

```bash
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
}
```

---

## 6.6.5 Recursion

Bash รองรับ recursion แต่ระวัง:

- Stack depth (default ~1000 ซ้อน)
- ไม่มี tail call optimization

จึงใช้กับงานเชิงวิเคราะห์ขนาดเล็กดีกว่า

---

## Recursion: Factorial

```bash
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
```

---

## Recursion: Fibonacci

```bash
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
```

---

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

<math xmlns="http://www.w3.org/1998/Math/MathML"><mi>n</mi><mo>!</mo></math> เรียกตัวเองด้วย <math xmlns="http://www.w3.org/1998/Math/MathML"><mo>(</mo><mi>n</mi><mo>-</mo><mn>1</mn><mo>)</mo><mo>!</mo></math> จนถึง base case

---

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

---

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

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

---

## 6.7.1 Indexed Array: การประกาศ

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

```bash
# การประกาศ
fruits=("apple" "banana" "cherry")
declare -a numbers=(10 20 30 40 50)
nums[0]=1; nums[5]=99           # sparse — มี gap

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

---

## Indexed Array: การเข้าถึง

```bash
echo "${fruits[0]}"           # apple
echo "${fruits[-1]}"          # cherry (index ลบ Bash 4.3+)
echo "${fruits[@]}"           # ทั้งหมด
echo "${#fruits[@]}"          # 3 (length)
echo "${!fruits[@]}"          # 0 1 2 (indices)

# slice
arr=(a b c d e f g h)
echo "${arr[@]:2}"            # c d e f g h
echo "${arr[@]:2:3}"          # c d e
echo "${arr[@]: -2}"          # g h
```

---

## Indexed Array: เพิ่ม/ลบ

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

# ลบ element
unset 'fruits[1]'               # ลบ index 1
unset fruits                    # ลบทั้ง array

# Compact (ลบ gap)
arr=("${arr[@]}")               # rebuild
```

---

## 6.7.2 Associative Array

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

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

user_info["name"]="Moo"
user_info["age"]=42
user_info["email"]="moo@example.com"

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

---

## Associative Array: การใช้งาน

```bash
echo "${user_info[name]}"        # Moo
echo "${!user_info[@]}"          # keys
echo "${user_info[@]}"           # values
echo "${#user_info[@]}"          # จำนวน

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

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

---

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

```bash
arr=(a b c d e f g)

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

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

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

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

---

## ความแตกต่าง @ vs *

```bash
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 เชื่อม
```

---

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

```bash
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
for ((i = 0; i < ${#fruits[@]}; i++)); do
    echo "$i: ${fruits[$i]}"
done
```

---

## ตัวอย่าง: หาคะแนนสูงสุด

```bash
declare -A scores=(
    [math]=85
    [english]=72
    [thai]=90
    [science]=88
)

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)"
```

---

## ตัวอย่าง: นับความถี่ของคำ

```bash
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)
for i in "${!names[@]}"; do
    printf "%-10s | %2d ปี\n" "${names[$i]}" "${ages[$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

---

## Here Document พื้นฐาน

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

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

---

## Here Document ใช้สร้างไฟล์

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

# ตัด tab นำหน้าด้วย <<-
if true; then
	cat <<-EOF
	บรรทัดนี้มี tab นำหน้า
	แต่ <<- จะตัดออก ทำให้ output ดู clean
	EOF
fi
```

---

## Here Document กับคำสั่งอื่น

```bash
# ส่งคำสั่ง 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;
SQL

# เขียนสคริปต์ Python ใน Bash
python3 <<'PYEOF'
import sys
print("Python within Bash!")
PYEOF
```

---

## 6.8.2 Here String (<<<)

Here String ส่งข้อความบรรทัดเดียวเข้า stdin

เปรียบเหมือน `echo "..." | cmd` แต่เร็วกว่าและไม่ fork

```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 ปัจจุบัน
```

---

## Here String กับ Regex

```bash
# ใช้กับ 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
```

---

## 6.8.3 getopts สำหรับ Argument Parsing

`getopts` เป็น builtin สำหรับแยก option flag (-a, -b, -c) แบบ POSIX-compatible

```bash
while getopts ":u:p:vh" opt; do
    case "$opt" in
        u) user="$OPTARG" ;;
        p) port="$OPTARG" ;;
        v) verbose=1 ;;
        h) usage ;;
        :) echo "Error: -$OPTARG ต้องมีค่า" >&2; usage ;;
        ?) echo "Error: option ไม่รู้จัก" >&2; usage ;;
    esac
done

# shift options ออก เหลือ argument ที่ไม่ใช่ option
shift $((OPTIND - 1))
```

---

## ตัวอย่าง getopts เต็ม

```bash
usage() {
    cat <<EOF
Usage: $0 -u USER -p PORT [-v] [-h]
  -u USER     ชื่อผู้ใช้ (จำเป็น)
  -p PORT     พอร์ต (default 22)
  -v          verbose mode
EOF
    exit 1
}

# ค่าเริ่มต้น
user=""
port=22
verbose=0

# parse argument...
[[ -z "$user" ]] && usage

echo "User: $user, Port: $port"
```

---

## Long Option Parser

```bash
# getopts รองรับเฉพาะ short option (-x)
# สำหรับ long option ต้องเขียน parser เอง
while [[ $# -gt 0 ]]; do
    case "$1" in
        -u | --user)
            user="$2"; shift 2 ;;
        -p | --port)
            port="$2"; shift 2 ;;
        -v | --verbose)
            verbose=1; shift ;;
        --user=*)
            user="${1#*=}"; shift ;;
        *)
            args+=("$1"); shift ;;
    esac
done
```

---

## 6.8.4 select สำหรับ Interactive Menu

`select` builtin สร้าง menu เลขเลือกอัตโนมัติ ใช้ทำเครื่องมือ interactive

```bash
PS3="กรุณาเลือก action: "

select action in "Start" "Stop" "Restart" "Quit"; do
    case "$action" in
        Start) echo "เริ่มต้น..." ;;
        Stop) echo "หยุดทำงาน..." ;;
        Restart) echo "รีสตาร์ท..." ;;
        Quit) break ;;
        *) echo "ตัวเลือกไม่ถูกต้อง" ;;
    esac
done
```

---

## select ขั้นสูง

```bash
# เลือกจากไฟล์ใน directory
echo "เลือกไฟล์ที่ต้องการดู:"
select file in *.log; do
    if [[ -n "$file" ]]; then
        less "$file"
        break
    fi
done

# เลือกจากหลาย source
options=("/etc/passwd" "/etc/group" "/etc/hosts" "Quit")
PS3="ไฟล์ไหน? "
select choice in "${options[@]}"; do
    case "$choice" in
        Quit) break ;;
        *) cat "$choice"; break ;;
    esac
done
```

---

## 6.8.5 IFS (Internal Field Separator)

`IFS` เป็นตัวแปรที่ shell ใช้เป็นตัวแยก field ใน word splitting

ค่า default คือ space, tab, newline (`$' \t\n'`)

```bash
# ดู IFS ปัจจุบัน
echo "IFS: $(printf '%q' "$IFS")"   # $' \t\n'

# เปลี่ยน IFS เพื่อ split string
csv="apple,banana,cherry,durian"
IFS=',' read -ra arr2 <<< "$csv"
echo "ได้: ${#arr2[@]} ตัว"      # 4
```

---

## IFS Pattern

```bash
# split path
path="/usr/local/bin"
IFS='/' read -ra parts <<< "$path"
for p in "${parts[@]}"; do echo "[$p]"; done

# save & restore IFS
oldIFS=$IFS
IFS='|'
# ทำงาน...
IFS=$oldIFS

# ใช้ subshell เพื่อ scope IFS
(
    IFS=':'
    for p in $PATH; do
        echo "PATH dir: $p"
    done
)
```

---

## IFS อ่านไฟล์ CSV

```bash
while IFS=',' read -r name age city; do
    echo "$name | $age | $city"
done <<EOF
Alice,30,Bangkok
Bob,25,Chiang Mai
Charlie,35,Phuket
EOF

# IFS เปล่า — เก็บทุก whitespace
while IFS= read -r line; do
    echo "[$line]"
done < /etc/issue
```

---

# 6.9 การจัดการข้อผิดพลาด
## Error Handling

---

## 6.9 การจัดการข้อผิดพลาด

Shell Script เริ่มต้นมาแบบ "ถูกใจมือใหม่" คือยังคงทำงานต่อแม้ว่าคำสั่งจะล้มเหลว ทำให้บั๊กยากตรวจ

ผู้พัฒนาที่ดีควรเปิดโหมดเข้มงวดและจัดการ error อย่างระมัดระวัง

---

## แผนผัง Error Handling

<pre class="mermaid">
%%{init: {'theme':'base', 'themeVariables': {
  'primaryColor': '#3c3836', 'primaryTextColor': '#ebdbb2',
  'primaryBorderColor': '#928374', 'lineColor': '#a89984',
  'secondaryColor': '#504945', 'background': '#282828',
  'mainBkg': '#3c3836'
}}}%%
flowchart LR
    S[Script Start] --> O[set -euo pipefail]
    O --> T[trap ERR จับ error]
    T --> R[Run command]
    R -->|success| C[continue]
    R -->|error| H[trap handler cleanup + exit]
    C --> X[exit 0]
    H --> X
</pre>

---

## 6.9.1 Exit Code

Process ทุกตัวคืน exit code (status) เป็นเลข 0-255 เมื่อจบ

ค่ามาตรฐาน: 0 = สำเร็จ, ไม่ใช่ 0 = ผิดพลาด

| Exit Code | ความหมาย |
| --- | --- |
| 0 | สำเร็จ |
| 1 | error ทั่วไป |
| 2 | misuse of shell builtin |
| 126 | permission denied |
| 127 | command not found |
| 128+N | ถูก kill ด้วย signal N |

---

## ตัวอย่างการใช้ Exit Code

```bash
# ดู exit code ของคำสั่งล่าสุด
ls /etc
echo "exit: $?"        # 0

ls /nonexistent 2>/dev/null
echo "exit: $?"        # 2

# ตั้ง exit code ของสคริปต์เอง
do_work() {
    if [[ ! -f "$1" ]]; then
        echo "Error: ไม่พบไฟล์ $1" >&2
        return 1
    fi
    return 0
}
```

---

## Defined Exit Codes

```bash
# รูปแบบที่นิยม
readonly E_OK=0
readonly E_ARG=1
readonly E_NOFILE=2
readonly E_NOPERM=3
readonly E_NETWORK=4

main() {
    [[ $# -lt 1 ]] && exit $E_ARG
    [[ ! -f "$1" ]] && exit $E_NOFILE
    [[ ! -r "$1" ]] && exit $E_NOPERM
    # ... ทำงาน
    exit $E_OK
}
```

---

## 6.9.2 set Options (Strict Mode)

```bash
# set -e (errexit): หยุดทันทีเมื่อคำสั่งล้มเหลว
set -e
ls /nonexistent       # error → exit ทันที

# set -u (nounset): error ถ้าใช้ตัวแปรที่ไม่ได้ตั้ง
set -u
echo "$undefined"     # bash: unbound variable

# set -x (xtrace): พิมพ์คำสั่งก่อนรัน — debug
set -x

# set -o pipefail: pipe ล้มเหลวถ้าคำสั่งใดในนั้นล้ม
set -o pipefail
```

---

## Strict Mode (Best Practice)

```bash
#!/usr/bin/env bash
set -euo pipefail
IFS=$'\n\t'

# ตัวเลือกอื่น
set -E      # trap ERR ทำงานใน function/subshell
set -T      # trap DEBUG ทำงานใน function

# ปิด errexit ชั่วคราว
set +e
some_command_might_fail
result=$?
set -e

# หรือใช้ || เพื่อข้าม errexit
some_command_might_fail || true
```

---

## 6.9.3 trap สำหรับจับ Signal

`trap` กำหนด handler เมื่อสคริปต์ได้รับ signal หรือเหตุการณ์พิเศษ

ใช้สำหรับ cleanup, logging, atomic operation

| Signal/Event | คำอธิบาย |
| --- | --- |
| `EXIT` | ก่อนสคริปต์จบ (ทุกกรณี) |
| `ERR` | เมื่อคำสั่งคืน non-zero |
| `INT` | Ctrl+C (SIGINT) |
| `TERM` | kill (SIGTERM) |
| `HUP` | SIGHUP (terminal ปิด) |

---

## Pattern: Cleanup ก่อนออก

```bash
TMPDIR=$(mktemp -d)
echo "ทำงานใน $TMPDIR"

cleanup() {
    echo "กำลัง cleanup..."
    rm -rf "$TMPDIR"
    echo "ลบ $TMPDIR แล้ว"
}
trap cleanup EXIT

# ทำงาน
touch "$TMPDIR/data.txt"
echo "test" > "$TMPDIR/data.txt"
# เมื่อจบ trap จะเรียก cleanup อัตโนมัติ
```

---

## Trap: จับ Ctrl+C และ ERR

```bash
# จับ Ctrl+C
processed=0
on_interrupt() {
    echo
    echo "ถูกหยุดที่ครั้งที่ $processed"
    exit 130
}
trap on_interrupt INT

# จับ ERR เพื่อ log error
set -eE                   # -E ทำให้ trap ERR สืบทอด
on_error() {
    local exit_code=$?
    local line_no=${BASH_LINENO[0]}
    local cmd="$BASH_COMMAND"
    echo "ERROR: '$cmd' ล้มเหลว line $line_no" >&2
}
trap on_error ERR
```

---

## 6.9.4 Debugging Techniques

```bash
# Method 1: bash -x ทั้งสคริปต์
# bash -x ./script.sh

# Method 2: bash -n syntax check (ไม่รัน)
# bash -n ./script.sh

# Method 3: set -x เฉพาะส่วน
echo "ปกติ"
set -x
problematic_section() {
    name="moo"
    echo "$name"
}
problematic_section
set +x
```

---

## Custom PS4 สำหรับ Debug

```bash
# ปรับ PS4 ให้ debug ดียิ่งขึ้น
export PS4='+ ${BASH_SOURCE}:${LINENO} ${FUNCNAME[0]:-main}() : '
set -x
my_func() {
    echo "test"
}
my_func
# + script.sh:5 main() : my_func
# + script.sh:3 my_func() : echo test
```

---

## Log Function หลายระดับ

```bash
LOG_LEVEL="${LOG_LEVEL:-INFO}"

log() {
    local level="$1"; shift
    local levels=(DEBUG INFO WARN ERROR)
    # ... compare level ...
    printf '[%s] [%s] %s\n' \
        "$(date '+%F %T')" "$level" "$*" >&2
}

log DEBUG "ค่าตัวแปร x=$x"
log INFO  "เริ่มต้นทำงาน"
log WARN  "ไฟล์ขนาดใหญ่"
log ERROR "เชื่อมต่อล้มเหลว"
```

---

## 6.9.5 ShellCheck

**ShellCheck** ([shellcheck.net](https://www.shellcheck.net)) คือ static analyzer สำหรับ shell script ที่ตรวจหาปัญหาและแนะนำการแก้ไข

เป็นเครื่องมือบังคับสำหรับนักเขียนสคริปต์มืออาชีพ

```bash
# ติดตั้ง
sudo pacman -S shellcheck      # Arch
sudo apt install shellcheck    # Debian/Ubuntu
sudo dnf install ShellCheck    # Fedora

# ใช้งาน
shellcheck script.sh
```

---

## คำเตือนยอดฮิตของ ShellCheck

| รหัส | ความหมาย | แก้ไข |
| --- | --- | --- |
| SC2086 | ตัวแปรไม่ใส่ quote | `echo "$var"` |
| SC2046 | command sub ไม่ใส่ quote | `cmd "$(...)"` |
| SC2155 | declare + assign แยก | `local x; x=$(...)` |
| SC2034 | ตัวแปรไม่ได้ใช้ | ลบหรือ export |
| SC2164 | `cd` อาจล้มเหลว | `cd dir \|\| exit 1` |

```bash
# disable เฉพาะกรณี
# shellcheck disable=SC2034
unused_var="ตั้งใจทิ้งไว้"
```

---

# 6.10 Best Practices
## แนวปฏิบัติที่ดี

---

## 6.10.1 ตั้งชื่อให้สื่อความหมาย

```bash
# ❌ ไม่ดี
a=10
b=$a
c() { echo "$1"; }

# ✅ ดีกว่า
max_retry=10
current_attempt=$max_retry
display_message() { echo "$1"; }
```

**กฎทั่วไป:**
- constant/global: `UPPER_SNAKE_CASE`
- local variable: `lower_snake_case`
- function: `snake_case`
- private function: `_underscore_prefix`

---

## ตัวอย่างชื่อที่ดี

```bash
readonly MAX_RETRY=5
readonly CONFIG_PATH="/etc/myapp/config.yaml"
readonly LOG_FILE="/var/log/myapp.log"

deploy_app() {
    local app_name="$1"
    local target_host="$2"
    _validate_inputs "$app_name" "$target_host" || return 1
}

_validate_inputs() {              # private helper
    [[ -n "$1" ]] && [[ -n "$2" ]]
}
```

---

## 6.10.2 Comment และ Documentation

```bash
#!/usr/bin/env bash
#===========================================
# Name        : deploy.sh
# Description : Deploy application to servers
# Author      : Moo <moo@example.com>
# Created     : 2026-04-25
# Version     : 2.1.0
#
# Dependencies:
#   - rsync >= 3.1
#   - ssh client, jq
#
# Exit Codes:
#   0=สำเร็จ 1=arg ผิด 2=config หาย
#===========================================
```

---

## Function Documentation

```bash
#-------------------------------------------
# build_artifact: สร้าง artifact จาก source
# Args:
#   $1 - source directory
#   $2 - output path
# Returns:
#   0 = ทำสำเร็จ
#   1 = source ไม่พบ
# Globals:
#   BUILD_FLAGS (read)
#-------------------------------------------
build_artifact() {
    local src="$1"
    local out="$2"
    [[ -d "$src" ]] || return 1
    # ...
}
```

---

## 6.10.3 Idempotency

สคริปต์ที่ดี **idempotent** — รันกี่ครั้งก็ได้ผลเหมือนเดิม ไม่สร้างผลข้างเคียงสะสม

เป็นหัวใจของ DevOps automation

```bash
# ❌ ไม่ idempotent — เพิ่ม line ทุกครั้ง
echo "PATH=/opt/myapp/bin:\$PATH" >> ~/.bashrc

# ✅ idempotent — เช็คก่อนเพิ่ม
if ! grep -q "/opt/myapp/bin" ~/.bashrc; then
    echo 'PATH=/opt/myapp/bin:$PATH' >> ~/.bashrc
fi
```

---

## ตัวอย่าง Idempotent Operations

```bash
# ❌ mkdir error ถ้ามีอยู่แล้ว
mkdir /var/log/myapp

# ✅ -p ไม่ error ถ้ามี
mkdir -p /var/log/myapp

# ❌ symlink ซ้ำซ้อน
ln -s /opt/myapp/bin/cli /usr/local/bin/cli

# ✅ ลบก่อนสร้างใหม่
ln -sf /opt/myapp/bin/cli /usr/local/bin/cli

# ✅ เช็คก่อนสร้าง user
id -u appuser &>/dev/null || useradd -m appuser
```

---

## Pattern: Ensure Config

```bash
# pattern: ensure line in file
ensure_line_in_file() {
    local line="$1"
    local file="$2"
    grep -qxF "$line" "$file" || echo "$line" >> "$file"
}

# pattern: ensure config
ensure_config() {
    local key="$1"
    local value="$2"
    local file="$3"
    if grep -q "^${key}=" "$file"; then
        sed -i "s|^${key}=.*|${key}=${value}|" "$file"
    else
        echo "${key}=${value}" >> "$file"
    fi
}
```

---

## 6.10.4 POSIX-compliant

ถ้าสคริปต์ต้องรันบนหลายระบบ (Alpine ใช้ ash, FreeBSD ใช้ sh, Embedded ใช้ busybox) ควรเขียนแบบ POSIX

```bash
#!/bin/sh
# POSIX-compliant

# ❌ Bash-only
arr=(a b c)              # array ไม่มีใน POSIX
[[ -z "$x" ]]            # [[ ]] ไม่มี
echo "${var^^}"          # case manipulation
function foo() {}        # keyword function

# ✅ POSIX
foo() { echo "ok"; }
[ -z "$x" ] && echo "empty"
echo "$var" | tr '[:lower:]' '[:upper:]'
```

---

## POSIX: Array & Substring

```bash
# Array → ใช้ positional parameter
set -- a b c
for item in "$@"; do echo "$item"; done

# String length
len=$(printf '%s' "$var" | wc -c)

# Substring (POSIX)
echo "$var" | cut -c1-5

# ตรวจสอบ POSIX compliance
shellcheck --shell=sh script.sh
checkbashisms script.sh
```

---

## 6.10.5 Google Shell Style Guide

**คำแนะนำหลัก:**

1. เลือกภาษาให้เหมาะ (เกิน 100 บรรทัด ใช้ Python/Go)
2. ใช้ Bash เท่านั้น `#!/usr/bin/env bash`
3. `set -euo pipefail` เสมอ
4. Indent 2 spaces (ไม่ใช้ tab)
5. Line length ≤ 80 ตัวอักษร
6. ใช้ `[[ ]]` แทน `[ ]`
7. Function อยู่บนสุด ก่อน main code
8. `main()` function เป็นจุดเริ่มต้น
9. อย่าใช้ backtick ใช้ `$(...)` แทน
10. อย่าใช้ `eval` ถ้าหลีกเลี่ยงได้

---

## Template Google-style

```bash
#!/usr/bin/env bash
set -euo pipefail
IFS=$'\n\t'

readonly SCRIPT_NAME="$(basename "$0")"
readonly SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"

err() {
  echo "[$(date +'%F %T')] ERROR: $*" >&2
}

usage() {
  cat <<EOF
Usage: $SCRIPT_NAME [options]
EOF
}

main() {
  if [[ $# -lt 1 ]]; then
    usage
    exit 1
  fi
}

main "$@"
```

---

# 6.11 ตัวอย่างการประยุกต์ใช้งาน
## Practical Applications

---

## 6.11.1 Backup/Restore Script

```bash
#!/usr/bin/env bash
set -euo pipefail

readonly SOURCE_DIR="${HOME}"
readonly BACKUP_DIR="/mnt/backup"
readonly KEEP_DAYS=7

log() {
    printf '[%s] %s\n' "$(date '+%F %T')" "$*"
}

backup() {
    local timestamp=$(date '+%Y%m%d_%H%M%S')
    local archive="${BACKUP_DIR}/home_${timestamp}.tar.gz"
    log "เริ่มสำรอง $SOURCE_DIR → $archive"
    tar -czf "$archive" -C "$(dirname "$SOURCE_DIR")" \
        "$(basename "$SOURCE_DIR")"
}
```

---

## Backup: Rotate และ Restore

```bash
rotate() {
    log "ลบ backup เก่ากว่า $KEEP_DAYS วัน"
    find "$BACKUP_DIR" -name "home_*.tar.gz" \
        -mtime "+$KEEP_DAYS" -delete
}

restore() {
    local archive="$1"
    local target="${2:-$HOME.restored}"
    [[ -f "$archive" ]] || { log "ERROR"; return 1; }
    log "กู้คืน $archive → $target"
    mkdir -p "$target"
    tar -xzf "$archive" -C "$target"
}

main() {
    case "${1:-backup}" in
        backup)  backup; rotate ;;
        restore) restore "${2:-}" ;;
        list)    ls -lh "$BACKUP_DIR" ;;
    esac
}
```

---

## 6.11.2 Log Rotation

```bash
#!/usr/bin/env bash
set -euo pipefail

readonly LOG_DIR="/var/log/myapp"
readonly MAX_SIZE_MB=100
readonly MAX_KEEP=10

rotate_log() {
    local logfile="$1"
    local size_mb=$(( $(stat -c%s "$logfile") / 1024 / 1024 ))

(( size_mb < MAX_SIZE_MB )) && return

# หมุนหมายเลข
    for ((i = MAX_KEEP - 1; i >= 1; i--)); do
        [[ -f "${logfile}.${i}" ]] && \
            mv "${logfile}.${i}" "${logfile}.$((i + 1))"
    done
    mv "$logfile" "${logfile}.1"
    : > "$logfile"          # สร้าง log ว่างใหม่
}
```

---

## Log Rotation: Compress & Cleanup

```bash
compress_old() {
    find "$LOG_DIR" -name "*.[0-9]" \
         -mtime "+1" -exec gzip {} \;
}

cleanup_old() {
    find "$LOG_DIR" -name "*.[0-9].gz" \
         -mtime "+$((MAX_KEEP * 7))" -delete
}

main() {
    for logfile in "$LOG_DIR"/*.log; do
        [[ -f "$logfile" ]] || continue
        rotate_log "$logfile"
    done
    compress_old
    cleanup_old
}

main "$@"
```

---

## 6.11.3 System Monitoring

```bash
#!/usr/bin/env bash
readonly CPU_THRESHOLD=80
readonly RAM_THRESHOLD=85
readonly DISK_THRESHOLD=90

check_cpu() {
    local cpu_usage
    cpu_usage=$(top -bn1 | awk '/Cpu/ {print 100-$8}' | cut -d. -f1)
    printf 'CPU  : %s%%\n' "$cpu_usage"
    (( cpu_usage > CPU_THRESHOLD )) && \
        alert "CPU สูงเกิน: ${cpu_usage}%"
}

check_ram() {
    local total used percent
    read -r total used <<< "$(free -m | awk '/^Mem:/ {print $2,$3}')"
    percent=$(( used * 100 / total ))
    printf 'RAM  : %dMB/%dMB (%d%%)\n' "$used" "$total" "$percent"
    (( percent > RAM_THRESHOLD )) && alert "RAM สูงเกิน"
}
```

---

## Monitoring: Disk และ Alert

```bash
check_disk() {
    while read -r fs size used avail percent mount; do
        local pct="${percent%\%}"
        printf 'Disk : %s %s/%s (%s)\n' \
            "$mount" "$used" "$size" "$percent"
        (( pct > DISK_THRESHOLD )) && \
            alert "Disk $mount สูงเกิน"
    done < <(df -h --output=source,size,used,avail,pcent,target \
             | grep -E '^/dev/')
}

alert() {
    local msg="$1"
    echo "[$(date '+%F %T')] ALERT: $msg" >&2
    command -v notify-send &>/dev/null && \
        notify-send -u critical "System Alert" "$msg"
}
```

---

## 6.11.4 Batch File Processing

```bash
#!/usr/bin/env bash
set -euo pipefail

readonly INPUT_DIR="${1:-./images}"
readonly OUTPUT_DIR="${2:-./output}"
readonly QUALITY=85
readonly MAX_WIDTH=1920
readonly PARALLEL_JOBS=4

convert_image() {
    local input="$1"
    local relative="${input#$INPUT_DIR/}"
    local output="$OUTPUT_DIR/${relative%.*}.webp"

mkdir -p "$(dirname "$output")"
    [[ -f "$output" && "$output" -nt "$input" ]] && return

cwebp -q $QUALITY "$input" -o "$output" -quiet
}
```

---

## Batch Processing: Parallel

```bash
export -f convert_image
export INPUT_DIR OUTPUT_DIR QUALITY MAX_WIDTH

main() {
    [[ -d "$INPUT_DIR" ]] || exit 1
    mkdir -p "$OUTPUT_DIR"

echo "ใช้ $PARALLEL_JOBS jobs ขนาน"

# parallel ด้วย xargs
    find "$INPUT_DIR" -type f \
         $ -iname '*.jpg' -o -iname '*.png' $ \
         -print0 \
        | xargs -0 -n1 -P "$PARALLEL_JOBS" \
                bash -c 'convert_image "$1"' _
}

main "$@"
```

---

## 6.11.5 Automation: cron

```bash
# แก้ crontab
crontab -e

# format: m h dom mon dow command

# ทุกวันเที่ยงคืน — สำรองข้อมูล
0 0 * * * /opt/scripts/backup.sh

# ทุก 5 นาที — ตรวจสอบ system
*/5 * * * * /opt/scripts/sysmon.sh

# วันที่ 1 ของเดือน — รายงาน
0 6 1 * * /opt/scripts/monthly-report.sh

# ใส่ environment
SHELL=/bin/bash
PATH=/usr/local/bin:/usr/bin:/bin
MAILTO="admin@example.com"
```

---

## Automation: systemd timer

```bash
# /etc/systemd/system/myapp-backup.service
[Unit]
Description=MyApp Backup Service

[Service]
Type=oneshot
User=backup
ExecStart=/opt/scripts/backup.sh

# /etc/systemd/system/myapp-backup.timer
[Unit]
Description=Run Backup Daily at 2 AM

[Timer]
OnCalendar=*-*-* 02:00:00
Persistent=true

[Install]
WantedBy=timers.target
```

---

## เปิดใช้งาน systemd timer

```bash
# enable และ start
sudo systemctl daemon-reload
sudo systemctl enable --now myapp-backup.timer

# ตรวจสอบ
systemctl list-timers --all
systemctl status myapp-backup.timer
journalctl -u myapp-backup.service -f
```

---

## 6.11.6 Deployment Script

<pre class="mermaid">
%%{init: {'theme':'base', 'themeVariables': {
  'primaryColor': '#3c3836', 'primaryTextColor': '#ebdbb2',
  'primaryBorderColor': '#928374', 'lineColor': '#a89984',
  'secondaryColor': '#504945', 'background': '#282828',
  'mainBkg': '#3c3836'
}}}%%
flowchart TD
    A[Start deploy] --> B[Preflight ตรวจ deps]
    B --> C[Build artifact]
    C --> D[Upload via rsync]
    D --> E[Activate symlink]
    E --> F[Restart service]
    F --> G{Health check?}
    G -->|Pass| H[Cleanup old]
    G -->|Fail| I[Rollback]
    H --> J[Done ✓]
    I --> K[Exit 1 ✗]
</pre>

---

## Deployment: Build & Upload

```bash
preflight() {
    log "ตรวจสอบ prerequisites"
    command -v rsync &>/dev/null || exit 1
    ssh -o ConnectTimeout=5 \
        "${DEPLOY_USER}@${REMOTE_HOST}" true || exit 1
}

upload() {
    local release_id=$(date +%Y%m%d_%H%M%S)
    local release_path="${RELEASES_DIR}/${release_id}"
    ssh "${DEPLOY_USER}@${REMOTE_HOST}" "mkdir -p '${release_path}'"
    rsync -avz --delete ./dist/ \
        "${DEPLOY_USER}@${REMOTE_HOST}:${release_path}/"
    echo "$release_id"
}
```

---

## Deployment: Activate & Health Check

```bash
activate() {
    local release_id="$1"
    ssh "${DEPLOY_USER}@${REMOTE_HOST}" bash <<EOF
ln -sfn '${RELEASES_DIR}/${release_id}' '${CURRENT_LINK}'
sudo systemctl restart ${APP_NAME}.service
EOF
}

health_check() {
    local i=0
    while (( i < 30 )); do
        curl -sf "http://${REMOTE_HOST}/health" &>/dev/null && \
            return 0
        sleep 2
        ((i++))
    done
    return 1
}
```

---

## Deployment: Rollback

```bash
rollback() {
    log "Rollback ไปยัง release ก่อนหน้า"
    ssh "${DEPLOY_USER}@${REMOTE_HOST}" bash <<EOF
cd '${RELEASES_DIR}'
prev=\$(ls -t | sed -n '2p')
ln -sfn '${RELEASES_DIR}/'"\$prev" '${CURRENT_LINK}'
sudo systemctl restart ${APP_NAME}.service
EOF
}

main() {
    case "${1:-deploy}" in
        deploy)   preflight; build; upload; activate ;;
        rollback) rollback ;;
        list)     ssh ... "ls -lt '${RELEASES_DIR}'" ;;
    esac
}
```

---

# สรุปท้ายบท
## Chapter Summary

---

## สรุปท้ายบท

Shell Script เป็นเครื่องมือสำคัญที่นักพัฒนาและผู้ดูแลระบบ Linux ทุกคนต้องใช้ทุกวัน

บทนี้ได้กล่าวถึงตั้งแต่พื้นฐาน — โครงสร้างไฟล์ ตัวแปร เงื่อนไข การวนซ้ำ ฟังก์ชัน — ไปจนถึงเทคนิคขั้นสูงเช่น associative array, here document, getopts และ trap signal

---

## สิ่งที่สำคัญที่สุด

**การเขียนสคริปต์ที่ปลอดภัย** ผ่าน:

- `set -euo pipefail` ในต้นไฟล์
- การใช้ `local` ในฟังก์ชัน
- การ quote ตัวแปรเสมอ `"$var"`
- การตรวจ syntax ด้วย **ShellCheck**

ตัวอย่างประยุกต์แสดงให้เห็นว่าสคริปต์ที่เขียนอย่างเป็นระบบสามารถทำงานสำคัญได้จริง ตั้งแต่ backup, monitoring, batch processing, ไปจนถึง deployment ที่มี rollback

---

## แหล่งศึกษาเพิ่มเติม

- [Bash Reference Manual](https://www.gnu.org/software/bash/manual/) — เอกสารทางการของ GNU Bash
- [Advanced Bash-Scripting Guide](https://tldp.org/LDP/abs/html/) — คู่มือเชิงลึกใน TLDP
- [Google Shell Style Guide](https://google.github.io/styleguide/shellguide.html) — แนวปฏิบัติที่ดี
- [ShellCheck](https://www.shellcheck.net/) — ตรวจสอบสคริปต์ออนไลน์
- [ExplainShell](https://explainshell.com/) — อธิบายความหมายของคำสั่ง
- `man bash` — manual ในเครื่อง

---

# คําถาม - ข้อสงสัย
<img src="/revealjs/pics/os.png" width="55%" />