സ്ട്രീമുകൾ, പ്രോഗ്രാം ചാനലുകൾ, റീഡയറക്‌ടുകൾ. ഷെൽ സ്ക്രിപ്റ്റുകൾ എഴുതുമ്പോൾ ബാഹ്യ പ്രോഗ്രാമുകൾക്കൊപ്പം പ്രവർത്തിക്കുന്നു

ഈ വിഷയം "ബാഷ് ഷെൽ ലാംഗ്വേജ്" പരമ്പരയിലെ നാലാമത്തെ വിഷയമാണ്. സോപാധിക പ്രസ്താവനകളായി ഭാഷയുടെ അത്തരം നിയന്ത്രണ ഘടനകളെക്കുറിച്ച് അദ്ദേഹം സംസാരിക്കും. എന്നാൽ അവയുടെ വിവരണത്തിലേക്ക് പോകുന്നതിനുമുമ്പ്, ചുവടെയുള്ള മെറ്റീരിയലിന്റെ പരിഗണന കൂടുതൽ മനസ്സിലാക്കാവുന്നതാക്കുന്ന ചില സൂക്ഷ്മതകളിൽ വസിക്കേണ്ടത് ആവശ്യമാണ്.
ആദ്യം, ഒരു കമാൻഡ് ലിസ്റ്റ് എന്താണെന്ന് നോക്കാം. ഒരു കമാൻഡ് ലിസ്റ്റ് എന്നത് ഒരൊറ്റ കമാൻഡ്, പൈപ്പ്‌ലൈൻ അല്ലെങ്കിൽ ഇനിപ്പറയുന്ന ഓപ്പറേറ്റർമാരിൽ ഒന്ന് വേർതിരിക്കുന്ന കമാൻഡുകളുടെ/പൈപ്പുകളുടെ സീക്വൻസാണ്: ";", "&&", "||", ഒരു അർദ്ധവിരാമത്താൽ അവസാനിപ്പിച്ചിരിക്കുന്നു.
; - നിരവധി കമാൻഡുകളുടെ തുടർച്ചയായ എക്സിക്യൂഷൻ ഓപ്പറേറ്റർ. ഓരോ തുടർന്നുള്ള കമാൻഡും മുമ്പത്തേത് പൂർത്തിയാക്കിയതിനുശേഷം മാത്രമേ എക്സിക്യൂട്ട് ചെയ്യാൻ തുടങ്ങുകയുള്ളൂ (അത് വിജയിച്ചോ ഇല്ലയോ എന്നത് പ്രശ്നമല്ല);
&& - മുമ്പത്തെ കമാൻഡ് വിജയകരമായി പൂർത്തിയാക്കിയതിന് ശേഷം മാത്രം ഒരു കമാൻഡ് എക്സിക്യൂട്ട് ചെയ്യാൻ ഓപ്പറേറ്റർ;
|| - മുമ്പത്തേത് തെറ്റായി എക്സിക്യൂട്ട് ചെയ്തതിന് ശേഷം മാത്രം ഒരു കമാൻഡ് എക്സിക്യൂട്ട് ചെയ്യുന്ന ഓപ്പറേറ്റർ.
വിജയ കോഡ് 0 ആണ്, കൂടാതെ പിശക് കോഡ് പൂജ്യമല്ല (പിശകിന്റെ തരം അനുസരിച്ച്). ഇത് പരമ്പരാഗത പ്രോഗ്രാമിംഗ് ഭാഷകളുമായി ആശയക്കുഴപ്പത്തിലാക്കരുത്, ഇവിടെ 1 എന്നത് ട്രൂ എന്നതിന് സമാനമാണ്, കൂടാതെ 0 എന്നത് തെറ്റിന് സമാനവുമാണ്.
ഇപ്പോൾ നമുക്ക് സോപാധിക പ്രസ്താവനകൾ നേരിട്ട് പരിഗണിക്കാൻ തുടങ്ങാം.

കേസ് ഓപ്പറേറ്റർ

കേസ് പ്രസ്താവനയുടെ പൊതുവായ വാക്യഘടന ഇതാണ്:

കേസ് മൂല്യം
ടെംപ്ലേറ്റ്1) ലിസ്റ്റ്1;;
ടെംപ്ലേറ്റ്2 | ടെംപ്ലേറ്റ്3) ലിസ്റ്റ്2;;
esac

കേസ് പ്രസ്താവന നടപ്പിലാക്കുന്നതിന്റെ യുക്തിസഹമായ ക്രമം:
a) മൂല്യവുമായി പൊരുത്തപ്പെടുന്ന ആദ്യ പാറ്റേൺ തിരയുന്നു;
b) അത് കണ്ടെത്തിയാൽ, ";;" എന്നതിൽ അവസാനിക്കുന്ന കമാൻഡുകളുടെ അനുബന്ധ ലിസ്റ്റ് എക്സിക്യൂട്ട് ചെയ്യുന്നു;
സി) കേസ് നിർമ്മാണത്തെ തുടർന്നുള്ള പ്രസ്താവനകളിലേക്ക് നിയന്ത്രണം കൈമാറുന്നു.
ടെംപ്ലേറ്റും ലിസ്റ്റും ")" എന്ന അക്ഷരത്താൽ വേർതിരിച്ചിരിക്കുന്നു. കമാൻഡുകളുടെ ഒരു ലിസ്റ്റ് നിരവധി വ്യവസ്ഥകളുമായി പൊരുത്തപ്പെടാം, തുടർന്ന് അവ "|" ചിഹ്നത്താൽ വേർതിരിക്കേണ്ടതാണ്.
ടെംപ്ലേറ്റുകളിൽ നിങ്ങൾക്ക് "*", "?", "" എന്നീ ചിഹ്നങ്ങൾ ഉപയോഗിക്കാം, അവ പരമ്പരയിലെ രണ്ടാമത്തെ വിഷയത്തിൽ ചർച്ചചെയ്തു. അവരുടെ സഹായത്തോടെ, C, PHP പോലുള്ള ഭാഷകളിലെ ഒരു സ്വിച്ച് സ്റ്റേറ്റ്‌മെന്റിൽ സ്ഥിരസ്ഥിതിയായി പ്രവർത്തിക്കുന്ന ഒരു നിർദ്ദേശം നിങ്ങൾക്ക് നടപ്പിലാക്കാൻ കഴിയും.
കേസ് ഉപയോഗിക്കുന്നതിനുള്ള ഒരു ഉദാഹരണം ഇതാ:
echo -n "[യൂണിവേഴ്സൽ വ്യൂവർ] ഫയലിന്റെ പേര് വ്യക്തമാക്കുക: "; *.jpg|*.gif|*.png-ൽ ഫയൽ കേസ് "$ഫയൽ" വായിക്കുക) eog $File ;; *.pdf) evince $File ;; *.txt) കുറവ് $ഫയൽ ;; *.html) firefox $File ;; /dev/*) echo "ശരി, ഇവ ഭയപ്പെടുത്തുന്ന ഫയലുകളാണ്." ;; *) പ്രതിധ്വനി "ശരി, ശരി - അത്ര സാർവത്രികമല്ല." echo "എനിക്ക് ഇത്തരത്തിലുള്ള ഫയലുകൾ പരിചിതമല്ല. അത് എങ്ങനെ കാണണമെന്ന് എനിക്കറിയില്ല." ;; esac
കേസ് നിർമ്മാണം ഉപയോഗിക്കുന്നതിനുള്ള മറ്റൊരു ഉദാഹരണം:
echo "പിശക്. ഞാൻ ആർക്കാണ് സന്ദേശം അയയ്‌ക്കേണ്ടത്?" പ്രതിധ്വനി "ബോസിനോട്: ബി" പ്രതിധ്വനി "സഹപ്രവർത്തകർക്ക്: സി" പ്രതിധ്വനി "ആരുമില്ല: ഏതെങ്കിലും കീ" ഉത്തരം കേസ് വായിക്കുക $answer in b|B) mail –s "error log" boss< error.log;; c|C) mail –s "Help! error log" –c denis nick < error.log;; *) echo "error"; exit;; esac

സോപാധിക എങ്കിൽ പ്രസ്താവന

if സ്റ്റേറ്റ്‌മെന്റിന്റെ പൊതുവായ വാക്യഘടന ഇതാണ്:

ലിസ്റ്റ് 1 ആണെങ്കിൽ
പട്ടിക2

fi

ഇവിടെ സ്ക്വയർ ബ്രാക്കറ്റുകൾ ഓപ്ഷണൽ നിർമ്മാണങ്ങളെ സൂചിപ്പിക്കുന്നു. കേസ് പ്രസ്താവന നടപ്പിലാക്കുന്നതിന്റെ യുക്തിസഹമായ ക്രമം:
a) list1 എക്സിക്യൂട്ട് ചെയ്തു;
b) ഇത് പിശകുകളില്ലാതെ നടപ്പിലാക്കുകയാണെങ്കിൽ, list2 എക്സിക്യൂട്ട് ചെയ്യപ്പെടും. അല്ലെങ്കിൽ, list3 എക്സിക്യൂട്ട് ചെയ്യപ്പെടും, കൂടാതെ അത് പിശകുകളില്ലാതെ പൂർത്തിയാകുകയാണെങ്കിൽ, list4 എക്സിക്യൂട്ട് ചെയ്യപ്പെടും. list3 ഒരു പിശക് കോഡും നൽകുന്നുവെങ്കിൽ, list5 എക്സിക്യൂട്ട് ചെയ്യപ്പെടും;
c) നിർമ്മാണം നടത്തിക്കഴിഞ്ഞാൽ, നിയന്ത്രണം ഓപ്പറേറ്റർമാർക്ക് കൈമാറുന്നു.
ഇനിപ്പറയുന്നവ ഉപയോഗിക്കുന്നതിനുള്ള ഒരു ഉദാഹരണം ഇതാ:
grep -q ബാഷ് ഫയൽ ആണെങ്കിൽ, "ഫയലിൽ കുറഞ്ഞത് ഒരു ബാഷ് പദമെങ്കിലും അടങ്ങിയിരിക്കുന്നു." fi
if, തുടർന്ന് ഒരേ വരിയിൽ ദൃശ്യമാകുമ്പോൾ, if, തുടർന്ന് കൺസ്ട്രക്‌റ്റുകൾ ഒരു അർദ്ധവിരാമത്തിൽ അവസാനിക്കണം. ഉദാഹരണത്തിന്:
$ എങ്കിൽ [$? -ne 0 ]; തുടർന്ന് "പിശക്" പ്രതിധ്വനിക്കുക; fi
ഇപ്പോൾ, ഒരേ വരിയിൽ എങ്കിൽ സ്ഥാപിക്കാൻ കഴിയുമെന്ന് അറിഞ്ഞുകൊണ്ട്, മുകളിലുള്ള ഉദാഹരണം വീണ്ടും എഴുതാം:
grep -q ബാഷ് ഫയൽ ആണെങ്കിൽ; തുടർന്ന് പ്രതിധ്വനിക്കുക "ഫയലിൽ ബാഷ് എന്ന വാക്ക് അടങ്ങിയിരിക്കുന്നു." fi

ടെസ്റ്റ് പ്രസ്താവനയും സോപാധിക പദപ്രയോഗങ്ങളും

മുകളിലുള്ള ഉദാഹരണത്തിൽ, എക്സിറ്റ് കോഡ് പാഴ്‌സ് ചെയ്യുന്നതിന് പകരം ഒരു കണ്ടീഷൻ ചെക്ക് ഉപയോഗിക്കുന്നു. ഈ ടെസ്റ്റിന്റെ രണ്ട് രൂപങ്ങൾ തുല്യമാണ്: ബിൽറ്റ്-ഇൻ ടെസ്റ്റ് കമാൻഡും [കണ്ടീഷനും]. ഉദാഹരണത്തിന്, ഒരു ഫയലിന്റെ അസ്തിത്വം പരിശോധിക്കാൻ നിങ്ങൾ എഴുതേണ്ടതുണ്ട്:
ടെസ്റ്റ് -ഇ<файл>
അഥവാ
[-ഇ<файл> ]
സ്ക്വയർ ബ്രാക്കറ്റുകൾ ഉപയോഗിക്കുകയാണെങ്കിൽ, അവ പരസ്പരം ഒരു സ്പേസ് ഉപയോഗിച്ച് വേർതിരിക്കേണ്ടതാണ്, കാരണം "[" എന്നത് കമാൻഡിന്റെ പേരാണ്, കൂടാതെ "]" എന്നത് അതിന്റെ പൂർത്തീകരണത്തിന് ആവശ്യമായ അവസാന ആർഗ്യുമെന്റാണ്.
വ്യവസ്ഥ വിജയകരമായി പരിശോധിച്ചാൽ, 0 തിരികെ നൽകും, തെറ്റാണെങ്കിൽ, പിശക് കോഡ് 1 തിരികെ നൽകും.
ഒരു സ്ട്രിംഗ് ശൂന്യമാണോ എന്ന് ടെസ്റ്റ് കമാൻഡിന് പരിശോധിക്കാൻ കഴിയും. ശൂന്യമല്ലാത്ത ഒരു സ്ട്രിംഗ് എക്സിറ്റ് കോഡ് 0. യഥാക്രമം ശൂന്യമായി - 1. ഉദാഹരണത്തിന്:
$ടെസ്റ്റ് $USER; പ്രതിധ്വനി $? 0
"" എന്നതുമായി താരതമ്യം ചെയ്യുമ്പോൾ "" ഡിസൈൻ കൂടുതൽ സാർവത്രികമാണ്. ഇത് ടെസ്റ്റ് കമാൻഡിന്റെ വിപുലീകൃത പതിപ്പാണ്. ഈ നിർമ്മിതിക്കുള്ളിൽ, ഫയൽ നാമങ്ങളുടെ അധിക വ്യാഖ്യാനമൊന്നും നടത്തപ്പെടുന്നില്ല, ആർഗ്യുമെന്റുകൾ പ്രത്യേക പദങ്ങളായി വിഭജിക്കപ്പെടുന്നില്ല, എന്നാൽ പാരാമീറ്ററുകളുടെയും കമാൻഡുകളുടെയും പകരം വയ്ക്കൽ അനുവദനീയമാണ്. ഉദാഹരണത്തിന്:
file=/etc/passwd [[ -e $file ]] എങ്കിൽ “പാസ്‌വേഡ് ഫയൽ കണ്ടെത്തി” എന്ന് പ്രതിധ്വനിപ്പിക്കുക. fi
ചില ലോജിക്കൽ പിശകുകൾ ഒഴിവാക്കാൻ സഹായിക്കുന്നതിനാൽ "" നിർമ്മാണം "" എന്നതിനേക്കാൾ അഭികാമ്യമാണ്. ഉദാഹരണത്തിന്, ഓപ്പറേറ്റർമാർ "&&", "||", "<" и ">" " ഉള്ളിൽ " " തികച്ചും സ്വീകാര്യമാണ്, അതേസമയം " " ഉള്ളിൽ പിശക് സന്ദേശങ്ങൾ സൃഷ്ടിക്കുന്നു.
"(())" നിർമ്മാണം നിങ്ങളെ കണക്കുകൂട്ടാൻ അനുവദിക്കുന്നു ഗണിത പദപ്രയോഗങ്ങൾഅവളുടെ ഉള്ളിൽ. കണക്കുകൂട്ടലിന്റെ ഫലം പൂജ്യമാണെങ്കിൽ, ഒരു പിശക് കോഡ് തിരികെ നൽകും. ഒരു കണക്കുകൂട്ടലിന്റെ പൂജ്യമല്ലാത്ത ഫലം 0 ന്റെ റിട്ടേൺ കോഡ് ഉണ്ടാക്കുന്നു. അതായത്, മുകളിൽ ചർച്ച ചെയ്തിരിക്കുന്ന ടെസ്റ്റിന്റെയും "" നിർദ്ദേശങ്ങളുടെയും നേർ വിപരീതം.
if സ്റ്റേറ്റ്മെന്റ് നെസ്റ്റഡ് ചെക്കുകൾ അനുവദിക്കുന്നു:
പ്രതിധ്വനി ആണെങ്കിൽ "അടുത്ത *if* ആദ്യത്തെ *if* ഉള്ളിലാണെങ്കിൽ." [[ $comparison = "integer" ]] എങ്കിൽ ((a< b)) else [[ $a < $b ]] fi then echo "$a меньше $b" fi

സാധാരണ ഉപയോഗിച്ച് സോപാധിക പദപ്രയോഗങ്ങൾ സംയോജിപ്പിക്കാം ലോജിക്കൽ പ്രവർത്തനങ്ങൾ:
! <выражение>- നിഷേധിക്കല്;
<выражение1>–എ<выражение2>- ലോജിക്കൽ AND;
<выражение1>–ഒ<выражение2>- ലോജിക്കൽ അല്ലെങ്കിൽ.

ഫയലുകൾക്കുള്ള എലിമെന്ററി സോപാധിക എക്സ്പ്രഷനുകൾ:
-e - ഫയൽ നിലവിലുണ്ട്;
-f - സാധാരണ ഫയൽ(ഒരു ഡയറക്‌ടറിയോ ഉപകരണ ഫയലോ അല്ല);
-s - പൂജ്യമല്ലാത്ത ഫയൽ വലുപ്പം;
-d - ഫയൽ ഒരു ഡയറക്ടറിയാണ്;
-b - ഫയൽ ഒരു ബ്ലോക്ക് ഉപകരണമാണ് (ഫ്ലോപ്പി, cdrom, മുതലായവ);
-c - ഫയൽ ഒരു പ്രതീക ഉപകരണമാണ് (കീബോർഡ്, മോഡം, സൌണ്ട് കാർഡ്ഇത്യാദി.);
-p - ഫയൽ ഒരു ചാനലാണ്;
-h - ഫയൽ ഒരു പ്രതീകാത്മക ലിങ്കാണ്;
-L - ഫയൽ ഒരു പ്രതീകാത്മക ലിങ്കാണ്;
-S - ഫയൽ ഒരു സോക്കറ്റ് ആണ്;
-t - ഫയൽ ടെർമിനൽ ഉപകരണവുമായി ബന്ധപ്പെട്ടിരിക്കുന്നു;
-r - ഫയൽ വായിക്കാവുന്നതാണ് (സ്ക്രിപ്റ്റ് സമാരംഭിച്ച ഉപയോക്താവിന്);
-w - ഫയൽ എഴുതാവുന്നതാണ് (സ്ക്രിപ്റ്റ് സമാരംഭിച്ച ഉപയോക്താവിന്);
-x - ഫയൽ എക്സിക്യൂഷൻ ലഭ്യമാണ് (സ്ക്രിപ്റ്റ് സമാരംഭിച്ച ഉപയോക്താവിന്);
ഫയലിനോ ഡയറക്ടറിക്കോ വേണ്ടി -g - (sgid) ഫ്ലാഗ് സജ്ജീകരിച്ചിരിക്കുന്നു;
ഫയലിനുള്ള -u - (suid) ഫ്ലാഗ് സജ്ജീകരിച്ചിരിക്കുന്നു;
-k - സ്റ്റിക്കി ബിറ്റ് ഫ്ലാഗ് സജ്ജീകരിച്ചിരിക്കുന്നു;
-ഒ - നിങ്ങൾ ഫയലിന്റെ ഉടമയാണ്;
-G - നിങ്ങൾ ഫയലിന്റെ അതേ ഗ്രൂപ്പിൽ പെട്ടവരാണ്;
-N - അവസാനമായി വായിച്ചതിനുശേഷം ഫയൽ പരിഷ്ക്കരിച്ചു;
file1 -nt file2 – file1 file2 നേക്കാൾ പുതിയതാണ്;
file1 -ot file2 – file1 file2 നേക്കാൾ പഴയതാണ്;
file1 -ef file2 - file1, file2 എന്നിവ ഒരേ ഫയലിലേക്കുള്ള "ഹാർഡ്" ലിങ്കുകളാണ്.

സ്ട്രിംഗുകൾ താരതമ്യം ചെയ്യുന്നതിനുള്ള എലിമെന്ററി സോപാധിക പദപ്രയോഗങ്ങൾ:
-z സ്ട്രിംഗ് - സ്ട്രിംഗ് നീളം 0 ആണ്;
-n സ്ട്രിംഗ് - സ്ട്രിംഗ് നീളം 0 ന് തുല്യമല്ല;
line1 == line2 - വരികൾ പൊരുത്തപ്പെടുന്നു ("=" പോലെ);
line1 !== line2 - വരികൾ പൊരുത്തപ്പെടുന്നില്ല ("!=" പോലെ);
വരി1< строка2 – строка1 предшествует строке2 в лексикографическом порядке;
ലൈൻ1 > ലൈൻ2 - ലൈൻ1 ലെക്സിക്കോഗ്രാഫിക്കൽ ക്രമത്തിൽ ലൈൻ2 പിന്തുടരുന്നു.
ഒരു ഗണിത സോപാധിക പദപ്രയോഗത്തിന് ഫോർമാറ്റ് ഉണ്ട്:
ആർഗ്യുമെന്റ്1 ഓപ്പറേഷൻ ആർഗ്യുമെന്റ്2, ആർഗ്യുമെന്റുകൾ പൂർണ്ണസംഖ്യകളാണ്, ഇനിപ്പറയുന്ന പ്രവർത്തനങ്ങൾ അനുവദനീയമാണ്:
-eq - തുല്യം;
-നെ - തുല്യമല്ല;
-lt - കുറവ്;
-le - കുറവ് അല്ലെങ്കിൽ തുല്യം;
-gt - കൂടുതൽ;
-ge - അതിലും വലുതോ തുല്യമോ;
< - меньше (внутри двойных круглых скобок);
<= - меньше или равно (внутри двойных круглых скобок);
> - അതിലും വലുത് (ഇരട്ട പരന്തീസിസിനുള്ളിൽ);
>= - അതിലും വലുതോ തുല്യമോ (ഇരട്ട പരന്തീസിസിനുള്ളിൽ).

ഒരു if സ്റ്റേറ്റ്മെന്റ് ഉപയോഗിച്ച് മുമ്പത്തെ ഉദാഹരണം മാറ്റിയെഴുതാം:
echo "പിശക്. ഞാൻ ആർക്കാണ് സന്ദേശം അയയ്‌ക്കേണ്ടത്?" echo "Boss: b" echo "Colleagues: c" echo "ആരുമില്ല: ഏതെങ്കിലും കീ" [ "$answer" == "b" –o "$answer" == "B" ] എങ്കിൽ ഉത്തരം വായിക്കുക; തുടർന്ന് മെയിൽ-s "പിശക് ലോഗ്" ബോസ്< error.log; elif [ "$answer" == "c" –o "$answer" == "C" ]; then mail –s "Help! error log" –c denis nick < error.log; else echo "error"; exit; fi

അടുത്ത വിഷയത്തിൽ ഞാൻ ബാഷ് കമാൻഡ് ഇന്റർപ്രെറ്ററിന്റെ നിയന്ത്രണ ഘടനകൾ നോക്കുന്നത് തുടരും. അതായത്, ലൂപ്പ് ഓപ്പറേറ്റർമാരെ പരിഗണിക്കും. ഇപ്പോൾ ഞാൻ അഭിപ്രായങ്ങൾക്കും വിമർശനങ്ങൾക്കും വേണ്ടി കാത്തിരിക്കുകയാണ് :).

UPD: ഉപയോക്താവിന് നന്ദി

എന്താണ് വേണ്ടത്?

കമാൻഡ് ലൈനിലും അടിസ്ഥാന പ്രോഗ്രാമിംഗ് ആശയങ്ങളിലും നിങ്ങൾ പരിചിതരായിരിക്കണം. ഇതൊരു പ്രോഗ്രാമിംഗ് ട്യൂട്ടോറിയൽ അല്ലെങ്കിലും, ഇത് പല അടിസ്ഥാന ആശയങ്ങളും വിശദീകരിക്കുന്നു (അല്ലെങ്കിൽ കുറഞ്ഞത് വിശദീകരിക്കാൻ ശ്രമിക്കുന്നു).
ഈ പ്രമാണത്തിന്റെ ഉപയോഗം

ഇനിപ്പറയുന്ന സാഹചര്യങ്ങളിൽ ഈ പ്രമാണം ആവശ്യമായി വന്നേക്കാം:

പ്രോഗ്രാമിംഗുമായി ബന്ധപ്പെട്ട ആശയങ്ങൾ നിങ്ങൾക്കുണ്ട്, കൂടാതെ ചില ഷെൽ സ്ക്രിപ്റ്റുകൾ കോഡിംഗ് ചെയ്യുന്ന പ്രക്രിയ നടത്തേണ്ടതുണ്ട്.

നിങ്ങളുടെ പ്രോഗ്രാമിംഗ് ആശയങ്ങൾ വേണ്ടത്ര നിർദ്ദിഷ്ടമല്ല കൂടാതെ അധിക മാർഗ്ഗനിർദ്ദേശം ആവശ്യമാണ്.

നിങ്ങളുടേതായവ സൃഷ്‌ടിക്കുന്നതിനുള്ള ഉദാഹരണമായി ചില ഷെൽ സ്‌ക്രിപ്റ്റുകളും കമന്റുകളും പരിശോധിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നുണ്ടോ?

നിങ്ങൾ DOS/Windows-ൽ നിന്ന് മൈഗ്രേറ്റ് ചെയ്യുകയാണ് (അല്ലെങ്കിൽ ഇതിനകം അങ്ങനെ ചെയ്തിട്ടുണ്ട്) കൂടാതെ "ബാച്ച്" ഫയലുകൾ സൃഷ്ടിക്കാൻ ആഗ്രഹിക്കുന്നു.

നിങ്ങൾ ഒരു പൂർണ്ണ വിഡ്ഢിയാണ്, അത് എങ്ങനെ ചെയ്യാമെന്നത് വായിക്കുക.

ഏറ്റവും ലളിതമായ സ്ക്രിപ്റ്റുകൾ

ഉദാഹരണങ്ങളെ മാത്രം അടിസ്ഥാനമാക്കി, ഷെൽ പ്രോഗ്രാമിംഗിനായുള്ള ചില മാർഗ്ഗനിർദ്ദേശങ്ങൾ നിങ്ങൾക്ക് നൽകാൻ ഈ HOW-TO ശ്രമിക്കുന്നു.

IN ഈ വിഭാഗംനിങ്ങൾ ചില ടെക്നിക്കുകൾ പഠിക്കുമ്പോൾ നിങ്ങൾക്ക് ഉപയോഗപ്രദമായേക്കാവുന്ന ചെറിയ സ്ക്രിപ്റ്റുകൾ നിങ്ങൾ കണ്ടെത്തും.

പരമ്പരാഗത "ഹലോ വേൾഡ്" സ്ക്രിപ്റ്റ്

#!/bin/bash echo ഹലോ വേൾഡ്!

ഈ സ്ക്രിപ്റ്റ്രണ്ട് വരികൾ മാത്രം ഉൾക്കൊള്ളുന്നു. ഫയൽ പ്രവർത്തിപ്പിക്കുന്നതിന് ഏത് പ്രോഗ്രാമാണ് ഉപയോഗിക്കുന്നതെന്ന് ആദ്യത്തേത് സിസ്റ്റത്തോട് പറയുന്നു.

ടെർമിനലിലേക്ക് "ഹലോ വേൾഡ്" എന്ന് അച്ചടിച്ച് ഈ സ്ക്രിപ്റ്റ് ചെയ്യുന്ന ഒരേയൊരു പ്രവർത്തനം രണ്ടാമത്തെ വരിയാണ്.

നിങ്ങൾക്ക് ./hello.sh: കമാൻഡ് പോലെ എന്തെങ്കിലും ലഭിക്കുകയാണെങ്കിൽ കണ്ടെത്തിയില്ല. , എങ്കിൽ ഒരുപക്ഷേ ആദ്യ വരി "#!/bin/bash" തെറ്റായിരിക്കാം; ഈ ലൈൻ എന്തായിരിക്കണമെന്ന് മനസിലാക്കാൻ എവിടെയാണ് ബാഷ് പ്രവർത്തിപ്പിക്കുക അല്ലെങ്കിൽ ബാഷ് കണ്ടെത്തുന്നത് നോക്കുക.

ലളിതമായ ബാക്കപ്പ് സ്ക്രിപ്റ്റ്

#!/bin/bash
tar -cZf /var/my-backup.tgz /home/me/

ഈ സ്ക്രിപ്റ്റിൽ, ടെർമിനലിൽ ഒരു സന്ദേശം അച്ചടിക്കുന്നതിനുപകരം, ഉപയോക്താവിന്റെ ഹോം ഡയറക്ടറിയുടെ ഒരു ടാർ ആർക്കൈവ് ഞങ്ങൾ സൃഷ്ടിക്കുന്നു. തിരക്കഥ ഉദ്ദേശിച്ചുള്ളതല്ല പ്രായോഗിക ഉപയോഗം. കൂടുതൽ കാര്യക്ഷമമായ ഒരു സ്ക്രിപ്റ്റ് ഈ ഡോക്യുമെന്റിൽ പിന്നീട് അവതരിപ്പിക്കും. റിസർവ് കോപ്പി.

റീഡയറക്ഷൻ സിദ്ധാന്തത്തെക്കുറിച്ചും ദ്രുത കാഴ്‌ചയെക്കുറിച്ചും എല്ലാം

3 ഫയൽ ഡിസ്ക്രിപ്റ്ററുകൾ ഉണ്ട്: stdin - സ്റ്റാൻഡേർഡ് ഇൻപുട്ട്, stdout - സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ട്, stderr - സ്റ്റാൻഡേർഡ് പിശക്.

നിങ്ങളുടെ പ്രധാന സവിശേഷതകൾ:
ഫയലിലേക്ക് stdout റീഡയറക്‌ട് ചെയ്യുക
ഫയലിലേക്ക് stderr റീഡയറക്‌ട് ചെയ്യുക
stdout stderr-ലേക്ക് റീഡയറക്‌ട് ചെയ്യുക
stderr stdout-ലേക്ക് റീഡയറക്‌ട് ചെയ്യുക
ഫയലിലേക്ക് stderr, stdout എന്നിവ റീഡയറക്‌ട് ചെയ്യുക
stderr, stdout എന്നിവ stdout-ലേക്ക് തിരിച്ചുവിടുക
stderr, stdout എന്നിവ stderr-ലേക്ക് തിരിച്ചുവിടുക

1 എന്നാൽ stdout എന്നും 2 എന്നാൽ stderr എന്നും അർത്ഥം. കൂടുതൽ മനസ്സിലാക്കുന്നതിനുള്ള ഒരു ദ്രുത കുറിപ്പ്: കുറവ് കമാൻഡ് ഉപയോഗിച്ച്, നിങ്ങൾക്ക് ബഫറിൽ അവശേഷിക്കുന്ന stdout ഉം സ്ക്രീനിൽ പ്രിന്റ് ചെയ്യുന്ന stderr ഉം കാണാൻ കഴിയും. എന്നിരുന്നാലും, നിങ്ങൾ ബഫർ "ബ്രൗസ്" ചെയ്യാൻ ശ്രമിക്കുമ്പോൾ അത് മായ്‌ക്കപ്പെടും.

ഉദാഹരണം: ഫയലിലേക്ക് stdout

ഈ പ്രവർത്തനം ഒരു ഫയലിലേക്ക് പ്രോഗ്രാമിന്റെ സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ട് എഴുതുന്നു.

ls -l > ls-l.txt

ഇത് "ls-l.txt" എന്ന പേരിൽ ഒരു ഫയൽ സൃഷ്ടിക്കുന്നു. നിങ്ങൾ "ls -l" കമാൻഡ് പ്രവർത്തിപ്പിച്ചാൽ നിങ്ങൾ കാണുന്നതെല്ലാം ഇതിൽ അടങ്ങിയിരിക്കും. 3.3 ഉദാഹരണം: ഫയലിലേക്ക് stderr
ഈ പ്രവർത്തനം പ്രോഗ്രാമിന്റെ സാധാരണ പിശക് സ്ട്രീം ഒരു ഫയലിലേക്ക് എഴുതുന്നു.
grep da * 2> grep-errors.txt

ഇത് "grep-errors.txt" എന്ന പേരിൽ ഒരു ഫയൽ സൃഷ്ടിക്കുന്നു. ഇതിൽ "grep;da;*" കമാൻഡ് ഔട്ട്‌പുട്ടിന്റെ സാധാരണ പിശക് ഭാഗം അടങ്ങിയിരിക്കും. 3.4 ഉദാഹരണം: stdout to stderr

ഈ പ്രവർത്തനം പ്രോഗ്രാമിന്റെ സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ട് സാധാരണ പിശക് സ്ട്രീമിന്റെ അതേ ഫയലിലേക്ക് എഴുതുന്നു.
grep da * 1>&2

ഇവിടെ കമാൻഡിന്റെ സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ട് സ്റ്റാൻഡേർഡ് പിശകിലേക്ക് അയയ്ക്കുന്നു. നിങ്ങൾക്ക് ഇത് വ്യത്യസ്ത രീതികളിൽ കാണാൻ കഴിയും. 3.5 മാതൃക: stderr 2 stdout

ഈ പ്രവർത്തനം പ്രോഗ്രാമിന്റെ സ്റ്റാൻഡേർഡ് പിശക് സ്ട്രീം സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ടിന്റെ അതേ സ്ഥലത്തേക്ക് എഴുതുന്നു.
grep * 2>&1
ഇവിടെ കമാൻഡിന്റെ സ്റ്റാൻഡേർഡ് പിശക് സ്ട്രീം സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ടിലേക്ക് അയയ്ക്കുന്നു; നിങ്ങൾ ഫലത്തെ (|) കുറച്ചുകൊണ്ട് പൈപ്പ് ചെയ്യുകയാണെങ്കിൽ, സാധാരണയായി നഷ്ടപ്പെടുന്ന (സാധാരണ പിശകിൽ എഴുതിയത് പോലെ) ലൈനുകൾ ഈ സാഹചര്യത്തിൽ സംരക്ഷിക്കപ്പെടുന്നതായി നിങ്ങൾ കാണും (അവ സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ടിൽ ഉള്ളതിനാൽ). 3.6 ഉദാഹരണം: ഫയൽ ചെയ്യാൻ stderr ഉം stdout ഉം

ഈ പ്രവർത്തനം പ്രോഗ്രാമിന്റെ എല്ലാ ഔട്ട്‌പുട്ടും ഒരു ഫയലിൽ ഇടുന്നു. ക്രോൺ ജോലികൾക്ക് ഇതൊരു നല്ല ഓപ്ഷനാണ്: കമാൻഡ് പൂർണ്ണമായും നിശബ്ദമായി പ്രവർത്തിക്കണമെങ്കിൽ.
rm -f $(കണ്ടെത്തുക / -നാമം കോർ) &> /dev/null

ഇത് (ക്രോണിന് വേണ്ടി കരുതുക) ഏത് ഡയറക്ടറിയിലും "കോർ" എന്ന് വിളിക്കപ്പെടുന്ന ഏത് ഫയലിനെയും ഇല്ലാതാക്കുന്നു. കമാൻഡ് അതിന്റെ ഔട്ട്‌പുട്ട് തിരുത്തിയെഴുതാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ അത് എന്താണ് ചെയ്യുന്നതെന്ന് നിങ്ങൾക്ക് പൂർണ്ണമായും ഉറപ്പുണ്ടായിരിക്കണമെന്ന് ഓർമ്മിക്കുക. 4. കൺവെയറുകൾ

ഈ വിഭാഗം വളരെ ലളിതവും പ്രായോഗികവുമായ രീതിയിൽ കൺവെയറുകൾ എങ്ങനെ ഉപയോഗിക്കണമെന്നും നിങ്ങൾക്ക് അവ ആവശ്യമായി വന്നേക്കാമെന്നും വിശദീകരിക്കുന്നു.
അതെന്താണ്, എന്തുകൊണ്ട് അത് ഉപയോഗിക്കണം?

ഒരു പ്രോഗ്രാമിന്റെ ഔട്ട്‌പുട്ട് മറ്റൊന്നിന്റെ ഇൻപുട്ടായി ഉപയോഗിക്കാനുള്ള കഴിവ് (ഇത് വളരെ ലളിതമാണെന്ന് രചയിതാവിന് ബോധ്യമുണ്ട്) പൈപ്പ് ലൈനുകൾ നിങ്ങൾക്ക് നൽകുന്നു.

ഉദാഹരണം: സെഡ് ഉള്ള ഒരു ലളിതമായ പൈപ്പ്ലൈൻ

കൺവെയറുകൾ ഉപയോഗിക്കുന്നതിനുള്ള വളരെ ലളിതമായ മാർഗമാണിത്.

ls -l | sed -e "s//u/g"

ഇവിടെ സംഭവിക്കുന്നത്, ls;-l എന്ന കമാൻഡ് ആദ്യം എക്സിക്യൂട്ട് ചെയ്യുകയും, അതിന്റെ ഔട്ട്പുട്ട് സ്ക്രീനിൽ പ്രദർശിപ്പിക്കുന്നതിനുപകരം, sed പ്രോഗ്രാമിലേക്ക് അയയ്ക്കുകയും, അത് സ്ക്രീനിൽ ചെയ്യേണ്ടത് പ്രിന്റ് ചെയ്യുകയും ചെയ്യുന്നു. 4.3 ഉദാഹരണം: ls;-l;*.txt എന്നതിനുള്ള ബദൽ

ഇത് ls;-l;*.txt എന്നതിനേക്കാൾ വളരെ സങ്കീർണ്ണമായേക്കാം, എന്നാൽ ഇത് പൈപ്പ് ലൈനുകൾ ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നത് ചിത്രീകരിക്കാൻ മാത്രമാണ് ഇവിടെ അവതരിപ്പിച്ചിരിക്കുന്നത്, രണ്ട് ലിസ്റ്റിംഗ് രീതികൾക്കിടയിൽ തീരുമാനിക്കാൻ വേണ്ടിയല്ല.

ls -l | grep "\.txt$"

ഇവിടെ, ls -l ന്റെ ഔട്ട്‌പുട്ട് grep-ലേക്ക് അയയ്‌ക്കുന്നു, ഇത് "\.txt$" എന്ന പതിവ് പദപ്രയോഗവുമായി പൊരുത്തപ്പെടുന്ന വരികൾ പ്രിന്റ് ചെയ്യുന്നു. 5. വേരിയബിളുകൾ

ഏത് പ്രോഗ്രാമിംഗ് ഭാഷയിലും ഉള്ളതുപോലെ നിങ്ങൾക്ക് വേരിയബിളുകൾ ഉപയോഗിക്കാം. ഡാറ്റ തരങ്ങളൊന്നുമില്ല. ബാഷിലെ ഒരു വേരിയബിൾ ഒരു സംഖ്യ, ഒരു പ്രതീകം അല്ലെങ്കിൽ പ്രതീകങ്ങളുടെ ഒരു സ്ട്രിംഗ് ആകാം.

നിങ്ങൾ ഒരു വേരിയബിൾ പ്രഖ്യാപിക്കരുത്. വാസ്തവത്തിൽ, അതിന്റെ പോയിന്ററിന് ഒരു മൂല്യം നൽകുന്നത് ഇതിനകം തന്നെ അത് സൃഷ്ടിക്കുന്നു.

ഉദാഹരണം: വേരിയബിളുകൾ ഉപയോഗിച്ച് "ഹലോ വേൾഡ്!"

#!/bin/bash
STR="ഹലോ വേൾഡ്!"
പ്രതിധ്വനി $STR

രണ്ടാമത്തെ വരി STR എന്ന ഒരു വേരിയബിൾ സൃഷ്ടിക്കുകയും അതിന് "ഹലോ വേൾഡ്!" എന്ന സ്ട്രിംഗ് മൂല്യം നൽകുകയും ചെയ്യുന്നു. ഒരു മുൻനിര "$" ചിഹ്നം ചേർത്ത് ഈ വേരിയബിളിന്റെ VALUE എക്‌സ്‌ട്രാക്‌റ്റുചെയ്യുന്നു. നിങ്ങൾ "$" ചിഹ്നം ഉപയോഗിക്കുന്നില്ലെങ്കിൽ, പ്രോഗ്രാം ഔട്ട്പുട്ട് വ്യത്യസ്തമായിരിക്കാമെന്ന് ദയവായി ഓർക്കുക (കഠിനമായി ശ്രമിക്കുക). ഒരുപക്ഷേ നിങ്ങൾക്ക് ആവശ്യമുള്ളത് അല്ല.
ഉദാഹരണം: വളരെ ലളിതമായ ബാക്കപ്പ് സ്ക്രിപ്റ്റ് (കൂടുതൽ കാര്യക്ഷമമായത്)
#!/bin/bash
OF=/var/my-backup-$(തീയതി +%Y%m%d).tgz #OF - ഔട്ട്‌പുട്ട് ഫയൽ - ഔട്ട്‌പുട്ട് ഫയൽ
tar -cZf $OF /home/me/

ഈ സ്ക്രിപ്റ്റ് മറ്റൊരു ആശയം അവതരിപ്പിക്കുന്നു. ഒന്നാമതായി, നിങ്ങൾ രണ്ടാമത്തെ വരി കൈകാര്യം ചെയ്യണം. "$(തീയതി +%Y%m%d)" എന്ന പദപ്രയോഗം ശ്രദ്ധിക്കുക. നിങ്ങൾ ഈ സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കുകയാണെങ്കിൽ, അത് പരാൻതീസിസിനുള്ളിൽ കമാൻഡ് എക്സിക്യൂട്ട് ചെയ്യുന്നത് അതിന്റെ ഔട്ട്പുട്ടിനെ തടസ്സപ്പെടുത്തുന്നത് നിങ്ങൾ ശ്രദ്ധിക്കും.

ഈ സ്ക്രിപ്റ്റിൽ, തീയതിയുടെ ഫോർമാറ്റ് അടിസ്ഥാനമാക്കി, ഔട്ട്പുട്ട് ഫയലിന്റെ പേര് ദിവസവും മാറും;(+%Y%m%d) കമാൻഡ് കീ. നിങ്ങൾക്ക് ഇത് മറ്റൊരു ഫോർമാറ്റ് അസൈൻമെന്റ് ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കാം.
മറ്റ് ഉദാഹരണങ്ങൾ:
എക്കോ ls
പ്രതിധ്വനി $(ls)

പ്രാദേശിക വേരിയബിളുകൾ

ലോക്കൽ കീവേഡ് ഉപയോഗിച്ച് ലോക്കൽ വേരിയബിളുകൾ സൃഷ്ടിക്കാൻ കഴിയും.
#!/bin/bash
HELLO=ഹലോ
ഫംഗ്ഷൻ ഹലോ(
പ്രാദേശിക HELLO=ലോകം
പ്രതിധ്വനി $HELLO
}
പ്രതിധ്വനി $HELLO
ഹലോ
പ്രതിധ്വനി $HELLO
ലോക്കൽ വേരിയബിളുകൾ എങ്ങനെ ഉപയോഗിക്കാമെന്ന് കാണിക്കാൻ ഈ ഉദാഹരണം മതിയാകും.

സോപാധിക പ്രസ്താവനകൾ

ഒരു പ്രവൃത്തി ചെയ്യണോ വേണ്ടയോ എന്ന് തീരുമാനിക്കാനുള്ള കഴിവ് സോപാധിക പ്രസ്താവനകൾ നിങ്ങൾക്ക് നൽകുന്നു; പദപ്രയോഗത്തിന്റെ മൂല്യം കണക്കാക്കുമ്പോൾ തീരുമാനം എടുക്കുന്നു.

ഒരു സിദ്ധാന്തം മാത്രം

നിലവിലുണ്ട് ഒരു വലിയ സംഖ്യസോപാധിക പ്രസ്താവനകളുടെ രൂപങ്ങൾ. എലിമെന്ററി ഫോം ഒരു if എക്‌സ്‌പ്രഷൻ തുടർന്ന് സ്റ്റേറ്റ്‌മെന്റാണ്, അവിടെ "എക്‌സ്‌പ്രഷൻ" "ട്രൂ" ആയി വിലയിരുത്തിയാൽ മാത്രമേ "സ്റ്റേറ്റ്‌മെന്റ്" എക്‌സിക്യൂട്ട് ചെയ്യൂ. "2<1" - это выражение, имеющее значение "ложь", в то время как "2>1" - "ശരി".

സോപാധിക പ്രസ്താവനകളുടെ മറ്റ് രൂപങ്ങളുണ്ട്: എക്സ്പ്രഷൻ ആണെങ്കിൽ, സ്റ്റേറ്റ്മെന്റ്1 else സ്റ്റേറ്റ്മെന്റ്2. "എക്സ്പ്രഷൻ" ശരിയാണെങ്കിൽ ഇവിടെ "operator1" എക്സിക്യൂട്ട് ചെയ്യപ്പെടും; അല്ലെങ്കിൽ, "statement2" എക്സിക്യൂട്ട് ചെയ്യുന്നു.

സോപാധിക പ്രസ്താവനകളുടെ മറ്റൊരു രൂപമാണ്: എക്സ്പ്രഷൻ1 ആണെങ്കിൽ ഓപ്പറേറ്റർ1 വേറെ എക്‌സ്‌പ്രഷൻ 2 ആണെങ്കിൽ ഓപ്പറേറ്റർ2 ഓപ്പറേറ്റർ3. ഈ ഫോം "എക്‌സ്‌പ്രഷൻ2" പിന്നീട് "സ്‌റ്റേറ്റ്‌മെന്റ്2" എന്ന ക്രമം മാത്രമേ ചേർക്കൂ, "എക്‌സ്‌പ്രഷൻ2" "ട്രൂ" എന്ന് വിലയിരുത്തുകയാണെങ്കിൽ "സ്റ്റേറ്റ്‌മെന്റ്2" എക്‌സിക്യൂട്ട് ചെയ്യപ്പെടും. മറ്റെല്ലാം ഇതിനെക്കുറിച്ചുള്ള നിങ്ങളുടെ ആശയവുമായി പൊരുത്തപ്പെടുന്നു (മുമ്പത്തെ ഫോമുകൾ കാണുക).

വാക്യഘടനയെക്കുറിച്ച് കുറച്ച് വാക്കുകൾ:
ബാഷിലെ ഒരു "if" പ്രസ്താവനയുടെ അടിസ്ഥാന നിർമ്മാണം ഇതുപോലെ കാണപ്പെടുന്നു:
എങ്കിൽ [എക്സ്പ്രഷൻ];
പിന്നെ
"എക്സ്പ്രഷൻ" ശരിയാണെങ്കിൽ കോഡ്.
fi

ഉദാഹരണം: ഒരു സോപാധിക പ്രസ്താവനയുടെ അടിസ്ഥാന ഉദാഹരണം എങ്കിൽ;..;പിന്നെ
#!/bin/bash
എങ്കിൽ [ "foo" = "foo" ]; പിന്നെ

fi

സ്ക്വയർ ബ്രാക്കറ്റിനുള്ളിലെ എക്സ്പ്രഷൻ ശരിയാണെങ്കിൽ, എക്സിക്യൂട്ട് ചെയ്യേണ്ട കോഡ് "അപ്പോൾ" എന്ന വാക്കിന് ശേഷവും "fi" എന്ന വാക്കിന് മുമ്പും ആണ്, ഇത് വ്യവസ്ഥ പാലിക്കുമ്പോൾ എക്സിക്യൂട്ട് ചെയ്യേണ്ട കോഡിന്റെ അവസാനത്തെ സൂചിപ്പിക്കുന്നു.
ഉദാഹരണം: ഒരു സോപാധിക പ്രസ്താവനയുടെ അടിസ്ഥാന ഉദാഹരണം എങ്കിൽ;..;പിന്നെ;...;മറ്റുള്ളവ
#!/bin/bash
എങ്കിൽ [ "foo" = "foo" ]; പിന്നെ
പ്രതിധ്വനി പദപ്രയോഗം സത്യമായി വിലയിരുത്തുന്നു
വേറെ

fi

ഉദാഹരണം: വേരിയബിളുകളുള്ള സോപാധിക പ്രസ്താവനകൾ
#!/bin/bash
T1="foo"
T2="ബാർ"
എങ്കിൽ [ "$T1" = "$T2" ]; പിന്നെ
പ്രതിധ്വനി പദപ്രയോഗം സത്യമായി വിലയിരുത്തുന്നു
വേറെ
പ്രതിധ്വനി പദപ്രയോഗം തെറ്റിനെ വിലയിരുത്തുന്നു
fi
വേണ്ടി, സമയത്ത്, ലൂപ്പുകൾ വരെ
ഈ വിഭാഗത്തിൽ, ലൂപ്പുകൾ വരെ, സമയത്ത്, ഒപ്പം വരെ നിങ്ങൾക്ക് പരിചിതമാകും.
ഫോർ ലൂപ്പ് മറ്റ് പ്രോഗ്രാമിംഗ് ഭാഷകളിലെ എതിരാളികളിൽ നിന്ന് അല്പം വ്യത്യസ്തമാണ്. ഒന്നാമതായി, ഇത് നിങ്ങൾക്ക് അവതരിപ്പിക്കാനുള്ള അവസരം നൽകുന്നു സ്ഥിരമായ പ്രവർത്തനങ്ങൾവരിയിലെ "വാക്കുകൾക്ക്" മുകളിൽ.
പരീക്ഷിക്കുന്ന പദപ്രയോഗം ശരിയാണെങ്കിൽ, while ലൂപ്പ് ഒരു കോഡിന്റെ ഒരു ഭാഗം നിർവ്വഹിക്കുന്നു; കൂടാതെ അത് തെറ്റാണെങ്കിൽ നിർത്തുന്നു (അല്ലെങ്കിൽ എക്സിക്യൂട്ടിംഗ് കോഡിനുള്ളിൽ വ്യക്തമായി വ്യക്തമാക്കിയ ലൂപ്പ് തടസ്സം നേരിട്ടു).
വരെ ലൂപ്പ്, while ലൂപ്പിന് ഏതാണ്ട് സമാനമാണ്. പരീക്ഷിക്കുന്ന പദപ്രയോഗം തെറ്റാണെങ്കിൽ കോഡ് എക്സിക്യൂട്ട് ചെയ്യപ്പെടും എന്നതാണ് വ്യത്യാസം.
എപ്പോൾ, വരെ വളരെ സാമ്യമുള്ളതാണെന്ന് നിങ്ങൾ അനുമാനിക്കുകയാണെങ്കിൽ, നിങ്ങൾ ശരിയാണ്.

ലൂപ്പിനുള്ള ഉദാഹരണം

#!/bin/bash
ഞാൻ $(ls) ൽ; ചെയ്യുക
പ്രതിധ്വനി ഇനം: $i
ചെയ്തു

രണ്ടാമത്തെ വരിയിൽ $(;ls;)-ൽ അടങ്ങിയിരിക്കുന്ന വിവിധ മൂല്യങ്ങൾ സ്വീകരിക്കുന്ന ഒരു വേരിയബിളായി ഞങ്ങൾ i-യെ പ്രതിനിധീകരിക്കുന്നു.

ആവശ്യമെങ്കിൽ, മൂന്നാമത്തെ വരി നീളമുള്ളതാകാം; അല്ലെങ്കിൽ പൂർത്തിയാക്കുന്നതിന് മുമ്പ് നിരവധി വരികൾ ഉണ്ടാകാം (നാലാമത്തെ വരി).

"done" (4-ആം വരി) സൂചിപ്പിക്കുന്നത് $i ഉപയോഗിച്ചുള്ള കോഡ് അവസാനിക്കുകയും $i ഒരു പുതിയ മൂല്യം നൽകുകയും ചെയ്യുന്നു എന്നാണ്.

ഈ സ്ക്രിപ്റ്റ് വലിയ പ്രാധാന്യമുള്ളതല്ല. ഫോർ ലൂപ്പിന്റെ കൂടുതൽ ഉപയോഗപ്രദമായ ഉപയോഗം, മുമ്പത്തെ ഉദാഹരണത്തിലെ ചില ഫയലുകൾ മാത്രം തിരഞ്ഞെടുക്കുന്നതിന് ഇത് ഉപയോഗിക്കുക എന്നതാണ്.
വേണ്ടി സി-ലൈക്ക്

ഫിഷ് ഈ ലൂപ്പ് ഫോം ചേർക്കാൻ നിർദ്ദേശിച്ചു. ഇത് ഫോർ ലൂപ്പാണ്, സി, പേൾ മുതലായവയിലെ ഫോർ ലൂപ്പിന് സമാനമാണ്.

#!/bin/bash
ഞാൻ `seq 1 10`-ൽ;
ചെയ്യുക
പ്രതിധ്വനി $i
ചെയ്തു
ഉദാഹരണം ലൂപ്പ് സമയത്ത്:
#!/bin/bash
COUNTER=0
അതേസമയം [ $COUNTER -lt 10 ]; ചെയ്യുക
പ്രതിധ്വനി $COUNTER ആണ്
COUNTER=COUNTER+1 അനുവദിക്കുക
ചെയ്തു

ഈ സ്ക്രിപ്റ്റ് അറിയപ്പെടുന്ന (സി, പാസ്കൽ, പേൾ മുതലായവയിൽ) ഘടനയെ "അനുകരിക്കുന്നു".

ലൂപ്പ് വരെ ഉദാഹരണം:

#!/bin/bash
COUNTER=20
[ $COUNTER -lt 10 ] വരെ; ചെയ്യുക
എക്കോ കൗണ്ടർ $COUNTER
COUNTER-=1 അനുവദിക്കുക
ചെയ്തു

പ്രവർത്തനങ്ങൾ

മറ്റേതൊരു പ്രോഗ്രാമിംഗ് ഭാഷയും പോലെ, നിങ്ങൾക്ക് കൂടുതൽ യുക്തിസഹമായ രീതിയിൽ കോഡ് കഷണങ്ങൾ ഗ്രൂപ്പുചെയ്യാൻ ഫംഗ്‌ഷനുകൾ ഉപയോഗിക്കാം, അതുപോലെ തന്നെ ആവർത്തനത്തിന്റെ മാന്ത്രിക കല പരിശീലിക്കാം.

ഒരു ഫംഗ്ഷൻ ഡിക്ലറേഷൻ ഒരു ഫംഗ്ഷൻ my_func (my_code ) എൻട്രി മാത്രമാണ്.

ഒരു ഫംഗ്‌ഷൻ വിളിക്കുന്നത് മറ്റ് പ്രോഗ്രാമുകളെ വിളിക്കുന്നതുപോലെ തന്നെ നടപ്പിലാക്കുന്നു. നീ അവളുടെ പേര് എഴുതിയാൽ മതി.

ഉദാഹരണ പ്രവർത്തനങ്ങൾ
#!/bin/bash
പ്രവർത്തനം ഉപേക്ഷിക്കുക (
പുറത്ത്
}
ഫംഗ്ഷൻ ഹലോ(
പ്രതിധ്വനി ഹലോ!
}
ഹലോ
ഉപേക്ഷിക്കുക
echo foo
2-4 വരികളിൽ "ക്വിറ്റ്" ഫംഗ്ഷൻ അടങ്ങിയിരിക്കുന്നു. 5-7 വരികളിൽ "ഹലോ" ഫംഗ്ഷൻ അടങ്ങിയിരിക്കുന്നു. ഈ സ്ക്രിപ്റ്റ് നടത്തുന്ന പ്രക്രിയ നിങ്ങൾക്ക് മനസ്സിലാകുന്നില്ലെങ്കിൽ, അത് പരീക്ഷിച്ചുനോക്കൂ!

ഏതെങ്കിലും പ്രത്യേക ക്രമത്തിൽ ഫംഗ്ഷനുകൾ പ്രഖ്യാപിക്കേണ്ട ആവശ്യമില്ല എന്നത് ശ്രദ്ധിക്കേണ്ടതാണ്.

നിങ്ങൾ സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കുകയാണെങ്കിൽ, "ഹലോ" ഫംഗ്ഷൻ ആദ്യം വിളിക്കുന്നത് ശ്രദ്ധിക്കുക, തുടർന്ന് "ക്വിറ്റ്" ഫംഗ്ഷൻ. പ്രോഗ്രാമിനെ സംബന്ധിച്ചിടത്തോളം, അത് ഒരിക്കലും പത്താം വരിയിൽ എത്തുന്നില്ല.

പരാമീറ്ററുകളുള്ള പ്രവർത്തനങ്ങളുടെ ഉദാഹരണം
#!/bin/bash
പ്രവർത്തനം ഉപേക്ഷിക്കുക (
പുറത്ത്
}
ഫംഗ്ഷൻ ഇ (
പ്രതിധ്വനി $1
}
ഹലോ
ഇ ലോകം
ഉപേക്ഷിക്കുക
echo foo
ഈ സ്ക്രിപ്റ്റ് മുമ്പത്തേതിന് ഏതാണ്ട് സമാനമാണ്. പ്രധാന വ്യത്യാസം "ഇ" ഫംഗ്ഷനാണ്. അത് ലഭിക്കുന്ന ആദ്യത്തെ ആർഗ്യുമെന്റ് അത് പ്രിന്റ് ചെയ്യുന്നു. സ്ക്രിപ്റ്റിലേക്ക് ആർഗ്യുമെന്റുകൾ കൈമാറുന്നതുപോലെ ഫംഗ്ഷനുകളിലെ ആർഗ്യുമെന്റുകളും പ്രോസസ്സ് ചെയ്യപ്പെടുന്നു.

ഉപയോക്തൃ ഇന്റർഫേസുകൾ

ലളിതമായ മെനുകൾ സൃഷ്ടിക്കാൻ തിരഞ്ഞെടുക്കുക ഉപയോഗിക്കുക
#!/bin/bash
ഓപ്ഷനുകൾ="ഹലോ ക്വിറ്റ്"
$OPTIONS-ൽ തിരഞ്ഞെടുക്കുക; ചെയ്യുക
എങ്കിൽ [ "$opt" = "പുറത്തുകടക്കുക" ]; പിന്നെ
പ്രതിധ്വനി ചെയ്തു
പുറത്ത്
elif [ "$opt" = "ഹലോ" ]; പിന്നെ
പ്രതിധ്വനി ഹലോ വേൾഡ്
വേറെ
വ്യക്തമായ
എക്കോ മോശം ഓപ്ഷൻ
fi
ചെയ്തു
നിങ്ങൾ ഈ സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കുകയാണെങ്കിൽ, ടെക്സ്റ്റ് അടിസ്ഥാനമാക്കിയുള്ള മെനു ഒരു പ്രോഗ്രാമറുടെ സ്വപ്നമാണെന്ന് നിങ്ങൾ കാണും. ഇത് "ഫോർ" കൺസ്ട്രക്‌റ്റുമായി വളരെ സാമ്യമുള്ളതാണെന്ന് നിങ്ങൾ ശ്രദ്ധിച്ചിരിക്കാം, എന്നാൽ $OPTIONS-ലെ ഓരോ "വാക്കും" ലൂപ്പ് ചെയ്യുന്നതിന് പകരം, പ്രോഗ്രാം ഉപയോക്താവിനെ വോട്ടെടുപ്പ് നടത്തുന്നു.
കമാൻഡ് ലൈൻ ഉപയോഗിക്കുന്നു
#!/bin/bash
എങ്കിൽ [ -z "$1" ]; പിന്നെ
എക്കോ ഉപയോഗം: $0 ഡയറക്ടറി
പുറത്ത്
fi
SRCD=$1 #SRCD - Source Directory - source directory

ടാർ -cZf $TGTD$OF $എസ്ആർസിഡി
ഈ സ്ക്രിപ്റ്റ് എന്താണ് ചെയ്യുന്നതെന്ന് നിങ്ങൾക്ക് വ്യക്തമായിരിക്കണം. ആദ്യത്തേതിലെ ഭാവം സോപാധിക ഓപ്പറേറ്റർപ്രോഗ്രാമിന് ഒരു ആർഗ്യുമെന്റ് ലഭിച്ചോ എന്ന് പരിശോധിക്കുന്നു ($1). ഇല്ലെങ്കിൽ, ഉപയോക്താവിന് ഒരു ചെറിയ പിശക് സന്ദേശം നൽകി പ്രോഗ്രാം അവസാനിപ്പിക്കുന്നു. ശേഷിക്കുന്നത് ഈ നിമിഷംസ്ക്രിപ്റ്റിന്റെ ഭാഗം വ്യക്തമായി മനസ്സിലാക്കാവുന്നതേയുള്ളൂ.

വിവിധ

റീഡിനൊപ്പം ഉപയോക്തൃ ഇൻപുട്ട് വായിക്കുന്നു

ചില സാഹചര്യങ്ങളിൽ, എന്തെങ്കിലും നൽകാൻ ഉപയോക്താവിനോട് ആവശ്യപ്പെടേണ്ടി വന്നേക്കാം. നിലവിലുണ്ട് വിവിധ വഴികൾഇത് ചെയ്യുന്നത്. ഒരു വഴി ഇനിപ്പറയുന്നതാണ്:

#!/bin/bash
echo ദയവായി നിങ്ങളുടെ പേര് നൽകുക
NAME വായിക്കുക
പ്രതിധ്വനി "ഹലോ $NAME!"

പകരമായി, റീഡ് ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഒരേസമയം ഒന്നിലധികം മൂല്യങ്ങൾ ലഭിക്കും. ഇനിപ്പറയുന്ന ഉദാഹരണം ഇത് വിശദീകരിക്കുന്നു:
#!/bin/bash
പ്രതിധ്വനി "ദയവായി നിങ്ങളുടെ പേരിന്റെ ആദ്യഭാഗവും അവസാന നാമവും നൽകുക"
FN LN വായിക്കുക #FN - ആദ്യനാമം - പേര്; LN - അവസാന നാമം - കുടുംബപ്പേര്
പ്രതിധ്വനി "ഹായ്! $LN, $FN !"

ഗണിത കണക്കുകൂട്ടലുകൾ

IN കമാൻഡ് ലൈൻ(അല്ലെങ്കിൽ ഷെൽ) ഇനിപ്പറയുന്നവ ടൈപ്പുചെയ്യാൻ ശ്രമിക്കുക:
പ്രതിധ്വനി;1;+;1
നിങ്ങൾ "2" കാണുമെന്ന് പ്രതീക്ഷിച്ചാൽ, നിങ്ങൾ നിരാശനാകും. നിങ്ങളുടെ നമ്പറുകളിൽ കണക്കുകൂട്ടലുകൾ നടത്താൻ നിങ്ങൾക്ക് ബാഷ് ആവശ്യമുണ്ടെങ്കിൽ എന്തുചെയ്യണം? പരിഹാരം ഇതാണ്:
പ്രതിധ്വനി;$((1+1))
തൽഫലമായി, നിഗമനം കൂടുതൽ "ലോജിക്കൽ" ആയിരിക്കും. ഗണിത പദപ്രയോഗങ്ങൾ വിലയിരുത്താൻ ഈ നൊട്ടേഷൻ ഉപയോഗിക്കുന്നു. നിങ്ങൾക്ക് ഇത് ഇതുപോലെയും ചെയ്യാം:
പ്രതിധ്വനി;$
നിങ്ങൾക്ക് ഭിന്നസംഖ്യകളോ സങ്കീർണ്ണമായ ഗണിതമോ ഉപയോഗിക്കണമെങ്കിൽ, ഗണിത പദപ്രയോഗങ്ങൾ വിലയിരുത്താൻ നിങ്ങൾക്ക് bc ഉപയോഗിക്കാം.
രചയിതാവ് "എക്കോ;$" എന്നതിൽ ഓടിക്കുമ്പോൾ കമാൻഡ് ഷെൽ, അത് മൂല്യം 0 നൽകി. കാരണം, ബാഷ് പ്രതികരിക്കുകയാണെങ്കിൽ, അത് പൂർണ്ണസംഖ്യ മൂല്യങ്ങൾ മാത്രമേ ഉപയോഗിക്കുന്നുള്ളൂ. നിങ്ങൾ "echo;3/4|bc;-l" റൺ ചെയ്യുകയാണെങ്കിൽ, ഷെൽ ശരിയായ മൂല്യം 0.75 നൽകും.

ബാഷ് തിരയൽ

മൈക്കിൽ നിന്നുള്ള സന്ദേശത്തിൽ നിന്ന് ("അംഗീകാരങ്ങൾ" വിഭാഗം കാണുക):

നിങ്ങൾ എപ്പോഴും #!/bin/bash ഉപയോഗിക്കുന്നു .. ബാഷ് എവിടെയാണെന്ന് എങ്ങനെ കണ്ടെത്താം എന്നതിന് ഒരു ഉദാഹരണം നൽകാമോ.
"ലൊക്കേറ്റ് ബാഷ്" ഉപയോഗിക്കുന്നതാണ് നല്ലത്, എന്നാൽ എല്ലാ മെഷീനുകളിലും ലൊക്കേറ്റ് ലഭ്യമല്ല.
റൂട്ട് ഡയറക്ടറിയിൽ നിന്നുള്ള "find ./ -name bash" സാധാരണയായി പ്രവർത്തിക്കുന്നു.
നിങ്ങൾക്ക് ഇനിപ്പറയുന്ന ലൊക്കേഷനുകൾ പരിശോധിക്കാം:
ls -l /bin/bash
ls -l /sbin/bash
ls -l /usr/local/bin/bash
ls -l /usr/bin/bash
ls -l /usr/sbin/bash
ls -l /usr/local/sbin/bash
(മറ്റൊരു ഡയറക്‌ടറിയും പെട്ടെന്ന് ചിന്തിക്കാൻ രചയിതാവിന് കഴിയുന്നില്ല... ഈ സ്ഥലങ്ങളിൽ മിക്കയിടത്തും വിവിധ സിസ്റ്റങ്ങളിൽ അദ്ദേഹം ബാഷ് കണ്ടെത്തി).

നിങ്ങൾക്ക് "ഏത് ബാഷ്" എന്നും ശ്രമിക്കാവുന്നതാണ്.

പ്രോഗ്രാമിന്റെ റിട്ടേൺ മൂല്യം നേടുന്നു

ബാഷിൽ, പ്രോഗ്രാമിന്റെ റിട്ടേൺ മൂല്യം $? എന്ന പ്രത്യേക വേരിയബിളിൽ സംഭരിച്ചിരിക്കുന്നു.

ഈ ഉദാഹരണംഒരു പ്രോഗ്രാമിന്റെ റിട്ടേൺ മൂല്യം എങ്ങനെ തടസ്സപ്പെടുത്താമെന്ന് ചിത്രീകരിക്കുന്നു; ദാദ ഡയറക്‌ടറി നിലവിലില്ലെന്ന് രചയിതാവ് അനുമാനിച്ചു (ഇതും മൈക്ക് നിർദ്ദേശിച്ചു).
#!/bin/bash
cd /dada &> /dev/null
echo rv: $?
cd $(pwd) &> /dev/null
echo rv: $?

കമാൻഡ് ഔട്ട്പുട്ട് തടസ്സപ്പെടുത്തുന്നു

ഈ ചെറിയ സ്ക്രിപ്റ്റ് എല്ലാ ഡാറ്റാബേസുകളിൽ നിന്നുമുള്ള എല്ലാ പട്ടികകളും അവതരിപ്പിക്കുന്നു (നിങ്ങൾ MySQL ഇൻസ്റ്റാൾ ചെയ്തിട്ടുണ്ടെന്ന് കരുതുക). കൂടാതെ, അനുയോജ്യമായ ഉപയോക്തൃനാമവും പാസ്‌വേഡും ഉപയോഗിക്കുന്നതിന് "mysql" കമാൻഡ് പരിവർത്തനം ചെയ്യുന്നതിനുള്ള വഴികളെക്കുറിച്ച് നിങ്ങൾ ചിന്തിക്കണം.
#!/bin/bash
DBS=`mysql -uroot -e"show databases"`
$DBS-ൽ ബിക്ക്;
ചെയ്യുക
mysql -uroot -e"$b-ൽ നിന്നുള്ള പട്ടികകൾ കാണിക്കുക"
ചെയ്തു

ഒന്നിലധികം ഉറവിട ഫയലുകൾ

സോഴ്സ് കമാൻഡ് ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഒന്നിലധികം ഫയലുകൾ പ്രവർത്തിപ്പിക്കാൻ കഴിയും.

ചെയ്യാൻ__
11. പട്ടികകൾ
11.1 സ്ട്രിംഗ് താരതമ്യ ഓപ്പറേറ്റർമാർ
(1) s1 = s2
(2) s1 != s2
(3) s1< s2
(4) s1 > s2
(5) -n s1
(6) -z s1
(1) s1 s2 മായി യോജിക്കുന്നു
(2) s1 s2 മായി പൊരുത്തപ്പെടുന്നില്ല
(3) s1 ഇഞ്ച് അക്ഷരമാല ക്രമത്തിൽമുമ്പുള്ള s2 (നിലവിലെ ഭാഷ അനുസരിച്ച്)
(4) s2 ന് ശേഷം അക്ഷരമാലാക്രമത്തിൽ s1 വരുന്നു (നിലവിലെ ഭാഷ അനുസരിച്ച്)
(5) s1-ന് പൂജ്യമല്ലാത്ത ഒരു മൂല്യമുണ്ട് (ഒരു പ്രതീകമോ അതിൽ കൂടുതലോ അടങ്ങിയിരിക്കുന്നു)
(6) s1 ന് പൂജ്യം മൂല്യമുണ്ട്
11.2 സ്ട്രിംഗ് താരതമ്യത്തിന്റെ ഉദാഹരണങ്ങൾ

രണ്ട് സ്ട്രിംഗുകൾ താരതമ്യം ചെയ്യുന്നു.
#!/bin/bash
S1="സ്ട്രിംഗ്"
S2="സ്ട്രിംഗ്"
[$S1=$S2] എങ്കിൽ;
പിന്നെ
പ്രതിധ്വനി "S1("$S1") S2-ന് തുല്യമല്ല ("$S2")"
fi
[$S1=$S1] എങ്കിൽ;
പിന്നെ
പ്രതിധ്വനി "S1("$S1") എന്നത് S1("$S1")" ന് തുല്യമാണ്
fi
ഈ ഘട്ടത്തിൽ, if [$1 = $2 ] എന്നതിന്റെ ഉപയോഗത്തെക്കുറിച്ച് ആൻഡ്രിയാസ് ബെക്കിൽ നിന്ന് ലഭിച്ച ഒരു ഇമെയിലിൽ നിന്ന് ഒരു പരാമർശം ഉദ്ധരിക്കേണ്ടത് ആവശ്യമാണെന്ന് രചയിതാവിന് തോന്നുന്നു.
ഇത് നല്ല ആശയമല്ല, കാരണം $S1 അല്ലെങ്കിൽ $S2 ഒരു ശൂന്യമായ സ്ട്രിംഗ് ആണെങ്കിൽ, നിങ്ങൾക്ക് ഒരു വാക്യഘടന പിശക് ലഭിക്കും. x$1;=;x$2 അല്ലെങ്കിൽ "$1";=;"$2" ഉപയോഗിക്കുന്നത് കൂടുതൽ സ്വീകാര്യമായിരിക്കും.
11.3 അരിത്മെറ്റിക് ഓപ്പറേറ്റർമാർ
+
-
*
% (ബാക്കിയുള്ളത്)
11.4 അരിത്മെറ്റിക് ഓപ്പറേറ്റർമാർതാരതമ്യങ്ങൾ
-lt (<)
-gt (>)
-ലെ (<=)
-ge (>=)
-eq (==)
-ne (!=)
C പ്രോഗ്രാമർമാർ പരാൻതീസിസിൽ തിരഞ്ഞെടുത്ത ഓപ്പറേറ്ററുമായി പൊരുത്തപ്പെടുന്ന ഓപ്പറേറ്ററെ തിരഞ്ഞെടുക്കേണ്ടതുണ്ട്.

ഉപയോഗപ്രദമായ കമാൻഡുകൾ

ഈ ഭാഗം കീസ് മാറ്റിയെഴുതി (അക്നോളജ്‌മെന്റ് വിഭാഗം കാണുക).

ഈ കമാൻഡുകളിൽ ചിലത് പ്രായോഗികമായി പൂർണ്ണമായ കമാൻഡ് ഭാഷകൾ ഉൾക്കൊള്ളുന്നു. അത്തരം കമാൻഡുകളുടെ അടിസ്ഥാനകാര്യങ്ങൾ മാത്രമാണ് ഇവിടെ വിശദീകരിക്കുന്നത്. കൂടുതൽ വിവരങ്ങൾക്ക്, ഓരോ കമാൻഡിന്റെയും മാൻ പേജുകൾ ശ്രദ്ധാപൂർവ്വം അവലോകനം ചെയ്യുക.
സെഡ് (സ്ട്രീം എഡിറ്റർ)
സെഡ് ഒരു നോൺ-ഇന്ററാക്ടീവ് എഡിറ്ററാണ്. സ്‌ക്രീനിലെ കഴ്‌സർ നീക്കി ഫയൽ മാറ്റുന്നതിന് പകരം, നിങ്ങൾ എഡിറ്റ് ചെയ്യുന്ന ഫയലിന്റെ പേരിനൊപ്പം ഒരു സെഡ് എഡിറ്റിംഗ് നിർദ്ദേശങ്ങൾ സ്‌ക്രിപ്റ്റ് ഉപയോഗിക്കണം. സെഡ് ഒരു ഫിൽട്ടറായും നിങ്ങൾക്ക് ചിന്തിക്കാം. ചില ഉദാഹരണങ്ങൾ നോക്കുക:
$sed "s/to_be_replaced/replaced/g" /tmp/dummy
/tmp/dummy ഫയൽ വായിച്ചുകൊണ്ട് Sed "to_be_replaced" എന്ന സ്ട്രിംഗ് "replaced" ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുന്നു. ഫലം സ്റ്റാൻഡേർഡ് ഔട്ട്‌പുട്ടിലേക്ക് (സാധാരണയായി കൺസോൾ) അയയ്‌ക്കും, എന്നാൽ "ക്യാപ്‌ചർ" ഫയലിലേക്ക് ഔട്ട്‌പുട്ട് അയയ്‌ക്കുന്നതിന് മുകളിലുള്ള വരിയിലേക്ക് നിങ്ങൾക്ക് ">;ക്യാപ്‌ചർ" ചേർക്കാനും കഴിയും.
$sed 12, 18d /tmp/dummy
12 മുതൽ 18 വരെയുള്ള വരികൾ ഒഴികെയുള്ള എല്ലാ വരികളും സെഡ് പ്രദർശിപ്പിക്കുന്നു. ഈ കമാൻഡ് മുഖേന സോഴ്‌സ് ഫയൽ പരിഷ്‌ക്കരിച്ചിട്ടില്ല.
awk (ഡാറ്റ ഫയൽ കൃത്രിമം, ടെക്സ്റ്റ് വീണ്ടെടുക്കൽ, പ്രോസസ്സിംഗ്)
AWK പ്രോഗ്രാമിംഗ് ഭാഷയുടെ ഒരു വലിയ സംഖ്യ നടപ്പിലാക്കലുകൾ ഉണ്ട് (ഏറ്റവും സാധാരണമായ വ്യാഖ്യാതാക്കൾ GNU പ്രോജക്റ്റിൽ നിന്നുള്ള gawk, "new awk" mawk എന്നിവയാണ്.) തത്വം വളരെ ലളിതമാണ്: AWK ഒരു പാറ്റേൺ തിരയുകയാണ്; പൊരുത്തപ്പെടുന്ന ഓരോ ടെംപ്ലേറ്റിനും, ചില പ്രവർത്തനങ്ങൾ നടത്തുന്നു.
അടങ്ങുന്ന ഡമ്മി ഫയൽ രചയിതാവ് വീണ്ടും സൃഷ്ടിച്ചു ഇനിപ്പറയുന്ന വരികൾ:
"ടെസ്റ്റ് 123
പരീക്ഷ
tteesstt"

$awk "/test/ (print)" /tmp/dummy
ടെസ്റ്റ്123
പരീക്ഷ
AWK തിരയുന്ന പാറ്റേൺ "ടെസ്റ്റ്" ആണ്, കൂടാതെ /tmp/dummy എന്നതിൽ "ടെസ്റ്റ്" എന്ന സബ്‌സ്ട്രിംഗ് ഉള്ള ഒരു ലൈൻ നേരിടുമ്പോൾ AWK എടുക്കുന്ന പ്രവർത്തനം "പ്രിന്റ്" ആണ്.
$awk "/test/ (i=i+1) END (print i)" /tmp/dummy
നിങ്ങൾ ഒന്നിലധികം പാറ്റേണുകൾക്കായി തിരയുകയാണെങ്കിൽ, ഉദ്ധരണികൾക്കിടയിലുള്ള വാചകം "-f;file.awk" ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുക. ഈ സാഹചര്യത്തിൽ, "file.awk" എന്ന ഫയലിൽ നിങ്ങൾക്ക് എല്ലാ ടെംപ്ലേറ്റുകളും പ്രവർത്തനങ്ങളും എഴുതാം.
grep (തിരയൽ പാറ്റേണുമായി പൊരുത്തപ്പെടുന്ന ലൈനുകൾ പ്രിന്റ് ചെയ്യുന്നു)
ഒരു പാറ്റേണുമായി പൊരുത്തപ്പെടുന്ന ലൈനുകൾ പ്രദർശിപ്പിക്കുന്ന മുൻ അധ്യായങ്ങളിൽ ഞങ്ങൾ നിരവധി grep കമാൻഡുകൾ പരിശോധിച്ചു. എന്നിരുന്നാലും, grep കൂടുതൽ കാര്യങ്ങൾ ചെയ്യാൻ കഴിയും.
$grep "ഇതിനായി തിരയുക" /var/log/messages -c
"ഇതിനായി തിരയുക" എന്ന സ്ട്രിംഗ് 12 തവണ /var/log/messages-ൽ കണ്ടെത്തി.
wc (വരികൾ, വാക്കുകൾ, ബൈറ്റുകൾ എന്നിവ കണക്കാക്കുന്നു)
ഇനിപ്പറയുന്ന ഉദാഹരണത്തിൽ, ഔട്ട്പുട്ട് ഞങ്ങൾ പ്രതീക്ഷിക്കുന്നതല്ലെന്ന് നിങ്ങൾ ശ്രദ്ധിക്കും. ഈ സാഹചര്യത്തിൽ, ഡമ്മി ഫയലിൽ ഇനിപ്പറയുന്ന വാചകം അടങ്ങിയിരിക്കുന്നു:
"ബാഷ് ആമുഖം
ഫയൽ എങ്ങനെ പരിശോധിക്കാം"
$wc --words --lines --bytes /tmp/dummy
2 5 34 /ടിഎംപി/ഡമ്മി
പാരാമീറ്ററുകളുടെ ക്രമം wc ശ്രദ്ധിക്കുന്നില്ല. അവൻ എപ്പോഴും അവരെ പുറത്തെടുക്കുന്നു സ്റ്റാൻഡേർഡ് നടപടിക്രമം: <число;строк><число;слов><число;байтов><имя;файла>.
അടുക്കുക (ഒരു ടെക്സ്റ്റ് ഫയലിന്റെ വരികൾ അടുക്കുന്നു)

ഈ സാഹചര്യത്തിൽ, ഡമ്മി ഫയലിൽ ഇനിപ്പറയുന്ന വാചകം അടങ്ങിയിരിക്കുന്നു:
"ബി
സി
ഒരു"
$sort /tmp/dummy
ഔട്ട്പുട്ട് ഇതുപോലെ കാണപ്പെടുന്നു:
എ
ബി
സി
കമാൻഡുകൾ വളരെ ലളിതമായിരിക്കരുത് :-)
ബിസി (കമ്പ്യൂട്ടേഷണൽ പ്രോഗ്രാമിംഗ് ഭാഷ)
bc കമാൻഡ് ലൈനിൽ നിന്ന് കണക്കുകൂട്ടലുകൾ നടത്തുന്നു (ഒരു ഫയലിൽ നിന്നുള്ള ഇൻപുട്ട്, പക്ഷേ റീഡയറക്‌ഷൻ അല്ലെങ്കിൽ പൈപ്പ്ലൈനിംഗ് വഴിയല്ല), അതുപോലെ നിന്ന് ഉപയോക്തൃ ഇന്റർഫേസ്. ഇനിപ്പറയുന്ന ഉദാഹരണം ചില കമാൻഡുകൾ കാണിക്കുന്നു. പ്രോംപ്റ്റ് സന്ദേശം അടിച്ചമർത്താൻ രചയിതാവ് -q ഓപ്ഷനോടൊപ്പം bc ഉപയോഗിച്ചുവെന്നത് ശ്രദ്ധിക്കുക.
$bc -q
1 == 5
0
0.05 == 0.05
1
5 != 5
0
2 ^ 8
256
ചതുരശ്ര (9)
3
അതേസമയം (i != 9) (
i = i + 1;
പ്രിന്റ് ഐ
}
123456789
ഉപേക്ഷിക്കുക
tput (ഒരു ടെർമിനൽ ആരംഭിക്കുന്നു അല്ലെങ്കിൽ ടെർമിൻഫോ ഡാറ്റാബേസ് അന്വേഷിക്കുന്നു)
tput ന്റെ കഴിവുകളുടെ ഒരു ചെറിയ ചിത്രം:

$tput കപ്പ് 10 4
കോർഡിനേറ്റുകളിൽ (y10,x4) കമാൻഡ് പ്രോംപ്റ്റ് ദൃശ്യമാകും.
$tput റീസെറ്റ്
സ്‌ക്രീൻ മായ്‌ക്കുകയും പ്രോംപ്റ്റ് (y1,x1) എന്നതിൽ ദൃശ്യമാവുകയും ചെയ്യുന്നു. (y0,x0) മുകളിൽ ഇടത് കോണാണെന്ന കാര്യം ശ്രദ്ധിക്കുക.
$tputcols
80 x-ദിശയിൽ സാധ്യമായ പ്രതീകങ്ങളുടെ എണ്ണം പ്രദർശിപ്പിക്കുന്നു.
ഈ പ്രോഗ്രാമുകൾ (കുറഞ്ഞത്) പരിചയപ്പെടാൻ ശക്തമായി ശുപാർശ ചെയ്യുന്നു. കമാൻഡ് ലൈനിൽ യഥാർത്ഥ മാജിക് ചെയ്യാൻ നിങ്ങൾക്ക് അവസരം നൽകുന്ന നിരവധി ചെറിയ പ്രോഗ്രാമുകൾ ഉണ്ട്.
[ചില ഉദാഹരണങ്ങൾ മാൻ പേജുകളിൽ നിന്നോ പതിവുചോദ്യങ്ങളിൽ നിന്നോ എടുത്തതാണ്.]

കൂടുതൽ സ്ക്രിപ്റ്റുകൾ

ഒരു ഡയറക്ടറിയിലെ എല്ലാ ഫയലുകളിലും കമാൻഡ് പ്രയോഗിക്കുക.

ഉദാഹരണം: വളരെ ലളിതമായ ബാക്കപ്പ് സ്ക്രിപ്റ്റ് (കൂടുതൽ കാര്യക്ഷമമായത്)

#!/bin/bash
SRCD="/home/" #SRCD - Source Directory - source directory
TGTD="/var/backups/" #TGTD - TarGeT ഡയറക്ടറി - അന്തിമ ഡയറക്ടറി
OF=home-$(date +%Y%m%d).tgz #OF - ഔട്ട്‌പുട്ട് ഫയൽ - ഔട്ട്‌പുട്ട് ഫയൽ
ടാർ -cZf $TGTD$OF $എസ്ആർസിഡി

ഫയൽ പുനർനാമകരണ പ്രോഗ്രാം

#!/bin/sh
# renna: പ്രത്യേക നിയമങ്ങൾ ഉപയോഗിച്ച് ഒന്നിലധികം ഫയലുകളുടെ പേരുമാറ്റുക
# രചയിതാവ് - ഫെലിക്സ് ഹഡ്സൺ ജനുവരി - 2000

#ആദ്യം, ഈ പ്രോഗ്രാമിലുള്ള വ്യത്യസ്ത "മോഡുകൾ" നോക്കുക.
#ആദ്യ വാദം ($1) അനുയോജ്യമാണെങ്കിൽ, ഞങ്ങൾ ഈ ഭാഗം എക്സിക്യൂട്ട് ചെയ്യുന്നു
#പ്രോഗ്രാമുകൾ കഴിഞ്ഞ് പോകൂ.

# ഒരു പ്രിഫിക്സ് ചേർക്കുന്നതിനുള്ള സാധ്യത പരിശോധിക്കുക.
എങ്കിൽ [ $1 = p ]; പിന്നെ

#ഇനി നമുക്ക് മുന്നോട്ട് പോകാം മോഡ് വേരിയബിൾ($1) പ്രിഫിക്സും ($2)
ഉപസർഗ്ഗം=$2 ; ഷിഫ്റ്റ് ; ഷിഫ്റ്റ്

# കുറഞ്ഞത് ഒരു ഫയലെങ്കിലും വ്യക്തമാക്കിയിട്ടുണ്ടോയെന്ന് പരിശോധിക്കണം.
# അല്ലെങ്കിൽ, നിലവിലില്ലാത്തതിന്റെ പേരുമാറ്റുകയല്ലാതെ ഒന്നും ചെയ്യാതിരിക്കുന്നതാണ് നല്ലത്
# ഫയലുകൾ!!

എങ്കിൽ [$1 = ]; പിന്നെ

പുറത്തുകടക്കുക 0
fi

# ഇത് ഞങ്ങൾ വ്യക്തമാക്കിയ എല്ലാ ഫയലുകളും ലൂപ്പ് പ്രോസസ്സ് ചെയ്യുന്നു
# പ്രോഗ്രാം.
# ഇത് ഒരു ഫയലിന് ഒരു പേരുമാറ്റം നടത്തുന്നു.
ഫയലിനായി$*-ൽ
ചെയ്യുക
mv $(ഫയൽ) $prefix$file
ചെയ്തു

#ഇതിനു ശേഷം പ്രോഗ്രാം പുറത്തുകടക്കുന്നു.
പുറത്തുകടക്കുക 0
fi

# ഒരു സഫിക്സ് ചേർക്കുന്നതിന്റെ അവസ്ഥ പരിശോധിക്കുക.
# അല്ലെങ്കിൽ, ഈ ഭാഗം മുമ്പത്തെ വിഭാഗവുമായി ഫലത്തിൽ സമാനമാണ്;
# ദയവായി അതിൽ അടങ്ങിയിരിക്കുന്ന അഭിപ്രായങ്ങൾ കാണുക.
[$1 = s] എങ്കിൽ; പിന്നെ
പ്രത്യയം=$2 ; ഷിഫ്റ്റ് ; ഷിഫ്റ്റ്
എങ്കിൽ [$1 = ]; പിന്നെ
പ്രതിധ്വനി "ഫയലുകളൊന്നും വ്യക്തമാക്കിയിട്ടില്ല"
പുറത്തുകടക്കുക 0
fi
$* എന്നതിലെ ഫയലിനായി
ചെയ്യുക
mv $(ഫയൽ) $file$suffix
ചെയ്തു
പുറത്തുകടക്കുക 0
fi

# മാറ്റിസ്ഥാപിക്കുന്നതിലൂടെ അവസ്ഥ പുനർനാമകരണം ചെയ്യുക.
[$1 = r] എങ്കിൽ; പിന്നെ
ഷിഫ്റ്റ്
# സുരക്ഷാ കാരണങ്ങളാൽ, ഉപയോക്താവാണെങ്കിൽ ഒരു ഫയലിനും കേടുപാടുകൾ വരുത്താതിരിക്കാൻ രചയിതാവ് ഈ ഭാഗം ഉൾപ്പെടുത്തിയിട്ടുണ്ട്
എന്ത് ചെയ്യണമെന്ന് # നിർവ്വചിച്ചിട്ടില്ല:
എങ്കിൽ [ $# -lt 3 ] ; പിന്നെ
പ്രതിധ്വനി "പിശക്; ശരിയായ ഇൻപുട്ട്: റെന്ന ആർ [എക്സ്‌പ്രഷൻ] [മാറ്റിസ്ഥാപിക്കൽ] ഫയലുകൾ..."
പുറത്തുകടക്കുക 0
fi

# മറ്റ് വിവരങ്ങൾ നോക്കാം
പഴയ=$1 ; പുതിയത്=$2 ; ഷിഫ്റ്റ് ; ഷിഫ്റ്റ്

# ഇത് ഫോർ ലൂപ്പ് തുടർച്ചയായി നമ്മൾ ചെയ്യുന്ന എല്ലാ ഫയലുകളിലൂടെയും കടന്നുപോകുന്നു
# പ്രോഗ്രാമിലേക്ക് നിയോഗിച്ചു.
# ഇത് "sed" പ്രോഗ്രാം ഉപയോഗിച്ച് ഒരു ഫയലിന് ഒരു പേരുമാറ്റുന്നു.
# ഇത് സ്റ്റാൻഡേർഡ് പാഴ്‌സ് ചെയ്യുന്ന ഒരു ലളിതമായ കമാൻഡ് ലൈൻ പ്രോഗ്രാമാണ്
# ഇൻപുട്ട്, നൽകിയിരിക്കുന്ന സ്ട്രിംഗ് ഉപയോഗിച്ച് റെഗുലർ എക്സ്പ്രഷൻ മാറ്റിസ്ഥാപിക്കുന്നു.
# ഇവിടെ നമ്മൾ സെഡിന് ഒരു ഫയൽനാമം (സ്റ്റാൻഡേർഡ് ഇൻപുട്ടായി) നൽകുകയും പകരം വയ്ക്കുകയും ചെയ്യുന്നു
# ആവശ്യമുള്ള വാചകം.
$* എന്നതിലെ ഫയലിനായി
ചെയ്യുക
പുതിയ=`എക്കോ $(ഫയൽ) | സെഡ് s/$(OLD)/$(പുതിയത്)/g`
mv $(ഫയൽ) $പുതിയത്
ചെയ്തു
പുറത്തുകടക്കുക 0
fi
# ഈ ലൈനിൽ എത്തിയാൽ പ്രോഗ്രാം കൊടുത്തു എന്നർത്ഥം
# അസാധുവായ പാരാമീറ്ററുകൾ. ഇക്കാര്യത്തിൽ, എങ്ങനെയെന്ന് ഉപയോക്താവിന് വിശദീകരിക്കണം
# ഉപയോഗം
എക്കോ "ഉപയോഗം:"
echo "renna p [പ്രിഫിക്സ്] ഫയലുകൾ.."
echo "renna s [suffix] ഫയലുകൾ.."
echo "renna r [expression] [replacement] files.."
പുറത്തുകടക്കുക 0
#ചെയ്തു!

ഫയൽ പുനർനാമകരണ പ്രോഗ്രാം (ലളിതം)
#!/bin/bash
#renames.sh
# ലളിതമായ പുനർനാമകരണ പ്രോഗ്രാം

മാനദണ്ഡം=$1
re_match=$2
പകരം=$3

$(ls *$മാനദണ്ഡം*) എന്നതിലെ i എന്നതിന്;
ചെയ്യുക
src=$i
tgt=$(echo $i | sed -e "s/$re_match/$replace/")
mv $src $tgt
ചെയ്തു

നിങ്ങൾ പ്രതീക്ഷിക്കുന്നതിൽ നിന്ന് വ്യത്യസ്തമാണ് സംഭവിക്കുന്നതെങ്കിൽ (ഡീബഗ്ഗിംഗ്)

എനിക്ക് എങ്ങനെ ബാഷിനെ വിളിക്കാം?

ആദ്യ വരിയിൽ ചേർത്താൽ നന്നായിരിക്കും

#!/bin/bash -x
ഇത് രസകരമായ ചില ഔട്ട്പുട്ട് വിവരങ്ങൾ നൽകും.

പ്രമാണത്തെ കുറിച്ച്

തിരുത്തലുകൾ, കൂട്ടിച്ചേർക്കലുകൾ അല്ലെങ്കിൽ ഈ പ്രമാണത്തിൽ ഉൾപ്പെടുത്തണമെന്ന് നിങ്ങൾക്ക് തോന്നുന്ന മറ്റെന്തെങ്കിലും ചെയ്യാൻ നിങ്ങൾ മടിക്കേണ്ടതില്ല. സാധ്യമാകുമ്പോഴെല്ലാം അത് അപ്ഡേറ്റ് ചെയ്യാൻ രചയിതാവ് ശ്രമിക്കും.

ഈ ചീറ്റ് ഷീറ്റ് ഇനിപ്പറയുന്ന വിഷയങ്ങൾ ഉൾക്കൊള്ളുന്നു: ഷെല്ലിലേക്കുള്ള ആമുഖം, നാവിഗേഷൻ, അടിസ്ഥാന കമാൻഡുകൾ, പരിസ്ഥിതി വേരിയബിളുകൾ, കണക്ടറുകൾ, പൈപ്പ് ലൈനുകൾ, I/O റീഡയറക്ഷൻ, അനുമതികൾ, കീ കോമ്പിനേഷനുകൾ.

ബാഷ് ഷെൽ: ആമുഖം

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

നാവിഗേഷൻ

ലിനക്സിൽ, ഫയലുകളും ഡയറക്ടറികളും ഉണ്ട് ശ്രേണിപരമായ സംഘടന, അതായത്, റൂട്ട് എന്ന് വിളിക്കപ്പെടുന്ന ഒരു നിശ്ചിത പ്രാരംഭ ഡയറക്ടറി ഉണ്ട്. അതിൽ ഫയലുകളും ഉപഡയറക്‌ടറികളും അടങ്ങിയിരിക്കുന്നു, അവയിൽ ഫയലുകളും അവയുടെ സ്വന്തം ഉപഡയറക്‌ടറികളും അടങ്ങിയിരിക്കുന്നു.

പിഡബ്ല്യുഡി

pwd കമാൻഡ്, ചുരുക്കത്തിൽ പ്രിന്റ് വർക്കിംഗ് ഡയറക്ടറി, ഡിസ്പ്ലേകൾ ഇപ്പോഴുള്ള സ്ഥലംഡയറക്ടറി ഘടനയിൽ.

സി.ഡി

ഒരു പുതിയ ഡയറക്ടറിയിലേക്ക് മാറാൻ cd കമാൻഡ് നിങ്ങളെ അനുവദിക്കുന്നു.

mkdir

mkdir കമാൻഡ് നിലവിലെ ഡയറക്ടറിയിൽ ഒരു പുതിയ ഡയറക്ടറി ഉണ്ടാക്കുന്നു.

അടിസ്ഥാന കമാൻഡുകൾ

മനുഷ്യൻ

മാൻ കമാൻഡ് കമാൻഡ് മാനുവലുകൾ പ്രദർശിപ്പിക്കുന്നു. ഉദാഹരണത്തിന്, ഇനിപ്പറയുന്ന കമാൻഡ് cat കമാൻഡിനെക്കുറിച്ചുള്ള എല്ലാ വിവരങ്ങളും പ്രദർശിപ്പിക്കും:

$ മനുഷ്യൻ പൂച്ച

പൂച്ച

ക്യാറ്റ് കമാൻഡ് ഒരു ആർഗ്യുമെന്റായി പാസ്സാക്കിയ ഫയൽ വായിക്കുകയും അതിലെ ഉള്ളടക്കങ്ങൾ പ്രിന്റ് ചെയ്യുകയും ചെയ്യുന്നു സാധാരണ ചാനൽഔട്ട്പുട്ട്. ഒന്നിലധികം ഫയലുകൾ ഒരു ആർഗ്യുമെന്റായി കൈമാറുന്നത് എല്ലാ ഫയലുകളുടെയും സംയോജിത ഉള്ളടക്കങ്ങൾ പ്രിന്റ് ചെയ്യും.

പ്രതിധ്വനി

എക്കോ കമാൻഡ് അതിന്റെ ആർഗ്യുമെന്റുകൾ സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ടിലേക്ക് പ്രിന്റ് ചെയ്യുന്നു.

$ എക്കോ ഹലോ വേൾഡ് ഹലോ വേൾഡ്

ആർഗ്യുമെന്റുകളില്ലാതെ നിങ്ങൾ എക്കോ വിളിക്കുകയാണെങ്കിൽ, ഒരു ശൂന്യമായ സ്ട്രിംഗ് പ്രിന്റ് ചെയ്യപ്പെടും.

തല

ഹെഡ് കമാൻഡ് ഏതെങ്കിലും ടെക്‌സ്‌റ്റിന്റെ ആദ്യ 10 വരികൾ വായിക്കുകയും അവയെ സാധാരണ പൈപ്പിലേക്ക് ഔട്ട്‌പുട്ട് ചെയ്യുകയും ചെയ്യുന്നു. പ്രദർശിപ്പിച്ചിരിക്കുന്ന വരികളുടെ എണ്ണം മാറ്റാവുന്നതാണ്:

$head -50 test.txt

വാൽ

ടെയിൽ കമാൻഡ് ഹെഡ് കമാൻഡിന് സമാനമായി പ്രവർത്തിക്കുന്നു, പക്ഷേ അവസാനം മുതൽ വരികൾ വായിക്കുന്നു:

$ ടെയിൽ -50 test.txt

-f ഫ്ലാഗ് ഉപയോഗിച്ച് നിങ്ങൾക്ക് തത്സമയം ഒരു ഫയലിലേക്ക് ചേർക്കുന്നത് കാണാനും കഴിയും:

$ ടെയിൽ -f test.txt

കുറവ്

രണ്ട് ദിശകളിലേക്കും ട്രാൻസ്ഫർ ചെയ്ത ഫയലിലൂടെയോ വാചകത്തിന്റെ ഭാഗത്തിലൂടെയോ നാവിഗേറ്റ് ചെയ്യാൻ കുറവ് കമാൻഡ് നിങ്ങളെ അനുവദിക്കുന്നു.

$ കുറവ് test.txt $ ps aux | കുറവ്

ചിഹ്നത്തിന്റെ ഉദ്ദേശ്യത്തെക്കുറിച്ച് കൂടുതലറിയുക | കമാൻഡിന്റെ ചരിത്ര വിഭാഗത്തിൽ ചുവടെ ഉൾപ്പെടുത്തും.

സാധാരണ കീബോർഡ് കുറുക്കുവഴികൾ	വിവരണം
ജി	ഫയലിന്റെ അവസാനഭാഗത്തേക്ക് നീങ്ങുന്നു
ജി	ഫയലിന്റെ തുടക്കത്തിലേക്ക് നീങ്ങുന്നു
:50	ഫയലിന്റെ 50-ാം വരിയിലേക്ക് നീങ്ങുന്നു
q	കുറച്ച് പുറത്തുകടക്കുക
/അന്വേഷണ പദം	നിലവിലെ സ്ട്രിംഗിന് താഴെയുള്ള ഒരു സ്ട്രിംഗ് പൊരുത്തപ്പെടുന്ന 'തിരയൽ ടെം' കണ്ടെത്തുന്നു
/
?അന്വേഷണ പദം	നിലവിലെ ലൈനിന് മുകളിൽ 'സെർച്ച്‌ടേം' പൊരുത്തപ്പെടുന്ന ഒരു ലൈൻ കണ്ടെത്തുന്നു
?	അടുത്ത പൊരുത്തപ്പെടുന്ന തിരയൽ ഫലത്തിലേക്ക് നീങ്ങുന്നു
മുകളിലേക്ക്	ഒരു വരി മുകളിലേക്ക് നീങ്ങുന്നു
താഴേക്ക്	ഒരു വരി താഴേക്ക് നീക്കുന്നു
പേജ്അപ്പ്	ഒരു പേജ് മുകളിലേക്ക് നീക്കുന്നു
അടുത്ത താൾ	ഒരു പേജ് താഴേക്ക് നീക്കുന്നു

സത്യം

വിജയത്തെ സൂചിപ്പിക്കുന്നതിന് യഥാർത്ഥ കമാൻഡ് എല്ലായ്പ്പോഴും പൂജ്യം ഔട്ട്പുട്ട് സ്റ്റാറ്റസ് ആയി നൽകുന്നു.

തെറ്റായ

പരാജയം സൂചിപ്പിക്കാൻ തെറ്റായ കമാൻഡ് എല്ലായ്പ്പോഴും പൂജ്യമല്ലാത്ത ഔട്ട്പുട്ട് സ്റ്റാറ്റസ് നൽകുന്നു.

$?

$? അവസാന കമാൻഡ് റണ്ണിന്റെ ഔട്ട്പുട്ട് സ്റ്റാറ്റസ് അടങ്ങുന്ന ഒരു വേരിയബിളാണ്. സ്റ്റാറ്റസ് സാധാരണയായി പ്രോഗ്രാമിന്റെ റിട്ടേൺ കോഡിനെ സൂചിപ്പിക്കുന്നു. 0 എന്നത് പ്രോഗ്രാമിന്റെ വിജയകരമായ നിർവ്വഹണം എന്നാണ് അർത്ഥമാക്കുന്നത്, 0-ൽ കൂടുതലുള്ള ഏതൊരു മൂല്യവും നിർവ്വഹണ സമയത്ത് ചില പിശകുകൾ സംഭവിച്ചുവെന്ന വസ്തുതയെ പ്രതിഫലിപ്പിക്കുന്നു. വഴിയിൽ, അതുകൊണ്ടാണ് ബാഷിൽ 0 സത്യമായി കണക്കാക്കുന്നത്, 0 അല്ലാത്തതെല്ലാം തെറ്റാണ്:

$true$echo$? 0 $ തെറ്റായ $ echo $? 1

grep

ഗ്രെപ് കമാൻഡ് ഇൻ പാസാക്കിയ സ്ട്രിങ്ങിനായി തിരയുന്നു വ്യക്തമാക്കിയ ഫയൽ:

$ cat users.txt ഉപയോക്താവ്:വിദ്യാർത്ഥി പാസ്‌വേഡ്:123 ഉപയോക്താവ്:അധ്യാപക രഹസ്യവാക്ക്:321 $ grep "student` file1.txt ഉപയോക്താവ്:വിദ്യാർത്ഥിയുടെ രഹസ്യവാക്ക്:123

വാചകത്തിന്റെ ഫോർമാറ്റ് പരിഷ്കരിക്കുന്നതിന് grep-ന് ഒന്നിലധികം ഫയലുകളും റെഗുലർ എക്സ്പ്രഷനുകളും സ്വീകരിക്കാൻ കഴിയും.

ചരിത്രം

ഹിസ്റ്ററി കമാൻഡ് കമാൻഡ് ലൈൻ ചരിത്രം പ്രദർശിപ്പിക്കുന്നു. ഒരു നിർദ്ദിഷ്‌ട കമാൻഡിനായി തിരയാൻ ഇത് സാധാരണയായി grep കമാൻഡുമായി സംയോജിച്ച് ഉപയോഗിക്കുന്നു. ഉദാഹരണത്തിന്, ഇനിപ്പറയുന്ന കോഡ് g++ സ്ട്രിംഗ് അടങ്ങുന്ന എല്ലാ കമാൻഡുകളും കണ്ടെത്തും:

$ചരിത്രം | grep g++ 155 g++ file1.txt 159 g++ file2.txt

ഇവിടെയും | ചിഹ്നം ഉപയോഗിക്കുന്നു. - ഇതാണ് കൺവെയർ (പൈപ്പ്) എന്ന് വിളിക്കപ്പെടുന്നത്. ഇതിന് നന്ദി, നിങ്ങൾക്ക് ഒരു കമാൻഡിന്റെ ഔട്ട്‌പുട്ട് മറ്റൊന്നിന്റെ ഇൻപുട്ടിലേക്ക് റീഡയറക്‌ട് ചെയ്യാൻ കഴിയും - അതിനാൽ, മുകളിലുള്ള ഉദാഹരണത്തിൽ, മുഴുവൻ സ്റ്റോറി, ഇതിൽ സാധാരണ നിലടെർമിനലിലേക്ക് നേരിട്ട് ഹിസ്റ്ററി കമാൻഡ് വഴിയുള്ള ഔട്ട്പുട്ട് ഇൻപുട്ടായി grep-ലേക്ക് റീഡയറക്ട് ചെയ്യപ്പെടും. നമ്മൾ ഹിസ്റ്ററി കമാൻഡിന്റെ ഔട്ട്പുട്ട് കാണില്ല, പക്ഷേ grep കമാൻഡിന്റെ ഔട്ട്പുട്ട് നമുക്ക് കാണാം.

പരിശീലനമില്ലാതെ ഇത് മനസിലാക്കാൻ വളരെ ബുദ്ധിമുട്ടാണ്, അതിനാൽ ls , history , ps (ചുവടെ വിവരിച്ചിരിക്കുന്നത്) കമാൻഡുകൾ ഉപയോഗിച്ച് സ്വയം പരീക്ഷണം നടത്തുക, ഉദാഹരണത്തിന് അവയുടെ ഔട്ട്‌പുട്ട് grep , sed അല്ലെങ്കിൽ അതിൽ കുറവ്.

കയറ്റുമതി

എക്‌സ്‌പോർട്ട് കമാൻഡ് ചൈൽഡ് പ്രോസസുകളിലേക്ക് കൈമാറാൻ എൻവയോൺമെന്റ് വേരിയബിളുകൾ സജ്ജമാക്കുന്നു. ഉദാഹരണത്തിന്, മൂല്യ വിദ്യാർത്ഥിക്കൊപ്പം നിങ്ങൾക്ക് ഒരു നെയിം വേരിയബിൾ കൈമാറുന്നത് ഇങ്ങനെയാണ്:

$ കയറ്റുമതി പേര്=വിദ്യാർത്ഥി

ps

ps കമാൻഡ് എന്നതിനെക്കുറിച്ചുള്ള വിവരങ്ങൾ പ്രദർശിപ്പിക്കുന്നു പ്രവർത്തിക്കുന്ന പ്രക്രിയകൾ.

$ ps PID TTY TIME CMD 35346 പോയിന്റ്/2 00:00:00 ബാഷ്

നാല് ഘടകങ്ങൾ ഔട്ട്പുട്ട് ആണ്:

പ്രോസസ്സ് ഐഡി (PID),
ടെർമിനൽ തരം (TTY),
പ്രോസസ്സ് പ്രവർത്തന സമയം (TIME),
പ്രക്രിയ ആരംഭിച്ച കമാൻഡിന്റെ പേര് (CMD).

awk

നൽകിയിരിക്കുന്ന പാറ്റേൺ ഉപയോഗിച്ച് awk കമാൻഡ് ഫയലുകളിലെ വാചകം കണ്ടെത്തുകയും മാറ്റിസ്ഥാപിക്കുകയും ചെയ്യുന്നു: awk "pattern (action)" test.txt

wget

wget കമാൻഡ് ഇന്റർനെറ്റിൽ നിന്ന് ഫയലുകൾ ഡൗൺലോഡ് ചെയ്യുകയും അവ അകത്ത് സ്ഥാപിക്കുകയും ചെയ്യുന്നു നിലവിലെ ഡയറക്ടറി.

$ wget https://github.com/mikeizbicki/ucr-cs100

എൻസി

പിംഗ്

പിംഗ് കമാൻഡ് പരിശോധിക്കുന്നു നെറ്റ്വർക്ക് കണക്ഷൻ.

$ പിംഗ് google.com PING google.com (74.125.224.34) 56(84) ഡാറ്റയുടെ ബൈറ്റുകൾ. lax17s01-in-f2.1e100.net (74.125.224.34): 64 ബൈറ്റുകൾ , സമയം 8ms rtt min/avg/max/mdev = 7.794/8.422/10.792/0.699 ms

അവസാനത്തെ സ്ഥിതിവിവരക്കണക്കുകൾ കമാൻഡ് പൂർത്തിയാകുന്നതിന് മുമ്പ് ഉണ്ടാക്കിയ കണക്ഷനുകളുടെ എണ്ണവും അവ പൂർത്തിയാക്കാൻ എടുത്ത സമയവും കാണിക്കുന്നു.

git

പരിസ്ഥിതി വേരിയബിളുകൾ

ഒന്നോ അതിലധികമോ ആപ്ലിക്കേഷനുകൾ ഉപയോഗിക്കുന്ന മൂല്യങ്ങൾ ഉൾക്കൊള്ളുന്ന വേരിയബിളുകളെ പരിസ്ഥിതി വേരിയബിളുകൾ എന്ന് വിളിക്കുന്നു.

എക്സിക്യൂട്ടബിൾ ഫയലുകൾക്കായി സിസ്റ്റം തിരയുന്ന ഡയറക്ടറികളുടെ ഒരു ലിസ്റ്റ് PATH വേരിയബിളിൽ അടങ്ങിയിരിക്കുന്നു.

ഹോം വേരിയബിളിൽ നിലവിലെ ഉപയോക്താവിന്റെ ഹോം ഡയറക്ടറിയിലേക്കുള്ള പാത അടങ്ങിയിരിക്കുന്നു.

കണക്ടറുകൾ

ഒരേസമയം ഒന്നിലധികം കമാൻഡുകൾ പ്രവർത്തിപ്പിക്കാൻ കണക്ടറുകൾ നിങ്ങളെ അനുവദിക്കുന്നു.

$ true && echo Hello Hello $ false || പ്രതിധ്വനി ഹലോ ഹലോ $ എക്കോ ഹലോ ; ls ഹലോ test.txt file1.txt file2.txt

കൺവെയറുകൾ

കൺവെയറുകൾ, അല്ലെങ്കിൽ പൈപ്പുകൾ, വ്യത്യസ്ത ടീമുകളുടെ ഇൻപുട്ട്, ഔട്ട്പുട്ട് ചാനലുകൾ ബന്ധിപ്പിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു. ഇനിപ്പറയുന്ന ഉദാഹരണത്തിൽ, ls കമാൻഡിന്റെ ഔട്ട്പുട്ട് ഹെഡ്ഡിലേക്ക് കൈമാറും, അതിന്റെ ഫലമായി ആദ്യത്തെ 10 ഘടകങ്ങൾ മാത്രമേ പ്രിന്റ് ചെയ്യപ്പെടുകയുള്ളൂ.

$ ls -l | തല

I/O റീഡയറക്ഷൻ

ഔട്ട്പുട്ട് റീഡയറക്ഷൻ

സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ട് റീഡയറക്‌ഷനായി >, >> എന്നീ ചിഹ്നങ്ങൾ ഉപയോഗിക്കുന്നു.

ഉദാഹരണത്തിന്, ഈ കോഡ് സ്‌ക്രീനിലേയ്‌ക്ക് പകരം ഒരു ഫയലിലേക്ക് ls ഔട്ട്‌പുട്ട് പൈപ്പ് ചെയ്യും:

$ ls > files.txt $ cat files.txt file1.cpp sample.txt

ഫയൽ നിലവിലില്ലെങ്കിൽ, അത് സൃഷ്ടിക്കപ്പെടുന്നു, അത് നിലവിലുണ്ടെങ്കിൽ അത് തിരുത്തിയെഴുതപ്പെടും. തിരുത്തിയെഴുതുന്നത് ഒഴിവാക്കാൻ, നിങ്ങൾ >> കമാൻഡ് ഉപയോഗിക്കണം - ഇത് ഫയലിന്റെ അവസാനം ഡാറ്റ കൂട്ടിച്ചേർക്കുന്നു.

ഇൻപുട്ട് റീഡയറക്ഷൻ

സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ട് റീഡയറക്ഷന്, ചിഹ്നം ഉപയോഗിക്കുക< . В следующем примере sort берет входные данные из файла, а не с клавиатуры:

$ cat files.txt c b $ അടുക്കുക< files.txt b c

ഞങ്ങൾ ഔട്ട്‌പുട്ട് റീഡയറക്‌ട് ചെയ്‌തിട്ടില്ലാത്തതിനാൽ സോർട്ട് കമാൻഡ് ഫയലിന്റെ ഉള്ളടക്കങ്ങൾ സ്‌ക്രീനിലേക്ക് പ്രിന്റ് ചെയ്യുന്നു. ഇത് ഇതുപോലെ ചെയ്യാൻ കഴിയും:

$sort< files.txt >files_sorted.txt

വിപുലമായ റീഡയറക്ഷൻ

& to > ചേർക്കുന്നത് സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ടും പിശകും വഴിതിരിച്ചുവിടുന്നതിന് കാരണമാകുന്നു. ഉദാഹരണത്തിന്, test.cpp എന്ന ഫയൽ, stdout എന്ന വരിയെ cout ലേക്കും stderr എന്ന ലൈൻ cerr എന്നതിലേക്കും ഔട്ട്പുട്ട് ചെയ്യും.

$ g++ test.cpp $ ./a.out >& test.txt $ cat test.txt stdout stderr

നിങ്ങൾക്ക് ഒരു നിർദ്ദിഷ്‌ട ഫയൽ ഡിസ്‌ക്രിപ്‌റ്റർ ഔട്ട്‌പുട്ട് ചെയ്യണമെങ്കിൽ, അതിന്റെ നമ്പർ നിങ്ങൾക്ക് > എന്നതിലേക്ക് നൽകാം.

പേര്	ഡിസ്ക്രിപ്റ്റർ	വിവരണം
stdin	0	സ്റ്റാൻഡേർഡ് ഇൻപുട്ട്
stdout	1	സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ട്
stderr	2	സ്റ്റാൻഡേർഡ് പിശക് ഔട്ട്പുട്ട്

ഉദാഹരണത്തിന്, stderr-നെ test.txt-ലേക്ക് റീഡയറക്‌ട് ചെയ്യുന്നതിന് നിങ്ങൾ ഇനിപ്പറയുന്നവ ചെയ്യണം:

$ g++ test.cpp $ ./a.out 2> test.txt stdout $ cat test.txt stderr

ആക്സസ് അവകാശങ്ങൾ

ഓരോ ഫയലിന്റെയും അനുമതികളെക്കുറിച്ചുള്ള ധാരാളം വിവരങ്ങൾ ls -l കമാൻഡ് പ്രദർശിപ്പിക്കുന്നു:

chmod

chmod കമാൻഡ് ഒരു ഫയലിന്റെ അനുമതികൾ മാറ്റുന്നു. നിർദ്ദിഷ്ട ഉപയോക്താക്കളുടെ അവകാശങ്ങൾ മാറ്റുന്നതിനുള്ള ഫ്ലാഗുകളുടെ സാധാരണ കോമ്പിനേഷനുകൾ ഇതാ:

ഒരു നിർദ്ദിഷ്‌ട ഫയലിൽ എന്തുചെയ്യണമെന്നതിന്റെ വിവരണത്തോടെ നിങ്ങൾക്ക് chmod എന്ന് വിളിക്കാം. - ചിഹ്നം എന്നാൽ അവകാശങ്ങൾ നീക്കം ചെയ്യുക, + ചിഹ്നം എന്നത് കൂട്ടിച്ചേർക്കുക എന്നാണ്. ഇനിപ്പറയുന്ന ഉദാഹരണം ഫയലിനെ ഉടമയ്ക്കും ഗ്രൂപ്പിനും വായിക്കാവുന്നതും എഴുതാവുന്നതുമാക്കും:

$ chmod ug+rw test.txt $ ls -l test.txt -rw-rw---- 1 ഉപയോക്തൃ ഗ്രൂപ്പ് 1097374 ജനുവരി 26 2:48 test.txt

കൂടാതെ, 1 അനുവദനീയവും 0 അല്ലാത്തതുമായ ഒക്ടൽ നമ്പറുകൾക്കൊപ്പം chmod ഉപയോഗിക്കാം:

Rwx = 111 = 7 rw- = 110 = 6 r-x = 101 = 5 r-- = 100 = 4

അടുത്ത കമാൻഡ് മുമ്പത്തേതിന് സമാനമായി പ്രവർത്തിക്കും.

ലിനക്സ് പഠിക്കുന്നു, 101

സ്ട്രീമുകൾ, പ്രോഗ്രാം ചാനലുകൾ, റീഡയറക്‌ടുകൾ

ലിനക്സ് പൈപ്പ് ലൈനുകളുടെ അടിസ്ഥാനകാര്യങ്ങൾ പഠിക്കുന്നു

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

ഹ്രസ്വ അവലോകനം

ഈ ലേഖനത്തിൽ, ലിനക്സിൽ സ്റ്റാൻഡേർഡ് I/O സ്ട്രീമുകൾ റീഡയറക്ട് ചെയ്യുന്നതിനുള്ള അടിസ്ഥാന ടെക്നിക്കുകൾ നിങ്ങൾ പഠിക്കും. നീ പഠിക്കും:

സ്റ്റാൻഡേർഡ് ഇൻപുട്ട്/ഔട്ട്പുട്ട് സ്ട്രീമുകൾ റീഡയറക്ട് ചെയ്യുക: സ്റ്റാൻഡേർഡ് ഇൻപുട്ട്, സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ട്, സ്റ്റാൻഡേർഡ് പിശക്.
ഒരു കമാൻഡിന്റെ ഔട്ട്പുട്ട് മറ്റൊരു കമാൻഡിന്റെ ഇൻപുട്ടിലേക്ക് നയിക്കുക.
സ്റ്റാൻഡേർഡ് ഔട്ട്‌പുട്ട് ഉപകരണത്തിലേക്കും (stdout) ഒരു ഫയലിലേക്കും ഒരേസമയം ഔട്ട്‌പുട്ട് അയയ്‌ക്കുക.
ഒരു കമാൻഡിന്റെ ഔട്ട്പുട്ട് മറ്റൊരു കമാൻഡിലേക്കുള്ള ആർഗ്യുമെന്റായി ഉപയോഗിക്കുക.

ഈ ലേഖനം നിങ്ങളെ LPI 101 എൻട്രി ലെവൽ അഡ്മിനിസ്ട്രേറ്റർ (LPIC-1) പരീക്ഷ എഴുതാൻ സഹായിക്കും, കൂടാതെ വിഷയം 103-ന്റെ ഒബ്ജക്റ്റീവ് 103.4-ൽ നിന്നുള്ള മെറ്റീരിയൽ അടങ്ങിയിരിക്കുന്നു. ലക്ഷ്യത്തിന്റെ ഭാരം 4 ആണ്.

ഈ പരമ്പരയെക്കുറിച്ച്

ലിനക്സ് ഓപ്പറേറ്റിംഗ് സിസ്റ്റം കൈകാര്യം ചെയ്യുന്നതിനുള്ള ചുമതലകൾ കൈകാര്യം ചെയ്യാൻ ഈ ലേഖന പരമ്പര നിങ്ങളെ സഹായിക്കും. തയ്യാറാക്കാൻ നിങ്ങൾക്ക് ഈ ലേഖനങ്ങളിലെ മെറ്റീരിയലും ഉപയോഗിക്കാം.

ഈ പരമ്പരയിലെ ലേഖനങ്ങളുടെ വിവരണങ്ങൾ കാണുന്നതിനും അവയിലേക്കുള്ള ലിങ്കുകൾ ലഭിക്കുന്നതിനും, ദയവായി ഞങ്ങളുടെ റഫർ ചെയ്യുക. പുതിയ ലേഖനങ്ങൾ ലഭ്യമാകുന്നതിനനുസരിച്ച് ഈ ലിസ്റ്റ് തുടർച്ചയായി അപ്ഡേറ്റ് ചെയ്യപ്പെടുന്നു, കൂടാതെ ഏറ്റവും നിലവിലുള്ള (ഏപ്രിൽ 2009 ലെ കണക്കനുസരിച്ച്) LPIC-1 സർട്ടിഫിക്കേഷൻ പരീക്ഷാ ലക്ഷ്യങ്ങൾ അടങ്ങിയിരിക്കുന്നു. ലിസ്റ്റിൽ നിന്ന് ഒരു ലേഖനം നഷ്‌ടപ്പെട്ടാൽ, മുമ്പത്തെ LPIC-1 ലക്ഷ്യങ്ങൾ (ഏപ്രിൽ 2009-ന് മുമ്പ്) പാലിക്കുന്ന ഒരു മുമ്പത്തെ പതിപ്പ് നിങ്ങൾക്ക് ഞങ്ങളുടെ റഫർ ചെയ്യുന്നതിലൂടെ കണ്ടെത്താനാകും.

ആവശ്യമായ വ്യവസ്ഥകൾ

ഞങ്ങളുടെ ലേഖനങ്ങളിൽ നിന്ന് പരമാവധി പ്രയോജനം നേടുന്നതിന്, നിങ്ങൾ ഉണ്ടായിരിക്കണം അടിസ്ഥാന അറിവ് Linux-നെ കുറിച്ച്, നിങ്ങൾ നേരിടുന്ന എല്ലാ കമാൻഡുകളും പ്രവർത്തിപ്പിക്കാൻ കഴിയുന്ന ഒരു ലിനക്സ് കമ്പ്യൂട്ടർ പ്രവർത്തിക്കുക. ചിലപ്പോൾ പ്രോഗ്രാമുകളുടെ വ്യത്യസ്ത പതിപ്പുകൾ വ്യത്യസ്തമായ ഫലങ്ങൾ നൽകുന്നു, അതിനാൽ ലിസ്റ്റിംഗുകളുടെയും കണക്കുകളുടെയും ഉള്ളടക്കം നിങ്ങളുടെ കമ്പ്യൂട്ടറിൽ നിങ്ങൾ കാണുന്നതിൽ നിന്ന് വ്യത്യസ്തമായിരിക്കും.

ഉദാഹരണങ്ങൾ പ്രവർത്തിപ്പിക്കാൻ തയ്യാറെടുക്കുന്നു

ഇയാനെ എങ്ങനെ ബന്ധപ്പെടാം

ഇയാൻ ഞങ്ങളുടെ ഏറ്റവും ജനപ്രിയവും സമൃദ്ധവുമായ എഴുത്തുകാരിൽ ഒരാളാണ്. ഡെവലപ്പർ വർക്കുകളിൽ പ്രസിദ്ധീകരിച്ച (EN) പരിശോധിക്കുക. നിങ്ങൾക്ക് ബന്ധപ്പെടാനുള്ള വിവരങ്ങൾ കണ്ടെത്താനും അവനുമായും മറ്റ് My developerWorks സംഭാവകരുമായും സംഭാവകരുമായും ബന്ധപ്പെടാനും കഴിയും.

ഈ ലേഖനത്തിലെ ഉദാഹരണങ്ങൾ പ്രവർത്തിപ്പിക്കുന്നതിന്, "" ലേഖനത്തിൽ നേരത്തെ സൃഷ്ടിച്ച ചില ഫയലുകൾ ഞങ്ങൾ ഉപയോഗിക്കും. നിങ്ങൾ ഈ ലേഖനം വായിക്കുകയോ ഈ ഫയലുകൾ സംരക്ഷിക്കുകയോ ചെയ്തിട്ടില്ലെങ്കിൽ, വിഷമിക്കേണ്ട! ഒരു പുതിയ ഡയറക്ടറി lpi103-4-ഉം ആവശ്യമായ എല്ലാ ഫയലുകളും സൃഷ്ടിച്ചുകൊണ്ട് നമുക്ക് ആരംഭിക്കാം. ഇത് ചെയ്യുന്നതിന്, തുറക്കുക ടെക്സ്റ്റ് ബോക്സ്നിങ്ങളുടെ ഹോം ഡയറക്ടറിയിലേക്ക് പോകുക. ലിസ്റ്റിംഗ് 1 ലെ ഉള്ളടക്കങ്ങൾ ടെക്സ്റ്റ് ബോക്സിലേക്ക് പകർത്തുക; കമാൻഡുകൾ എക്സിക്യൂട്ട് ചെയ്യുന്നതിന്റെ ഫലമായി, lpi103-4 ഉപഡയറക്‌ടറിയും അതിൽ ആവശ്യമായ എല്ലാ ഫയലുകളും നിങ്ങളുടെ ഹോം ഡയറക്‌ടറിയിൽ സൃഷ്‌ടിക്കപ്പെടും, അത് ഞങ്ങൾ ഉദാഹരണങ്ങളിൽ ഉപയോഗിക്കും.

ലിസ്റ്റിംഗ് 1. ഈ ലേഖനത്തിന്റെ ഉദാഹരണങ്ങൾക്ക് ആവശ്യമായ ഫയലുകൾ സൃഷ്ടിക്കുന്നു

mkdir -p lpi103-4 && cd lpi103-4 && ( echo -e "1 apple\n2 pear\n3 banana" > text1 echo -e "9\tplum\n3\tbanana\n10\tapple" > text2 echo "ഇതാണ് ഒരു വാചകം. " !#:* !#:1->text3 split -l 2 text1 split -b 17 text2 y; )

നിങ്ങളുടെ വിൻഡോ ലിസ്‌റ്റിംഗ് 2 പോലെയായിരിക്കണം, നിങ്ങളുടെ നിലവിലെ വർക്കിംഗ് ഡയറക്‌ടറി പുതുതായി സൃഷ്‌ടിച്ച lpi103-4 ഡയറക്‌ടറി ആയിരിക്കണം.

ലിസ്റ്റിംഗ് 2. ആവശ്യമായ ഫയലുകൾ സൃഷ്ടിക്കുന്നതിന്റെ ഫലങ്ങൾ

$ mkdir -p lpi103-4 && cd lpi103-4 && ( > echo -e "1 apple\n2 pear\n3 banana" > text1 > echo -e "9\tplum\n3\tbanana\n10\tapple" > text2 > echo "ഇതൊരു വാക്യമാണ്." -ബി 17 ടെക്സ്റ്റ്2 y;) $

സാധാരണ ഇൻപുട്ട്/ഔട്ട്പുട്ട് റീഡയറക്‌ട് ചെയ്യുന്നു

ബാഷ് പോലെയുള്ള ഒരു ലിനക്സ് ഷെൽ ഇൻപുട്ട് എടുക്കുകയും ഔട്ട്പുട്ട് സീക്വൻസുകളുടെ രൂപത്തിൽ അയയ്ക്കുകയും ചെയ്യുന്നു. അരുവികൾകഥാപാത്രങ്ങൾ. ഏതൊരു കഥാപാത്രവും മുമ്പത്തെ അല്ലെങ്കിൽ തുടർന്നുള്ള പ്രതീകങ്ങളിൽ നിന്ന് സ്വതന്ത്രമാണ്. ചിഹ്നങ്ങൾ ഘടനാപരമായ എൻട്രികളിലോ ബ്ലോക്കുകളിലോ ക്രമീകരിച്ചിട്ടില്ല നിശ്ചിത വലിപ്പം. പ്രതീക സ്ട്രീമുകൾ എവിടെ നിന്ന് വരുന്നു അല്ലെങ്കിൽ എവിടെ നിന്ന് അയച്ചാലും (ഒരു ഫയൽ, കീബോർഡ്, വിൻഡോ, സ്ക്രീൻ അല്ലെങ്കിൽ മറ്റ് I/O ഉപകരണം) I/O മെക്കാനിസങ്ങൾ ഉപയോഗിച്ചാണ് സ്ട്രീമുകൾ ആക്സസ് ചെയ്യുന്നത്. ടീം ലിനക്സ് വ്യാഖ്യാതാക്കൾമൂന്ന് സ്റ്റാൻഡേർഡ് I/O സ്ട്രീമുകൾ ഉപയോഗിക്കുക, ഓരോന്നിനും ഒരു പ്രത്യേക ഫയൽ ഡിസ്ക്രിപ്റ്റർ നൽകിയിരിക്കുന്നു.

stdout – സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ട്, കമാൻഡ് ഔട്ട്പുട്ട് പ്രദർശിപ്പിക്കുന്നു കൂടാതെ ഹാൻഡിൽ 1 ഉണ്ട്.
stderr – സാധാരണ പിശക് സ്ട്രീം, കമാൻഡ് പിശകുകൾ പ്രദർശിപ്പിക്കുന്നു കൂടാതെ ഡിസ്ക്രിപ്റ്റർ 2 ഉണ്ട്.
stdin – സ്റ്റാൻഡേർഡ് ഇൻപുട്ട്, കമാൻഡുകൾക്ക് ഇൻപുട്ട് നൽകുന്നു, കൂടാതെ ഹാൻഡിൽ 0 ഉണ്ട്.

ഇൻപുട്ട് സ്ട്രീമുകൾ കമാൻഡുകൾക്ക് ഇൻപുട്ട് (സാധാരണയായി കീബോർഡിൽ നിന്ന്) നൽകുന്നു. ഔട്ട്‌പുട്ട് സ്ട്രീമുകൾ ടെക്‌സ്‌റ്റ് പ്രതീകങ്ങളുടെ പ്രിന്റിംഗ് നൽകുന്നു, സാധാരണയായി ഒരു ടെർമിനലിലേക്ക്. ടെർമിനൽ യഥാർത്ഥത്തിൽ ഒരു ASCII പ്രിന്റിംഗ് ഉപകരണം അല്ലെങ്കിൽ ഡിസ്പ്ലേ ടെർമിനൽ ആയിരുന്നു, എന്നാൽ ഇപ്പോൾ ഇത് സാധാരണയായി കമ്പ്യൂട്ടർ ഡെസ്ക്ടോപ്പിലെ ഒരു വിൻഡോ മാത്രമാണ്.

നിങ്ങൾ ഇതിനകം "" ഗൈഡ് വായിച്ചിട്ടുണ്ടെങ്കിൽ, ഈ ലേഖനത്തിലെ ചില മെറ്റീരിയലുകൾ നിങ്ങൾക്ക് പരിചിതമായിരിക്കും.

ഔട്ട്പുട്ട് റീഡയറക്ഷൻ

ഒരു ഫയലിലേക്ക് ഔട്ട്പുട്ട് റീഡയറക്ട് ചെയ്യാൻ രണ്ട് വഴികളുണ്ട്:

എൻ> ഒരു ഫയൽ ഡിസ്ക്രിപ്റ്ററിൽ നിന്ന് ഔട്ട്പുട്ട് റീഡയറക്‌ട് ചെയ്യുന്നു എൻഫയൽ ചെയ്യാൻ. നിങ്ങൾക്ക് ഫയലിലേക്ക് എഴുതാനുള്ള അനുമതികൾ ഉണ്ടായിരിക്കണം. ഫയൽ നിലവിലില്ലെങ്കിൽ, അത് സൃഷ്ടിക്കപ്പെടും. ഫയൽ നിലവിലുണ്ടെങ്കിൽ, അതിന്റെ എല്ലാ ഉള്ളടക്കങ്ങളും ഒരു മുന്നറിയിപ്പും കൂടാതെ സാധാരണയായി നശിപ്പിക്കപ്പെടും. എൻ>> ഫയൽ ഡിസ്ക്രിപ്റ്ററിൽ നിന്നുള്ള ഔട്ട്പുട്ടും റീഡയറക്ട് ചെയ്യുന്നു എൻഫയൽ ചെയ്യാൻ. നിങ്ങൾക്ക് ഫയലിൽ എഴുതാനുള്ള അനുമതിയും ഉണ്ടായിരിക്കണം. ഫയൽ നിലവിലില്ലെങ്കിൽ, അത് സൃഷ്ടിക്കപ്പെടും. ഫയൽ നിലവിലുണ്ടെങ്കിൽ, ഔട്ട്പുട്ട് അതിന്റെ ഉള്ളടക്കത്തിലേക്ക് കൂട്ടിച്ചേർക്കും.

ചിഹ്നം എൻഓപ്പറേറ്റർമാരിൽ n> അല്ലെങ്കിൽ n>> ആണ് ഫയൽ ഡിസ്ക്രിപ്റ്റർ. ഇത് വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ, സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ട് ഉപകരണം ഉപയോഗിക്കുമെന്ന് കരുതപ്പെടുന്നു. lpi103-4 ഡയറക്‌ടറിയിൽ നേരത്തെ സൃഷ്‌ടിച്ച ഫയലുകൾ ഉപയോഗിച്ച് ls കമാൻഡിന്റെ സ്റ്റാൻഡേർഡ് ഔട്ട്‌പുട്ടും സ്റ്റാൻഡേർഡ് പിശകും വേർതിരിക്കുന്നതിനുള്ള റീഡയറക്ഷൻ ഓപ്പറേഷൻ ലിസ്റ്റിംഗ് 3 കാണിക്കുന്നു. നിലവിലുള്ള ഫയലുകളിലേക്ക് കമാൻഡ് ഔട്ട്പുട്ട് ചേർക്കുന്നതും പ്രദർശിപ്പിച്ചിരിക്കുന്നു.

ലിസ്റ്റിംഗ് 3. ഔട്ട്പുട്ട് റീഡയറക്ഷൻ

$ ls x* z* ls: z* ആക്‌സസ് ചെയ്യാൻ കഴിയില്ല: അത്തരം ഫയലോ ഡയറക്‌ടറിയോ xaa xab $ ls x* z* >stdout.txt 2>stderr.txt $ ls w* y* ls: ആക്‌സസ് ചെയ്യാൻ കഴിയില്ല w*: അങ്ങനെയൊന്നുമില്ല ഫയൽ അല്ലെങ്കിൽ ഡയറക്ടറി yaa yab $ ls w* y* >>stdout.txt 2>>stderr.txt $ cat stdout.txt xaa xab yaa yab $ cat stderr.txt ls: z* ആക്‌സസ് ചെയ്യാൻ കഴിയില്ല: അത്തരം ഫയലോ ഡയറക്‌ടറിയോ ഇല്ല: ആക്സസ് ചെയ്യാൻ കഴിയില്ല w*: അത്തരം ഫയലോ ഡയറക്ടറിയോ ഇല്ല

n> ഓപ്പറേറ്റർ ഉപയോഗിച്ച് ഔട്ട്‌പുട്ട് റീഡയറക്‌ട് ചെയ്യുന്നത് നിലവിലുള്ള ഫയലുകൾ തിരുത്തിയെഴുതുന്നതിലേക്ക് നയിക്കുമെന്ന് ഞങ്ങൾ ഇതിനകം പറഞ്ഞിട്ടുണ്ട്. നോക്ലോബർ ബിൽറ്റ്-ഇൻ ഓപ്ഷൻ ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഈ പ്രോപ്പർട്ടി നിയന്ത്രിക്കാനാകും കമാൻഡുകൾ സജ്ജമാക്കുക. ഈ ഓപ്‌ഷൻ നിർവചിച്ചിട്ടുണ്ടെങ്കിൽ, ലിസ്റ്റിംഗ് 4-ൽ കാണിച്ചിരിക്കുന്നതുപോലെ, n>| ഓപ്പറേറ്റർ ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഇത് അസാധുവാക്കാനാകും.

ലിസ്റ്റിംഗ് 4. നോക്ലോബർ ഓപ്ഷൻ ഉപയോഗിച്ച് ഔട്ട്പുട്ട് റീഡയറക്‌ട് ചെയ്യുന്നു

$ set -o noclobber $ ls x* z* >stdout.txt 2>stderr.txt -bash: stdout.txt: നിലവിലുള്ള ഫയൽ $ ls x* z* >|stdout.txt 2>|stderr.txt $ cat തിരുത്തിയെഴുതാൻ കഴിയില്ല stdout.txt xaa xab $ cat stderr.txt ls: z* ആക്സസ് ചെയ്യാൻ കഴിയില്ല: അത്തരം ഫയലോ ഡയറക്ടറിയോ ഒന്നുമില്ല $ set +o noclobber #restore original noclobber ക്രമീകരണം

ചിലപ്പോൾ നിങ്ങൾക്ക് സ്റ്റാൻഡേർഡ് ഔട്ട്‌പുട്ടും സ്റ്റാൻഡേർഡ് പിശകും ഒരു ഫയലിലേക്ക് റീഡയറക്‌ട് ചെയ്യാൻ താൽപ്പര്യപ്പെട്ടേക്കാം. ഇത് പലപ്പോഴും ഓട്ടോമേറ്റഡ് പ്രോസസുകളിലോ പശ്ചാത്തല ജോലികളിലോ ഉപയോഗിക്കപ്പെടുന്നതിനാൽ ജോലിയുടെ ഫലങ്ങൾ പിന്നീട് അവലോകനം ചെയ്യാൻ കഴിയും. സ്റ്റാൻഡേർഡ് ഔട്ട്‌പുട്ടും സ്റ്റാൻഡേർഡ് പിശകും ഒരേ സ്ഥലത്തേക്ക് റീഡയറക്‌ട് ചെയ്യുന്നതിന്, &> അല്ലെങ്കിൽ &>> ഓപ്പറേറ്റർ ഉപയോഗിക്കുക. ഫയൽ ഡിസ്ക്രിപ്റ്റർ റീഡയറക്ട് ചെയ്യുക എന്നതാണ് ഇതര ഓപ്ഷൻ എൻതുടർന്ന് ഫയൽ ഡിസ്ക്രിപ്റ്റർ എംനിർമ്മാണം m>&n അല്ലെങ്കിൽ m>>&n ഉപയോഗിച്ച് അതേ സ്ഥലത്തേക്ക്. ഈ സാഹചര്യത്തിൽ, ത്രെഡുകൾ റീഡയറക്ട് ചെയ്യുന്ന ക്രമം പ്രധാനമാണ്. ഉദാഹരണത്തിന്, കമാൻഡ്
കമാൻഡ് 2>&1 >output.txt
അത് ഒരു കമാൻഡിന് തുല്യമല്ല
കമാൻഡ് >output.txt 2>&1
ആദ്യ സന്ദർഭത്തിൽ, പിശക് സ്ട്രീം stderr stdout സ്ട്രീമിന്റെ നിലവിലെ സ്ഥാനത്തേക്ക് റീഡയറക്‌ടുചെയ്യുന്നു, തുടർന്ന് stdout സ്ട്രീം output.txt ഫയലിലേക്ക് റീഡയറക്‌ടുചെയ്യുന്നു; എന്നിരുന്നാലും, രണ്ടാമത്തെ റീഡയറക്ഷൻ stdout-നെ മാത്രമേ ബാധിക്കുകയുള്ളൂ, stderr-നെ ബാധിക്കില്ല. രണ്ടാമത്തെ സാഹചര്യത്തിൽ, stderr സ്ട്രീം stdout സ്ട്രീമിന്റെ നിലവിലെ സ്ഥാനത്തേക്ക്, അതായത് output.txt ഫയലിലേക്ക് റീഡയറക്‌ട് ചെയ്യുന്നു. ഈ റീഡയറക്‌ടുകൾ ലിസ്റ്റിംഗ് 5-ൽ ചിത്രീകരിച്ചിരിക്കുന്നു. സ്റ്റാൻഡേർഡ് എറർ സ്‌ട്രീമിന് ശേഷം സ്റ്റാൻഡേർഡ് ഔട്ട്‌പുട്ട് റീഡയറക്‌ട് ചെയ്‌തതായി അവസാന കമാൻഡിൽ ശ്രദ്ധിക്കുക, അതിന്റെ ഫലമായി, പിശക് സ്ട്രീം ടെർമിനൽ വിൻഡോയിലേക്ക് ഔട്ട്‌പുട്ടായി തുടരുന്നു.

ലിസ്റ്റിംഗ് 5. രണ്ട് സ്ട്രീമുകൾ ഒരു ഫയലിലേക്ക് റീഡയറക്‌ട് ചെയ്യുന്നു

$ ls x* z* &>output.txt $ cat output.txt ls: z* ആക്‌സസ് ചെയ്യാൻ കഴിയില്ല: അത്തരം ഫയലോ ഡയറക്‌ടറിയോ xaa xab $ ls x* z* >output.txt 2>&1 $ cat output.txt ls: z* ആക്‌സസ് ചെയ്യാൻ കഴിയില്ല: അത്തരം ഫയലോ ഡയറക്‌ടറിയോ xaa xab $ ls x* z* 2>&1 >output.txt # stderr output.txt ls-ലേക്ക് പോകുന്നില്ല: z*: അത്തരം ഫയലോ ഡയറക്ടറിയോ $ cat ഔട്ട്‌പുട്ടോ ആക്‌സസ് ചെയ്യാൻ കഴിയില്ല. txt xaa xab

മറ്റ് സാഹചര്യങ്ങളിൽ, സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ട് അല്ലെങ്കിൽ സ്റ്റാൻഡേർഡ് പിശക് പൂർണ്ണമായും അവഗണിക്കാൻ നിങ്ങൾ ആഗ്രഹിച്ചേക്കാം. ഇത് ചെയ്യുന്നതിന്, അനുബന്ധ സ്ട്രീം ശൂന്യമായ /dev/null ഫയലിലേക്ക് റീഡയറക്‌ട് ചെയ്യുക. ls പിശക് സ്ട്രീം എങ്ങനെ അവഗണിക്കാമെന്നും /dev/null യഥാർത്ഥത്തിൽ ശൂന്യമാണോ എന്ന് പരിശോധിക്കാൻ cat കമാൻഡ് എങ്ങനെ ഉപയോഗിക്കാമെന്നും ലിസ്റ്റിംഗ് 6 കാണിക്കുന്നു.

ലിസ്റ്റിംഗ് 6. /dev/null ഉപയോഗിച്ച് സാധാരണ പിശക് അവഗണിക്കുന്നു

$ ls x* z* 2>/dev/null xaa xab $ cat /dev/null

ഇൻപുട്ട് റീഡയറക്ഷൻ

നമുക്ക് stdout, stderr എന്നിവ റീഡയറക്‌ട് ചെയ്യാൻ കഴിയുന്നതുപോലെ, ഓപ്പറേറ്റർ ഉപയോഗിച്ച് ഒരു ഫയലിൽ നിന്ന് stdin റീഡയറക്‌ട് ചെയ്യാം.<. Если вы прочли руководство " ", то должны помнить, что в разделе была использована команда tr для замены пробелов в файле text1 на символы табуляции. В том примере мы использовали вывод команды cat чтобы создать стандартный поток ввода для команды tr . Теперь для преобразования пробелов в символы табуляции вместо бесполезного вызова команды cat мы можем использовать перенаправление ввода, как показано в листинге 7.

ലിസ്റ്റിംഗ് 7. ഇൻപുട്ട് റീഡയറക്ഷൻ

$ TR " " "\t"

ബാഷ് ഉൾപ്പെടെയുള്ള കമാൻഡ് ഇന്റർപ്രെട്ടർമാർ ഈ ആശയം നടപ്പിലാക്കുന്നു ഇവിടെ-രേഖ, ഇൻപുട്ട് റീഡയറക്‌ട് ചെയ്യുന്നതിനുള്ള ഒരു മാർഗമാണിത്. ഇത് ഡിസൈൻ ഉപയോഗിക്കുന്നു<< и какое-либо слово, например END, являющееся маркером, или сигнальной меткой, означающей конец ввода. Эта концепция продемонстрирована в листинге 8.

ലിസ്റ്റിംഗ് 8. ഇവിടെ ഡോക്യുമെന്റ് ആശയം ഉപയോഗിച്ച് ഇൻപുട്ട് റീഡയറക്‌ട് ചെയ്യുന്നു

$sort -k2<1 ആപ്പിൾ > 2 പിയർ > 3 വാഴപ്പഴം > അവസാനം 1 ആപ്പിൾ 3 വാഴപ്പഴം 2 പേരയ്ക്ക

എന്നാൽ എന്തുകൊണ്ട് നിങ്ങൾക്ക് സോർട്ട് -k2 എന്ന കമാൻഡ് ടൈപ്പ് ചെയ്യാൻ കഴിയില്ല, ഡാറ്റ നൽകി കോമ്പിനേഷൻ അമർത്തുക Ctrl-d, ഇൻപുട്ടിന്റെ അവസാനം സൂചിപ്പിക്കുന്നത്? തീർച്ചയായും, നിങ്ങൾക്ക് ഈ കമാൻഡ് പ്രവർത്തിപ്പിക്കാം, എന്നാൽ ഷെൽ സ്‌ക്രിപ്റ്റുകളിൽ വളരെ സാധാരണമായ ഇവിടെ-ഡോക്യുമെന്റ് ആശയത്തെക്കുറിച്ച് നിങ്ങൾക്ക് അറിയില്ല (ഇൻപുട്ടായി ഏതൊക്കെ വരികളാണ് സ്വീകരിക്കേണ്ടതെന്ന് വ്യക്തമാക്കാൻ മറ്റൊരു മാർഗവുമില്ല). ടെക്‌സ്‌റ്റ് വിന്യസിക്കുന്നതിനും വായിക്കാൻ എളുപ്പമാക്കുന്നതിനും സ്‌ക്രിപ്റ്റുകളിൽ ടാബുകൾ വ്യാപകമായി ഉപയോഗിക്കുന്നതിനാൽ, ഇവിടെ ഡോക്യുമെന്റ് ആശയം ഉപയോഗിക്കുന്നതിന് മറ്റൊരു സാങ്കേതികതയുണ്ട്. ഓപ്പറേറ്റർ ഉപയോഗിക്കുമ്പോൾ<<- вместо оператора << начальные символы табуляции удаляются.

ലിസ്‌റ്റിംഗ് 9-ൽ, ഒരു ടാബ് പ്രതീകം സൃഷ്‌ടിക്കാൻ ഞങ്ങൾ കമാൻഡ് സബ്‌സ്റ്റിറ്റ്യൂഷൻ ഉപയോഗിച്ചു, തുടർന്ന് രണ്ട് ക്യാറ്റ് കമാൻഡുകൾ അടങ്ങിയ ഒരു ചെറിയ ഷെൽ സ്‌ക്രിപ്റ്റ് സൃഷ്‌ടിച്ചു, അവ ഓരോന്നും ഇവിടെ-ഡോക്യുമെന്റ് ബ്ലോക്കിൽ നിന്നുള്ള ഡാറ്റ വായിക്കുന്നു. ടെർമിനലിൽ നിന്ന് നമ്മൾ വായിക്കുന്ന ഇവിടെ ഡോക്യുമെന്റ് ബ്ലോക്കിനെ സൂചിപ്പിക്കാൻ ഞങ്ങൾ END എന്ന വാക്ക് ഉപയോഗിച്ചുവെന്നത് ശ്രദ്ധിക്കുക. നമ്മുടെ സ്ക്രിപ്റ്റിൽ ഇതേ വാക്ക് ഉപയോഗിച്ചാൽ, നമ്മുടെ ഇൻപുട്ട് അകാലത്തിൽ അവസാനിക്കും. അതിനാൽ, END എന്ന വാക്കിന് പകരം, ഞങ്ങൾ സ്ക്രിപ്റ്റിൽ EOF എന്ന വാക്ക് ഉപയോഗിക്കുന്നു. ഞങ്ങളുടെ സ്ക്രിപ്റ്റ് സൃഷ്ടിച്ചുകഴിഞ്ഞാൽ, ഞങ്ങൾ കമാൻഡ് ഉപയോഗിക്കുന്നു. (ഡോട്ട്) നിലവിലെ ഷെല്ലിന്റെ പശ്ചാത്തലത്തിൽ ഇത് പ്രവർത്തിപ്പിക്കുന്നതിന്.

ലിസ്റ്റിംഗ് 9. ഇവിടെ ഡോക്യുമെന്റ് ആശയം ഉപയോഗിച്ച് ഇൻപുട്ട് റീഡയറക്‌ട് ചെയ്യുന്നു

$ ht=$(echo -en "\t") $ പൂച്ച<ex-here.sh > പൂച്ച<<-EOF >apple > EOF > $(ht)പൂച്ച<<-EOF >$(ht)pear > $(ht)EOF > END $ cat ex-here.sh പൂച്ച<<-EOF apple EOF cat <<-EOF pear EOF $ . ex-here.sh apple pear

ഈ പരമ്പരയിലെ ഭാവി ലേഖനങ്ങളിൽ, കമാൻഡ് സബ്സ്റ്റിറ്റ്യൂഷനെക്കുറിച്ചും സ്ക്രിപ്റ്റിംഗിനെക്കുറിച്ചും കൂടുതലറിയാൻ നിങ്ങൾ പഠിക്കും. ഈ പരമ്പരയിലെ എല്ലാ ലേഖനങ്ങളിലേക്കുമുള്ള ലിങ്കുകൾ ഇതിൽ കാണാം.

പൈപ്പ് ലൈനുകൾ സൃഷ്ടിക്കുന്നു

xargs കമാൻഡ് ഉപയോഗിക്കുന്നു

xargs കമാൻഡ് സ്റ്റാൻഡേർഡ് ഇൻപുട്ട് ഉപകരണത്തിൽ നിന്നുള്ള ഡാറ്റ വായിക്കുന്നു, തുടർന്ന് ലഭിച്ച ഇൻപുട്ടിനെ പാരാമീറ്ററുകളായി എടുക്കുന്ന കമാൻഡുകൾ നിർമ്മിക്കുകയും നടപ്പിലാക്കുകയും ചെയ്യുന്നു. കമാൻഡ് ഒന്നും വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ, echo കമാൻഡ് ഉപയോഗിക്കുന്നു. ലിസ്റ്റിംഗ് 12 ഞങ്ങളുടെ ടെക്സ്റ്റ് 1 ഫയൽ ഉപയോഗിക്കുന്നതിനുള്ള ഒരു ലളിതമായ ഉദാഹരണം കാണിക്കുന്നു, അതിൽ രണ്ട് വാക്കുകളുടെ മൂന്ന് വരികൾ അടങ്ങിയിരിക്കുന്നു.

ലിസ്റ്റിംഗ് 12. xargs കമാൻഡ് ഉപയോഗിക്കുന്നു

$ പൂച്ച വാചകം1 1 ആപ്പിൾ 2 പിയർ 3 വാഴപ്പഴം $ xargs

എന്തുകൊണ്ടാണ് xargs ഔട്ട്‌പുട്ടിൽ ഒരു വരി മാത്രം അടങ്ങിയിരിക്കുന്നത്? ഡിലിമിറ്റർ പ്രതീകങ്ങൾ നേരിട്ടാൽ, ഡിഫോൾട്ടായി, xargs ഇൻപുട്ടിനെ വിഭജിക്കുന്നു, തത്ഫലമായുണ്ടാകുന്ന ഓരോ ശകലവും ഒരു പ്രത്യേക പാരാമീറ്ററായി മാറുന്നു. എന്നിരുന്നാലും, xargs ഒരു കമാൻഡ് നിർമ്മിക്കുമ്പോൾ, അത് ഒരു സമയം കഴിയുന്നത്ര പരാമീറ്ററുകൾ കൈമാറുന്നു. -n അല്ലെങ്കിൽ --max-args ഓപ്ഷൻ ഉപയോഗിച്ച് ഈ സ്വഭാവം മാറ്റാവുന്നതാണ്. ലിസ്റ്റിംഗ് 13 രണ്ട് ഓപ്ഷനുകളുടെയും ഒരു ഉദാഹരണം കാണിക്കുന്നു; xargs-ന്റെ ഉപയോഗത്തിനായി echo കമാൻഡിലേക്കുള്ള ഒരു വ്യക്തമായ കോളും ചെയ്തു.

ലിസ്റ്റിംഗ് 13. xargs, echo കമാൻഡുകൾ എന്നിവ ഉപയോഗിക്കുന്നു

$xargs " args > 1 ആപ്പിൾ 2 പിയർ 3 വാഴപ്പഴം $ xargs --max-args 3 " args > 1 ആപ്പിൾ 2 args > pear 3 banana $ xargs -n 1 " args > 1 args > Apple args > 2 args > pear args > 3 args > വാഴപ്പഴം

ഇൻപുട്ടിൽ സ്‌പെയ്‌സുകൾ അടങ്ങിയിട്ടുണ്ടെങ്കിലും സിംഗിൾ അല്ലെങ്കിൽ ഡബിൾ ഉദ്ധരണികളിലാണെങ്കിൽ (അല്ലെങ്കിൽ സ്‌പെയ്‌സുകൾ ബാക്ക്‌സ്ലാഷുകൾ ഉപയോഗിച്ച് രക്ഷപ്പെടുന്നു), xargs അതിനെ പ്രത്യേക ഭാഗങ്ങളായി വിഭജിക്കില്ല. ഇത് ലിസ്റ്റിംഗ് 14 ൽ കാണിച്ചിരിക്കുന്നു.

ലിസ്റ്റിംഗ് 14. xargs കമാൻഡും ഉദ്ധരണികളും ഉപയോഗിക്കുന്നു

$ എക്കോ ""4 പ്ലം"" | പൂച്ച വാചകം1 - 1 ആപ്പിൾ 2 പിയർ 3 വാഴപ്പഴം "4 പ്ലം" $ എക്കോ ""4 പ്ലം"" | പൂച്ച വാചകം1 - | xargs -n 1 1 ആപ്പിൾ 2 പിയർ 3 വാഴപ്പഴം 4 പ്ലം

ഇതുവരെ, എല്ലാ ആർഗ്യുമെന്റുകളും കമാൻഡിന്റെ അവസാനത്തിൽ ചേർത്തിട്ടുണ്ട്. അവയ്‌ക്ക് ശേഷം മറ്റ് ഓപ്‌ഷണൽ ആർഗ്യുമെന്റുകൾ ചേർക്കണമെങ്കിൽ, ഒരു റീപ്ലേസ്‌മെന്റ് സ്‌ട്രിംഗ് വ്യക്തമാക്കാൻ -I ഓപ്ഷൻ ഉപയോഗിക്കുക. പകരം സ്ട്രിംഗ് ഉപയോഗിക്കുന്ന xargs വഴി വിളിക്കുന്ന കമാൻഡിലെ പോയിന്റിൽ, പകരം ഒരു ആർഗ്യുമെന്റ് പകരം വയ്ക്കും. ഈ സമീപനത്തിലൂടെ, ഓരോ കമാൻഡിലേക്കും ഒരു ആർഗ്യുമെന്റ് മാത്രമേ കൈമാറുകയുള്ളൂ. എന്നിരുന്നാലും, ആർഗ്യുമെന്റ് അതിന്റെ ഒരു പ്രത്യേക ശകലത്തിൽ നിന്നല്ല, മുഴുവൻ ഇൻപുട്ട് സ്ട്രിംഗിൽ നിന്നും സൃഷ്ടിക്കപ്പെടും. നിങ്ങൾക്ക് xargs കമാൻഡിന്റെ -L ഓപ്ഷനും ഉപയോഗിക്കാം, ഇത് സ്‌പെയ്‌സുകളാൽ വേർതിരിക്കുന്ന വ്യക്തിഗത കഷണങ്ങളേക്കാൾ മുഴുവൻ സ്‌ട്രിംഗും ഒരു ആർഗ്യുമെന്റായി ഉപയോഗിക്കുന്നതിന് കാരണമാകും. -I ഓപ്ഷൻ ഉപയോഗിക്കുന്നത് -L 1 ഓപ്ഷൻ ഉപയോഗിക്കുന്നതിന് കാരണമാകുന്നു. ലിസ്റ്റിംഗ് 15 -I, -L ഓപ്ഷനുകൾ ഉപയോഗിക്കുന്നതിനുള്ള ഉദാഹരണങ്ങൾ കാണിക്കുന്നു.

ലിസ്റ്റിംഗ് 15. xargs കമാൻഡും ഇൻപുട്ട് ലൈനുകളും ഉപയോഗിക്കുന്നു

$ xargs -I XYZ എക്കോ "ആരംഭിക്കുക XYZ ആവർത്തിക്കുക XYZ END" " <9 plum> <3 banana><3 banana> <10 apple><10 apple>$ cat text1 text2 | xargs -L2 1 ആപ്പിൾ 2 പിയർ 3 വാഴപ്പഴം 9 പ്ലം 3 വാഴപ്പഴം 10 ആപ്പിൾ

ഞങ്ങളുടെ ഉദാഹരണങ്ങൾ ലളിതമായ ടെക്സ്റ്റ് ഫയലുകൾ ഉപയോഗിക്കുന്നുണ്ടെങ്കിലും, അത്തരം സന്ദർഭങ്ങളിൽ നിങ്ങൾ പലപ്പോഴും xargs കമാൻഡ് ഉപയോഗിക്കില്ല. സാധാരണഗതിയിൽ, ls , find or grep പോലുള്ള കമാൻഡുകളുടെ ഫലമായുണ്ടാകുന്ന ഫയലുകളുടെ ഒരു വലിയ ലിസ്റ്റ് നിങ്ങൾ കൈകാര്യം ചെയ്യും. ഗ്രെപ്പ് പോലുള്ള ഒരു കമാൻഡിലേക്ക് ഒരു ഡയറക്ടറിയുടെ ഉള്ളടക്കങ്ങളുടെ ഒരു ലിസ്റ്റ് xargs കൈമാറുന്നതിനുള്ള ഒരു വഴി ലിസ്റ്റിംഗ് 16 കാണിക്കുന്നു.

ലിസ്റ്റിംഗ് 16. xargs കമാൻഡും ഫയൽ ലിസ്റ്റും ഉപയോഗിക്കുന്നു

$ ls |xargs grep "1" text1:1 apple text2:10 apple xaa:1 apple yaa:1

അവസാനത്തെ ഉദാഹരണത്തിൽ, ഒന്നോ അതിലധികമോ ഫയൽ നാമങ്ങളിൽ സ്‌പെയ്‌സുകൾ ഉണ്ടെങ്കിൽ എന്ത് സംഭവിക്കും? ലിസ്റ്റിംഗ് 16-ൽ ഉള്ളതുപോലെ കമാൻഡ് ഉപയോഗിക്കാൻ ശ്രമിച്ചാൽ, നിങ്ങൾക്ക് ഒരു പിശക് ലഭിക്കും. ഒരു യഥാർത്ഥ സാഹചര്യത്തിൽ, ഫയലുകളുടെ ലിസ്റ്റ് ls കമാൻഡിൽ നിന്ന് ലഭിച്ചേക്കില്ല, പക്ഷേ, ഉദാഹരണത്തിന്, ഒരു ഉപയോക്തൃ സ്ക്രിപ്റ്റ് അല്ലെങ്കിൽ കമാൻഡ് എക്സിക്യൂട്ട് ചെയ്യുന്നതിന്റെ ഫലമായി; അല്ലെങ്കിൽ അധിക ഫിൽട്ടറിംഗിനായി പൈപ്പ്ലൈനിലെ മറ്റ് ഘട്ടങ്ങളിൽ ഇത് പ്രോസസ്സ് ചെയ്യാൻ നിങ്ങൾ ആഗ്രഹിച്ചേക്കാം. അതിനാൽ നിലവിലുള്ള ലോജിക്കൽ ഘടനയ്ക്ക് പകരം നിങ്ങൾക്ക് grep "1" * ഉപയോഗിക്കാമെന്ന വസ്തുത ഞങ്ങൾ കണക്കിലെടുക്കുന്നില്ല.

ls കമാൻഡിന്റെ കാര്യത്തിൽ, സ്‌പെയ്‌സുകൾ അടങ്ങിയ ഫയൽനാമങ്ങൾ പരാന്തീസിസിൽ (അല്ലെങ്കിൽ എസ്കേപ്പ്) ഉൾപ്പെടുത്താൻ നിർബന്ധിതമാക്കാൻ നിങ്ങൾക്ക് --quoting-style ഓപ്ഷൻ ഉപയോഗിക്കാം. ഇൻപുട്ട് ആർഗ്യുമെന്റുകൾ വേർതിരിക്കുന്നതിന് ശൂന്യമായ പ്രതീകങ്ങൾ (\0) ഉപയോഗിക്കുന്നതിന് കാരണമാകുന്ന xargs കമാൻഡിന്റെ -0 ഓപ്ഷൻ ഉപയോഗിക്കുന്നതാണ് ഒരു മികച്ച പരിഹാരം (സാധ്യമാകുമ്പോൾ). ls കമാൻഡിന് null-terminated file names ഔട്ട്പുട്ടായി ഉപയോഗിക്കാനുള്ള ഓപ്ഷൻ ഇല്ലെങ്കിലും, പല കമാൻഡുകൾക്കും ഇത് ചെയ്യാൻ കഴിയും.

ലിസ്റ്റിംഗ് 17 ൽ, ഞങ്ങൾ ആദ്യം ഫയൽ ടെക്സ്റ്റ് 1 "ടെക്സ്റ്റ് 1" ലേക്ക് പകർത്തും, തുടർന്ന് xargs കമാൻഡ് ഉപയോഗിച്ച് സ്പെയ്സുകൾ അടങ്ങിയ ഫയൽനാമങ്ങളുടെ ഒരു ലിസ്റ്റ് ഉപയോഗിക്കുന്നതിന് ചില ഉദാഹരണങ്ങൾ നൽകും. ഈ ഉദാഹരണങ്ങൾ ആശയം മനസ്സിലാക്കാൻ നിങ്ങളെ സഹായിക്കുന്നു, കാരണം xargs പൂർണ്ണമായും മാസ്റ്റർ ചെയ്യുന്നത് അത്ര എളുപ്പമായിരിക്കില്ല. പ്രത്യേകിച്ചും, ചില ഫയൽ നാമങ്ങളിൽ ഇതിനകം തന്നെ ന്യൂലൈനുകൾ അടങ്ങിയിട്ടുണ്ടെങ്കിൽ, ന്യൂലൈനുകൾ ശൂന്യമായ പ്രതീകങ്ങളാക്കി മാറ്റുന്നതിനുള്ള അവസാന ഉദാഹരണം പ്രവർത്തിക്കില്ല. ഈ ലേഖനത്തിന്റെ അടുത്ത വിഭാഗത്തിൽ, നൾ പ്രതീകങ്ങൾ ഡിലിമിറ്ററുകളായി ഉപയോഗിക്കുന്ന അനുയോജ്യമായ ഔട്ട്‌പുട്ട് സൃഷ്‌ടിക്കുന്നതിന് ഫൈൻഡ് കമാൻഡ് ഉപയോഗിച്ച് ഞങ്ങൾ കൂടുതൽ ശക്തമായ ഒരു പരിഹാരം നോക്കാം.

ലിസ്‌റ്റിംഗ് 17. xargs കമാൻഡും അവയുടെ പേരുകളിൽ സ്‌പെയ്‌സുകളുള്ള ഫയലുകളും ഉപയോഗിക്കുന്നു

$ cp text1 "text 1" $ ls *1 |xargs grep "1" # പിശക് വാചകം1:1 apple grep: text: അത്തരം ഫയലോ ഡയറക്‌ടറിയോ ഇല്ല grep: 1: അത്തരം ഫയലോ ഡയറക്ടറിയോ ഇല്ല $ ls --quoting-style escape * 1 text1 text\ 1 $ ls --quoting-style shell *1 text1 "text 1" $ ls --quoting-style shell *1 |xargs grep "1" text1:1 apple text 1:1 apple $ # Illustrate -0 xargs $ ls *1 | എന്ന ഓപ്ഷൻ tr "\n" "\0" |xargs -0 grep "1" text1:1 apple text 1:1 app

xargs കമാൻഡിന് ഏകപക്ഷീയമായി ദൈർഘ്യമേറിയ കമാൻഡുകൾ നിർമ്മിക്കാൻ കഴിയില്ല. അങ്ങനെ, ലിനക്സിൽ, കേർണൽ പതിപ്പ് 2.26.3 വരെ, പരമാവധി കമാൻഡ് ദൈർഘ്യം പരിമിതപ്പെടുത്തിയിരിക്കുന്നു. നിങ്ങൾ rm somepath/* പോലുള്ള ഒരു കമാൻഡ് പ്രവർത്തിപ്പിക്കാൻ ശ്രമിക്കുകയാണെങ്കിൽ, ഡയറക്‌ടറിയിൽ ദൈർഘ്യമേറിയ പേരുകളുള്ള നിരവധി ഫയലുകൾ അടങ്ങിയിരിക്കുന്നുവെങ്കിൽ, ആർഗ്യുമെന്റ് ലിസ്റ്റ് വളരെ ദൈർഘ്യമേറിയതാണെന്ന് പ്രസ്താവിക്കുന്ന ഒരു പിശക് കൊണ്ട് അത് പരാജയപ്പെടാം. ഈ പരിമിതികളുണ്ടായേക്കാവുന്ന Linux-ന്റെയോ UNIX-ന്റെയോ പഴയ പതിപ്പുകളാണ് നിങ്ങൾ പ്രവർത്തിപ്പിക്കുന്നതെങ്കിൽ, xarg-കൾ എങ്ങനെ ഉപയോഗിക്കാമെന്ന് അറിയുന്നത് സഹായകമായേക്കാം.

xargs കമാൻഡിനുള്ള ഡിഫോൾട്ട് പരിധികൾ കാണുന്നതിന് നിങ്ങൾക്ക് --show-limits ഓപ്ഷനും കമാൻഡ് ഔട്ട്പുട്ടിന്റെ പരമാവധി ദൈർഘ്യം സജ്ജീകരിക്കുന്നതിന് -s ഓപ്ഷനും ഉപയോഗിക്കാം. മാൻ പേജുകളിൽ നിന്ന് നിങ്ങൾക്ക് മറ്റ് ഓപ്ഷനുകളെക്കുറിച്ച് പഠിക്കാം.

-exec ഓപ്ഷൻ അല്ലെങ്കിൽ xargs കമാൻഡുമായി ചേർന്ന് find കമാൻഡ് ഉപയോഗിക്കുന്നു

" " ട്യൂട്ടോറിയലിൽ, ഫയലുകൾ അവയുടെ പേരുകൾ, പരിഷ്ക്കരണ സമയം, വലുപ്പങ്ങൾ, മറ്റ് സവിശേഷതകൾ എന്നിവയെ അടിസ്ഥാനമാക്കി കണ്ടെത്തുന്നതിന് ഫൈൻഡ് കമാൻഡ് എങ്ങനെ ഉപയോഗിക്കാമെന്ന് നിങ്ങൾ പഠിച്ചു. സാധാരണയായി, കണ്ടെത്തിയ ഫയലുകളിൽ ചില പ്രവർത്തനങ്ങൾ നടത്തണം - ഇല്ലാതാക്കുക, പകർത്തുക, പേരുമാറ്റുക തുടങ്ങിയവ. നമ്മൾ ഇപ്പോൾ ഫൈൻഡ് കമാൻഡിന്റെ -exec ഓപ്ഷൻ നോക്കാം, അത് ഫൈൻഡ് കമാൻഡിന് സമാനമായി പ്രവർത്തിക്കുകയും ഔട്ട്പുട്ട് xargs കമാൻഡിലേക്ക് കൈമാറുകയും ചെയ്യുന്നു.

ലിസ്‌റ്റിംഗ് 18. ഫൈൻഡ് വിത്ത് -എക്‌സെക് ഓപ്ഷൻ ഉപയോഗിക്കുന്നു

$ വാചകം കണ്ടെത്തുക -എക്‌സെക് ക്യാറ്റ് വാചകം3()\; ഇതൊരു വാക്യമാണ്. ഇതൊരു വാക്യമാണ്. ഇതൊരു വാക്യമാണ്. 1 ആപ്പിൾ 2 പിയർ 3 വാഴപ്പഴം ഇതൊരു വാക്യമാണ്. ഇതൊരു വാക്യമാണ്. ഇതൊരു വാക്യമാണ്. 9 പ്ലം 3 വാഴപ്പഴം 10 ആപ്പിൾ

xargs-നെ കുറിച്ച് നിങ്ങൾക്ക് ഇതിനകം അറിയാവുന്ന കാര്യങ്ങളുമായി ലിസ്റ്റിംഗ് 18-ന്റെ ഫലങ്ങൾ താരതമ്യം ചെയ്യുന്നത് കുറച്ച് വ്യത്യാസങ്ങൾ വെളിപ്പെടുത്തുന്നു.

നിങ്ങൾ വേണംഫയലിന്റെ പേര് മാറ്റിസ്ഥാപിക്കുന്ന സ്ഥലത്തെ സൂചിപ്പിക്കുന്നതിന് കമാൻഡിലെ () ചിഹ്നങ്ങൾ ഉപയോഗിക്കുക. കമാൻഡിന്റെ അവസാനത്തിൽ ഈ പ്രതീകങ്ങൾ സ്വയമേവ ചേർക്കപ്പെടുന്നില്ല.
നിങ്ങൾ ഒരു അർദ്ധവിരാമം ഉപയോഗിച്ച് കമാൻഡ് അവസാനിപ്പിക്കണം, അത് രക്ഷപ്പെടണം (\;, ";" അല്ലെങ്കിൽ ";").
ഓരോ ഇൻപുട്ട് ഫയലിനും ഒരിക്കൽ കമാൻഡ് എക്സിക്യൂട്ട് ചെയ്യുന്നു.

വ്യത്യാസങ്ങൾ കാണുന്നതിന് ഫൈൻഡ് ടെക്സ്റ്റ് |xargs cat text3 പ്രവർത്തിപ്പിക്കാൻ ശ്രമിക്കുക.

ഇനി നമുക്ക് ഫയലിന്റെ പേരിൽ സ്‌പെയ്‌സുകളുള്ള കേസിലേക്ക് മടങ്ങാം. ലിസ്റ്റിംഗ് 19-ൽ, ls, xargs കമാൻഡുകൾക്ക് പകരം -exec ഓപ്ഷൻ ഉപയോഗിച്ച് ഞങ്ങൾ find കമാൻഡ് ഉപയോഗിക്കാൻ ശ്രമിച്ചു.

ലിസ്‌റ്റിംഗ് 19. -exec ഓപ്ഷനുള്ള ഫൈൻഡ് കമാൻഡും അവയുടെ പേരുകളിൽ സ്‌പെയ്‌സുകൾ അടങ്ങിയ ഫയലുകളും ഉപയോഗിക്കുന്നു

$കണ്ടെത്തുക. -name "*1" -exec grep "1" () \; 1 ആപ്പിൾ 1 ആപ്പിൾ

ഇതുവരെ വളരെ നല്ലതായിരുന്നു. എന്നിരുന്നാലും, ഇവിടെ എന്തെങ്കിലും നഷ്ടപ്പെട്ടതായി നിങ്ങൾ കരുതുന്നില്ലേ? grep കണ്ടെത്തിയ വരികൾ ഏതൊക്കെ ഫയലുകളിൽ അടങ്ങിയിരിക്കുന്നു? ഇവിടെ നഷ്‌ടമായത് ഫയൽനാമങ്ങളാണ്, കാരണം ഓരോ ഫയലിനും ഒരിക്കൽ കോളുകൾ grep കണ്ടെത്തുക, കൂടാതെ grep, ഒരു സ്മാർട്ട് കമാൻഡ് ആയതിനാൽ, അതിന് ഒരു ഫയലിന്റെ പേര് മാത്രമേ നൽകിയിട്ടുള്ളൂവെങ്കിൽ, അത് എന്താണെന്ന് നിങ്ങളോട് പറയേണ്ടതില്ലെന്ന് അറിയാം. .

ഈ സാഹചര്യത്തിൽ, നമുക്ക് xargs കമാൻഡ് ഉപയോഗിക്കാം, പക്ഷേ പേരുകളിൽ സ്‌പെയ്‌സുകളുള്ള ഫയലുകളുടെ പ്രശ്‌നത്തെക്കുറിച്ച് ഞങ്ങൾക്കറിയാം. -print0 ഓപ്ഷന് നന്ദി, ഫൈൻഡ് കമാൻഡിന് പേരുകളുടെ അസാധുവായ ഒരു ലിസ്റ്റ് സൃഷ്ടിക്കാൻ കഴിയുമെന്ന വസ്തുതയും ഞങ്ങൾ പരാമർശിച്ചു. ഫൈൻഡ് കമാൻഡിന്റെ ആധുനിക പതിപ്പുകൾ ഒരു അർദ്ധവിരാമം കൊണ്ടല്ല, ഒരു + ചിഹ്നം ഉപയോഗിച്ച് വേർതിരിക്കാനാകും, അതുവഴി xargs ഉപയോഗിക്കുന്നതുപോലെ ഒരു കോളിൽ പരമാവധി പേരുകൾ ഫൈൻഡ് കമാൻഡിലേക്ക് കൈമാറാൻ കഴിയും. ഈ സാഹചര്യത്തിൽ നിങ്ങൾക്ക് () കൺസ്ട്രക്‌റ്റ് ഒരിക്കൽ മാത്രമേ ഉപയോഗിക്കാനാകൂ, അത് കമാൻഡിന്റെ അവസാന പരാമീറ്ററായിരിക്കണം എന്ന് പ്രത്യേകം പറയേണ്ടതില്ല. ലിസ്റ്റ് 20 ഈ രണ്ട് രീതികളും കാണിക്കുന്നു.

ലിസ്‌റ്റിംഗ് 20. ഫൈൻഡ്, xargs, ഫയലുകൾ എന്നിവ ഉപയോഗിച്ച് അവയുടെ പേരുകളിൽ സ്‌പെയ്‌സ് അടങ്ങിയിരിക്കുന്നു

$കണ്ടെത്തുക. -name "*1" -print0 |xargs -0 grep "1" ./text 1:1 apple ./text1:1 apple $ കണ്ടെത്താൻ . -name "*1" -exec grep "1" () + ./text 1:1 apple ./text1:1 apple

ഈ രണ്ട് രീതികളും പ്രവർത്തിക്കുന്നു, അവയിലൊന്നിന്റെ തിരഞ്ഞെടുപ്പ് പലപ്പോഴും ഉപയോക്താവിന്റെ വ്യക്തിഗത മുൻഗണനകളാൽ മാത്രമേ നിർണ്ണയിക്കപ്പെടുകയുള്ളൂ. റോ ഡിലിമിറ്ററുകളും വൈറ്റ്‌സ്‌പെയ്‌സും ഉപയോഗിച്ച് ഒബ്‌ജക്‌റ്റുകൾ പൈപ്പ് ചെയ്യുമ്പോൾ നിങ്ങൾക്ക് പ്രശ്‌നങ്ങൾ നേരിടേണ്ടിവരുമെന്ന് ശ്രദ്ധിക്കുക; അതിനാൽ നിങ്ങൾ ഔട്ട്‌പുട്ട് xargs-ലേക്ക് കൈമാറുകയാണെങ്കിൽ, കണ്ടെത്തുന്നതിനുള്ള -print0 ഓപ്ഷനും ഇൻപുട്ടിൽ null delimiters ഉപയോഗിക്കാൻ നിങ്ങളോട് പറയുന്ന xargs-ന്റെ -0 ഓപ്ഷനും ഉപയോഗിക്കുക. ടാർ ഉൾപ്പെടെയുള്ള മറ്റ് കമാൻഡുകളും -0 ഓപ്ഷനെ പിന്തുണയ്ക്കുകയും നൾ-ഡിലിമിറ്റഡ് ഇൻപുട്ടിൽ പ്രവർത്തിക്കുകയും ചെയ്യുന്നു, അതിനാൽ ഇൻപുട്ട് ലിസ്റ്റ് നിങ്ങൾക്ക് പ്രശ്നങ്ങൾ സൃഷ്ടിക്കില്ലെന്ന് നിങ്ങൾക്ക് 100% ഉറപ്പില്ലെങ്കിൽ, അതിനെ പിന്തുണയ്ക്കുന്ന കമാൻഡുകൾക്കായി നിങ്ങൾ എല്ലായ്പ്പോഴും ഈ ഓപ്ഷൻ ഉപയോഗിക്കണം.

ഞങ്ങളുടെ അവസാന കമന്റ് ഫയലുകളുടെ ഒരു ലിസ്‌റ്റുമായി പ്രവർത്തിക്കുന്നതുമായി ബന്ധപ്പെട്ടതാണ്. ബാച്ച് പ്രവർത്തനങ്ങൾ നടത്തുന്നതിന് മുമ്പ് (ഒന്നിലധികം ഫയലുകൾ ഇല്ലാതാക്കുകയോ പുനർനാമകരണം ചെയ്യുകയോ പോലുള്ളവ) എപ്പോഴും നിങ്ങളുടെ ലിസ്റ്റും കമാൻഡുകളും ശ്രദ്ധാപൂർവ്വം പരിശോധിക്കുന്നത് നല്ലതാണ്. ആവശ്യമുള്ളപ്പോൾ കാലികമായ ബാക്കപ്പ് ഉണ്ടായിരിക്കുന്നതും വിലമതിക്കാനാവാത്തതാണ്.

ഔട്ട്പുട്ട് വിഭജനം

ഈ ലേഖനം അവസാനിപ്പിക്കാൻ, ഞങ്ങൾ ഒരു കമാൻഡ് കൂടി വേഗത്തിൽ നോക്കാം. ചിലപ്പോൾ നിങ്ങൾ സ്ക്രീനിൽ ഔട്ട്പുട്ട് കാണേണ്ടതും അതേ സമയം ഒരു ഫയലിലേക്ക് സംരക്ഷിക്കേണ്ടതുമാണ്. ഇതിനായി നിങ്ങൾ ഞങ്ങൾക്ക് കഴിഞ്ഞുഒരു കമാൻഡിന്റെ ഔട്ട്‌പുട്ട് ഒരു വിൻഡോയിലെ ഫയലിലേക്ക് റീഡയറക്‌ട് ചെയ്യുക, തുടർന്ന് മറ്റൊരു വിൻഡോയിൽ ഔട്ട്‌പുട്ട് കണ്ടെത്തുന്നതിന് tail -fn1 ഉപയോഗിക്കുക, എന്നാൽ ഏറ്റവും എളുപ്പമുള്ള മാർഗം tee കമാൻഡ് ഉപയോഗിക്കുക എന്നതാണ്.

ടീ കമാൻഡ് ഒരു പൈപ്പിൽ ഉപയോഗിക്കുന്നു, അതിന്റെ വാദം സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ട് പൈപ്പ് ചെയ്യുന്ന ഫയലിന്റെ പേരാണ് (അല്ലെങ്കിൽ നിരവധി ഫയലുകളുടെ പേരുകൾ). ഫയലിന്റെ പഴയ ഉള്ളടക്കങ്ങൾ പുതിയ ഉള്ളടക്കം ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കാതെ ഫയലിന്റെ അവസാനം ഡാറ്റ കൂട്ടിച്ചേർക്കാൻ -a ഓപ്ഷൻ നിങ്ങളെ അനുവദിക്കുന്നു. പൈപ്പ്ലൈനിംഗ് ചർച്ച ചെയ്തപ്പോൾ ചർച്ച ചെയ്തതുപോലെ, നിങ്ങൾക്ക് സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ടും പിശക് സ്ട്രീമും സംഭരിക്കണമെങ്കിൽ, tee കമാൻഡിലേക്ക് ഇൻപുട്ടായി ഡാറ്റ കൈമാറുന്നതിന് മുമ്പ് നിങ്ങൾ stderr stdout-ലേക്ക് റീഡയറക്ട് ചെയ്യണം. f1, f2 എന്നീ രണ്ട് ഫയലുകളിൽ ഔട്ട്‌പുട്ട് സേവ് ചെയ്യുന്നതിന് tee കമാൻഡ് ഉപയോഗിക്കുന്നതിന്റെ ഉദാഹരണം ലിസ്റ്റിംഗ് 21 കാണിക്കുന്നു.

ലിസ്റ്റിംഗ് 21. tee കമാൻഡ് ഉപയോഗിച്ച് stdout വിഭജിക്കുന്നു

$ ls text|tee f1 f2 text1 text2 text3 $ cat f1 text1 text2 text3 $ cat f2 text1 text2 text3 ഇന്റർപ്രോസസ് കമ്മ്യൂണിക്കേഷനുള്ള ഒരു ഏകദിശ ചാനലാണ് പൈപ്പ്. യുണിക്സ് ഷെല്ലിനായി ഡഗ്ലസ് മക്‌ലോറോയ് ആണ് ഈ പദം ഉപയോഗിച്ചത്, ഇത് ഒരു പൈപ്പ് ലൈനിന്റെ പേരിലാണ്. പൈപ്പ് ചിഹ്നം '|' ഉപയോഗിച്ച് ഒരു കമാൻഡിന്റെ (stdout) ഔട്ട്‌പുട്ട് അടുത്തതിന്റെ ഇൻപുട്ടിലേക്ക് (stdin) റീഡയറക്‌ട് ചെയ്‌ത് ഒന്നിലധികം കമാൻഡുകൾ ലിങ്ക് ചെയ്യാൻ ഷെൽ സ്‌ക്രിപ്റ്റുകളിൽ പൈപ്പ് ലൈനുകൾ മിക്കപ്പോഴും ഉപയോഗിക്കുന്നു:
cmd1 | cmd2 | .... | cmdN
ഉദാഹരണത്തിന്:
$ grep -i "പിശക്" ./ലോഗ് | wc -l 43
ലോഗ് ഫയലിലെ "പിശക്" എന്ന സ്‌ട്രിംഗിനായി grep ഒരു കേസ്-ഇൻസെൻസിറ്റീവ് തിരയൽ നടത്തുന്നു, പക്ഷേ തിരയലിന്റെ ഫലം സ്ക്രീനിലേക്ക് പ്രിന്റ് ചെയ്യപ്പെടുന്നില്ല, പക്ഷേ wc കമാൻഡിന്റെ ഇൻപുട്ടിലേക്ക് (stdin) റീഡയറക്‌ടുചെയ്യുന്നു, അത് ഒരു നിർവ്വഹിക്കുന്നു ലൈൻ എണ്ണം.

യുക്തികൾ

I/O ബഫറിംഗ് ഉപയോഗിച്ച് കമാൻഡുകളുടെ അസമന്വിത നിർവ്വഹണം പൈപ്പ്ലൈൻ നൽകുന്നു. അങ്ങനെ, പൈപ്പ്ലൈനിലെ എല്ലാ ടീമുകളും സമാന്തരമായി പ്രവർത്തിക്കുന്നു, ഓരോന്നും സ്വന്തം പ്രക്രിയയിൽ.

കേർണൽ പതിപ്പ് 2.6.11 മുതലുള്ള ബഫർ വലുപ്പം 65536 ബൈറ്റുകൾ (64Kb) ആണ്, പഴയ കേർണലുകളിലെ മെമ്മറിയുടെ ഒരു പേജിന് തുല്യമാണ്. ഒരു ശൂന്യമായ ബഫറിൽ നിന്ന് വായിക്കാൻ ശ്രമിക്കുമ്പോൾ, ഡാറ്റ ദൃശ്യമാകുന്നതുവരെ റീഡ് പ്രോസസ്സ് തടയുന്നു. അതുപോലെ, നിങ്ങൾ ഒരു പൂർണ്ണ ബഫറിലേക്ക് എഴുതാൻ ശ്രമിക്കുകയാണെങ്കിൽ, ആവശ്യമായ ഇടം സ്വതന്ത്രമാകുന്നതുവരെ എഴുത്ത് പ്രക്രിയ തടയപ്പെടും.
I/O സ്ട്രീമുകളുടെ ഫയൽ ഡിസ്ക്രിപ്റ്ററുകളിൽ പൈപ്പ്ലൈൻ പ്രവർത്തിക്കുന്നുണ്ടെങ്കിലും, ഡിസ്കിൽ ലോഡ് കൂടാതെ എല്ലാ പ്രവർത്തനങ്ങളും മെമ്മറിയിൽ നടത്തുന്നു എന്നത് പ്രധാനമാണ്.
ചുവടെയുള്ള എല്ലാ വിവരങ്ങളും ബാഷ്-4.2 ഷെല്ലിനും 3.10.10 കേർണലിനും വേണ്ടിയുള്ളതാണ്.

ലളിതമായ ഡീബഗ്

പ്രോഗ്രാം എക്സിക്യൂഷൻ സമയത്ത് സിസ്റ്റം കോളുകൾ കണ്ടെത്തുന്നതിന് സ്‌ട്രേസ് യൂട്ടിലിറ്റി നിങ്ങളെ അനുവദിക്കുന്നു:
$ strace -f bash -c ‘/bin/echo foo | grep bar' .... getpid() = 13726<– PID основного процесса... pipe() <– системный вызов для создания конвеера.... clone(....) = 13727 <– подпроцесс для первой команды конвеера (echo) ... execve("/bin/echo", ["/bin/echo", "foo"], ..... clone(....) = 13728 <– подпроцесс для второй команды (grep) создается так же основным процессом... stat("/home/aikikode/bin/grep", ... Видно, что для создания конвеера используется системный вызов pipe(), а также, что оба процесса выполняются параллельно в разных потоках.

ധാരാളം ബാഷും കേർണൽ സോഴ്‌സ് കോഡും

ഉറവിട കോഡ്, ലെവൽ 1, ഷെൽ

ഏറ്റവും മികച്ച ഡോക്യുമെന്റേഷൻ സോഴ്സ് കോഡ് ആയതിനാൽ, നമുക്ക് അതിലേക്ക് തിരിയാം. ഇൻപുട്ട് കമാൻഡുകൾ പാഴ്‌സ് ചെയ്യാൻ Bash Yacc ഉപയോഗിക്കുന്നു, ഒരു '|' പ്രതീകം നേരിടുമ്പോൾ 'command_connect()' നൽകുന്നു.
parse.y:
1242 പൈപ്പ്ലൈൻ: പൈപ്പ്ലൈൻ '|' newline_list പൈപ്പ്ലൈൻ 1243 ( $$ = command_connect ($1, $4, '|'); ) 1244 | പൈപ്പ്‌ലൈൻ BAR_AND newline_list പൈപ്പ്‌ലൈൻ 1245 ( 1246 /* cmd1 |& cmd2 എന്നത് cmd1 ന് തുല്യമാക്കുക 2>&1 | cmd2 */ 1247 കമാൻഡ് *tc; 1248 റീഡയറക്‌ടീ rd, sd; 1248 = 251tr1 = 255tr1 = REDIRECT5 cm_simple ? (COMMAND *)$1->value.Simple: $1; 1252 sd.dest = 2; 1253 rd.dest = 1; 1254 r = make_redirection (sd, r_duplicating_output, rd, 0); tc->5 ഡയറക്ട് ആണെങ്കിൽ ) 1256 ( 1257 റിഡയറക്റ്റ് *t; 1258 എന്നതിനായി (t = tc-> റീഡയറക്‌ടുകൾ; t->അടുത്തത്; t = t->അടുത്തത്) 1259; 1260 t->അടുത്തത് = r; 1261 = r; 1264 1265 $$ = command_connect ($1, $4, '|'); 1266 ) 1267 | കമാൻഡ് 1268 ($$ = $1;) 1269; stdout ഉം stderr ഉം പൈപ്പ്‌ലൈനിലേക്ക് റീഡയറക്‌ട് ചെയ്യുന്നതിന് തുല്യമായ '|&' പ്രതീക ജോഡിയുടെ പ്രോസസ്സിംഗ് ഇവിടെ കാണാം. അടുത്തതായി, നമുക്ക് command_connect():make_cmd.c നോക്കാം :
194 COMMAND * 195 command_connect (com1, com2, കണക്റ്റർ) 196 കമാൻഡ് *com1, *com2; 197 ഇന്റ് കണക്റ്റർ; 198 (199 കണക്ഷൻ *താപനില; 200 201 temp = (കണക്‌ഷൻ *)xmalloc (sizeof (കണക്‌ഷൻ)); 202 temp->കണക്റ്റർ = കണക്റ്റർ; 203 temp->ആദ്യം = com1; 204 tempcom->സെക്കൻഡ് 2; 5 മടങ്ങ് make_command (cm_connection, (SIMPLE_COM *)temp)); 206 ) ഇവിടെ കണക്റ്റർ '|' പ്രതീകമാണ് int. കമാൻഡുകളുടെ ഒരു ശ്രേണി ('&', '|', ';', മുതലായവ വഴി ലിങ്ക് ചെയ്‌തിരിക്കുമ്പോൾ, execute_connection():execute_cmd.c എന്ന് വിളിക്കപ്പെടുന്നു:
2325 കേസ് '|': ... 2331 exec_result = execute_pipeline (കമാൻഡ്, അസിൻക്രണസ്, പൈപ്പ്_ഇൻ, പൈപ്പ്_ഔട്ട്, fds_to_close);
PIPE_IN, PIPE_OUT - ഫയൽ വിവരണങ്ങൾ, ഇൻപുട്ട്, ഔട്ട്പുട്ട് സ്ട്രീമുകളെക്കുറിച്ചുള്ള വിവരങ്ങൾ അടങ്ങിയിരിക്കുന്നു. അവർക്ക് NO_PIPE എന്ന മൂല്യം എടുക്കാം, അതായത് I/O എന്നത് stdin/stdout ആണ്.
execute_pipeline() എന്നത് വളരെ വിപുലമായ ഒരു ഫംഗ്‌ഷനാണ്, ഇതിന്റെ നടപ്പിലാക്കൽ execute_cmd.c യിൽ അടങ്ങിയിരിക്കുന്നു. ഞങ്ങൾക്ക് ഏറ്റവും താൽപ്പര്യമുണർത്തുന്ന ഭാഗങ്ങൾ ഞങ്ങൾ നോക്കും.
execute_cmd.c :
2112 മുൻ = പൈപ്പ്_ഇൻ; 2113 cmd = കമാൻഡ്; 2114 2115 അതേസമയം (cmd && cmd->type == cm_connection && 2116 cmd->value.Connection && cmd->value.Connection->കണക്റ്റർ == '|') 2117 ( 2118 /* രണ്ട് കമാൻഡുകൾക്കിടയിൽ ഒരു പൈപ്പ്ലൈൻ സൃഷ്ടിക്കുക */ 2119 എങ്കിൽ (പൈപ്പ് (ഫിൽഡുകൾ)< 0) 2120 { /* возвращаем ошибку */ } ....... /* Выполняем первую команду из конвейера, используя в качестве входных данных prev - вывод предыдущей команды, а в качестве выходных fildes - выходной файловый дескриптор, полученный в результате вызова pipe() */ 2178 execute_command_internal (cmd->മൂല്യം.കണക്ഷൻ->ആദ്യം, അസിൻക്രണസ്, 2179 മുമ്പത്തെ, fildes, fd_bitmap); 2180 2181 എങ്കിൽ (മുമ്പ് >= 0) 2182 അടയ്ക്കുക (മുമ്പ്); 2183 2184 മുൻ = fildes; /* ഞങ്ങളുടെ ഔട്ട്പുട്ട് അടുത്ത കമാൻഡിനുള്ള ഇൻപുട്ടായി മാറുന്നു */ 2185 അടയ്ക്കുക (ഫിൽഡുകൾ); ....... 2190 cmd = cmd->value.Connection->second; /* പൈപ്പ്ലൈനിൽ നിന്ന് അടുത്ത കമാൻഡിലേക്ക് "നീക്കുക" */ 2191 ) അതിനാൽ ബാഷ് പൈപ്പ്ലൈൻ ചിഹ്നം പ്രോസസ്സ് ചെയ്യുന്നു സിസ്റ്റം കോൾപൈപ്പ്() ഓരോ '|' പ്രതീകത്തിനും അഭിമുഖീകരിക്കുകയും ഓരോ കമാൻഡും ഇൻപുട്ട്, ഔട്ട്‌പുട്ട് സ്ട്രീമുകളായി അനുബന്ധ ഫയൽ ഡിസ്ക്രിപ്റ്ററുകൾ ഉപയോഗിച്ച് പ്രത്യേക പ്രോസസ്സിൽ പ്രവർത്തിപ്പിക്കുകയും ചെയ്യുന്നു.

സോഴ്സ് കോഡ്, ലെവൽ 2, കേർണൽ

നമുക്ക് കേർണൽ കോഡിലേക്ക് തിരിയാം, പൈപ്പ് () ഫംഗ്ഷൻ നടപ്പിലാക്കുന്നത് നോക്കാം. ഈ ലേഖനം കേർണൽ പതിപ്പ് 3.10.10 സ്റ്റേബിളിനെക്കുറിച്ചാണ് ചർച്ച ചെയ്യുന്നത്.
(ഈ ലേഖനത്തിന് അപ്രധാനമായ കോഡ് വിഭാഗങ്ങൾ ഒഴിവാക്കിയിരിക്കുന്നു):
/* ഒരു പ്രത്യേകാവകാശമില്ലാത്ത ഉപയോക്താവിനുള്ള പരമാവധി പൈപ്പ്ലൈൻ ബഫർ വലുപ്പം. /proc/sys/fs/pipe-max-size */ 35 unsigned int pipe_max_size = 1048576 എന്ന ഫയലിൽ റൂട്ട് ഉപയോഗിച്ച് സജ്ജമാക്കാൻ കഴിയും; /* കുറഞ്ഞ വലിപ്പം പൈപ്പ്ലൈൻ ബഫർ, POSIX ശുപാർശകൾ അനുസരിച്ച്, ഒരു മെമ്മറി പേജിന്റെ വലുപ്പത്തിന് തുല്യമാണ്, അതായത്. 4Kb */ 40 സൈൻ ചെയ്യാത്ത ഇൻറ്റ് പൈപ്പ്_മിനിറ്റ്_സൈസ് = PAGE_SIZE; 869 int create_pipe_files (struct file **res, int flags) 870 ( 871 int err; 872 struct inode *inode = get_pipe_inode(); 873 struct file *f; 874 struct path path; 875 സ്റ്റാറ്റിക് നാമം struct. = struct. "" ); /* dcache ൽ ഡെൻട്രി അനുവദിക്കുക */ 881 path.dentry = d_alloc_pseudo(pipe_mnt->mnt_sb, &name); /* ഫയൽ ഘടന അനുവദിക്കുകയും സമാരംഭിക്കുകയും ചെയ്യുക. FMODE_WRITE-ലും O_WRONLY ഫ്ലാഗും ശ്രദ്ധിക്കുക, അതായത്. ഘടന എഴുതാൻ മാത്രമുള്ളതാണ്, പൈപ്പ്ലൈനിലെ ഔട്ട്പുട്ട് സ്ട്രീമായി ഉപയോഗിക്കും. ഞങ്ങൾ പിന്നീട് O_NONBLOCK ഫ്ലാഗിലേക്ക് മടങ്ങും. */ 889 f = alloc_file(&path, FMODE_WRITE, &pipefifo_fops); 893 f->f_flags = O_WRONLY | (പതാകകൾ & (O_NONBLOCK | O_DIRECT )); /* അതുപോലെ, വായിക്കുന്നതിനായി ഞങ്ങൾ ഫയൽ ഘടന അനുവദിക്കുകയും ആരംഭിക്കുകയും ചെയ്യുന്നു (FMODE_READ, O_RDONLY ഫ്ലാഗ് എന്നിവ കാണുക) */ 896 res = alloc_file(&path, FMODE_READ, &pipefifo_fops); = 902 ags-> Of_ONDL | (ഫ്ലാഗുകൾ & O_NONBLOCK); 903 res = f; 904 റിട്ടേൺ 0; 917 ) 918 919 സ്റ്റാറ്റിക് int __do_pipe_flags (int *fd, struct file **files, int flags) 920 ( 921 int പിശക്; 922 int fdw, fdr; /* പൈപ്പ്ലൈൻ ഫയൽ ഡിസ്ക്രിപ്റ്ററുകൾക്കായി ഫയൽ ഘടനകൾ സൃഷ്ടിക്കുക (മുകളിലുള്ള പ്രവർത്തനം കാണുക) */ 927 പിശക് = create_pipe_files(ഫയലുകൾ, ഫ്ലാഗുകൾ); /* സൗജന്യ ഫയൽ വിവരണങ്ങൾ തിരഞ്ഞെടുക്കുക */ 931 fdr = get_unused_fd_flags(flags); 936 fdw = get_unused_fd_flags(flags); 941 audit_fd_pair(fdr, fdw); 942 fd = fdr; 943 fd = fdw; 944 റിട്ടേൺ 0; 952 ) /* ഫംഗ്‌ഷനുകൾ നേരിട്ട് നടപ്പിലാക്കൽ int pipe2(int pipefd, int ഫ്ലാഗുകൾ)... */ 969 SYSCALL_DEFINE2(pipe2, int __user *, fildes, int, flags) 970 ( 971 struct file *files; 972 int fd; * ഞങ്ങൾ ഇൻപുട്ട്/ഔട്ട്‌പുട്ടിനായി ഘടനകൾ സൃഷ്‌ടിക്കുകയും സൗജന്യ വിവരണങ്ങൾക്കായി നോക്കുകയും ചെയ്യുന്നു */ 975 __do_pipe_flags(fd, ഫയലുകൾ, ഫ്ലാഗുകൾ); /* ഫയൽ വിവരണങ്ങൾ കേർണൽ സ്‌പെയ്‌സിൽ നിന്ന് ഉപയോക്തൃ സ്‌പെയ്‌സിലേക്ക് പകർത്തുക */ 977 copy_to_user(fildes, fd, sizeof(fd)) */ സ്ഥിരസ്ഥിതി ഫ്ലാഗുകൾ ഉപയോഗിച്ച് പൈപ്പ്2 വിളിക്കുന്നു; */ 991 SYSCALL_DEFINE1(pipe, int __user *, fildes) 992 ( 993 return sys_pipe2(fildes, 0); 994 ) നിങ്ങൾ ശ്രദ്ധിച്ചാൽ, കോഡ് O_NONBLOCK ഫ്ലാഗിനായി പരിശോധിക്കുന്നു. fcntl-ലെ F_SETFL പ്രവർത്തനം ഉപയോഗിച്ച് ഇത് സജ്ജീകരിക്കാം. പൈപ്പ്ലൈനിൽ I/O ത്രെഡുകൾ തടയാതെ ഒരു മോഡിലേക്ക് മാറുന്നതിന് ഇത് ഉത്തരവാദിയാണ്. ഈ മോഡിൽ, തടയുന്നതിന് പകരം, സ്ട്രീമിലേക്ക് വായിക്കുന്ന/എഴുതുന്ന പ്രക്രിയ EAGAIN എന്ന തെറ്റ് കോഡ് ഉപയോഗിച്ച് അവസാനിക്കും.

പൈപ്പ്‌ലൈനിൽ എഴുതപ്പെടുന്ന ഒരു ഡാറ്റ ബ്ലോക്കിന്റെ പരമാവധി വലുപ്പം മെമ്മറിയുടെ ഒരു പേജിന് (4Kb) തുല്യമാണ്. ഭുജ വാസ്തുവിദ്യ:
:
8 #നിർവ്വചിക്കുക PIPE_BUF PAGE_SIZE കേർണലുകൾക്ക് >= 2.6.35 നിങ്ങൾക്ക് പൈപ്പ്ലൈൻ ബഫർ വലുപ്പം മാറ്റാം:
fcntl(fd, F_SETPIPE_SZ, ) ഞങ്ങൾ മുകളിൽ കണ്ടതുപോലെ, അനുവദനീയമായ പരമാവധി ബഫർ വലുപ്പം /proc/sys/fs/pipe-max-size എന്ന ഫയലിൽ വ്യക്തമാക്കിയിട്ടുണ്ട്.

നുറുങ്ങുകളും തന്ത്രങ്ങളും

ചുവടെയുള്ള ഉദാഹരണങ്ങളിൽ, നിലവിലുള്ള ഡോക്യുമെന്റ് ഡയറക്ടറിയിലും നിലവിലില്ലാത്ത രണ്ട് ഫയലുകളിലും ഞങ്ങൾ ls എക്സിക്യൂട്ട് ചെയ്യും: ./non-existent_file, . /other_non-existent_file.

stdout ഉം stderr ഉം പൈപ്പിലേക്ക് റീഡയറക്‌ട് ചെയ്യുക
ls -d ./Documents ./non-existent_file ./other_non-existent_file 2>&1 | egrep “Doc|other” ls: ആക്‌സസ് ചെയ്യാൻ കഴിയില്ല ./other_non-existent_file: അത്തരം ഫയലോ ഡയറക്‌ടറിയോ ./Documents അല്ലെങ്കിൽ നിങ്ങൾക്ക് '|&' എന്ന പ്രതീക കോമ്പിനേഷൻ ഉപയോഗിക്കാം (നിങ്ങൾക്ക് ഇത് ഷെൽ ഡോക്യുമെന്റേഷനിൽ (മാൻ ബാഷ്) കണ്ടെത്താനാകും. അല്ലെങ്കിൽ മുകളിലുള്ള സോഴ്‌സ് കോഡിൽ നിന്ന്, ഞങ്ങൾ Yacc ബാഷ് പാഴ്‌സർ പാഴ്‌സ് ചെയ്‌തത്):
ls -d ./Documents ./non-existent_file ./other_non-existent_file |& egrep “Doc|other” ls: ആക്സസ് ചെയ്യാൻ കഴിയില്ല ./other_non-existent_file: അത്തരം ഫയലോ ഡയറക്ടറിയോ ഇല്ല ./Documents
പൈപ്പിലേക്ക് _only_ stderr റീഡയറക്‌ട് ചെയ്യുക
$ ls -d ./Documents ./non-existent_file ./other_non-existent_file 2>&1 >/dev/null | egrep “Doc|other” ls: ആക്സസ് ചെയ്യാൻ കഴിയില്ല ./other_non-existent_file: അത്തരം ഫയലോ ഡയറക്ടറിയോ ഇല്ല കാലിൽ സ്വയം വെടിവയ്ക്കുക
stdout, stderr എന്നിവ റീഡയറക്‌ട് ചെയ്യുന്ന ക്രമം മാനിക്കേണ്ടത് പ്രധാനമാണ്. ഉദാഹരണത്തിന്, '>/dev/null 2>&1' കോമ്പിനേഷൻ stdout, stderr എന്നിവയെ /dev/null-ലേക്ക് റീഡയറക്ട് ചെയ്യും.
ശരിയായ പൈപ്പ്ലൈൻ പൂർത്തീകരണ കോഡ് നേടുന്നു
സ്ഥിരസ്ഥിതിയായി, പൈപ്പ്ലൈനിലെ അവസാന കമാൻഡിന്റെ എക്സിറ്റ് കോഡാണ് പൈപ്പ്ലൈൻ എക്സിറ്റ് കോഡ്. ഉദാഹരണത്തിന്, പൂജ്യമല്ലാത്ത കോഡിനൊപ്പം പുറത്തുകടക്കുന്ന യഥാർത്ഥ കമാൻഡ് എടുക്കുക:
$ ls -d ./non-existent_file 2>/dev/null; പ്രതിധ്വനി $? 2 പൈപ്പിൽ ഇടുക:
$ ls -d ./non-existent_file 2>/dev/null | സ്വാഗതം; പ്രതിധ്വനി $? 0 0 0 0 ഇപ്പോൾ പൈപ്പ്ലൈൻ എക്സിറ്റ് കോഡ് wc കമാൻഡ് എക്സിറ്റ് കോഡാണ്, അതായത്. 0.
സാധാരണഗതിയിൽ, പൈപ്പ് ലൈൻ എക്സിക്യൂഷൻ സമയത്ത് ഒരു പിശക് സംഭവിച്ചിട്ടുണ്ടോ എന്ന് നമുക്ക് അറിയേണ്ടതുണ്ട്. ഇത് ചെയ്യുന്നതിന്, പൈപ്പ്‌ലൈൻ എക്‌സിറ്റ് കോഡ് പൈപ്പ്‌ലൈൻ കമാൻഡുകളിലൊന്നിന്റെ ആദ്യ പൂജ്യമല്ലാത്ത എക്‌സിറ്റ് കോഡുമായി പൊരുത്തപ്പെടുമെന്ന് ഷെല്ലിനോട് പറയുന്ന പൈപ്പ്ഫെയിൽ ഓപ്ഷൻ സജ്ജമാക്കുക, അല്ലെങ്കിൽ എല്ലാ കമാൻഡുകളും ശരിയായി പൂർത്തീകരിച്ചാൽ പൂജ്യം:
$ set -o പൈപ്പ് ഫെയിൽ $ ls -d ./non-existent_file 2>/dev/null | സ്വാഗതം; പ്രതിധ്വനി $? 0 0 0 2 കാലിൽ സ്വയം വെടിവയ്ക്കുക
പൂജ്യം നൽകാത്ത "നിരുപദ്രവകരമായ" കമാൻഡുകളെക്കുറിച്ച് നിങ്ങൾ അറിഞ്ഞിരിക്കണം. കൺവെയറുകളുമായി പ്രവർത്തിക്കുന്നതിന് മാത്രമല്ല ഇത് ബാധകമാണ്. ഉദാഹരണത്തിന്, grep ഉദാഹരണം പരിഗണിക്കുക:
$ egrep “^foo=+” ./config | awk '("new_"$0 പ്രിന്റ് ചെയ്യുക;)' ഇവിടെ നമ്മൾ കണ്ടെത്തിയ എല്ലാ വരികളും പ്രിന്റ് ചെയ്യുന്നു, ഓരോ വരിയുടെയും തുടക്കത്തിൽ 'new_' ചേർക്കുന്നു, അല്ലെങ്കിൽ വരികൾ ഇല്ലെങ്കിൽ ഒന്നും പ്രിന്റ് ചെയ്യരുത് ആവശ്യമായ ഫോർമാറ്റ്കണ്ടെത്തിയില്ല. പൊരുത്തങ്ങളൊന്നും കണ്ടെത്തിയില്ലെങ്കിൽ കോഡ് 1-ൽ grep പരാജയപ്പെടുമെന്നതാണ് പ്രശ്നം, അതിനാൽ ഞങ്ങളുടെ സ്ക്രിപ്റ്റിൽ പൈപ്പ്ഫെയ്ൽ ഓപ്ഷൻ സജ്ജീകരിച്ചിട്ടുണ്ടെങ്കിൽ, ഈ ഉദാഹരണം കോഡ് 1-ൽ പരാജയപ്പെടും:
$ set -o പൈപ്പ് പരാജയം $ egrep “^foo=+” ./config | awk '("പുതിയ_"$0 അച്ചടിക്കുക;)' >/dev/null; പ്രതിധ്വനി $? 1 സങ്കീർണ്ണമായ ഘടനകളും നീളമുള്ള പൈപ്പ് ലൈനുകളും ഉള്ള വലിയ സ്ക്രിപ്റ്റുകളിൽ, ഈ പോയിന്റ് അവഗണിക്കാം, ഇത് തെറ്റായ ഫലങ്ങളിലേക്ക് നയിച്ചേക്കാം.
ഒരു പൈപ്പ്ലൈനിലെ വേരിയബിളുകൾക്ക് മൂല്യങ്ങൾ നൽകൽ
ആദ്യം, പൈപ്പ്ലൈനിലെ എല്ലാ കമാൻഡുകളും ക്ലോൺ () എന്ന് വിളിക്കുന്നതിലൂടെ ലഭിക്കുന്ന പ്രത്യേക പ്രോസസ്സുകളിലാണ് നടപ്പിലാക്കുന്നത് എന്ന് ഓർക്കുക. വേരിയബിൾ മൂല്യങ്ങൾ മാറുന്നില്ലെങ്കിൽ ഇത് പൊതുവെ ഒരു പ്രശ്നമല്ല.
ഇനിപ്പറയുന്ന ഉദാഹരണം പരിഗണിക്കുക:
$ a=aaa $ b=bbb $ echo “one two” | a b വായിക്കുക a, b വേരിയബിളുകളുടെ മൂല്യങ്ങൾ യഥാക്രമം "ഒന്ന്", "രണ്ട്" എന്നിവ ആയിരിക്കുമെന്ന് ഞങ്ങൾ ഇപ്പോൾ പ്രതീക്ഷിക്കുന്നു. വാസ്തവത്തിൽ, അവ "aaa", "bbb" എന്നിവയായി തുടരും. പൊതുവേ, പൈപ്പ്ലൈനിലെ വേരിയബിളുകളുടെ മൂല്യങ്ങളിൽ എന്തെങ്കിലും മാറ്റം വരുത്തിയാൽ, വേരിയബിളുകൾ മാറ്റമില്ലാതെ തുടരും:
$ filefound=0 $ കണ്ടുപിടിക്കുക. -ടൈപ്പ് എഫ് -സൈസ് +100k | ശരിയാണെങ്കിലും, f echo വായിക്കുക “$f 100KB-ന് മുകളിലാണ്” ഫയൽഫൗണ്ട്=1 ബ്രേക്ക് # എക്സിറ്റ് ആദ്യ ഫയലിന് ശേഷം $ echo $filefound; 100Kb-യിൽ കൂടുതൽ വലിപ്പമുള്ള ഒരു ഫയൽ കണ്ടെത്തുകയാണെങ്കിൽപ്പോലും, ഫയൽഫൗണ്ട് ഫ്ലാഗ് 0 ആയി സജ്ജീകരിക്കും.
ഈ പ്രശ്നത്തിന് സാധ്യമായ നിരവധി പരിഹാരങ്ങളുണ്ട്:
- സെറ്റ് ഉപയോഗിക്കുക -- $var
  ഈ നിർമ്മിതി var വേരിയബിളിന്റെ ഉള്ളടക്കം അനുസരിച്ച് പൊസിഷണൽ വേരിയബിളുകൾ സജ്ജമാക്കും. ഉദാഹരണത്തിന്, മുകളിലുള്ള ആദ്യ ഉദാഹരണത്തിലെന്നപോലെ:
  $ var=”one two” $ set -- $var $ a=$1 # “one” $ b=$2 # “two” സ്ക്രിപ്റ്റിന് യഥാർത്ഥ പൊസിഷണൽ പാരാമീറ്ററുകൾ നഷ്‌ടമാകുമെന്ന് ഓർമ്മിക്കേണ്ടതാണ്.
- വേരിയബിൾ മൂല്യം പ്രോസസ്സ് ചെയ്യുന്നതിനുള്ള എല്ലാ യുക്തികളും പൈപ്പ്ലൈനിലെ അതേ ഉപപ്രോസസിലേക്ക് മാറ്റുക:
  $ എക്കോ "ഒന്ന്" | (വായിക്കുക a; echo $a;) ഒന്ന്
- പൈപ്പ്ലൈനിനുള്ളിൽ വേരിയബിളുകൾ നൽകുന്നത് ഒഴിവാക്കാൻ ലോജിക്ക് മാറ്റുക.
  ഉദാഹരണത്തിന്, നമ്മുടെ കണ്ടെത്തൽ ഉദാഹരണം മാറ്റാം:
  $ filefound=0 $ എന്നതിലെ f-ന് $(കണ്ടെത്തുക . -type f -size +100k) # ഞങ്ങൾ പൈപ്പ്‌ലൈൻ നീക്കംചെയ്തു, അതിന് പകരം ഒരു ലൂപ്പ് ഉപയോഗിച്ച് അത് റീഡ് എഫ് എക്കോ "$f ഈസ് 100KB" ഫയൽഫൗണ്ട്=1 ബ്രേക്ക് ചെയ്തു $ echo $ ഫയൽ കണ്ടെത്തി;
- (ബാഷ്-4.2-നും അതിനുശേഷമുള്ളതിനും മാത്രം) ലാസ്റ്റ് പൈപ്പ് ഓപ്ഷൻ ഉപയോഗിക്കുക
  പ്രധാന പ്രക്രിയയിൽ അവസാന പൈപ്പ്ലൈൻ കമാൻഡ് എക്സിക്യൂട്ട് ചെയ്യാൻ ലാസ്റ്റ് പൈപ്പ് ഓപ്ഷൻ ഷെല്ലിനോട് നിർദ്ദേശിക്കുന്നു.
  $ (shopt -s lastpipe; a=”aaa”; echo “one” | read a; echo $a) ഒന്ന് കമാൻഡ് ലൈനിലെ ലാസ്റ്റ് പൈപ്പ് ഓപ്ഷൻ അനുബന്ധ പൈപ്പ് ലൈൻ ഉള്ള അതേ പ്രക്രിയയിൽ തന്നെ സജ്ജീകരിക്കേണ്ടത് പ്രധാനമാണ്. വിളിക്കുന്നു, അതിനാൽ മുകളിലുള്ള ഉദാഹരണത്തിലെ പരാൻതീസിസുകൾ ആവശ്യമാണ്. സ്ക്രിപ്റ്റുകളിൽ, പരാൻതീസിസ് ഓപ്ഷണൽ ആണ്.