Linux कमांड लाइन और Bash स्क्रिप्टिंग में महारत · पाठ

पैटर्न, रेंज और BEGIN/END ब्लॉक

सशर्त पैटर्न से रिकॉर्ड फ़िल्टर करें और BEGIN तथा END ब्लॉक का उपयोग करके शीर्षलेख और कुल योग तैयार करें।

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

पैटर्न, रेंज और BEGIN/END ब्लॉक, CoddyKit पर Linux कमांड लाइन और Bash स्क्रिप्टिंग में महारत का एक निःशुल्क पाठ है। यह 4 में से 2वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह Linux कमांड लाइन और Bash स्क्रिप्टिंग में महारत सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। Linux कमांड लाइन और Bash स्क्रिप्टिंग में महारत पाठ्यक्रम में कुल 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/ — इनमें से कोई भी गंभीरता स्तर

नीचे दिया गया उदाहरण एक सरलीकृत एक्सेस लॉग का विश्लेषण करता है और केवल 1000 बाइट से बड़े प्रतिक्रिया आकार वाले POST अनुरोधों को प्रिंट करता है:

#!/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

BEGIN में FS निर्धारित करना -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
}
'

OFS और ORS निर्धारित करने के लिए BEGIN का उपयोग

अक्सर अनदेखी की जाने वाली दो आउटपुट चरों को 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 }
फ़्लैग तरीका: /start/ पर किसी चर को मैन्युअल रूप से 1 और /end/ पर 0 निर्धारित करें

जब सीमांकक का पाठ मुख्य सामग्री में भी दिखाई दे सकता हो, तब फ़्लैग तरीका अधिक विश्वसनीय होता है:

#!/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 खंड का व्यवहार

जाँचें कि awk में BEGIN और END खंड इनपुट संसाधन के साथ किस प्रकार काम करते हैं, यह आपकी समझ में आया है या नहीं।

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

पाठ का पुनरावलोकन: पैटर्न, परास और BEGIN/END

इस पाठ में आपने awk प्रोग्राम की तीन सबसे शक्तिशाली संरचनात्मक विशेषताओं में महारत हासिल की:

पैटर्न — रेगेक्स (/ERROR/), संबंधपरक ($3 > 1000), निषेधित (!/DEBUG/) और संयुक्त (&&, ||) — स्पष्ट if कथनों की आवश्यकता के बिना यह नियंत्रित करते हैं कि कौन-से रिकॉर्ड किसी क्रिया को चलाएँगे।
परास पैटर्न (/start/,/end/) — रिकॉर्ड के सन्निहित खंड चुनते हैं, इसलिए लॉग घटना की समय-सीमा, कॉन्फ़िगरेशन अनुभाग और रिपोर्ट के खंड निकालने के लिए बिल्कुल उपयुक्त हैं। जब स्वयं सीमांकक पंक्तियों को हटाना हो, तब फ़्लैग चर (next + बूलियन) का उपयोग करें।
BEGIN खंड — किसी भी इनपुट से पहले एक बार चलता है; FS, OFS, ORS निर्धारित करने, काउंटरों का प्रारंभिक मान तय करने और रिपोर्ट शीर्षक प्रिंट करने के लिए आदर्श है।
END खंड — सभी इनपुट के बाद एक बार चलता है; मुख्य नियमों में जमा किए गए चरों का उपयोग करके योग, औसत और अंतिम भाग प्रिंट करने के लिए सही स्थान है।

इन विशेषताओं को साथ मिलाकर आप ऐसे पूर्ण, स्वयं-व्याख्यात्मक awk प्रोग्राम लिख सकते हैं जो कच्चे पाठ को ग्रहण करके संरचित, मनुष्यों के लिए पठनीय रिपोर्ट तैयार करते हैं — अस्थायी फ़ाइलों या बाहरी उपकरणों के बिना, केवल एक प्रोसेसिंग श्रृंखला चरण में।

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

एआई शिक्षक के साथ Bash सीखें — निःशुल्क

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

पाठ्यक्रम: 22
पाठ: 88

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

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

क्या “पैटर्न, रेंज और BEGIN/END ब्लॉक” पाठ निःशुल्क है?

हाँ—“पैटर्न, रेंज और BEGIN/END ब्लॉक” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और Linux कमांड लाइन और Bash स्क्रिप्टिंग में महारत पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। Linux कमांड लाइन और Bash स्क्रिप्टिंग में महारत पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“पैटर्न, रेंज और BEGIN/END ब्लॉक” में मैं क्या सीखूँगा?

सशर्त पैटर्न से रिकॉर्ड फ़िल्टर करें और BEGIN तथा END ब्लॉक का उपयोग करके शीर्षलेख और कुल योग तैयार करें। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ Linux कमांड लाइन और Bash स्क्रिप्टिंग में महारत का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या Linux कमांड लाइन और Bash स्क्रिप्टिंग में महारत शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

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

“पैटर्न, रेंज और BEGIN/END ब्लॉक” पाठ पूरा करने में कितना समय लगता है?

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

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

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

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

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

← Linux कमांड लाइन और Bash स्क्रिप्टिंग में महारत पर वापस जाएँ