വേരിയബിൾ മൂല്യം അനുസരിച്ച് Awk തിരയൽ സ്ട്രിംഗ്. AWK: സാമ്പിൾ പ്രോഗ്രാമുകൾ. ഫിൽട്ടറുകളും പ്രിൻ്റ് കമാൻഡുകളും സംയോജിപ്പിക്കുന്നു

ഈ ലേഖനത്തിൽ ഞങ്ങൾ ചിലത് കാണിക്കും പ്രായോഗിക ഉദാഹരണങ്ങൾഎന്നതിൽ AWK എങ്ങനെ ഉപയോഗിക്കാം എന്നതിനെക്കുറിച്ച്.

ആമുഖം

ആൽഫ്രഡ് അഹോ, പീറ്റർ വെയ്ൻബർഗർ, ബ്രയാൻ കെർനിഗാൻ എന്നീ രചയിതാക്കളുടെ പേരിലാണ് AWK എന്ന പേര് നൽകിയിരിക്കുന്നത്. AWK വളരെ ആണ് ഉപയോഗപ്രദമായ ഭാഷടെക്സ്റ്റ് പ്രോസസ്സിംഗിനുള്ള സ്ക്രിപ്റ്റുകൾ. ഈ ഭാഷ ഒരു വ്യാഖ്യാതാവിൽ പ്രവർത്തിക്കുന്നു. ചില ഇൻപുട്ട് പ്രോസസ്സ് ചെയ്യാനും വേരിയബിളുകൾ നിർവചിക്കാനും ഉപയോഗിക്കാനും ഇത് ഉപയോക്താവിനെ അനുവദിക്കുന്നു ലോജിക്കൽ ഓപ്പറേറ്റർമാർ, സ്ട്രിംഗ്, ന്യൂമറിക് ഫംഗ്‌ഷനുകൾ, ഡാറ്റ എക്‌സ്‌ട്രാക്‌റ്റ് ചെയ്‌ത് ഫോർമാറ്റ് ചെയ്‌ത റിപ്പോർട്ടുകൾ സൃഷ്‌ടിക്കുക. AWK യുടെ വാക്യഘടന സി ഭാഷയുമായി വളരെ സാമ്യമുള്ളതാണ് കൂടാതെ പേളിന് നേരിട്ടുള്ള മുൻഗാമിയുമാണ്. A2P യൂട്ടിലിറ്റി ഉപയോഗിച്ച് എല്ലാ AWK സ്ക്രിപ്റ്റുകളും Perl സ്ക്രിപ്റ്റുകളിലേക്ക് പരിവർത്തനം ചെയ്യാൻ കഴിയും.

മുൻവ്യവസ്ഥകൾ

AWK വ്യാഖ്യാതാവാണ് സാധാരണ ഉപകരണം, എല്ലാ Linux വിതരണത്തിലും കണ്ടെത്തി. ഗാക്ക് പാക്കേജിൽ AWK-യുടെ ഒരു ഓപ്പൺ സോഴ്‌സ് പതിപ്പ് അടങ്ങിയിരിക്കുന്നു സോഴ്സ് കോഡ്, എന്നിവയെ ആശ്രയിച്ച് ലിനക്സ് വിതരണംഅതിൽ നിന്ന് ഇൻസ്റ്റാൾ ചെയ്യാൻ കഴിയും ഉറവിട ഫയൽഅല്ലെങ്കിൽ നിങ്ങളുടെ പ്രത്യേക Linux വിതരണത്തിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്ന gawk അല്ലെങ്കിൽ mawk പാക്കേജുകൾ ഉപയോഗിക്കുക.

ഇൻസ്റ്റലേഷൻ

സൂപ്പർ യൂസർ അവകാശങ്ങളോടെ

Ssh റൂട്ട്@IP_വിലാസം

കമാൻഡ് യൂട്ടിലിറ്റി ഇൻസ്റ്റാൾ ചെയ്യാൻ AWK സ്ട്രിംഗുകൾ/Fedora അല്ലെങ്കിൽ മറ്റേതെങ്കിലും ഓൺ RPM അടിസ്ഥാനമാക്കിലിനക്സ് വിതരണം, ഇനിപ്പറയുന്ന കമാൻഡ് പ്രവർത്തിപ്പിക്കുക:

യം ഇൻസ്റ്റാൾ ഗാക്ക്

/ ൽ, Gawk ഇൻസ്റ്റാൾ ചെയ്യാൻ നിങ്ങൾ ഈ കമാൻഡ് വിളിക്കേണ്ടതുണ്ട്:

Apt-get install gawk

AWK കമാൻഡ് ഉദാഹരണങ്ങൾ

ലളിതമായ awk കമാൻഡുകൾ കമാൻഡ് ലൈനിൽ നിന്ന് എളുപ്പത്തിൽ പ്രവർത്തിപ്പിക്കാൻ കഴിയും, കൂടുതൽ സങ്കീർണ്ണമായ ജോലികൾക്കായി ഒരു ഫയലിലേക്ക് awk സ്ക്രിപ്റ്റുകളായി എഴുതണം. ചിലത് ചുവടെ പട്ടികപ്പെടുത്തിയിരിക്കുന്നു ഉപയോഗപ്രദമായ ഉദാഹരണങ്ങൾ awk കമാൻഡുകളും എക്സിക്യൂട്ടബിൾ സ്ക്രിപ്റ്റുകളും.

ഒരു ഇൻപുട്ട് ഫീൽഡിൽ നിന്ന് പ്രത്യേക കോളങ്ങൾ മാത്രം പ്രിൻ്റ് ചെയ്യാൻ നിങ്ങൾക്ക് AWK കമാൻഡ് ഉപയോഗിക്കാം. ഉദാഹരണത്തിന്, ചുവടെയുള്ള കമാൻഡ് ഉപയോഗിച്ച് നിങ്ങൾക്ക് സെർവറുമായി ബന്ധിപ്പിച്ചിരിക്കുന്ന IP വിലാസങ്ങളുടെ ലിസ്റ്റ് കണ്ടെത്താനാകും:

നിങ്ങളുടെ സെർവർ കീഴിലാണോ എന്ന് അന്വേഷിക്കുകയാണെങ്കിൽ ഇത് വളരെ ഉപയോഗപ്രദമാണ് DoS ആക്രമണംഅല്ലെങ്കിൽ DDoS.

ഇനിപ്പറയുന്ന ഉദാഹരണത്തിൽ, ചില കോളങ്ങളിൽ ഒരു നിർദ്ദിഷ്ട പാറ്റേൺ തിരയാനും ഫലത്തെ അടിസ്ഥാനമാക്കി ചില പ്രവർത്തനങ്ങൾ ചെയ്യാനും ഞങ്ങൾ AWK ഉപയോഗിക്കുന്നു:

Exim -bpr | ഗ്രെപ് ഫ്രീസൻ | awk("പ്രിൻ്റ് $3") | xargs exim -Mrm

മുകളിലെ കമാൻഡ് എല്ലാ ഫ്രോസൺ സന്ദേശങ്ങളും ഇല്ലാതാക്കും ഇമെയിൽ Exim മെയിൽ ക്യൂവിൽ നിന്ന്.

ഉപയോഗപ്രദമായ പ്രകടനം നടത്താൻ AWK ഉപയോഗിക്കാറുണ്ട് പ്രായോഗിക പ്രോസസ്സിംഗ്ടെക്സ്റ്റ് കൃത്രിമത്വവും. ഉദാഹരണത്തിന്, ഡ്യൂപ്ലിക്കേറ്റുകൾ നീക്കം ചെയ്യാൻ നമുക്ക് AWK ഉപയോഗിക്കാം ടെക്സ്റ്റ് ഫയൽതരംതിരിക്കാതെ:

Awk "!x[$0]++" ഫയൽ ഡ്യൂപ്ലിക്കേറ്റുകളോടെ > പുതിയ ഫയൽ ഡ്യൂപ്ലിക്കേറ്റുകളില്ലാതെ

ഇനിപ്പറയുന്ന കമാൻഡ് 0 മുതൽ 999 വരെയുള്ള അഞ്ച് റാൻഡം നമ്പറുകൾ പ്രിൻ്റ് ചെയ്യും:

Awk "BEGIN ( for (i = 1; i<= 5; i++) print int(1000 * rand()) }"

"sample_file" എന്ന പേരിലുള്ള ഒരു ഫയലിലെ വരികളുടെ എണ്ണം കണക്കാക്കാൻ ഇനിപ്പറയുന്ന കമാൻഡ് ഉപയോഗിക്കുക:

Awk "END ( പ്രിൻ്റ് NR )" സാമ്പിൾ_ഫയൽ

ഇനിപ്പറയുന്ന കമാൻഡ് "സാമ്പിൾ_ഫയൽ" ഫയലിലെ എല്ലാ വരികളും പ്രിൻ്റ് ചെയ്യും, അതിൽ 'A' അല്ലെങ്കിൽ 'a' എന്നതിൽ ആരംഭിക്കുന്ന വരികൾ 're' തുടർന്ന്:

Awk "/re/(print)" /opt/sample_file

കൂടുതൽ സങ്കീർണ്ണമായ പ്രവർത്തനങ്ങൾക്കായി നിങ്ങൾക്ക് AWK കമാൻഡ് ഉപയോഗിക്കാം. നിങ്ങളുടെ വെബ്‌സൈറ്റ് വളരെ മന്ദഗതിയിലാണ് പ്രവർത്തിക്കുന്നതെങ്കിൽ, I/O ഡിസ്‌കിൽ (കൂടാതെ/അല്ലെങ്കിൽ നെറ്റ്‌വർക്ക്, ചില അപൂർവ സന്ദർഭങ്ങളിൽ) എന്തെങ്കിലും പ്രശ്‌നമുണ്ടോയെന്ന് പരിശോധിക്കാൻ നിങ്ങൾക്ക് ഇനിപ്പറയുന്ന കമാൻഡ് ഉപയോഗിക്കാം:

Tac /proc/stat | awk "/^btime/ (up=systime()-$2;print "up" up" up/86400 "d"); /^cpu / ("ഉപയോക്താവ്" $2/up "%, നല്ല " $3/up "%, sys " $4/up "%, idle " $5/up "%, iowait " $6/up "%, മോഷ്ടിക്കുക " $9/up "%\niowait/used " $6 / ($2+$3+$4) ", മോഷ്ടിക്കുക/ഉപയോഗിച്ചു "$9 / ($2+$3+$4)"

IOWAIT എന്നാൽ I/O, പ്രധാനമായും ഡിസ്ക് സ്റ്റോറേജ് അല്ലെങ്കിൽ ഒരുപക്ഷേ നെറ്റ്‌വർക്ക് എന്നിവയിൽ തിരക്കിലായിരിക്കുമ്പോൾ എത്രത്തോളം പ്രക്രിയകൾ തടയപ്പെടുന്നു എന്നാണ് അർത്ഥമാക്കുന്നത്. STEAL എന്നാൽ സെർവറിലെ CPU ടൈം സ്ലൈസ് ലക്ക് വഴി എത്രത്തോളം പ്രക്രിയകൾ തടഞ്ഞിരിക്കുന്നു എന്നാണ് അർത്ഥമാക്കുന്നത്. ഉപയോക്താവിൻ്റെ CPU സമയത്തിനായുള്ള മുകളിലെ iowait (=USER + NICE + SYSTEM) തിരക്കുള്ള I/O കാണിക്കുന്നു, മുകളിൽ കാണുന്ന സ്റ്റിൽ ഒരു തിരക്കുള്ള CPU കാണിക്കുന്നു.

ഇനിപ്പറയുന്ന സ്‌ക്രിപ്റ്റ് ഒരു ലളിതമായ awk കമാൻഡ് ഉപയോഗിക്കുന്നു, അത് ഇൻപുട്ട് ഫയൽ '/etc/passwd' തിരയുകയും അവസാനമായി ലോഗിൻ ചെയ്ത തീയതിയും സമയവും ഉപയോക്തൃനാമത്തോടുകൂടിയ ഔട്ട്പുട്ട് നൽകുകയും ചെയ്യുന്നു:

Vi login-check #!/bin/bash എന്ന ഉപയോക്താവിന് `awk -F: "($1 പ്രിൻ്റ് ചെയ്യുക)" /etc/passwd` do echo -n "$user: " finger $user | grep അവസാനമാണെങ്കിൽ [ $? != 0 ]; പിന്നെ echo fi ചെയ്തു

സ്ക്രിപ്റ്റ് എക്സിക്യൂട്ടബിൾ ആക്കുക:

Chmod 755 ലോഗിൻ-ചെക്ക്

സ്ക്രിപ്റ്റ് എക്സിക്യൂട്ട് ചെയ്യുക:

./ലോഗിൻ ചെക്ക്

സെർവറിൽ ലഭ്യമായ ഉപയോക്തൃ അക്കൗണ്ടുകളും തുടർന്ന് ഓരോ ഉപയോക്താവിൻ്റെയും അവസാന ലോഗിൻ തീയതിയും സമയവും നിങ്ങൾക്ക് കാണാനാകും.

ഉപസംഹാരം

AWK-ന് പകരം ഉപയോഗിക്കാവുന്ന പേൾ, പൈത്തൺ പോലുള്ള ചില പുതിയ ഭാഷകളുണ്ട്, എന്നാൽ AWK ഉപയോഗിക്കുന്നതിന് നിരവധി ഗുണങ്ങളുണ്ട്:

AWK തിരിച്ചറിയാൻ വളരെ എളുപ്പമാണ്.
മറ്റ് ടൂളുകൾ/ഭാഷകൾ ഉപയോഗിക്കുന്നതിനേക്കാൾ ചില തരത്തിലുള്ള പ്രശ്നങ്ങൾ വേഗത്തിൽ പരിഹരിക്കാനും കൂടുതൽ കാര്യക്ഷമമായ സ്ക്രിപ്റ്റുകൾ സൃഷ്ടിക്കാനും AWK ഉപയോഗിക്കാം.
ലോഗുകൾ മുതലായ വലിയ ഫയലുകളിൽ പ്രവർത്തിക്കുമ്പോൾ AWK വളരെ ഉപയോഗപ്രദമാണ്, കാരണം AWK കമാൻഡ്/സ്ക്രിപ്റ്റിൻ്റെ സഹായത്തോടെ നിങ്ങൾക്ക് ഫിൽട്ടർ ചെയ്തതും വായിക്കാവുന്നതുമായ ഒരു റിപ്പോർട്ട് സൃഷ്ടിക്കാൻ കഴിയും.

ഈ ലേഖനത്തിൽ, ദൈനംദിന പ്രശ്നങ്ങൾ പരിഹരിക്കാനും കമാൻഡ് ലൈനിൻ്റെ ഉപയോഗം വളരെ ലളിതമാക്കാനും എന്നെ സഹായിക്കുന്ന ഉപയോഗപ്രദമായ ഉദാഹരണങ്ങൾ പങ്കിടാൻ ഞാൻ പദ്ധതിയിടുന്നു. AWK-യുമായി ഇതുവരെ പരിചിതമല്ലാത്തവർക്ക്, നിങ്ങൾ തീർച്ചയായും ഈ സ്ക്രിപ്റ്റിംഗ് ഭാഷയിൽ വൈദഗ്ദ്ധ്യം നേടണമെന്ന് ഞാൻ ശുപാർശ ചെയ്യുന്നു; ഇതിൽ സങ്കീർണ്ണമായ ഒന്നും തന്നെയില്ല. ചില ഓപ്പറേറ്റർമാരെ ഉപയോഗിക്കുന്നതിൻ്റെ സൂക്ഷ്മതകളിലേക്ക് വെളിച്ചം വീശുന്ന ചെറിയ അഭിപ്രായങ്ങളോടെ ഓരോ ഉദാഹരണവും അനുഗമിക്കാൻ ഞാൻ പദ്ധതിയിടുന്നു.
.

ഒരു പാരാമീറ്റർ ഉള്ള ഒരു വരി ഞങ്ങൾ തിരയുകയാണ് ബൈൻഡ്-വിലാസംകോൺഫിഗറേഷൻ ഫയലിൽ.

റൂട്ട്@ഡെബിയൻ:~# awk '/bind-address/' /etc/mysql/my.cnf
ബൈൻഡ്-വിലാസം = 127.0.0.1
ബൈൻഡ്-വിലാസം = 192.168.1.110

വിശദീകരണങ്ങൾ: AWK-ന് ഇനിപ്പറയുന്ന വാക്യഘടനയും ഓപ്ഷനുകളും ഉണ്ട്.

awk[-f program_file | 'പ്രോഗ്രാം'] [-Fdelimiter]
[-v വേരിയബിൾ=മൂല്യം] [ഫയൽ ...]

−Fമൂല്യം - സെപ്പറേറ്റർ നിർവചിക്കുന്നു (ബിൽറ്റ്-ഇൻ എഫ്എസ് വേരിയബിളിൻ്റെ മൂല്യം സജ്ജമാക്കുന്നു);
−fഫയൽ - കമാൻഡ് ലൈനിന് പകരം ഒരു ഫയലിൽ നിന്ന് പ്രോഗ്രാം ടെക്സ്റ്റ് വായിക്കുന്നു. ഒന്നിലധികം ഫയലുകളിൽ നിന്നുള്ള വായന പിന്തുണയ്ക്കുന്നു;
-വി var=മൂല്യം - ഒരു വേരിയബിളിന് ആവശ്യമായ മൂല്യം നൽകുന്നു;
−− - ഓപ്ഷനുകളുടെ പട്ടികയുടെ അവസാനം അടയാളപ്പെടുത്തുന്നു.

ഉദാഹരണം നമ്പർ 2

മുകളിലുള്ള ഉദാഹരണത്തിൽ, തിരയൽ ഒരു ഫയലിലാണ് നടക്കുന്നത്, എന്നാൽ AWK-ന് മറ്റൊരു കമാൻഡിൻ്റെ ഔട്ട്പുട്ട് സ്വീകരിക്കാനും കഴിയും. അതിനനുസരിച്ച് നമ്മുടെ ഉദാഹരണം സങ്കീർണ്ണമാക്കാൻ ശ്രമിക്കാം.

root@debian-wordpress:~# പൂച്ച /etc/mysql/my.cnf | awk '/ബൈൻഡ്-വിലാസം/'
ബൈൻഡ്-വിലാസം = 127.0.0.1
ബൈൻഡ്-വിലാസം = 192.168.1.110

നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, ഡിസൈൻ, തീർച്ചയായും, കൂടുതൽ സങ്കീർണ്ണമായെങ്കിലും, ഔട്ട്പുട്ട് ഫലം അതേപടി തുടർന്നു. ഈ ഉദാഹരണത്തിൽ രണ്ടാമത്തെ ഓപ്ഷൻ ഉപയോഗിക്കുന്നത് പൂർണ്ണമായും ഉചിതമല്ലെന്ന് പറയണം, കാരണം ഇത് കൂടുതൽ സങ്കീർണ്ണമാണ്. അത്തരമൊരു രൂപകൽപ്പനയുടെ ഉപയോഗം ന്യായീകരിക്കപ്പെടുന്ന മറ്റ് സാഹചര്യങ്ങൾ പരിഗണിക്കാൻ ശ്രമിക്കാം.

ഉദാഹരണം നമ്പർ 3

ടാർഗെറ്റ് ഫയലുകളിലേക്കുള്ള പ്രതീകാത്മക ലിങ്കുകളും പാതകളും ലിസ്റ്റ് ചെയ്യുക.

റൂട്ട്@ഡെബിയൻ:~# ls -l /bin/ | awk '/lrwxrwxrwx/ ( $9, $10, $11 അച്ചടിക്കുക)'
bzcmp -> bzdiff
bzegrep -> bzgrep
bzfgrep -> bzgrep
bzless -> bzmore
lessfile -> ലെസ്സ് പൈപ്പ്
lsmod -> kmod
mt -> /etc/alternatives/mt
nc -> /etc/alternatives/nc
netcat -> /etc/alternatives/netcat
open -> openvt
pidof -> /sbin/killall5
rbash -> bash
rnano -> നാനോ
sh -> ഡാഷ്
sh.distrib -> ഡാഷ്

വിശദീകരണങ്ങൾ: awk പ്രോഗ്രാം ഒരു ടെംപ്ലേറ്റ് ജോഡിയാണ് ( മാതൃക) കൂടാതെ പ്രവർത്തനങ്ങൾ ( (പ്രവർത്തനം)), അതുപോലെ ഉപയോക്തൃ-നിർവചിച്ച പ്രവർത്തനങ്ങളുടെ നിർവചനങ്ങൾ. ടെംപ്ലേറ്റും പ്രവർത്തനവും ഇതുപോലെ കാണപ്പെടുന്നു: പാറ്റേൺ (പ്രവർത്തനം) ടെംപ്ലേറ്റോ പ്രവർത്തനമോ ഒഴിവാക്കാവുന്നതാണ്. ആദ്യ സന്ദർഭത്തിൽ, ഓരോ വരിയിലും പ്രവർത്തനം നടത്തും, രണ്ടാമത്തേതിൽ, കമാൻഡിന് തുല്യമായ സ്ക്രീനിലേക്കുള്ള സാധാരണ ഔട്ട്പുട്ട് നടപ്പിലാക്കും.(പ്രിൻ്റ്). ഈ കീവേഡുകൾ മറ്റ് പാറ്റേണുകളുമായി സംയോജിപ്പിക്കാൻ കഴിയില്ല.

ഇൻപുട്ട് സ്‌ട്രിംഗിൽ സാധാരണയായി വൈറ്റ്‌സ്‌പെയ്‌സ് കൊണ്ട് വേർതിരിച്ച ഫീൽഡുകൾ അടങ്ങിയിരിക്കുന്നു. (ബിൽറ്റ്-ഇൻ വേരിയബിൾ ഉപയോഗിച്ച് ഈ സ്ഥിരസ്ഥിതി ക്രമീകരണം മാറ്റാവുന്നതാണ് എഫ്.എസ്അല്ലെങ്കിൽ ഓപ്ഷനുകൾ -എഫ് ഡിലിമിറ്റർ.) ഫീൽഡുകൾ $1, $2, ...; $0 എന്നത് മുഴുവൻ വരിയെയും സൂചിപ്പിക്കുന്നു.

ഉദാഹരണം നമ്പർ 4

മുകളിലുള്ള വിവരങ്ങളെ അടിസ്ഥാനമാക്കി, ഡിഫോൾട്ട് സെപ്പറേറ്റർ മാറ്റുന്നതിനുള്ള ഒരു ഉദാഹരണം നോക്കാം - അധിക വിവരങ്ങളില്ലാതെ എല്ലാ ഉപയോക്താക്കളുടെയും ഒരു ലിസ്റ്റ് കാണുക.

റൂട്ട്@ഡെബിയൻ:~# awk -F ":" '( പ്രിൻ്റ് $1 )' /etc/passwd
റൂട്ട്
പിശാച്
ബിൻ
sys
സമന്വയിപ്പിക്കുക
ഗെയിമുകൾ
മനുഷ്യൻ

(കമാൻഡ് ഔട്ട്പുട്ട് ചുരുക്കി)

വിശദീകരണങ്ങൾ: ഫയലിൽ നിന്ന് /etc/passwdരേഖകൾ ഫോമിൽ സൂക്ഷിക്കുന്നു " root:x:0:0:root:/root:/bin/bash", ഒരു കോളൻ സെപ്പറേറ്ററായി തിരഞ്ഞെടുത്ത് ആദ്യത്തെ ഫീൽഡ് പ്രദർശിപ്പിക്കുന്നത് തികച്ചും യുക്തിസഹമാണ് ( $1 ) ഓരോ വരിയും ( $0 ).

ഉദാഹരണം നമ്പർ 5

ഉപയോക്താക്കളുമായി ഒരേ ഫയലിൽ, നിങ്ങൾക്ക് അവരുടെ നമ്പർ കണക്കാക്കാം.

റൂട്ട്@ഡെബിയൻ:~# awk 'END ( പ്രിൻ്റ് NR )' /etc/passwd
25

വിശദീകരണങ്ങൾ: പ്രത്യേക ടെംപ്ലേറ്റുകൾ ആരംഭിക്കുന്നുഒപ്പം അവസാനിക്കുന്നുയഥാക്രമം ആദ്യ ഇൻപുട്ട് ലൈൻ വായിക്കുന്നതിന് മുമ്പും അവസാന ഇൻപുട്ട് ലൈൻ വായിച്ചതിനുശേഷവും നിയന്ത്രണം നേടുന്നതിന് ഉപയോഗിക്കാം.

Awk അടിസ്ഥാനപരമായി sed പോലെയുള്ള ഒരു സ്ട്രീം എഡിറ്ററാണ്. നിങ്ങൾക്ക് ഈ പ്രോഗ്രാമിലേക്ക് വാചകം പൈപ്പ് ചെയ്യാനും അത് വരി വരിയായി കൈകാര്യം ചെയ്യാനും കഴിയും. പ്രോഗ്രാമിന് ഒരു ഫയലിൽ നിന്നും വായിക്കാനും കഴിയും. Awk ഒരു പ്രോഗ്രാമിംഗ് ഭാഷ കൂടിയാണ്. ഇത് അടിസ്ഥാനപരമായി അർത്ഥമാക്കുന്നത്, സെഡിന് ചെയ്യാൻ കഴിയുന്ന എല്ലാ കാര്യങ്ങളും കൂടാതെ അതിലേറെയും ചെയ്യാൻ awk-ന് കഴിയും എന്നാണ്.

sed-ൽ നിന്ന് വ്യത്യസ്തമായി, awk-ന് സന്ദർഭം ഓർക്കാനും താരതമ്യങ്ങൾ ചെയ്യാനും മറ്റ് പ്രോഗ്രാമിംഗ് ഭാഷകൾക്ക് ചെയ്യാൻ കഴിയുന്ന മറ്റ് നിരവധി കാര്യങ്ങൾ ചെയ്യാനും കഴിയും. ഉദാഹരണത്തിന്, ഇത് ഒരു വരിയിൽ മാത്രം ഒതുങ്ങുന്നില്ല. ശരിയായ വൈദഗ്ദ്ധ്യം ഉപയോഗിച്ച്, ഇതിന് ഒന്നിലധികം ലൈനുകൾ ബന്ധിപ്പിക്കാൻ കഴിയും.

ഏറ്റവും ലളിതമായ രൂപം awk ഇതുപോലെ കാണപ്പെടുന്നു:

ഓക്ക് "(ഇവിടെ ചില_പ്രവർത്തനങ്ങൾ)"

"Some_action_here" എന്നത് ഫലം പ്രിൻ്റ് ചെയ്യാനുള്ള ഒരു പദപ്രയോഗമോ അല്ലെങ്കിൽ കൂടുതൽ സങ്കീർണ്ണമായ ഒന്നോ ആകാം. വാക്യഘടന "സി" പ്രോഗ്രാമിംഗ് ഭാഷയ്ക്ക് സമാനമാണ്. ലളിതമായ ഉദാഹരണം:

Awk "(അച്ചടി $1,$3)"

ആദ്യത്തെയും മൂന്നാമത്തെയും കോളം പ്രിൻ്റ് ചെയ്യുക എന്നാണ് അർത്ഥമാക്കുന്നത്, ഇവിടെ കോളങ്ങൾ അർത്ഥമാക്കുന്നത് "വൈറ്റ് സ്പേസ് കൊണ്ട് വേർതിരിച്ച കാര്യങ്ങൾ" എന്നാണ്. വൈറ്റ് സ്പേസ് = ടാബ് അല്ലെങ്കിൽ സ്പേസ്.

തത്സമയ ഉദാഹരണം:

എക്കോ "1 2 3 4" | awk "($1,$3 അച്ചടിക്കുക)" 1 3

ഭാഗം രണ്ട്: AWKക്ക് എന്ത് ചെയ്യാൻ കഴിയും?

AWK-യുടെ ജീവിതത്തിലെ പ്രധാന ലക്ഷ്യം അതിൻ്റെ ഇൻപുട്ട് ഒരു ലൈൻ-ബൈ-ലൈൻ അടിസ്ഥാനത്തിൽ കൈകാര്യം ചെയ്യുക എന്നതാണ്. awk പ്രോഗ്രാംസാധാരണയായി ശൈലിയിൽ പ്രവർത്തിക്കുന്നു

നിങ്ങൾ ചെയ്യാൻ ആഗ്രഹിക്കുന്നത് ഈ മോഡലിന് അനുയോജ്യമല്ലെങ്കിൽ, awk നിങ്ങളുടെ ആശയത്തിന് അനുയോജ്യമല്ലായിരിക്കാം.

awk പ്രോഗ്രാമിംഗിൽ ഉപയോഗിക്കുന്ന സാധാരണ വാക്യഘടനയെ ഇനിപ്പറയുന്ന രീതിയിൽ വിവരിക്കാം:

Awk സാമ്പിൾ (കമാൻഡ്(കൾ))

അതിനർത്ഥം അതാണ്

“ഒരു പാറ്റേൺ ഉണ്ടോ എന്നറിയാൻ ഇൻപുട്ടിൻ്റെ ഓരോ വരിയും നോക്കുക. അത് അവിടെ ഉണ്ടെങ്കിൽ, അതിനിടയിലുള്ളത് പ്രവർത്തിപ്പിക്കുക ()"

നിങ്ങൾക്ക് സാമ്പിൾ അല്ലെങ്കിൽ കമാൻഡ് ഒഴിവാക്കാം

നിങ്ങൾ ഒരു പാറ്റേൺ വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ, കമാൻഡ് ഓരോ വരിയിലും പ്രയോഗിക്കും.

ഒരു കമാൻഡ് ഒഴിവാക്കിയാൽ, അത് പറയുന്നതിന് തുല്യമാണ് (ലൈൻ പ്രിൻ്റ് ചെയ്യുക):

(പ്രിൻ്റ്)

പ്രത്യേക ഉദാഹരണങ്ങൾ:

Awk "/#/ ("ഈ ലൈനിൽ ഒരു അഭിപ്രായമുണ്ട്" എന്ന് അച്ചടിക്കുക)" /etc/hosts

/etc/host ലെ ലൈനിൽ എവിടെയെങ്കിലും കുറഞ്ഞത് ഒരു "#" അടങ്ങിയിരിക്കുന്ന എല്ലാ വരികൾക്കും "ഈ ലൈനിൽ ഒരു അഭിപ്രായമുണ്ട്" എന്ന് പ്രിൻ്റ് ചെയ്യും

വ്യക്തതയ്ക്കായി പരിഷ്ക്കരണം

Awk "/#/ ($0" പ്രിൻ്റ് ചെയ്യുക:\tഈ ലൈനിൽ ഒരു അഭിപ്രായമുണ്ട്)" /etc/hosts

പാറ്റേണിലെ "//" ഘടകം ഒരു പൊരുത്തം വ്യക്തമാക്കുന്നതിനുള്ള ഒരു മാർഗമാണ്. ഒരു സ്ട്രിംഗ് പൊരുത്തപ്പെടുന്നുണ്ടോ എന്ന് നിർണ്ണയിക്കാൻ മറ്റ് വഴികളും ഉണ്ട്. ഉദാഹരണത്തിന്,

Awk "$1 == "#" ("ലൈൻ ആരംഭിക്കുന്നത് ഹാഷിൽ")" /etc/hosts

ആദ്യത്തെ കോളം "#" ആയ വരികളുമായി പൊരുത്തപ്പെടും. പ്രതീകങ്ങളുടെ ക്രമം "==" എന്നതിൻ്റെ അർത്ഥം മുഴുവൻ ആദ്യ നിരയുടെ കൃത്യമായ പൊരുത്തം എന്നാണ്.

വ്യക്തതയ്ക്കായി പരിഷ്ക്കരണം:

Awk "$1 == "#" ($0 പ്രിൻ്റ് ചെയ്യുക "\tline ആരംഭിക്കുന്നത് ഹാഷ് ഉപയോഗിച്ച്)" /etc/hosts

മറുവശത്ത്, നിങ്ങൾക്ക് ഒരു നിർദ്ദിഷ്‌ട കോളത്തിൻ്റെ ഭാഗിക പൊരുത്തം വേണമെങ്കിൽ, "~" ഓപ്പറേറ്റർ ഉപയോഗിക്കുക

Awk "$1 ~ /#/ ("എവിടെയെങ്കിലും കോളം 1 ൽ ഒരു ഹാഷ് ഉണ്ട്" എന്ന് അച്ചടിക്കുക)" /etc/hosts

ആദ്യത്തെ കോളം ഒരു വൈറ്റ് സ്‌പെയ്‌സിന് ശേഷമായിരിക്കാമെന്ന് ഓർമ്മിക്കുക.

വ്യക്തതയ്ക്കായി പരിഷ്ക്കരണം:

Awk "$1 ~ /#/ ($0 പ്രിൻ്റ് ചെയ്യുക "\t കോളം 1 ൽ എവിടെയോ ഒരു ഹാഷ് ഉണ്ട്)" /etc/hosts

"#comment" നൽകുന്നത് പൊരുത്തപ്പെടും

"#കമൻറ്" നൽകുന്നതും പൊരുത്തപ്പെടും

"കൃത്യമായി # എന്നതിൽ ആരംഭിക്കുന്ന ഒരു സ്‌ട്രിംഗും ഒരു സ്‌പെയ്‌സും" നിങ്ങൾക്ക് ഒരു നിർദ്ദിഷ്ട പൊരുത്തം വേണമെങ്കിൽ നിങ്ങൾ ഉപയോഗിക്കും

ഓക്ക് "/^# / (എന്തെങ്കിലും ചെയ്യുക)"

ഒന്നിലധികം പൊരുത്തങ്ങൾ

നിലവിലെ ലൈനുമായി പൊരുത്തപ്പെടുന്ന എല്ലാ പാറ്റേണുകളും Awk പ്രോസസ്സ് ചെയ്യും. അതിനാൽ, ഞങ്ങൾ ഇനിപ്പറയുന്ന ഉദാഹരണം ഉപയോഗിക്കുകയാണെങ്കിൽ,

Awk " /#/ ("ഒരു അഭിപ്രായമുണ്ട്" എന്ന് അച്ചടിക്കുക) $1 == "#" ("ആദ്യ നിരയിലെ അഭിപ്രായം" അച്ചടിക്കുക) /^# / ("ആദ്യം തന്നെ അഭിപ്രായം" എന്ന് അച്ചടിക്കുക) " /etc/hosts

ഇനിപ്പറയുന്നതുപോലുള്ള ഒരു ലൈനിനായി മൂന്ന് എൻട്രികൾ ഔട്ട്പുട്ട് ചെയ്യും:

#ഇതൊരു കമൻ്റാണ്

രണ്ട് എൻട്രികൾ

# ഇതൊരു ഇൻഡൻ്റ് ചെയ്ത കമൻ്റാണ്

കൂടാതെ ഒന്ന് മാത്രം

1.2.3.4 ഹോസ്റ്റിൻ്റെ പേര് # ഒരു അന്തിമ അഭിപ്രായം

സന്ദർഭ ട്രാക്കിംഗ്

എല്ലാ സ്ട്രിംഗുകളും തുല്യമായി സൃഷ്ടിക്കപ്പെട്ടിട്ടില്ല, അവ ഒരേപോലെയാണെങ്കിലും. ചില സമയങ്ങളിൽ ഒരു സ്ട്രിംഗിന് മുമ്പായി വരുന്ന വരികൾക്കനുസരിച്ച് എന്തെങ്കിലും ചെയ്യാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നു.

ഇവിടെ പെട്ടെന്നുള്ള ഉദാഹരണംനിങ്ങൾ "രഹസ്യം" വിഭാഗത്തിൽ ഇല്ലെങ്കിൽ "ADDR" എന്ന വരികൾ പ്രിൻ്റ് ചെയ്യുന്നു

Awk " /secretstart/ (രഹസ്യം=1) /ADDR/ ( if(secret==0) പ്രിൻ്റ് $0 ) /* $0 ആണ് മുഴുവൻ വരി*/ /രഹസ്യം/ (രഹസ്യം=0) "

"രഹസ്യ ആരംഭം" എന്ന സ്ട്രിംഗ് കാണാത്ത പക്ഷം ഉള്ളിൽ "ADDR" അടങ്ങിയിരിക്കുന്ന ഉള്ളടക്കങ്ങൾ ഇനിപ്പറയുന്നവ പ്രിൻ്റ് ചെയ്യും. ഓർഡർ കാര്യങ്ങൾ. ഉദാഹരണത്തിന്, നിങ്ങൾ ഇത് ഇതുപോലെ എഴുതുകയാണെങ്കിൽ:

Awk " /ADDR/ ( if(secret==0) print $0 ) /* $0 എന്നത് പൂർണ്ണമായ വരി */ /secretstart/ (secret=1) /secretend/ (secret=0) "

കൂടാതെ ഇനിപ്പറയുന്ന ഇൻപുട്ട് നൽകുക

ADDR ഒരു സാധാരണ ആഡർ രഹസ്യം ആരംഭിക്കുക ADDR ഒരു രഹസ്യ ആഡ്ർ ADDR മറ്റൊരു രഹസ്യ ആഡ്ർ ഒരു മൂന്നാമത്തെ രഹസ്യം ADDR രഹസ്യം ADDR സാധാരണയും

അപ്പോൾ ആദ്യത്തെ "രഹസ്യ" ആഡ്ർ പ്രിൻ്റ് ചെയ്യപ്പെടും. യഥാർത്ഥ ഉദാഹരണം രണ്ട് രഹസ്യങ്ങളും മറയ്ക്കും.

ഭാഗം മൂന്ന്: പ്രത്യേക വേരിയബിളുകൾ

സാധാരണ awk വാക്യഘടനയെക്കുറിച്ച് ഞങ്ങൾ ഇതിനകം സംസാരിച്ചു. ഇനി നമുക്ക് ഫാഷനബിൾ കാര്യങ്ങൾ നോക്കാം.

awk-ന് "പ്രത്യേക" പൊരുത്തപ്പെടുന്ന സ്ട്രിംഗുകൾ ഉണ്ട്: " ആരംഭിക്കുന്നു" ഒപ്പം " അവസാനിക്കുന്നു"

നിർദ്ദേശം ആരംഭിക്കുന്നുഡാറ്റയിൽ നിന്ന് ഏതെങ്കിലും വരികൾ വായിക്കുന്നതിന് മുമ്പ് ഒരിക്കൽ വിളിച്ചു, ഇനിയൊരിക്കലും.

നിർദ്ദേശം അവസാനിക്കുന്നുഎല്ലാ വരികളും വായിച്ചതിനു ശേഷം വിളിച്ചു. ഒന്നിലധികം ഫയലുകൾ നൽകിയിട്ടുണ്ടെങ്കിൽ, ഏറ്റവും പുതിയ ഫയൽ പൂർത്തിയായതിന് ശേഷം മാത്രമേ അത് വിളിക്കൂ.

സാധാരണയായി നിങ്ങൾ ഉപയോഗിക്കും ആരംഭിക്കുന്നുവ്യത്യസ്ത സമാരംഭത്തിനായി, ഒപ്പം അവസാനിക്കുന്നുസംഗ്രഹിക്കുന്നതിനോ വൃത്തിയാക്കുന്നതിനോ വേണ്ടി.

BEGIN ( maxerrors=3 ; logfile=/var/log/something ; tmpfile=/tmp/blah) ... ( blah blah blah ) /^ header/ ( headercount += 1 ) END ( printf("മൊത്തം തലക്കെട്ടുകൾ എണ്ണി =% d\n", തലക്കെട്ട്);

ഈ ഉദാഹരണം ഇൻപുട്ട് ഫയലിൽ "ഹെഡർ" എത്ര തവണ ദൃശ്യമാകുന്നു എന്ന് കണക്കാക്കുകയും മുഴുവൻ ഫയലും പ്രോസസ്സ് ചെയ്തതിന് ശേഷം മാത്രം പ്രിൻ്റ് ചെയ്യുകയും ചെയ്യും.

( ) വിഭാഗത്തിൽ നിങ്ങൾക്ക് ഉപയോഗിക്കാനാകുന്ന മറ്റ് നിരവധി പ്രത്യേക മൂല്യങ്ങളും AWK ന് ഉണ്ട്. ഉദാഹരണത്തിന്,

NF അച്ചടിക്കുക

നിലവിലെ വരിയിലെ മൊത്തം നിരകളുടെ എണ്ണം (ഫീൽഡുകളുടെ എണ്ണം) നിങ്ങൾക്ക് നൽകും. ഫയലിന്റെ പേര്നിലവിലെ ഫയൽനാമം ആയിരിക്കും, ഫയലിൻ്റെ പേര് പൈപ്പ് ഉപയോഗിക്കുന്നതിനുപകരം awk-ലേക്ക് കൈമാറിയെന്ന് സൂചിപ്പിക്കുന്നു.

നിങ്ങൾക്ക് മാറ്റാൻ കഴിയില്ല എൻ.എഫ്സ്വന്തമായി.

വേരിയബിളിൻ്റെ കാര്യത്തിലും സമാനമാണ് NR, നിങ്ങൾ എത്ര വരികൾ പ്രോസസ്സ് ചെയ്തുവെന്ന് ഇത് നിങ്ങളോട് പറയുന്നു. (“രേഖകളുടെ എണ്ണം” - റെക്കോർഡുകളുടെ എണ്ണം)

മറ്റ് പ്രത്യേക വേരിയബിളുകൾ ഉണ്ട്, പ്രോഗ്രാമിൻ്റെ മധ്യത്തിൽ നിങ്ങൾക്ക് മാറ്റാൻ കഴിയുന്നവ പോലും.

ഭാഗം നാല്: ലളിതമായ Awk ഉദാഹരണങ്ങൾ

പറഞ്ഞ കാര്യങ്ങൾ വിശദീകരിക്കാനും ശക്തിപ്പെടുത്താനും, നമുക്ക് ചിലത് നോക്കാം നിർദ്ദിഷ്ട ഉദാഹരണങ്ങൾ. അവർക്കായി ഞങ്ങൾക്ക് മൂന്ന് ചെറിയ ടെക്സ്റ്റ് ഫയലുകൾ ആവശ്യമാണ്.

ഇനിപ്പറയുന്ന ഉദാഹരണങ്ങൾക്കായി, ഇനിപ്പറയുന്ന ഉള്ളടക്കമുള്ള ഒരു field_data.txt ഫയൽ സൃഷ്ടിക്കാം:

റോസാപ്പൂക്കൾ ചുവപ്പാണ്, വയലറ്റ് നീലയാണ്, പഞ്ചസാര മധുരമാണ്, നിങ്ങളും.

Echo -e "റോസാപ്പൂക്കൾ ചുവപ്പാണ്,\nവയലറ്റുകൾ നീലയാണ്,\nപഞ്ചസാര മധുരമാണ്,\nനിങ്ങളും." >field_data.txt

നമുക്ക് ഇനിപ്പറയുന്ന ഉള്ളടക്കങ്ങൾ ഉപയോഗിച്ച് letters.txt ഫയൽ സൃഷ്ടിക്കാം

ഒരു bb ccc dddd ggg hh i

IN കമാൻഡ് ലൈൻഇത് ഇതുപോലെ ചെയ്യാം:

Echo -e "a\nbb\nccc\ndddd\nggg\nhh\ni" > letters.txt

അവസാനമായി, ഇനിപ്പറയുന്ന ഉള്ളടക്കം ഉപയോഗിച്ച് നമുക്ക് ഒരു മെയിൽ-ഡാറ്റ ഫയൽ സൃഷ്ടിക്കാം:

കമാൻഡ് ലൈനിൽ ഇത് ഇതുപോലെ ചെയ്യാൻ കഴിയും:

Wget https://raw.githubusercontent.com/tdhopper/awk-lessons/master/data/mail-data -O mail-data

ലളിതമായ പാറ്റേൺ (സാമ്പിൾ)

ഞങ്ങൾക്ക് രണ്ട് പ്രതീകങ്ങളിൽ കൂടുതൽ നീളമുള്ള വരികൾ ആവശ്യമുണ്ടെങ്കിൽ, സ്ഥിരസ്ഥിതി പ്രവർത്തനം ഉപയോഗിക്കണമെങ്കിൽ ( അച്ചടിക്കുക), അപ്പോൾ നമുക്ക് ലഭിക്കുന്നു:

Awk "നീളം $0 > 2" letters.txt bb ccc dddd ggg hh

$0 ഒരു സ്ട്രിംഗ് അടങ്ങുന്ന ഒരു ബിൽറ്റ്-ഇൻ വേരിയബിൾ ആണ്.

ലളിതമായ പ്രവർത്തനം

ഞങ്ങൾ ഒരു പാറ്റേൺ വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ, ഓരോ വരിയും പൊരുത്തപ്പെടും. ഓരോ വരിയും അച്ചടിക്കുക എന്നതാണ് നിസ്സാരമായ ഒരു പ്രവൃത്തി:

Awk "( പ്രിൻ്റ് )" letters.txt a bb ccc dddd ggg hh i

ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു നീളംഞങ്ങളുടെ പ്രവർത്തനമെന്ന നിലയിൽ, ഓരോ വരിയുടെയും ദൈർഘ്യം നമുക്ക് ലഭിക്കും:

Awk "( പ്രിൻ്റ് നീളം )" letters.txt 1 2 3 4 3 2 1

ഈ പ്രവർത്തനം നിരുപാധികമായി മുഴുവൻ വരിയിലും ബാധകമാണ്. ഞങ്ങൾക്ക് ഇത് വ്യക്തമായി വ്യക്തമാക്കാനും കഴിയും:

Awk "( പ്രിൻ്റ് നീളം $0 )" letters.txt 1a 2bb 3ccc 4dddd 3ggg 2hh 1i

ഫയൽ ഇൻപുട്ട് ആരംഭിക്കുന്നതിന് മുമ്പും ഫയൽ പൂർത്തിയാക്കിയതിന് ശേഷവും ചില കോഡ് എക്സിക്യൂട്ട് ചെയ്യുന്നതിന് Awk-ന് പ്രത്യേക നിയന്ത്രണങ്ങളുണ്ട്.

Awk "BEGIN ( പ്രിൻ്റ് "HI" ) ( പ്രിൻ്റ് $0 ) END ( പ്രിൻ്റ് "BYE!" )" letters.txt HI a bb ccc dddd ggg hh i BYE!

നമുക്കു കഴിയും കൂടുതൽ ഘടകങ്ങൾഉപയോഗിച്ച് അച്ചടി സമയത്ത് നിയന്ത്രണം printf.

Awk "BEGIN ( printf "%-10s %s\n", "Name", "Number" \ printf "%-10s %s\n", "----", "------" ) \ ( printf "%-10s %s\n", $1, $2 )" മെയിൽ-ഡാറ്റയുടെ പേര് നമ്പർ ---- ------ അമേലിയ 555-5553 ആൻ്റണി 555-3412 ബെക്കി 555-7685 ബിൽ 555-1675 ബ്രോഡറിക്ക് 555-0542 കാമില 555-2912 ഫാബിയസ് 555-1234 ജൂലി 555-6699 മാർട്ടിൻ 555-6480 സാമുവൽ 555-3430 ജീൻ പോൾ 555-2127

സാമ്പിളുകളും പ്രവർത്തനങ്ങളും സംയോജിപ്പിക്കുന്നു

തീർച്ചയായും, പാറ്റേണുകളും ഫംഗ്‌ഷനുകളും സംയോജിപ്പിക്കാൻ കഴിയും, അതിനാൽ സ്ട്രിംഗ് പാറ്റേണുമായി പൊരുത്തപ്പെടുന്നെങ്കിൽ മാത്രമേ ഫംഗ്‌ഷൻ പ്രയോഗിക്കൂ.

2 പ്രതീകങ്ങളിൽ കൂടുതൽ നീളമുള്ള എല്ലാ വരികളുടെയും ദൈർഘ്യം നമുക്ക് പ്രിൻ്റ് ചെയ്യാം.

Awk "നീളം($0) > 2 ( പ്രിൻ്റ് നീളം($0) )" letters.txt 3 4 3

വാസ്തവത്തിൽ, ഞങ്ങൾ Awk-നെ ഒരു പാറ്റേണിൽ മാത്രം പരിമിതപ്പെടുത്തേണ്ടതില്ല! അർദ്ധവിരാമങ്ങളോ ന്യൂലൈനുകളോ ഉപയോഗിച്ച് വേർതിരിക്കപ്പെട്ട പാറ്റേണുകളുടെ അനിയന്ത്രിതമായ സംഖ്യ നമുക്ക് ഉണ്ടായിരിക്കാം:

Awk "നീളം($0) > 2 ("നീളം:" നീളം($0) ); നീളം($0)< 2 { print "Short: " length($0) }" letters.txt Short: 1 Long: 3 Long: 4 Long: 3 Short: 1

ധാരാളം വയലുകൾ

തുടർച്ചയായി നിരവധി ഫീൽഡുകളുള്ള ലളിതമായ ഡാറ്റ പ്രോസസ്സിംഗിനായി Awk രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്നു. ഫീൽഡ് സെപ്പറേറ്റർ കീ ഉപയോഗിച്ച് വ്യക്തമാക്കാം -എഫ്.

ഡിലിമിറ്റർ ഒരു സ്‌പെയ്‌സ് ആയ ഫയലിൻ്റെ ഉദാഹരണം:

Awk "( print )" field_data.txt റോസാപ്പൂക്കൾ ചുവപ്പാണ്, വയലറ്റുകൾ നീലയാണ്, പഞ്ചസാര മധുരമാണ്, അതുപോലെ നിങ്ങളും.

ഞങ്ങൾ ഒരു ഫീൽഡ് സെപ്പറേറ്റർ വ്യക്തമാക്കുകയാണെങ്കിൽ, ഓരോ വരിയുടെയും രണ്ടാമത്തെ ഫീൽഡ് നമുക്ക് പ്രിൻ്റ് ചെയ്യാം:

Awk -F " " "( പ്രിൻ്റ് $2 )" field_data.txt are are so

വരിയിൽ പൊരുത്തപ്പെടുന്ന ഫീൽഡ് ഇല്ലെങ്കിൽ ഞങ്ങൾക്ക് ഒരു പിശക് ലഭിക്കില്ല; ഞങ്ങൾ ഒരു ശൂന്യമായ വരി കാണിക്കും:

Awk -F " " "( പ്രിൻ്റ് $4 )" field_data.txt നിങ്ങൾ.

ഡിഫോൾട്ട് സെപ്പറേറ്റർ ഒരു സ്പേസ് ആയതിനാൽ, ഓപ്‌ഷൻ ഉപയോഗിക്കാതെ മുമ്പത്തെ കമാൻഡ് അതേ ഫലം തന്നെ നൽകുമായിരുന്നു -എഫ്.കൂടുതൽ അർത്ഥവത്തായ ഉദാഹരണത്തിനായി, നമുക്ക് മറ്റൊരു ഫയൽ സൃഷ്ടിക്കാം നിരക്കുകൾ.txtഇനിപ്പറയുന്ന ഉള്ളടക്കത്തോടൊപ്പം:

പിൽക്രോ, ഹംഫ്രി, 3 പിൽക്രോ, സോറ, 1 പ്ലീനസ്, ഓൾഡോൺ, 4 റസ്‌നിക്കി, ആൻ്റൺ, 7 റസ്സൽ, ബെർട്രാൻഡ്, 0

ഇപ്പോൾ നമ്മൾ ഒരു സെപ്പറേറ്ററായി സൂചിപ്പിക്കുന്നു , (കോമ) കൂടാതെ രണ്ടാമത്തെ നിരയിലെ ഉള്ളടക്കങ്ങൾ പ്രദർശിപ്പിക്കുക:

Awk -F "," "( പ്രിൻ്റ് $2 )" നിരക്കുകൾ.txt ഹംഫ്രി സോറ ഓൾഡോൺ ആൻ്റൺ ബെർട്രാൻഡ്

ഡിലിമിറ്റർ എക്സ്പ്രഷൻ ഒരു റെഗുലർ എക്സ്പ്രഷൻ ആയി വ്യാഖ്യാനിക്കപ്പെടുന്നു.

Awk -F "((അങ്ങനെ)? are|is) " "("ഫീൽഡ് 1 അച്ചടിക്കുക: " $1 "\nഫീൽഡ് 2: " $2)" field_data.txt ഫീൽഡ് 1: റോസസ് ഫീൽഡ് 2: ചുവപ്പ്, ഫീൽഡ് 1: വയലറ്റ് ഫീൽഡ് 2 : നീല, ഫീൽഡ് 1: പഞ്ചസാര ഫീൽഡ് 2: മധുരം, ഫീൽഡ് 1: ഒപ്പം ഫീൽഡ് 2: നിങ്ങൾ.

റെഗുലർ എക്സ്പ്രഷനുകൾ

പാറ്റേണുകൾ ബിൽറ്റ്-ഇൻ ഫംഗ്‌ഷനുകൾ മാത്രമല്ല, പതിവ് എക്‌സ്‌പ്രഷനുകളാകാം.

നമുക്ക് ഉപയോഗിക്കാം പതിവ് ഭാവങ്ങൾതുടർച്ചയായി 5 സ്വരാക്ഷരങ്ങളുള്ള Unix ലോകത്തിലെ എല്ലാ വാക്കുകളും കണ്ടെത്താൻ.

Awk "/(5)/" /usr/share/dict/words cadiueio Chaouia euouae Guauaenok

ഒരു പ്രോഗ്രാമിലേക്ക് വേരിയബിളുകൾ കൈമാറുന്നു

ഓപ്ഷൻ -വിപ്രോഗ്രാമിലേക്ക് വേരിയബിളുകൾ കൈമാറാൻ Awk ഞങ്ങളെ അനുവദിക്കുന്നു. ഉദാഹരണത്തിന്, ഹാർഡ് കോഡ് കോൺസ്റ്റൻ്റുകൾക്ക് ഇത് ഉപയോഗിക്കാം.

Awk -v pi=3.1415 "BEGIN (print pi )" 3.1415

നമുക്കും ഉപയോഗിക്കാം -വിബാഷ് വേരിയബിളുകൾ Awk വേരിയബിളുകളായി കൈമാറാൻ

Awk -v ഉപയോക്താവ്=$USER "BEGIN ( പ്രിൻ്റ് ഉപയോക്താവ് )" mial

എങ്കിൽ-മറ്റുള്ള പദപ്രയോഗങ്ങൾ

എങ്കിൽ-അല്ലെങ്കിൽ Awk-ലെ പദപ്രയോഗങ്ങൾ ഇതുപോലെ കാണപ്പെടുന്നു:

(അവസ്ഥ) ശരീരമാണെങ്കിൽ-അപ്പോൾ

ഉദാഹരണത്തിന്:

Printf "1\n2\n3\n4" | awk \ "( \ if ($1 % 2 == 0) പ്രിൻ്റ് $1, "ഇവൻ"; \ else പ്രിൻ്റ് $1, "ഒറ്റം" \ )" 1 ഒറ്റയടി 2 ആണ്, 3 ഒറ്റത് 4 ആണ്

സൈക്കിളുകൾ

Awk-ൽ നിരവധി ലൂപ്പ് എക്സ്പ്രഷനുകൾ ഉൾപ്പെടുന്നു: സമയത്ത്, സമയത്ത് ചെയ്യാൻഒപ്പം വേണ്ടി.

അവർക്ക് പ്രതീക്ഷിക്കുന്ന സി വാക്യഘടനയുണ്ട്.

Awk\"BEGIN(\i=0;\uveyle(i< 5) { print i; i+=1; } \ }" 0 1 2 3 4 awk \ "BEGIN { \ i = 0; \ do { print i; i+=1; } while(i < 0) \ }" 0 awk \ "BEGIN { \ i = 0; \ for(i = 0; i<5; i++) print i \ }" 0 1 2 3 4

വേണ്ടിഅറേ കീകൾ വഴി ഒരു ലൂപ്പ് നിർവചിക്കാനും കഴിയും, ഏത്പിന്നീട് ചർച്ച ചെയ്യും.

ഭാഗം അഞ്ച്: കോളിംഗ് ഫംഗ്‌ഷനുകൾ

AWK-യുടെ അടുത്ത ഘടകം അതിൻ്റെ എല്ലാ പ്രത്യേക ബിൽറ്റ്-ഇൻ ഫംഗ്ഷനുകളുമാണ്.

ശരാശരി സി പ്രോഗ്രാമറെ സന്തോഷിപ്പിക്കുന്ന ഫീച്ചറുകൾ AWK-യിലുണ്ട്. ഇവിടെ sin()/cos()/tan(), rand(),index(), sprintf(), tolower(), system() തുടങ്ങിയ കാര്യങ്ങൾ ഉണ്ട്.

ഫംഗ്‌ഷനുകൾ ഗ്രൂപ്പുചെയ്‌തിരിക്കുന്നു, അവ ഇനിപ്പറയുന്ന രീതിയിൽ കാണാൻ കഴിയും:

ഗണിതശാസ്ത്രം

+, -, /, *, sin(), cos(), tan(), Atan(), sqrt(), rand(), srand()

അവർ സ്വയം സംസാരിക്കുന്നു, കുറഞ്ഞത് ഞാൻ അങ്ങനെ ചിന്തിക്കാൻ ആഗ്രഹിക്കുന്നു.

Awk -v pi=3.1415 "BEGIN (print exp(1), log(exp(1)), sqrt(2), sin(pi), cos(pi), atan2(pi, 2) )" 2.71828 1 1.41421 9.26536 ഇ-05 -1 1.00387

പ്രോഗ്രാം സൃഷ്ടിക്കാൻ കഴിയും ക്രമരഹിത സംഖ്യപരിധിയിൽ (0, 1).

സ്ഥിരസ്ഥിതിയായി, Awk-ൻ്റെ അതേ ആരംഭത്തിൽ നിന്ന് (വിത്ത്) Awk ആരംഭിക്കുന്നു. ഈ കമാൻഡ് തുടർച്ചയായി രണ്ടുതവണ പ്രവർത്തിപ്പിക്കുന്നത് ഒരേ ഫലം നൽകും:

Awk "BEGIN (print rand(); print rand() )" 0.237788 0.291066

ആരംഭം (വിത്ത്) സജ്ജമാക്കാൻ നിങ്ങൾക്ക് സ്രാൻഡ് ഫംഗ്ഷൻ ഉപയോഗിക്കാം:

Awk "BEGIN (srand(10); print rand(); print rand() )" 0.255219 0.898883 awk "BEGIN (srand(10); print rand(); print rand() )" 0.255219 0.898883

ഫംഗ്ഷൻ int"x-നും പൂജ്യത്തിനും ഇടയിലുള്ള x-ൻ്റെ ഏറ്റവും അടുത്തുള്ള പൂർണ്ണസംഖ്യ, മുൻനിര പൂജ്യം ഉപേക്ഷിച്ച്" നൽകുന്നു.

Awk "BEGIN ( print "int(0.9) = " int(0.9); print "int(-0.9) = " int(-0.9) )" int(0.9) = 0 int(-0.9) = 0

സ്ട്രിംഗ് കൃത്രിമത്വം

സൂചിക()ഒരു സബ്‌സ്‌ട്രിംഗിനുള്ളിൽ എവിടെയാണ് ഒരു സ്ട്രിംഗ് സംഭവിക്കുന്നത് എന്ന് നിങ്ങളോട് പറയും.
പൊരുത്തം ()സമാനമാണ്, എന്നാൽ പതിവ് എക്സ്പ്രഷനുകൾക്കായി പ്രവർത്തിക്കുന്നു.
sprintf()ഔട്ട്പുട്ട് ഫോർമാറ്റ് ചെയ്യാനും വഴിയിൽ പരിവർത്തനം ചെയ്യാനും നിങ്ങൾക്ക് വഴികൾ നൽകുന്നു. C ഉപയോഗിച്ച് printf() ഉപയോഗിച്ചിട്ടുള്ള ആർക്കും ഇത് പരിചിതമായിരിക്കണം. ഉദാഹരണത്തിന്,

newsstring=sprintf("ഒന്ന് %d എന്ന സംഖ്യയാണ്, രണ്ട് എന്നത് ഒരു സ്ട്രിംഗാണ് %s\n", ഒന്ന്, രണ്ട്); ന്യൂസ്‌ട്രിംഗ് അച്ചടിക്കുക

"%d" പറയുന്നു "എനിക്ക് അനുയോജ്യമായ മൂല്യം ഒരു ദശാംശ സംഖ്യയായി അച്ചടിക്കുക"
"%s"എനിക്ക് അനുയോജ്യമായ മൂല്യം ഒരു സ്ട്രിംഗായി പ്രിൻ്റ് ചെയ്യുക" എന്ന് പറയുന്നു

ആ. ഇടവേളകളില്ലാതെ രണ്ട് വരികൾ കൂട്ടിച്ചേർക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, ഒരു മാർഗ്ഗം ഉപയോഗിക്കുക എന്നതാണ്

Newsstring=sprintf("%s%s", ഒന്ന്, രണ്ട്)

നീളം ()നിങ്ങൾക്ക് വേണമെങ്കിൽ ഒരു വരിയിലെ പ്രതീകങ്ങളുടെ എണ്ണം കണക്കാക്കാനുള്ള ഒരു എളുപ്പ മാർഗം നൽകുന്നു.

ഫംഗ്ഷൻ substr(s, m, n)സബ്‌സ്ട്രിംഗ് തിരികെ നൽകും എൻ- സ്ഥാനത്ത് നിന്ന് ആരംഭിക്കുന്ന പ്രതീകങ്ങൾ എം, 1 മുതൽ കണക്കാക്കുന്നു.

Awk "( പ്രിൻ്റ് $1, substr($1, 2, 3) )" field_data.txt റോസാപ്പൂക്കൾ അല്ലെങ്കിൽ വയലറ്റ്, പഞ്ചസാര എന്നിവയും nd

സൂചിക(കൾ, ടി)സ്ഥാനം തിരികെ നൽകുന്നു എസ്അതിൽ ലൈൻ സംഭവിക്കുന്നു ടി, അല്ലെങ്കിൽ അത് സംഭവിച്ചില്ലെങ്കിൽ 0.`

സൂചികയുടെ പാറ്റേൺ ഒരു സാധാരണ പദപ്രയോഗമല്ല.

Awk "( $1, index($1, "s") )" field_data.txt റോസസ് 3 വയലറ്റ് 7 പഞ്ചസാര 0 ഉം 0 ഉം

പൊരുത്തം(കൾ, ആർ)സ്ഥാനം തിരികെ നൽകുന്നു എസ്അതിൽ പതിവ് പദപ്രയോഗം സംഭവിക്കുന്നു ആർ, അല്ലെങ്കിൽ അത് സംഭവിച്ചില്ലെങ്കിൽ 0. വേരിയബിളുകൾ RSTARTഒപ്പം RLENGTHപൊരുത്തപ്പെടുന്ന സ്ട്രിംഗിൻ്റെ സ്ഥാനവും നീളവും സജ്ജീകരിച്ചിരിക്കുന്നു.

പൊരുത്തം- അതെങ്ങനെ സൂചികപാറ്റേൺ ഒരു സാധാരണ പദപ്രയോഗമാണ് എന്നതൊഴിച്ചാൽ.

Awk "( പ്രിൻ്റ് $1, match($1, "") )" field_data.txt റോസസ് 3 വയലറ്റ് 7 ഷുഗർ 1 കൂടാതെ 0 # "മൂന്നോ അതിലധികമോ ആവർത്തിക്കുന്ന അക്ഷരങ്ങൾ കണ്ടെത്തുക" awk "( പൊരുത്തം($1, "(3)"); പ്രിൻ്റ് ചെയ്യുക $1, "\tpattern start:", RSTART, "\tpattern end:", RLENGTH )" letters.txt ഒരു പാറ്റേൺ തുടക്കം: 0 പാറ്റേൺ അവസാനം: -1 bb പാറ്റേൺ ആരംഭം: 0 പാറ്റേൺ അവസാനം: -1 ccc പാറ്റേൺ ആരംഭം: 1 പാറ്റേൺ അവസാനം: 3 dddd പാറ്റേൺ ആരംഭം: 1 പാറ്റേൺ അവസാനം: 3 ggg പാറ്റേൺ ആരംഭം: 1 പാറ്റേൺ അവസാനം: 3 hh പാറ്റേൺ ആരംഭം: 0 പാറ്റേൺ അവസാനം: -1 i പാറ്റേൺ ആരംഭം: 0 പാറ്റേൺ അവസാനം: -1

സ്പ്ലിറ്റ്(കൾ, എ, എഫ്എസ്)ഒരു സ്ട്രിംഗ് മൂലകങ്ങളുടെ ഒരു നിരയായി വിഭജിക്കുന്നു a, a, ..., a, ഒപ്പം റിട്ടേണുകളും എൻ.

പതിവ് പദപ്രയോഗത്തിലൂടെയാണ് വിഭജനം നടത്തുന്നത് fsഅല്ലെങ്കിൽ ഫീൽഡ് സെപ്പറേറ്റർ ഉപയോഗിച്ച് എഫ്.എസ്, എങ്കിൽ fsകൊടുത്തിട്ടില്ല. ഒരു ഫീൽഡ് സെപ്പറേറ്റർ എന്ന നിലയിൽ ശൂന്യമായ സ്‌ട്രിംഗ് സ്‌ട്രിംഗിനെ പ്രതീകം അനുസരിച്ച് ഘടകങ്ങളുടെ ഒരു നിരയിലേക്ക് വിഭജിക്കുന്നു.
Awk "BEGIN ( പ്രിൻ്റ് സ്പ്ലിറ്റ്("ഇത്-ആയത്_മികച്ച_സമയങ്ങൾ", output_array, "[-_]"), output_array, output_array )" 6 മികച്ചതായിരുന്നു
ഉപ(r, t, s)ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുന്നു ടിപതിവ് പദപ്രയോഗത്തിൻ്റെ ആദ്യ സംഭവം ആർഇൻ ലൈൻ എസ്. s നൽകിയിട്ടില്ലെങ്കിൽ, ഉപയോഗിക്കുക $0

എസ്മാറ്റിസ്ഥാപിക്കൽ സംഭവിക്കുന്ന സ്ട്രിംഗ് ആണ്. മാറ്റിസ്ഥാപിക്കലിനൊപ്പം ഒരു പുതിയ സ്ട്രിംഗ് തിരികെ നൽകുന്നതിനുപകരം, മാറ്റിസ്ഥാപിച്ചവയുടെ എണ്ണം (0 അല്ലെങ്കിൽ 1) തിരികെ നൽകും.
Awk "BEGIN ( s = "ഇത് ഏറ്റവും മികച്ച സമയമായിരുന്നു, ഇത് ഏറ്റവും മോശം സമയമായിരുന്നു"; \ പ്രിൻ്റ് "എണ്ണം. പൊരുത്തങ്ങൾ മാറ്റിസ്ഥാപിച്ചു:", ഉപ("സമയം", "gifs", s); \ print s )" സംഖ്യ മത്സരങ്ങൾ മാറ്റിസ്ഥാപിച്ചു: 1 ഇത് gif-കളിൽ ഏറ്റവും മികച്ചതായിരുന്നു, ഇത് ഏറ്റവും മോശം സമയമായിരുന്നു
gsubപോലെ തന്നെ ചെയ്യുന്നു ഉപപതിവ് പദപ്രയോഗത്തിൻ്റെ എല്ലാ സംഭവങ്ങളും മാറ്റിസ്ഥാപിക്കുന്നു എന്നതൊഴിച്ചാൽ; ഉപഒപ്പം gsubപകരക്കാരുടെ എണ്ണം തിരികെ നൽകുക.
Awk "BEGIN ( s = "ഇത് ഏറ്റവും മികച്ച സമയമായിരുന്നു, അത് ഏറ്റവും മോശം സമയമായിരുന്നു"; \ പ്രിൻ്റ് "എണ്ണം. പൊരുത്തങ്ങൾ മാറ്റിസ്ഥാപിച്ചു:", gsub("times", "cats", s); \ print s )" സംഖ്യ പൊരുത്തങ്ങൾ മാറ്റിസ്ഥാപിച്ചു: 2 ഇത് പൂച്ചകളിൽ ഏറ്റവും മികച്ചതായിരുന്നു, ഇത് പൂച്ചകളിൽ ഏറ്റവും മോശമായിരുന്നു, sprintf sprintf(fmt, expr, ...) expr ഫോർമാറ്റിംഗ് ഫലമായുണ്ടാകുന്ന സ്ട്രിംഗ് നൽകുന്നു ... printf(3) ഫോർമാറ്റ് fmt awk "BEGIN അനുസരിച്ച് ( x = sprintf("[%8.3f]", 3.141592654); പ്രിൻ്റ് x )" [3.142]
സിസ്റ്റം ലെവൽ പ്രവർത്തനങ്ങൾ

സിസ്റ്റം()സിസ്റ്റത്തിൽ എക്സിക്യൂട്ടബിൾ സാധ്യമായ ഏതൊരു ഫയലും വിളിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു. ടാർഗെറ്റ് പ്രോഗ്രാം നിങ്ങളിലായിരിക്കാം $PATH, അല്ലെങ്കിൽ ഒരു സമ്പൂർണ്ണ പാത ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഇത് വ്യക്തമാക്കാൻ കഴിയും.

ഉദാഹരണത്തിന്, ഭയപ്പെടുത്തുന്ന
സിസ്റ്റം("rm -rf $HOME");
സിസ്റ്റം("/ബിൻ/കിൽ 1")
നിങ്ങൾക്ക് കൂടുതൽ സങ്കീർണ്ണമായ കാര്യങ്ങൾ ചെയ്യാൻ താൽപ്പര്യമുണ്ടെങ്കിൽ, ഒരുപക്ഷേ നിങ്ങൾ ഇതുപോലുള്ള എന്തെങ്കിലും ചെയ്യുന്നത് അവസാനിപ്പിക്കും
Sysstring=sprintf("somecommand %s %s", arg1, arg2); സിസ്റ്റം (സിസ്‌ട്രിംഗ്)
അടയ്ക്കുക()പലപ്പോഴും അവഗണിക്കപ്പെടുന്ന ഒരു പ്രധാന സവിശേഷതയാണ്. വ്യക്തമായ വിളി ഇല്ലാത്തതുകൊണ്ടാകാം ഇത് തുറക്കുക(), അതുകൊണ്ടാണ് ആളുകൾ വെല്ലുവിളിയെക്കുറിച്ച് ചിന്തിക്കാത്തത് അടയ്ക്കുക(). മിക്ക ആവശ്യങ്ങൾക്കും ഇത് ആവശ്യമില്ല. എന്നാൽ നിങ്ങൾ ഒന്നിലധികം ഔട്ട്‌പുട്ട് ഫയലുകൾ കൈകാര്യം ചെയ്യുകയാണെങ്കിൽ നിങ്ങൾ ഇത് ചെയ്യണം.

ഈച്ചയിൽ ഒരു അനിയന്ത്രിതമായ ഫയൽ തുറക്കാനുള്ള കഴിവ് Awk നിങ്ങൾക്ക് നൽകുന്നു. ഉദാഹരണത്തിന്
/^file/ ( പ്രിൻ്റ് $3 >> $2 )
"ഫയൽ ഔട്ട്പുട്ട് ഹിയർ-ഇസ്-എ-വേഡ്" എന്ന വരി എടുക്കണം, "ഔട്ട്പുട്ട്" ഫയൽ തുറന്ന് അതിൽ "ഇവിടെ-എ-വേഡ്" എന്ന് പ്രിൻ്റ് ചെയ്യണം.

AWK "സ്മാർട്ട്" ആണ്, അതിൽ നിങ്ങൾ ഏതൊക്കെ ഫയലുകളാണ് തുറക്കുന്നതെന്ന് ട്രാക്ക് ചെയ്യുകയും അവ തുറന്ന് സൂക്ഷിക്കുകയും ചെയ്യുന്നു. നിങ്ങൾ ഒരിക്കൽ ഫയൽ തുറന്നാൽ, ഒരുപക്ഷേ നിങ്ങൾ അത് വീണ്ടും ചെയ്യുമെന്ന് കരുതുന്നു. നിർഭാഗ്യവശാൽ, നിങ്ങൾ ധാരാളം ഫയലുകൾ തുറക്കുകയാണെങ്കിൽ, നിങ്ങൾക്ക് ഫയൽ ഡിസ്ക്രിപ്റ്ററുകൾ തീർന്നുപോയേക്കാം എന്നാണ് ഇതിനർത്ഥം. അതിനാൽ നിങ്ങൾ ഒരു ഫയൽ പൂർത്തിയാക്കിയെന്ന് അറിയുമ്പോൾ, അത് അടയ്ക്കുക. അതിനാൽ മുകളിലുള്ള ഉദാഹരണം മെച്ചപ്പെടുത്തുന്നതിന്, ഇനിപ്പറയുന്ന വരികൾ പോലെയുള്ള ഒന്ന് നിങ്ങൾ ഉപയോഗിക്കണം:
/^file/ (($2 != പഴയ ഫയൽ ആണെങ്കിൽ) (അടയ്ക്കുക(പഴയ ഫയൽ) ); $3 >> $2 പ്രിൻ്റ് ചെയ്യുക; പഴയ ഫയൽ = $2;)
ഭാഗം ആറ്: അണികൾ

അറേ ആശയം

ഒരു മൂല്യം ഉൾക്കൊള്ളുന്ന പേരുകളായി ഞങ്ങൾ ഇതിനകം വേരിയബിളുകൾ നോക്കിയിട്ടുണ്ട്. അറേകൾ വേരിയബിളുകളുടെ ഒരു വിപുലീകരണമാണ്. ഒന്നിലധികം മൂല്യങ്ങൾ ഉൾക്കൊള്ളുന്ന വേരിയബിളുകളാണ് അറേകൾ. ഓരോ മൂല്യത്തിനും അതിൻ്റേതായ നമ്പർ ഉള്ളതിനാൽ അവയ്ക്ക് ഒന്നിലധികം മൂല്യങ്ങൾ അടങ്ങിയിരിക്കാം.

നിങ്ങൾക്ക് മൂന്ന് മൂല്യങ്ങൾ വേണമെങ്കിൽ, നിങ്ങൾക്ക് ഇങ്ങനെ പറയാം:
മൂല്യം1="ഒന്ന്"; മൂല്യം2="രണ്ട്"; മൂല്യം3="മൂന്ന്";
അല്ലെങ്കിൽ, നിങ്ങൾക്ക് ഉപയോഗിക്കാം
മൂല്യങ്ങൾ="ഒന്ന്"; മൂല്യങ്ങൾ="രണ്ട്"; മൂല്യങ്ങൾ = "മൂന്ന്";
സ്വന്തം പേരുകളുള്ള മൂന്ന് വ്യത്യസ്ത വേരിയബിളുകളാണ് ആദ്യ ഉദാഹരണം (അത് ഒരു പ്രതീകം കൊണ്ട് വ്യത്യാസപ്പെട്ടിരിക്കുന്നു). രണ്ടാമത്തെ ഉദാഹരണം ഒരു വേരിയബിൾ ഉൾക്കൊള്ളുന്ന ഒരു അറേയാണ്, എന്നാൽ നിരവധി മൂല്യങ്ങൾ അടങ്ങിയിരിക്കുന്നു, അവയിൽ ഓരോന്നിനും അതിൻ്റേതായ സംഖ്യയുണ്ട്.

ഒരു വേരിയബിൾ ഒരു അറേ ആയി ഉപയോഗിക്കുമ്പോൾ, നിങ്ങൾ എല്ലായ്പ്പോഴും മൂല്യം ചതുര ബ്രാക്കറ്റുകളിൽ ഉൾപ്പെടുത്തണം. ഒരു അറേ വേരിയബിളിനായി നിങ്ങൾക്ക് ഏത് പേരും തിരഞ്ഞെടുക്കാം, എന്നാൽ ഇനി മുതൽ ആ പേര് ഒരു അറേയ്‌ക്ക് മാത്രമേ ഉപയോഗിക്കാൻ കഴിയൂ. നിങ്ങൾക്ക് അർത്ഥവത്തായ ഒന്നും ചെയ്യാൻ കഴിയില്ല
മൂല്യങ്ങൾ="ഒന്ന്"; മൂല്യങ്ങൾ = "പുതിയ മൂല്യം";
എന്നിരുന്നാലും, സാധാരണ വേരിയബിളുകൾക്കായി നിങ്ങൾക്ക് മൂല്യങ്ങൾ വീണ്ടും നൽകാം. ആ. ഇനിപ്പറയുന്നവ ശരിയാണ്:
മൂല്യങ്ങൾ="1"; പ്രിൻ്റ് മൂല്യങ്ങൾ; മൂല്യങ്ങൾ="ഒന്ന്"; പ്രിൻ്റ് മൂല്യങ്ങൾ;
രസകരമായ കാര്യം, മറ്റ് ചില ഭാഷകളിൽ നിന്ന് വ്യത്യസ്തമായി, അക്കങ്ങൾ മാത്രം ഉപയോഗിക്കാൻ നിങ്ങൾ നിർബന്ധിതരല്ല എന്നതാണ്. മുകളിലുള്ള ഉദാഹരണങ്ങളിൽ, , യഥാർത്ഥത്തിൽ [“1”], [“2”], [“3”] എന്നിങ്ങനെ വ്യാഖ്യാനിക്കപ്പെടുന്നു. നിങ്ങൾക്ക് മറ്റ് സ്‌ട്രിംഗുകളും ഐഡൻ്റിഫയറുകളായി ഉപയോഗിക്കാമെന്നും അറേയെ ഏതാണ്ട് ഒരു കോളം ഡാറ്റാബേസ് പോലെ പരിഗണിക്കാമെന്നും ഇതിനർത്ഥം. ഇതിൻ്റെ ഔദ്യോഗിക നാമം "അസോസിയേറ്റഡ് അറേ" എന്നാണ്.
അക്കങ്ങൾ["ഒന്ന്"]=1; അക്കങ്ങൾ ["രണ്ട്"]=2; പ്രിൻ്റ് നമ്പറുകൾ["ഒന്ന്"]; മൂല്യം="(! LANG:രണ്ട്"; print numbers; value=$1; if(numbers = ""){ print "no such number"; } !}
അറേകൾ എപ്പോൾ, എങ്ങനെ ഉപയോഗിക്കണം

നിങ്ങൾക്ക് അറേകൾ ഉപയോഗിക്കാൻ തിരഞ്ഞെടുക്കാവുന്ന വിവിധ സന്ദർഭങ്ങൾ ഉണ്ടാകാം. ചില ആളുകൾ, awk-ൽ പ്രവർത്തിക്കുമ്പോൾ, അറേകൾ ഇല്ലാതെ തന്നെ ചെയ്യുന്നു. എന്നാൽ ഇത് പൂർണ്ണമായും ശരിയായ സ്ഥാനമല്ല: അറേകൾക്ക് പ്രത്യേക വേരിയബിളുകൾ ഉണ്ട്, ഉദാഹരണത്തിന്, അതിൻ്റെ വലുപ്പം (അറേയിലെ മൂല്യങ്ങളുടെ എണ്ണം) കാണിക്കുന്നു, അറേ അംഗങ്ങളെ കണക്കാക്കാൻ സൗകര്യപ്രദമായ നിർമ്മാണങ്ങളുണ്ട്, ചില പ്രവർത്തനങ്ങൾ ഒരു മൂല്യം നൽകുന്നു. ഒരു ശ്രേണിയുടെ രൂപത്തിൽ. എന്തായാലും, ഉപയോഗപ്രദമായേക്കാവുന്ന ചില ഉദാഹരണങ്ങൾ നോക്കാം.

പിന്നീടുള്ള ഉപയോഗത്തിനായി വിവരങ്ങൾ സംരക്ഷിക്കുന്നു

ഒരു വലിയ ഷെൽ സ്ക്രിപ്റ്റിൽ awk ഉപയോഗിക്കുമ്പോൾ, നിങ്ങൾക്ക് വിവരങ്ങൾ ഒരു താൽക്കാലിക ഫയലിലേക്ക് സംരക്ഷിക്കാൻ കഴിയും. എന്നാൽ നിങ്ങൾക്ക് ആവശ്യമുള്ള പദങ്ങൾ മെമ്മറിയിലേക്ക് സംരക്ഷിക്കുകയും അവസാനം അവയെല്ലാം പ്രിൻ്റ് ചെയ്യുകയും ചെയ്യാം, ഇത് ഒരു താൽക്കാലിക ഫയൽ ഉപയോഗിക്കുന്നതിനേക്കാൾ വേഗതയുള്ളതായിരിക്കും.
/പ്രത്യേക/(സംരക്ഷിച്ച വാക്കുകൾ=$2; lnum+=1; ) END (എണ്ണം=0; അതേസമയം(സംരക്ഷിച്ച വാക്കുകൾ != "") ( പ്രിൻ്റ് എണ്ണം, സംരക്ഷിച്ച വാക്കുകൾ; എണ്ണം+=1; ) )
വാക്കുകൾ ലളിതമായി പ്രദർശിപ്പിക്കുന്നതിനുപകരം, അവ പ്രദർശിപ്പിക്കുന്നതിന് മുമ്പ് നിങ്ങൾക്ക് ആവശ്യമായേക്കാവുന്ന ഏതെങ്കിലും അധിക പ്രോസസ്സിംഗ് ചെയ്യാൻ നിങ്ങൾക്ക് END വിഭാഗം ഉപയോഗിക്കാം.

നിങ്ങൾക്ക് മൂല്യങ്ങൾക്ക് ഒരു അദ്വിതീയ സൂചിക നൽകണമെങ്കിൽ (ഡ്യൂപ്ലിക്കേറ്റുകൾ ഒഴിവാക്കാൻ), നിങ്ങൾക്ക് അവയുടെ മൂല്യങ്ങൾ അവയുടെ സ്വന്തം വരികൾ ഉപയോഗിച്ച് റഫർ ചെയ്യാം. അല്ലെങ്കിൽ, ഉദാഹരണത്തിന്, കോളം 3-ൽ ഒരു അറേ സംരക്ഷിക്കുക, കോളം 2-ലെ അനുബന്ധ മൂല്യത്താൽ സൂചികയിലാക്കിയിരിക്കുന്നു.
(ത്രീകോൾ[$2]=$3 ) END ( (വി ഇൻ ത്രീകോൾ) (പ്രിൻ്റ് വി, ത്രീകോൾ[വി] ) )
അറേകളും വിഭജനവും()

നിങ്ങൾക്ക് ഉപഫീൽഡുകൾ ചെയ്യണമെങ്കിൽ അറേകൾ ഉപയോഗിക്കാനുള്ള മറ്റൊരു പ്രധാന കാരണം. നിങ്ങൾക്ക് നിരവധി വലിയ ഡിവിഷനുകളും നിരവധി ചെറിയ ഡിവിഷനുകളും ഉള്ള ഒരു വരി ഉണ്ടെന്ന് പറയാം. മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, ടോപ്പ് ലെവൽ ഫീൽഡുകൾ സ്‌പെയ്‌സുകളാൽ വേർതിരിക്കപ്പെടുന്നു, എന്നാൽ കോളണുകളാൽ വേർതിരിക്കുന്ന ചെറിയ വാക്കുകൾ നിങ്ങൾക്ക് ലഭിക്കും.
ഇതൊരു വേരിയബിളാണ്: ഫീൽഡ്: ടൈപ്പ് ലൈൻ ഇവിടെ ഒന്നിലധികം: തരം: മൂല്യങ്ങൾ ഉണ്ടാകാം
മുകളിലെ ഉദാഹരണത്തിൽ, ഒരു സ്‌പെയ്‌സ് കൊണ്ട് വേർതിരിക്കുന്ന നാലാമത്തെ ഫീൽഡിന് കോളണുകളാൽ വേർതിരിക്കുന്ന ഉപഫീൽഡുകളുണ്ട്. ഇപ്പോൾ, നാലാമത്തെ വലിയ ഫീൽഡിലെ രണ്ടാമത്തെ സബ്ഫീൽഡിൻ്റെ മൂല്യം നിങ്ങൾക്ക് അറിയണമെന്ന് പറയാം. ഇത് ചെയ്യാനുള്ള ഒരു മാർഗ്ഗം ഒരു പൈപ്പ് വഴി ബന്ധിപ്പിച്ചിരിക്കുന്ന രണ്ട് awks വിളിക്കുക എന്നതാണ്:
Awk "($4 പ്രിൻ്റ് ചെയ്യുക)" | awk -F: "($2 അച്ചടിക്കുക)"
ഫീൽഡ് സെപ്പറേറ്റർ അടങ്ങിയിരിക്കുന്ന ഫ്ലൈയിലെ "FS" മൂല്യം മാറ്റുക എന്നതാണ് മറ്റൊരു മാർഗം (പ്രത്യക്ഷമായും ഇത് എല്ലാ awk നടപ്പിലാക്കലുകളിലും പ്രവർത്തിക്കില്ല):
Awk "( newline=$4; fs=FS; FS=":"; $0=newline; പ്രിൻ്റ് $2 ; FS=fs; )"
എന്നാൽ ഇതുപോലുള്ള സ്പ്ലിറ്റ്() ഫംഗ്ഷൻ ഉപയോഗിച്ച് നിങ്ങൾക്ക് അറേകൾ ഉപയോഗിച്ചും ഇത് ചെയ്യാൻ കഴിയും:
Awk "( newline=$4; split(newline,subfields,":"); print subfields) "
ഈ സാഹചര്യത്തിൽ, ഒരു അറേ ഉപയോഗിക്കുന്നത് ഏറ്റവും സാധാരണവും ഒരുപക്ഷേ ഏറ്റവും ഗംഭീരവുമായ മാർഗമാണ്.

അതിനാൽ, Awk പരിമിതമായ എണ്ണം ഡാറ്റാ ഘടനകൾ നൽകുന്നു. സ്കെയിലർ, സ്ട്രിംഗ് വേരിയബിളുകൾ എന്നിവ കൂടാതെ, ഭാഷയ്ക്ക് ഒരു ബിൽറ്റ്-ഇൻ വലിയ ഡാറ്റാ ഘടനയുണ്ട്. ഔദ്യോഗികമായി "അറേകൾ" എന്ന് വിളിക്കപ്പെടുന്നുണ്ടെങ്കിലും, ഈ ഘടന യഥാർത്ഥത്തിൽ പൈത്തണിലെ ഡിക്റ്റ് ഡാറ്റ ഘടനയ്ക്ക് സമാനമായ ഒരു അനുബന്ധ ശ്രേണിയാണ്.

അറേകൾ ഇനിഷ്യലൈസ് ചെയ്യേണ്ടതില്ല. നിങ്ങൾക്ക് മൂല്യങ്ങൾ അസൈൻ ചെയ്യാൻ തുടങ്ങാം. കീകൾ അക്കങ്ങളോ സ്ട്രിംഗുകളോ ആകാം എന്നത് ശ്രദ്ധിക്കുക.
Awk "BEGIN ( \ a = 1.1; \ a = 0; \ a [" DOG"] = "CAT"; \ print a, a, a ["DOG"] \ )" 1.1 0 CAT
ഒരു സൂചിക ഇല്ലാതെ Awk ഒരു വേരിയബിൾ പ്രിൻ്റ് ചെയ്യില്ല:
Awk "BEGIN ( \a["DOG"] = "CAT"; \print a\ )" awk: cmd. line:3: fatal: ഒരു സ്കെയിലർ സന്ദർഭത്തിൽ അറേ `a" ഉപയോഗിക്കാനുള്ള ശ്രമം
കീ ഉപയോഗിച്ച് നമുക്ക് ലൂപ്പ് ചെയ്യാമെങ്കിലും വേണ്ടി:
Awk "BEGIN ( \ a = 1.1; \ a = 0; \ a [" DOG"] = "CAT"; \ for(k in a) print(a[k]) \ )" CAT 0 1.1
ഭാഗം ഏഴ്: AWK, ഷെല്ലുകൾ (sh/ksh/bash/csh)

ചിലപ്പോൾ AWK യുടെ പ്രവർത്തനം മതിയാകണമെന്നില്ല. ഈ സാഹചര്യത്തിൽ, നിങ്ങൾക്ക് നിങ്ങളുടെ ഷെൽ സ്ക്രിപ്റ്റിലേക്ക് awk സംയോജിപ്പിക്കാൻ കഴിയും. ഇത് എങ്ങനെ ചെയ്യാമെന്നതിൻ്റെ ചില ഉദാഹരണങ്ങൾ ചുവടെയുണ്ട്.

ലളിതമായ ഉപസംഹാരം

ചിലപ്പോൾ നിങ്ങൾക്ക് awk ഒരു ഫോർമാറ്ററായി ഉപയോഗിക്കാനും ഔട്ട്‌പുട്ട് നേരിട്ട് ഉപയോക്താവിന് നൽകാനും താൽപ്പര്യപ്പെടുന്നു. ഇനിപ്പറയുന്ന സ്‌ക്രിപ്റ്റ് ഒരു ഉപയോക്തൃനാമം ഒരു ആർഗ്യുമെൻ്റായി എടുക്കുകയും ഉപയോക്താവിൻ്റെ വിവരങ്ങൾ /etc/passwd-ൽ നിന്ന് ഡംപ് ചെയ്യാൻ awk ഉപയോഗിക്കുകയും ചെയ്യുന്നു.

കുറിപ്പ്: സ്ക്രിപ്റ്റിൽ സിംഗിൾ ഉദ്ധരണികൾ വികസിപ്പിച്ചിരിക്കുന്നു (നെസ്റ്റ് ചെയ്തിട്ടില്ല) കൂടാതെ രണ്ട് വിപുലീകരിച്ച ജോഡി സിംഗിൾ ഉദ്ധരണികൾക്കിടയിൽ $1 (രണ്ടാമത്തേത്) വേരിയബിൾ ഉണ്ട്, ഈ സാഹചര്യത്തിൽ സ്ക്രിപ്റ്റ് ആർഗ്യുമെൻ്റ് ആണ്, $1 എന്നത് വാക്യഘടനയുടെ ഭാഗമാണ്. $1 (ലൈനിലെ ആദ്യ ഫീൽഡ് എന്നാണ് അർത്ഥമാക്കുന്നത്).
#!/bin/sh അതേസമയം [ "$1" != "" ] ; do awk -F: "$1 == ""$1"" ( $1,$3 പ്രിൻ്റ് ചെയ്യുക) " /etc/passwd shift ചെയ്തു
awk ഔട്ട്പുട്ട് ഷെൽ വേരിയബിളുകൾ അസൈൻ ചെയ്യുന്നു

ഒരു വേരിയബിളിൻ്റെ മൂല്യം സജ്ജീകരിക്കുന്നതിനുള്ള ദ്രുത മാർഗത്തിനായി ചിലപ്പോൾ ഞങ്ങൾ awk ഉപയോഗിക്കാൻ ആഗ്രഹിക്കുന്നു. പാസ്‌വേഡ് തീം ഉപയോഗിച്ച്, ഉപയോക്താവിനുള്ള ഷെൽ കണ്ടെത്താനും അത് ഔദ്യോഗിക ഷെല്ലുകളുടെ പട്ടികയിൽ ഉണ്ടോ എന്ന് നോക്കാനും ഞങ്ങൾക്ക് ഒരു മാർഗമുണ്ട്.

വീണ്ടും, awk എക്‌സ്‌പ്രഷനിൽ സിംഗിൾ ഉദ്ധരണികൾ എങ്ങനെ അടച്ചിരിക്കുന്നുവെന്ന് ശ്രദ്ധിക്കുക. അടച്ച (രണ്ടാം) ഉദ്ധരണിക്ക് ശേഷം, $1 എന്നത് സ്‌ക്രിപ്റ്റിലേക്ക് ആദ്യ ആർഗ്യുമെൻ്റിൻ്റെ മൂല്യം കൈമാറുന്ന ഒരു വേരിയബിളാണ്, awk വാക്യഘടനയുടെ ഭാഗമല്ല.
#!/bin/sh ഉപയോക്താവ് = "$1" എങ്കിൽ [ "$user" == "" ] ; തുടർന്ന് പ്രതിധ്വനി പിശക്: ഒരു ഉപയോക്തൃനാമം ആവശ്യമാണ് ; പുറത്ത് ; fi usershell=`awk -F: "$1 == ""$1"" ( പ്രിൻ്റ് $7) " /etc/passwd` grep -l $usershell /etc/shells എങ്കിൽ [ $? -ne 0 ] ; തുടർന്ന് പ്രതിധ്വനി പിശക്: $user എന്ന ഉപയോക്താവിനുള്ള ഷെൽ $usershell /etc/shells fi-ൽ അല്ല
മറ്റ് ഇതരമാർഗങ്ങൾ:
# "man regex" usershell=`awk -F കാണുക: "/^"$1":/ ( പ്രിൻ്റ് $7) " /etc/passwd` echo $usershell; # ആധുനിക awk മാത്രമേ സ്വീകരിക്കുകയുള്ളൂ -v. നിങ്ങൾ "nawk" അല്ലെങ്കിൽ "gawk" usershell2=`awk -F: -v ഉപയോക്താവ്=$1 "$1 == ഉപയോക്താവ് ($7 അച്ചടിക്കുക) " /etc/passwd` echo $usershell2;
മുകളിലുള്ള അധിക രീതികൾ വിശദീകരിക്കുന്നത് വായനക്കാരൻ്റെ ഗൃഹപാഠമായി അവശേഷിക്കുന്നു :)

പൈപ്പ് വഴി awk-ലേക്ക് ഡാറ്റ കൈമാറുന്നു

ചിലപ്പോൾ നിങ്ങൾ awk ഒരു ഡാറ്റ ഫിൽട്ടറായോ ഒരു വലിയ പ്രോഗ്രാമിലോ ഷെൽ പ്രോംപ്റ്റിൽ നൽകിയ ഒരു വൺ-ലൈൻ കമാൻഡായോ ഇടാൻ ആഗ്രഹിക്കുന്നു. ഒരു സ്ക്രിപ്റ്റിലെ അത്തരമൊരു കമാൻഡിൻ്റെ ഒരു ഉദാഹരണം (വെബ് സെർവർ ലോഗ് ഫയലുകളുടെ ഒരു ലിസ്റ്റ് സ്ക്രിപ്റ്റിലേക്ക് ആർഗ്യുമെൻ്റുകളായി കൈമാറുന്നു, കാരണം ലോഗിംഗ് ഇഷ്ടാനുസൃതമാക്കാവുന്നതും ലോഗുകൾക്ക് വ്യത്യസ്തമായ ഘടനയും ഉണ്ടായിരിക്കാം; ഇത് നിർദ്ദിഷ്ട സന്ദർഭങ്ങളിൽ പ്രവർത്തിക്കുന്നതിന്, ഇത് കമാൻഡുകൾ ക്രമീകരിക്കേണ്ടത് ആവശ്യമാണ്):
#!/bin/sh grep -h " /index.html" $* | awk -F\" "($4 പ്രിൻ്റ് ചെയ്യുക)" | അടുക്കുക -u

രസകരമായ ലേഖനം, നിങ്ങളുടെ ശ്രമങ്ങൾക്ക് നന്ദി പറയാൻ ഞാൻ ആഗ്രഹിക്കുന്നു.

അത് കൃത്യമല്ലെന്ന് ഞാൻ കണ്ടെത്തി. നിങ്ങൾ ഉദാഹരണത്തിൽ നിന്നുള്ള ലൈൻ എക്സിക്യൂട്ട് ചെയ്യുകയാണെങ്കിൽ
Awk -F " " "( പ്രിൻ്റ് $2 )" field_data.txt
അത് അതേ കാര്യം തന്നെ ഔട്ട്പുട്ട് ചെയ്യും
Awk "( പ്രിൻ്റ് $2 )" field_data.txt
ഫലം ഒരു ഉദാഹരണമാണ് -എഫ്നന്നായി വിവരിച്ചിട്ടില്ല.

വിചിത്രമായ പേരുള്ള ഒരു അത്ഭുതകരമായ ഭാഷയുടെ ആമുഖം

ഉള്ളടക്ക പരമ്പര:

awk-ൻ്റെ പ്രതിരോധത്തിൽ
ഈ ലേഖന പരമ്പരയിൽ, ഞാൻ വായനക്കാരനെ ഒരു വിദഗ്ദ്ധ awk പ്രോഗ്രാമർ ആക്കാൻ പോകുന്നു. awk-ന് ഏറ്റവും നല്ലതോ ട്രെൻഡിയോ ആയ പേരില്ലെന്ന് ഞാൻ സമ്മതിക്കുന്നു, gawk എന്ന് വിളിക്കപ്പെടുന്ന awk-ൻ്റെ GNU പതിപ്പ് തികച്ചും വിചിത്രമായി തോന്നുന്നു. ഭാഷ അറിയാത്ത പ്രോഗ്രാമർമാർ അതിൻ്റെ പേര് കേൾക്കുകയും, ഏറ്റവും അറിവുള്ള UNIX സ്പെഷ്യലിസ്റ്റിനെപ്പോലും ഭ്രാന്തന്മാരാക്കാൻ കഴിയുന്ന പുരാതനവും കാലഹരണപ്പെട്ടതുമായ ഒരു കോഡ് സങ്കൽപ്പിക്കുകയും ചെയ്യാം ("കൊല്ലുക -9!" എന്ന് വിളിച്ചുപറയുകയും നിരന്തരം കാപ്പി കുടിക്കാൻ ഓടുകയും ചെയ്യും).
അതെ, awk-ന് മികച്ച പേരില്ല. പക്ഷേ അതിമനോഹരമായ ഭാഷയാണ്. Awk ടെക്‌സ്‌റ്റ് പ്രോസസ്സിംഗിനും റിപ്പോർട്ടിംഗിനുമായി രൂപകൽപ്പന ചെയ്‌തിട്ടുള്ളതാണ്, എന്നാൽ ഗുരുതരമായ പ്രോഗ്രാമിംഗ് പ്രവർത്തനക്ഷമമാക്കുന്ന നിരവധി നന്നായി വികസിപ്പിച്ച സവിശേഷതകളുണ്ട്. എന്നിരുന്നാലും, മറ്റ് ചില ഭാഷകളിൽ നിന്ന് വ്യത്യസ്തമായി, awk-ൻ്റെ വാക്യഘടന പരിചിതമാണ് കൂടാതെ C, python, bash പോലുള്ള ഭാഷകളിൽ നിന്ന് ഏറ്റവും മികച്ചത് കടമെടുക്കുന്നു (പൈത്തണിനും ബാഷിനും മുമ്പാണ് ഔക്ക് ഔദ്യോഗികമായി സൃഷ്ടിക്കപ്പെട്ടതെങ്കിലും). പഠിച്ചുകഴിഞ്ഞാൽ, ഒരു പ്രോഗ്രാമറുടെ തന്ത്രപരമായ ആയുധശേഖരത്തിൻ്റെ പ്രധാന ഭാഗമായി മാറുന്ന ഭാഷകളിൽ ഒന്നാണ് Awk.
awk-ലെ ആദ്യ പടി
നമുക്ക് ആരംഭിക്കാം, അത് എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് കാണാൻ awk ഉപയോഗിച്ച് പരീക്ഷിച്ചുനോക്കൂ. കമാൻഡ് ലൈനിൽ, ഇനിപ്പറയുന്ന കമാൻഡ് നൽകുക:
$awk "( പ്രിൻ്റ് )" /etc/passwd
ഫലം /etc/passwd ഫയലിൻ്റെ ഉള്ളടക്കം കാണിക്കണം. ഇപ്പോൾ - awk ചെയ്തതിൻ്റെ ഒരു വിശദീകരണം. awk-ലേക്ക് വിളിക്കുമ്പോൾ, ഇൻപുട്ട് ഫയലായി ഞങ്ങൾ /etc/passwd സൂചിപ്പിച്ചു. ഞങ്ങൾ awk പ്രവർത്തിപ്പിക്കുമ്പോൾ, അത് /etc/passwd എന്ന ക്രമത്തിൽ ഓരോ വരിയുടെയും പ്രിൻ്റ് കമാൻഡ് പ്രോസസ്സ് ചെയ്തു. എല്ലാ ഔട്ട്‌പുട്ടും stdout-ലേക്ക് അയയ്‌ക്കുന്നു, ഞങ്ങൾക്ക് cat /etc/passwd-ൻ്റെ അതേ ഫലം ലഭിക്കും. ഇനി നമുക്ക് (പ്രിൻ്റ്) ബ്ലോക്ക് വിശദീകരിക്കാം. awk-ൽ ബ്രേസുകൾ C ലെ പോലെ ടെക്‌സ്‌റ്റ് ബ്ലോക്കുകളെ ഗ്രൂപ്പുചെയ്യാൻ ഉപയോഗിക്കുന്നു. ഞങ്ങളുടെ ടെക്‌സ്‌റ്റ് ബ്ലോക്കിന് ഒരു പ്രിൻ്റ് കമാൻഡ് മാത്രമേയുള്ളൂ. awk-ൽ, അധിക പാരാമീറ്ററുകളില്ലാത്ത പ്രിൻ്റ് കമാൻഡ് മുഴുവൻ ഉള്ളടക്കങ്ങളും പ്രിൻ്റ് ചെയ്യുന്നു നിലവിലെ ലൈൻ.
ഇതേ കാര്യം ചെയ്യുന്ന awk പ്രോഗ്രാമിൻ്റെ മറ്റൊരു ഉദാഹരണം ഇതാ:
$awk "( പ്രിൻ്റ് $0 )" /etc/passwd
awk-ൽ, $0 എന്ന വേരിയബിൾ നിലവിലെ ലൈനിനെ പ്രതിനിധീകരിക്കുന്നു, അതിനാൽ $0 പ്രിൻ്റ് ചെയ്‌ത് പ്രിൻ്റ് ചെയ്യുക. നിങ്ങൾക്ക് താൽപ്പര്യമുണ്ടെങ്കിൽ, ഇൻപുട്ട് ഡാറ്റയുമായി പൂർണ്ണമായും ബന്ധമില്ലാത്ത ഡാറ്റ ഔട്ട്‌പുട്ട് ചെയ്യുന്ന ഒരു പ്രോഗ്രാം awk-ൽ നിങ്ങൾക്ക് സൃഷ്ടിക്കാൻ കഴിയും. ഒരു ഉദാഹരണം ഇതാ:
$awk "( പ്രിൻ്റ് "" )" /etc/passwd
നിങ്ങൾ പ്രിൻ്റ് കമാൻഡിലേക്ക് "" സ്ട്രിംഗ് കൈമാറുമ്പോൾ, അത് എല്ലായ്പ്പോഴും ഒരു ശൂന്യമായ സ്ട്രിംഗ് പ്രിൻ്റ് ചെയ്യുന്നു. നിങ്ങൾ ഈ സ്‌ക്രിപ്റ്റ് പരീക്ഷിക്കുകയാണെങ്കിൽ, /etc/passwd-ലെ എല്ലാ വരികൾക്കും awk ഒരു ശൂന്യമായ ലൈൻ ഔട്ട്‌പുട്ട് ചെയ്യുന്നതായി നിങ്ങൾ കണ്ടെത്തും. ഇൻപുട്ട് ഫയലിലെ ഓരോ വരിക്കും awk ഒരു സ്ക്രിപ്റ്റ് എക്സിക്യൂട്ട് ചെയ്യുന്നതിനാൽ ഇത് വീണ്ടും സംഭവിക്കുന്നു. മറ്റൊരു ഉദാഹരണം ഇതാ:
$awk "( പ്രിൻ്റ് "ഹിയ" )" /etc/passwd
നിങ്ങൾ ഈ സ്‌ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കുകയാണെങ്കിൽ, അത് സ്‌ക്രീനിൽ "യേ" എന്ന വാക്കുകൾ കൊണ്ട് നിറയും. :)
ഒന്നിലധികം ഫീൽഡുകൾ
ഒന്നിലധികം ലോജിക്കൽ ഫീൽഡുകളായി വിഭജിച്ചിരിക്കുന്ന ടെക്‌സ്‌റ്റ് പ്രോസസ്സ് ചെയ്യുന്നതിന് Awk നന്നായി അനുയോജ്യമാണ്, കൂടാതെ ഒരു awk സ്‌ക്രിപ്റ്റിനുള്ളിൽ നിന്ന് ഓരോ ഫീൽഡും ആക്‌സസ് ചെയ്യുന്നത് എളുപ്പമാക്കുന്നു. ഇനിപ്പറയുന്ന സ്ക്രിപ്റ്റ് സിസ്റ്റത്തിലെ എല്ലാ അക്കൗണ്ടുകളുടെയും ഒരു ലിസ്റ്റ് പ്രിൻ്റ് ചെയ്യും:
$ awk -F":" "( പ്രിൻ്റ് $1 )" /etc/passwd
മുകളിലെ ഉദാഹരണത്തിലെ awk കോളിൽ, ഫീൽഡ് സെപ്പറേറ്ററായി –F ഓപ്ഷൻ ":" വ്യക്തമാക്കുന്നു. പ്രിൻ്റ് $1 കമാൻഡ് പ്രോസസ്സ് ചെയ്യുമ്പോൾ, ഇൻപുട്ട് ഫയലിൻ്റെ ഓരോ വരിയിലും നേരിടുന്ന ആദ്യത്തെ ഫീൽഡ് awk പ്രിൻ്റ് ചെയ്യുന്നു. മറ്റൊരു ഉദാഹരണം ഇതാ:
$ awk -F":" "( പ്രിൻ്റ് $1 $3 )" /etc/passwd
ഈ സ്ക്രിപ്റ്റിൻ്റെ സ്ക്രീൻ ഔട്ട്പുട്ടിൽ നിന്നുള്ള ഒരു സ്നിപ്പറ്റ് ഇതാ:
halt7 operator11 root0 shutdown6 sync5 bin1 ....etc.
നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, /etc/passwd ഫയലിൻ്റെ ആദ്യത്തെയും മൂന്നാമത്തെയും ഫീൽഡുകൾ awk ഔട്ട്പുട്ട് ചെയ്യുന്നു, അവ യഥാക്രമം ഉപയോക്തൃനാമവും uid ഫീൽഡുകളും ആണ്. അതേ സമയം, സ്ക്രിപ്റ്റ് പ്രവർത്തിക്കുന്നുണ്ടെങ്കിലും, അത് തികഞ്ഞതല്ല - രണ്ട് ഔട്ട്പുട്ട് ഫീൽഡുകൾക്കിടയിൽ സ്പേസുകളൊന്നുമില്ല! ബാഷ് അല്ലെങ്കിൽ പൈത്തണിൽ പ്രോഗ്രാമിംഗ് പരിചിതമായവർ ഈ രണ്ട് ഫീൽഡുകൾക്കിടയിൽ ഒരു സ്പേസ് തിരുകാൻ പ്രിൻ്റ് $1 $3 കമാൻഡ് പ്രതീക്ഷിച്ചിരിക്കാം. എന്നിരുന്നാലും, ഒരു awk പ്രോഗ്രാമിൽ രണ്ട് വരികൾ അടുത്തടുത്തായിരിക്കുമ്പോൾ, അവയ്ക്കിടയിൽ ഒരു ഇടം ചേർക്കാതെ awk അവയെ സംയോജിപ്പിക്കുന്നു. ഇനിപ്പറയുന്ന കമാൻഡ് ഫീൽഡുകൾക്കിടയിൽ ഒരു സ്പേസ് ചേർക്കും:
$ awk -F":" "( പ്രിൻ്റ് $1 " " $3 )" /etc/passwd
പ്രിൻ്റ് ഈ രീതിയിൽ വിളിക്കുമ്പോൾ, അത് $1 , " ", $3 എന്നിവ ശ്രേണിയിൽ സംയോജിപ്പിച്ച് സ്ക്രീനിൽ മനുഷ്യർക്ക് വായിക്കാവുന്ന ഔട്ട്പുട്ട് ഉണ്ടാക്കുന്നു. തീർച്ചയായും, ആവശ്യമെങ്കിൽ ഞങ്ങൾക്ക് ഫീൽഡ് ലേബലുകൾ ചേർക്കാനും കഴിയും:
$ awk -F":" "( പ്രിൻ്റ് "ഉപയോക്തൃനാമം: " $1 "\t\tuid: " $3" )" /etc/passwd
തൽഫലമായി, ഞങ്ങൾക്ക് ഇനിപ്പറയുന്ന നിഗമനം ലഭിക്കും:
ഉപയോക്തൃനാമം: ഹാൾട്ട് യുഐഡി:7 ഉപയോക്തൃനാമം: ഓപ്പറേറ്റർ യുഐഡി:11 ഉപയോക്തൃനാമം: റൂട്ട് യുഐഡി:0 ഉപയോക്തൃനാമം: ഷട്ട്ഡൗൺ യുഐഡി:6 ഉപയോക്തൃനാമം: സമന്വയം യുഐഡി:5 ഉപയോക്തൃനാമം: ബിൻ യുഐഡി:1 .... തുടങ്ങിയവ.
ബാഹ്യ സ്ക്രിപ്റ്റുകൾ
കമാൻഡ് ലൈൻ ആർഗ്യുമെൻ്റുകളായി awk-ലേക്ക് സ്ക്രിപ്റ്റുകൾ കൈമാറുന്നത് ചെറിയ വൺ-ലൈനറുകൾക്ക് സൗകര്യപ്രദമായിരിക്കും, എന്നാൽ സങ്കീർണ്ണമായ മൾട്ടി-ലൈൻ പ്രോഗ്രാമുകളുടെ കാര്യം വരുമ്പോൾ, സ്ക്രിപ്റ്റ് ഒരു ബാഹ്യ ഫയലായി രചിക്കുന്നതാണ് നല്ലത്. തുടർന്ന് -f ഓപ്ഷൻ ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഈ സ്ക്രിപ്റ്റ് ഫയലിലേക്ക് awk പോയിൻ്റ് ചെയ്യാം:
$ awk -f myscript.awk myfile.in
വ്യത്യസ്‌ത ടെക്‌സ്‌റ്റ് ഫയലുകളിൽ സ്‌ക്രിപ്‌റ്റുകൾ സ്ഥാപിക്കുന്നത് awk-ൻ്റെ അധിക ആനുകൂല്യങ്ങൾ പ്രയോജനപ്പെടുത്താനും നിങ്ങളെ അനുവദിക്കുന്നു. ഉദാഹരണത്തിന്, ഇനിപ്പറയുന്ന മൾട്ടി-ലൈൻ സ്ക്രിപ്റ്റ് ഞങ്ങളുടെ മുമ്പത്തെ വൺ-ലൈനറുകളിൽ ഒന്നിൻ്റെ അതേ കാര്യം തന്നെ ചെയ്യുന്നു - /etc/passwd-ൽ നിന്ന് ഓരോ വരിയുടെയും ആദ്യ ഫീൽഡ് പ്രിൻ്റ് ചെയ്യുന്നു:
BEGIN (FS=":") ($1 പ്രിൻ്റ് ചെയ്യുക)
ഈ രണ്ട് രീതികൾ തമ്മിലുള്ള വ്യത്യാസം ഞങ്ങൾ എങ്ങനെയാണ് ഫീൽഡ് സെപ്പറേറ്റർ വ്യക്തമാക്കുന്നത് എന്നതാണ്. ഈ സ്‌ക്രിപ്റ്റിൽ, ഫീൽഡ് സെപ്പറേറ്റർ പ്രോഗ്രാം തന്നെ (FS വേരിയബിൾ സജ്ജീകരിക്കുന്നതിലൂടെ) ആന്തരികമായി വ്യക്തമാക്കുന്നു, അതേസമയം ഞങ്ങളുടെ മുൻ ഉദാഹരണത്തിൽ, കമാൻഡ് ലൈനിലെ awk-F":" ഓപ്‌ഷനിലൂടെ FS ക്രമീകരിച്ചിരിക്കുന്നു. സ്ക്രിപ്റ്റിൽ തന്നെ ഫീൽഡ് സെപ്പറേറ്റർ വ്യക്തമാക്കുന്നതാണ് സാധാരണയായി നല്ലത്, കാരണം നിങ്ങൾക്ക് മറ്റൊരു കമാൻഡ് ലൈൻ ആർഗ്യുമെൻ്റ് ഓർമ്മിക്കേണ്ട ആവശ്യമില്ല. ഈ ലേഖനത്തിൽ പിന്നീട് കൂടുതൽ വിശദമായി FS വേരിയബിളിലേക്ക് നോക്കാം.
BEGIN, END ബ്ലോക്കുകൾ
സാധാരണയായി awk ഓരോ ഇൻപുട്ട് ലൈനിനും സ്ക്രിപ്റ്റ് ടെക്സ്റ്റിലെ ഓരോ ബ്ലോക്കും ഒരിക്കൽ എക്സിക്യൂട്ട് ചെയ്യുന്നു. എന്നിരുന്നാലും, awk ഒരു ഇൻപുട്ട് ഫയലിൽ നിന്ന് ടെക്‌സ്‌റ്റ് പ്രോസസ്സ് ചെയ്യാൻ തുടങ്ങുന്നതിന് മുമ്പ് നിങ്ങൾ ഇനീഷ്യലൈസേഷൻ കോഡ് എക്‌സിക്യൂട്ട് ചെയ്യേണ്ട സാഹചര്യങ്ങൾ പ്രോഗ്രാമിംഗിൽ പലപ്പോഴും ഉണ്ടാകാറുണ്ട്. അത്തരം സന്ദർഭങ്ങളിൽ, ഒരു BEGIN ബ്ലോക്ക് നിർവചിക്കാനുള്ള കഴിവ് awk നൽകുന്നു. മുമ്പത്തെ ഉദാഹരണത്തിൽ ഞങ്ങൾ BEGIN ബ്ലോക്ക് ഉപയോഗിച്ചു. ഇൻപുട്ട് ഫയൽ പ്രോസസ്സ് ചെയ്യാൻ awk ആരംഭിക്കുന്നതിന് മുമ്പ് BEGIN ബ്ലോക്ക് പ്രോസസ്സ് ചെയ്യുന്നതിനാൽ, ഒരു FS (ഫീൽഡ് സെപ്പറേറ്റർ) വേരിയബിൾ ആരംഭിക്കുന്നതിനോ ഒരു ഹെഡ്ഡർ ഔട്ട്പുട്ട് ചെയ്യുന്നതിനോ അല്ലെങ്കിൽ പ്രോഗ്രാമിൽ പിന്നീട് ഉപയോഗിക്കുന്ന മറ്റ് ആഗോള വേരിയബിളുകൾ സമാരംഭിക്കുന്നതിനോ ഉള്ള മികച്ച സ്ഥലമാണിത്.
END ബ്ലോക്ക് എന്ന മറ്റൊരു പ്രത്യേക ബ്ലോക്കും Awk നൽകുന്നു. ഇൻപുട്ട് ഫയലിലെ എല്ലാ വരികളും പ്രോസസ്സ് ചെയ്തതിന് ശേഷം Awk ഈ ബ്ലോക്ക് എക്സിക്യൂട്ട് ചെയ്യുന്നു. സാധാരണഗതിയിൽ, അന്തിമ കണക്കുകൂട്ടലുകൾ അല്ലെങ്കിൽ ഔട്ട്പുട്ട് സ്ട്രീമിൻ്റെ അവസാനം ദൃശ്യമാകുന്ന ഔട്ട്പുട്ട് ഫലങ്ങൾ നടത്താൻ ഒരു END ബ്ലോക്ക് ഉപയോഗിക്കുന്നു.
പതിവ് എക്സ്പ്രഷനുകളും ബ്ലോക്കുകളും
റെഗുലർ എക്‌സ്‌പ്രഷൻ നിലവിലെ ലൈനുമായി പൊരുത്തപ്പെടുന്നുണ്ടോ ഇല്ലയോ എന്നതിനെ ആശ്രയിച്ച് ഒരു പ്രോഗ്രാമിൻ്റെ നിർദ്ദിഷ്ട ബ്ലോക്കുകൾ തിരഞ്ഞെടുത്ത് എക്‌സിക്യൂട്ടീവ് ചെയ്യാൻ റെഗുലർ എക്‌സ്‌പ്രഷനുകൾ ഉപയോഗിക്കാൻ Awk നിങ്ങളെ അനുവദിക്കുന്നു. foo എന്ന ക്യാരക്ടർ സീക്വൻസ് അടങ്ങിയിരിക്കുന്ന വരികൾ മാത്രം പ്രിൻ്റ് ചെയ്യുന്ന ഒരു ഉദാഹരണ സ്ക്രിപ്റ്റ് ഇതാ:
/foo/ (പ്രിൻ്റ്)
തീർച്ചയായും, നിങ്ങൾക്ക് കൂടുതൽ സങ്കീർണ്ണമായ പതിവ് പദപ്രയോഗങ്ങൾ ഉപയോഗിക്കാം. ഫ്ലോട്ട് അടങ്ങിയ സ്ട്രിംഗുകൾ മാത്രം ഔട്ട്പുട്ട് ചെയ്യുന്ന ഒരു സ്ക്രിപ്റ്റ് ഇതാ:
/+\.*/ ( പ്രിൻ്റ് )
എക്സ്പ്രഷനുകളും ബ്ലോക്കുകളും
ഒരു പ്രോഗ്രാമിൻ്റെ ഒരു ബ്ലോക്ക് തിരഞ്ഞെടുത്ത് എക്സിക്യൂട്ട് ചെയ്യുന്നതിന് മറ്റ് നിരവധി മാർഗങ്ങളുണ്ട്. ആ ബ്ലോക്കിൻ്റെ നിർവ്വഹണം നിയന്ത്രിക്കുന്നതിന് ഒരു പ്രോഗ്രാം ബ്ലോക്കിന് മുമ്പായി നമുക്ക് ഏതെങ്കിലും ബൂളിയൻ എക്സ്പ്രഷൻ സ്ഥാപിക്കാം. മുമ്പത്തെ ബൂളിയൻ പദപ്രയോഗം true ആയി വിലയിരുത്തിയാൽ മാത്രമേ Awk ഒരു പ്രോഗ്രാം ബ്ലോക്ക് എക്സിക്യൂട്ട് ചെയ്യുകയുള്ളൂ. ഇനിപ്പറയുന്ന ഉദാഹരണ സ്ക്രിപ്റ്റ് എല്ലാ വരികളുടെയും മൂന്നാമത്തെ ഫീൽഡ് ഔട്ട്പുട്ട് ചെയ്യും, അവിടെ ആദ്യ ഫീൽഡ് ഫ്രെഡ് ചെയ്യുന്നു. നിലവിലെ ലൈനിൻ്റെ ആദ്യ ഫീൽഡ് ഫ്രെഡ് ചെയ്തിട്ടില്ലെങ്കിൽ, awk ഫയൽ പ്രോസസ്സ് ചെയ്യുന്നത് തുടരും കൂടാതെ നിലവിലെ ലൈനിനായി ഒരു പ്രിൻ്റ് സ്റ്റേറ്റ്മെൻ്റ് നൽകില്ല: :
$1 == "ഫ്രെഡ്" ( $3 പ്രിൻ്റ് ചെയ്യുക)
Awk സാധാരണ "=="," ഉൾപ്പെടെയുള്ള താരതമ്യ ഓപ്പറേറ്റർമാരുടെ ഒരു പൂർണ്ണ സെറ്റ് വാഗ്ദാനം ചെയ്യുന്നു.<", ">", "<=", ">=" കൂടാതെ "!=". കൂടാതെ, awk "~", "!~" ഓപ്പറേറ്റർമാരെ നൽകുന്നു, അതായത് "പൊരുത്തങ്ങൾ", "പൊരുത്തപ്പെടില്ല." അവർ വേരിയബിളിനെ ഓപ്പറേറ്ററുടെ ഇടതുവശത്തും റെഗുലർ എക്സ്പ്രഷനും സ്ഥാപിക്കുന്നു. അതിൻ്റെ വലതുവശത്ത്, അതേ വരിയുടെ അഞ്ചാമത്തെ ഫീൽഡിൽ പ്രതീക സീക്വൻസ് റൂട്ട് അടങ്ങിയിട്ടുണ്ടെങ്കിൽ, ഒരു വരിയുടെ മൂന്നാമത്തെ ഫീൽഡ് മാത്രം പ്രിൻ്റ് ചെയ്യുന്ന ഒരു ഉദാഹരണം ഇതാ:
$5 ~ /റൂട്ട്/ ( $3 പ്രിൻ്റ് ചെയ്യുക)
സോപാധിക പ്രസ്താവനകൾ
Awk വളരെ നല്ല C-like if പ്രസ്താവനകളും നൽകുന്നു. നിങ്ങൾക്ക് വേണമെങ്കിൽ, ഇനിപ്പറയുന്നവ ഉപയോഗിച്ച് നിങ്ങൾക്ക് മുമ്പത്തെ സ്ക്രിപ്റ്റ് വീണ്ടും എഴുതാം:
($5 ~ /root/) ($3 അച്ചടിക്കുക)
രണ്ട് സ്ക്രിപ്റ്റുകളും ഒരേപോലെയാണ് പ്രവർത്തിക്കുന്നത്. ആദ്യ ഉദാഹരണത്തിൽ, ബൂളിയൻ എക്സ്പ്രഷൻ ബ്ലോക്കിന് പുറത്താണ്, രണ്ടാമത്തെ ഉദാഹരണത്തിൽ, ഓരോ ഇൻപുട്ട് ലൈനിനും ബ്ലോക്ക് എക്സിക്യൂട്ട് ചെയ്യുന്നു, കൂടാതെ if സ്റ്റേറ്റ്മെൻ്റ് ഉപയോഗിച്ച് ഞങ്ങൾ പ്രിൻ്റ് കമാൻഡ് തിരഞ്ഞെടുത്ത് എക്സിക്യൂട്ട് ചെയ്യുന്നു. രണ്ട് രീതികളും പ്രവർത്തിക്കുന്നു, നിങ്ങൾക്ക് ഒന്ന് തിരഞ്ഞെടുക്കാം. അത് സ്ക്രിപ്റ്റിൻ്റെ മറ്റ് ഭാഗങ്ങളുമായി നന്നായി സംയോജിപ്പിക്കുന്നു.
awk-ലെ if പ്രസ്താവനയുടെ സങ്കീർണ്ണമായ ഒരു ഉദാഹരണം ഇതാ. നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, സങ്കീർണ്ണമായ നെസ്റ്റഡ് കണ്ടീഷനലുകൾക്കൊപ്പം പോലും, പ്രസ്താവനകൾ അവയുടെ C എതിരാളികൾക്ക് സമാനമാണെങ്കിൽ:
($1 == "foo" ആണെങ്കിൽ) (($2 == "foo") ("uno" എന്ന് അച്ചടിക്കുക) മറ്റെന്തെങ്കിലും ("ഒന്ന്" അച്ചടിക്കുക) ) മറ്റുള്ളവയാണെങ്കിൽ ($1 == "ബാർ") ("രണ്ട്" എന്ന് അച്ചടിക്കുക) വേറെ ("മൂന്ന്" അച്ചടിക്കുക) )
if സ്റ്റേറ്റ്‌മെൻ്റുകൾ ഉപയോഗിച്ച്, നമുക്ക് ഈ കോഡ് രൂപാന്തരപ്പെടുത്താം:
! /matchme/ ( $1 $3 $4 പ്രിൻ്റ് ചെയ്യുക)($0 !~ /matchme/) എങ്കിൽ ($1 $3 $4 അച്ചടിക്കുക)
രണ്ട് സ്ക്രിപ്റ്റുകളും ആ വരികൾ മാത്രമേ അച്ചടിക്കുകയുള്ളൂ അല്ലക്യാരക്ടർ സീക്വൻസ് മാച്ച്മെ ഉൾക്കൊള്ളുന്നു. ഈ സാഹചര്യത്തിലും, ഒരു പ്രത്യേക പ്രോഗ്രാമിൽ മികച്ച രീതിയിൽ പ്രവർത്തിക്കുന്ന ഒരു രീതി നിങ്ങൾക്ക് തിരഞ്ഞെടുക്കാം. അവർ രണ്ടുപേരും ഒരേ കാര്യം ചെയ്യുന്നു.
"||" ബൂളിയൻ ഓപ്പറേറ്റർമാരെ ഉപയോഗിക്കാനുള്ള കഴിവും Awk നിങ്ങൾക്ക് നൽകുന്നു. (“ലോജിക്കൽ OR”) കൂടാതെ “&&” (“ലോജിക്കൽ AND”), ഇത് കൂടുതൽ സങ്കീർണ്ണമായ ബൂളിയൻ എക്സ്പ്രഷനുകൾ സൃഷ്ടിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു:
($1 == "foo") && ($2 == "ബാർ") ( പ്രിൻ്റ് )
ഈ ഉദാഹരണം ആദ്യ ഫീൽഡ് foo ആയ ലൈനുകൾ മാത്രമേ ഔട്ട്പുട്ട് ചെയ്യും ഒപ്പംരണ്ടാമത്തെ ഫീൽഡ് ബാർ ആണ്.
സംഖ്യാ വേരിയബിളുകൾ!
ഞങ്ങൾ ഇതുവരെ സ്ട്രിംഗ് വേരിയബിളുകൾ, മുഴുവൻ സ്ട്രിംഗുകൾ അല്ലെങ്കിൽ നിർദ്ദിഷ്ട ഫീൽഡുകൾ എന്നിവ പ്രിൻ്റ് ചെയ്തിട്ടുണ്ട്. എന്നിരുന്നാലും, പൂർണ്ണസംഖ്യകളിലും ഫ്ലോട്ടിംഗ് പോയിൻ്റ് നമ്പറുകളിലും താരതമ്യം ചെയ്യാനുള്ള കഴിവ് awk നൽകുന്നു. ഗണിത പദപ്രയോഗങ്ങൾ ഉപയോഗിച്ച്, ഒരു ഫയലിലെ ശൂന്യമായ വരികളുടെ എണ്ണം കണക്കാക്കുന്ന ഒരു സ്ക്രിപ്റ്റ് എഴുതുന്നത് വളരെ എളുപ്പമാണ്. അത്തരത്തിലുള്ള ഒരു സ്ക്രിപ്റ്റ് ഇതാ:
BEGIN ( x=0 ) /^$/ ( x=x+1 ) END ( പ്രിൻ്റ് "" x " ശൂന്യമായ വരികൾ കണ്ടെത്തി. :)" )
BEGIN ബ്ലോക്കിൽ, ഞങ്ങൾ പൂർണ്ണസംഖ്യ വേരിയബിൾ x മുതൽ പൂജ്യം വരെ ആരംഭിക്കുന്നു. തുടർന്ന്, ഓരോ തവണയും awk ഒരു ശൂന്യമായ വരി അഭിമുഖീകരിക്കുമ്പോൾ, അത് x=x+1 എന്ന സ്റ്റേറ്റ്മെൻ്റ് എക്സിക്യൂട്ട് ചെയ്യും, x-നെ 1 കൊണ്ട് വർദ്ധിപ്പിക്കും. എല്ലാ ലൈനുകളും പ്രോസസ്സ് ചെയ്തുകഴിഞ്ഞാൽ, END ബ്ലോക്ക് എക്സിക്യൂട്ട് ചെയ്യപ്പെടും, കൂടാതെ awk അവസാനത്തെ ആകെത്തുക പ്രിൻ്റ് ചെയ്യും. കണ്ടെത്തിയ ശൂന്യമായ വരികളുടെ എണ്ണം.
സ്ട്രിംഗ് വേരിയബിളുകൾ
awk വേരിയബിളുകളെക്കുറിച്ചുള്ള ഒരു നല്ല കാര്യം, അവ "പ്ലെയിൻ, ചെറിയക്ഷരം" ആണ് എന്നതാണ്. എല്ലാ awk വേരിയബിളുകളും സ്ട്രിംഗുകളായി ആന്തരികമായി സംഭരിച്ചിരിക്കുന്നതിനാൽ ഞാൻ awk വേരിയബിളുകളെ "സ്ട്രിംഗ്" എന്ന് വിളിക്കുന്നു. അതേ സമയം, awk വേരിയബിളുകൾ "ലളിതമാണ്", കാരണം നിങ്ങൾക്ക് ഒരു വേരിയബിളിൽ ഗണിതം ചെയ്യാൻ കഴിയും, കൂടാതെ അതിൽ സാധുതയുള്ള ഒരു നമ്പർ സ്ട്രിംഗ് അടങ്ങിയിട്ടുണ്ടെങ്കിൽ, സ്‌ട്രിംഗ് ഒരു സംഖ്യയിലേക്ക് പരിവർത്തനം ചെയ്യുന്നത് awk സ്വയമേവ ശ്രദ്ധിക്കും. ഞാൻ എന്താണ് ഉദ്ദേശിക്കുന്നതെന്ന് കാണാൻ, ഈ ഉദാഹരണം നോക്കുക:
x=1.01
Awk ഔട്ട്പുട്ട് ചെയ്യും:
2.01
കൗതുകകരമായ! ഞങ്ങൾ 1.01 എന്ന സ്‌ട്രിംഗ് മൂല്യം x-ന് നൽകിയിട്ടുണ്ടെങ്കിലും, അതിൽ ഒരെണ്ണം ചേർക്കാൻ ഞങ്ങൾക്ക് ഇപ്പോഴും കഴിഞ്ഞു. ബാഷിലോ പൈത്തണിലോ ഞങ്ങൾക്ക് ഇത് ചെയ്യാൻ കഴിഞ്ഞില്ല. ഒന്നാമതായി, ബാഷ് ഫ്ലോട്ടിംഗ് പോയിൻ്റ് ഗണിതത്തെ പിന്തുണയ്ക്കുന്നില്ല. ബാഷിന് "സ്ട്രിംഗ്" വേരിയബിളുകൾ ഉണ്ടെങ്കിലും അവ "ലളിതമായ" അല്ല; ഏതെങ്കിലും കണക്ക് ചെയ്യാൻ, ബാഷ് ഞങ്ങളുടെ കണക്കുകൂട്ടലുകൾ വൃത്തികെട്ട $() നിർമ്മിതികളിൽ പൊതിയേണ്ടതുണ്ട്. നമ്മൾ പൈത്തണാണ് ഉപയോഗിക്കുന്നതെങ്കിൽ, അത് ഉപയോഗിച്ച് എന്തെങ്കിലും കണക്കുകൂട്ടലുകൾ നടത്തുന്നതിന് മുമ്പ് ഞങ്ങളുടെ സ്ട്രിംഗ് 1.01 ഒരു ഫ്ലോട്ടിംഗ് പോയിൻ്റ് മൂല്യത്തിലേക്ക് വ്യക്തമായി പരിവർത്തനം ചെയ്യേണ്ടതുണ്ട്. ഇത് ബുദ്ധിമുട്ടുള്ള കാര്യമല്ലെങ്കിലും, ഇത് ഒരു അധിക ഘട്ടമാണ്. awk-ൻ്റെ കാര്യത്തിൽ, ഇതെല്ലാം സ്വയമേവ ചെയ്യപ്പെടും, ഇത് ഞങ്ങളുടെ കോഡ് മനോഹരവും വൃത്തിയുള്ളതുമാക്കുന്നു. ഓരോ ഇൻപുട്ട് സ്‌ട്രിംഗിൻ്റെയും ആദ്യ ഫീൽഡ് സ്‌ക്വയർ ചെയ്യുകയും അതിലേക്ക് ഒരെണ്ണം ചേർക്കുകയും ചെയ്യണമെങ്കിൽ, ഞങ്ങൾ ഇതുപോലുള്ള ഒരു സ്‌ക്രിപ്റ്റ് ഉപയോഗിക്കും:
(പ്രിൻ്റ് ($1^2)+1 )
നിങ്ങൾ ഒരു ചെറിയ പരീക്ഷണം നടത്തുകയാണെങ്കിൽ, ഒരു വേരിയബിളിൽ സാധുവായ ഒരു സംഖ്യ ഇല്ലെങ്കിൽ, ഒരു ഗണിത പദപ്രയോഗം വിലയിരുത്തുമ്പോൾ awk ആ വേരിയബിളിനെ ഒരു സംഖ്യാ പൂജ്യമായി കണക്കാക്കുമെന്ന് നിങ്ങൾ കണ്ടെത്തും.
നിരവധി ഓപ്പറേറ്റർമാർ
awk-ൻ്റെ മറ്റൊരു നല്ല സവിശേഷത അതിൻ്റെ സമ്പൂർണ്ണ ഗണിത ഓപ്പറേറ്റർമാരാണ്. സ്റ്റാൻഡേർഡ് സങ്കലനം, വ്യവകലനം, ഗുണനം, ഹരിക്കൽ എന്നിവയ്‌ക്ക് പുറമേ, മുമ്പ് പ്രദർശിപ്പിച്ച എക്‌സ്‌പോണൻ്റ് ഓപ്പറേറ്റർ "^", ഇൻ്റിജർ ഡിവിഷൻ ബാക്കിയുള്ള ഓപ്പറേറ്റർ "%", കൂടാതെ സിയിൽ നിന്ന് കടമെടുത്ത മറ്റ് സൗകര്യപ്രദമായ അസൈൻമെൻ്റ് ഓപ്പറേറ്റർമാർ എന്നിവ ഉപയോഗിക്കാനുള്ള കഴിവ് awk നൽകുന്നു.
ഇതിൽ പ്രീ-, പോസ്റ്റ്-ഇൻക്രിമെൻ്റൽ/ഡിക്രിമെൻ്റൽ അസൈൻമെൻ്റ് ഓപ്പറേറ്റർമാർ (i++, --foo), സങ്കലനം/കുറക്കൽ/ഗുണനം/വിഭജനം എന്നിവയുള്ള അസൈൻമെൻ്റ് ഓപ്പറേറ്റർമാർ (a+=3, b*=2, c/=2.2, d-=6.2) ഉൾപ്പെടുന്നു. . എന്നാൽ അത്രയൊന്നും അല്ല - പൂർണ്ണസംഖ്യാ വിഭജനത്തിൻ്റെയും എക്‌സ്‌പോണൻഷ്യേഷൻ്റെയും ശേഷിക്കുന്ന (a^=2, b%=4) കണക്കാക്കുന്ന സൗകര്യപ്രദമായ അസൈൻമെൻ്റ് ഓപ്പറേറ്റർമാരും ഞങ്ങൾക്കുണ്ട്.
ഫീൽഡ് സെപ്പറേറ്ററുകൾ
awk-ന് അതിൻ്റേതായ പ്രത്യേക വേരിയബിളുകൾ ഉണ്ട്. അവയിൽ ചിലത് നിങ്ങൾക്ക് awk എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്ന് നന്നായി ക്രമീകരിക്കാനുള്ള കഴിവ് നൽകുന്നു, മറ്റുള്ളവയിൽ വിലപ്പെട്ട ഇൻപുട്ട് വിവരങ്ങൾ അടങ്ങിയിരിക്കുന്നു. ഈ പ്രത്യേക വേരിയബിളുകളിലൊന്നായ FS-ൽ ഞങ്ങൾ ഇതിനകം സ്പർശിച്ചിട്ടുണ്ട്. നേരത്തെ സൂചിപ്പിച്ചതുപോലെ, ഒരു ഫീൽഡ് സെപ്പറേറ്ററായി awk പരിഗണിക്കുന്ന പ്രതീകങ്ങളുടെ ക്രമം വ്യക്തമാക്കാൻ ഈ വേരിയബിൾ നിങ്ങളെ അനുവദിക്കുന്നു. ഞങ്ങൾ /etc/passwd ഇൻപുട്ടായി ഉപയോഗിക്കുമ്പോൾ, FS ":" ആയി സജ്ജമാക്കി. ഇത് മതിയാകും, പക്ഷേ FS ഞങ്ങൾക്ക് കൂടുതൽ വഴക്കം നൽകുന്നു.
FS വേരിയബിളിൻ്റെ മൂല്യം ഒരൊറ്റ പ്രതീകമായിരിക്കണമെന്നില്ല; ഏത് നീളത്തിലുമുള്ള പ്രതീക പാറ്റേൺ വ്യക്തമാക്കുന്ന ഒരു സാധാരണ പദപ്രയോഗം ഇതിന് നൽകാം. ഒന്നോ അതിലധികമോ ടാബ് പ്രതീകങ്ങളാൽ വേർതിരിച്ച ഫീൽഡുകളാണ് നിങ്ങൾ പ്രോസസ്സ് ചെയ്യുന്നതെങ്കിൽ, FS ഇനിപ്പറയുന്ന രീതിയിൽ കോൺഫിഗർ ചെയ്യണം:
FS="\t+"
മുകളിൽ ഞങ്ങൾ ഉപയോഗിച്ചു പ്രത്യേക സ്വഭാവംപതിവ് പദപ്രയോഗം "+" അതായത് "മുമ്പത്തെ പ്രതീകത്തിൻ്റെ ഒന്നോ അതിലധികമോ സംഭവങ്ങൾ".
ഫീൽഡുകൾ വൈറ്റ് സ്‌പെയ്‌സ് (ഒന്നോ അതിലധികമോ സ്‌പെയ്‌സുകളോ ടാബുകളോ) കൊണ്ട് വേർതിരിക്കുകയാണെങ്കിൽ, ഇനിപ്പറയുന്ന പതിവ് എക്‌സ്‌പ്രഷനിലേക്ക് FS സജ്ജമാക്കാൻ നിങ്ങൾ ആഗ്രഹിച്ചേക്കാം:
FS="[[:space:]+]"
ഈ സജ്ജീകരണം പ്രവർത്തിക്കുമെങ്കിലും, അത് ആവശ്യമില്ല. എന്തുകൊണ്ട്? കാരണം FS-ൻ്റെ ഡിഫോൾട്ട് മൂല്യം ഒരു സ്പേസ് പ്രതീകമാണ്, അത് awk "ഒന്നോ അതിലധികമോ സ്‌പെയ്‌സുകൾ അല്ലെങ്കിൽ ടാബുകൾ" ആയി വ്യാഖ്യാനിക്കുന്നു. ഞങ്ങളുടെ നിർദ്ദിഷ്ട ഉദാഹരണത്തിൽ, സ്ഥിരസ്ഥിതി FS മൂല്യം ഞങ്ങൾക്ക് ആവശ്യമുള്ളത് തന്നെയാണ്!
സങ്കീർണ്ണമായ പതിവ് എക്സ്പ്രഷനുകളിലും പ്രശ്നങ്ങളില്ല. റെക്കോർഡുകളെ "foo" എന്ന വാക്ക് കൊണ്ട് വേർതിരിക്കുകയാണെങ്കിൽപ്പോലും, ഇനിപ്പറയുന്ന പതിവ് എക്സ്പ്രഷൻ ഡാറ്റയെ ശരിയായി പാഴ്സ് ചെയ്യും:
FS="foo"
ഫീൽഡുകളുടെ എണ്ണം
ഞങ്ങൾ നോക്കാൻ പോകുന്ന അടുത്ത രണ്ട് വേരിയബിളുകൾ സാധാരണയായി എഴുതാൻ ഉദ്ദേശിച്ചുള്ളതല്ല, പക്ഷേ ഇൻപുട്ടിനെക്കുറിച്ചുള്ള ഉപയോഗപ്രദമായ വിവരങ്ങൾ വായിക്കാനും നേടാനും ഉപയോഗിക്കുന്നു. ഇതിൽ ആദ്യത്തേത് NF വേരിയബിളാണ്, ഇതിനെ "ഫീൽഡുകളുടെ എണ്ണം" എന്നും വിളിക്കുന്നു. Awk ഈ വേരിയബിളിൻ്റെ മൂല്യം നിലവിലെ റെക്കോർഡിലെ ഫീൽഡുകളുടെ എണ്ണത്തിലേക്ക് സ്വയമേവ സജ്ജീകരിക്കുന്നു. ചില ഇൻപുട്ട് ലൈനുകൾ മാത്രം പ്രദർശിപ്പിക്കാൻ നിങ്ങൾക്ക് NF വേരിയബിൾ ഉപയോഗിക്കാം:
NF == 3 (പ്രിൻ്റ് "ഈ എൻട്രിയിൽ മൂന്ന് ഫീൽഡുകൾ ഉണ്ട്: " $0 )
തീർച്ചയായും, NF വേരിയബിൾ സോപാധിക പ്രസ്താവനകളിലും ഉപയോഗിക്കാം, ഉദാഹരണത്തിന്:
( എങ്കിൽ (NF > 2) ( $1 " " $2 ":" $3 ) അച്ചടിക്കുക )
റെക്കോർഡ് നമ്പർ
മറ്റൊരു സൗകര്യപ്രദമായ വേരിയബിൾ റെക്കോർഡ് നമ്പർ (NR) ആണ്. അതിൽ എല്ലായ്‌പ്പോഴും നിലവിലെ റെക്കോർഡിൻ്റെ നമ്പർ അടങ്ങിയിരിക്കുന്നു (ആദ്യ റെക്കോർഡ് റെക്കോർഡ് നമ്പർ 1 ആയി awk കണക്കാക്കുന്നു). ഇതുവരെ ഞങ്ങൾ കൈകാര്യം ചെയ്തു ഇൻപുട്ട് ഫയലുകൾ, ഒരു വരിയിൽ ഒരു എൻട്രി അടങ്ങുന്നു. അത്തരം സാഹചര്യങ്ങളിൽ, NR നിലവിലെ ലൈൻ നമ്പറും റിപ്പോർട്ട് ചെയ്യും. എന്നിരുന്നാലും, ഈ പരമ്പരയിലെ പിന്നീടുള്ള ലേഖനങ്ങളിൽ ഞങ്ങൾ മൾട്ടി-ലൈൻ റെക്കോർഡുകൾ കൈകാര്യം ചെയ്യാൻ തുടങ്ങുമ്പോൾ, ഇത് മേലിൽ സംഭവിക്കില്ല, അതിനാൽ ജാഗ്രത പാലിക്കണം! NF വേരിയബിൾ പോലെ NR ഔട്ട്‌പുട്ട് ചെയ്യാൻ മാത്രം ഉപയോഗിക്കാം ചില വരികൾഇൻപുട്ട്:
(NR< 10) || (NR >100) ( "ഞങ്ങൾ 1-9 അല്ലെങ്കിൽ 101 അല്ലെങ്കിൽ അതിലധികമോ റെക്കോർഡ് നമ്പറിലാണ്" എന്ന് അച്ചടിക്കുക )
ഒരു ഉദാഹരണം കൂടി:
(#Skip header if (NR > 10) ("ഇപ്പോൾ യഥാർത്ഥ വിവരങ്ങൾ വരുന്നു!") )
വിവിധ ആവശ്യങ്ങൾക്കായി ഉപയോഗിക്കാവുന്ന അധിക വേരിയബിളുകൾ Awk നൽകുന്നു. ഭാവിയിലെ ലേഖനങ്ങളിൽ ഈ വേരിയബിളുകൾ നോക്കാം. ഞങ്ങൾ awk-ൻ്റെ പ്രാരംഭ പര്യവേക്ഷണത്തിൻ്റെ അവസാനത്തിലെത്തി. പരമ്പരയിലെ ഭാവി ലേഖനങ്ങളിൽ, ഞാൻ കൂടുതൽ വിപുലമായ awk പ്രവർത്തനം കാണിക്കും, ഞങ്ങൾ ഈ സീരീസ് ഒരു യഥാർത്ഥ ലോക awk ആപ്ലിക്കേഷൻ ഉപയോഗിച്ച് അവസാനിപ്പിക്കും. അതിനിടയിൽ, നിങ്ങൾക്ക് കൂടുതലറിയണമെങ്കിൽ, ചുവടെ ലിസ്റ്റുചെയ്തിരിക്കുന്ന ഉറവിടങ്ങൾ നിങ്ങൾക്ക് പരിശോധിക്കാവുന്നതാണ്.

മുൻ ലേഖനംമൈക്രോസോഫ്റ്റ് നെറ്റ് ഫ്രെയിംവർക്ക് ഡ്രൈവറുകൾ അൺഇൻസ്റ്റാൾ ചെയ്യുന്നു

അടുത്ത ലേഖനംഇൻ്റർനെറ്റിൽ സുരക്ഷിതമായി പ്രവർത്തിക്കുന്നതിനുള്ള ലളിതമായ നിയമങ്ങൾ!

ജൂലിയ