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

ฟังก์ชัน awk การจัดรูปแบบด้วย printf และการสร้างรายงาน

กำหนดฟังก์ชันของผู้ใช้และใช้ printf เพื่อสร้างรายงานแบบตารางที่เรียบร้อยจากกระแสข้อมูลดิบ

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

คุณจะเรียนรู้อะไรในบทเรียน “ฟังก์ชัน awk การจัดรูปแบบด้วย printf และการสร้างรายงาน”

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

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

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

บทเรียน “ฟังก์ชัน awk การจัดรูปแบบด้วย printf และการสร้างรายงาน” ใช้เวลานานแค่ไหน

บทเรียน 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