DevOps बूटकैंप · पाठ

awk ऐरे और समूहों से समुच्चयन

फ़ील्ड मानों के आधार पर कुंजीबद्ध associative arrays का उपयोग करके योग, गिनती और समूह-आधारित सारांश निकालें।

पाठ 3, कुल 4 में से13 चरण

awk ऐरे और समूहों से समुच्चयन, CoddyKit पर DevOps बूटकैंप का एक निःशुल्क पाठ है। यह 4 में से 3वाँ पाठ है। इस अध्ययन पथ के 3 तक कोई भी पाठ पूरा पढ़ना निःशुल्क है — इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ व्यावहारिक अभ्यास भी उपलब्ध कराता है। यह DevOps बूटकैंप सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। DevOps बूटकैंप पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

awk की संबद्ध सारणियाँ क्या हैं

awk में संबद्ध सारणी एक कुंजी-मान भंडार होती है, जहाँ कुंजियाँ कोई भी स्ट्रिंग या संख्या हो सकती हैं। अधिकांश भाषाओं की क्रमांकित सारणियों के विपरीत, awk की सारणियाँ अंदरूनी रूप से हैश मानचित्र होती हैं — इसलिए फ़ील्ड के मानों के आधार पर डेटा को समूहबद्ध करने और उसका समेकन करने के लिए ये बहुत उपयोगी हैं।

अप्रत्यक्ष रूप से घोषित करें: बस arr[key] = value असाइन करें
कुंजियाँ डिफ़ॉल्ट रूप से स्ट्रिंग होती हैं (संख्याओं को स्ट्रिंग में बदला जाता है)
आकार की कोई सीमा नहीं — आवश्यकता के अनुसार awk सारणी का आकार बढ़ाता है
एक ही पास में योग, गिनती और समूह-आधारित संक्षिप्त परिणाम निकालने के लिए आदर्श

किसी कुंजी को बढ़ाने से पहले उसे आरंभ करने की आवश्यकता नहीं होती — awk अपने-आप बिना सेट की गई कुंजी को शून्य या खाली स्ट्रिंग मान लेता है।

प्रत्येक समूह की पंक्तियों की गिनती

सबसे सामान्य समेकन प्रतिरूप यह गिनना है कि किसी फ़ील्ड में प्रत्येक विशिष्ट मान कितनी बार दिखाई देता है। फ़ील्ड $1 (या कोई भी फ़ील्ड) को सारणी की कुंजी के रूप में उपयोग करें और प्रत्येक मेल खाती पंक्ति पर गणक बढ़ाएँ।

END ब्लॉक तब चलता है जब पूरा इनपुट पढ़ लिया जाता है — संचित परिणामों को प्रदर्शित करने का स्थान यही है।

count[$1]++

प्रसंस्करण के बाद, count में $1 के प्रत्येक विशिष्ट मान के लिए पंक्तियों की कुल संख्या होती है।

#!/usr/bin/env bash
# Count how many log entries exist per HTTP status code
# Input format: <ip> <date> <method> <path> <status> <bytes>
printf '10.0.0.1 2024-01-01 GET /index 200 512
10.0.0.2 2024-01-01 POST /api 404 128
10.0.0.3 2024-01-01 GET /img 200 2048
10.0.0.4 2024-01-01 GET /api 500 64
10.0.0.5 2024-01-01 DELETE /api 404 32
' | awk '
{
    count[$5]++
}
END {
    for (status in count)
        print status, count[status]
}'

प्रत्येक समूह के संख्यात्मक फ़ील्ड का योग

गिनती समेकन का केवल एक रूप है। किसी अन्य फ़ील्ड के आधार पर समूहबद्ध संख्यात्मक फ़ील्ड का योग निकालने के लिए, संख्यात्मक मान को समूह वाले फ़ील्ड की कुंजी वाली सारणी में जोड़ते जाएँ।

प्रतिरूप यह है:

कुंजी = समूह बनाने वाला फ़ील्ड (जैसे, उपयोगकर्ता नाम के लिए $1)
मान = संख्यात्मक फ़ील्ड का लगातार बढ़ता कुल (जैसे, बाइट के लिए $2)

यह एक ही awk पास में समूह-आधारित पूरा योग निकालता है — छँटाई या पहले से प्रसंस्करण की आवश्यकता नहीं होती।

#!/usr/bin/env bash
# Sum bytes transferred per user from an access log
printf 'alice 1024
bob 512
alice 2048
charlie 256
bob 768
alice 128
' | awk '
{
    bytes[$1] += $2
}
END {
    for (user in bytes)
        printf "%-10s %d bytes\n", user, bytes[user]
}'

एक ही पास में गिनती और योग का संयोजन

awk आपको एक साथ कई सारणियाँ बनाए रखने देता है, जिससे फ़ाइल को एक बार स्कैन करके प्रत्येक समूह की गिनती और योग (और इसलिए औसत) निकाला जा सकता है। यह डेटा-प्रवाह को दो बार चलाने की तुलना में कहीं अधिक दक्ष है।

count[key]++ — घटनाओं की संख्या दर्ज करता है
total[key] += $N — लगातार बढ़ता योग दर्ज करता है
END में प्रति-समूह औसत के लिए total[k] / count[k] से भाग दें

#!/usr/bin/env bash
# Compute per-department headcount and average salary
printf 'Engineering Alice 95000
Engineering Bob 88000
Marketing Carol 72000
Marketing Dave 68000
Engineering Eve 102000
Marketing Frank 75000
' | awk '
{
    dept  = $1
    sal   = $3
    count[dept]++
    total[dept] += sal
}
END {
    printf "%-15s %5s %10s\n", "Department", "Count", "Avg Salary"
    for (d in count)
        printf "%-15s %5d %10.0f\n", d, count[d], total[d]/count[d]
}'

2-आयामी समूहबद्धकरण के लिए बहु-फ़ील्ड कुंजियाँ

आप कई फ़ील्ड को विभाजक के साथ जोड़कर एक संयुक्त कुंजी बना सकते हैं। इससे किसी विशेष सिंटैक्स के बिना द्वि-आयामी समूहबद्धकरण संभव होता है।

ऐसा विभाजक चुनें जो डेटा में दिखाई न दे (जैसे, SUBSEP, awk का अंतर्निर्मित रिकॉर्ड विभाजक \034, या शाब्दिक पाइप |)।

संयुक्त कुंजी: arr[$1 SUBSEP $2] या arr[$1"|"$2]
प्रदर्शित करते समय कुंजी को फिर से विभाजित करें: split(key, parts, "|")

#!/usr/bin/env bash
# Count requests grouped by HTTP method AND status code
printf 'GET 200
POST 201
GET 404
GET 200
DELETE 204
POST 201
GET 404
POST 500
' | awk '
{
    key = $1 "|" $2
    count[key]++
}
END {
    printf "%-8s %-6s %s\n", "Method", "Status", "Count"
    for (k in count) {
        split(k, parts, "|")
        printf "%-8s %-6s %d\n", parts[1], parts[2], count[k]
    }
}'

प्रत्येक समूह का न्यूनतम और अधिकतम दर्ज करना

संबद्ध सारणियों की सहायता से प्रत्येक समूह के न्यूनतम और अधिकतम मान दर्ज करना आसान होता है। उपाय यह है कि प्रत्येक कुंजी की पहली उपस्थिति पर ही विशेष शर्त !(key in arr) का उपयोग करके आरंभ किया जाए।

कुंजी पहली बार दिखाई देने पर !(key in min_arr) सत्य होता है
आरंभ करने के बाद, मान की तुलना करें और सामान्य कम-से-कम / अधिक-से-अधिक जाँच के आधार पर उसे बदलें

यह प्रतिरूप उस गलत शून्य मान से बचाता है जो आपके न्यूनतम मान को बिगाड़ सकता है।

#!/usr/bin/env bash
# Find min and max response time per endpoint
printf '/api/users 120
/api/orders 340
/api/users 98
/api/orders 512
/api/users 210
/api/orders 280
/health 5
/health 7
' | awk '
{
    ep  = $1
    rt  = $2
    if (!(ep in mn)) { mn[ep] = rt; mx[ep] = rt }
    if (rt < mn[ep]) mn[ep] = rt
    if (rt > mx[ep]) mx[ep] = rt
}
END {
    printf "%-15s %6s %6s\n", "Endpoint", "Min", "Max"
    for (ep in mn)
        printf "%-15s %6d %6d\n", ep, mn[ep], mx[ep]
}'

आवृत्ति वितरण — शीर्ष-N समूह

वास्तविक दुनिया का एक सामान्य कार्य सबसे अधिक बार आने वाले शीर्ष-N मान खोजना है। awk गिनती संभालता है; क्रम तय करने और परिणाम सीमित करने के लिए sort और head के माध्यम से पाइप करें।

यह डेटा-प्रवाह प्रतिरूप शेल इंजीनियरिंग में प्रचलित है:

awk एक सारणी में घटनाओं की गिनती करता है और END में count key प्रदर्शित करता है
sort -rn संख्यात्मक रूप से घटते क्रम में छाँटता है
head -n 5 केवल शीर्ष 5 रखता है

समेकन पर awk का ध्यान केंद्रित रखना और छँटाई का काम sort को सौंपना Unix दर्शन के अनुरूप है।

#!/usr/bin/env bash
# Top 3 most active IP addresses from an access log
printf '192.168.1.10 GET /index
10.0.0.5 POST /api
192.168.1.10 GET /css
172.16.0.3 GET /index
10.0.0.5 GET /api
192.168.1.10 DELETE /api
172.16.0.3 POST /login
10.0.0.5 GET /index
10.0.0.5 POST /logout
' | awk '{count[$1]++} END {for (ip in count) print count[ip], ip}' \
  | sort -rn \
  | head -n 3

बहु-फ़ाइल समेकन के लिए NR और FNR का उपयोग

कई फ़ाइलों को संसाधित करते समय, awk के अंतर्निर्मित NR (अब तक पढ़े गए कुल रिकॉर्ड) और FNR (वर्तमान फ़ाइल के रिकॉर्ड) आपको FILENAME की सहायता से यह चिह्नित करने देते हैं कि प्रत्येक रिकॉर्ड किस फ़ाइल से आया है।

FILENAME — वर्तमान में पढ़ी जा रही फ़ाइल का नाम
FNR == 1 — प्रत्येक नई फ़ाइल की शुरुआत में सक्रिय होता है (शीर्षलेख छोड़ने के लिए उपयोगी)

इससे एक ही awk आह्वान में पूरी निर्देशिका की लॉग फ़ाइलों पर प्रति-फ़ाइल समूह-आधारित समेकन किया जा सकता है।

awk सारणियों से क्रमबद्ध परिणाम प्रदर्शित करना

awk में for (key in array) लूप क्रम की गारंटी नहीं देता। नियत परिणाम के लिए awk के END वाले प्रदर्शन को sort में पाइप करें, या मानों को एकत्र करके asorti / asort फ़ंक्शन से awk के भीतर छाँटें (केवल GNU awk)।

अलग-अलग प्लेटफ़ॉर्म पर चलने वाली स्क्रिप्ट के लिए पोर्टेबल शेल-डेटा-प्रवाह तरीका सामान्यतः अधिक पसंद किया जाता है:

sort -k1,1 — पहले फ़ील्ड (समूह कुंजी) के अनुसार वर्णक्रम में छाँटें
sort -k2,2rn — दूसरे फ़ील्ड (गिनती/योग) के अनुसार संख्यात्मक घटते क्रम में छाँटें

#!/usr/bin/env bash
# Bytes per user, sorted alphabetically by username
printf 'zara 800
alice 1500
bob 300
alice 200
zara 400
bob 1100
' | awk '
{
    total[$1] += $2
}
END {
    for (u in total)
        print u, total[u]
}' | sort -k1,1

सारणी की कुंजियाँ हटाना और स्थिति साफ़ करना

कभी-कभी आपको डेटा-प्रवाह के बीच समेकन की स्थिति फिर से सेट करनी पड़ती है — उदाहरण के लिए, जब लॉग फ़ाइलों को संसाधित करते समय प्रत्येक अनुभाग खाली पंक्ति या किसी संकेतक मान से अलग किया गया हो।

delete arr[key] — एक प्रविष्टि हटाता है
delete arr — पूरी सारणी साफ़ करता है (GNU awk)
अनचाही प्रविष्टियाँ बनने से बचने के लिए पहुँचने से पहले (key in arr) से अस्तित्व जाँचें

यह तकनीक awk को फिर से शुरू किए बिना चलती-खिड़की या प्रति-अनुभाग समेकन संभव बनाती है।

#!/usr/bin/env bash
# Sum values within each section delimited by "---"
printf 'alice 100
bob 200
---
alice 50
bob 75
charlie 300
---
' | awk '
/^---/ {
    print "-- Section totals --"
    for (u in total) printf "  %-10s %d\n", u, total[u]
    delete total
    next
}
{
    total[$1] += $2
}'

वास्तविक डेटा-प्रवाह: Nginx लॉग का सारांश

सभी बातों को एक साथ रखते हुए — यहाँ Nginx के संयुक्त लॉग प्रारूप पर उत्पादन-स्तर का awk एक-पास समेकन है। यह एक ही स्कैन में प्रत्येक आभासी होस्ट के लिए अनुरोधों की गिनती, कुल बाइट और त्रुटि दर निकालता है।

उपयोग की गई प्रमुख तकनीकें:

संयुक्त कुंजी: किसी फ़ील्ड से निकाला गया vhost
समानांतर सारणियाँ: reqs[], bytes[], errors[]
सशर्त संचय: केवल त्रुटिपूर्ण प्रतिक्रियाओं की गिनती के लिए $9 >= 400
END में स्वरूपित printf सारणी

#!/usr/bin/env bash
# Simulated Nginx combined log: host ip - - [date] "METHOD /path HTTP/1.1" status bytes
printf 'api.example.com 10.0.0.1 - - [01/Jan/2024] "GET /v1" 200 1024
www.example.com 10.0.0.2 - - [01/Jan/2024] "GET /" 200 4096
api.example.com 10.0.0.3 - - [01/Jan/2024] "POST /v1" 500 128
www.example.com 10.0.0.4 - - [01/Jan/2024] "GET /img" 404 64
api.example.com 10.0.0.5 - - [01/Jan/2024] "GET /v1" 200 2048
www.example.com 10.0.0.6 - - [01/Jan/2024] "GET /" 200 4096
api.example.com 10.0.0.7 - - [01/Jan/2024] "DELETE /v1" 403 32
' | awk '
{
    host = $1; status = $9; b = $10
    reqs[host]++
    bytes[host] += b
    if (status + 0 >= 400) errors[host]++
}
END {
    printf "%-20s %6s %10s %6s\n", "Host", "Reqs", "Bytes", "Errors"
    for (h in reqs)
        printf "%-20s %6d %10d %6d\n", h, reqs[h], bytes[h], errors[h]+0
}'

ज्ञान जाँच: न्यूनतम मान को सही ढंग से आरंभ करना

एक सामान्य awk समेकन संबंधी गलती के बारे में अपनी समझ जाँचें।

इंटरैक्टिव पाठ में इसका उत्तर दें

पाठ का पुनरावलोकन: awk सारणियों से समेकन

आपने awk के भीतर ही समूह-आधारित समेकन निकालने के मुख्य प्रतिरूप सीखे हैं:

गिनती: count[$key]++ — हर पंक्ति पर बढ़ाएँ, END में प्रदर्शित करें
योग: total[$key] += $N — प्रत्येक समूह के संख्यात्मक फ़ील्ड जोड़ते जाएँ
औसत: count[] और total[] दोनों बनाए रखें, END में भाग दें
न्यूनतम/अधिकतम: !(key in arr) से पहली उपस्थिति पर आरंभ करें, फिर तुलना करें
संयुक्त कुंजियाँ: बहु-आयामी समूहबद्धकरण के लिए फ़ील्ड को विभाजक के साथ जोड़ें
क्रमबद्ध परिणाम: नियत क्रम के लिए awk के END वाले प्रदर्शन को sort में पाइप करें
अनुभाग रीसेट: इनपुट के तार्किक अनुभागों के बीच स्थिति साफ़ करने के लिए delete arr का उपयोग करें

इन प्रतिरूपों की सहायता से आप भारी डेटाबेस प्रश्नों या डेटा-प्रवाह के कई चरणों को एकल, दक्ष awk आह्वान से बदल सकते हैं — उत्पादन शेल इंजीनियरिंग के लिए यह एक आवश्यक कौशल है।

शुरुआत निःशुल्क

एआई शिक्षक के साथ DevOps बूटकैंप सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम: 142
पाठ: 568

निःशुल्क सीखना शुरू करें पूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “awk ऐरे और समूहों से समुच्चयन” पाठ निःशुल्क है?

हाँ — DevOps बूटकैंप अध्ययन पथ के 3 तक कोई भी पाठ, जिसमें “awk ऐरे और समूहों से समुच्चयन” भी शामिल है, यहाँ वेब पर पूरा पढ़ना निःशुल्क है। इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ इंटरैक्टिव अभ्यास भी उपलब्ध कराता है। DevOps बूटकैंप पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“awk ऐरे और समूहों से समुच्चयन” में मैं क्या सीखूँगा?

फ़ील्ड मानों के आधार पर कुंजीबद्ध associative arrays का उपयोग करके योग, गिनती और समूह-आधारित सारांश निकालें। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ DevOps बूटकैंप का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या DevOps बूटकैंप शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर DevOps बूटकैंप शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 3वाँ पाठ है।

“awk ऐरे और समूहों से समुच्चयन” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस DevOps बूटकैंप पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर DevOps बूटकैंप पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

awk में रिकॉर्ड, फ़ील्ड और कस्टम विभाजक
पैटर्न, रेंज और BEGIN/END ब्लॉक
awk ऐरे और समूहों से समुच्चयन
awk फ़ंक्शन, printf फ़ॉर्मैटिंग और रिपोर्ट निर्माण

← DevOps बूटकैंप पर वापस जाएँ