grep, sed மற்றும் awk: Linux டெர்மினலில் உரை செயலாக்க எடுத்துக்காட்டுகள்

grep, sed மற்றும் awk — Linux-இல் உரை செயலாக்கத்திற்கான மூன்று உன்னதமான கருவிகள். grep வடிவத்தின்படி வரிகளைக் கண்டறியும், sed திறந்த எடிட்டர் இல்லாமல் ஸ்ட்ரீமில் உரையை மாற்றி நீக்கும், awk ஒரு வரியை நெடுவரிசைகளாகப் பிரித்துக் கணக்கிடும். கீழே log, config மற்றும் கட்டளை வெளியீட்டைப் பகுப்பாய்வு செய்யும்போது உண்மையில் தேவைப்படும் grep sed awk examples, அத்துடன் பொதுவான தவறுகளும் உள்ளன.

எப்போது எதைப் பயன்படுத்துவது

மூன்று கருவிகளும் உரையை வரி வரியாகப் படித்து முடிவை standard output-க்கு எழுதும், எனவே | மூலம் எளிதாக இணைக்கலாம். வேறுபாடு ஒவ்வொன்றும் சிறப்பாகத் தீர்க்கும் பணியில் உள்ளது.

எளிய விதி: வெறும் வடிகட்ட வேண்டுமெனில் grep, உரையை மாற்ற வேண்டுமெனில் sed, உரையில் நெடுவரிசைகள் இருந்தாலோ கணித செயல்பாடு தேவைப்பட்டாலோ awk.

grep: வடிவத்தின்படி வரிகளைத் தேடுதல்

grep-இன் அடிப்படை எடுத்துக்காட்டுகள்

# கோப்பில் error என்ற சொல் உள்ள வரிகள்
grep error /var/log/syslog

# பெரிய/சிறிய எழுத்தைப் பொருட்படுத்தாமல்: Error, ERROR, error
grep -i error app.log

# வரி எண்களுடன்
grep -n "Connection refused" app.log

# கோப்பகத்தில் மீண்டும் மீண்டும், கோப்புப் பெயர்களுடன்
grep -rn "DB_HOST" /etc/myapp/

# பொருத்தம் உள்ள கோப்புப் பெயர்கள் மட்டும்
grep -rl "TODO" src/

# தலைகீழ்: கருத்துகள் மற்றும் காலி வரிகள் தவிர அனைத்தும்
grep -v -e '^#' -e '^$' /etc/ssh/sshd_config

# பொருந்திய வரிகளின் எண்ணிக்கை
grep -c " 500 " access.log

-w கொடி முழு சொல்லைத் தேடும்: grep -w log login-ஐக் கண்டறியாது. -F கொடி regular expression-ஐ முடக்கி வரியை அப்படியே தேடும் — வடிவத்தில் புள்ளி, அடைப்பு அல்லது நட்சத்திரக்குறி இருக்கும்போது இது வசதியானது.

கண்டறிந்த வரியைச் சுற்றியுள்ள சூழல்

log-இல் உள்ள பிழை ஒரே வரியில் அரிதாகவே புரியும் — அதற்கு வழிவகுத்த stack அல்லது query தேவை. இதற்கு சூழல் கொடிகள் உள்ளன:

# பொருத்தத்திற்குப் பின் 3 வரிகள் (After)
grep -A 3 "Traceback" app.log

# முன் 2 வரிகள் (Before)
grep -B 2 "OOM" /var/log/kern.log

# இருபுறமும் தலா 5 வரிகள் (Context)
grep -C 5 "segfault" /var/log/syslog

பொருத்தக் குழுக்களை grep -- வரியால் பிரிக்கும், எனவே வெளியீட்டைக் கண்ணால் படிப்பது எளிது.

grep மற்றும் regular expression

இயல்பாக grep அடிப்படை regex-ஐ (BRE) புரிந்துகொள்ளும். -E கொடியுடன் விரிவாக்கப்பட்ட regex (ERE) இயங்கும், அதில் +, ?, | மற்றும் அடைப்புகள் பின்சாய்வு இல்லாமல் வேலை செய்யும்.

# பிழைகள் அல்லது எச்சரிக்கைகள் உள்ள வரிகள்
grep -E "ERROR|WARN" app.log

# log-இலிருந்து IP முகவரிகள் மட்டும், ஒரு வரிக்கு ஒன்று (-o — பொருத்தத்தை மட்டும் அச்சிடும்)
grep -oE '([0-9]{1,3}\.){3}[0-9]{1,3}' access.log

grep -P: தெரிந்த பகுதிகளுக்கு இடையிலான மதிப்பை எடுத்தல்

GNU grep-இல் -P கொடி உள்ளது — Perl பாணி regex. அதனுடன் \K («இதுவரை பொருந்தியதை மறந்துவிடு») மற்றும் முன்னோக்கிப் பார்த்தல் கிடைக்கின்றன, இதனால் மதிப்பை மட்டும் எடுக்கலாம்:

$ echo 'user_id=4821 status=ok' | grep -oP 'user_id=\K[0-9]+'
4821

$ grep -oP '"version":\s*"\K[^"]+' package.json
2.4.1

-P கொடி எல்லா grep பதிப்புகளிலும் இல்லை (எடுத்துக்காட்டாக macOS-இன் BSD grep-இல் இல்லை), எனவே பல தளங்களில் இயங்கும் script-களில் sed அல்லது awk பயன்படுத்துவது நல்லது.

script நிபந்தனைகளில் grep -q

grep -q எதையும் அச்சிடாது, வெளியேறும் குறியீட்டை மட்டும் தருகிறது: 0 — கண்டறியப்பட்டது, 1 — இல்லை. இதனால் சோதனையை நேரடியாக if-இல் எழுதலாம்:

if grep -q "^PermitRootLogin no" /etc/ssh/sshd_config; then
  echo "root உள்நுழைவு முடக்கப்பட்டுள்ளது"
fi

வெளியீட்டை மாறியில் சேமித்து அது காலியா என்று சோதிப்பதை விட இது சுருக்கமானது, மேலும் முதல் பொருத்தத்திலேயே grep நின்றுவிடும்.

sed: உரையை மாற்றுதல் மற்றும் நீக்குதல்

மாற்றுதல்: s கட்டளை

sed-இன் முக்கிய கட்டளை — s/வடிவம்/மாற்று/கொடிகள். g கொடி இல்லாமல் ஒவ்வொரு வரியிலும் முதல் பொருத்தம் மட்டுமே மாற்றப்படும்.

# மாற்றப்பட்ட உரையை வெளியிடு (கோப்பு மாறாது)
sed 's/foo/bar/' file.txt

# வரியில் உள்ள அனைத்து நிகழ்வுகளையும் மாற்று
sed 's/foo/bar/g' file.txt

# பெரிய/சிறிய எழுத்தைப் பொருட்படுத்தாமல் (GNU sed)
sed 's/error/ERROR/gI' app.log

# சாய்வுகள் இருந்தால் வேறு பிரிப்பான்
sed 's|/var/www|/srv/www|g' nginx.conf

sed -i: கோப்பிலேயே நேரடியாக மாற்றுதல்

-i கொடி முடிவை மீண்டும் கோப்பில் எழுதும். மூலத்தை இழக்காமல் இருக்க, காப்புப் பிரதியின் பின்னொட்டைக் கொடுங்கள்:

# config.ini.bak உருவாக்கி config.ini-ஐ மாற்றும்
sed -i.bak 's/^debug=true/debug=false/' config.ini

# கோப்பகத்தில் உள்ள அனைத்து .conf கோப்புகளிலும் மாற்று
find /etc/myapp -name "*.conf" -exec sed -i 's/old-host/new-host/g' {} +

பெருமளவிலான திருத்தத்திற்கு முன், முதலில் -i இல்லாமல் கட்டளையை இயக்கி வெளியீட்டைப் பாருங்கள். macOS (BSD sed)-இல் -i-க்கு கட்டாய வாதம் தேவை: sed -i '' 's/a/b/' file.

வரி எண் அல்லது வடிவத்தின்படி வரிகளுடன் வேலை

# 10–20 வரிகளைக் காட்டு (-n தானியங்கி அச்சிடலை முடக்கும், p — அச்சிடு)
sed -n '10,20p' file.txt

# 5-ஆம் வரியை நீக்கு
sed '5d' file.txt

# கடைசி வரியை நீக்கு
sed '$d' file.txt

# காலி வரிகள் மற்றும் கருத்துகளை நீக்கு
sed -e '/^$/d' -e '/^#/d' nginx.conf

# "listen" உள்ள வரிகளில் மட்டும் மாற்று
sed '/listen/s/80/8080/' nginx.conf

# பொருத்தத்திற்குப் பின் ஒரு வரியைச் செருகு (GNU sed)
sed '/^\[mysqld\]/a max_connections = 500' my.cnf

பின்னோக்கு குறிப்புகள் மற்றும் &

வடிவத்தில் உள்ள அடைப்புப் பகுதியை \1, \2 மூலம் மாற்றில் பயன்படுத்தலாம், மேலும் & குறியீடு கண்டறிந்த முழு உரையைக் குறிக்கும்.

# பெயரையும் குடும்பப் பெயரையும் இடமாற்று (-E வழியாக ERE)
$ echo "Ivanov Petr" | sed -E 's/(\S+) (\S+)/\2 \1/'
Petr Ivanov

# எல்லா எண்களையும் சதுர அடைப்புக்குள் சுற்று
$ echo "port 8080, timeout 30" | sed -E 's/[0-9]+/[&]/g'
port [8080], timeout [30]

# 2026-10-14 தேதியை 14.10.2026 ஆக மாற்று
$ echo 2026-10-14 | sed -E 's/([0-9]{4})-([0-9]{2})-([0-9]{2})/\3.\2.\1/'
14.10.2026

awk: நெடுவரிசைகள், நிபந்தனைகள் மற்றும் கணக்கீடுகள்

தேவையான நெடுவரிசையை வெளியிடுதல்

awk ஒவ்வொரு வரியையும் இடைவெளி மற்றும் tab மூலம் புலங்களாகப் பிரிக்கும்: $1 — முதல் புலம், $2 — இரண்டாவது, $NF — கடைசி, $0 — முழு வரி.

# nginx log-இலிருந்து IP முகவரிகள் (முதல் நெடுவரிசை)
awk '{print $1}' /var/log/nginx/access.log

# /etc/passwd-இலிருந்து பயனர் பெயரும் shell-ம் (பிரிப்பான் — இரட்டைப்புள்ளி)
awk -F: '{print $1, $7}' /etc/passwd

# கடைசி நெடுவரிசை
df -h | awk '{print $NF}'

# வெளியீட்டில் தனிப் பிரிப்பான்
awk -F: -v OFS=';' '{print $1, $3}' /etc/passwd

நிபந்தனைகள்: தேவையான வரிகளை மட்டும் அச்சிடுதல்

சுருள் அடைப்புகளுக்கு முன் ஒரு நிபந்தனை வைக்கலாம் — awk அந்த செயலை பொருத்தமான வரிகளுக்கு மட்டும் இயக்கும்.

# UID 1000-இலிருந்து தொடங்கும் பயனர்கள் (சாதாரண, system அல்ல)
awk -F: '$3 >= 1000 {print $1}' /etc/passwd

# 500 மற்றும் அதற்கு மேல் பதில் குறியீடு கொண்ட கோரிக்கைகள் (combined வடிவத்தில் 9-ஆம் புலம்)
awk '$9 >= 500' access.log

# 6-ஆம் நெடுவரிசை regex-உடன் பொருந்தும் வரிகள்
awk '$6 ~ /POST/' access.log

# ls -l வெளியீட்டில் 100 MB-க்கு மேற்பட்ட கோப்புகள்
ls -l | awk '$5 > 100*1024*1024 {print $9}'

BEGIN, END மற்றும் NR: awk ஒரு சிறிய நிரலாக

BEGIN தொகுதி முதல் வரியைப் படிக்கும் முன்பும், END கடைசி வரிக்குப் பின்னும் இயங்கும். NR தற்போதைய வரி எண்ணை வைத்திருக்கும், END தொகுதியில் அது மொத்த வரிகளின் எண்ணிக்கை.

# பதில்களின் அளவுகளை (10-ஆம் புலம்) மெகாபைட்டில் கூட்டு
awk '{sum += $10} END {printf "%.1f MB\n", sum/1024/1024}' access.log

# கடைசி நெடுவரிசையில் உள்ள சராசரி பதில் நேரம்
awk '{s += $NF} END {if (NR) print s/NR}' timings.log

# CSV தலைப்பை தவிர்
awk -F, 'NR > 1 {print $2}' users.csv

# IP வாரியாக கோரிக்கைகளை எண்ணுதல்: associative array
awk '{count[$1]++} END {for (ip in count) print count[ip], ip}' access.log | sort -rn | head

கடைசி எடுத்துக்காட்டு log பகுப்பாய்வின் உன்னதமான முறை: IP-ஐ key ஆகக் கொண்ட count array sort | uniq -c இணைப்பை மாற்றுகிறது, மேலும் ஒவ்வொரு முகவரிக்கான போக்குவரத்துக் கூட்டுத்தொகை போன்றவற்றுக்கு எளிதாக விரிவுபடுத்தலாம்.

Pipeline-கள்: grep, sed மற்றும் awk ஒன்றாக

உண்மையான சக்தி இணைப்பில் உள்ளது. ஒவ்வொரு கருவியும் தன் பகுதியைச் செய்கிறது, | முடிவை அடுத்ததுக்கு அனுப்புகிறது.

5xx பிழைகள் கொண்ட முதல் 10 IP-கள்

grep ' 50[0-9] ' /var/log/nginx/access.log \
  | awk '{print $1}' \
  | sort | uniq -c | sort -rn | head -10

    412 203.0.113.45
    118 198.51.100.7
     36 192.0.2.19

இங்கே grep வரிகளை தோராயமாக வடிகட்டுகிறது, awk ஒரு புலத்தை வெட்டி எடுக்கிறது, sort | uniq -c திரும்பத் திரும்ப வருவதை எண்ணுகிறது. இதை ஒரே awk-இலும் எழுதலாம்: awk '$9 ~ /^5/ {c[$1]++} END {for (i in c) print c[i], i}' access.log | sort -rn | head — இது மிகவும் துல்லியம், ஏனெனில் பதில் குறியீட்டு நெடுவரிசை நேரடியாகச் சரிபார்க்கப்படுகிறது.

அதிகம் திறக்கப்படும் URL-கள்

awk '{print $7}' access.log | sed 's/?.*//' | sort | uniq -c | sort -rn | head

இங்கே sed query சரத்தை வெட்டுகிறது, இதனால் /search?q=a மற்றும் /search?q=b ஒரே பக்கமாகக் கணக்கிடப்படும்.

கருத்துகள் இல்லாத config-இலிருந்து மதிப்புகள்

grep -v '^\s*#' /etc/myapp/app.env | grep '=' | awk -F= '{print $1}'

ஒரு குறிப்பிட்ட மணி நேரத்தின் பிழைகள்

grep '14/Oct/2026:03:' access.log | awk '$9 >= 500 {print $4, $7, $9}'

பொதுவான தவறுகள்

• awk-இல் ஒற்றை மேற்கோளுக்குப் பதில் இரட்டை மேற்கோள். awk "{print $1}"-இல் awk தொடங்குவதற்கு முன்பே shell தனது $1 மாறியை பொருத்திவிடும். awk நிரலையும் sed வெளிப்பாடுகளையும் ஒற்றை மேற்கோளில் எழுதுங்கள்.
• sed-இல் g மறந்துவிடுவது. அது இல்லாமல் ஒரு வரியில் முதல் பொருத்தம் மட்டுமே மாறும், மற்றவை அப்படியே இருக்கும்.
• சரிபார்க்காமல் sed -i. தவறான regex கோப்பை அமைதியாகச் சிதைக்கும். முதலில் -i இல்லாமல் இயக்குங்கள் அல்லது -i.bak பயன்படுத்துங்கள்.
• grep-இல் + மற்றும் | வேலை செய்யாது. அவை விரிவாக்கப்பட்ட தொடரியல்: grep -E (அல்லது sed -E) தேவை.
• வடிவத்தில் உள்ள புள்ளி. grep 192.168.1.1 192x168y1z1-ஐயும் கண்டறியும்: புள்ளி என்பது «எந்த எழுத்தும்». grep -F பயன்படுத்துங்கள் அல்லது \. என்று escape செய்யுங்கள்.
• நெடுவரிசைகளில் இடைவெளிகள். புலத்தில் இடைவெளி இருக்கக்கூடும் எனில் (CSV, பாதை), பிரிப்பானை வெளிப்படையாகக் கொடுங்கள்: awk -F, அல்லது awk -F'\t'.
• தேவையற்ற cat. cat file | grep x வேலை செய்யும், ஆனால் grep x file சுருக்கமானது மற்றும் கூடுதல் செயல்முறையை உருவாக்காது.

grep, sed மற்றும் awk-க்கு மாற்றுகள்

JSON-க்கு இந்தக் கருவிகள் சிரமமானவை: கட்டமைப்பை jq (jq '.items[] | select(.status=="active") | .name') மூலமும், YAML-ஐ yq மூலமும் படிப்பது நல்லது. பெரிய திட்டங்களில் வேகமான மறுசுழற்சி தேடலுக்கு பெரும்பாலும் ripgrep (கட்டளை rg) பயன்படுத்தப்படுகிறது, அது இயல்பாகவே .gitignore-ஐ கணக்கில் எடுக்கும். Perl தொடரியல் பிடித்திருந்தால், perl -pe 's/a/b/g' மற்றும் perl -lane 'print $F[0]' ஒரு வரியில் sed மற்றும் awk-ஐ மாற்றும். ஆனால் grep, sed மற்றும் awk கிட்டத்தட்ட எல்லா சர்வரிலும் நிறுவல் இல்லாமலே கிடைக்கின்றன — அதனால் முதலில் இவற்றைத் தெரிந்துகொள்வது மதிப்புமிக்கது.

சுருக்கம்

grep வரிகளைத் தேடுகிறது, sed அவற்றை மாற்றுகிறது, awk நெடுவரிசைகளுடன் வேலை செய்து கணக்கிடுகிறது. அடிப்படைத் தொகுப்பை நினைவில் வையுங்கள்: grep -rniE மற்றும் -A/-B/-C, sed 's/.../.../g' உடன் -i.bak மற்றும் -n 'Np', awk -F உடன் $1, $NF, நிபந்தனைகள் மற்றும் END தொகுதி. இந்தக் கட்டுமானத் தொகுதிகளிலிருந்து கிட்டத்தட்ட எந்த log பகுப்பாய்வையும் உருவாக்கலாம். இந்த grep sed awk examples, find, jq மற்றும் curl உடன் சேர்ந்து, Linux பாடத்திட்டத்தின் டெர்மினலில் உரை செயலாக்கம் பற்றிய பாடத்தில் நடைமுறையில் விளக்கப்பட்டுள்ளன.