Linux-ൽ Awk ഉപയോഗിച്ച് അടുത്ത കമാൻഡ് എങ്ങനെ ഉപയോഗിക്കാം - ഭാഗം 6


Awk സീരീസിന്റെ ഈ ആറാം ഭാഗത്ത്, ഞങ്ങൾ next കമാൻഡ് ഉപയോഗിക്കുന്നത് നോക്കും, അത് നിങ്ങൾ നൽകിയ ബാക്കിയുള്ള എല്ലാ പാറ്റേണുകളും എക്uസ്uപ്രഷനുകളും ഒഴിവാക്കാൻ Awk-നോട് പറയുന്നു, പകരം അടുത്ത ഇൻപുട്ട് ലൈൻ വായിക്കുക.

ഒരു കമാൻഡ് എക്uസിക്യൂഷനിലെ സമയം പാഴാക്കുന്ന ഘട്ടങ്ങൾ എന്ന് ഞാൻ പരാമർശിക്കുന്ന കാര്യങ്ങൾ നടപ്പിലാക്കുന്നത് തടയാൻ next കമാൻഡ് നിങ്ങളെ സഹായിക്കുന്നു.

ഇത് എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് മനസിലാക്കാൻ, നമുക്ക് food_list.txt എന്ന ഫയൽ പരിഗണിക്കാം:

No      Item_Name               Price           Quantity
1       Mangoes                 $3.45              5
2       Apples                  $2.45              25
3       Pineapples              $4.45              55
4       Tomatoes                $3.45              25
5       Onions                  $1.45              15
6       Bananas                 $3.45              30

ഓരോ വരിയുടെയും അവസാനം ഒരു (*) അടയാളം ഉപയോഗിച്ച് 20-ൽ കുറവോ തുല്യമോ ആയ ഭക്ഷണ സാധനങ്ങൾ ഫ്ലാഗ് ചെയ്യുന്ന ഇനിപ്പറയുന്ന കമാൻഡ് പ്രവർത്തിപ്പിക്കുന്നത് പരിഗണിക്കുക:

# awk '$4 <= 20 { printf "%s\t%s\n", $0,"*" ; } $4 > 20 { print $0 ;} ' food_list.txt 

No	Item_Name		Price		Quantity
1	Mangoes			$3.45		   5	*
2	Apples			$2.45              25
3	Pineapples		$4.45              55
4	Tomatoes		$3.45              25 
5	Onions			$1.45              15	*
6	Bananas	                $3.45              30

മുകളിലുള്ള കമാൻഡ് യഥാർത്ഥത്തിൽ ഇനിപ്പറയുന്ന രീതിയിൽ പ്രവർത്തിക്കുന്നു:

  1. ആദ്യം, ഓരോ ഇൻപുട്ട് ലൈനിന്റെയും നാലാമത്തെ ഫീൽഡ് 20-ൽ കുറവാണോ അതോ തുല്യമാണോ എന്ന് ഇത് പരിശോധിക്കുന്നു, ഒരു മൂല്യം ആ വ്യവസ്ഥ പാലിക്കുകയാണെങ്കിൽ, അത് (*) ചിഹ്നം ഉപയോഗിച്ച് പ്രിന്റ് ചെയ്യുകയും ഫ്ലാഗ് ചെയ്യുകയും ചെയ്യുന്നു. അവസാനം എക്സ്പ്രഷൻ ഒന്ന് ഉപയോഗിക്കുന്നു: $4 <= 20
  2. രണ്ടാമതായി, ഓരോ ഇൻപുട്ട് ലൈനിന്റെയും നാലാമത്തെ ഫീൽഡ് 20-നേക്കാൾ വലുതാണോയെന്ന് ഇത് പരിശോധിക്കുന്നു, കൂടാതെ ഒരു വരി വ്യവസ്ഥ പാലിക്കുന്നുണ്ടെങ്കിൽ രണ്ട് എക്സ്പ്രഷൻ ഉപയോഗിച്ച് പ്രിന്റ് ചെയ്യപ്പെടും: $4 > 20

എന്നാൽ ഇവിടെ ഒരു പ്രശ്uനമുണ്ട്, ആദ്യത്തെ എക്uസ്uപ്രഷൻ എക്uസ്uക്യൂഷൻ ചെയ്യുമ്പോൾ, നമ്മൾ ഫ്ലാഗ് ചെയ്യാൻ ആഗ്രഹിക്കുന്ന ഒരു ലൈൻ പ്രിന്റ് ചെയ്യുന്നത്: { printf \%s %s \, $0,\**\ ; } തുടർന്ന് അതേ ഘട്ടത്തിൽ, രണ്ടാമത്തെ എക്സ്പ്രഷനും പരിശോധിക്കുന്നു, അത് സമയം പാഴാക്കുന്ന ഘടകമായി മാറുന്നു.

അതിനാൽ, ആദ്യ എക്സ്പ്രഷൻ ഉപയോഗിച്ച് പ്രിന്റ് ചെയ്uത ഫ്ലാഗ് ചെയ്uത ലൈനുകൾ പ്രിന്റ് ചെയ്uതതിന് ശേഷം, $4 > 20 എന്ന രണ്ടാമത്തെ എക്uസ്uപ്രഷൻ വീണ്ടും എക്uസിക്യൂട്ട് ചെയ്യേണ്ട ആവശ്യമില്ല.

ഈ പ്രശ്നം കൈകാര്യം ചെയ്യാൻ, നിങ്ങൾ ഇനിപ്പറയുന്ന രീതിയിൽ next കമാൻഡ് ഉപയോഗിക്കണം:

# awk '$4 <= 20 { printf "%s\t%s\n", $0,"*" ; next; } $4 > 20 { print $0 ;} ' food_list.txt

No	Item_Name		Price		Quantity
1	Mangoes			$3.45		   5	*
2	Apples			$2.45              25
3	Pineapples		$4.45              55
4	Tomatoes		$3.45              25 
5	Onions			$1.45              15	*
6	Bananas	                $3.45              30

$4 <= 20 { printf \%s %s ഉപയോഗിച്ച് ഒരൊറ്റ ഇൻപുട്ട് ലൈൻ പ്രിന്റ് ചെയ്ത ശേഷം \, $0,\*\ ; അടുത്തത് ; }, ഉൾപ്പെടുത്തിയിരിക്കുന്ന അടുത്ത കമാൻഡ് $4 > 20 { എന്ന രണ്ടാമത്തെ എക്സ്പ്രഷൻ ഒഴിവാക്കാൻ സഹായിക്കും. $0 ;} പ്രിന്റ് ചെയ്യുക, അതിനാൽ അളവ് 20-ൽ കൂടുതലാണോ എന്ന് പരിശോധിക്കാൻ സമയം പാഴാക്കാതെ തന്നെ എക്സിക്യൂഷൻ അടുത്ത ഇൻപുട്ട് ലൈനിലേക്ക് പോകുന്നു.

അടുത്ത കമാൻഡ് വളരെ പ്രധാനമാണ് കാര്യക്ഷമമായ കമാൻഡുകൾ എഴുതുക, ആവശ്യമുള്ളിടത്ത്, ഒരു സ്ക്രിപ്റ്റിന്റെ നിർവ്വഹണം വേഗത്തിലാക്കാൻ നിങ്ങൾക്ക് എല്ലായ്പ്പോഴും ഉപയോഗിക്കാം. Awk-നുള്ള ഇൻപുട്ടായി സ്റ്റാൻഡേർഡ് ഇൻപുട്ട് (STDIN) ഉപയോഗിക്കുന്നത് ഞങ്ങൾ നോക്കുന്ന പരമ്പരയുടെ അടുത്ത ഭാഗത്തിനായി തയ്യാറെടുക്കുക.

ഇത് സഹായകരമാണെന്ന് നിങ്ങൾ കണ്ടെത്തുമെന്ന് പ്രതീക്ഷിക്കുന്നു, ചുവടെയുള്ള അഭിപ്രായ വിഭാഗത്തിൽ ഒരു അഭിപ്രായം ഇടുന്നതിലൂടെ നിങ്ങൾക്ക് എല്ലായ്പ്പോഴും നിങ്ങളുടെ ചിന്തകൾ എഴുതാം.