grep, sed na awk: mifano ya kuchakata maandishi kwenye terminal ya Linux

grep, sed na awk ni zana tatu za kawaida za Linux za kuchakata maandishi. grep hutafuta mistari kwa muundo, sed hubadilisha na kufuta maandishi kwenye mtiririko bila kufungua mhariri, na awk hugawanya mstari kuwa safu na kuweza kuhesabu. Hapa chini ni mifano ya grep sed awk ambayo mara nyingi huhitajika unapochambua kumbukumbu za logi, faili za usanidi na matokeo ya amri, pamoja na makosa ya kawaida.

Wakati wa kutumia kila chombo

Zana zote tatu husoma maandishi mstari kwa mstari na kuandika matokeo kwenye pato la kawaida, kwa hiyo ni rahisi kuziunganisha kwa |. Tofauti iko kwenye kazi ambayo kila moja inafanya vizuri zaidi.

Kanuni rahisi: ikiwa unahitaji tu kuchuja — tumia grep; ikiwa unataka kubadilisha maandishi — sed; ikiwa maandishi yana safu au unahitaji hesabu — awk.

grep: kutafuta mistari kwa muundo

Mifano ya msingi ya grep

# Mistari yenye neno error kwenye faili
grep error /var/log/syslog

# Bila kujali herufi kubwa au ndogo: Error, ERROR, error
grep -i error app.log

# Pamoja na namba za mistari
grep -n "Connection refused" app.log

# Kwa kurudia kwenye saraka nzima, pamoja na majina ya faili
grep -rn "DB_HOST" /etc/myapp/

# Majina ya faili tu ambapo kuna mlingano
grep -rl "TODO" src/

# Geuza: kila kitu ISIPOKUWA maoni na mistari tupu
grep -v -e '^#' -e '^$' /etc/ssh/sshd_config

# Hesabu idadi ya mistari iliyolingana
grep -c " 500 " access.log

Bendera -w hutafuta neno zima: grep -w log haitapata login. Bendera -F huzima regex na kutafuta mfuatano kama ulivyo — ni rahisi pale muundo una nukta, mabano au nyota.

Muktadha karibu na mstari uliopatikana

Kosa kwenye logi mara chache huwa wazi kwa mstari mmoja — unahitaji stack au ombi lililosababisha. Kwa hilo kuna bendera za muktadha:

# Mistari 3 baada ya mlingano (After)
grep -A 3 "Traceback" app.log

# Mistari 2 kabla (Before)
grep -B 2 "OOM" /var/log/kern.log

# Mistari 5 kila upande (Context)
grep -C 5 "segfault" /var/log/syslog

grep hutenganisha makundi ya mlingano kwa mstari wa --, kwa hiyo pato ni rahisi kusoma kwa macho.

grep na regular expressions

Kwa chaguo-msingi grep inaelewa regex za msingi (BRE). Kwa bendera -E zinawashwa regex zilizopanuliwa (ERE), ambapo +, ?, | na mabano hufanya kazi bila mistari ya nyuma (backslash).

# Mistari yenye makosa au maonyo
grep -E "ERROR|WARN" app.log

# Anwani za IP tu kutoka kwenye logi, moja kwa kila mstari (-o — chapisha mlingano tu)
grep -oE '([0-9]{1,3}\.){3}[0-9]{1,3}' access.log

grep -P: kutoa thamani kati ya vipande vinavyojulikana

GNU grep ina bendera -P — regex za mtindo wa Perl. Kwa hiyo zinapatikana \K («sahau kila kilicholingana hadi hapa») na lookahead, ambazo zinaruhusu kutoa thamani pekee:

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

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

Bendera -P haipatikani kwenye kila toleo la grep (kwa mfano, BSD grep kwenye macOS haina), kwa hiyo kwenye script zinazopaswa kufanya kazi kila mahali ni bora kutumia sed au awk.

grep -q kwenye masharti ya script

grep -q haichapishi chochote, inarudisha tu msimbo wa kutoka: 0 — imepatikana, 1 — haijapatikana. Hivyo ukaguzi unaweza kuandikwa moja kwa moja ndani ya if:

if grep -q "^PermitRootLogin no" /etc/ssh/sshd_config; then
  echo "kuingia kwa root kumezimwa"
fi

Hii ni fupi kuliko kuhifadhi pato kwenye kigeu na kukagua kama ni tupu, na grep huacha kwenye mlingano wa kwanza.

sed: kubadilisha na kufuta maandishi

Kubadilisha: amri s

Amri kuu ya sed ni s/muundo/badala/bendera. Bila bendera g ni mlingano wa kwanza tu kwenye kila mstari unaobadilishwa.

# Kuonyesha maandishi yaliyobadilishwa (faili haibadiliki)
sed 's/foo/bar/' file.txt

# Kubadilisha mlingano wote kwenye mstari
sed 's/foo/bar/g' file.txt

# Bila kujali herufi kubwa au ndogo (GNU sed)
sed 's/error/ERROR/gI' app.log

# Kitenganishi kingine, ikiwa maandishi yana slash
sed 's|/var/www|/srv/www|g' nginx.conf

sed -i: kubadilisha moja kwa moja ndani ya faili

Bendera -i huandika matokeo kurudi kwenye faili. Ili usipoteze chanzo, weka kiambishi cha nakala rudufu:

# Itaunda config.ini.bak na kubadilisha config.ini
sed -i.bak 's/^debug=true/debug=false/' config.ini

# Kubadilisha kwenye faili zote .conf za saraka
find /etc/myapp -name "*.conf" -exec sed -i 's/old-host/new-host/g' {} +

Kabla ya marekebisho ya wingi, endesha amri bila -i kwanza na uangalie pato. Kwenye macOS (BSD sed) -i inahitaji hoja: sed -i '' 's/a/b/' file.

Kufanya kazi na mistari kwa namba na kwa muundo

# Onyesha mistari 10–20 (-n huzima chapisho la kiotomatiki, p — chapisha)
sed -n '10,20p' file.txt

# Futa mstari wa 5
sed '5d' file.txt

# Futa mstari wa mwisho
sed '$d' file.txt

# Futa mistari tupu na maoni
sed -e '/^$/d' -e '/^#/d' nginx.conf

# Badilisha tu kwenye mistari yenye "listen"
sed '/listen/s/80/8080/' nginx.conf

# Ingiza mstari baada ya mlingano (GNU sed)
sed '/^\[mysqld\]/a max_connections = 500' my.cnf

Marejeo ya nyuma na &

Sehemu ya muundo iliyo kwenye mabano inaweza kuingizwa kwenye badala kwa \1, \2, na ishara & inamaanisha maandishi yote yaliyopatikana.

# Badilisha jina na jina la ukoo mahali pake (ERE kwa -E)
$ echo "Ivanov Petr" | sed -E 's/(\S+) (\S+)/\2 \1/'
Petr Ivanov

# Funga namba zote kwenye mabano ya mraba
$ echo "port 8080, timeout 30" | sed -E 's/[0-9]+/[&]/g'
port [8080], timeout [30]

# Badilisha tarehe 2026-10-14 kuwa 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: safu, masharti na hesabu

Kutoa safu inayohitajika

awk hugawanya kila mstari kuwa sehemu kwa nafasi na tabo: $1 — sehemu ya kwanza, $2 — ya pili, $NF — ya mwisho, $0 — mstari mzima.

# Anwani za IP kutoka kwenye logi ya nginx (safu ya kwanza)
awk '{print $1}' /var/log/nginx/access.log

# Jina la mtumiaji na shell kutoka /etc/passwd (kitenganishi — koloni)
awk -F: '{print $1, $7}' /etc/passwd

# Safu ya mwisho
df -h | awk '{print $NF}'

# Kitenganishi chako wakati wa pato
awk -F: -v OFS=';' '{print $1, $3}' /etc/passwd

Masharti: chapisha mistari inayohitajika tu

Kabla ya kizuizi cha mabano ya mikunjo unaweza kuweka sharti — awk itatekeleza kitendo kwa mistari inayofaa tu.

# Watumiaji wenye UID kuanzia 1000 (wa kawaida, si wa mfumo)
awk -F: '$3 >= 1000 {print $1}' /etc/passwd

# Maombi yenye msimbo wa jibu 500 au zaidi (uwanja wa 9 katika muundo wa combined)
awk '$9 >= 500' access.log

# Mistari ambayo safu ya 6 inalingana na regex
awk '$6 ~ /POST/' access.log

# Faili kubwa kuliko MB 100 kutoka pato la ls -l
ls -l | awk '$5 > 100*1024*1024 {print $9}'

BEGIN, END na NR: awk kama programu ndogo

Kizuizi cha BEGIN hutekelezwa kabla ya kusoma mstari wa kwanza, END — baada ya wa mwisho. NR ina namba ya mstari wa sasa, na kwenye kizuizi cha END — jumla yake.

# Jumla ya ukubwa wa majibu (uwanja wa 10) kwa megabaiti
awk '{sum += $10} END {printf "%.1f MB\n", sum/1024/1024}' access.log

# Wastani wa muda wa jibu kutoka safu ya mwisho
awk '{s += $NF} END {if (NR) print s/NR}' timings.log

# Ruka kichwa cha CSV
awk -F, 'NR > 1 {print $2}' users.csv

# Hesabu ya maombi kwa IP: safu shirikishi (associative array)
awk '{count[$1]++} END {for (ip in count) print count[ip], ip}' access.log | sort -rn | head

Mfano wa mwisho ni wa kawaida kwa kuchambua logi: safu count yenye IP kama ufunguo inachukua nafasi ya mchanganyiko wa sort | uniq -c na inaweza kupanuliwa kwa urahisi, kwa mfano hadi jumla ya trafiki kwa kila anwani.

Mabomba: grep, sed na awk pamoja

Nguvu halisi iko kwenye mchanganyiko. Kila chombo kinafanya sehemu yake, na | inapitisha matokeo mbele.

IP 10 zinazoongoza kwa makosa 5xx

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

Hapa grep kwa ukali huondoa mistari, awk hukata uwanja, na sort | uniq -c huhesabu marudio. Hili pia linaweza kuandikwa kwa awk moja: awk '$9 ~ /^5/ {c[$1]++} END {for (i in c) print c[i], i}' access.log | sort -rn | head — ni sahihi zaidi, kwa sababu inakagua moja kwa moja safu ya msimbo wa jibu.

URL zinazofunguliwa mara nyingi zaidi

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

Hapa sed inakata sehemu ya query, ili /search?q=a na /search?q=b zihesabiwe kama ukurasa mmoja.

Thamani kutoka kwenye usanidi bila maoni

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

Makosa ya saa fulani

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

Makosa ya kawaida

• Nukuu mbili badala ya moja kwenye awk. Katika awk "{print $1}" shell itaweka kigeu chake $1 kabla awk haijaanza. Andika programu ya awk na misemo ya sed ndani ya nukuu moja.
• Kusahau g kwenye sed. Bila hiyo ni mlingano wa kwanza tu kwenye mstari unaobadilishwa, mengine yanabaki.
• sed -i bila ukaguzi. Regex isiyo sahihi itaharibu faili kimya kimya. Kwanza endesha bila -i au tumia -i.bak.
• + na | hazifanyi kazi kwenye grep. Hii ni sintaksia iliyopanuliwa: unahitaji grep -E (au sed -E).
• Nukta kwenye muundo. grep 192.168.1.1 itapata pia 192x168y1z1: nukta ni «herufi yoyote». Tumia grep -F au ukimbie kwa \..
• Nafasi kwenye safu. Ikiwa sehemu inaweza kuwa na nafasi (CSV, njia ya faili), weka kitenganishi wazi: awk -F, au awk -F'\t'.
• cat isiyo ya lazima. cat file | grep x inafanya kazi, lakini grep x file ni fupi zaidi na haizalishi mchakato wa ziada.

Zana za kuchukua nafasi ya grep, sed na awk

Kwa JSON zana hizi si rahisi: muundo ni bora kuchambuliwa kwa jq (jq '.items[] | select(.status=="active") | .name'), na YAML — kwa yq. Kwa utafutaji wa haraka kwenye miradi mikubwa mara nyingi hutumika ripgrep (amri rg), ambayo kwa chaguo-msingi inazingatia .gitignore. Ikiwa unapendelea sintaksia ya Perl, perl -pe 's/a/b/g' na perl -lane 'print $F[0]' zinachukua nafasi ya sed na awk kwa mstari mmoja. Lakini grep, sed na awk zipo karibu kila seva bila kusakinisha chochote — kwa hiyo ni muhimu kuzijua kwanza.

Muhtasari

grep hutafuta mistari, sed huibadilisha, awk hufanya kazi na safu na kuhesabu. Kumbuka seti ya msingi: grep -rniE na -A/-B/-C, sed 's/.../.../g' pamoja na -i.bak na -n 'Np', awk -F pamoja na $1, $NF, masharti na kizuizi cha END. Kutoka kwa vipande hivi unaweza kujenga karibu uchambuzi wowote wa logi. Mifano hii ya grep sed awk, pamoja na find, jq na curl, inafafanuliwa kwa vitendo katika somo la kozi ya Linux kuhusu kuchakata maandishi kwenye terminal.