Linux Command Line & Bash Scripting Mastery · บทเรียน

รูปแบบ ช่วง และบล็อก BEGIN/END

กรองระเบียนด้วยรูปแบบตามเงื่อนไข และสร้างส่วนหัวกับผลรวมโดยใช้บล็อก BEGIN และ END

รูปแบบ ช่วง และบล็อก BEGIN/END เป็นบทเรียน Linux Command Line & Bash Scripting Mastery ฟรีบน CoddyKit นี่คือบทเรียนที่ 2 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Linux Command Line & Bash Scripting Mastery และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Linux Command Line & Bash Scripting Mastery มีบทเรียนทั้งหมด 4 บทเรียน

รูปแบบของ awk คืออะไร

ใน awk รูปแบบคือเงื่อนไขที่ควบคุมว่าจะให้บล็อกการดำเนินการทำงานกับบรรทัดข้อมูลขาเข้าที่กำหนดหรือไม่ รูปแบบทั่วไปคือ:

awk 'pattern { action }' file

หากรูปแบบตรงกับระเบียนปัจจุบัน การดำเนินการจะทำงาน หากไม่ได้ระบุการดำเนินการ awk จะพิมพ์ทั้งบรรทัดโดยค่าเริ่มต้น รูปแบบอาจเป็น:

นิพจน์ทั่วไป — /regex/
นิพจน์สัมพันธ์ — $3 > 100
นิพจน์ผสม — $1 == "ERROR" && $4 > 500
รูปแบบช่วง — /start/,/end/
รูปแบบพิเศษ — BEGIN และ END

การทำความเข้าใจรูปแบบคือก้าวแรกสู่การใช้ awk เป็นตัวกรองข้อมูลที่มีประสิทธิภาพ แทนที่จะใช้เพียงพิมพ์คอลัมน์

รูปแบบนิพจน์ทั่วไปสำหรับกรองบรรทัด

ประเภทรูปแบบที่พบบ่อยที่สุดคือนิพจน์ทั่วไปที่ครอบด้วยเครื่องหมายทับ awk จะทดสอบแต่ละบรรทัดกับนิพจน์ทั่วไป และดำเนินการเฉพาะบรรทัดที่ตรงกัน

ด้านล่างนี้เราจะกรองไฟล์ลักษณะเดียวกับ /var/log/syslog เพื่อแสดงเฉพาะบรรทัดที่มีคำว่า ERROR:

#!/usr/bin/env bash
# Simulate a log file and filter ERROR lines
log=$(cat <<'EOF'
2026-06-11 08:01:22 INFO  service started
2026-06-11 08:02:05 ERROR disk quota exceeded on /dev/sda1
2026-06-11 08:02:44 WARN  memory usage at 80%
2026-06-11 08:03:10 ERROR connection timeout to 10.0.0.5
2026-06-11 08:03:55 INFO  backup completed
EOF
)

echo "=== ERROR lines only ==="
echo "$log" | awk '/ERROR/ { print NR": "$0 }'

รูปแบบปฏิเสธและรูปแบบผสม

เติม ! หน้ารูปแบบนิพจน์ทั่วไปเพื่อกลับเงื่อนไข ให้ตรงกับบรรทัดที่ ไม่มี รูปแบบนั้นอยู่ คุณสามารถรวมหลายเงื่อนไขด้วย && (AND) หรือ || (OR) เพื่อควบคุมได้ละเอียดขึ้น

!/DEBUG/ — ข้ามบรรทัดการแก้ไขข้อบกพร่อง
$3 > 500 && $5 == "POST" — คำขอ POST ขนาดใหญ่
/WARN/ || /ERROR/ — ระดับความรุนแรงอย่างใดอย่างหนึ่ง

ตัวอย่างด้านล่างแยกวิเคราะห์บันทึกการเข้าถึงแบบย่อ และพิมพ์เฉพาะคำขอ POST ที่มีขนาดการตอบกลับมากกว่า 1,000 ไบต์:

#!/usr/bin/env bash
access=$(cat <<'EOF'
10.0.0.1 GET  /api/ping     200  48
10.0.0.2 POST /api/upload   201  2048
10.0.0.3 GET  /api/users    200  512
10.0.0.4 POST /api/data     200  3500
10.0.0.5 POST /api/health   200  60
EOF
)

echo "Large POST requests (>1000 bytes):"
echo "$access" | awk '$2 == "POST" && $5 > 1000 { print $1, $3, "size="$5 }'

รูปแบบช่วง: /start/,/end/

รูปแบบช่วงใช้เลือกบล็อกระเบียนที่ต่อเนื่องกัน ตั้งแต่บรรทัดที่ตรงกับ /start/ ไปจนถึงบรรทัดที่ตรงกับ /end/ โดยรวมทั้งสองบรรทัดด้วย รูปแบบไวยากรณ์คือ:

awk '/start/,/end/ { action }' file

พฤติกรรมสำคัญที่ควรทราบ:

ช่วงจะเริ่มทำงานเมื่อพบบรรทัดแรกที่ตรงกับ /start/ และหยุดทำงานหลังจากพบบรรทัดถัดไปที่ตรงกับ /end/ เป็นครั้งแรก
หากไม่พบ /end/ ช่วงจะยังทำงานต่อจนถึง EOF
ช่วงที่ไม่ทับซ้อนกันหลายช่วงในไฟล์เดียวกันจะถูกประมวลผลแยกจากกัน

ด้วยเหตุนี้ รูปแบบช่วงจึงเหมาะอย่างยิ่งสำหรับดึงส่วนที่ทำเครื่องหมายไว้จากไฟล์การตั้งค่า บันทึกที่มีส่วนหัวเป็นตัวคั่น หรือรายงานที่แบ่งเป็นหลายบล็อก

การดึงส่วนต่าง ๆ ด้วยรูปแบบช่วง

ลองพิจารณาการตั้งค่าเซิร์ฟเวอร์ที่มีหลายส่วนและใช้ส่วนหัว [section] เป็นตัวแบ่ง เราต้องการเฉพาะบรรทัดภายใน [database]:

#!/usr/bin/env bash
config=$(cat <<'EOF'
[server]
host = 0.0.0.0
port = 8080

[database]
host = 127.0.0.1
port = 5432
name = appdb
user = admin

[cache]
host = 127.0.0.1
port = 6379
EOF
)

echo "=== [database] section ==="
echo "$config" | awk '/\[database\]/,/^\[/' \
  | awk 'NR > 1 && !/^\[/ && NF'

บล็อก BEGIN

บล็อก BEGIN จะทำงานเพียงครั้งเดียวก่อนอ่านข้อมูลขาเข้าใด ๆ จึงเหมาะสำหรับ:

พิมพ์ส่วนหัวรายงาน
กำหนดค่าเริ่มต้นให้ตัวแปรและตัวนับ
กำหนดตัวคั่นฟิลด์ (FS) หรือตัวแปรในตัวอื่น ๆ
เรียกใช้โปรแกรม awk แบบทำงานเดี่ยวที่ไม่ต้องรับข้อมูลขาเข้า

ไวยากรณ์:

awk 'BEGIN { setup } pattern { action }' file

การกำหนด FS ใน BEGIN เป็นทางเลือกที่เป็นระเบียบแทนแฟล็ก -F โดยเฉพาะเมื่อเขียนโปรแกรมที่มีกฎหลายข้อและตรรกะของตัวคั่นอยู่ภายในสคริปต์

#!/usr/bin/env bash
csv=$(cat <<'EOF'
alice,engineering,95000
bob,marketing,72000
carol,engineering,105000
dave,hr,68000
EOF
)

echo "$csv" | awk 'BEGIN {
  FS = ","
  printf "%-10s %-15s %10s\n", "Name", "Department", "Salary"
  print "--------------------------------------------"
}'

บล็อก END

บล็อก END จะทำงานเพียงครั้งเดียวหลังประมวลผลระเบียนสุดท้ายเสร็จสิ้น จึงเป็นตำแหน่งที่เหมาะสำหรับ:

พิมพ์ผลรวม ค่าเฉลี่ย และสรุปที่สะสมระหว่างการประมวลผล
เขียนข้อมูลค้างให้เสร็จหรือปิดไฟล์ผลลัพธ์
พิมพ์บรรทัดส่วนท้ายของรายงานที่จัดรูปแบบไว้

ตัวแปรที่กำหนดระหว่างกฎหลักยังคงอยู่ในขอบเขตภายใน END นี่คือวิธีทำงานของผลรวมสะสม ตัวอย่างด้านล่างรวมค่าเงินเดือนจาก CSV และพิมพ์ผลรวมไว้ในส่วนท้าย:

#!/usr/bin/env bash
csv=$(cat <<'EOF'
alice,engineering,95000
bob,marketing,72000
carol,engineering,105000
dave,hr,68000
EOF
)

echo "$csv" | awk -F',' '
  { total += $3; count++ }
  END { printf "Employees: %d  Total payroll: $%d\n", count, total }
'

การรวม BEGIN, กฎ และ END

พลังที่แท้จริงปรากฏขึ้นเมื่อคุณรวมบล็อกทั้งสามเป็นโปรแกรม awk แบบครบในตัวเดียว ซึ่งพิมพ์ส่วนหัว ประมวลผลแต่ละระเบียน และพิมพ์สรุป รูปแบบนี้เป็นพื้นฐานสำคัญของไปป์ไลน์สร้างรายงานด้วยเชลล์

ด้านล่างคือโปรแกรมสร้างรายงานฉบับสมบูรณ์ที่อ่าน CSV ของคำขอเว็บ พิมพ์รายละเอียดรายบรรทัด พร้อมจำนวนคำขอสุดท้ายที่ใช้เวลาเกิน 1 วินาที:

#!/usr/bin/env bash
data=$(cat <<'EOF'
/api/ping,0.03
/api/users,1.45
/api/login,0.88
/api/upload,2.10
/api/health,0.02
/api/report,1.73
EOF
)

echo "$data" | awk -F',' '
BEGIN {
  printf "%-20s %10s %s\n", "Endpoint", "Latency(s)", "Status"
  print "--------------------------------------"
}
{
  status = ($2 > 1.0) ? "SLOW" : "OK"
  if (status == "SLOW") slow++
  printf "%-20s %10s %s\n", $1, $2, status
}
END {
  print "--------------------------------------"
  printf "Slow requests: %d / %d\n", slow, NR
}
'

การใช้ BEGIN เพื่อกำหนด OFS และ ORS

ตัวแปรผลลัพธ์สองตัวที่มักถูกมองข้ามสามารถกำหนดได้อย่างเป็นระเบียบใน BEGIN:

OFS (ตัวคั่นฟิลด์ผลลัพธ์) — แทรกไว้ระหว่างฟิลด์เมื่อสร้างระเบียนใหม่ด้วย $1=$1 หรือใช้ print $1, $2
ORS (ตัวคั่นระเบียนผลลัพธ์) — เติมต่อท้ายหลังการเรียกใช้ print แต่ละครั้ง (ค่าเริ่มต้นคือ \n)

การกำหนด OFS="," ช่วยให้จัดรูปแบบ TSV เป็น CSV ได้ในการประมวลผลครั้งเดียวโดยไม่ต้องต่อสตริง การเปลี่ยน ORS เป็น "\n---\n" จะเพิ่มเส้นคั่นระหว่างระเบียนโดยอัตโนมัติ

#!/usr/bin/env bash
# Convert whitespace-delimited data to CSV with a header
data=$(cat <<'EOF'
alice   engineering  95000
bob     marketing    72000
carol   engineering  105000
EOF
)

echo "$data" | awk 'BEGIN { OFS=","; print "name,dept,salary" }
{ $1=$1; print }'

รูปแบบช่วงเชิงปฏิบัติ: ช่วงเหตุการณ์ในบันทึก

รูปแบบช่วงมีประโยชน์อย่างมากในการวิเคราะห์บันทึกการทำงาน งานที่พบบ่อยคือการดึงบรรทัดบันทึกทั้งหมดระหว่างจุดเริ่มต้นและจุดสิ้นสุดของเหตุการณ์ ซึ่งระบุด้วยข้อความสัญญาณ เช่น INCIDENT START และ INCIDENT END

ในตัวอย่างด้านล่าง awk จะดึงเฉพาะบรรทัดภายในช่วงเหตุการณ์และนับเหตุการณ์ ERROR ที่เกิดขึ้นในช่วงนั้น โดยรวมรูปแบบช่วงเข้ากับตัวสะสมและสรุปใน END:

#!/usr/bin/env bash
log=$(cat <<'EOF'
08:00:01 INFO  Normal operation
08:01:00 INFO  INCIDENT START: disk pressure detected
08:01:05 ERROR write failed on /dev/sda1
08:01:09 ERROR inode table corruption
08:01:14 WARN  remounting read-only
08:01:22 INFO  INCIDENT END: disk replaced
08:02:00 INFO  Normal operation resumed
EOF
)

echo "$log" | awk '
/INCIDENT START/,/INCIDENT END/ {
  print
  if (/ERROR/) errors++
}
END { print "Errors during incident:", errors+0 }
'

การข้ามบรรทัดตัวคั่นในช่วง

โดยค่าเริ่มต้น รูปแบบช่วงจะรวมบรรทัดที่ตรงกับ /start/ และ /end/ ไว้ด้วย หากต้องการข้ามบรรทัดตัวคั่นเหล่านั้นและเก็บเฉพาะเนื้อหาตรงกลาง ให้ครอบการดำเนินการด้วยการปฏิเสธหรือตัวแปรสถานะ:

แนวทางใช้การปฏิเสธ: /start/,/end/ { if (!/start/ && !/end/) print }
แนวทางใช้ตัวแปรสถานะ: กำหนดค่าตัวแปรเป็น 1 ด้วยตนเองเมื่อพบ /start/ และเป็น 0 เมื่อพบ /end/

แนวทางใช้ตัวแปรสถานะมีความทนทานมากกว่าเมื่อข้อความตัวคั่นอาจปรากฏอยู่ในเนื้อหาด้านในด้วย:

#!/usr/bin/env bash
doc=$(cat <<'EOF'
## preamble
some intro text
## BEGIN_REPORT
row1: alpha 100
row2: beta  200
row3: gamma 150
## END_REPORT
## appendix
EOF
)

echo "$doc" | awk '
/## BEGIN_REPORT/ { capture=1; next }
/## END_REPORT/   { capture=0 }
capture           { print }
'

ตรวจสอบความรู้: การทำงานของบล็อก BEGIN

ทดสอบความเข้าใจของคุณเกี่ยวกับการทำงานร่วมกันของบล็อก BEGIN และ END กับการประมวลผลข้อมูลขาเข้าใน awk

สรุปบทเรียน: รูปแบบ ช่วง และ BEGIN/END

ในบทเรียนนี้ คุณได้เรียนรู้คุณลักษณะเชิงโครงสร้างที่ทรงพลังที่สุดสามประการของโปรแกรม awk:

รูปแบบ — นิพจน์ทั่วไป (/ERROR/) นิพจน์สัมพันธ์ ($3 > 1000) รูปแบบปฏิเสธ (!/DEBUG/) และรูปแบบผสม (&&, ||) ใช้ควบคุมว่าระเบียนใดจะเรียกใช้การดำเนินการ โดยไม่ต้องเขียนคำสั่ง if อย่างชัดเจน
รูปแบบช่วง (/start/,/end/) — ใช้เลือกบล็อกระเบียนที่ต่อเนื่องกัน เหมาะสำหรับดึงช่วงเหตุการณ์จากบันทึก ส่วนการตั้งค่า และส่วนต่าง ๆ ของรายงาน หากต้องการตัดบรรทัดตัวคั่นออก ให้ใช้ตัวแปรสถานะ (next + ค่าบูลีน)
บล็อก BEGIN — ทำงานครั้งเดียวก่อนข้อมูลขาเข้าใด ๆ เหมาะสำหรับกำหนด FS, OFS, ORS ตั้งค่าเริ่มต้นให้ตัวนับ และพิมพ์ส่วนหัวรายงาน
บล็อก END — ทำงานครั้งเดียวหลังข้อมูลขาเข้าทั้งหมด เหมาะสำหรับพิมพ์ผลรวม ค่าเฉลี่ย และส่วนท้าย โดยใช้ตัวแปรที่สะสมในกฎหลัก

เมื่อใช้ร่วมกัน คุณจะสามารถเขียนโปรแกรม awk ที่สมบูรณ์และอธิบายตัวเองได้ โปรแกรมจะรับข้อความดิบและสร้างรายงานที่มีโครงสร้างและมนุษย์อ่านเข้าใจได้ ทั้งหมดนี้ทำได้ในขั้นตอนเดียวของไปป์ไลน์ โดยไม่ต้องใช้ไฟล์ชั่วคราวหรือเครื่องมือภายนอก

คำถามที่พบบ่อย

บทเรียน “รูปแบบ ช่วง และบล็อก BEGIN/END” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “รูปแบบ ช่วง และบล็อก BEGIN/END” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Linux Command Line & Bash Scripting Mastery ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Linux Command Line & Bash Scripting Mastery มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “รูปแบบ ช่วง และบล็อก BEGIN/END”

กรองระเบียนด้วยรูปแบบตามเงื่อนไข และสร้างส่วนหัวกับผลรวมโดยใช้บล็อก BEGIN และ END คุณปฏิบัติ Linux Command Line & Bash Scripting Mastery ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Linux Command Line & Bash Scripting Mastery หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Linux Command Line & Bash Scripting Mastery บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 2 จากทั้งหมด 4 บทเรียน

บทเรียน “รูปแบบ ช่วง และบล็อก BEGIN/END” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Linux Command Line & Bash Scripting Mastery นี้ได้ไหม

ได้ บทเรียน Linux Command Line & Bash Scripting Mastery ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

ระเบียน ฟิลด์ และตัวคั่นแบบกำหนดเองใน awk
รูปแบบ ช่วง และบล็อก BEGIN/END
การรวมข้อมูลด้วยอาร์เรย์และการจัดกลุ่มใน awk
ฟังก์ชัน awk การจัดรูปแบบด้วย printf และการสร้างรายงาน

← กลับไปที่ Linux Command Line & Bash Scripting Mastery