ฟังก์ชัน awk การจัดรูปแบบด้วย printf และการสร้างรายงาน
กำหนดฟังก์ชันของผู้ใช้และใช้ printf เพื่อสร้างรายงานแบบตารางที่เรียบร้อยจากกระแสข้อมูลดิบ
ฟังก์ชัน awk การจัดรูปแบบด้วย printf และการสร้างรายงาน เป็นบทเรียน DevOps Bootcamp ฟรีบน CoddyKit นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน DevOps Bootcamp และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส DevOps Bootcamp มีบทเรียนทั้งหมด 4 บทเรียน
เหตุใดฟังก์ชันและ printf จึงสำคัญใน awk
เมื่อโปรแกรม awk ของคุณเติบโตจากคำสั่งบรรทัดเดียวเป็นกระบวนการส่งต่อคำสั่งหลายขั้นตอน คุณลักษณะสองอย่างจะกลายเป็นสิ่งจำเป็น ได้แก่ ฟังก์ชันที่ผู้ใช้กำหนดและการจัดรูปแบบด้วย printf
ฟังก์ชันช่วยห่อหุ้มตรรกะที่นำกลับมาใช้ใหม่ได้ — เช่น เครื่องคำนวณเปอร์เซ็นต์ เครื่องตัดช่องว่างจากสตริง หรือตัวแปลงหน่วย — ทำให้คุณเขียนเพียงครั้งเดียวแล้วเรียกใช้ที่ใดก็ได้ในโปรแกรมเดียวกัน ส่วน printf ช่วยให้คุณควบคุมลักษณะของผลลัพธ์ได้อย่างแม่นยำ ทั้งความกว้างคอลัมน์ ตำแหน่งทศนิยม การเติมช่องว่าง และการจัดแนว
เมื่อนำมาทำงานร่วมกัน ทั้งสองอย่างจะเปลี่ยนบรรทัดบันทึกดิบให้เป็นรายงานที่เรียบร้อยและอ่านง่าย ซึ่งวิศวกรและผู้จัดการสามารถนำไปใช้ตัดสินใจได้
- ฟังก์ชันลดการเขียนซ้ำและทำให้โปรแกรมทดสอบแยกส่วนได้
printfจัดข้อมูลให้อยู่ในคอลัมน์ความกว้างคงที่ ทำให้รายงานยังอ่านง่ายแม้ความยาวของข้อมูลเข้าจะแตกต่างกัน- คุณลักษณะทั้งสองทำงานได้ใน POSIX awk, gawk และ mawk — ไม่ต้องใช้ส่วนขยาย
การกำหนดฟังก์ชันที่ผู้ใช้สร้างใน awk
ฟังก์ชันที่ผู้ใช้สร้างประกาศด้วยคำสำคัญ function โดยวางไว้ก่อนหรือหลังชุดกฎรูปแบบ-การทำงานใด ๆ ไวยากรณ์คือ:
function name(param1, param2, local1, local2) {
# body
return value
}รูปแบบการเขียน awk ที่สำคัญ: ตัวแปรเฉพาะที่เป็นเพียงพารามิเตอร์เพิ่มเติมที่มีช่องว่างนำหน้าเพิ่มขึ้น ไม่มีคำสำคัญ local — ธรรมเนียมการเว้นวรรคเพิ่มใช้สื่อว่าพารามิเตอร์เหล่านั้นเป็นตัวแปรเฉพาะที่ ไม่ใช่อาร์กิวเมนต์ที่ผู้เรียกส่งมา
- ตัวแปรทั้งหมดที่ไม่ได้ประกาศเป็นพารามิเตอร์จะเป็นตัวแปรส่วนกลางโดยค่าเริ่มต้น
- ฟังก์ชันสามารถเรียกตัวเองซ้ำได้
returnเป็นตัวเลือก หากไม่มี ฟังก์ชันจะคืนค่าสตริงว่าง
#!/usr/bin/env bash
# Demonstrate a simple awk user function
echo '10 3
7 0
100 4' | awk '
function divide(a, b, result) {
if (b == 0) return "ERR"
result = a / b
return result
}
{
print $1 "/" $2 " = " divide($1, $2)
}
'ฟังก์ชันที่มีตรรกะเกี่ยวกับสตริง
ฟังก์ชันมีประโยชน์อย่างยิ่งสำหรับการดำเนินการกับสตริงซ้ำ ๆ ลองพิจารณาการตัดช่องว่างด้านหน้าและด้านหลัง ซึ่งเป็นสิ่งที่ข้อมูลบันทึกดิบมักต้องทำก่อนการเปรียบเทียบหรือจัดทำรายงาน
ตัวอย่างด้านล่างกำหนด trim(s) โดยใช้ gsub และเรียกใช้กับทุกระเบียน ทำให้กฎหลักสะอาดและอ่านง่าย
gsub(regex, replacement, target)แก้ไข target โดยตรงและคืนค่าจำนวนการแทนที่- การใส่ตรรกะของนิพจน์ประจำไว้ในฟังก์ชันทำให้บล็อกกฎมุ่งเน้นที่ตรรกะทางธุรกิจ
- คุณสามารถทดสอบหน่วยได้โดยส่งสตริงที่สร้างขึ้นเองโดยตรงในบล็อก
BEGIN
#!/usr/bin/env bash
# trim() strips leading/trailing spaces; used to normalise CSV-like data
printf ' alice , 90 \n bob , 85 \n carol , 92 \n' | awk -F',' '
function trim(s) {
gsub(/^[ \t]+|[ \t]+$/, "", s)
return s
}
{
name = trim($1)
score = trim($2)
print name, score
}
'บทนำสู่ printf ใน awk
printf ใน awk ใช้แนวคิดเดียวกับ printf ของภาษา C และของ Bash ความแตกต่างสำคัญจาก print คือ printf จะไม่เพิ่มบรรทัดใหม่โดยอัตโนมัติ — คุณต้องเพิ่ม \n เอง
ตัวระบุรูปแบบที่ใช้บ่อย:
%s— สตริง%d— จำนวนเต็ม%f— จำนวนจุดลอยตัว%e— รูปแบบเลขชี้กำลัง%g— รูปแบบที่สั้นกว่าระหว่าง%f/%e
ควบคุมความกว้างและความละเอียดโดยใส่ตัวเลขระหว่าง % กับตัวระบุ: %-20s จัดชิดซ้ายในฟิลด์กว้าง 20 อักขระ ส่วน %8.2f ให้จำนวนจุดลอยตัวในช่องกว้าง 8 อักขระและมีทศนิยม 2 ตำแหน่ง
#!/usr/bin/env bash
# printf format specifiers in awk
echo '' | awk '
BEGIN {
printf "%s\n", "plain string"
printf "%10s\n", "right-pad"
printf "%-10s|\n", "left-pad"
printf "%8.2f\n", 3.14159
printf "%08d\n", 42
printf "%e\n", 123456.789
}
'การสร้างส่วนหัวรายงานด้วย printf
รายงานที่เรียบร้อยต้องมีแถวส่วนหัวและบรรทัดคั่น บล็อก BEGIN เป็นตำแหน่งที่เหมาะสมในการพิมพ์สิ่งเหล่านี้ เพราะจะทำงานหนึ่งครั้งก่อนประมวลผลข้อมูลเข้าใด ๆ
เคล็ดลับคือกำหนดความกว้างให้ตรงกันในส่วนหัวกับความกว้างที่ใช้ในแถวข้อมูลทุกประการ การกำหนดค่าคงที่ของความกว้างใน BEGIN (หรือในฟังก์ชัน) ช่วยให้ทุกอย่างสอดคล้องกันเมื่อคุณปรับความกว้างคอลัมน์ในภายหลัง
- ใช้
printfพร้อมสตริงตัวคั่นที่ประกอบด้วยขีดกลางเพื่อวาดเส้นแบ่ง - ลงท้ายบรรทัดส่วนหัวด้วย
\nเสมอ - รวมส่วนหัวใน
BEGINแถวต่อระเบียน และส่วนท้ายในENDเพื่อสร้างโครงสร้างรายงานที่สมบูรณ์
#!/usr/bin/env bash
# Print a report header in BEGIN, data rows per-record, total in END
printf 'alice 9200 12\nbob 8750 10\ncarol 10400 14\n' | awk '
BEGIN {
printf "%-10s %10s %6s %12s\n", "Name", "Salary", "Months", "Annual"
printf "%s\n", "----------------------------------------------"
total = 0
}
{
annual = $2 * $3
total += annual
printf "%-10s %10d %6d %12d\n", $1, $2, $3, annual
}
END {
printf "%s\n", "----------------------------------------------"
printf "%-10s %10s %6s %12d\n", "TOTAL", "", "", total
}
'ฟังก์ชันที่ผู้ใช้สร้างสำหรับตรรกะการจัดรูปแบบ
เมื่อคุณสร้างรายงานหลายคอลัมน์ มักจำเป็นต้องเรียกใช้การจัดรูปแบบเดิมในหลายตำแหน่ง — เช่น การแสดงแถบเปอร์เซ็นต์หรือการแปลงไบต์เป็นหน่วยที่อ่านเข้าใจง่าย การใส่การทำงานนี้ไว้ในฟังก์ชันช่วยหลีกเลี่ยงการเขียนซ้ำและทำให้เปลี่ยนรูปแบบได้ง่ายทั่วทั้งโปรแกรม
ฟังก์ชันด้านล่างแปลงไบต์เป็น KB, MB หรือ GB แล้วคืนค่าสตริงที่จัดรูปแบบไว้ กฎที่เรียกใช้เพียงส่ง $NF (ฟิลด์สุดท้าย) และพิมพ์ค่าที่ได้รับกลับมา
#!/usr/bin/env bash
# human_bytes() converts raw byte counts to KB/MB/GB strings
printf 'var.log 1024\naccess.log 2097152\ncore.dump 1073741824\ntiny.txt 512\n' | awk '
function human_bytes(n, s) {
if (n >= 1073741824) { s = sprintf("%.1f GB", n/1073741824) }
else if (n >= 1048576) { s = sprintf("%.1f MB", n/1048576) }
else if (n >= 1024) { s = sprintf("%.1f KB", n/1024) }
else { s = sprintf("%d B", n) }
return s
}
BEGIN { printf "%-20s %10s\n", "File", "Size"; print "------------------------------" }
{ printf "%-20s %10s\n", $1, human_bytes($2) }
'การสะสมข้อมูลในอาร์เรย์ก่อนพิมพ์ผลลัพธ์
รายงานจริงมักต้องใช้ผลรวม ค่าเฉลี่ย หรือการจัดอันดับ ซึ่งเป็นค่าที่ไม่สามารถคำนวณได้จนกว่าจะเห็นข้อมูลนำเข้า ทั้งหมด รูปแบบการทำงานคือ:
- สะสมข้อมูลลงในอาร์เรย์แบบเชื่อมโยงระหว่างขั้นตอนประมวลผลทีละระเบียน
- คำนวณค่าที่ได้จากการประมวลผล (ค่าเฉลี่ย เปอร์เซ็นต์) ใน
END - ส่งออกผลลัพธ์ที่จัดรูปแบบแล้วจาก
ENDเท่านั้น เพื่อให้ความกว้างปรับตามชุดข้อมูลทั้งหมดได้
รูปแบบการส่งออกภายหลังนี้เป็นสำนวนการเขียนที่ทรงพลังอย่างหนึ่งในการสร้างรายงานด้วย awk ตัวอย่างด้านล่างจะนับจำนวนคำขอและไบต์การตอบกลับแยกตามรหัสสถานะ HTTP จากบันทึกการเข้าถึง
#!/usr/bin/env bash
# Summarise an nginx-style access log by HTTP status code
printf '127.0.0.1 200 1234\n127.0.0.1 404 512\n10.0.0.2 200 8900\n10.0.0.3 500 256\n10.0.0.4 200 4096\n10.0.0.5 404 300\n' | awk '
{
status = $2
bytes = $3
count[status]++
total_bytes[status] += bytes
}
END {
printf "%-8s %8s %14s\n", "Status", "Requests", "Total Bytes"
print "-----------------------------------"
for (s in count)
printf "%-8s %8d %14d\n", s, count[s], total_bytes[s]
}
'ฟังก์ชันเวียนเกิดใน awk
awk รองรับการเรียกใช้ฟังก์ชันเวียนเกิด กรณีใช้งานแบบคลาสสิกคือการคำนวณแฟกทอเรียลหรือการสร้างสตริงซ้ำ ๆ (เช่น เส้นประที่มีความยาวเท่ากับความกว้างของเทอร์มินัล) การเวียนเกิดพบใน awk น้อยกว่าภาษาสำหรับใช้งานทั่วไป แต่ทำงานได้อย่างถูกต้องและมีให้ใช้ในการพัฒนาหลักทุกแบบ
ตัวอย่างด้านล่างกำหนดฟังก์ชันเวียนเกิด repeat(s, n) และใช้ฟังก์ชันนี้วาดเส้นคั่นที่ปรับให้ตรงกับความกว้างของแถวข้อมูลที่กว้างที่สุดโดยอัตโนมัติ จึงไม่ต้องกำหนดจำนวนขีดแบบตายตัว
- หลีกเลี่ยงการเวียนเกิดที่ลึกมากกับข้อมูลนำเข้าขนาดใหญ่ เพราะ awk ไม่มีการปรับการเรียกฟังก์ชันแบบหางให้เหมาะสม
- หากต้องการทำซ้ำแบบง่าย ๆ
sprintf("%*s", n, "")ร่วมกับgsub(/ /, "-")จะทำงานเร็วกว่า แต่สื่อให้เห็นแนวคิดได้น้อยกว่า
#!/usr/bin/env bash
# Recursive repeat() to build separator lines dynamically
awk '
function repeat(s, n, acc) {
if (n <= 0) return ""
acc = s repeat(s, n-1)
return acc
}
BEGIN {
header = sprintf("%-15s %10s %10s", "Metric", "Current", "Target")
sep = repeat("-", length(header))
print sep
print header
print sep
printf "%-15s %10.1f %10.1f\n", "CPU %", 72.4, 60.0
printf "%-15s %10.1f %10.1f\n", "Mem GB", 14.2, 16.0
printf "%-15s %10d %10d\n", "Open FDs", 1024, 800
print sep
}
' /dev/nullการใช้ printf กับไฟล์หรือไปป์ไลน์ภายใน awk
printf (และ print) ของ awk สามารถเปลี่ยนเส้นทางผลลัพธ์ไปยังไฟล์หรือส่งผ่านคำสั่งเชลล์ได้โดยตรงจากภายในโปรแกรม awk โดยไม่ต้องครอบการทำงานทั้งหมดด้วย subshell
printf "..." > "file.txt"— เขียนลงไฟล์ (ตัดข้อมูลเดิมหนึ่งครั้ง จากนั้นจึงเขียนต่อท้ายภายในการทำงานครั้งเดียวกัน)printf "..." >> "file.txt"— เขียนต่อท้ายไฟล์printf "..." | "sort -rn"— ส่งต่อไปยังคำสั่งเชลล์ โดย awk จะเปิดไปป์ไว้ตลอดระหว่างประมวลผลแต่ละระเบียน และปิดเมื่อโปรแกรมทำงานเสร็จ
รูปแบบที่ใช้กันทั่วไปคือแบ่งการอ่านบันทึกหนึ่งรอบออกเป็นไฟล์ผลลัพธ์หลายไฟล์แยกตามสถานะหรือโฮสต์ เพื่อหลีกเลี่ยงการสแกนไฟล์ขนาดใหญ่ซ้ำหลายครั้ง
#!/usr/bin/env bash
# Route records into per-status files using print redirection
tmpdir=$(mktemp -d)
trap 'rm -rf "$tmpdir"' EXIT
printf '200 /index.html\n404 /missing\n200 /api/data\n500 /crash\n404 /lost\n' | awk -v out="$tmpdir" '
{
file = out "/" $1 ".log"
printf "%-6s %s\n", $1, $2 > file
}
END {
close(file) # flush all open handles
}
'
echo "=== 200 ==="
cat "$tmpdir/200.log"
echo "=== 404 ==="
cat "$tmpdir/404.log"การสร้างรายงาน CSV ด้วย awk
รายงานทุกประเภทไม่ได้จัดทำสำหรับมนุษย์เสมอไป บางครั้งผลลัพธ์ต้องเป็น CSV ที่เครื่องอ่านได้ เพื่อป้อนให้สเปรดชีตหรือไปป์ไลน์ขั้นถัดไป printf ของ awk จัดการเรื่องนี้ได้อย่างสะดวก โดยกำหนด OFS เป็นเครื่องหมายจุลภาค หรือควบคุมตัวคั่นทุกตัวอย่างชัดเจน
กฎสำคัญสองข้อสำหรับ CSV ที่สร้างจาก awk อย่างรัดกุม:
- ครอบฟิลด์ที่อาจมีเครื่องหมายจุลภาคหรือขึ้นบรรทัดใหม่ด้วยเครื่องหมายอัญประกาศคู่
- หลีกเลี่ยงเครื่องหมายอัญประกาศคู่ตามตัวอักษรภายในฟิลด์ด้วยการเขียนซ้ำสองครั้ง:
He said ""hello""
ฟังก์ชัน csv_field(s) ด้านล่างจะรวมตรรกะการใส่อัญประกาศนี้ไว้ เพื่อให้ใช้กับฟิลด์สตริงทุกตัวได้อย่างสม่ำเสมอ
#!/usr/bin/env bash
# Emit a valid CSV report from space-separated input
printf 'alice engineer 95000\nbob "sales,mgr" 82000\ncarol developer 110000\n' | awk '
function csv_field(s, safe) {
safe = s
gsub(/"/, "\"\"" , safe) # double any embedded quotes
return "\"" safe "\"" # wrap in quotes
}
BEGIN { print "Name,Role,Salary" }
{
printf "%s,%s,%d\n", csv_field($1), csv_field($2), $3
}
'ตั้งแต่ต้นจนจบ: รายงานบันทึกการเข้าถึงฉบับสมบูรณ์
ตัวอย่างสุดท้ายนี้รวบรวมทุกแนวคิดเข้าด้วยกัน ได้แก่ ฟังก์ชันที่ผู้ใช้กำหนด การจัดรูปแบบด้วย printf การสะสมข้อมูลในอาร์เรย์ และส่วนหัวกับส่วนท้ายที่มีโครงสร้าง ข้อมูลนำเข้าคือบันทึกการเข้าถึงเว็บไซต์แบบย่อ ส่วนผลลัพธ์คือตารางสรุปที่มนุษย์อ่านได้ พร้อมผลรวมแยกตามเมธอดและบรรทัดผลรวมทั้งหมด
เทคนิคสำคัญที่ใช้:
count[method]++และbytes[method] += sizeสะสมสถิติแยกตามเมธอดในการอ่านข้อมูลเพียงรอบเดียวhuman_bytes()(จากฉากก่อนหน้า) แปลงผลรวมไบต์printfที่ใช้ความกว้างตรงกันในส่วนหัว ข้อมูล และส่วนท้าย ช่วยให้ตารางจัดแนวตรงกันไม่ว่าข้อมูลนำเข้าจะมีขนาดเท่าใด- บล็อก
ENDวนซ้ำผ่านอาร์เรย์ด้วยfor (k in arr)และส่งออกผลลัพธ์ที่เรียงลำดับผ่านไปป์ไปยังsort
#!/usr/bin/env bash
# Full access log report: method breakdown with human-readable bytes
printf 'GET /index 200 4096\nPOST /api 201 512\nGET /img 200 102400\nDELETE /item 204 0\nPOST /login 401 256\nGET /style 200 8192\n' | awk '
function human_bytes(n, s) {
if (n >= 1048576) s = sprintf("%.1f MB", n/1048576)
else if (n >= 1024) s = sprintf("%.1f KB", n/1024)
else s = sprintf("%d B", n)
return s
}
{
method = $1
size = $4
count[method]++
bytes[method] += size
grand_count++
grand_bytes += size
}
END {
fmt = "%-10s %8s %15s\n"
sep = "----------------------------------"
printf fmt, "Method", "Requests", "Bytes"
print sep
for (m in count)
printf "%-10s %8d %15s\n", m, count[m], human_bytes(bytes[m])
print sep
printf "%-10s %8d %15s\n", "TOTAL", grand_count, human_bytes(grand_bytes)
}
'ตรวจสอบความรู้: ตัวแปรเฉพาะที่ในฟังก์ชัน awk
ข้อใดต่อไปนี้ประกาศ result ให้เป็นตัวแปรเฉพาะที่ภายในฟังก์ชัน awk ได้อย่างถูกต้องตามแบบแผนของ POSIX
ทบทวนบทเรียน: ฟังก์ชัน awk, printf และการสร้างรายงาน
ในบทเรียนนี้ คุณได้เรียนรู้วิธีเขียนโปรแกรม awk ระดับพร้อมใช้งานจริง ซึ่งสร้างรายงานที่จัดรูปแบบจากกระแสข้อมูลดิบ ต่อไปนี้คือสิ่งสำคัญที่ควรนำไปใช้ต่อ:
- ฟังก์ชันที่ผู้ใช้กำหนดประกาศด้วย
function name(params, locals)การเว้นวรรคเพิ่มเติมก่อนพารามิเตอร์ตัวแปรเฉพาะที่เป็นแบบแผนของ POSIX และไม่มีคีย์เวิร์ดlocal - printf ช่วยควบคุมผลลัพธ์ได้อย่างแม่นยำ ทั้งความกว้าง (
%10s) การจัดแนว (%-10s) และความละเอียด (%8.2f) อย่าลืมเพิ่ม\nอย่างชัดเจน - ใช้ BEGIN เพื่อส่งออกส่วนหัวและเส้นคั่น ใช้กฎต่อระเบียนเพื่อสะสมข้อมูล และใช้ END เพื่อคำนวณผลรวมและพิมพ์รายงานที่เสร็จสมบูรณ์
- เปลี่ยนเส้นทางผลลัพธ์ของ
printfไปยังไฟล์ (> file) หรือไปป์ไลน์ (| "sort") จากภายใน awk เพื่อแบ่งรายงานหรือประมวลผลผลลัพธ์เพิ่มเติม - ครอบฟิลด์สตริงด้วยตัวช่วย csv_field() เมื่อส่งออก CSV เพื่อจัดการเครื่องหมายจุลภาคและอัญประกาศที่อยู่ภายในได้อย่างปลอดภัย
- ฟังก์ชันที่แปลงหน่วย (
human_bytes) ทำอักขระซ้ำ (repeat) หรือล้างสตริง (trim,csv_field) ควรเก็บไว้ในคลัง awk ส่วนตัว เพราะสามารถนำมาประกอบใช้ข้ามโครงการได้อย่างราบรื่น
คำถามที่พบบ่อย
บทเรียน “ฟังก์ชัน awk การจัดรูปแบบด้วย printf และการสร้างรายงาน” ฟรีหรือไม่
ใช่ — ข้อความเต็มของ “ฟังก์ชัน awk การจัดรูปแบบด้วย printf และการสร้างรายงาน” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส DevOps Bootcamp ให้อัปเกรดเป็น CoddyKit PRO คอร์ส DevOps Bootcamp มีบทเรียนทั้งหมด 4 บทเรียน
คุณจะเรียนรู้อะไรในบทเรียน “ฟังก์ชัน awk การจัดรูปแบบด้วย printf และการสร้างรายงาน”
กำหนดฟังก์ชันของผู้ใช้และใช้ printf เพื่อสร้างรายงานแบบตารางที่เรียบร้อยจากกระแสข้อมูลดิบ คุณปฏิบัติ DevOps Bootcamp ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน
คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน DevOps Bootcamp หรือไม่
ไม่จำเป็นต้องมีประสบการณ์มาก่อน DevOps Bootcamp บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน
บทเรียน “ฟังก์ชัน awk การจัดรูปแบบด้วย printf และการสร้างรายงาน” ใช้เวลานานแค่ไหน
บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย
ฉันเขียนและรันโค้ดในบทเรียน DevOps Bootcamp นี้ได้ไหม
ได้ บทเรียน DevOps Bootcamp ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- ระเบียน ฟิลด์ และตัวคั่นแบบกำหนดเองใน awk
- รูปแบบ ช่วง และบล็อก BEGIN/END
- การรวมข้อมูลด้วยอาร์เรย์และการจัดกลุ่มใน awk
- ฟังก์ชัน awk การจัดรูปแบบด้วย printf และการสร้างรายงาน