മുകളിൽ സൂചിപ്പിച്ചതുപോലെ, അനിയന്ത്രിതമായ അൽഗോരിതങ്ങൾ നിർമ്മിക്കുന്നതിന്, അവസ്ഥ പരിശോധിക്കുന്ന ഓപ്പറേറ്റർമാർ ഉണ്ടായിരിക്കേണ്ടത് ആവശ്യമാണ്. ഷെൽ ബാഷ്തിരഞ്ഞെടുക്കൽ പ്രസ്താവനകളെ പിന്തുണയ്ക്കുന്നു എങ്കിൽ…പിന്നെ…വേറെയും കേസും, അതുപോലെ ലൂപ്പിംഗ് ഓപ്പറേറ്റർമാർ വേണ്ടി,സമയത്ത്, വരുവോളം, കാരണം അത് മാറുന്നു ശക്തമായ ഭാഷപ്രോഗ്രാമിംഗ്.

5.8.1 ഓപ്പറേറ്റർമാർ എങ്കിൽഒപ്പം പരീക്ഷ(അഥവാ )

ഡിസൈൻ സോപാധിക ഓപ്പറേറ്റർചെറുതായി ലളിതമാക്കിയ രൂപത്തിൽ ഇത് ഇതുപോലെ കാണപ്പെടുന്നു:

list1 ആണെങ്കിൽ list2 else list3 fi

എവിടെ പട്ടിക1, ലിസ്റ്റ്2, ലിസ്റ്റ്3കോമകളാൽ വേർതിരിച്ച് അർദ്ധവിരാമത്തിലോ ന്യൂലൈൻ പ്രതീകത്തിലോ അവസാനിക്കുന്ന കമാൻഡുകളുടെ ക്രമങ്ങളാണ്. കൂടാതെ, ഈ സീക്വൻസുകൾ ഉൾപ്പെടുത്താവുന്നതാണ് ബ്രേസുകൾ: (ലിസ്റ്റ്).

ഓപ്പറേറ്റർ എങ്കിൽഎന്നതിൽ നിന്നുള്ള കമാൻഡുകൾ നൽകിയ മൂല്യം പരിശോധിക്കുന്നു പട്ടിക1. ഈ ലിസ്റ്റിൽ നിരവധി കമാൻഡുകൾ ഉണ്ടെങ്കിൽ, ലിസ്റ്റിലെ അവസാന കമാൻഡ് നൽകിയ മൂല്യം പരിശോധിക്കും. ഈ മൂല്യം 0 ആണെങ്കിൽ, കമാൻഡുകൾ നിന്ന് പട്ടിക2; ഈ മൂല്യം പൂജ്യമല്ലെങ്കിൽ, കമാൻഡുകൾ പട്ടിക3. അത്തരമൊരു കോമ്പൗണ്ട് ഓപ്പറേറ്റർ നൽകുന്ന മൂല്യം എങ്കിൽ, എക്സിക്യൂട്ട് ചെയ്ത ശ്രേണിയുടെ അവസാന കമാൻഡ് നിർമ്മിക്കുന്ന മൂല്യത്തിന് തുല്യമാണ്.

പൂർണ്ണ കമാൻഡ് ഫോർമാറ്റ് എങ്കിൽഫോം ഉണ്ട്:

ലിസ്റ്റ് എങ്കിൽ ലിസ്റ്റ് [ elif ലിസ്റ്റ് പിന്നെ ലിസ്റ്റ് ] ... [ else list ] fi

(ഇവിടെ ചതുര ബ്രാക്കറ്റുകൾ അർത്ഥമാക്കുന്നത് അവയിൽ അടങ്ങിയിരിക്കുന്നത് ഓപ്പറേറ്ററിൽ ഉണ്ടായിരിക്കണമെന്നില്ല).

തൊട്ടുപിന്നാലെ വരുന്ന ഒരു പ്രയോഗമായി എങ്കിൽഅഥവാ എലിഫ്, പതിവായി ഉപയോഗിക്കുന്ന ഒരു കമാൻഡ് പരീക്ഷ, ഇത് ചതുര ബ്രാക്കറ്റുകളാലും സൂചിപ്പിക്കാം. ടീം പരീക്ഷചില പദപ്രയോഗങ്ങൾ വിലയിരുത്തുകയും പദപ്രയോഗം ശരിയാണെങ്കിൽ 0 നൽകുകയും അല്ലാത്തപക്ഷം 1 നൽകുകയും ചെയ്യുന്നു. എക്സ്പ്രഷൻ പ്രോഗ്രാമിലേക്ക് കൈമാറുന്നു പരീക്ഷഒരു വാദമായി. എഴുതുന്നതിനു പകരം

ടെസ്റ്റ് എക്സ്പ്രഷൻ,

നിങ്ങൾക്ക് ചതുര ബ്രാക്കറ്റുകളിൽ എക്സ്പ്രഷൻ ഉൾപ്പെടുത്താം:

[എക്സ്പ്രഷൻ].

ദയവായി ശ്രദ്ധിക്കുക പരീക്ഷകൂടാതെ [ ഒരേ പ്രോഗ്രാമിന്റെ രണ്ട് പേരുകളാണ്, ഷെൽ നടത്തുന്ന മാന്ത്രിക പരിവർത്തനമല്ല ബാഷ്( [ വാക്യഘടനയിൽ മാത്രം ഒരു ക്ലോസിംഗ് പരാൻതീസിസ് ഉൾപ്പെടുത്തേണ്ടതുണ്ട്). പകരം എന്നതും ശ്രദ്ധിക്കുക പരീക്ഷരൂപകൽപ്പനയിൽ എങ്കിൽഏത് പ്രോഗ്രാമും ഉപയോഗിക്കാം.

ഉപസംഹാരമായി, ഓപ്പറേറ്റർ ഉപയോഗിക്കുന്നതിനുള്ള ഒരു ഉദാഹരണം ഞങ്ങൾ നൽകുന്നു എങ്കിൽ:

എങ്കിൽ [ -e textmode2.htm ] ; പിന്നെ

ls ടെക്സ്റ്റ് മോഡ്*

വേറെ

പിഡബ്ല്യുഡി

ഓപ്പറേറ്ററെ കുറിച്ച് പരീക്ഷ(അല്ലെങ്കിൽ […]) ഞങ്ങൾക്ക് ഒരു പ്രത്യേക സംഭാഷണം ആവശ്യമാണ്.

5.8.2 ഓപ്പറേറ്റർ പരീക്ഷവ്യവസ്ഥകളും

പ്രസ്താവനയിൽ ഉപയോഗിച്ചിരിക്കുന്ന സോപാധിക പദപ്രയോഗങ്ങൾ പരീക്ഷ, സ്ഥിരീകരണത്തെ അടിസ്ഥാനമാക്കിയുള്ളതാണ് ഫയൽ ആട്രിബ്യൂട്ടുകൾ, സ്ട്രിംഗ് താരതമ്യങ്ങളും സാധാരണ ഗണിത താരതമ്യങ്ങളും. സങ്കീർണ്ണമായ ആവിഷ്കാരങ്ങൾഇനിപ്പറയുന്ന ഏകീകൃത അല്ലെങ്കിൽ ബൈനറി പ്രവർത്തനങ്ങളിൽ നിന്നാണ് നിർമ്മിച്ചിരിക്കുന്നത് ("എലിമെന്ററി ഇഷ്ടികകൾ"):

ഒരു ഫയല്

ഫയൽ എന്ന് പേരുള്ള ഒരു ഫയൽ നിലവിലുണ്ടെങ്കിൽ ശരിയാണ്.

ബി ഫയൽ

ശരിയാണെങ്കിൽ ഫയൽനിലവിലുണ്ട്, ഉണ്ട് പ്രത്യേക ഫയൽബ്ലോക്ക് ഉപകരണം.

സി ഫയൽ

ശരിയാണെങ്കിൽ ഫയൽനിലവിലുള്ളതും ഒരു പ്രത്യേക പ്രതീക ഉപകരണ ഫയലുമാണ്.

ഡി ഫയൽ

ശരിയാണെങ്കിൽ ഫയൽനിലവിലുള്ളതും ഒരു ഡയറക്ടറിയുമാണ്.

ഇ ഫയൽ

ഫയലിന്റെ പേരുണ്ടെങ്കിൽ ശരിയാണ് ഫയൽനിലവിലുണ്ട്.

എഫ് ഫയൽ

ഫയലിന്റെ പേരുണ്ടെങ്കിൽ ശരിയാണ് ഫയൽനിലവിലുള്ളതും ഒരു സാധാരണ ഫയലുമാണ്.

ജി ഫയൽ

ഫയലിന്റെ പേരുണ്ടെങ്കിൽ ശരിയാണ് ഫയൽനിലവിലുണ്ട്, അതിന്റെ ഗ്രൂപ്പ് മാറ്റ ബിറ്റ് സജ്ജീകരിച്ചിരിക്കുന്നു.

H ഫയൽ അല്ലെങ്കിൽ -L ഫയൽ

ഫയലിന്റെ പേരുണ്ടെങ്കിൽ ശരിയാണ് ഫയൽനിലനിൽക്കുന്നതും ഒരു പ്രതീകാത്മക ലിങ്കുമാണ്.

കെ ഫയൽ

ഫയലിന്റെ പേരുണ്ടെങ്കിൽ ശരിയാണ് ഫയൽനിലവിലുണ്ട്, അതിന്റെ "സ്റ്റിക്കി" ബിറ്റ് സജ്ജീകരിച്ചിരിക്കുന്നു.

പി ഫയൽ

ഫയലിന്റെ പേരുണ്ടെങ്കിൽ ശരിയാണ് ഫയൽനിലവിലുണ്ട്, ഉണ്ട് പേര് പൈപ്പ്(FIFO).

R ഫയൽ

ഫയലിന്റെ പേരുണ്ടെങ്കിൽ ശരിയാണ് ഫയൽനിലവിലുണ്ട് കൂടാതെ റീഡ് പെർമിഷൻ സെറ്റ് ചെയ്തിട്ടുണ്ട്

എസ് ഫയൽ

ഫയലിന്റെ പേരുണ്ടെങ്കിൽ ശരിയാണ് ഫയൽനിലവിലുണ്ട് ഒപ്പം അതിന്റെ വലിപ്പം പൂജ്യത്തേക്കാൾ വലുതാണ്.

ടിഎഫ്ഡി

ഫയൽ ഡിസ്ക്രിപ്റ്റർ ആണെങ്കിൽ ശരി fdതുറന്ന് ടെർമിനലിലേക്ക് ചൂണ്ടിക്കാണിക്കുന്നു.

യു ഫയൽ

ഫയലിന്റെ പേരുണ്ടെങ്കിൽ ശരിയാണ് ഫയൽനിലവിലുണ്ട്, അതിന്റെ മാറ്റം യൂസർ ബിറ്റ് സജ്ജീകരിച്ചിരിക്കുന്നു.

W ഫയൽ

ഫയലിന്റെ പേരുണ്ടെങ്കിൽ ശരിയാണ് ഫയൽനിലവിലുണ്ട് കൂടാതെ എഴുതാനുള്ള അനുമതി സജ്ജീകരിച്ചിരിക്കുന്നു.

X ഫയൽ

ഫയലിന്റെ പേരുണ്ടെങ്കിൽ ശരിയാണ് ഫയൽനിലവിലുണ്ട്, എക്സിക്യൂട്ടബിൾ ആണ്.

ഒ ഫയൽ

ഫയലിന്റെ പേരുണ്ടെങ്കിൽ ശരിയാണ് ഫയൽനിലവിലുള്ളതും ഫലപ്രദമായ ഉപയോക്തൃ ഐഡി ചൂണ്ടിക്കാണിച്ച ഉപയോക്താവിന്റെ ഉടമസ്ഥതയിലുള്ളതുമാണ്.

ജി ഫയൽ

ഫയലിന്റെ പേരുണ്ടെങ്കിൽ ശരിയാണ് ഫയൽനിലവിലുള്ളതും ഫലപ്രദമായ ഗ്രൂപ്പ് ഐഡി തിരിച്ചറിഞ്ഞ ഗ്രൂപ്പിൽ പെട്ടതുമാണ്.

എസ് ഫയൽ

ഫയലിന്റെ പേരുണ്ടെങ്കിൽ ശരിയാണ് ഫയൽനിലവിലുണ്ട്, ഒരു സോക്കറ്റ് ആണ്.

എൻ ഫയൽ

ഫയലിന്റെ പേരുണ്ടെങ്കിൽ ശരിയാണ് ഫയൽനിലവിലുണ്ട്, അവസാനം വായിച്ചതിനുശേഷം അത് മാറിയിരിക്കുന്നു.

ഫയൽ1 -എൻടി ഫയൽ2

ഫയൽ ആണെങ്കിൽ ശരി ഫയൽ1എന്നതിനേക്കാൾ പിന്നീടുള്ള പരിഷ്ക്കരണ സമയമുണ്ട് ഫയൽ2.

file1 -ot ഫയൽ2

ഫയൽ ആണെങ്കിൽ ശരി ഫയൽ1അതിനേക്കാൾ പഴയ ഫയൽ2.

ഫയൽ1 -എഫ് ഫയൽ2

ഫയലുകളാണെങ്കിൽ ശരിയാണ് ഫയൽ1ഒപ്പം ഫയൽ2ഒരേ ഉപകരണവും ഐനോഡ് നമ്പറുകളും ഉണ്ട്(ഇനോഡ്).

ഓ ഓപ്‌റ്റ് നെയിം

ഷെൽ ഓപ്ഷൻ പ്രവർത്തനക്ഷമമാക്കിയിട്ടുണ്ടെങ്കിൽ ശരിയാണ് ഒപ്റ്റ്നാമം. വിശദീകരണത്തിന്, ബാഷ് മാൻ പേജ് കാണുക.

Z സ്ട്രിംഗ്

സ്ട്രിംഗിന്റെ നീളം പൂജ്യമാണെങ്കിൽ ശരിയാണ്.

N സ്ട്രിംഗ്

സ്ട്രിംഗിന്റെ നീളം പൂജ്യമല്ലെങ്കിൽ ശരിയാണ്.

string1 == string2

സ്ട്രിംഗുകൾ പൊരുത്തപ്പെടുന്നുവെങ്കിൽ ശരിയാണ്. ഇതിനുപകരമായി == ഉപയോഗിക്കാന് കഴിയും = .

string1 !== string2

സ്ട്രിംഗുകൾ പൊരുത്തപ്പെടുന്നില്ലെങ്കിൽ ശരിയാണ്.

സ്ട്രിംഗ്1< string2

വരി ആണെങ്കിൽ ശരി സ്ട്രിംഗ്1ലെക്സിക്കോഗ്രാഫിക്കലി സ്ട്രിംഗിന് മുമ്പുള്ളതാണ് ചരട്2(നിലവിലെ പ്രാദേശികമായി).

string1 > string2

വരി ആണെങ്കിൽ ശരി സ്ട്രിംഗ്1ലെക്സിക്കോഗ്രാഫിക്കലി വരിക്ക് ശേഷം വരുന്നു ചരട്2(നിലവിലെ പ്രാദേശികമായി).

arg1 OP arg2

ഇവിടെ ഒ.പി- ഓ തുടർന്ന് ഗണിത താരതമ്യ പ്രവർത്തനങ്ങളിൽ ഒന്ന്: -eq(തുല്യം), -നെ(തുല്യമല്ല), -lt(അതിൽ കുറവ്), -ലെ(കുറവ് അല്ലെങ്കിൽ തുല്യം), -ജിടി(കൂടുതൽ), -ജി(കൂടുതലോ തുല്യമോ). പോസിറ്റീവ് അല്ലെങ്കിൽ നെഗറ്റീവ് പൂർണ്ണസംഖ്യകൾ ആർഗ്യുമെന്റുകളായി ഉപയോഗിക്കാം.

ഈ എലിമെന്ററി സോപാധിക പദപ്രയോഗങ്ങളിൽ നിന്ന്, NEGATION, AND കൂടാതെ OR എന്നതിന്റെ സാധാരണ ലോജിക്കൽ ഓപ്പറേഷനുകൾ ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഇഷ്ടമുള്ളത്ര സങ്കീർണ്ണമായത് നിർമ്മിക്കാൻ കഴിയും:

!(എക്സ്പ്രഷൻ)

ബൂളിയൻ നിഷേധ ഓപ്പറേറ്റർ.

എക്സ്പ്രഷൻ1 -എ എക്സ്പ്രഷൻ2

ബൂളിയൻ ഓപ്പറേറ്റർ ഒപ്പം(ഒപ്പം). രണ്ട് പ്രയോഗങ്ങളും ശരിയാണെങ്കിൽ ശരി.

എക്സ്പ്രഷൻ1 -ഒ എക്സ്പ്രഷൻ2

ബൂളിയൻ ഓപ്പറേറ്റർ അഥവാ(അഥവാ). രണ്ട് പ്രയോഗങ്ങളിൽ ഏതെങ്കിലും ശരിയാണെങ്കിൽ ശരി.

ഒരേ സോപാധിക പദപ്രയോഗങ്ങൾ ഓപ്പറേറ്ററുകളിലും ഉപയോഗിക്കുന്നു സമയത്ത്ഒപ്പം വരുവോളം, ഞങ്ങൾ താഴെ നോക്കും.

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

ഓപ്പറേറ്റർ ഫോർമാറ്റ് കേസ്ആണ്:

[[(] പാറ്റേൺ [ | പാറ്റേൺ ] ...) ലിസ്റ്റിലെ കേസ് വാക്ക് ;; ]...എസക്

ടീം കേസ്ആദ്യം വാക്ക് വികാസം ഉണ്ടാക്കുന്നു വാക്ക്, കൂടാതെ ഓരോ സാമ്പിളുകളുമായും ഫലം പൊരുത്തപ്പെടുത്താൻ ശ്രമിക്കുന്നു മാതൃകഒന്നൊന്നായി. ആദ്യ പൊരുത്തം കണ്ടെത്തിയതിന് ശേഷം, കൂടുതൽ പരിശോധനകളൊന്നും നടക്കുന്നില്ല; പൊരുത്തം കണ്ടെത്തിയ പാറ്റേൺ പിന്തുടരുന്ന കമാൻഡുകളുടെ ലിസ്റ്റ് എക്സിക്യൂട്ട് ചെയ്യുന്നു. പാറ്റേൺ പൊരുത്തങ്ങളൊന്നും കണ്ടെത്തിയില്ലെങ്കിൽ, ഓപ്പറേറ്റർ നൽകുന്ന മൂല്യം 0 ആണ്. അല്ലെങ്കിൽ, അനുബന്ധ ലിസ്റ്റിലെ അവസാന കമാൻഡ് നൽകിയ മൂല്യം തിരികെ നൽകും.

കേസ് സ്റ്റേറ്റ്മെന്റ് ഉപയോഗിക്കുന്നതിനുള്ള ഇനിപ്പറയുന്ന ഉദാഹരണം സിസ്റ്റം സ്ക്രിപ്റ്റിൽ നിന്ന് എടുത്തതാണ് /etc/rc.d/rc.sysinit.

"$UTC" എന്ന കേസ്

അതെ|ശരി)

CLOCKFLAGS="$CLOCKFLAGS -u";

CLOCKDEF="$CLOCKDEF (utc)";

ഇല്ല|തെറ്റ്)

CLOCKFLAGS="$CLOCKFLAGS --localtime";

CLOCKDEF="$CLOCKDEF (പ്രാദേശിക സമയം)";

esac

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

5.8.4 ഓപ്പറേറ്റർ തിരഞ്ഞെടുക്കുക

ഓപ്പറേറ്റർ തിരഞ്ഞെടുക്കുകഉപയോക്താവുമായി സംവേദനാത്മക ഇടപെടൽ സംഘടിപ്പിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു. ഇതിന് ഇനിപ്പറയുന്ന ഫോർമാറ്റ് ഉണ്ട്:

പേര് തിരഞ്ഞെടുക്കുക [വാക്കിൽ; ] ചെയ്യേണ്ട പട്ടിക; ചെയ്തു

ടെംപ്ലേറ്റിൽ നിന്ന് ആദ്യം വാക്ക്പാറ്റേണുമായി പൊരുത്തപ്പെടുന്ന പദങ്ങളുടെ ഒരു ലിസ്റ്റ് സൃഷ്ടിക്കപ്പെടുന്നു. ഈ വാക്കുകളുടെ കൂട്ടം സ്റ്റാൻഡേർഡ് പിശകിലേക്ക് ഔട്ട്പുട്ട് ചെയ്യുന്നു, ഓരോ വാക്കും പിന്തുടരുന്നു സീരിയൽ നമ്പർ. പാറ്റേൺ എങ്കിൽ വാക്ക്ഒഴിവാക്കി, പൊസിഷണൽ പാരാമീറ്ററുകൾ അതേ രീതിയിൽ ഉരുത്തിരിഞ്ഞതാണ്. തുടർന്ന് സ്റ്റാൻഡേർഡ് PS3 പ്രോംപ്റ്റ് നൽകുകയും സ്റ്റാൻഡേർഡ് ഇൻപുട്ടിൽ ഒരു ലൈൻ നൽകുന്നതിനായി ഷെൽ കാത്തിരിക്കുകയും ചെയ്യുന്നു. നൽകിയ സ്ട്രിംഗിൽ പ്രദർശിപ്പിച്ച പദങ്ങളിലൊന്നിന് അനുയോജ്യമായ ഒരു സംഖ്യ ഉണ്ടെങ്കിൽ, വേരിയബിൾ പേര്ആ വാക്കിന് തുല്യമായ മൂല്യം നൽകിയിരിക്കുന്നു. ഒരു ശൂന്യമായ വരി നൽകിയാൽ, അക്കങ്ങളും അനുബന്ധ വാക്കുകളും വീണ്ടും പ്രദർശിപ്പിക്കും. മറ്റേതെങ്കിലും മൂല്യം നൽകിയിട്ടുണ്ടെങ്കിൽ, വേരിയബിൾ പേര്ചുമതലപ്പെടുത്തി ശൂന്യമായ മൂല്യം. ഉപയോക്താവ് നൽകിയ സ്ട്രിംഗ് ഒരു വേരിയബിളിൽ സംഭരിച്ചിരിക്കുന്നു മറുപടി. കമാൻഡുകളുടെ പട്ടിക പട്ടികതിരഞ്ഞെടുത്ത വേരിയബിൾ മൂല്യം ഉപയോഗിച്ച് നടപ്പിലാക്കുന്നു പേര്.

ഒരു ചെറിയ സ്ക്രിപ്റ്റ് ഇതാ:

#!/bin/sh

echo "ഏത് OS ആണ് നിങ്ങൾ ഇഷ്ടപ്പെടുന്നത്?"

"Linux" "Gnu Hurd" "Free BSD" "Other" എന്നതിൽ var തിരഞ്ഞെടുക്കുക; ചെയ്യുക

ബ്രേക്ക്

ചെയ്തു

പ്രതിധ്വനി "നിങ്ങൾ $var തിരഞ്ഞെടുക്കും"

ഏത് OS ആണ് നിങ്ങൾ ഇഷ്ടപ്പെടുന്നത്?
1) ലിനക്സ്
2) ഗ്നു ഹർഡ്
3) സൗജന്യ ബിഎസ്ഡി
4) മറ്റുള്ളവ
#?

നിർദ്ദേശിച്ചിരിക്കുന്ന 4 നമ്പറുകളിൽ ഏതെങ്കിലും അമർത്തുക (1,2,3,4). നിങ്ങൾ 1 നൽകുകയാണെങ്കിൽ, ഉദാഹരണത്തിന്, നിങ്ങൾ സന്ദേശം കാണും:

"നിങ്ങൾ Linux തിരഞ്ഞെടുക്കുമോ"

5.8.5 ഓപ്പറേറ്റർ വേണ്ടി

ഓപ്പറേറ്റർ വേണ്ടിസാധാരണ പ്രോഗ്രാമിംഗ് ഭാഷകളേക്കാൾ അല്പം വ്യത്യസ്തമായി പ്രവർത്തിക്കുന്നു. ഓരോ തവണയും ലൂപ്പിലൂടെ കടന്നുപോകുമ്പോൾ ചില വേരിയബിളിന്റെ മൂല്യം ഒന്നായി കൂട്ടുകയോ കുറയ്ക്കുകയോ ചെയ്യുന്നതിനുപകരം, ഓരോ തവണയും ലൂപ്പിലൂടെ കടന്നുപോകുമ്പോൾ നൽകിയിരിക്കുന്ന വാക്കുകളുടെ പട്ടികയിൽ നിന്ന് അടുത്ത മൂല്യം വേരിയബിളിലേക്ക് നൽകുന്നു. പൊതുവേ, ഡിസൈൻ ഇതുപോലെ കാണപ്പെടുന്നു:

വാക്കുകളിൽ പേരിനായി ലിസ്റ്റ് ചെയ്തു.

കമാൻഡ് ലിസ്റ്റുകൾ നിർമ്മിക്കുന്നതിനുള്ള നിയമങ്ങൾ ( പട്ടിക) ഓപ്പറേറ്ററിലുള്ളതിന് സമാനമാണ് എങ്കിൽ.

ഉദാഹരണം. ഇനിപ്പറയുന്ന സ്ക്രിപ്റ്റ് foo_1, foo_2, foo_3 എന്നീ ഫയലുകൾ സൃഷ്ടിക്കുന്നു:

ഒരു ഇൻ 1 2 3 ; ചെയ്യുക

foo_$a സ്പർശിക്കുക

ചെയ്തു

പൊതുവായി പ്രസ്താവനയ്ക്കായിഫോർമാറ്റ് ഉണ്ട്:

പേരിന് [വാക്കിൽ; ] ചെയ്യേണ്ട പട്ടിക; ചെയ്തു

ആദ്യം, വാക്ക് വെളിപ്പെടുന്നു വാക്ക്മുകളിൽ നൽകിയിരിക്കുന്ന എക്സ്പ്രഷൻ വെളിപ്പെടുത്തൽ നിയമങ്ങൾ അനുസരിച്ച്. പിന്നെ വേരിയബിൾ പേര്തത്ഫലമായുണ്ടാകുന്ന മൂല്യങ്ങൾ ഓരോന്നായി അസൈൻ ചെയ്യുന്നു, ഓരോ തവണയും കമാൻഡുകളുടെ ഒരു ലിസ്റ്റ് എക്സിക്യൂട്ട് ചെയ്യുന്നു ist. എങ്കിൽ " വാക്കിൽ" കാണുന്നില്ല, തുടർന്ന് കമാൻഡുകളുടെ പട്ടിക പട്ടികവ്യക്തമാക്കിയ ഓരോ പൊസിഷണൽ പാരാമീറ്ററിനും ഒരിക്കൽ എക്സിക്യൂട്ട് ചെയ്യുന്നു.

ലിനക്സിന് ഒരു പ്രോഗ്രാം ഉണ്ട് seq, ഇത് രണ്ട് സംഖ്യകളെ ആർഗ്യുമെന്റുകളായി എടുക്കുകയും തന്നിരിക്കുന്നവയ്ക്കിടയിൽ സ്ഥിതി ചെയ്യുന്ന എല്ലാ സംഖ്യകളുടെയും ഒരു ക്രമം ഉണ്ടാക്കുകയും ചെയ്യുന്നു. ഈ കമാൻഡ് ഉപയോഗിച്ച് നിങ്ങൾക്ക് നിർബന്ധിക്കാം വേണ്ടിവി ബാഷ്പരമ്പരാഗത പ്രോഗ്രാമിംഗ് ഭാഷകളിൽ സമാനമായ ഓപ്പറേറ്റർ പ്രവർത്തിക്കുന്നത് പോലെ തന്നെ പ്രവർത്തിക്കുക. ഇത് ചെയ്യുന്നതിന്, സൈക്കിൾ എഴുതുക വേണ്ടിഇനിപ്പറയുന്ന രീതിയിൽ:

ഒരു ഇൻ $(seq 1 10) ; ചെയ്യുക

പൂച്ച ഫയൽ_$a

ചെയ്തു

ഈ കമാൻഡ് 10 ഫയലുകളുടെ ഉള്ളടക്കം പ്രദർശിപ്പിക്കുന്നു: " file_1", ..., "file_10".

5.8.6 ഓപ്പറേറ്റർമാർ സമയത്ത്ഒപ്പം വരുവോളം

ഓപ്പറേറ്റർ സമയത്ത്പോലെ പ്രവർത്തിക്കുന്നു എങ്കിൽ, ലിസ്റ്റിൽ നിന്നുള്ള ഓപ്പറേറ്റർമാരെ മാത്രം നടപ്പിലാക്കുന്നു പട്ടിക2വ്യവസ്ഥ ശരിയാകുന്നിടത്തോളം ലൂപ്പ് തുടരുകയും വ്യവസ്ഥ ശരിയല്ലെങ്കിൽ അലസിപ്പിക്കുകയും ചെയ്യുന്നു. ഡിസൈൻ ഇതുപോലെ കാണപ്പെടുന്നു:

ലിസ്റ്റ്1 ചെയ്യുമ്ബോൾ ലിസ്റ്റ്2 ചെയ്തു.

അതേസമയം [-d mydirectory]; ചെയ്യുക

ls -l mydirectory >> logfile

echo -- SEPARATOR -- >> logfile

ഉറക്കം 60

ചെയ്തു

ഡയറക്‌ടറി നിലനിൽക്കുന്നിടത്തോളം ഓരോ മിനിറ്റിലും "mydirectory" എന്ന ഡയറക്‌ടറിയിലെ ഉള്ളടക്കങ്ങൾ അത്തരമൊരു പ്രോഗ്രാം ലോഗ് ചെയ്യും.

ഓപ്പറേറ്റർ വരുവോളംഓപ്പറേറ്റർ പോലെ സമയത്ത്:

ലിസ്‌റ്റ്1 ചെയ്‌ത് ലിസ്‌റ്റ്2 ചെയ്യുന്നതുവരെ.

സ്റ്റേറ്റ്‌മെന്റുകളുടെ ഒരു ലിസ്റ്റ് എക്‌സിക്യൂട്ട് ചെയ്യുമ്പോൾ ഫലം ലഭിച്ചു എന്നതാണ് വ്യത്യാസം പട്ടിക1, നിഷേധാത്മകമായി എടുത്തത്: പട്ടിക2ലിസ്റ്റിലെ അവസാന കമാൻഡ് ആണെങ്കിൽ എക്സിക്യൂട്ട് ചെയ്യപ്പെടും പട്ടിക1പൂജ്യമല്ലാത്ത എക്സിറ്റ് സ്റ്റാറ്റസ് നൽകുന്നു.

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

വാക്യഘടന

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

ഫംഗ്‌ഷൻ നാമം() (ലിസ്റ്റ്)

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

നിലവിലെ ഷെല്ലിന്റെ പശ്ചാത്തലത്തിലാണ് ഫംഗ്‌ഷനുകൾ നടപ്പിലാക്കുന്നത്: ഫംഗ്‌ഷനെ വ്യാഖ്യാനിക്കുന്നതിന് ഒരു പുതിയ പ്രക്രിയ ആരംഭിച്ചിട്ടില്ല (ഷെൽ സ്‌ക്രിപ്റ്റുകൾ നടപ്പിലാക്കുന്നതിൽ നിന്ന് വ്യത്യസ്തമായി).

വാദങ്ങൾ

ഒരു ഫംഗ്‌ഷൻ എക്‌സിക്യൂഷനു വേണ്ടി വിളിക്കുമ്പോൾ, ഫംഗ്‌ഷന്റെ ആർഗ്യുമെന്റുകൾ മാറുന്നു സ്ഥാന പരാമീറ്ററുകൾ(സ്ഥാന പാരാമീറ്ററുകൾ)ഫംഗ്ഷന്റെ കാലത്തേക്ക്. എന്നാണ് അവരെ പരാമർശിക്കുന്നത് $n, എവിടെ എൻ— ഞങ്ങൾ ആക്സസ് ചെയ്യാൻ ആഗ്രഹിക്കുന്ന ആർഗ്യുമെന്റിന്റെ എണ്ണം. ആർഗ്യുമെന്റ് നമ്പറിംഗ് 1-ൽ ആരംഭിക്കുന്നു, അങ്ങനെ $1 - ഇതാണ് ആദ്യത്തെ വാദം. നമുക്ക് എല്ലാ വാദങ്ങളും ഒരേസമയം നേടാനും കഴിയും $* , ഉപയോഗിക്കുന്ന ആർഗ്യുമെന്റുകളുടെ എണ്ണം $# . പൊസിഷണൽ പാരാമീറ്റർ 0 മാറുന്നില്ല.

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

പ്രാദേശിക വേരിയബിളുകൾ (ലോക്കൽ)

നമുക്ക് സൃഷ്ടിക്കണമെങ്കിൽ പ്രാദേശിക പരാമീറ്റർ, നിങ്ങൾക്ക് കീവേഡ് ഉപയോഗിക്കാം പ്രാദേശികമായ. ഇത് വ്യക്തമാക്കുന്നതിനുള്ള വാക്യഘടന സാധാരണ പാരാമീറ്ററുകൾക്ക് തുല്യമാണ്, നിർവചനത്തിന് മുമ്പായി ഒരു കീവേഡ് മാത്രമേ ഉള്ളൂ പ്രാദേശികം: പ്രാദേശികം പേര്=മൂല്യം.

മുകളിൽ സൂചിപ്പിച്ച കമാൻഡ് നടപ്പിലാക്കുന്ന ഒരു ഫംഗ്ഷൻ വ്യക്തമാക്കുന്നതിനുള്ള ഒരു ഉദാഹരണം ഇതാ seq:

seq()

പ്രാദേശിക I=$1;

അതേസമയം [ $2 != $I ]; ചെയ്യുക

echo -n "$I";

I=$(($I + 1))

ചെയ്തു;

പ്രതിധ്വനി $2

ഓപ്ഷൻ ശ്രദ്ധിക്കുക -എൻഓപ്പറേറ്റർ പ്രതിധ്വനി, എന്നതിലേക്കുള്ള പരിവർത്തനം ഇത് റദ്ദാക്കുന്നു പുതിയ വര. ഇവിടെ നമ്മൾ മനസ്സിൽ കരുതുന്ന ഉദ്ദേശ്യങ്ങൾക്ക് ഇത് അത്യാവശ്യമല്ലെങ്കിലും, മറ്റ് ആവശ്യങ്ങൾക്ക് ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നതിന് ഇത് ഉപയോഗപ്രദമാകും.

ഫാക്റ്റീരിയൽ കണക്കുകൂട്ടൽ പ്രവർത്തനം വസ്തുത

ഒരു ഉദാഹരണം കൂടി:

വസ്തുത()

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

എക്കോ 1;

വേറെ

പ്രതിധ്വനി $(($1 * $(വസ്തുത $(($1 - 1))))))

ഇതാണ് ഫാക്‌ടോറിയൽ ഫംഗ്‌ഷൻ, ഒരു റിക്കേഴ്‌സീവ് ഫംഗ്‌ഷന്റെ ഉദാഹരണം. ഗണിത വിപുലീകരണവും കമാൻഡ് പകരം വയ്ക്കലും ശ്രദ്ധിക്കുക.

വി. കോസ്ട്രോമിൻ (കോസ് അറ്റ് റൂസ്-ലിനക്സ് ഡോട്ട് നെറ്റ്) - 5.8. ഒരു പ്രോഗ്രാമിംഗ് ഭാഷയായി ഷെൽ

    ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങൾ ലിനക്സ് കുടുംബം, മറ്റേതൊരു OS-നും എന്നപോലെ, കമ്പ്യൂട്ടർ സിസ്റ്റത്തിന്റെ ഘടകങ്ങളും അന്തിമ ഉപയോക്താവും തമ്മിലുള്ള ഒരു ഇന്ററാക്ഷൻ ഇന്റർഫേസിന്റെ സാന്നിധ്യം ആവശ്യമാണ്, അതായത്, ആവശ്യമുള്ള ഫലങ്ങൾ നേടുന്നതിന് കമാൻഡുകളുടെയും പാരാമീറ്ററുകളുടെയും ഇൻപുട്ട് നൽകുന്ന ഒരു സോഫ്റ്റ്വെയർ ലെവലിന്റെ സാന്നിധ്യം. അത്തരം പ്രോഗ്രാം ലെവൽപേര് ലഭിച്ചു "ഷെൽ"അല്ലെങ്കിൽ, ഇംഗ്ലീഷിൽ - ഷെൽ.

എന്താണ് ഷെൽ?

കമാൻഡ് ഷെൽ ( ഷെൽ) ഉപയോക്താവും Linux ഓപ്പറേറ്റിംഗ് സിസ്റ്റം പരിസ്ഥിതിയും തമ്മിലുള്ള ആശയവിനിമയം നൽകുന്നു. അവൾ സ്പെഷ്യലൈസ്ഡ് ആണ് സോഫ്റ്റ്വെയർ ഉൽപ്പന്നം, ഇത് കമാൻഡുകൾ നടപ്പിലാക്കുന്നതും അവയുടെ നിർവ്വഹണത്തിന്റെ ഫലങ്ങൾ നേടുന്നതും ഉറപ്പാക്കുന്നു, അല്ലെങ്കിൽ, വളരെ ലളിതമായി പറഞ്ഞാൽ, ഉപയോക്താവിന്റെ അഭ്യർത്ഥനപ്രകാരം മറ്റ് പ്രോഗ്രാമുകളുടെ നിർവ്വഹണം ഉറപ്പാക്കാൻ രൂപകൽപ്പന ചെയ്ത ഒരു പ്രോഗ്രാമാണ് ഷെൽ. ഒരു ഷെല്ലിന്റെ ഒരു ഉദാഹരണം, ഉദാഹരണത്തിന്, ഒരു കമാൻഡ് ഇന്റർപ്രെറ്റർ ആകാം command.comഓപ്പറേറ്റിംഗ് സിസ്റ്റം MS DOS, അല്ലെങ്കിൽ ഷെൽ ബാഷ്ഓപ്പറേഷൻ റൂമുകൾ യുണിക്സ് സിസ്റ്റങ്ങൾ/ലിനക്സ്.

എല്ലാ ഷെല്ലുകൾക്കും അവയുടെ പ്രധാന ഉദ്ദേശ്യത്തിന് അനുസൃതമായി സമാനമായ പ്രവർത്തനങ്ങളും ഗുണങ്ങളുമുണ്ട് - ഉപയോക്തൃ കമാൻഡുകൾ നടപ്പിലാക്കുന്നതിനും അവയുടെ നിർവ്വഹണ ഫലങ്ങൾ പ്രദർശിപ്പിക്കുന്നതിനും:

കമാൻഡ് ലൈൻ വ്യാഖ്യാനം.

കമാൻഡുകളിലേക്കുള്ള പ്രവേശനവും അവയുടെ നിർവ്വഹണ ഫലങ്ങളും.

വേരിയബിളുകൾ, പ്രത്യേക പ്രതീകങ്ങൾ എന്നിവയ്ക്കുള്ള പിന്തുണ സംവരണം ചെയ്ത വാക്കുകൾ.

ഫയലുകളുടെ പ്രോസസ്സിംഗ്, സ്റ്റാൻഡേർഡ് ഇൻപുട്ട്, ഔട്ട്പുട്ട് പ്രവർത്തനങ്ങൾ.

ഒരു പ്രത്യേക ഷെൽ പ്രോഗ്രാമിംഗ് ഭാഷയുടെ നടപ്പാക്കൽ.

    Unix / Linux കുടുംബത്തിന്റെ ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങൾക്കായി, സിസ്റ്റവുമായുള്ള ഇടപെടലിന്റെ സവിശേഷതകളിലും രീതികളിലും വ്യത്യാസമുള്ള നിരവധി വ്യത്യസ്ത ഷെല്ലുകൾ ഉപയോഗിക്കാൻ കഴിയും. ഏറ്റവും സാധാരണമായ ഷെല്ലുകളാണ്

sh- ഷെൽ ബോൺ , ക്ലാസിക് ഷെൽ Unix OS-ന്

ബാഷ്ഷെൽ വീണ്ടും ബോൺ(GNU Bourne-Again SHell). Linux OS പരിതസ്ഥിതിയിൽ ഇപ്പോൾ ഏറ്റവും സാധാരണമായ ഷെൽ.

ksh- ഷെൽ കോർൺ, ഒരു ഷെൽ വികസനം രൂപകൽപ്പന ബോൺകമാൻഡ് ലൈൻ ചരിത്രവും കമാൻഡുകൾ എഡിറ്റ് ചെയ്യാനുള്ള കഴിവും.

csh- ഷെൽ സി, വാക്യഘടന ഉപയോഗിക്കുന്നു ജനകീയ ഭാഷപ്രോഗ്രാമിംഗ് സി

tcsh- ഷെൽ പതിപ്പ് സിസംവേദനാത്മക കമാൻഡ് ലൈൻ എഡിറ്റിംഗിനൊപ്പം.

സിസ്റ്റത്തിൽ നിരവധി വ്യത്യസ്ത ഷെല്ലുകൾ ഇൻസ്റ്റാൾ ചെയ്യാൻ കഴിയും, കൂടാതെ ഓരോ ഉപയോക്താവിനും അവരുടേതായ ഡിഫോൾട്ട് ഷെൽ ഉപയോഗിക്കാം. ഡൗൺലോഡ് ചെയ്യുമ്പോഴും ഉപയോക്തൃ രജിസ്ട്രേഷൻ പ്രക്രിയയിലും ഇതെല്ലാം സ്വയമേവ ചെയ്യപ്പെടും.

    ലിനക്സ് കുടുംബത്തിന്റെ ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളുടെ ലോഡിംഗ് പ്രക്രിയയിൽ, സിസ്റ്റം കേർണൽ ലോഡ് ചെയ്ത ശേഷം, സിസ്റ്റം ഇന്ററാക്ടീവ് മോഡിലേക്ക് മാറുന്നു - ഉപയോക്താവും ഓപ്പറേറ്റിംഗ് സിസ്റ്റവും തമ്മിലുള്ള ആശയവിനിമയ രീതി. Linux-ൽ, ബൂട്ട് സമയത്ത് ആരംഭിക്കുന്ന ആദ്യത്തെ പ്രക്രിയ init പ്രോഗ്രാമാണ്. init, കോൺഫിഗറേഷൻ ഫയലിന്റെ ഉള്ളടക്കം വായിക്കുന്നു /etc/inittab, സിസ്റ്റത്തിൽ ലഭ്യമായ ടെർമിനലുകളുടെ ലിസ്റ്റും സവിശേഷതകളും നിർണ്ണയിക്കുന്നു, കൂടാതെ ഇന്ററാക്ടീവ് ലോഗിൻ പ്രോഗ്രാമിനെ വിളിക്കുന്നു ഗെറ്റി, ഇത് നിങ്ങളുടെ ഉപയോക്തൃനാമം നൽകാൻ നിങ്ങളെ പ്രേരിപ്പിക്കുന്നു. ഉപയോക്തൃനാമവും പാസ്വേഡും നൽകിയ ശേഷം, പ്രോഗ്രാം ഗെറ്റിപ്രോഗ്രാം വിളിക്കുന്നു ലോഗിൻ, ഇത് സാധുത പരിശോധിക്കുന്നു അക്കൗണ്ട്, ഉപയോക്താവിന്റെ ഹോം ഡയറക്ടറിയിലേക്ക് നാവിഗേറ്റ് ചെയ്യുകയും പ്രോഗ്രാമിലേക്ക് നിയന്ത്രണം കൈമാറുകയും ചെയ്യുന്നു പ്രാരംഭ വിക്ഷേപണംസെഷൻ, ഇത് സാധാരണയായി ഒരു ഉപയോക്തൃ ഷെൽ പ്രോഗ്രാമാണ്, അതിന്റെ നിർദ്ദിഷ്ട തരം ഫയലിന്റെ ഉള്ളടക്കത്താൽ നിർണ്ണയിക്കപ്പെടുന്നു /etc/passwdഈ അക്കൗണ്ടിനായി. ഉദാഹരണത്തിന്:

user1:x:508:511::/home/user1:/bin/sh
interbase:x:510:511::/home/interbase:/bin/csh
apb:x:511:513:apb:/home/apb:/bin/bash

ഫയലിന്റെ ഉള്ളടക്കത്തിൽ നിന്ന് കാണാൻ കഴിയുന്നത് പോലെ /etc/passwd, ഉപയോക്താവിന് ഉപയോക്താവ്1ഷെൽ വിക്ഷേപിക്കും sh(ബോൺ ഷെൽ), ഉപയോക്താവിനായി ഇന്റർബേസ്- ഷെൽ csh(സി ഷെൽ) ഉപയോക്താവിനും apb- ഷെൽ ബാഷ്(ബോൺ എഗെയ്ൻ) ഷെൽ ആരംഭിച്ചതിനുശേഷം, സ്ക്രീനിൽ ഒരു കമാൻഡ് പ്രോംപ്റ്റ് പ്രദർശിപ്പിക്കും (സാധാരണയായി ഒരു ഡോളർ ചിഹ്നത്തിന്റെ രൂപത്തിൽ $ ഒരു സാധാരണ ഉപയോക്തൃ അക്കൗണ്ടിന്റെ പശ്ചാത്തലത്തിലാണ് ജോലി ചെയ്യുന്നതെങ്കിൽ, അല്ലെങ്കിൽ പൗണ്ട് # , ഒരു റൂട്ട് യൂസർ അക്കൗണ്ടിന് കീഴിലാണ് ഷെൽ ഉപയോഗിക്കുന്നതെങ്കിൽ ( റൂട്ട്).

ഷെല്ലിൽ നിന്ന് പുറത്തുകടക്കുമ്പോൾ, സിസ്റ്റം കേർണൽ പ്രോഗ്രാമിലേക്ക് നിയന്ത്രണം നൽകുന്നു init, ഇത് ലോഗിൻ പ്രക്രിയ പുനരാരംഭിക്കുകയും ടെർമിനലിൽ ഒരു ഉപയോക്തൃനാമം പ്രോംപ്റ്റ് പ്രദർശിപ്പിക്കുകയും ചെയ്യുന്നു. ഷെല്ലിൽ നിന്ന് പുറത്തുകടക്കുന്നത് രണ്ട് വഴികളിൽ ഒന്നിൽ ചെയ്യാം:

ടീമിലൂടെ പുറത്ത്ഉപയോക്താവ് നിർവഹിച്ചു

ഒരു ഷെൽ പ്രോസസ്സിന് ഒരു സിഗ്നൽ ലഭിക്കുമ്പോൾ കൊല്ലുക, കേർണൽ അയച്ചത്, ഉദാഹരണത്തിന് സിസ്റ്റം റീബൂട്ട് ചെയ്യുമ്പോൾ.

കമാൻഡ് ലൈൻ വ്യാഖ്യാനം.

    ഒരു ഷെൽ പ്രോംപ്റ്റിനുള്ള പ്രതികരണമായി ഉപയോക്തൃ ഇൻപുട്ട് സാധാരണയായി വിളിക്കപ്പെടുന്നു കമാൻഡ് ലൈൻഅഥവാ ടീം. ഒരു ലിനക്സ് കമാൻഡ് എന്നത് കമാൻഡ് നാമത്തിന്റെയും ആർഗ്യുമെന്റുകളുടെയും ഒരു പ്രതീക സ്ട്രിംഗ് ആണ്, ഇത് സ്‌പെയ്‌സുകളാൽ വേർതിരിച്ചിരിക്കുന്നു. ആർഗ്യുമെന്റുകൾ കമാൻഡിന് അതിന്റെ സ്വഭാവം നിർണ്ണയിക്കുന്ന അധിക പാരാമീറ്ററുകൾ നൽകുന്നു. മിക്കപ്പോഴും വാദങ്ങളായി ഉപയോഗിക്കുന്നു ഓപ്ഷനുകൾഒപ്പം പേരുകൾഫയലുകളും ഡയറക്ടറികളും. ഉദാഹരണത്തിന്, കമാൻഡ് ലൈൻ

ls -l ഫയൽ01 ഫയൽ02

ls കമാൻഡ്, -l ഓപ്ഷൻ, file01 file02 എന്ന രണ്ട് ഫയൽനാമങ്ങൾ എന്നിവ അടങ്ങിയിരിക്കുന്നു.

നിരവധി ഓപ്ഷനുകൾ ഉപയോഗിക്കുമ്പോൾ, അവ കൂട്ടിച്ചേർക്കാവുന്നതാണ്. ഉദാഹരണത്തിന്, ഇനിപ്പറയുന്ന കമാൻഡ് ഓപ്ഷനുകൾ സമാനമാണ്:

Ls -l -d
ls -ld

ഷെല്ലിന്റെ ഭാഗമായ കമാൻഡുകൾ വിളിക്കുന്നു അന്തർനിർമ്മിത. അത്തരം കമാൻഡുകളിൽ, ഉദാഹരണത്തിന്, cd, if, കേസ് മുതലായവ ഉൾപ്പെടുന്നു. സ്വാഭാവികമായും, ബിൽറ്റ്-ഇൻ കമാൻഡുകൾ വ്യത്യസ്തമായേക്കാം വിവിധ ഓപ്ഷനുകൾഷെല്ലുകൾ. ബിൽറ്റ്-ഇൻ കമാൻഡുകൾക്ക് പുറമേ, പ്രത്യേക എക്സിക്യൂട്ടബിൾ ഫയലുകളോ ഫയലുകളോ ആയ പ്രോഗ്രാം മൊഡ്യൂളുകൾ ഉപയോഗിക്കാൻ കഴിയും. സ്ക്രിപ്റ്റുകൾഅഥവാ രംഗങ്ങൾ- ഷെൽ കമാൻഡുകൾ ഉപയോഗിച്ച് തുടർച്ചയായി എക്സിക്യൂട്ട് ചെയ്ത വരികൾ അടങ്ങുന്ന സാധാരണ ടെക്സ്റ്റ് ഫയലുകൾ. ചില സ്ക്രിപ്റ്റുകൾ (സ്ക്രിപ്റ്റുകൾ) എക്സിക്യൂട്ട് ചെയ്യാൻ കഴിയും Linux പ്രക്രിയകൾ, ഒരു ടാസ്ക് ഷെഡ്യൂളർ പോലെ ക്രോൺ. ഒരു ടാസ്‌ക് ഷെഡ്യൂളർ സാധാരണയായി രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്നു ഓട്ടോമാറ്റിക് എക്സിക്യൂഷൻഷെഡ്യൂൾ ചെയ്ത സിസ്റ്റം അഡ്മിനിസ്ട്രേഷൻ ജോലികൾ. ചുമതലകൾ ക്രോൺകമാൻഡുകളോ സ്ക്രിപ്റ്റുകളോ ആണ്, അവ യാന്ത്രികമായി നടപ്പിലാക്കുന്നു, യാതൊരു മനുഷ്യ ഇടപെടലും കൂടാതെ, വ്യത്യസ്ത ഉപയോക്തൃ അക്കൗണ്ടുകളുടെ പശ്ചാത്തലത്തിൽ ഇത് നടപ്പിലാക്കാൻ കഴിയും. ഷെഡ്യൂളർ ടാസ്‌ക്കിൽ ഒരു സ്‌ക്രിപ്റ്റ് എക്‌സിക്യൂട്ട് ചെയ്യുന്നത് ഉൾപ്പെടുന്ന സാഹചര്യത്തിൽ, ഒരു ചൈൽഡ് പ്രോസസായി ലോഞ്ച് ചെയ്യേണ്ട ഒരു ഷെൽ തിരഞ്ഞെടുക്കുന്നതിൽ പ്രശ്‌നം ഉണ്ടാകുന്നു. ക്രോൺഒരു സ്ക്രിപ്റ്റ് ഫയലിൽ നിന്ന് കമാൻഡുകൾ പ്രോസസ്സ് ചെയ്യുന്നതിന് - എല്ലാത്തിനുമുപരി, ഷെൽ ഏതെങ്കിലും ആകാം, കൂടാതെ ഒരു സ്ക്രിപ്റ്റിന്റെ വാക്യഘടനയ്ക്ക്, ഒരു ചട്ടം പോലെ, അത് എഴുതിയിരിക്കുന്ന നിർദ്ദിഷ്ട ഷെല്ലിന്റെ ഉപയോഗം ആവശ്യമാണ്. ഈ പ്രശ്നം ഇല്ലാതാക്കാൻ, Linux ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളിൽ, സ്ക്രിപ്റ്റിന്റെ ആദ്യ വരിയിൽ അതിന്റെ നിർവ്വഹണത്തിന് ആവശ്യമായ ഷെല്ലിന്റെ തരം, രൂപത്തിൽ സൂചിപ്പിക്കുന്നത് പതിവാണ്:

#!/bin/bash- ഷെല്ലിന് ബാഷ്

#!/bin/sh- ഷെല്ലിന് sh

അടയാളം # എന്നത് ഒരു അഭിപ്രായത്തിന്റെ അടയാളമാണ്, അതിനെ പിന്തുടരുന്ന പ്രതീകങ്ങൾ ഒരു കമാൻഡായി വ്യാഖ്യാനിക്കപ്പെടുന്നില്ല. തുടർന്നുള്ള ഫയൽ ഉള്ളടക്കങ്ങൾ പ്രോസസ്സ് ചെയ്യുന്നതിന് ഏത് ഷെല്ലാണ് ഉപയോഗിക്കേണ്ടതെന്ന് വ്യക്തമായി വ്യക്തമാക്കാൻ ഈ സാങ്കേതികത നിങ്ങളെ അനുവദിക്കുന്നു. ആവശ്യമായ ഷെല്ലിനെ വ്യക്തമായി നിർവചിക്കുന്ന ഒരു എൻട്രി സ്ക്രിപ്റ്റിൽ ഇല്ലെങ്കിൽ, അത് എക്സിക്യൂട്ട് ചെയ്യുന്ന സന്ദർഭത്തിൽ അക്കൗണ്ടിൽ നിന്നുള്ള ക്രമീകരണങ്ങൾ ഉപയോഗിക്കും. ഈ സ്ക്രിപ്റ്റ്. ഈ സാഹചര്യത്തിൽ, ഷെല്ലിനായി എഴുതിയ ഒരു സ്ക്രിപ്റ്റ് സാധ്യമാണ്, ഉദാഹരണത്തിന്, tchനിർവ്വഹണത്തിനായി ഷെല്ലിലേക്ക് കൈമാറും ബാഷ്, അത് എക്സിക്യൂട്ട് ചെയ്യുന്നത് അസാധ്യമാക്കും.

കമാൻഡുകൾ അല്ലെങ്കിൽ സ്ക്രിപ്റ്റുകൾ നടപ്പിലാക്കുമ്പോൾ, ഉപയോഗിക്കുക പരിസ്ഥിതി വേരിയബിളുകൾ (ഇംഗ്ലീഷിൽ - പരിസ്ഥിതി, കമാൻഡുകൾ എക്‌സിക്യൂട്ട് ചെയ്യുന്ന സോഫ്റ്റ്‌വെയർ പരിതസ്ഥിതിയെ ചിത്രീകരിക്കുന്ന മൂല്യങ്ങൾ. അത്തരം വേരിയബിളുകൾ അടങ്ങിയിരിക്കാം പൊതുവായ ക്രമീകരണങ്ങൾസിസ്റ്റം, ഗ്രാഫിക്കൽ അല്ലെങ്കിൽ കമാൻഡ് ഷെൽ പാരാമീറ്ററുകൾ, പാതകൾ എക്സിക്യൂട്ടബിൾ ഫയലുകൾഇത്യാദി. എൻവയോൺമെന്റ് വേരിയബിൾ മൂല്യങ്ങൾ സിസ്റ്റം തലത്തിലും (എല്ലാ ഉപയോക്താക്കൾക്കും) സജ്ജീകരിച്ചിരിക്കുന്നു നിർദ്ദിഷ്ട ഉപയോക്താവ്. സിസ്റ്റം തലത്തിൽ പരിസ്ഥിതി വേരിയബിളുകൾ സജ്ജീകരിക്കുന്നതിന്, ഫയലുകളുടെ ഉള്ളടക്കങ്ങൾ ഉപയോഗിക്കുന്നു:

/etc/profile- കമാൻഡ് ഷെല്ലുകൾക്കായി മാത്രം വേരിയബിളുകൾ സജ്ജമാക്കുന്നു. ബോൺ ഷെല്ലിന് അനുയോജ്യമായ ഷെല്ലുകളിൽ ഏത് സ്ക്രിപ്റ്റുകളും പ്രവർത്തിപ്പിക്കാൻ കഴിയും.

/etc/bash.bashrc- സംവേദനാത്മക ഷെല്ലുകൾക്കായി മാത്രം വേരിയബിളുകൾ സജ്ജമാക്കുന്നു. ഇത് ബാഷ് സ്ക്രിപ്റ്റുകളും പ്രവർത്തിപ്പിക്കുന്നു.

/etc/പരിസ്ഥിതി- PAM-env മൊഡ്യൂൾ ഉപയോഗിക്കുന്നു. ഈ ഫയലിൽ ജോഡികളെ മാത്രമേ വ്യക്തമാക്കാൻ കഴിയൂ പേര്=മൂല്യം.

ഈ ഫയലുകളിൽ ഓരോന്നിനും അതിന്റേതായ ആപ്ലിക്കേഷൻ ഉണ്ട്, അതിനാൽ നിങ്ങളുടെ ഉദ്ദേശ്യങ്ങൾക്ക് അനുയോജ്യമായ ഒന്ന് നിങ്ങൾ ശ്രദ്ധാപൂർവ്വം തിരഞ്ഞെടുക്കണം. ഉദാഹരണത്തിന്, നിങ്ങൾക്ക് ഒരു ഇഷ്‌ടാനുസൃത ഡയറക്ടറി ചേർക്കണമെങ്കിൽ ~/ബിൻഒരു വേരിയബിളിലേക്ക് പാതഎല്ലാ ഉപയോക്താക്കൾക്കും, ഇനിപ്പറയുന്ന കോഡ് ഒന്നിൽ സ്ഥാപിക്കുക സിസ്റ്റം ഫയലുകൾപരിസ്ഥിതി ആരംഭിക്കൽ (/etc/profile അല്ലെങ്കിൽ /etc/bash.bashrc):

# ഉപയോക്തൃ ഐഡി 1000-നേക്കാൾ വലുതോ അതിന് തുല്യമോ ആണെങ്കിൽ ഒരു ~/ബിൻ ഡയറക്‌ടറിയും അതുമുണ്ട്.

#PATH വേരിയബിളിലേക്ക് മുമ്പ് ചേർത്തിട്ടില്ല,

# ~/ബിൻ $PATH-ലേക്ക് കയറ്റുമതി ചെയ്യുക.

എങ്കിൽ [[ $UID -ge 1000 && -d $HOME/bin && -z $(echo $PATH | grep -o $HOME/bin)

കയറ്റുമതി PATH=$HOME/ബിൻ:$(PATH)

സാധാരണയായി ഓപ്പറേഷൻ റൂമുകളിൽ ലിനക്സ് സിസ്റ്റങ്ങൾ, സേവന അക്കൗണ്ടുകൾക്ക് 1000-ൽ താഴെയോ 500-ൽ താഴെയോ ഉള്ള ഉപയോക്തൃ ഐഡി ഉപയോഗിക്കുന്നു. ഈ ഉദാഹരണത്തിൽ, പരിസ്ഥിതി വേരിയബിൾ എല്ലാവർക്കുമായി സജ്ജീകരിക്കും പ്രാദേശിക ഉപയോക്താക്കൾ 1000 അല്ലെങ്കിൽ അതിലധികമോ ഐഡിയുള്ള സിസ്റ്റങ്ങൾ.

ഒരു നിർദ്ദിഷ്‌ട ഉപയോക്താവിനായി നിങ്ങൾക്ക് പരിസ്ഥിതി മാറ്റണമെങ്കിൽ, ഉപയോക്താവിന്റെ പരിസ്ഥിതിയിലെ ഉള്ളടക്കങ്ങൾ പരിഷ്‌ക്കരിക്കുക:

- ~/.bash_profile, ~/.bash_loginഇത്യാദി. - ൽ നിന്നുള്ള ഷെൽ ഇനീഷ്യലൈസേഷൻ ഫയലുകൾ ഹോം ഡയറക്ടറിഉപയോക്താവ്.

- ~/.പ്രൊഫൈൽ- ഉപയോക്തൃ പ്രൊഫൈൽ സമാരംഭിക്കൽ ഫയൽ. പരിസ്ഥിതി വേരിയബിളുകൾ നിർവചിക്കാൻ നിരവധി ഷെല്ലുകൾ ഉപയോഗിക്കുന്നു.

~/.pam_environment- PAM-env മൊഡ്യൂൾ ഉപയോഗിക്കുന്ന /etc/environment ഫയലിന്റെ ഒരു ഇഷ്‌ടാനുസൃത അനലോഗ്.

ഉദാഹരണത്തിന്, വേരിയബിൾ വ്യക്തമാക്കിയ എക്സിക്യൂട്ടബിൾ ഫയലുകളുടെ തിരയൽ പാതയിലേക്ക് ഉപയോക്തൃ ഡയറക്ടറി ~/bin ചേർക്കുന്നതിന് പാത, ഉദാഹരണത്തിന്, ഒരു ഫയലിലേക്ക് ~/.പ്രൊഫൈൽവരി ഇടുക:

PATH="$(PATH):/home/user/bin" കയറ്റുമതി ചെയ്യുക

പരിസ്ഥിതി വേരിയബിളുകൾ സജ്ജീകരിക്കുന്നതിന് ഗ്രാഫിക് ആപ്ലിക്കേഷനുകൾ, ഉപയോക്തൃ ഗ്രാഫിക്കൽ എൻവയോൺമെന്റ് കോൺഫിഗറേഷൻ ഫയലുകളുടെ ഉള്ളടക്കങ്ങൾ ഉപയോഗിക്കുന്നു ~/.xinitrc

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

കയറ്റുമതി PATH=~/bin:$PATH

പുതിയ വേരിയബിൾ മൂല്യം പാതനിലവിലെ ഉപയോക്തൃ സെഷൻ അവസാനിക്കുന്നത് വരെ മാത്രമേ നിലനിൽക്കൂ.

ഒരു വേരിയബിളിന്റെ മൂല്യം കാണുന്നതിന്, നിങ്ങൾക്ക് കമാൻഡ് ഉപയോഗിക്കാം എക്കോ $ വേരിയബിൾ, ഉദാഹരണത്തിന്:

പ്രതിധ്വനി $PATH

നിലവിൽ, മുകളിൽ സൂചിപ്പിച്ചതുപോലെ ഏറ്റവും സാധാരണമായ ഷെൽ ആണ് ബാഷ്. ഇത് പ്രാഥമികമായി ഷെൽ മൂലമാണ് ഉണ്ടാകുന്നത് ബാഷ്ആണ് sh- അനുയോജ്യം കമാൻഡ് ഷെൽ, അതിൽ ചേർത്തിരിക്കുന്നു ഉപയോഗപ്രദമായ സവിശേഷതകൾകോൺ ഷെല്ലുകളിൽ നിന്ന് ( ksh) കൂടാതെ സി ഷെൽ ( csh). ഷെൽ ബാഷ്ഷെൽ പ്രോഗ്രാമിംഗ് ഭാഷയിൽ എഴുതിയ മിക്ക സ്ക്രിപ്റ്റുകളും യാതൊരു മാറ്റവും കൂടാതെ പ്രവർത്തിപ്പിക്കാൻ കഴിയും shഒപ്പം കഴിയുന്നത്ര സ്റ്റാൻഡേർഡിനോട് അടുക്കാൻ ശ്രമിക്കുന്നു പോസിക്സ്, ഇത് പ്രോഗ്രാമിംഗിനും ഇന്ററാക്ടീവ് ഉപയോഗത്തിനുമായി നിരവധി മെച്ചപ്പെടുത്തലുകളിലേക്ക് നയിച്ചു. ആധുനിക നടപ്പാക്കലിൽ ബാഷ്ഒരു കമാൻഡ് ലൈൻ എഡിറ്റിംഗ് മോഡ്, അൺലിമിറ്റഡ് കമാൻഡ് ഹിസ്റ്ററി സൈസ്, ടാസ്‌ക് മാനേജ്‌മെന്റ് ടൂളുകൾ, അപരനാമങ്ങൾ ഉപയോഗിക്കാനുള്ള കഴിവ്, ബിൽറ്റ്-ഇൻ കമാൻഡുകളുടെ വിപുലമായ ലിസ്റ്റ്, കമാൻഡ് ഷെൽ ഫംഗ്‌ഷനുകൾ മുതലായവ ഉണ്ട്. പൊതുവെ, ബാഷ്ലിനക്സ് പരിതസ്ഥിതിയിൽ ഏറ്റവും കൂടുതൽ ഉപയോഗിക്കുന്ന സാധാരണ ഉപയോക്താവിന്റെ ആവശ്യങ്ങൾക്ക് ഏറ്റവും അനുയോജ്യമാണ്.

തുടക്കത്തിൽ ബാഷ്കമാൻഡ് ലൈൻ പാരാമീറ്ററുകൾ ഇല്ലാതെ, ഷെൽ ഇന്ററാക്ടീവ് മോഡിൽ ആരംഭിക്കുന്നു, സ്ക്രീനിൽ ഒരു കമാൻഡ് പ്രോംപ്റ്റ് പ്രദർശിപ്പിക്കുന്നു. ഒരു സംവേദനാത്മക ഷെൽ സാധാരണയായി ഉപയോക്താവിന്റെ ടെർമിനലിൽ നിന്നുള്ള ഡാറ്റ വായിക്കുകയും അതേ ടെർമിനലിലേക്ക് ഡാറ്റ എഴുതുകയും ചെയ്യുന്നു, സാധാരണ ഉപകരണംഇൻപുട്ട് ഉപകരണം കീബോർഡാണ്, സാധാരണ ഔട്ട്പുട്ട് ഉപകരണം ഡിസ്പ്ലേയാണ്. ഉപയോക്താവ് കീബോർഡിൽ കമാൻഡുകൾ നൽകുന്നു, അവയുടെ നിർവ്വഹണത്തിന്റെ ഫലം ഡിസ്പ്ലേയിൽ പ്രദർശിപ്പിക്കും.

കമാൻഡ് ലാംഗ്വേജ് ഷെൽ (ഷെൽ, ഷെൽ എന്ന് വിവർത്തനം ചെയ്യപ്പെടുന്നു) യഥാർത്ഥത്തിൽ വളരെ ഉയർന്ന തലത്തിലുള്ള പ്രോഗ്രാമിംഗ് ഭാഷയാണ്. ഈ ഭാഷയിൽ, ഉപയോക്താവ് കമ്പ്യൂട്ടറിനെ നിയന്ത്രിക്കുന്നു. സാധാരണയായി, ലോഗിൻ ചെയ്ത ശേഷം, നിങ്ങൾ കമാൻഡ് ഷെല്ലുമായി സംവദിക്കാൻ തുടങ്ങുന്നു. കമാൻഡുകൾ സ്വീകരിക്കാൻ ഷെൽ തയ്യാറാണ് എന്നതിന്റെ സൂചനയാണ് സ്ക്രീനിൽ അത് പ്രദർശിപ്പിക്കുന്ന പ്രോംപ്റ്റർ. ഏറ്റവും ലളിതമായ സാഹചര്യത്തിൽ ഇത് ഒരു ഡോളറാണ് ("$"). ഷെൽ ആവശ്യമില്ല, ഒരേയൊരു കമാൻഡ് ഭാഷയാണ് (മൊബൈൽ സിസ്റ്റം സ്റ്റാൻഡേർഡായ POSIX-ന്റെ ചട്ടക്കൂടിനുള്ളിൽ ഇത് സ്റ്റാൻഡേർഡ് ചെയ്തിട്ടുള്ള ഒന്നാണെങ്കിലും). ഉദാഹരണത്തിന്, cshell ഭാഷ വളരെ ജനപ്രിയമാണ്; kshell, bashell എന്നിവയും ഉണ്ട്. മാത്രമല്ല, ഓരോ ഉപയോക്താവിനും സ്വന്തമായി സൃഷ്ടിക്കാൻ കഴിയും കമാൻഡ് ഭാഷ. ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിന്റെ ഒരു സന്ദർഭത്തിൽ വ്യത്യസ്ത കമാൻഡ് ഭാഷകളിൽ ഒരേസമയം പ്രവർത്തിക്കാൻ കഴിയും. ഷെൽ നിരവധി UNIX കമാൻഡുകളിൽ ഒന്നാണ്. അതായത്, "ഷെൽ" കമാൻഡ് സെറ്റിൽ "sh" കമാൻഡ് ഉൾപ്പെടുന്നു - "ഷെൽ" വ്യാഖ്യാതാവിനെ വിളിക്കുന്നു. നിങ്ങൾ ലോഗിൻ ചെയ്ത് ഒരു പ്രോഗ്രാമർ പ്രദർശിപ്പിക്കുമ്പോൾ ആദ്യത്തെ "ഷെൽ" സ്വയമേവ വിളിക്കപ്പെടും. ഇതിനുശേഷം, "ഷെൽ" ഉൾപ്പെടെ, നിർവ്വഹണത്തിനായി നിങ്ങൾക്ക് ഏതെങ്കിലും കമാൻഡുകൾ വിളിക്കാം, അത് പഴയതിനുള്ളിൽ നിങ്ങൾക്കായി ഒരു പുതിയ ഷെൽ സൃഷ്ടിക്കും. ഉദാഹരണത്തിന്, നിങ്ങൾ എഡിറ്ററിൽ "file_1" ഫയൽ തയ്യാറാക്കുകയാണെങ്കിൽ:

എക്കോ ഹലോ!

അപ്പോൾ അത് സാധാരണമായിരിക്കും ടെക്സ്റ്റ് ഫയൽ, "എക്കോ" കമാൻഡ് അടങ്ങിയിരിക്കുന്നു, അത് എക്സിക്യൂട്ട് ചെയ്യുമ്പോൾ, സ്ക്രീനിൽ വലതുവശത്ത് എഴുതിയതെല്ലാം പ്രദർശിപ്പിക്കുന്നു. "chmod 755 file_1" എന്ന കമാൻഡ് ഉപയോഗിച്ച് നിങ്ങൾക്ക് "file_1" ഫയൽ എക്സിക്യൂട്ടബിൾ ആക്കാം. എന്നാൽ "sh" ("shell") കമാൻഡ് വ്യക്തമായി വിളിച്ചുകൊണ്ട് ഇത് ചെയ്യാൻ കഴിയും:

Sh ഫയൽ_1

ശ്രീ< file1

നിലവിലെ ഷെൽ ഇൻസ്റ്റൻസിലും ഫയൽ എക്സിക്യൂട്ട് ചെയ്യാവുന്നതാണ്. ഇതിന് ഒരു പ്രത്യേക കമാൻഡ് ഉണ്ട് "." (ഡോട്ട്), അതായത്.

ഫയൽ_1

UNIX ഒരു മൾട്ടി-യൂസർ സിസ്റ്റമായതിനാൽ, നിങ്ങൾക്ക് പോലും കഴിയും പെഴ്സണൽ കമ്പ്യൂട്ടർ 12 സ്‌ക്രീനുകളിൽ സമാന്തരമായി പ്രവർത്തിക്കുക (സ്‌ക്രീനിൽ നിന്ന് സ്‌ക്രീനിൽ നിന്ന് സ്‌ക്രീൻ ALT/ഫംഗ്‌ഷൻ കീയിലേക്ക് മാറുക), ഓരോ സ്‌ക്രീനിലും സ്വന്തം കമാൻഡ് ഷെല്ലുള്ള ഒരു പുതിയ (അല്ലെങ്കിൽ അതേ) ഉപയോക്താവ് ഉണ്ടായിരിക്കും. നിങ്ങൾക്ക് ഗ്രാഫിക്കൽ മോഡിൽ എക്സ്-വിൻഡോ തുറക്കാനും കഴിയും വലിയ സംഖ്യജാലകങ്ങൾ, കൂടാതെ ഓരോ ജാലകത്തിനും അതിന്റേതായ കമാൻഡ് ഷെൽ ഉപയോഗിച്ച് സ്വന്തം ഉപയോക്താവ് ഉണ്ടായിരിക്കാം... ഷെൽ ഭാഷയുടെ പ്രധാന ഘടകം കമാൻഡ് ആണ്.

കമാൻഡ് ഘടനകൾ:

ഷെല്ലിലെ കമാൻഡുകൾക്ക് സാധാരണയായി ഇനിപ്പറയുന്ന ഫോർമാറ്റ് ഉണ്ടായിരിക്കും:

<имя команды> <флаги> <аргумент(ы)>

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

Ls -ls /usr/bin

ഇവിടെ ls എന്നത് ഇഷ്യു ചെയ്യുന്ന കമാൻഡിന്റെ പേരാണ് ഉള്ളടക്ക ഡയറക്ടറി, -ls - ഫ്ലാഗുകൾ ("-" - ഫ്ലാഗുകളുടെ അടയാളം, l - ലോംഗ് ഫോർമാറ്റ്, s - ബ്ലോക്കുകളിലെ ഫയലുകളുടെ വോളിയം), /usr/bin - കമാൻഡ് എക്സിക്യൂട്ട് ചെയ്യുന്ന ഡയറക്ടറി. ഈ കമാൻഡ് ഡയറക്ടറിയുടെ ഉള്ളടക്കങ്ങൾ പ്രദർശിപ്പിക്കും. ദൈർഘ്യമേറിയ ഫോർമാറ്റിൽ /usr/bin, ബ്ലോക്കുകളിൽ ഓരോ ഫയലിന്റെയും വലുപ്പത്തെക്കുറിച്ചുള്ള വിവരങ്ങൾ ചേർക്കും. നിർഭാഗ്യവശാൽ, ഈ കമാൻഡ് ഘടന എല്ലായ്പ്പോഴും പിന്തുടരില്ല. ഫ്ലാഗുകൾക്ക് എല്ലായ്പ്പോഴും ഒരു മൈനസ് ഉണ്ടായിരിക്കില്ല, ഫ്ലാഗുകൾ എല്ലായ്പ്പോഴും ഒരു വാക്ക് ആയിരിക്കില്ല. ആർഗ്യുമെന്റുകളുടെ അവതരണത്തിലും വൈവിദ്ധ്യമുണ്ട്, വിദേശ ഫോർമാറ്റുകളുള്ള കമാൻഡുകളിൽ cc - C ലാംഗ്വേജ് കംപൈലറിലേക്ക് വിളിക്കൽ, ടാർ - ആർക്കൈവുകളിൽ പ്രവർത്തിക്കുക, dd - പരിവർത്തനത്തോടുകൂടിയ ഒരു ഫയൽ പകർത്തുക, ഫയലുകൾക്കായി തിരയുക തുടങ്ങിയവ പോലുള്ള "റണ്ണിംഗ്" കമാൻഡുകൾ ഉൾപ്പെടുന്നു. ചട്ടം പോലെ, ആദ്യ വാക്ക് ഷെൽ ഒരു ടീമായി അംഗീകരിക്കുന്നു, അതിനാൽ, ഇൻ കമാൻഡ് ലൈൻ

ആദ്യ വാക്ക് ഷെൽ ഒരു കമാൻഡ് (കോൺകാറ്റനേഷൻ) ആയി ഡീക്രിപ്റ്റ് ചെയ്യും, അത് നിലവിലെ ഡയറക്ടറിയിൽ സ്ഥിതി ചെയ്യുന്ന "കാറ്റ്" (രണ്ടാമത്തെ വാക്ക്) എന്ന ഫയൽ പ്രദർശിപ്പിക്കും. കമാൻഡ് റീഡയറക്ഷൻ സ്റ്റാൻഡേർഡ് ഇൻപുട്ട് (ഇൻപുട്ട്) - UNIX OS-ലെ "stdin" ടെർമിനൽ കീബോർഡിൽ നിന്നാണ് നടപ്പിലാക്കുന്നത്, കൂടാതെ സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ട്(ഔട്ട്പുട്ട്) - "stdout" ടെർമിനൽ സ്ക്രീനിലേക്ക് നയിക്കപ്പെടുന്നു. അവിടെയും ഉണ്ട് സാധാരണ ഫയൽഡയഗ്നോസ്റ്റിക് സന്ദേശങ്ങൾ - "stderr", അത് കുറച്ച് കഴിഞ്ഞ് ചർച്ച ചെയ്യും. സ്റ്റാൻഡേർഡ് ഇൻപുട്ടിലും ഔട്ട്പുട്ടിലും പ്രവർത്തിക്കാൻ കഴിയുന്ന ഒരു കമാൻഡിനെ FILTER എന്ന് വിളിക്കുന്നു. മറ്റ് ഫയലുകളിലേക്ക് (ഉപകരണങ്ങൾ) ഇൻപുട്ടും ഔട്ട്‌പുട്ടും റീഡയറക്‌ടുചെയ്യുന്നതിന് ഉപയോക്താവിന് സൗകര്യപ്രദമായ മാർഗങ്ങളുണ്ട്. ">", ">>" ചിഹ്നങ്ങൾ ഔട്ട്പുട്ട് റീഡയറക്‌ഷനെ സൂചിപ്പിക്കുന്നു. ls >file_1 "ls" കമാൻഡ് നിലവിലെ ഡയറക്‌ടറിയിൽ ഫയലുകളുടെ ഒരു ലിസ്റ്റ് സൃഷ്‌ടിക്കുകയും അത് "file_1" ഫയലിൽ സ്ഥാപിക്കുകയും ചെയ്യും (അത് സ്‌ക്രീനിൽ പ്രിന്റ് ചെയ്യുന്നതിന് പകരം). "file_1" ഫയൽ മുമ്പ് നിലവിലുണ്ടെങ്കിൽ, അത് പുതിയത് തിരുത്തിയെഴുതും.

Pwd >>file_1

pwd കമാൻഡ് നിലവിലെ ഡയറക്‌ടറിയുടെ മുഴുവൻ പേര് രൂപപ്പെടുത്തുകയും "file_1" ഫയലിന്റെ അവസാനം സ്ഥാപിക്കുകയും ചെയ്യും, അതായത്. ">>" ഫയൽ ശൂന്യമല്ലെങ്കിൽ അതിലേക്ക് കൂട്ടിച്ചേർക്കുന്നു. ചിഹ്നങ്ങൾ "<" и "<<" обозначают перенаправление ввода.

Wc -l

ഫയൽ_1 ഫയലിലെ വരികളുടെ എണ്ണം എണ്ണി പ്രദർശിപ്പിക്കും.

Ed ഫയൽ_2<

ടെർമിനലിൽ നിന്ന് നേരിട്ട് എഡിറ്റർ ഉപയോഗിച്ച് "file_2" ഫയൽ സൃഷ്ടിക്കും. ഇൻപുട്ടിന്റെ അവസാനം നിർണ്ണയിക്കുന്നത് വലതുവശത്തുള്ള പ്രതീകമാണ് "<<" (т. е. "!"). То есть ввод будет закончен, когда первым в очередной строке будет "!". Можно сочетать перенаправления. Так

Wc -l ഫയൽ_4

Wc -l >file_4

അതേ രീതിയിൽ നടപ്പിലാക്കുന്നു: "file_3" ഫയലിലെ വരികളുടെ എണ്ണം കണക്കാക്കുകയും ഫലം "file_4" ഫയലിൽ സ്ഥാപിക്കുകയും ചെയ്യുന്നു. ഒരു കമാൻഡിന്റെ സ്റ്റാൻഡേർഡ് ഔട്ട്‌പുട്ടും മറ്റൊന്നിന്റെ സ്റ്റാൻഡേർഡ് ഇൻപുട്ടും സംയോജിപ്പിക്കുന്ന മാർഗങ്ങളെ പൈപ്പ്ലൈൻ എന്ന് വിളിക്കുന്നു, ഇത് ഒരു ലംബ ബാർ "|" സൂചിപ്പിക്കുന്നു.

ls | wc -l

നിലവിലെ ഡയറക്‌ടറിയിലെ ഫയലുകളുടെ ഒരു ലിസ്റ്റ് "wc" കമാൻഡിന്റെ ഇൻപുട്ടിലേക്ക് അയയ്‌ക്കും, അത് ഡയറക്‌ടറിയിലെ ലൈനുകളുടെ എണ്ണം പ്രദർശിപ്പിക്കും. പൈപ്പ്ലൈനിന് രണ്ടിൽ കൂടുതൽ കമാൻഡുകൾ സംയോജിപ്പിക്കാൻ കഴിയും, അവയെല്ലാം, ഒരുപക്ഷേ ആദ്യത്തേതും അവസാനത്തേതും ഒഴികെ, ഫിൽട്ടറുകളാകുമ്പോൾ:

പൂച്ച ഫയൽ_1 | grep -h ഫലം | അടുക്കുക | cat -b > file_2

"file_1" ("cat") ഫയലിൽ നിന്നുള്ള ഈ പൈപ്പ്ലൈൻ "ഫലം" ("grep") എന്ന വാക്ക് അടങ്ങുന്ന എല്ലാ വരികളും തിരഞ്ഞെടുക്കും, തത്ഫലമായുണ്ടാകുന്ന വരികൾ അടുക്കുക ("ക്രമീകരിക്കുക"), തുടർന്ന് നമ്പർ ("cat -b") കൂടാതെ "file_2" ഫയലിൽ ഫലം പ്രിന്റ് ചെയ്യുക. UNIX ഉപകരണങ്ങളെ പ്രത്യേക ഫയലുകൾ പ്രതിനിധീകരിക്കുന്നതിനാൽ, അവ റീഡയറക്‌ടുകളിൽ ഉപയോഗിക്കാനാകും. പ്രത്യേക ഫയലുകൾ "/dev" ഡയറക്‌ടറിയിൽ സ്ഥിതിചെയ്യുന്നു. ഉദാഹരണത്തിന്, "lp" - പ്രിന്റ്; "കൺസോൾ" - കൺസോൾ; "ttyi" - i-th ടെർമിനൽ; "null" എന്നത് ഒരു ഡമ്മി (ശൂന്യമായ) ഫയലാണ് (ഉപകരണം). അപ്പോൾ, ഉദാഹരണത്തിന്,

Ls > /dev/lp

നിലവിലെ ഡയറക്‌ടറിയുടെ ഉള്ളടക്കം പ്രിന്റ് ചെയ്യും, ഫയൽ_1< /dev/null обнулит файл "file_1".

ഫയൽ_1 | ടീ /dev/lp | വാൽ -20

ഈ സാഹചര്യത്തിൽ, "file_1" ഫയൽ അടുക്കുകയും പ്രിന്റ് ചെയ്യുകയും ചെയ്യും, കൂടാതെ അവസാന 20 വരികളും സ്ക്രീനിൽ പ്രിന്റ് ചെയ്യപ്പെടും. ഔട്ട്‌പുട്ട് റീഡയറക്‌ഷനിലേക്ക് മടങ്ങാം. സ്റ്റാൻഡേർഡ് ഫയലുകൾ അക്കമിട്ടിരിക്കുന്നു:

0 - stdin, 1 - stdout 2 - stderr. നിങ്ങൾക്ക് സ്ക്രീനിൽ ഒരു പിശക് സന്ദേശം ആവശ്യമില്ലെങ്കിൽ, നിങ്ങൾക്ക് അത് സ്ക്രീനിൽ നിന്ന് നിങ്ങൾ വ്യക്തമാക്കിയ ഫയലിലേക്ക് റീഡയറക്‌ട് ചെയ്യാം (അല്ലെങ്കിൽ "ശൂന്യമായ ഉപകരണം" ഫയലിലേക്ക് റീഡയറക്‌ട് ചെയ്‌ത് പൂർണ്ണമായും വലിച്ചെറിയുക - /dev/null). ഉദാഹരണത്തിന്, കമാൻഡ് എക്സിക്യൂട്ട് ചെയ്യുമ്പോൾ

പൂച്ച ഫയൽ_1 ഫയൽ_2

"file_1", "file_2" എന്നീ ഫയലുകളുടെ ഉള്ളടക്കങ്ങൾ സ്ക്രീനിൽ തുടർച്ചയായി പ്രദർശിപ്പിക്കണം, അത് നിങ്ങൾക്ക് നൽകും, ഉദാഹരണത്തിന്, ഇനിപ്പറയുന്നവ

111111 222222 cat: f2: അത്തരം ഫയലോ ഡയറക്ടറിയോ ഇല്ല

ഇവിടെ 111111 222222 എന്നത് "file_1" ഫയലിന്റെയും "file_2" എന്ന ഫയലിന്റെയും ഉള്ളടക്കം കാണുന്നില്ല, ഇത് "cat" കമാൻഡ് സ്ഥിരസ്ഥിതിയായി, സ്‌ക്രീൻ പ്രതിനിധീകരിക്കുന്ന സ്റ്റാൻഡേർഡ് ഔട്ട്‌പുട്ട് പോലെ സ്റ്റാൻഡേർഡ് ഡയഗ്നോസ്റ്റിക് ഫയലിലേക്ക് റിപ്പോർട്ട് ചെയ്യുന്നു. നിങ്ങൾക്ക് സ്ക്രീനിൽ അത്തരമൊരു സന്ദേശം ആവശ്യമില്ലെങ്കിൽ, നിങ്ങൾ വ്യക്തമാക്കിയ ഫയലിലേക്ക് അത് റീഡയറക്ട് ചെയ്യാം:

Cat file_1 file_2 2>f-err

പിശക് സന്ദേശങ്ങൾ ("2>" റീഡയറക്ഷൻ സൂചിപ്പിക്കുന്നത് പോലെ) "f-err" ഫയലിലേക്ക് അയയ്ക്കും. വഴിയിൽ, "ff" എന്ന ഒരു ഫയലിലേക്ക് നിങ്ങൾക്ക് എല്ലാ വിവരങ്ങളും അയയ്ക്കാൻ കഴിയും ഈ സാഹചര്യത്തിൽഡിസൈൻ

Cat file_1 file_2 >>ff 2>ff

ഏത് സ്റ്റാൻഡേർഡ് ഫയലാണ് റീഡയറക്ട് ചെയ്യേണ്ടതെന്ന് മാത്രമല്ല, ഏത് സ്റ്റാൻഡേർഡ് ഫയലിലേക്കാണ് റീഡയറക്ട് ചെയ്യേണ്ടതെന്നും നിങ്ങൾക്ക് വ്യക്തമാക്കാൻ കഴിയും.

Cat file_1 file_2 2>>ff 1>&2

ഇവിടെ, ആദ്യം "stderr" എന്നത് "ff" ഫയലിലേക്ക് റീഡയറക്‌ടുചെയ്യുന്നു (അനുബന്ധ മോഡിൽ), തുടർന്ന് സ്റ്റാൻഡേർഡ് ഔട്ട്‌പുട്ട് "stderr" ലേക്ക് റീഡയറക്‌ടുചെയ്യുന്നു, അത് ഈ ഘട്ടത്തിൽ ഫയൽ "ff" ആണ്. അതായത്, ഫലം മുമ്പത്തേതിന് സമാനമായിരിക്കും. "1>&2" എന്ന നിർമ്മാണം അർത്ഥമാക്കുന്നത്, റീഡയറക്‌ട് ചെയ്യേണ്ട സ്റ്റാൻഡേർഡ് ഫയലിന്റെ എണ്ണത്തിന് പുറമേ, നിങ്ങൾ "&" മുമ്പിൽ നൽകണം എന്നാണ്; മുഴുവൻ ഘടനയും ഇടങ്ങളില്ലാതെ എഴുതിയിരിക്കുന്നു.<- закрывает стандартный ввод. >- സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ട് അടയ്ക്കുന്നു. കമാൻഡ് ഫയലുകൾ. ഒരു ടെക്സ്റ്റ് ഫയൽ ഒരു കമാൻഡ് ആയി ഉപയോഗിക്കാൻ അനുവദിക്കുന്നതിന് നിരവധി ഓപ്ഷനുകൾ ഉണ്ട്. ഇതുപോലുള്ള ഒരു ലൈൻ അടങ്ങുന്ന "cmd" എന്ന ഫയൽ സൃഷ്ടിക്കാൻ നമുക്ക് ഒരു എഡിറ്റർ ഉപയോഗിക്കാം:

തീയതി; pwd; ls

നിങ്ങൾക്ക് ഷെല്ലിനെ ഒരു കമാൻഡായി വിളിക്കാം, "sh" എന്ന് സൂചിപ്പിക്കാം, ഒരു "cmd" ഫയൽ ഒരു ആർഗ്യുമെന്റായി അല്ലെങ്കിൽ റീഡയറക്‌ട് ചെയ്‌ത ഇൻപുട്ടായി കൈമാറാം, അതായത്.

$ sh cmd

$sh

ഈ കമാൻഡുകളിലേതെങ്കിലും എക്സിക്യൂട്ട് ചെയ്യുന്നതിന്റെ ഫലം തീയതി, തുടർന്ന് നിലവിലെ ഡയറക്ടറിയുടെ പേര്, തുടർന്ന് ഡയറക്ടറിയുടെ ഉള്ളടക്കം എന്നിവ ആയിരിക്കും. ഒരു ബാച്ച് ഫയലുമായി പ്രവർത്തിക്കുന്നതിനുള്ള കൂടുതൽ രസകരവും സൗകര്യപ്രദവുമായ ഓപ്ഷൻ അത് എക്സിക്യൂട്ടബിൾ ഒന്നാക്കി മാറ്റുക എന്നതാണ്, അതായത്. സുരക്ഷാ കോഡ് മാറ്റുന്നതിലൂടെ ഇത് ഒരു കമാൻഡ് ആക്കുക. ഇത് ചെയ്യുന്നതിന്, നിങ്ങൾ ഈ ഫയലിന്റെ എക്സിക്യൂഷൻ അനുവദിക്കണം. ഉദാഹരണത്തിന്,

Chmod 711 cmd

സുരക്ഷാ കോഡ് "rwx__x__x" ആക്കും. പിന്നെ ഒരു സിമ്പിൾ കോൾ

ഒരേ മൂന്ന് കമാൻഡുകൾ എക്സിക്യൂട്ട് ചെയ്യും. ഉള്ളടക്കമുള്ള ഫയലാണെങ്കിൽ ഫലം സമാനമായിരിക്കും

തീയതി; pwd; ls

ഫോമിൽ പ്രതിനിധീകരിക്കുന്നു: തീയതി pwd ls, കാരണം മറ്റൊരു ലൈനിലേക്കുള്ള പരിവർത്തനവും കമാൻഡുകളുടെ ക്രമത്തിൽ ഒരു സെപ്പറേറ്റർ ആണ്. അങ്ങനെ, എക്സിക്യൂട്ടബിൾ ഫയലുകൾ സമാഹാരത്തിന്റെയും അസംബ്ലിയുടെയും ഫലമായി ലഭിച്ച ഫയലുകൾ മാത്രമല്ല, ഷെൽ ഭാഷയിൽ എഴുതിയ ഫയലുകളും ആകാം. അവ ഒരു ഷെൽ ഇന്റർപ്രെറ്റർ ഉപയോഗിച്ച് വ്യാഖ്യാന മോഡിൽ നടപ്പിലാക്കുന്നു

ബാച്ച് ഫയലുകൾ ഡീബഗ്ഗിംഗ് ചെയ്യുന്നു

ബാച്ച് ഫയലുകൾ ഡീബഗ്ഗ് ചെയ്യുന്നതിനായി SHELL രണ്ട് മെക്കാനിസങ്ങൾ ഉപയോഗിക്കുന്നു. ആദ്യത്തേത്: set -v വരികൾ പ്രിന്റ് ചെയ്യുന്നു ബാച്ച് ഫയൽനിങ്ങൾ അവ വായിക്കുമ്പോൾ. വാക്യഘടന പിശകുകൾക്കായി തിരയുമ്പോൾ ഈ മോഡ് ഉപയോഗിക്കുന്നു. ഇത് ഉപയോഗിക്കുന്നതിന്, നിങ്ങൾ കമാൻഡ് ഫയൽ പരിഷ്ക്കരിക്കേണ്ടതില്ല, ഉദാഹരണത്തിന്: sh -v proc... ഇവിടെ proc എന്നത് കമാൻഡ് ഫയലിന്റെ പേരാണ്. -n സ്വിച്ചിനൊപ്പം -v സ്വിച്ച് ഉപയോഗിക്കാവുന്നതാണ്, ഇത് തുടർന്നുള്ള കമാൻഡുകൾ നടപ്പിലാക്കുന്നത് തടയുന്നു (EOF ഫ്ലാഗ് നൽകുന്നതുവരെ സെറ്റ് -n കമാൻഡ് ടെർമിനലിനെ തടയുന്നു). സെറ്റ് -x കമാൻഡ് കമാൻഡുകൾ എക്സിക്യൂട്ട് ചെയ്യുമ്പോൾ പ്രദർശിപ്പിക്കുന്നു, കൂടാതെ പ്രോഗ്രാം ലൈനുകൾ ടെർമിനലിലേക്ക് ഔട്ട്പുട്ട് ചെയ്യുകയും അവയുടെ മൂല്യങ്ങൾ വേരിയബിളുകൾക്ക് പകരം നൽകുകയും ചെയ്യുന്നു. -x, -v സ്വിച്ചുകൾ റദ്ദാക്കുന്നതിന്, നിങ്ങൾക്ക് സെറ്റ് കമാൻഡ് ഉപയോഗിക്കാം - ഇൻസ്റ്റാൾ ചെയ്യാൻ, ഒരു മാക്രോ വേരിയബിളിലേക്ക് അനുബന്ധ മൂല്യം നൽകുക. ഷെൽ എൻവയോൺമെന്റ് (വേരിയബിളുകളും പാരാമീറ്ററുകളും) ഷെൽ ഭാഷയിൽ, നിങ്ങൾക്ക് ബാച്ച് ഫയലുകൾ എഴുതാനും അവ എക്സിക്യൂട്ടബിൾ ആക്കുന്നതിന് "chmod" കമാൻഡ് ഉപയോഗിക്കാനും കഴിയും. ഇതിനുശേഷം, അവ മറ്റ് UNIX OS കമാൻഡുകളിൽ നിന്ന് വ്യത്യസ്തമല്ല.

ഷെൽ വേരിയബിളുകൾ

ഒരു അക്ഷരത്തിൽ തുടങ്ങുന്ന അക്ഷരങ്ങൾ, അക്കങ്ങൾ, അടിവരകൾ എന്നിവയുടെ ഒരു ശ്രേണിയാണ് ഷെൽ വേരിയബിൾ നാമം. ഒരു ഷെൽ വേരിയബിളിന്റെ മൂല്യം പ്രതീകങ്ങളുടെ ഒരു സ്ട്രിംഗാണ്. ഷെല്ലിൽ രണ്ട് തരം ഡാറ്റ മാത്രമേ ഉള്ളൂ എന്ന വസ്തുത: പ്രതീകങ്ങളുടെ ഒരു സ്ട്രിംഗും ഒരു ടെക്സ്റ്റ് ഫയലും, ഒരു വശത്ത്, ഇതുവരെ പ്രോഗ്രാമിംഗ് ചെയ്തിട്ടില്ലാത്ത അന്തിമ ഉപയോക്താക്കളെ പ്രോഗ്രാമിംഗിൽ ഉൾപ്പെടുത്തുന്നത് എളുപ്പമാക്കുന്നു, മറുവശത്ത്, ഭാഷാപരമായ മാർഗങ്ങളുടെ ഗണ്യമായ വൈവിധ്യവും കൂടുതൽ വഴക്കവും പരിചിതമായ നിരവധി പ്രോഗ്രാമർമാർക്കിടയിൽ ഒരു നിശ്ചിത ആന്തരിക പ്രതിഷേധത്തിന് കാരണമാകുന്നു. എന്നിരുന്നാലും, ഉയർന്ന യോഗ്യതയുള്ള പ്രോഗ്രാമർമാർ, ഷെല്ലിന്റെ “ഗെയിമിന്റെ നിയമങ്ങൾ” പരിചിതമായി, അതിൽ പ്രോഗ്രാമുകൾ സി യേക്കാൾ എത്രയോ മടങ്ങ് വേഗത്തിൽ എഴുതുന്നത് നിരീക്ഷിക്കുന്നത് രസകരമാണ്, പക്ഷേ, പ്രത്യേകിച്ചും രസകരമായത്, ചില സന്ദർഭങ്ങളിൽ ഈ പ്രോഗ്രാമുകൾ സിയിൽ നടപ്പിലാക്കിയതിനേക്കാൾ വേഗത്തിൽ ഓടുക. ഒരു വേരിയബിൾ നാമം ഒരു ഐഡന്റിഫയറിന്റെ പരമ്പരാഗത ആശയത്തിന് സമാനമാണ്, അതായത്. ഒരു പേര് അക്ഷരങ്ങൾ, അക്കങ്ങൾ, അടിവരകൾ എന്നിവയുടെ ഒരു ശ്രേണി ആകാം, ഒരു അക്ഷരത്തിലോ അടിവരയിലോ ആരംഭിക്കുന്നു. അസൈൻമെന്റ് ഓപ്പറേറ്റർ "=" വേരിയബിളുകൾക്ക് മൂല്യങ്ങൾ നൽകുന്നതിന് ഉപയോഗിക്കാം.

Var_1=13 - "13" എന്നത് ഒരു സംഖ്യയല്ല, രണ്ട് അക്കങ്ങളുടെ ഒരു സ്ട്രിംഗാണ്. var_2="UNIX OS" - സ്‌ട്രിംഗിൽ ഒരു സ്‌പെയ്‌സ് ഉള്ളതിനാൽ ഇവിടെ ഇരട്ട ഉദ്ധരണികൾ (" ") ആവശ്യമാണ്.

ഷെൽ വേരിയബിളുകൾക്ക് മൂല്യങ്ങൾ നൽകുന്നതിനുള്ള മറ്റ് വഴികളും സാധ്യമാണ്. ഉദാഹരണത്തിന്, റെക്കോർഡിംഗ്

DAT=`date`

"date" കമാൻഡ് ആദ്യം എക്സിക്യൂട്ട് ചെയ്യാൻ കാരണമാകുന്നു (അടച്ചിരിക്കുന്ന കമാൻഡ് ആദ്യം എക്സിക്യൂട്ട് ചെയ്യണമെന്ന് ബാക്ക്ടിക്കുകൾ സൂചിപ്പിക്കുന്നു), കൂടാതെ അതിന്റെ നിർവ്വഹണത്തിന്റെ ഫലം, സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ടിലേക്ക് ഔട്ട്പുട്ട് ചെയ്യുന്നതിനുപകരം, ഒരു വേരിയബിളിന്റെ മൂല്യമായി നിയോഗിക്കപ്പെടുന്നു. ഈ കേസ് "DAT". ഡയലോഗ് മോഡിലെ (കീബോർഡ്) ഡിസ്പ്ലേയിൽ നിന്ന് വേരിയബിളിന്റെ മൂല്യം ലഭിക്കുന്നുണ്ടെന്ന് ഉറപ്പാക്കുന്ന "വായന" കമാൻഡ് ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഒരു വേരിയബിളിന് ഒരു മൂല്യം നൽകാനും കഴിയും. സാധാരണയായി ബാച്ച് ഫയലിലെ "റീഡ്" കമാൻഡിന് മുമ്പായി "എക്കോ" കമാൻഡ് ഉണ്ടാകും, ഇത് സ്ക്രീനിൽ ചില സന്ദേശം മുൻകൂട്ടി പ്രദർശിപ്പിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു. ഉദാഹരണത്തിന്:

Echo -n "ഒരു മൂന്നക്ക നമ്പർ നൽകുക:" x വായിക്കുക

കമാൻഡ് ഫയലിന്റെ ഈ ഭാഗം എക്സിക്യൂട്ട് ചെയ്യുമ്പോൾ, സന്ദേശം പ്രദർശിപ്പിച്ചതിന് ശേഷം

മൂന്നക്ക നമ്പർ നൽകുക:

വ്യാഖ്യാതാവ് നിർത്തി കീബോർഡിൽ നിന്ന് ഒരു മൂല്യം നൽകുന്നതിനായി കാത്തിരിക്കും. നിങ്ങൾ നൽകിയിട്ടുണ്ടെങ്കിൽ, "753" എന്ന് പറയുക, ഇത് "x" എന്ന വേരിയബിളിന്റെ മൂല്യമായി മാറും. ഒരു "റീഡ്" കമാൻഡിന് ഒരേസമയം നിരവധി വേരിയബിളുകളിലേക്ക് മൂല്യങ്ങൾ വായിക്കാൻ (അസൈൻ ചെയ്യാൻ) കഴിയും. "വായന" എന്നതിൽ നൽകിയതിനേക്കാൾ കൂടുതൽ വേരിയബിളുകൾ ഉണ്ടെങ്കിൽ (സ്‌പെയ്‌സുകളാൽ വേർതിരിച്ചത്), ശേഷിക്കുന്നവയ്ക്ക് ഒരു ശൂന്യമായ സ്ട്രിംഗ് നൽകും. "റീഡ്" കമാൻഡിൽ വേരിയബിളുകളേക്കാൾ കൂടുതൽ ട്രാൻസ്മിറ്റ് ചെയ്ത മൂല്യങ്ങൾ ഉണ്ടെങ്കിൽ, അധികമായവ അവഗണിക്കപ്പെടും. ഒരു ഷെൽ വേരിയബിൾ ആക്സസ് ചെയ്യുമ്പോൾ, നിങ്ങൾ പേരിന് മുമ്പായി "$" ചിഹ്നം നൽകണം. അതിനാൽ $var_2 echo var_2 എന്ന കമാൻഡുകൾ സ്ക്രീനിൽ പ്രദർശിപ്പിക്കും

UNIX OS var_2 എസ്കേപ്പിംഗ്

ഷെല്ലിൽ ഉപയോഗിക്കുന്ന രക്ഷപ്പെടൽ വിദ്യകൾ നമുക്ക് സൂക്ഷ്മമായി പരിശോധിക്കാം. ഇരട്ട ഉദ്ധരണികൾ (" "), ഒറ്റ ഉദ്ധരണികൾ (" "), ബാക്ക്‌സ്ലാഷുകൾ (\) എന്നിവ എസ്‌കേപ്പ് ഉപകരണങ്ങളായി ഉപയോഗിക്കുന്നു. ഉദാഹരണങ്ങളിൽ നിന്ന് അവരുടെ പ്രവർത്തനം വ്യക്തമാണ്: നിങ്ങൾക്ക് ഒരു വരിയിൽ നിരവധി അസൈൻമെന്റുകൾ എഴുതാം.

X=22 y=33 z=$x A="$x" B="$x" C=\$x D="$x + $y + $z" E="$x + $y + $z " F=$x\ +\ $y\ +\ $z

(സ്‌പെയ്‌സുകൾ കാരണം അസൈൻമെന്റ് G=$x+$y പരാജയപ്പെടും) തുടർന്ന്

Echo A = $A B = $B C = $C echo D = $D E = $E F = $F eval echo evaluated A = $A eval echo evaluated B = $B eval echo evaluated C = $C

സ്ക്രീനിൽ പ്രദർശിപ്പിക്കും

A = 22 B = $x C = $x D = 22 + 33 + 22 E = $x + $y + $z F = 22 + 33 + 22 വിലയിരുത്തി A = 22 മൂല്യനിർണ്ണയം ചെയ്ത B = 22 മൂല്യനിർണ്ണയം ചെയ്ത C = 22

എസ്കേപ്പിംഗ് ലൈൻ ഫീഡുകളുമായി ബന്ധപ്പെട്ട ചില ഉദാഹരണങ്ങൾ കൂടി നൽകാം. വേരിയബിളിന് "സ്ട്രിംഗ്" ഒരു 2x3 "അറേ" യുടെ മൂല്യം നൽകട്ടെ: abc def അധിക സ്‌പെയ്‌സുകൾ നൽകുന്നത് ഒഴിവാക്കാൻ, അറേയുടെ രണ്ടാമത്തെ വരി ഇനിപ്പറയുന്ന വരിയുടെ ആദ്യ സ്ഥാനത്ത് നിന്ന് ആരംഭിക്കുന്നു: string="abc def" തുടർന്ന് "echo" echo കമാൻഡിൽ വേരിയബിൾ എഴുതുന്നതിന് മൂന്ന് ഓപ്ഷനുകൾ ഉണ്ട് $string echo "$string" echo "$string" യഥാക്രമം മൂന്ന് വ്യത്യസ്ത ഫലങ്ങൾ നൽകും: abc def $string abc def, കമാൻഡുകളുടെ ക്രമം echo "str_1 str_2" > file_1 echo "str_1 str_2" > file_2 cat file_1 file_2 തുടർച്ചയായി നൽകും സമാന ഫയലുകൾ file_1, file_2: str_1 str_2 str_1 str_2 ബാക്ക്‌സ്ലാഷ് (\) അതിനെ പിന്തുടരുന്ന പ്രതീകത്തിൽ നിന്ന് രക്ഷപ്പെടുക മാത്രമല്ല, അത് ഉപയോഗിക്കാൻ നിങ്ങളെ അനുവദിക്കുകയും ചെയ്യുന്നു. പ്രത്യേക ചിഹ്നങ്ങൾപ്രതീകങ്ങൾ സ്വയം പ്രതിനിധീകരിക്കുന്നതുപോലെ (അതിന് സ്വയം രക്ഷപ്പെടാം - \\), എന്നാൽ ഒരു കമാൻഡ് ഫയലിൽ, ഒരു ബാക്ക്‌സ്ലാഷ് വരികൾ ഒന്നായി സംയോജിപ്പിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു (ഒരു വരിയുടെ അവസാനം രക്ഷപ്പെടുക). ഉദാഹരണത്തിന്, നേരത്തെ നൽകിയ കമാൻഡ് ലൈൻ ഉദാഹരണം:

പൂച്ച ഫയൽ_1 | grep -h ഫലം | അടുക്കുക | cat -b > file_2

ഒരു ബാച്ച് ഫയലിൽ എഴുതാം

പൂച്ച ഫയൽ_1 | grep -h\ ഫലം | അടുക്കുക | cat -b > file_2

വഴിയിൽ, കൺവെയർ ചിഹ്നം കമാൻഡ് ലൈൻ തുടരുന്നതിന്റെ ഫലവും നൽകുന്നു. ഈ സാഹചര്യത്തിൽ, ഇതുപോലുള്ള ഒരു നല്ല ഫലം നൽകാം:

പൂച്ച ഫയൽ_1 | grep -h ഫലം | അടുക്കുക | cat -b > file_2

ഷെൽ വേരിയബിളുകൾ ഉപയോഗിച്ചുള്ള കൃത്രിമങ്ങൾ, ഷെൽ വേരിയബിളുകൾ സാധാരണയായി സ്ട്രിംഗുകളായി കാണപ്പെടുന്നുണ്ടെങ്കിലും, അതായത് “35” എന്നത് ഒരു സംഖ്യയല്ല, മറിച്ച് “3”, “5” എന്നീ രണ്ട് പ്രതീകങ്ങളുടെ ഒരു സ്ട്രിംഗ് ആണ്, പല സന്ദർഭങ്ങളിലും അവയെ വ്യത്യസ്തമായി വ്യാഖ്യാനിക്കാം. ഉദാഹരണത്തിന് പൂർണ്ണസംഖ്യകളായി. "expr" കമാൻഡിന് വൈവിധ്യമാർന്ന കഴിവുകളുണ്ട്. നമുക്ക് ചില ഉദാഹരണങ്ങൾ ഉപയോഗിച്ച് ചിത്രീകരിക്കാം: ഒരു ബാച്ച് ഫയൽ എക്സിക്യൂട്ട് ചെയ്യുന്നു:

X=7 y=2 a=`expr $x + $y` ; പ്രതിധ്വനി a=$a a=`expr $a + 1` ; പ്രതിധ്വനി a=$a b=`expr $y - $x` ; എക്കോ b=$b c=`expr $x "*" $y` ; എക്കോ c=$c d=`expr $x / $y` ; എക്കോ d=$d e=`expr $x % $y` ; പ്രതിധ്വനി e=$e

സ്ക്രീനിൽ പ്രദർശിപ്പിക്കും

A=9 a=10 b=-5 c=14 d=3 e=1

ഗുണന പ്രവർത്തനം ("*") ഒഴിവാക്കണം, കാരണം ഷെല്ലിൽ ഈ ഐക്കൺ ഒരു പ്രത്യേക പ്രതീകമായി കാണപ്പെടുന്നു, അതായത് പ്രതീകങ്ങളുടെ ഏത് ശ്രേണിയും ഈ സ്ഥലത്ത് പകരം വയ്ക്കാൻ കഴിയും. "expr" കമാൻഡ് ഉപയോഗിച്ച്, (പൂർണ്ണസംഖ്യ) ഗണിത പ്രവർത്തനങ്ങൾ മാത്രമല്ല, സ്ട്രിംഗുകളും സാധ്യമാണ്:

A=`expr "cocktail" : "cock"` ; echo $A B=`expr "cocktail" : "tail"` ; echo $B C=`expr "cocktail" : "cook"` ; echo $C D=`expr "cock" : "cocktail"` ; പ്രതിധ്വനി $D

ചെയിനുകളിൽ (ആരംഭം മുതൽ) പൊരുത്തപ്പെടുന്ന പ്രതീകങ്ങളുടെ എണ്ണം കാണിക്കുന്ന നമ്പറുകൾ സ്ക്രീനിൽ പ്രദർശിപ്പിക്കും. രണ്ടാമത്തെ വരി ആദ്യത്തേതിനേക്കാൾ ദൈർഘ്യമേറിയതായിരിക്കരുത്:

4 0 0 0

വേരിയബിളുകൾ കയറ്റുമതി ചെയ്യുന്നത് UNIX OS-ന് ഒരു പ്രക്രിയ എന്ന ആശയമുണ്ട്. ഒരു കമാൻഡ് എക്സിക്യൂട്ട് ചെയ്യുമ്പോൾ ഒരു പ്രക്രിയ സംഭവിക്കുന്നു. ഉദാഹരണത്തിന്, കീബോർഡിൽ "p" എന്ന് ടൈപ്പ് ചെയ്യുമ്പോൾ "p" എന്ന പ്രക്രിയ രൂപം കൊള്ളുന്നു. അതാകട്ടെ, "p" ന് മറ്റ് പ്രക്രിയകൾ സൃഷ്ടിക്കാൻ കഴിയും. "p" "p1", "p2" എന്നിവയെ വിളിക്കുന്നു, അത് അനുബന്ധ പ്രക്രിയകളെ തുടർച്ചയായി സൃഷ്ടിക്കുന്നു. ഓരോ പ്രക്രിയയ്ക്കും അതിന്റേതായ പരിസ്ഥിതിയുണ്ട് - a ഇതിന് ലഭ്യമായ വേരിയബിളുകളുടെ ഒരു കൂട്ടം ഉദാഹരണത്തിന്, "p" സമാരംഭിക്കുന്നതിന് മുമ്പ് ചില വേരിയബിളുകൾ ഇതിനകം തന്നെ നിർവചിക്കപ്പെട്ടിട്ടുള്ള ഒരു പരിതസ്ഥിതി ഉണ്ടായിരുന്നു. വേരിയബിളുകൾ അവ പ്രഖ്യാപിച്ച പ്രക്രിയയിൽ പ്രാദേശികമാണ്, അതായത് അവയ്ക്ക് മൂല്യങ്ങൾ നൽകിയിരിക്കുന്നിടത്ത്. അവ മറ്റ് സ്പോൺഡ് പ്രോസസ്സുകൾക്ക് ലഭ്യമാകുന്നതിന്, അവ വ്യക്തമായി പാസ്സാക്കണം. ഇത് ചെയ്യുന്നതിന്, ബിൽറ്റ്-ഇൻ "കയറ്റുമതി" കമാൻഡ് ഉപയോഗിക്കുക.

ഓപ്ഷനുകൾ

പാരാമീറ്ററുകൾ കമാൻഡ് ഫയലിലേക്ക് കൈമാറാൻ കഴിയും. ഷെൽ പൊസിഷണൽ പാരാമീറ്ററുകൾ ഉപയോഗിക്കുന്നു (അതായത്, അവ ദൃശ്യമാകുന്ന ക്രമം പ്രധാനമാണ്). കമാൻഡ് ഫയലിൽ, പരാമീറ്ററുകളുമായി ബന്ധപ്പെട്ട വേരിയബിളുകൾ (ഷെൽ വേരിയബിളുകൾക്ക് സമാനമായത്) "$" എന്ന ചിഹ്നത്തിൽ ആരംഭിക്കുന്നു, തുടർന്ന് 0 മുതൽ 9 വരെയുള്ള അക്കങ്ങളിൽ ഒന്ന്: "കോക്ക്" എന്ന പാരാമീറ്ററുകൾ ഉപയോഗിച്ച് "examp-1" വിളിക്കാം. കൂടാതെ "വാൽ". ഈ പാരാമീറ്ററുകൾ പുതിയ പരിതസ്ഥിതിയിൽ വീഴുന്നു സ്റ്റാൻഡേർഡ് പേരുകൾ"1" ഉം "2" ഉം. "0" എന്ന് പേരുള്ള (സ്റ്റാൻഡേർഡ്) വേരിയബിൾ വിളിക്കപ്പെടുന്ന കണക്കുകൂട്ടലിന്റെ പേര് സംഭരിക്കും. പാരാമീറ്ററുകൾ ആക്സസ് ചെയ്യുമ്പോൾ, നമ്പറിന് മുമ്പായി ഡോളർ ചിഹ്നം "$" (വേരിയബിളുകൾ ആക്സസ് ചെയ്യുമ്പോൾ): $0 ഈ കമാൻഡ് ഫയലിന്റെ പേരുമായി യോജിക്കുന്നു; $1 ആണ് ക്രമത്തിലുള്ള ആദ്യ പരാമീറ്റർ; $2 സെക്കൻഡ് പാരാമീറ്റർ മുതലായവ. പാരാമീറ്ററുകൾ കൈമാറാൻ കഴിയുന്ന വേരിയബിളുകളുടെ എണ്ണം ഒരു അക്കത്തിൽ പരിമിതപ്പെടുത്തിയിരിക്കുന്നതിനാൽ, അതായത്. 9-ാമത്തേത് ("0", ഇതിനകം സൂചിപ്പിച്ചതുപോലെ, ഒരു പ്രത്യേക അർത്ഥമുണ്ട്), തുടർന്ന് പ്രക്ഷേപണത്തിന് കൂടുതൽപരാമീറ്ററുകൾ, "shift" എന്ന പ്രത്യേക കമാൻഡ് ഉപയോഗിക്കുന്നു. "set" കമാൻഡ് പരാമീറ്ററുകൾക്ക് ഒരു അദ്വിതീയ സമീപനം നൽകുന്നു. ഉദാഹരണത്തിന്, ശകലം

എക്കോ ഫസ്റ്റ്=$1 സെക്കൻഡ്=$2 മൂന്നാമത്=$3 ഉപയോഗിച്ച് ഒരു ബി സജ്ജീകരിക്കുക

സ്ക്രീനിൽ പ്രദർശിപ്പിക്കും

ആദ്യം=ഒരു സെക്കന്റ്=ബി മൂന്നാമത്=സി

ആ. "set" കമാൻഡ് പാരാമീറ്റർ മൂല്യങ്ങൾ സജ്ജമാക്കുന്നു. ഇത് വളരെ സൗകര്യപ്രദമായിരിക്കും. ഉദാഹരണത്തിന്, "date" കമാൻഡ് പ്രദർശിപ്പിക്കുന്നു നിലവിലെ തീയതി, അഞ്ച് വാക്കുകൾ അടങ്ങുന്ന "Mon May 01 12:15:10 2000" എന്ന് പറയുക, തുടർന്ന്

`തീയതി` എക്കോ $1 $3 $5 സജ്ജമാക്കുക

സ്ക്രീനിൽ പ്രദർശിപ്പിക്കും

തിങ്കൾ 01 2000

പ്രോഗ്രാമിന്റെ എക്സിക്യൂഷൻ നിയന്ത്രിക്കാനും "set" കമാൻഡ് നിങ്ങളെ അനുവദിക്കുന്നു, ഉദാഹരണത്തിന്: സെറ്റ് -v ലൈനുകൾ ടെർമിനലിലേക്ക് ഔട്ട്പുട്ട് ചെയ്യുന്നു, ഷെൽ വായിക്കുന്നു. സെറ്റ് +v മുമ്പത്തെ മോഡ് റദ്ദാക്കുന്നു. എക്സിക്യൂഷന് മുമ്പ് ടെർമിനലിലേക്ക് -x പ്രിന്റ് കമാൻഡുകൾ സജ്ജമാക്കുക. സെറ്റ് +x മുമ്പത്തെ മോഡ് റദ്ദാക്കുന്നു. പാരാമീറ്ററുകളില്ലാത്ത "സെറ്റ്" കമാൻഡ് ടെർമിനലിലേക്ക് സോഫ്റ്റ്വെയർ പരിതസ്ഥിതിയുടെ അവസ്ഥ പ്രദർശിപ്പിക്കുന്നു.

ഷെൽ മാറ്റിസ്ഥാപിക്കൽ

ബാച്ച് ഫയലുകളിൽ അടങ്ങിയിരിക്കുന്ന കമാൻഡുകൾ നേരിട്ട് വ്യാഖ്യാനിച്ച് നടപ്പിലാക്കുന്നതിന് മുമ്പ്, ഷെൽ എക്സിക്യൂട്ട് ചെയ്യുന്നു പല തരംസബ്സ്റ്റിറ്റ്യൂഷനുകൾ: 1. ഫലങ്ങളുടെ പകരം വയ്ക്കൽ. ബാക്ക്‌ക്വോട്ടുകളിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്ന എല്ലാ കമാൻഡുകളും എക്‌സിക്യൂട്ട് ചെയ്യുകയും ഫലം അവയുടെ സ്ഥാനത്ത് പകരം വയ്ക്കുകയും ചെയ്യുന്നു. 2. പാരാമീറ്ററുകളുടെയും വേരിയബിളുകളുടെയും മൂല്യങ്ങൾ മാറ്റിസ്ഥാപിക്കൽ. അതായത്, "$" ൽ ആരംഭിക്കുന്ന വാക്കുകൾ വേരിയബിളുകളുടെയും പാരാമീറ്ററുകളുടെയും അനുബന്ധ മൂല്യങ്ങൾ ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുന്നു. 3. വിടവുകൾ വ്യാഖ്യാനിക്കുന്നു. രക്ഷപ്പെട്ട ഇടങ്ങൾ അവഗണിക്കപ്പെടുന്നു. 4. ഫയൽ നാമങ്ങളുടെ ജനറേഷൻ. പ്രത്യേക പ്രതീകങ്ങളുടെ ("*", "?","") സാന്നിധ്യത്തിനായി വാക്കുകൾ പരിശോധിക്കുകയും അനുബന്ധ തലമുറകൾ അവതരിപ്പിക്കുകയും ചെയ്യുന്നു. സോഫ്‌റ്റ്‌വെയർ എൻവയോൺമെന്റ് ഓരോ പ്രക്രിയയ്ക്കും അത് പ്രവർത്തിക്കുന്ന ഒരു പരിതസ്ഥിതിയുണ്ട്. ഷെൽ ഈ എൻവയോൺമെന്റ് വേരിയബിളുകൾ ഉപയോഗിക്കുന്നു. നിങ്ങൾ "സെറ്റ്" കമാൻഡ് പാരാമീറ്ററുകൾ ഇല്ലാതെ ടൈപ്പുചെയ്യുകയാണെങ്കിൽ, സ്‌ക്രീൻ ലോഗിൻ ചെയ്യുമ്പോൾ സൃഷ്‌ടിച്ച നിരവധി സ്റ്റാൻഡേർഡ് വേരിയബിളുകളെക്കുറിച്ചുള്ള വിവരങ്ങൾ പ്രദർശിപ്പിക്കും (പിന്നീട് നിങ്ങളുടെ എല്ലാ പുതിയ പ്രോസസുകളിലേക്കും "ഹെറിറ്റഡ്" കൈമാറുന്നു), അതുപോലെ തന്നെ നിങ്ങളുടെ പ്രോസസ്സുകൾ സൃഷ്‌ടിക്കുകയും കയറ്റുമതി ചെയ്യുകയും ചെയ്യുന്ന വേരിയബിളുകൾ. . വിവര ഔട്ട്പുട്ടിന്റെ നിർദ്ദിഷ്ട തരവും ഉള്ളടക്കവും UNIX-ന്റെ ഏത് പതിപ്പാണ് ഉപയോഗിക്കുന്നത്, സിസ്റ്റം എങ്ങനെ ഇൻസ്റ്റാൾ ചെയ്തു എന്നതിനെ ആശ്രയിച്ചിരിക്കുന്നു.

നിർവ്വഹണ ഫലം കമാൻഡുകൾ സജ്ജമാക്കുകപാരാമീറ്ററുകൾ ഇല്ലാതെ (പൂർണ്ണമല്ല):

HOME=/root PATH=/usr/local/bin:/usr/bin:/bin:.:/usr/bin/X11: IFS= LOGNAME=sae MAIL=/var/spool/mail/sae PWD=/home/ sae/STUDY/SHELL PS1=$(PWD):" " PS2=> SHELL=/bin/bash

വേരിയബിളുകളുടെ മൂല്യങ്ങളെക്കുറിച്ച് നമുക്ക് അഭിപ്രായമിടാം. ലോഗിൻ ചെയ്‌ത ശേഷം ഉപയോക്താവ് അവസാനിക്കുന്ന ഹോം ഡയറക്‌ടറിയുടെ പേരാണ് HOME=/root. അതായത്, പേരും പാസ്‌വേഡും ശരിയായി നൽകിയാൽ, ഞാൻ "/ റൂട്ട്" ഡയറക്‌ടറിയിൽ കണ്ടെത്തും. PATH=/bin:/usr/bin:.:/usr/local/bin:/usr/bin/X11 - ഒരു കമാൻഡിനായി ഷെൽ തിരയുന്ന ഫയലുകളുടെ ക്രമം ഈ വേരിയബിൾ വ്യക്തമാക്കുന്നു. ഫയലുകളുടെ പേരുകൾ ഇവിടെ കോളണുകൾ കൊണ്ട് വേർതിരിച്ചിരിക്കുന്നു. കാണൽ ക്രമം ട്രയലിലെ പേരുകളുടെ ക്രമവുമായി പൊരുത്തപ്പെടുന്നു. എന്നാൽ തുടക്കത്തിൽ ബിൽറ്റ്-ഇൻ കമാൻഡുകൾ എന്ന് വിളിക്കപ്പെടുന്ന ഇടയിലാണ് തിരയൽ സംഭവിക്കുന്നത്. ബിൽറ്റ്-ഇൻ കമാൻഡുകളിൽ "echo", "cd", "pwd", "date" തുടങ്ങിയ ഏറ്റവും സാധാരണയായി ഉപയോഗിക്കുന്ന കമാൻഡുകൾ ഉൾപ്പെടുന്നു. ഇതിനുശേഷം, സിസ്റ്റം "/ bin" ഡയറക്ടറിയിലൂടെ നോക്കുന്നു, അതിൽ "sh", "cp", "mv", "ls" മുതലായവ അടങ്ങിയിരിക്കാം. തുടർന്ന് "/usr/bin" എന്ന ഡയറക്ടറി "cat", "ss", "expr", "nroff", "man" എന്നിവയും മറ്റു പലതും. അടുത്തതായി, നിങ്ങൾ എഴുതിയ കമാൻഡുകൾ മിക്കവാറും സ്ഥിതി ചെയ്യുന്ന നിലവിലെ ഡയറക്ടറിയിൽ (".", അല്ലെങ്കിൽ മറ്റൊരു പദവി "ശൂന്യം", അതായത് "") തിരയൽ നടക്കുന്നു. കമാൻഡ് ലൈൻ ടൈപ്പ് ചെയ്ത് അമർത്തിയാൽ "shell" (ആവശ്യമായ സബ്സ്റ്റിറ്റ്യൂഷനുകൾ നടത്തിയ ശേഷം) കമാൻഡിന് അനുയോജ്യമായ പേര് തിരിച്ചറിയുകയും PATH-ൽ ലിസ്റ്റുചെയ്തിരിക്കുന്ന ഡയറക്ടറികളിൽ അതിനായി തിരയുകയും ചെയ്യുന്നു. ഈ ഡയറക്‌ടറികൾക്ക് പുറത്ത് കമാൻഡ് നൽകിയാൽ, അത് കണ്ടെത്താനാകില്ല. ഒരേ പേരിൽ നിരവധി കമാൻഡുകൾ ഉണ്ടെങ്കിൽ, ആദ്യം കണ്ട ഡയറക്ടറിയിൽ സ്ഥിതി ചെയ്യുന്നവയെ വിളിക്കും. ഡയറക്‌ടറികൾ ചേർക്കുകയോ പുനഃക്രമീകരിക്കുകയോ ഇല്ലാതാക്കുകയോ ചെയ്‌തുകൊണ്ട് മറ്റ് വേരിയബിളുകൾ പോലെ PATH-നും എളുപ്പത്തിൽ മാറ്റാനാകും. IFS= (ഇന്റേണൽ ഫീൽഡ് സെപ്പറേറ്റർ) പദങ്ങൾ (ഫീൽഡുകൾ) വേർതിരിക്കാൻ സഹായിക്കുന്ന പ്രതീകങ്ങൾ ലിസ്റ്റ് ചെയ്യുന്നു. ഇവ "സ്പേസ്", "ടാബ്", "ലൈൻ ഫീഡ്" എന്നിവയാണ്, അതിനാൽ ഇവിടെ അസൈൻമെന്റിന്റെ ഇടതുവശത്ത് ഒന്നും ദൃശ്യമാകില്ല, രണ്ട് വരികൾ ഉൾക്കൊള്ളുന്നു. LOGNAME=റൂട്ട് - ലോഗിൻ നാമം (“ഉപയോക്തൃനാമം”). MAIL=/var/spool/mail/root - (ഇ-മെയിൽ) മെയിൽ ലഭിച്ച ഫയലിന്റെ പേര്. PWD=/root - നിലവിലെ ഡയറക്ടറിയുടെ പേര് PS1=$(PWD): " " - ഡയറക്ടറിയുടെ തരം. ഈ സാഹചര്യത്തിൽ, പ്രോംപ്റ്റർ നിലവിലെ ഡയറക്‌ടറിയുടെ പേരും കോളണും സ്‌പെയ്‌സും പ്രദർശിപ്പിക്കും. അതായത്, "/റൂട്ട്:" ഉണ്ടാകും. PS2=> - ഈ പ്രോംപ്റ്റ് (ഇവിടെ ">") ഒരു പൂർത്തിയാകാത്ത കമാൻഡ് (അടുത്ത വരിയിൽ) നൽകുന്നത് തുടരുന്നതിനുള്ള ക്ഷണമായി ഉപയോഗിക്കുന്നു. ഉദാഹരണത്തിന്, ഓപ്പണിംഗ് ബ്രാക്കറ്റ് "(" ടൈപ്പ് ചെയ്ത് അമർത്തിയാൽ വി അടുത്ത വരിനിങ്ങൾ ഈ പ്രോംപ്റ്റർ കാണും. അടുത്തതായി എന്തുചെയ്യണമെന്ന് നിങ്ങൾക്കറിയില്ലെങ്കിൽ, ക്ലോസിംഗ് ബ്രാക്കറ്റ് ")" എന്ന് ടൈപ്പ് ചെയ്യുക, അത് അപ്രത്യക്ഷമാകും. SHELL=/bin/sh - ഈ വേരിയബിൾ ഉപയോക്താവ് ഉപയോഗിക്കുന്ന ഷെൽ വ്യക്തമാക്കുന്നു. ഈ സാഹചര്യത്തിൽ അത് ഉപയോഗിക്കുന്നു സാധാരണ ഷെൽ("sh"). "/etc/rc", "/etc/.profile" തുടങ്ങിയ ഫയലുകൾ ഉപയോഗിച്ച് ലോഗിൻ ചെയ്യുമ്പോൾ പ്രാരംഭ പരിതസ്ഥിതി സ്വയമേവ ഇൻസ്റ്റാൾ ചെയ്യപ്പെടും. പരിസ്ഥിതിയെ ലളിതമായി മാറ്റുന്നതിനുള്ള ഒരു മാർഗം (ഉദാഹരണത്തിന്, കമാൻഡ് തിരയൽ പാത, പ്രോഗ്രാം തരം, ഷെൽ തരം, സ്‌ക്രീൻ നിറം മുതലായവ) ഈ വിവരങ്ങൾ നിങ്ങളുടെ ഹോം ഡയറക്‌ടറിയിൽ ഒരു പ്രത്യേക ".പ്രൊഫൈൽ" ഫയലിൽ ($(HOME)/ സ്ഥാപിക്കുക എന്നതാണ്. പ്രൊഫൈൽ), ആവശ്യമായ മൂല്യങ്ങൾ നൽകൽ പരിസ്ഥിതി വേരിയബിളുകൾ. അതായത്, ഈ ഫയലിനെ എഡിറ്ററിലേക്ക് വിളിച്ച് നിങ്ങൾക്ക് ആവശ്യമുള്ളത് എഴുതുക). തുടർന്ന്, നിങ്ങൾ ലോഗിൻ ചെയ്യുമ്പോഴെല്ലാം, ഈ ഫയൽ സ്വയമേവ എക്സിക്യൂട്ട് ചെയ്യുകയും ഒരു പുതിയ പരിസ്ഥിതി ഇൻസ്റ്റാൾ ചെയ്യുകയും ചെയ്യും. ഈ ഫയൽ നിങ്ങളിൽ സ്ഥാപിക്കണം ഹോം ഡയറക്ടറി(എൻട്രി ഡയറക്ടറികൾ). ഒരു ഡോട്ടിൽ ആരംഭിക്കുന്ന ഫയലുകളുടെ പേരുകൾക്ക് പൊതുവെ ഒരു പ്രത്യേക പദവിയുണ്ടെന്ന് ഓർമ്മിക്കേണ്ടതാണ്. അതിനാൽ, അവ ഒരു ലളിതമായ "ls" കമാൻഡ് ഉപയോഗിച്ച് സ്ക്രീനിൽ പ്രദർശിപ്പിക്കില്ല - നിങ്ങൾ ഈ കമാൻഡ് "-a" ഫ്ലാഗ് ഉപയോഗിച്ച് വിളിക്കണം. വഴിയിൽ, "rm *" കമാൻഡ് വഴി അവ വിവേചനരഹിതമായി നശിപ്പിക്കപ്പെടുന്നില്ല. ഞാൻ തന്നെ ഷെൽ വ്യാഖ്യാതാവ്ഇനിപ്പറയുന്ന വേരിയബിളുകൾക്ക് (പാരാമീറ്ററുകൾ) സ്വപ്രേരിതമായി മൂല്യങ്ങൾ നൽകുന്നു: ? അവസാന കമാൻഡ് നൽകിയ മൂല്യം; $ പ്രോസസ്സ് നമ്പർ; ! പശ്ചാത്തല പ്രോസസ്സ് നമ്പർ;

1. ഷെല്ലിലേക്ക് കൈമാറിയ സ്ഥാന പരാമീറ്ററുകളുടെ എണ്ണം;

• ഒരു വരിയായി പരാമീറ്ററുകളുടെ പട്ടിക;

@ പരാമീറ്ററുകളുടെ ലിസ്റ്റ്, ഒരു കൂട്ടം വാക്കുകളായി; - പതാകകൾ ഷെല്ലിലേക്ക് കടന്നു. ഈ വേരിയബിളുകൾ ആക്സസ് ചെയ്യുമ്പോൾ (അതായത്, ഒരു കമാൻഡ് ഫയലിൽ - ഷെൽ പ്രോഗ്രാമിൽ അവ ഉപയോഗിക്കുമ്പോൾ), നിങ്ങൾ "$" മുന്നിൽ വെക്കണം. അദ്വിതീയ ഫയലുകൾ സൃഷ്ടിക്കുന്നതിൽ ഒരു പ്രധാന പങ്ക് പ്രത്യേക വേരിയബിൾ "$$" വഹിക്കുന്നു, അതിന്റെ മൂല്യം ഈ കണക്കുകൂട്ടൽ നടത്തുന്ന പ്രക്രിയയുടെ എണ്ണവുമായി പൊരുത്തപ്പെടുന്നു. ഒരു കമ്പ്യൂട്ടർ നടത്തുന്ന ഓരോ പുതിയ കണക്കുകൂട്ടലും ക്രമത്തിൽ നമ്പറുകൾ സ്വയമേവ സ്വീകരിക്കുന്ന ഒന്നോ അതിലധികമോ പ്രക്രിയകൾ ആരംഭിക്കുന്നു. അതിനാൽ, പ്രോസസ്സ് നമ്പർ ഒരു ഫയൽ നാമമായി ഉപയോഗിക്കുമ്പോൾ, ഓരോ പുതിയ ഫയലിനും ഒരു പുതിയ പേര് ഉണ്ടായിരിക്കുമെന്ന് നിങ്ങൾക്ക് ഉറപ്പിക്കാം (നിലവിലുള്ള ഒന്നിന്റെ സ്ഥാനത്ത് എഴുതപ്പെടില്ല). ഫയലുകൾക്ക് പേരിടുന്ന ഈ രീതിയുടെ പ്രധാന പോരായ്മയും നേട്ടമാണ്. ഫയലുകൾക്ക് ഏതെല്ലാം പേരുകൾ നൽകുമെന്ന് അറിയില്ല. കൂടാതെ, ഈ പ്രക്രിയയുടെ ചട്ടക്കൂടിനുള്ളിൽ നിങ്ങൾക്ക് "നോക്കാതെ തന്നെ" ഒരു ഫയൽ കണ്ടെത്താൻ കഴിയുമെങ്കിൽ, അത് $$ ഉപയോഗിച്ച് ആക്സസ് ചെയ്യുന്നതിലൂടെ, അത്തരം ഫയലുകൾ എളുപ്പത്തിൽ നഷ്ടപ്പെടും. ഇത് സൃഷ്ടിക്കുന്നു അധിക പ്രശ്നങ്ങൾപ്രോഗ്രാമുകൾ ഡീബഗ്ഗ് ചെയ്യുമ്പോൾ. വ്യാഖ്യാതാവിനെ വിളിക്കുന്നു ഉപയോക്താവിനെ സിസ്റ്റത്തിൽ രജിസ്റ്റർ ചെയ്ത ശേഷം (ലോഗിൻ കമാൻഡ് ഉപയോഗിച്ച്), SHELL ഭാഷാ വ്യാഖ്യാതാവിനെ വിളിക്കുന്നു. ഉപയോക്താവിന്റെ രജിസ്ട്രേഷൻ ഡയറക്‌ടറിയിൽ ഒരു .profile ഫയൽ അടങ്ങിയിട്ടുണ്ടെങ്കിൽ, ടെർമിനലിൽ നിന്ന് ഒരു കമാൻഡെങ്കിലും ലഭിക്കുന്നതിന് മുമ്പ്, വ്യാഖ്യാതാവ് ഈ ഫയൽ എക്‌സിക്യൂട്ട് ചെയ്യുന്നു (. പ്രൊഫൈൽ ഫയലിൽ കമാൻഡുകൾ ഉണ്ടെന്ന് അനുമാനിക്കപ്പെടുന്നു). വിളിക്കുമ്പോൾ, ഇനിപ്പറയുന്ന കീകൾ വ്യക്തമാക്കാൻ കഴിയും: -c സ്ട്രിംഗ് കമാൻഡുകൾ നൽകിയിരിക്കുന്ന സ്ട്രിംഗിൽ നിന്ന് വായിക്കുന്നു. -s കമാൻഡുകൾ സാധാരണ ഇൻപുട്ടിൽ നിന്ന് വായിക്കുന്നു. ഇന്റർപ്രെറ്റർ സന്ദേശങ്ങൾ ഒരു സാധാരണ ഡയഗ്നോസ്റ്റിക്സ് ഫയലിൽ എഴുതിയിരിക്കുന്നു. -ഐ ഇന്ററാക്ടീവ് ഓപ്പറേറ്റിംഗ് മോഡ്. "0" പാരാമീറ്ററിന്റെ ആദ്യ പ്രതീകം ഒരു - ചിഹ്നമാണെങ്കിൽ, കമാൻഡുകൾ .profile ഫയലിൽ നിന്ന് വായിക്കുന്നു.

പ്രോഗ്രാം ഘടനകൾ===

ഏതൊരു പ്രോഗ്രാമിംഗ് ഭാഷയിലെയും പോലെ, ഷെൽ ടെക്സ്റ്റിൽ അഭിപ്രായങ്ങൾ അടങ്ങിയിരിക്കാം. ഇതിനായി "#" ചിഹ്നം ഉപയോഗിക്കുന്നു. ഈ പ്രതീകത്തിന്റെ ഇടതുവശത്തുള്ള ലൈനിലുള്ള (കമാൻഡ് ഫയലിൽ) എല്ലാം വ്യാഖ്യാതാവ് ഒരു അഭിപ്രായമായി കാണുന്നു. ഉദാഹരണത്തിന്,

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

ഏതൊരു പ്രൊസീജറൽ പ്രോഗ്രാമിംഗ് ഭാഷയും പോലെ, ഷെൽ ഭാഷയ്ക്കും ഓപ്പറേറ്റർമാരുണ്ട്. കമാൻഡ് എക്സിക്യൂഷന്റെ ക്രമം നിയന്ത്രിക്കാൻ നിരവധി ഓപ്പറേറ്റർമാർ നിങ്ങളെ അനുവദിക്കുന്നു. അത്തരം ഓപ്പറേറ്റർമാരിൽ, പലപ്പോഴും അവസ്ഥ പരിശോധിക്കേണ്ടത് ആവശ്യമാണ്, ഇത് കണക്കുകൂട്ടലുകൾ തുടരുന്ന ദിശ നിർണ്ണയിക്കുന്നു.

ടെസ്റ്റ്("") കമാൻഡ്

ടെസ്റ്റ് കമാൻഡ് ഒരു നിശ്ചിത വ്യവസ്ഥ പാലിക്കുന്നുണ്ടോയെന്ന് പരിശോധിക്കുന്നു. ഈ (ബിൽറ്റ്-ഇൻ) കമാൻഡ് ഉപയോഗിച്ചാണ് ഷെൽ ഭാഷ തിരഞ്ഞെടുക്കുന്നതും ലൂപ്പ് പ്രസ്താവനകളും സൃഷ്ടിക്കുന്നത്. സാധ്യമായ രണ്ട് കമാൻഡ് ഫോർമാറ്റുകൾ:

ടെസ്റ്റ് അവസ്ഥ

[ വ്യവസ്ഥ ]

ഞങ്ങൾ രണ്ടാമത്തെ ഓപ്ഷൻ ഉപയോഗിക്കും, അതായത്. വ്യവസ്ഥയ്ക്ക് മുമ്പ് "ടെസ്റ്റ്" എന്ന വാക്ക് എഴുതുന്നതിനുപകരം, പ്രോഗ്രാമർമാർക്ക് കൂടുതൽ സാധാരണമായ പരാൻതീസിസിൽ ഞങ്ങൾ വ്യവസ്ഥ ഉൾപ്പെടുത്തും. വാസ്തവത്തിൽ, "[" എന്ന ഓപ്പണിംഗ് ബ്രാക്കറ്റിൽ "ടെസ്റ്റ്" കമാൻഡിന് അനുയോജ്യമായ പദമായി ഷെൽ ഈ കമാൻഡ് തിരിച്ചറിയും. ബ്രാക്കറ്റുകൾക്കും അവയിൽ അടങ്ങിയിരിക്കുന്ന അവസ്ഥയ്ക്കും ഇടയിൽ ഇടങ്ങൾ ഉണ്ടായിരിക്കണം. മൂല്യങ്ങൾക്കും താരതമ്യത്തിനും അല്ലെങ്കിൽ പ്രവർത്തന ചിഹ്നത്തിനും ഇടയിലും ഇടങ്ങൾ ഉണ്ടായിരിക്കണം. ഷെൽ വിവിധ "തരം" വ്യവസ്ഥകൾ ഉപയോഗിക്കുന്നു. ഫയൽ പരിശോധിക്കുന്നതിനുള്ള വ്യവസ്ഥകൾ: -f ഫയൽ ഫയൽ "ഫയൽ" ഒരു സാധാരണ ഫയലാണ്; -d ഫയൽ ഫയൽ "ഫയൽ" - ഡയറക്ടറി; -с ഫയൽ ഫയൽ "ഫയൽ" ഒരു പ്രത്യേക ഫയലാണ്; -r ഫയലിന് "ഫയൽ" ഫയൽ വായിക്കാൻ അനുമതിയുണ്ട്; "ഫയൽ" ഫയലിലേക്ക് എഴുതാൻ -w ഫയലിന് അനുമതിയുണ്ട്; -s ഫയൽ ഫയൽ "ഫയൽ" ശൂന്യമല്ല.

സ്ട്രിംഗുകൾ പരിശോധിക്കുന്നതിനുള്ള വ്യവസ്ഥകൾ: str1 = str2 സ്ട്രിംഗുകൾ "str1", "str2" എന്നിവ പൊരുത്തം; str1 != str2 സ്ട്രിംഗുകൾ "str1" ഉം "str2" ഉം ഒന്നല്ല; -n str1 സ്ട്രിംഗ് "str1" നിലവിലുണ്ട് (ശൂന്യമല്ല); -z str1 സ്ട്രിംഗ് "str1" നിലവിലില്ല (ശൂന്യം). ഉദാഹരണങ്ങൾ.

X="ആരാണ് ആരാണ്"; കയറ്റുമതി x; [ "ആരാണ്" = "$x" ]; പ്രതിധ്വനി $? 0 x=abc; കയറ്റുമതി x; [ abc = "$x" ] ; പ്രതിധ്വനി $? 0 x=abc; കയറ്റുമതി x; [-n "$x" ] ; പ്രതിധ്വനി $? 0 x="" ; കയറ്റുമതി x; [-n "$x" ] ; പ്രതിധ്വനി $? 1

കൂടാതെ, വ്യവസ്ഥയുടെ സ്ഥാനത്ത് ഉപയോഗിക്കാവുന്ന രണ്ട് സ്റ്റാൻഡേർഡ് കണ്ടീഷൻ മൂല്യങ്ങളുണ്ട് (ഇതിന് പരാൻതീസിസുകളൊന്നും ആവശ്യമില്ല). സംഖ്യകൾ താരതമ്യം ചെയ്യുന്നതിനുള്ള വ്യവസ്ഥകൾ: x -eq y "x" എന്നത് "y" ന് തുല്യമാണ്, x -ne y "x" എന്നത് "y" ന് തുല്യമല്ല, x -gt y "x" എന്നത് "y" എന്നതിനേക്കാൾ വലുതാണ്, x - ge y "x" എന്നത് "y" എന്നതിനേക്കാൾ വലുതോ തുല്യമോ ആണ്, x -lt y "x" "y" നേക്കാൾ കുറവാണ്, x -le y "x" "y" എന്നതിനേക്കാൾ കുറവോ തുല്യമോ ആണ്. സങ്കീർണ്ണമായ വ്യവസ്ഥകൾ: സ്റ്റാൻഡേർഡ് ലോജിക്കൽ ഓപ്പറേഷനുകൾ ഉപയോഗിച്ച് നടപ്പിലാക്കിയത്: ! (അല്ല) എക്സിറ്റ് കോഡ് മൂല്യം വിപരീതമാക്കുന്നു. -o (അല്ലെങ്കിൽ) ലോജിക്കൽ "OR" മായി പൊരുത്തപ്പെടുന്നു. -a (ഒപ്പം) ലോജിക്കൽ "AND" മായി പൊരുത്തപ്പെടുന്നു.

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

പൊതുവേ, "if" പ്രസ്താവനയ്ക്ക് ഘടനയുണ്ട്

വ്യവസ്ഥയാണെങ്കിൽ ലിസ്റ്റ് ചെയ്യുക

ഇവിടെ "elif" എന്നത് പൂർണ്ണമായ ഒന്നിനൊപ്പം "else if" എന്നതിന്റെ ചുരുക്കിയ പതിപ്പ് ഉപയോഗിക്കാം, അതായത്. അറ്റാച്ച്മെന്റ് അനുവദിച്ചു ഏതെങ്കിലും നമ്പർ"if" പ്രസ്താവനകൾ (അതുപോലെ മറ്റ് പ്രസ്താവനകളും). തീർച്ചയായും, ഓരോ സാഹചര്യത്തിലും "ലിസ്റ്റ്" നൽകിയിരിക്കുന്ന സന്ദർഭത്തിൽ അർത്ഥവത്തായതും സ്വീകാര്യവുമായിരിക്കണം. ഈ ഓപ്പറേറ്ററുടെ ഏറ്റവും വെട്ടിച്ചുരുക്കിയ ഘടന

വ്യവസ്ഥയാണെങ്കിൽ fi ലിസ്റ്റ് ചെയ്യുക

നിബന്ധന പാലിച്ചാൽ (സാധാരണയായി ഇവിടെയാണ് പൂർത്തീകരണ കോഡ് "0" ലഭിക്കുന്നത്), തുടർന്ന് "ലിസ്റ്റ്" എക്സിക്യൂട്ട് ചെയ്യപ്പെടും, അല്ലാത്തപക്ഷം അത് ഒഴിവാക്കപ്പെടും. ഉദാഹരണങ്ങൾ: "if-1" എഴുതട്ടെ

എങ്കിൽ [ $1 -gt $2 ]

പിന്നെ pwd else echo $0: ഹലോ!

അപ്പോൾ if-1 12 11 എന്ന് വിളിക്കുന്നത് /home/sae/STUDY/SHELL ഉൽപ്പാദിപ്പിക്കുകയും if-1 12 13 എന്നത് if-1 നിർമ്മിക്കുകയും ചെയ്യും: ഹലോ!

കോൾ ഓപ്പറേറ്റർ ("കേസ്")

"കേസ്" തിരഞ്ഞെടുക്കൽ ഓപ്പറേറ്ററിന് ഘടനയുണ്ട്:

കേസ് സ്ട്രിംഗ് ഇൻ

ടെംപ്ലേറ്റ്) കമാൻഡുകളുടെ പട്ടിക; ടെംപ്ലേറ്റ്) കമാൻഡുകളുടെ പട്ടിക; ... ടെംപ്ലേറ്റ്) കമാൻഡുകളുടെ ലിസ്റ്റ്;;

ഇവിടെ "കേസ്", "ഇൻ", "എസക്" എന്നിവ ഫംഗ്ഷൻ പദങ്ങളാണ്. "സ്ട്രിംഗ്" (ഇത് ഒരു പ്രതീകം ആകാം) "പാറ്റേണുമായി" താരതമ്യം ചെയ്യുന്നു. തിരഞ്ഞെടുത്ത വരിയുടെ "കമാൻഡ് ലിസ്റ്റ്" പിന്നീട് എക്സിക്യൂട്ട് ചെയ്യുന്നു. തിരഞ്ഞെടുക്കൽ വരികളുടെ അവസാനം ";;" അസാധാരണമായി തോന്നുന്നു, എന്നാൽ ഇവിടെ ";" എഴുതുക അതൊരു തെറ്റായിരിക്കും. ഓരോ ബദലിനും ഒന്നിലധികം കമാൻഡുകൾ എക്സിക്യൂട്ട് ചെയ്യാൻ കഴിയും. ഈ കമാൻഡുകൾ ഒരു വരിയിൽ എഴുതിയിട്ടുണ്ടെങ്കിൽ, ചിഹ്നം ";" ഒരു കമാൻഡ് സെപ്പറേറ്ററായി ഉപയോഗിക്കും. സാധാരണയായി അവസാന വരിതിരഞ്ഞെടുപ്പിന് "*" എന്ന പാറ്റേൺ ഉണ്ട്, അത് "കേസ്" ഘടനയിൽ "ഏതെങ്കിലും മൂല്യം" എന്നാണ് അർത്ഥമാക്കുന്നത്. വേരിയബിളിന്റെ മൂല്യം (ഇവിടെ $z) ")" ബ്രാക്കറ്റിൽ നിന്ന് വേർതിരിക്കുന്ന മുമ്പ് എഴുതിയ ഏതെങ്കിലും പാറ്റേണുമായി പൊരുത്തപ്പെടുന്നില്ലെങ്കിൽ ഈ ലൈൻ തിരഞ്ഞെടുക്കപ്പെടും. മൂല്യങ്ങൾ അവ എഴുതിയ ക്രമത്തിലാണ് കാണുന്നത്.

എണ്ണിയ ലൂപ്പ് ഓപ്പറേറ്റർ ("ഫോർ")

"ഫോർ" ലൂപ്പ് ഓപ്പറേറ്ററിന് ഘടനയുണ്ട്:

പേരിന്

"for" എന്നത് ലൂപ്പിന്റെ തരം നിർവചിക്കുന്ന ഒരു സഹായ പദമാണ്, "do", "done" എന്നിവ ലൂപ്പിന്റെ ബോഡി ഹൈലൈറ്റ് ചെയ്യുന്ന സഹായ പദങ്ങളാണ്. "lsort" കമാൻഡ് ഒരു ബാച്ച് ഫയൽ പ്രതിനിധീകരിക്കട്ടെ

file_1 file_2 file_3-ലെ i-നായി proc_sort $i ചെയ്തു

ഈ ഉദാഹരണത്തിൽ, "i" എന്ന പേര് ഒരു ലൂപ്പ് പാരാമീറ്ററായി പ്രവർത്തിക്കുന്നു. ലിസ്‌റ്റ് ചെയ്‌ത മൂല്യങ്ങൾ ക്രമാനുഗതമായി അസൈൻ ചെയ്‌തിരിക്കുന്ന ഒരു ഷെൽ വേരിയബിളായി ഈ പേര് കണക്കാക്കാം (i=file_1, i=file_2, i=file_3), കൂടാതെ "proc_sort" കമാൻഡ് ഒരു ലൂപ്പിൽ എക്‌സിക്യൂട്ട് ചെയ്യുന്നു. ഫോർ ഐ ഇൻ *" എന്ന ഫോം പലപ്പോഴും ഉപയോഗിക്കാറുണ്ട്, അതായത് "നിലവിലെ ഡയറക്‌ടറിയിലെ എല്ലാ ഫയലുകൾക്കും". "proc_sort" ഒരു ബാച്ച് ഫയൽ പ്രതിനിധീകരിക്കട്ടെ

പൂച്ച $1 | അടുക്കുക | tee /dev/lp > $(1)_sorted

ആ. നിർദ്ദിഷ്ട ഫയലുകൾ ക്രമാനുഗതമായി അടുക്കുന്നു, സോർട്ടിംഗ് ഫലങ്ങൾ പ്രിന്റ് ചെയ്‌ത് ("/dev/lp") ഫയലുകളിലേക്ക് അയയ്ക്കുകയും file_1_sorted file_2_sorted, file_3_sorted

യഥാർത്ഥ അവസ്ഥയിലുള്ള ലൂപ്പ് പ്രസ്താവന ("ഇപ്പോൾ")

പാരാമീറ്റർ മൂല്യങ്ങളുടെ കൃത്യമായ ലിസ്റ്റ് മുൻകൂട്ടി അറിയാത്തപ്പോൾ അല്ലെങ്കിൽ ഒരു ലൂപ്പിലെ കണക്കുകൂട്ടലുകളുടെ ഫലമായി ഈ ലിസ്റ്റ് ലഭിക്കുമ്പോൾ കണക്കുകൂട്ടലുകൾ നടത്തുന്ന "അതേസമയം" ഘടനയാണ് അഭികാമ്യം. "വേൽ" ലൂപ്പ് പ്രസ്താവനയ്ക്ക് ഘടനയുണ്ട്:

അതേസമയം അവസ്ഥ

"വേൽ" എന്നത് ഒരു യഥാർത്ഥ അവസ്ഥയിലുള്ള ലൂപ്പിന്റെ തരം നിർണ്ണയിക്കുന്ന ഒരു സഹായ പദമായിരിക്കുന്നിടത്ത് ചെയ്ത കമാൻഡുകളുടെ ലിസ്റ്റ് ചെയ്യുക. ലൂപ്പ് ബോഡിയിലെ കമാൻഡുകളുടെ ലിസ്റ്റ് ("do" എന്നതിനും "ചെയ്തു" എന്നതിനും ഇടയിൽ) വ്യവസ്ഥ ശരിയാകുന്നതുവരെ (അതായത്, ലൂപ്പ് ബോഡിയിലെ അവസാന കമാൻഡിന്റെ പൂർത്തീകരണ കോഡ് "0" ആണ്) അല്ലെങ്കിൽ ലൂപ്പ് തടസ്സപ്പെടാതിരിക്കുന്നതുവരെ ആവർത്തിക്കുന്നു. ഉള്ളിൽ നിന്ന് പ്രത്യേക കമാൻഡുകൾ ( "ബ്രേക്ക്", "തുടരുക" അല്ലെങ്കിൽ "പുറത്തുകടക്കുക"). നിങ്ങൾ ആദ്യം ലൂപ്പിൽ പ്രവേശിക്കുമ്പോൾ, വ്യവസ്ഥ ശരിയായിരിക്കണം. "break [n]" കമാൻഡ് ഒരു ലൂപ്പിൽ നിന്ന് പുറത്തുകടക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു. "n" ഇല്ലെങ്കിൽ, അത് "ബ്രേക്ക് 1" ന് തുല്യമാണ്. "n" എന്നത് പുറത്തുകടക്കേണ്ട നെസ്റ്റഡ് ലൂപ്പുകളുടെ എണ്ണം സൂചിപ്പിക്കുന്നു, ഉദാഹരണത്തിന്, "ബ്രേക്ക് 3" - മൂന്ന് നെസ്റ്റഡ് ലൂപ്പുകളിൽ നിന്ന് പുറത്തുകടക്കുക. "ബ്രേക്ക്" കമാൻഡിൽ നിന്ന് വ്യത്യസ്തമായി, "തുടരുക [n]" കമാൻഡ് നിലവിലെ ലൂപ്പിന്റെ എക്സിക്യൂഷൻ നിർത്തുകയും ലൂപ്പിന്റെ ആരംഭത്തിലേക്ക് മടങ്ങുകയും ചെയ്യുന്നു. ഇത് ഒരു പാരാമീറ്റർ ഉപയോഗിച്ചും ആകാം. ഉദാഹരണത്തിന്, "തുടരുക 2" എന്നാൽ രണ്ടാമത്തെ (ആഴത്തിൽ നിന്ന് എണ്ണുന്നത്) നെസ്റ്റഡ് ലൂപ്പിന്റെ തുടക്കത്തിലേക്ക് പുറത്തുകടക്കുക എന്നാണ്. "0" അല്ലെങ്കിൽ "n" ("n" പാരാമീറ്റർ വ്യക്തമാക്കിയിട്ടുണ്ടെങ്കിൽ) റിട്ടേൺ കോഡ് ഉപയോഗിച്ച് നടപടിക്രമത്തിൽ നിന്ന് പൂർണ്ണമായും പുറത്തുകടക്കാൻ "exit [n]" കമാൻഡ് നിങ്ങളെ അനുവദിക്കുന്നു. ഈ കമാൻഡ് ലൂപ്പുകളേക്കാൾ കൂടുതൽ ഉപയോഗിക്കാവുന്നതാണ്. കമാൻഡുകളുടെ ഒരു രേഖീയ ശ്രേണിയിൽ പോലും, ഒരു നിശ്ചിത പോയിന്റിൽ (നിലവിലെ) കണക്കുകൂട്ടൽ നിർത്തുന്നതിന് ഡീബഗ്ഗിംഗിൽ ഇത് ഉപയോഗപ്രദമാകും.

തെറ്റായ അവസ്ഥയിലുള്ള ലൂപ്പ് പ്രസ്താവന ("വരെ")

"വരെ" ലൂപ്പ് ഓപ്പറേറ്ററിന് ഘടനയുണ്ട്:

വ്യവസ്ഥ വരെ

"വരെ" എന്നത് ഒരു തെറ്റായ അവസ്ഥയുള്ള ലൂപ്പിന്റെ തരം നിർണ്ണയിക്കുന്ന ഒരു സഹായ പദമായിരിക്കുന്നിടത്ത് ചെയ്ത കമാൻഡുകളുടെ ലിസ്റ്റ് ചെയ്യുക. ലൂപ്പിന്റെ ബോഡിയിലെ കമാൻഡുകളുടെ ലിസ്റ്റ് ("do" എന്നതിനും "ചെയ്തു" എന്നതിനും ഇടയിൽ) വ്യവസ്ഥ തെറ്റാകുന്നതുവരെ അല്ലെങ്കിൽ പ്രത്യേക കമാൻഡുകൾ ("ബ്രേക്ക്", "തുടരുക" അല്ലെങ്കിൽ "പുറത്തുകടക്കുക" എന്നിവ ഉപയോഗിച്ച് ലൂപ്പ് അകത്തു നിന്ന് തടസ്സപ്പെടുന്നതുവരെ ആവർത്തിക്കുന്നു. ). നിങ്ങൾ ആദ്യമായി ലൂപ്പിൽ പ്രവേശിക്കുമ്പോൾ, വ്യവസ്ഥ ശരിയാകരുത്. "വേൽ" ഓപ്പറേറ്ററിൽ നിന്നുള്ള വ്യത്യാസം എന്തെന്നാൽ, ലൂപ്പ് അവസ്ഥ തെറ്റായി പരിശോധിക്കപ്പെടുന്നു (ലൂപ്പ് ബോഡിയുടെ അവസാന കമാൻഡിന്റെ പൂജ്യമല്ലാത്ത എക്സിറ്റ് കോഡിനായി) ഓരോന്നിനും (ആദ്യത്തേത് ഉൾപ്പെടെ!) കമാൻഡുകൾ നടപ്പിലാക്കിയതിന് ശേഷം പരിശോധിക്കുന്നു. ലൂപ്പ് ബോഡി. ഉദാഹരണം.

തെറ്റായി പ്രവർത്തിക്കുന്നത് വരെ

[$x = 5] എങ്കിൽ x വായിക്കുക, അപ്പോൾ മതി പ്രതിധ്വനിക്കുക; ബ്രേക്ക് അല്ലാതെ കുറച്ചു കൂടി ഫൈ പ്രതിധ്വനിക്കുക

കൂടെയുള്ള പരിപാടി ഇതാ അനന്തമായ ലൂപ്പ്"5" നൽകുന്നതുവരെ വാക്കുകൾ നൽകുന്നതിനായി കാത്തിരിക്കുന്നു (സ്‌ക്രീനിൽ "ചിലത്" എന്ന വാചകം ആവർത്തിക്കുന്നു). ഇതിനുശേഷം, "മതി" പുറപ്പെടുവിക്കുകയും "ബ്രേക്ക്" കമാൻഡ് ലൂപ്പ് എക്സിക്യൂട്ട് ചെയ്യുന്നത് നിർത്തുകയും ചെയ്യുന്നു.

ശൂന്യമായ ഓപ്പറേറ്റർ

ശൂന്യമായ പ്രസ്താവനയ്ക്ക് ഫോർമാറ്റ് ഉണ്ട്

:

ഒന്നും ചെയ്യാതെ. "0" മൂല്യം നൽകുന്നു.

ഷെല്ലിലെ പ്രവർത്തനങ്ങൾ

തുടർന്നുള്ള നിർവ്വഹണത്തിനായി ഷെൽ കമാൻഡുകളുടെ ഒരു ലിസ്റ്റ് തയ്യാറാക്കാൻ ഫംഗ്ഷൻ നിങ്ങളെ അനുവദിക്കുന്നു. ഫംഗ്ഷൻ വിവരണം ഇതുപോലെ കാണപ്പെടുന്നു:

പേര്() (കമാൻഡ് ലിസ്റ്റ്)

അതിനുശേഷം ഫംഗ്ഷനെ പേര് വിളിക്കുന്നു. ഫംഗ്ഷൻ എക്സിക്യൂട്ട് ചെയ്യുമ്പോൾ, ഒരു പുതിയ പ്രക്രിയയും സൃഷ്ടിക്കപ്പെടുന്നില്ല. ഇത് അനുബന്ധ പ്രക്രിയയുടെ പരിതസ്ഥിതിയിൽ പ്രവർത്തിക്കുന്നു. ഫംഗ്‌ഷന്റെ ആർഗ്യുമെന്റുകൾ അതിന്റെ സ്ഥാന പരാമീറ്ററുകളായി മാറുന്നു; ഫംഗ്‌ഷന്റെ പേര് അതിന്റെ പൂജ്യം പരാമീറ്ററാണ്. "റിട്ടേൺ [n]" ഓപ്പറേറ്റർ ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഒരു ഫംഗ്ഷന്റെ നിർവ്വഹണം തടസ്സപ്പെടുത്താം, ഇവിടെ (ഓപ്ഷണൽ) "n" എന്നത് റിട്ടേൺ കോഡാണ്.

തടസ്സം കൈകാര്യം ചെയ്യൽ ("ട്രാപ്പ്")

പ്രോഗ്രാം നിർവ്വഹണം തടസ്സപ്പെടാതെ സംരക്ഷിക്കേണ്ടത് ആവശ്യമായി വന്നേക്കാം. മിക്കപ്പോഴും, സിഗ്നലുകളുമായി ബന്ധപ്പെട്ട ഇനിപ്പറയുന്ന തടസ്സങ്ങൾ നിങ്ങൾ നേരിടുന്നു: 0 ഇന്റർപ്രെറ്ററിൽ നിന്ന് പുറത്തുകടക്കുക, 1 ഹാംഗ് അപ്പ് (റിമോട്ട് സബ്‌സ്‌ക്രൈബർ വിച്ഛേദിക്കുക), 2 തടസ്സം , 9 നാശം (തടഞ്ഞുകിടക്കുന്നില്ല), 15 വധശിക്ഷയുടെ അവസാനം. തടസ്സങ്ങളിൽ നിന്ന് പരിരക്ഷിക്കുന്നതിന്, ഫോർമാറ്റ് ഉള്ള ഒരു "ട്രാപ്പ്" കമാൻഡ് ഉണ്ട്:

"കമാൻഡ് ലിസ്റ്റ്" സിഗ്നലുകൾ ട്രാപ്പ് ചെയ്യുക

സിസ്റ്റത്തിൽ തടസ്സങ്ങൾ സംഭവിക്കുകയാണെങ്കിൽ, സിഗ്നലുകൾ "സിഗ്നലുകളിൽ" ഒരു സ്പേസ് കൊണ്ട് വേർതിരിച്ചിരിക്കുന്നു, തുടർന്ന് "കമാൻഡ് ലിസ്റ്റ്" എക്സിക്യൂട്ട് ചെയ്യും, അതിനുശേഷം (കമാൻഡ് ലിസ്റ്റിൽ "എക്സിറ്റ്" കമാൻഡ് എക്സിക്യൂട്ട് ചെയ്തിട്ടില്ലെങ്കിൽ) നിയന്ത്രണം തടസ്സപ്പെടുത്തൽ പോയിന്റിലേക്ക് മടങ്ങുക, കമാൻഡ് ഫയലിന്റെ എക്സിക്യൂഷൻ തുടരും. ഉദാഹരണത്തിന്, ഒരു കമാൻഡ് ഫയലിന്റെ നിർവ്വഹണത്തെ തടസ്സപ്പെടുത്തുന്നതിന് മുമ്പ് "/tmp" ലെ ഫയലുകൾ ഇല്ലാതാക്കേണ്ടത് ആവശ്യമാണെങ്കിൽ, ഇത് "ട്രാപ്പ്" കമാൻഡ് ഉപയോഗിച്ച് ചെയ്യാം:

ട്രാപ്പ് "rm /tmp/* ; എക്സിറ്റ് 1" 1 2 15

ഫയലിലെ മറ്റ് കമാൻഡുകൾക്ക് മുമ്പുള്ളതാണ്. ഇവിടെ, ഫയലുകൾ ഇല്ലാതാക്കിയ ശേഷം, കമാൻഡ് ഫയൽ എക്സിറ്റ് ചെയ്യും.

• ട്യൂട്ടോറിയൽ

ലേഖനം എന്തിന്, ആർക്കുവേണ്ടിയാണ്?

തുടക്കത്തിൽ, ഇത് Unix പോലുള്ള സിസ്റ്റങ്ങളുമായി പ്രവർത്തിക്കാൻ തുടങ്ങുന്ന വിദ്യാർത്ഥികൾക്കുള്ള ഒരു ഓർമ്മപ്പെടുത്തലായിരുന്നു. മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, ലേഖനം യുണിക്സ് കമാൻഡ് ലൈനിൽ പ്രവർത്തിച്ച് മുൻ പരിചയമില്ലാത്തവരെ ഉദ്ദേശിച്ചുള്ളതാണ്, എന്നാൽ ഒരു കാരണത്താലോ മറ്റൊരു കാരണത്താലോ അത് എങ്ങനെ ഫലപ്രദമായി സംവദിക്കാമെന്ന് പഠിക്കേണ്ടതുണ്ട്.

മനയുടെ (ഡോക്യുമെന്റേഷൻ) പുനർവായന ഉണ്ടാകില്ല, ലേഖനം ഒരു തരത്തിലും അവ വായിക്കുന്നത് റദ്ദാക്കുകയോ പകരം വയ്ക്കുകയോ ചെയ്യുന്നില്ല. പകരം, ജോലിയുടെ തുടക്കം മുതൽ നിങ്ങൾ മനസ്സിലാക്കേണ്ട പ്രധാന കാര്യങ്ങളെക്കുറിച്ച് (കമാൻഡുകൾ, ടെക്നിക്കുകൾ, തത്വങ്ങൾ) ഞാൻ സംസാരിക്കും. unix ഷെൽഅങ്ങനെ ജോലി കാര്യക്ഷമമായും സന്തോഷത്തോടെയും നടക്കുന്നു.

പൂർണ്ണമായും പ്രവർത്തനക്ഷമമായ ഷെല്ലും (വെയിലത്ത് zsh അല്ലെങ്കിൽ ബാഷ്) സാമാന്യം വിപുലമായ ശ്രേണികളുമുള്ള പൂർണ്ണമായ യുണിക്സ് പോലുള്ള പരിതസ്ഥിതികളെയാണ് ലേഖനം പരിഗണിക്കുന്നത്. സ്റ്റാൻഡേർഡ് പ്രോഗ്രാമുകൾ.

എന്താണ് ഷെൽ

ഷെൽ (ഷെൽ, അല്ലെങ്കിൽ "കമാൻഡ് ലൈൻ", അല്ലെങ്കിൽ CLI, അല്ലെങ്കിൽ "കൺസോൾ", അല്ലെങ്കിൽ "ടെർമിനൽ", അല്ലെങ്കിൽ "വെളുത്ത അക്ഷരങ്ങളുള്ള കറുത്ത വിൻഡോ") ആശയവിനിമയത്തിനുള്ള ഒരു ടെക്സ്റ്റ് ഇന്റർഫേസ് ആണ്. ഓപ്പറേറ്റിംഗ് സിസ്റ്റം(ശരി, കർശനമായി പറഞ്ഞാൽ, ഇതാണ് പ്രോഗ്രാം, ഇത് അത്തരമൊരു ഇന്റർഫേസ് നൽകുന്നു, എന്നാൽ ഇപ്പോൾ ഈ വ്യത്യാസം അപ്രധാനമാണ്).

പൊതുവേ, ഒരു ഷെല്ലിലൂടെയുള്ള ജോലി ഇതുപോലെ കാണപ്പെടുന്നു: ഉപയോക്താവ് (അതായത് നിങ്ങൾ) കീബോർഡിൽ നിന്ന് ഒരു കമാൻഡ് നൽകുന്നു, എന്റർ അമർത്തുന്നു, സിസ്റ്റം കമാൻഡ് എക്സിക്യൂട്ട് ചെയ്യുന്നു, എക്സിക്യൂഷന്റെ ഫലം സ്ക്രീനിൽ എഴുതുന്നു, വീണ്ടും അടുത്ത കമാൻഡിനായി കാത്തിരിക്കുന്നു. പ്രവേശിക്കണം.

സാധാരണ കാഴ്ചഷെല്ല:

എല്ലാ Unix പോലുള്ള സെർവർ സിസ്റ്റങ്ങളുമായും സംവദിക്കാനുള്ള പ്രാഥമിക മാർഗമാണ് ഷെൽ.

കമാൻഡ് ലൈൻ സിസ്റ്റങ്ങൾ എവിടെയാണ് കാണപ്പെടുന്നത്?

ഒരു യുണിക്സ് ഷെൽ നിങ്ങൾക്കായി കാത്തിരിക്കുന്നിടത്ത്, ജനപ്രിയ ഓപ്ഷനുകൾ:

• MacOS (ബാഷ്);
• ജോലിയ്‌ക്കോ വ്യക്തിഗത വെബ് പ്രോജക്‌റ്റിനോ വേണ്ടി സെർവറിലേക്കുള്ള വിദൂര ആക്‌സസ്;
• റിമോട്ട് ആക്സസ് ഉള്ള ഹോം ഫയൽ സെർവർ;
• ഉബുണ്ടു, ലാപ്‌ടോപ്പ്/ഡെസ്‌ക്‌ടോപ്പിലെ PC-BSD - unix പോലുള്ള സിസ്റ്റങ്ങൾ ഇന്ന് ഇൻസ്റ്റാൾ ചെയ്യാനും ഉപയോഗിക്കാനും എളുപ്പമാണ്.

ഒരു ഷെൽ ഉപയോഗിച്ച് പരിഹരിക്കാൻ ന്യായമായ പ്രശ്നങ്ങൾ ഏതാണ്?

ഷെൽ അനുയോജ്യവും ഉപയോഗപ്രദവും ഒഴിച്ചുകൂടാനാവാത്തതുമായ സ്വാഭാവിക ജോലികൾ:

• ടെർമിനലിലെ സംവേദനാത്മക പ്രവർത്തനം:
  • സമാഹാരം നടത്തുക, നിർമ്മാണം വഴി ജോലികൾ നടത്തുക;
  • ടെക്സ്റ്റ് ഫയലുകളുടെ താരതമ്യം;
  • വേഗത്തിലുള്ള അഡ്-ഹോക്ക് ഡാറ്റ വിശകലനം (ലോഗിലെ അദ്വിതീയ ഐപികളുടെ എണ്ണം, മണിക്കൂറുകൾ/മിനിറ്റുകൾ പ്രകാരം റെക്കോർഡുകളുടെ വിതരണം മുതലായവ);
  • ഒറ്റത്തവണ മാസ് പ്രവർത്തനങ്ങൾ (നിരവധി പ്രക്രിയകൾ ഇല്ലാതാക്കുക; നിങ്ങൾ ഒരു പതിപ്പ് നിയന്ത്രണ സംവിധാനത്തിൽ പ്രവർത്തിക്കുകയാണെങ്കിൽ, ഒരു കൂട്ടം ഫയലുകൾ റിവേഴ്സ് ചെയ്യുക അല്ലെങ്കിൽ പരിഹരിക്കുക);
  • സിസ്റ്റത്തിൽ എന്താണ് സംഭവിക്കുന്നതെന്ന് ഡയഗ്നോസ്റ്റിക്സ് (സെമാഫോറുകൾ, ലോക്കുകൾ, പ്രോസസ്സുകൾ, ഡിസ്ക്രിപ്റ്ററുകൾ, ഡിസ്ക് സ്പേസ് മുതലായവ);
• സ്ക്രിപ്റ്റിംഗ്:
  • ഇൻസ്റ്റാളേഷൻ സ്ക്രിപ്റ്റുകൾ, ഇതിനായി നിങ്ങൾക്ക് മറ്റ് വ്യാഖ്യാതാക്കളുടെ സാന്നിധ്യത്തിൽ ആശ്രയിക്കാൻ കഴിയില്ല - ഇത് തുടക്കക്കാർക്കുള്ളതല്ല;
  • ഇന്ററാക്ടീവ് ഷെൽ ഇഷ്‌ടാനുസൃതമാക്കുന്നതിനുള്ള പ്രവർത്തനങ്ങളും (ക്ഷണത്തെ ബാധിക്കുന്നു, ഡയറക്‌ടറി മാറ്റുന്നു, എൻവയോൺമെന്റ് വേരിയബിളുകൾ സജ്ജീകരിക്കുന്നു) തുടക്കക്കാർക്കുള്ളതല്ല;
  • മാസ് ഫയൽ റീകോഡിംഗ് പോലുള്ള ഒറ്റത്തവണ സ്ക്രിപ്റ്റുകൾ;
  • മേക്ക് ഫയലുകൾ.

തികച്ചും ആദ്യ പടികൾ

നമുക്ക് ആരംഭിക്കാം: സൈൻ ഇൻ ചെയ്‌ത് സൈൻ ഔട്ട് ചെയ്യുക

ഷെൽ എങ്ങനെ ആരംഭിക്കണമെന്നും അതിൽ നിന്ന് എങ്ങനെ പുറത്തുകടക്കണമെന്നും കൃത്യമായി അറിയാമെന്ന് ഉറപ്പാക്കുക.

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

MacOS-ൽ - ടെർമിനലും സമാരംഭിക്കുക.

ആക്സസ് ചെയ്യാൻ റിമോട്ട് സെർവർ- ssh (നിങ്ങൾക്ക് MacOS, ഉബുണ്ടു അല്ലെങ്കിൽ പ്രാദേശികമായി യുണിക്സ് പോലുള്ള മറ്റൊരു സിസ്റ്റം ഉണ്ടെങ്കിൽ) അല്ലെങ്കിൽ പുട്ടി (നിങ്ങൾക്ക് വിൻഡോസ് ഉണ്ടെങ്കിൽ) ഉപയോഗിക്കുക.

ഞാൻ ആരാണ്, ഞാൻ എവിടെയാണ്?

ഇനിപ്പറയുന്ന കമാൻഡുകൾ പ്രവർത്തിപ്പിക്കുക:

• ഹോസ്റ്റ്നാമം - നിങ്ങൾ നിലവിൽ ഉള്ള മെഷീന്റെ (സെർവർ) പേര് പ്രദർശിപ്പിക്കുന്നു;
• whoami - നിങ്ങളുടെ ലോഗിൻ പ്രദർശിപ്പിക്കുന്നു (സിസ്റ്റത്തിൽ നിങ്ങളുടെ പേര്);
• ട്രീ-ഡി / |ലെസ്സ് - മെഷീനിലെ ഡയറക്‌ടറി ട്രീയുടെ കപട-ഗ്രാഫിക് പ്രാതിനിധ്യം; സ്ക്രോളിംഗിൽ നിന്ന് പുറത്തുകടക്കുക - q ;
• pwd - നിങ്ങൾ നിലവിൽ ഉള്ള ഡയറക്ടറി പ്രദർശിപ്പിക്കുന്നു; കമാൻഡ് ലൈനിൽ നിങ്ങൾക്ക് "അങ്ങനെ തന്നെ" ആകാൻ കഴിയില്ല, നിങ്ങൾ ഏതെങ്കിലും ഡയറക്ടറിയിലായിരിക്കണം (=നിലവിലെ ഡയറക്ടറി, വർക്കിംഗ് ഡയറക്ടറി). നിലവിലെ പ്രവർത്തിക്കുന്ന ഡയറക്‌ടറി ഒരുപക്ഷേ നിങ്ങളുടെ പ്രോംപ്റ്റിൽ പ്രദർശിപ്പിച്ചിരിക്കാം.
• ls - നിലവിലെ ഡയറക്ടറിയിലെ ഫയലുകളുടെ ലിസ്റ്റ്; ls /home - നിർദ്ദിഷ്ട ഡയറക്ടറിയിലെ ഫയലുകളുടെ ലിസ്റ്റ്;

കമാൻഡ് ഹിസ്റ്ററി (ചരിത്രം)

ഒരു പൂർണ്ണമായ കമാൻഡ് ലൈനിന്റെ ഒരു പ്രധാന സ്വത്ത് കമാൻഡ് ഹിസ്റ്ററിയാണ്.

നിരവധി കമാൻഡുകൾ പ്രവർത്തിപ്പിക്കുക: ഹോസ്റ്റ്നാമം, ls, pwd, whoami. ഇപ്പോൾ അപ്പ് കീ അമർത്തുക. മുമ്പത്തെ കമാൻഡ് ഇൻപുട്ട് ലൈനിൽ ദൃശ്യമാകുന്നു. ചരിത്രത്തിലൂടെ മുന്നോട്ടും പിന്നോട്ടും നീങ്ങാൻ നിങ്ങൾക്ക് മുകളിലേക്കും താഴേക്കുമുള്ള കീകൾ ഉപയോഗിക്കാം. നിങ്ങൾ ഹോസ്റ്റ്നാമത്തിൽ എത്തുമ്പോൾ, എന്റർ അമർത്തുക - കമാൻഡ് വീണ്ടും നടപ്പിലാക്കും.

ചരിത്രത്തിൽ നിന്നുള്ള കമാൻഡുകൾ ആവർത്തിച്ച് നടപ്പിലാക്കാൻ മാത്രമല്ല, എഡിറ്റുചെയ്യാനും കഴിയും. ചരിത്രത്തിലൂടെ ls കമാൻഡിലേക്ക് സ്ക്രോൾ ചെയ്യുക, അതിലേക്ക് -l സ്വിച്ച് ചേർക്കുക (ഇത് ls -l ആയി മാറുന്നു, മൈനസിന് മുമ്പ് ഒരു സ്പേസ് ഉണ്ട്, പക്ഷേ അതിന് ശേഷമല്ല). എന്റർ അമർത്തുക - പരിഷ്കരിച്ച കമാൻഡ് എക്സിക്യൂട്ട് ചെയ്യും.

കമാൻഡ് ലൈനിൽ പ്രവർത്തിക്കുമ്പോൾ ചരിത്രത്തിലൂടെ സ്ക്രോൾ ചെയ്യുക, കമാൻഡുകൾ എഡിറ്റുചെയ്യുക, വീണ്ടും നടപ്പിലാക്കുക എന്നിവയാണ് ഏറ്റവും സാധാരണമായ പ്രവർത്തനങ്ങൾ, അതിനാൽ ഇത് ഉപയോഗിക്കുക.

കോപ്പി-പേസ്റ്റ്

കമാൻഡ് ലൈൻ വളരെ ടെക്സ്റ്റ് കേന്ദ്രീകൃതമാണ്: കമാൻഡുകൾ ടെക്സ്റ്റ് ആണ്, മിക്ക സ്റ്റാൻഡേർഡ് പ്രോഗ്രാമുകളുടെയും ഇൻപുട്ട് ഡാറ്റ ടെക്സ്റ്റ് ആണ്, ഔട്ട്പുട്ട് മിക്കപ്പോഴും ടെക്സ്റ്റ് ആണ്.

ടെക്‌സ്‌റ്റിന്റെ മഹത്തായ കാര്യം അത് പകർത്താനും ഒട്ടിക്കാനും കഴിയും എന്നതാണ്, ഇത് കമാൻഡ് ലൈനിലും ശരിയാണ്.

കമാൻഡ് തീയതി ശ്രമിക്കുക +"%y-%m-%d, %A"
നിങ്ങൾ ഇത് പൂർണ്ണമായും കൈകൊണ്ട് നൽകിയതാണോ അതോ ലേഖനത്തിൽ നിന്ന് പകർത്തിയതാണോ? നിങ്ങൾക്ക് ഇത് പകർത്താനും ടെർമിനലിൽ ഒട്ടിക്കാനും എക്സിക്യൂട്ട് ചെയ്യാനും കഴിയുമെന്ന് ഉറപ്പാക്കുക.

മാൻ എങ്ങനെ ഉപയോഗിക്കാമെന്ന് നിങ്ങൾ പഠിച്ചുകഴിഞ്ഞാൽ, സഹായത്തിൽ നിന്ന് നിങ്ങൾക്ക് ഉദാഹരണ കമാൻഡുകൾ പകർത്തി പ്രവർത്തിപ്പിക്കാൻ കഴിയുമെന്ന് ഉറപ്പാക്കുക. പരിശോധിക്കുന്നതിന്, തീയതി പ്രോഗ്രാമിലെ ഉദാഹരണങ്ങൾ വിഭാഗം നോക്കുക സഹായത്തിന്, നൽകിയിരിക്കുന്ന ആദ്യ ഉദാഹരണം പകർത്തി പ്രവർത്തിപ്പിക്കുക (കേവലം: ഡോളർ ചിഹ്നം കമാൻഡിന്റെ ഭാഗമല്ല , ഇതൊരു ഇൻപുട്ട് പ്രോംപ്റ്റിന്റെ പ്രതീകാത്മക ചിത്രമാണ്).

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

കീകളും ഓപ്ഷനുകളും

നിങ്ങൾ കമാൻഡുകളുടെ ചരിത്രം പര്യവേക്ഷണം ചെയ്തതുപോലെ, ls കമാൻഡിന് കുറഞ്ഞത് രണ്ട് ഓപ്ഷനുകളെങ്കിലും ഉണ്ടെന്ന് നിങ്ങൾ ഇതിനകം നേരിട്ടു. നിങ്ങൾ അതിനെ അങ്ങനെ വിളിക്കുകയാണെങ്കിൽ, അത് ഒരു ലളിതമായ ലിസ്റ്റ് ഔട്ട്പുട്ട് ചെയ്യുന്നു:

Akira@latitude-e7240: ~/shell-survival-quide> ls Makefile shell-first-steps.md shell-first-steps.pdf shell-survival-quide.md shell-survival-quide.pdf
നിങ്ങൾ -l സ്വിച്ച് ചേർക്കുകയാണെങ്കിൽ, ഓരോ ഫയലിനും വിശദമായ വിവരങ്ങൾ പ്രദർശിപ്പിക്കും:

Akira@latitude-e7240: ~/shell-survival-quide> ls -l ആകെ 332 -rw-rw-r-- 1 അകിര അകിര 198 ഫെബ്രുവരി 13 11:48 Makefile -rw-rw-r-- 1 akira akira 15107 ഫെബ്രുവരി 14 22:26 shell-first-steps.md -rw-rw-r-- 1 akira akira 146226 Feb 13 11:49 shell-fist-steps.pdf -rw-rw-r-- 1 akira akira 1613261 Feb :45 shell-survival-quide.md -rw-rw-r-- 1 അകിര അകിര 146203 ഫെബ്രുവരി 13 11:35 shell-survival-quide.pdf
ഇത് വളരെ സാധാരണ സാഹചര്യം: കമാൻഡ് കോളിലേക്ക് പ്രത്യേക മോഡിഫയറുകൾ (കീകൾ, ഓപ്ഷനുകൾ, പാരാമീറ്ററുകൾ) ചേർത്തിട്ടുണ്ടെങ്കിൽ, കമാൻഡിന്റെ സ്വഭാവം മാറുന്നു. താരതമ്യം ചെയ്യുക: വൃക്ഷം / വൃക്ഷം -d / , ഹോസ്റ്റ്നാമം, ഹോസ്റ്റ്നാമം -f .

കൂടാതെ, കമാൻഡുകൾക്ക് ഫയൽ നാമങ്ങൾ, ഡയറക്ടറി നാമങ്ങൾ അല്ലെങ്കിൽ ലളിതമായി എടുക്കാം ടെക്സ്റ്റ് സ്ട്രിംഗുകൾ. ശ്രമിക്കുക:

Ls -ld /home ls -l /home grep root /etc/passwd

മനുഷ്യൻ

മനുഷ്യൻ - നിങ്ങളുടെ മെഷീനിൽ ലഭ്യമായ കമാൻഡുകൾക്കും പ്രോഗ്രാമുകൾക്കും അതുപോലെ സിസ്റ്റം കോളുകൾക്കും സ്റ്റാൻഡേർഡ് സി ലൈബ്രറിയിലും സഹായം.

ശ്രമിക്കുക: man grep , man atoi , man chdir , man man .

മുന്നോട്ടും പിന്നോട്ടും സ്ക്രോൾ ചെയ്യുന്നത് “മുകളിലേക്ക്”, “താഴേക്ക്”, “പേജ്അപ്പ്”, “പേജ്ഡൗൺ” ബട്ടണുകൾ ഉപയോഗിച്ചാണ്, സഹായ കാഴ്‌ചയിൽ നിന്ന് പുറത്തുകടക്കുന്നത് q ബട്ടൺ ഉപയോഗിച്ചാണ്. തിരയുക നിർദ്ദിഷ്ട വാചകംസഹായ ലേഖനത്തിൽ: / (ഫോർവേഡ് സ്ലാഷ്) അമർത്തുക, തിരയാൻ ടെക്സ്റ്റ് നൽകുക, എന്റർ അമർത്തുക. അടുത്ത സംഭവങ്ങളിലേക്ക് നീങ്ങുക - കീ n.

എല്ലാ സഹായ ലേഖനങ്ങളും വിഭാഗങ്ങളായി തിരിച്ചിരിക്കുന്നു. ഏറ്റവും പ്രധാനപ്പെട്ടത്:

• 1 - എക്സിക്യൂട്ടബിൾ പ്രോഗ്രാമുകളും ഷെൽ കമാൻഡുകളും (wc, ls, pwd, മുതലായവ);
• 2 - സിസ്റ്റം കോളുകൾ (ഫോർക്ക്, ഡ്യൂപ്പ്2, മുതലായവ)
• 3 - ലൈബ്രറി പ്രവർത്തനങ്ങൾ (printf, scanf, cos, exec).

പേരുകൾ യാദൃശ്ചികമാകുന്ന സന്ദർഭങ്ങളിൽ ഏത് വിഭാഗത്തിൽ നിന്നാണ് സർട്ടിഫിക്കറ്റ് കാണിക്കേണ്ടതെന്ന് സൂചിപ്പിക്കേണ്ടത് ആവശ്യമാണ്. ഉദാഹരണത്തിന്, man 3 printf ഫംഗ്‌ഷൻ വിവരിക്കുന്നു സാധാരണ ലൈബ്രറി C, and man 1 printf എന്നിവ ഒരേ പേരിലുള്ള ഒരു കൺസോൾ പ്രോഗ്രാമാണ്.

man -k കമാൻഡ് ഉപയോഗിച്ച് നിങ്ങളുടെ മെഷീനിൽ ലഭ്യമായ എല്ലാ സഹായ ലേഖനങ്ങളുടെയും ഒരു ലിസ്റ്റ് നിങ്ങൾക്ക് കാണാൻ കഴിയും. (ഡോട്ട് കോമഡയുടെ ഭാഗമാണ്).

കുറവ്

ഉള്ളപ്പോൾ ചെറിയ ജാലകംടെർമിനൽ വളരെയധികം കാണേണ്ടതുണ്ട് നീണ്ട വാചകം(ചില ഫയലുകളുടെ ഉള്ളടക്കം, ഒരു നീണ്ട മനുഷ്യൻ മുതലായവ), അവർ പ്രത്യേക "പേജർ" പ്രോഗ്രാമുകൾ ഉപയോഗിക്കുന്നു (പേജ് എന്ന വാക്കിൽ നിന്ന്, അതായത് പേജ് ഫ്ലിപ്പറുകൾ). ഏറ്റവും ജനപ്രിയമായ സ്ക്രോളർ കുറവാണ്, നിങ്ങൾ മാൻ പേജുകൾ വായിക്കുമ്പോൾ സ്ക്രോളിംഗ് നൽകുന്നത് ഇതാണ്.

പെരുമാറ്റം താരതമ്യം ചെയ്യാൻ ശ്രമിക്കുക:

പൂച്ച /etc/bash.bashrc cat /etc/bash.bashrc |കുറവ്

നിങ്ങൾക്ക് പാരാമീറ്ററുകളിൽ നേരിട്ട് പേജറിലേക്ക് ഫയൽ കൈമാറാൻ കഴിയും:

കുറവ് /etc/bash.bashrc

മുകളിലേക്കും താഴേക്കും സ്ക്രോൾ ചെയ്യുന്നു - ബട്ടണുകൾ "അപ്പ്", "ഡൗൺ", "പേജ്അപ്പ്", "പേജ്ഡൗൺ", എക്സിറ്റ് - ബട്ടൺ q. നിർദ്ദിഷ്ട വാചകത്തിനായി തിരയുക: / (ഫോർവേഡ് സ്ലാഷ്) അമർത്തുക, തിരയാൻ വാചകം നൽകുക, എന്റർ അമർത്തുക. അടുത്ത സംഭവങ്ങളിലേക്ക് നീങ്ങുക - കീ n. (മനുഷ്യനെ കുറിച്ചുള്ള നിർദ്ദേശങ്ങൾ നിങ്ങൾ തിരിച്ചറിയുന്നുണ്ടോ? അത്ഭുതപ്പെടാനില്ല, സഹായം പ്രദർശിപ്പിക്കാനും ഇത് കുറവാണ്.)

അവകാശങ്ങൾ

ഏതെങ്കിലും ഫയലോ ഡയറക്ടറിയോ "അവകാശങ്ങളുടെ" ഒരു കൂട്ടവുമായി ബന്ധപ്പെട്ടിരിക്കുന്നു: ഫയൽ വായിക്കാനുള്ള അവകാശം, ഫയലിലേക്ക് എഴുതാനുള്ള അവകാശം, ഫയൽ എക്സിക്യൂട്ട് ചെയ്യാനുള്ള അവകാശം. എല്ലാ ഉപയോക്താക്കളെയും മൂന്ന് വിഭാഗങ്ങളായി തിരിച്ചിരിക്കുന്നു: ഫയൽ ഉടമ, ഫയൽ ഉടമ ഗ്രൂപ്പ്, മറ്റ് എല്ലാ ഉപയോക്താക്കളും.

നിങ്ങൾക്ക് ls -l ഉപയോഗിച്ച് ഫയൽ അനുമതികൾ കാണാൻ കഴിയും. ഉദാഹരണത്തിന്:

> ls -l Makefile -rw-r--r-- 1 അകിര വിദ്യാർത്ഥികൾ 198 ഫെബ്രുവരി 13 11:48 Makefile
ഈ ഔട്ട്‌പുട്ട് അർത്ഥമാക്കുന്നത് ഉടമയ്ക്ക് (അകിര) ഫയൽ വായിക്കാനും എഴുതാനും കഴിയും, ഗ്രൂപ്പിന് (വിദ്യാർത്ഥികൾക്ക്) മാത്രമേ വായിക്കാൻ കഴിയൂ, മറ്റ് എല്ലാ ഉപയോക്താക്കൾക്കും വായിക്കാൻ മാത്രമേ കഴിയൂ എന്നാണ്.

ജോലി ചെയ്യുമ്പോൾ നിങ്ങൾക്ക് അനുമതി നിഷേധിച്ച സന്ദേശം ലഭിക്കുകയാണെങ്കിൽ, നിങ്ങൾ പ്രവർത്തിക്കാൻ ആഗ്രഹിക്കുന്ന ഒബ്‌ജക്‌റ്റിൽ നിങ്ങൾക്ക് മതിയായ അവകാശങ്ങൾ ഇല്ലെന്നാണ് ഇതിനർത്ഥം.

man chmod-ൽ കൂടുതൽ വായിക്കുക.

STDIN, STDOUT, കൺവെയറുകൾ (പൈപ്പുകൾ)

പ്രവർത്തിക്കുന്ന ഓരോ പ്രോഗ്രാമുമായും ബന്ധപ്പെട്ടിരിക്കുന്നു 3 സാധാരണ ഒഴുക്ക്ഡാറ്റ: ഇൻപുട്ട് ഡാറ്റ സ്ട്രീം STDIN, ഔട്ട്പുട്ട് ഡാറ്റ സ്ട്രീം STDOUT, പിശക് ഔട്ട്പുട്ട് സ്ട്രീം STDERR.

wc പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കുക, Good day today എന്ന ടെക്‌സ്‌റ്റ് നൽകുക, Enter അമർത്തുക, നല്ല ദിവസം എന്ന വാചകം നൽകുക, Enter അമർത്തുക, Ctrl+d അമർത്തുക. നിങ്ങളുടെ വാചകത്തിലും അവസാനത്തിലും ഉള്ള അക്ഷരങ്ങളുടെയും വാക്കുകളുടെയും വരികളുടെയും എണ്ണം സംബന്ധിച്ച സ്ഥിതിവിവരക്കണക്കുകൾ wc പ്രോഗ്രാം കാണിക്കും:

> wc നല്ല ദിവസം ഇന്ന് നല്ല ദിവസം 2 5 24
ഈ സാഹചര്യത്തിൽ, പ്രോഗ്രാമിന്റെ STDIN-ലേക്ക് നിങ്ങൾ രണ്ട്-വരി ടെക്‌സ്‌റ്റ് നൽകി, കൂടാതെ STDOUT-ൽ മൂന്ന് നമ്പറുകൾ ലഭിച്ചു.

ഇപ്പോൾ head -n3 /etc/passwd എന്ന കമാൻഡ് പ്രവർത്തിപ്പിക്കുക, ഇത് ഇതുപോലെയായിരിക്കണം:

> head -n3 /etc/passwd root:x:0:0:root:/root:/bin/bash deemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin bin:x: 2:2:bin:/bin:/usr/sbin/nologin
ഈ സാഹചര്യത്തിൽ, ഹെഡ് പ്രോഗ്രാം STDIN-ൽ നിന്ന് ഒന്നും വായിച്ചില്ല, എന്നാൽ STDOUT-ലേക്ക് മൂന്ന് വരികൾ എഴുതി.

നിങ്ങൾക്ക് ഇത് ഇങ്ങനെ സങ്കൽപ്പിക്കാൻ കഴിയും: പ്രോഗ്രാം STDIN ഒഴുകുകയും STDOUT പുറത്തേക്ക് ഒഴുകുകയും ചെയ്യുന്ന ഒരു പൈപ്പാണ്.

Unix കമാൻഡ് ലൈനിന്റെ ഏറ്റവും പ്രധാനപ്പെട്ട സ്വത്ത് "പൈപ്പ്" പ്രോഗ്രാമുകൾ പരസ്പരം ബന്ധിപ്പിക്കാൻ കഴിയും എന്നതാണ്: ഒരു പ്രോഗ്രാമിന്റെ ഔട്ട്പുട്ട് (STDOUT) മറ്റൊരു പ്രോഗ്രാമിലേക്ക് ഇൻപുട്ട് ഡാറ്റയായി (STDIN) കൈമാറാൻ കഴിയും.

ബന്ധിപ്പിച്ച പ്രോഗ്രാമുകളുടെ അത്തരം നിർമ്മാണത്തെ ഇംഗ്ലീഷിൽ പൈപ്പ് അല്ലെങ്കിൽ റഷ്യൻ ഭാഷയിൽ ഒരു കൺവെയർ അല്ലെങ്കിൽ പൈപ്പ് എന്ന് വിളിക്കുന്നു.

ഒരു പൈപ്പ് ലൈനിലേക്ക് പ്രോഗ്രാമുകൾ സംയോജിപ്പിക്കുന്നത് | ചിഹ്നം ഉപയോഗിച്ചാണ് ചെയ്യുന്നത് (ലംബ ബാർ)

head -n3 /etc/passwd |wc കമാൻഡ് പ്രവർത്തിപ്പിക്കുക, ഇത് ഇതുപോലെ കാണപ്പെടും:

> head -n3 /etc/passwd |wc 3 3 117
എന്താണ് സംഭവിച്ചത്: ഹെഡ് പ്രോഗ്രാം STDOUT-ൽ മൂന്ന് വരി ടെക്‌സ്‌റ്റ് ഔട്ട്‌പുട്ട് ചെയ്യുന്നു, അത് ഉടനടി wc പ്രോഗ്രാമിന്റെ ഇൻപുട്ടിലേക്ക് പോയി, അത് ഫലമായുണ്ടാകുന്ന വാചകത്തിലെ പ്രതീകങ്ങളുടെയും വാക്കുകളുടെയും വരികളുടെയും എണ്ണം കണക്കാക്കുന്നു.

നിങ്ങൾക്ക് ഇഷ്ടമുള്ളത്ര പ്രോഗ്രാമുകൾ ഒരു പൈപ്പ്ലൈനിലേക്ക് സംയോജിപ്പിക്കാം. ഉദാഹരണത്തിന്, നിങ്ങൾക്ക് മുമ്പത്തെ പൈപ്പ്ലൈനിലേക്ക് മറ്റൊരു wc പ്രോഗ്രാം ചേർക്കാൻ കഴിയും, അത് ആദ്യത്തെ wc-യുടെ ഔട്ട്പുട്ടിൽ എത്ര വാക്കുകളും അക്ഷരങ്ങളും ഉണ്ടെന്ന് കണക്കാക്കും:

> head -n3 /etc/passwd |wc |wc 1 3 24

കമാൻഡ് ലൈനിൽ പ്രവർത്തിക്കുമ്പോൾ പൈപ്പ്ലൈനുകൾ (പൈപ്പുകൾ) സൃഷ്ടിക്കുന്നത് വളരെ സാധാരണമായ ഒരു ജോലിയാണ്. ഇത് പ്രായോഗികമായി എങ്ങനെ ചെയ്യപ്പെടുന്നു എന്നതിന്റെ ഒരു ഉദാഹരണത്തിനായി, "ഒരു ലൈനർ പൈപ്പ്ലൈൻ സൃഷ്ടിക്കുന്നു" എന്ന വിഭാഗം വായിക്കുക.

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

ഒരു പ്രോഗ്രാമിന്റെ ഔട്ട്‌പുട്ട് (STDOUT) ഒരു പൈപ്പ്‌ലൈൻ വഴി മറ്റൊരു പ്രോഗ്രാമിലേക്ക് മാറ്റാൻ മാത്രമല്ല, ഒരു ഫയലിലേക്ക് ലളിതമായി എഴുതാനും കഴിയും. ഈ തിരിച്ചുവിടൽ > (ചിഹ്നത്തേക്കാൾ വലുത്) ഉപയോഗിച്ചാണ് ചെയ്യുന്നത്:

തീയതി > /tmp/today.txt
ഈ കമാൻഡ് എക്സിക്യൂട്ട് ചെയ്യുന്നതിന്റെ ഫലമായി, /tmp/today.txt ഫയൽ ഡിസ്കിൽ ദൃശ്യമാകും. cat /tmp/today.txt ഉപയോഗിച്ച് അതിന്റെ ഉള്ളടക്കങ്ങൾ കാണുക

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

നിങ്ങൾക്ക് ഒരു ഫയൽ തിരുത്തിയെഴുതാൻ താൽപ്പര്യമില്ലെങ്കിൽ, അതിന്റെ അവസാനം ഔട്ട്പുട്ട് ചേർക്കുക, >> : ഉപയോഗിക്കുക

തീയതി >> /tmp/today.txt
ഫയലിൽ ഇപ്പോൾ എന്താണ് എഴുതിയിരിക്കുന്നതെന്ന് പരിശോധിക്കുക.

കൂടാതെ, നിങ്ങൾക്ക് STDIN-ന് പകരം ഏത് ഫയലും പ്രോഗ്രാമിലേക്ക് കൈമാറാം. ശ്രമിക്കുക:

സ്വാഗതം

എന്തെങ്കിലും അവ്യക്തമാകുമ്പോൾ എന്തുചെയ്യണം

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

• കഴിയുന്നത്ര വ്യക്തമായി, ചോദ്യമോ ചുമതലയോ രൂപപ്പെടുത്തുക - “എനിക്ക് എന്താണെന്ന് അറിയാത്തത്” പരിഹരിക്കുന്നതിനേക്കാൾ ബുദ്ധിമുട്ടുള്ള മറ്റൊന്നില്ല;
• നിങ്ങൾ ഇതിനകം സമാനമോ സമാനമോ ആയ പ്രശ്നം നേരിട്ടിട്ടുണ്ടെങ്കിൽ ഓർക്കുക - ഈ സാഹചര്യത്തിൽ, കഴിഞ്ഞ തവണ പ്രവർത്തിച്ച പരിഹാരം പരീക്ഷിക്കുന്നത് മൂല്യവത്താണ്;
• ഉചിതമായ മാൻ പേജുകൾ വായിക്കുക (നിങ്ങളുടെ കാര്യത്തിൽ ഏതൊക്കെ മാൻ പേജുകളാണ് അനുയോജ്യമെന്ന് നിങ്ങൾ മനസ്സിലാക്കുന്നുവെങ്കിൽ) - കമാൻഡുകൾ, ആവശ്യമായ ഓപ്ഷനുകൾ അല്ലെങ്കിൽ മറ്റ് കമാൻഡുകളിലേക്കുള്ള ലിങ്കുകൾ ഉപയോഗിക്കുന്നതിന് അനുയോജ്യമായ ഉദാഹരണങ്ങൾ നിങ്ങൾ കണ്ടെത്തും;
• ചിന്തിക്കുക: ചുമതല അല്പം മാറ്റാൻ കഴിയുമോ? - ഒരുപക്ഷേ, വ്യവസ്ഥകൾ ചെറുതായി മാറ്റുന്നതിലൂടെ, എങ്ങനെ പരിഹരിക്കണമെന്ന് നിങ്ങൾക്ക് ഇതിനകം അറിയാവുന്ന ഒരു പ്രശ്നം നിങ്ങൾക്ക് ലഭിക്കും;
• ഒരു സെർച്ച് എഞ്ചിനിൽ നിങ്ങളുടെ വ്യക്തമായി രൂപപ്പെടുത്തിയ ചോദ്യം ചോദിക്കുക - ഒരുപക്ഷേ ഉത്തരം സ്റ്റാക്ക് ഓവർഫ്ലോയിലോ മറ്റ് സൈറ്റുകളിലോ കണ്ടെത്താം;

മുകളിൽ പറഞ്ഞതൊന്നും സഹായിക്കുന്നില്ലെങ്കിൽ, ഒരു അധ്യാപകനിൽ നിന്നോ പരിചയസമ്പന്നനായ സഹപ്രവർത്തകനിൽ നിന്നോ സുഹൃത്തിൽ നിന്നോ ഉപദേശം തേടുക. "വിഡ്ഢിത്തം" ചോദ്യങ്ങൾ ചോദിക്കാൻ ഭയപ്പെടരുത് - അറിയാത്തത് നാണക്കേടല്ല, ചോദിക്കാത്തത് ലജ്ജാകരമാണ്.

നിങ്ങൾ ഒരു ബുദ്ധിമുട്ടുള്ള പ്രശ്നം പരിഹരിക്കുകയാണെങ്കിൽ (സ്വന്തമായി, ഇന്റർനെറ്റിന്റെയോ മറ്റ് ആളുകളുടെയോ സഹായത്തോടെ), നിങ്ങൾക്കോ ​​നിങ്ങളുടെ സുഹൃത്തുക്കൾക്കോ ​​വീണ്ടും അതേ പ്രശ്നം ഉണ്ടായാൽ നിങ്ങളുടെ പരിഹാരം എഴുതുക. നിങ്ങൾക്ക് ഇത് ഒരു ലളിതമായ ടെക്സ്റ്റ് ഫയലിൽ, Evernote-ൽ റെക്കോർഡ് ചെയ്യാം അല്ലെങ്കിൽ സോഷ്യൽ നെറ്റ്‌വർക്കുകളിൽ പ്രസിദ്ധീകരിക്കാം.

പ്രവർത്തന രീതികൾ

പകര്ത്തി ഒട്ടിക്കുക- മാൻ പേജുകളിൽ നിന്ന്, StackOverflow എന്നതിലെ ലേഖനങ്ങളിൽ നിന്ന്, കമാൻഡ് ലൈനിൽ വാചകം അടങ്ങിയിരിക്കുന്നു, ഇത് പ്രയോജനപ്പെടുത്തുക: ഉദാഹരണ കമാൻഡുകൾ പകർത്തി ഉപയോഗിക്കുക, വിജയകരമായ കണ്ടെത്തലുകൾ ഒരു ഓർമ്മയായി എഴുതുക, ട്വിറ്ററിലും ബ്ലോഗുകളിലും പ്രസിദ്ധീകരിക്കുക.

ചരിത്രത്തിൽ നിന്ന് മുമ്പത്തെ കമാൻഡ് വലിക്കുക, പൈപ്പ്ലൈനിലേക്ക് മറ്റൊരു കമാൻഡ് ചേർക്കുക, പ്രവർത്തിപ്പിക്കുക, ആവർത്തിക്കുക.സെമി. "ഒരു ഒറ്റ ലൈനർ പൈപ്പ്ലൈൻ സൃഷ്ടിക്കൽ" എന്ന വിഭാഗവും കാണുക.

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

• മറ്റൊരു ഡയറക്ടറിയിലേക്ക് മാറ്റുക: cd ;
• ഫയലുകളുടെ ഉള്ളടക്കം കാണുന്നത്: പൂച്ച, കുറവ്, തല, വാൽ;
• ഫയൽ കൃത്രിമത്വം: cp, mv, rm;
• ഡയറക്ടറി ഉള്ളടക്കങ്ങൾ കാണുന്നു: ls , ls -l , ls -lS ;
• ഡയറക്ടറി ഘടന: ട്രീ , ട്രീ -ഡി (ഡയറക്‌ടറി ഒരു പാരാമീറ്ററായി കൈമാറാം);
• ഫയലുകൾക്കായി തിരയുക: കണ്ടെത്തുക. -പേര് ...;

അനലിറ്റിക്സ്

• wc, wc -l;
• sort -k - നിർദ്ദിഷ്ട ഫീൽഡ് അനുസരിച്ച് അടുക്കുക;
• അടുക്കുക -n - സംഖ്യാ ക്രമപ്പെടുത്തൽ;
• വ്യത്യാസം - ഫയൽ താരതമ്യം;
• grep , grep -v , grep -w , grep "\ " , grep -E - വാചകത്തിനായി തിരയുക;
• uniq, uniq -c - സ്ട്രിംഗ് അദ്വിതീയമാക്കൽ;
• awk - awk "($1 പ്രിന്റ് ചെയ്യുക)" ഓപ്ഷനിൽ, ഓരോ വരിയിൽ നിന്നും ആദ്യ ഫീൽഡ് മാത്രം വിടാൻ, $1 എന്നത് $2, $3 എന്നിങ്ങനെ മാറ്റാവുന്നതാണ്.

സിസ്റ്റം ഡയഗ്നോസ്റ്റിക്സ്

• ps axuww - മെഷീനിൽ പ്രവർത്തിക്കുന്ന പ്രക്രിയകളെക്കുറിച്ചുള്ള വിവരങ്ങൾ (പ്രോഗ്രാമുകൾ പ്രവർത്തിപ്പിക്കുന്നു);
• മുകളിൽ - ഏറ്റവും റിസോഴ്സ്-ഇന്റൻസീവ് പ്രക്രിയകളുടെ സംവേദനാത്മക കാഴ്ച;
• df - ഉപയോഗിച്ചതും സ്വതന്ത്ര ഡിസ്ക് സ്പേസും;
• du - ഡയറക്‌ടറിയിലെ ഫയലുകളുടെ ആകെ വലുപ്പം (ഉപ ഡയറക്‌ടറികൾക്കൊപ്പം ആവർത്തിച്ച്);
• സ്‌ട്രേസ്, കെട്രേസ് - പ്രോസസ് എന്ത് സിസ്റ്റം വിളിക്കുന്നു;
• lsof - പ്രോസസ്സ് ഉപയോഗിക്കുന്ന ഫയലുകൾ;
• netstat -na, netstat -nap - ഏത് പോർട്ടുകളും സോക്കറ്റുകളും സിസ്റ്റത്തിൽ തുറന്നിരിക്കുന്നു.

നിങ്ങൾക്ക് ചില പ്രോഗ്രാമുകൾ ഇല്ലായിരിക്കാം; അവ അധികമായി ഇൻസ്റ്റാൾ ചെയ്യേണ്ടതുണ്ട്. കൂടാതെ, ഈ പ്രോഗ്രാമുകളുടെ ചില ഓപ്ഷനുകൾ പ്രത്യേക ഉപയോക്താക്കൾക്ക് മാത്രമേ ലഭ്യമാകൂ (റൂട്ട്).

ബൾക്ക്, സെമി-ഓട്ടോമാറ്റിക് എക്സിക്യൂഷൻ

ആദ്യം, ഈ വിഭാഗം ഒഴിവാക്കുക; നിങ്ങൾ ലളിതമായ ഷെൽ സ്ക്രിപ്റ്റിംഗിൽ എത്തുമ്പോൾ നിങ്ങൾക്ക് ഈ കമാൻഡുകളും നിർമ്മാണങ്ങളും ആവശ്യമാണ്.

• ടെസ്റ്റ് - പരിശോധന വ്യവസ്ഥകൾ;
• വായിക്കുമ്പോൾ - ലൂപ്പ് ലൈൻ ബൈ ലൈൻ STDIN ;
• xargs - STDIN-ൽ നിന്നുള്ള സ്ട്രിംഗുകൾ നിർദ്ദിഷ്ട പ്രോഗ്രാമിന്റെ പാരാമീറ്ററുകളിലേക്ക് മാറ്റിസ്ഥാപിക്കൽ;
• seq - സ്വാഭാവിക സംഖ്യകളുടെ ശ്രേണികളുടെ തലമുറ;
• () - നിരവധി കമാൻഡുകളുടെ ഔട്ട്പുട്ട് കൂട്ടിച്ചേർക്കുക;
• ; - ഒന്നിനുപുറകെ ഒന്നായി ചെയ്യുക;
• && - ആദ്യ കമാൻഡ് വിജയകരമായി പൂർത്തിയാക്കിയാൽ എക്സിക്യൂട്ട് ചെയ്യുക;
• || - ആദ്യ കമാൻഡ് പരാജയപ്പെട്ടാൽ എക്സിക്യൂട്ട് ചെയ്യുക;
• tee - പ്രോഗ്രാം ഔട്ട്പുട്ട് STDOUT ലേക്ക് ഡ്യൂപ്ലിക്കേറ്റ് ഡിസ്കിലെ ഒരു ഫയലിലേക്ക്.

വിവിധ

• തീയതി - നിലവിലെ തീയതി;
• curl - നിർദ്ദിഷ്ട url-ൽ നിന്ന് ഒരു പ്രമാണം ഡൗൺലോഡ് ചെയ്യുകയും ഫലം STDOUT-ലേക്ക് എഴുതുകയും ചെയ്യുന്നു;
• ടച്ച് - അപ്ഡേറ്റ് ഫയൽ പരിഷ്ക്കരണ തീയതി;
• കൊല്ലുക - പ്രക്രിയയിലേക്ക് ഒരു സിഗ്നൽ അയയ്ക്കുക;
• സത്യം - ഒന്നും ചെയ്യുന്നില്ല, സത്യമായി തിരികെ നൽകുന്നു, ശാശ്വത ലൂപ്പുകൾ സംഘടിപ്പിക്കുന്നതിന് ഉപയോഗപ്രദമാണ്;
• sudo - കമാൻഡ് റൂട്ട് "a ആയി നടപ്പിലാക്കുക.

ഒരു ഒറ്റ-ലൈനർ പൈപ്പ്ലൈൻ സൃഷ്ടിക്കുന്നു

ഒരു യഥാർത്ഥ ടാസ്‌ക്കിന്റെ ഒരു ഉദാഹരണം നോക്കാം: നിലവിലെ ഉപയോക്താവായി പ്രവർത്തിക്കുന്ന എല്ലാ ടാസ്‌ക്-6-സെർവർ പ്രോസസ്സുകളും ഞങ്ങൾ ഇല്ലാതാക്കേണ്ടതുണ്ട്.

ഘട്ടം 1.
ഏത് പ്രോഗ്രാമാണ് അതിന്റെ ശുദ്ധമായ രൂപത്തിലല്ലെങ്കിൽപ്പോലും, ഏകദേശം ആവശ്യമായ ഡാറ്റ നിർമ്മിക്കുന്നത് എന്ന് മനസ്സിലാക്കുക. ഞങ്ങളുടെ ചുമതലയ്ക്കായി, സിസ്റ്റത്തിലെ എല്ലാ പ്രക്രിയകളുടെയും ഒരു ലിസ്റ്റ് ലഭിക്കുന്നത് മൂല്യവത്താണ്: ps axuww. ലോഞ്ച്.

ഘട്ടം 2.
നിങ്ങളുടെ കണ്ണുകളാൽ ലഭിച്ച ഡാറ്റ നോക്കുക, അനാവശ്യമായ ചില ഡാറ്റ വലിച്ചെറിയുന്ന ഒരു ഫിൽട്ടർ കൊണ്ടുവരിക. ഇത് പലപ്പോഴും grep അല്ലെങ്കിൽ grep -v ആണ്. ചരിത്രത്തിൽ നിന്ന് മുമ്പത്തെ കമാൻഡ് പുറത്തെടുക്കാൻ "അപ്പ്" കീ ഉപയോഗിക്കുക, അതിലേക്ക് ഒരു കണ്ടുപിടിച്ച ഫിൽട്ടർ നൽകുകയും അത് പ്രവർത്തിപ്പിക്കുകയും ചെയ്യുക.

Ps axuww |grep `woami`
- നിലവിലെ ഉപയോക്താവിന്റെ മാത്രം പ്രക്രിയകൾ.

ഘട്ടം 3.
നിങ്ങൾക്ക് ആവശ്യമുള്ള ക്ലീൻ ഡാറ്റ ലഭിക്കുന്നതുവരെ ഘട്ടം 2 ആവർത്തിക്കുക.

"
- ആവശ്യമായ പേരുള്ള എല്ലാ പ്രക്രിയകളും (കൂടാതെ, ഒരുപക്ഷേ, vim task-6-server.c, മുതലായവ)

Ps axuww |grep `whoami` | grep "\ " | grep -v vim ps axuww |grep `whoami` | grep "\ " | grep -v vim |grep -v കുറവ്
- ആവശ്യമായ പേരിലുള്ള പ്രക്രിയകൾ മാത്രം

Ps axuww |grep `whoami` | grep "\ " | grep -v vim |grep -v കുറവ് |awk "($2 അച്ചടിക്കുക)"

ആവശ്യമായ പ്രക്രിയകളുടെ പിഡുകൾ, ഘട്ടം 3 പൂർത്തിയായി

ഘട്ടം 4.
അനുയോജ്യമായ ഒരു അന്തിമ ഹാൻഡ്ലർ പ്രയോഗിക്കുക. "അപ്പ്" കീ ഉപയോഗിച്ച്, ഞങ്ങൾ ചരിത്രത്തിൽ നിന്ന് മുമ്പത്തെ കമാൻഡ് പുറത്തെടുത്ത് പ്രശ്നത്തിനുള്ള പരിഹാരം പൂർത്തിയാക്കുന്ന പ്രോസസ്സിംഗ് ചേർക്കുക:

• പ്രക്രിയകളുടെ എണ്ണം കണക്കാക്കാൻ |wc -l;
• >പിഡുകൾ ഒരു ഫയലിലേക്ക് പിഡുകൾ എഴുതാൻ;
• |xargs kill -9 കിൽ പ്രക്രിയകൾ.

പരിശീലന ജോലികൾ

പുതിയ കഴിവുകൾ പരിശീലിക്കാൻ ആഗ്രഹിക്കുന്നുണ്ടോ? ഇനിപ്പറയുന്ന ജോലികൾ പരീക്ഷിക്കുക:

• നിങ്ങളുടെ ഹോം ഡയറക്ടറിയിലെ എല്ലാ ഫയലുകളുടെയും ഡയറക്ടറികളുടെയും ഒരു ലിസ്റ്റ് നേടുക;
• വിഭാഗം 2 (സിസ്റ്റം കോളുകൾ) ൽ നിന്നുള്ള എല്ലാ മനുഷ്യ ലേഖനങ്ങളുടെയും ഒരു ലിസ്റ്റ് നേടുക;
• grep പ്രോഗ്രാമിന്റെ മാൻ പേജിൽ grep എന്ന വാക്ക് എത്ര തവണ പ്രത്യക്ഷപ്പെടുന്നുവെന്ന് എണ്ണുക;
• നിലവിൽ എത്ര പ്രോസസ്സുകൾ പ്രവർത്തിക്കുന്നുണ്ടെന്ന് കണക്കാക്കുക റൂട്ട് ഉപയോക്താവ് ;
• പരമാവധി സഹായ വിഭാഗങ്ങളിൽ (മാൻ) ദൃശ്യമാകുന്ന കമാൻഡ് കണ്ടെത്തുക;
• ya.ru എന്ന പേജിൽ var എന്ന വാക്ക് എത്ര തവണ പ്രത്യക്ഷപ്പെടുന്നുവെന്ന് എണ്ണുക.

സൂചന: നിങ്ങൾ കണ്ടെത്തേണ്ടതുണ്ട് , grep-o , awk "($1 പ്രിന്റ് ചെയ്യുക)" , grep , curl -s ലെ പതിവ് പദപ്രയോഗങ്ങൾ .

ഇനി എന്ത് പഠിക്കണം?

നിങ്ങൾ കമാൻഡ് ലൈൻ ഇഷ്ടപ്പെടാൻ തുടങ്ങിയാൽ, നിർത്തരുത്, നിങ്ങളുടെ കഴിവുകൾ മെച്ചപ്പെടുത്തുന്നത് തുടരുക.

നിങ്ങൾ കമാൻഡ് ലൈനിൽ താമസിക്കുന്നെങ്കിൽ തീർച്ചയായും ഉപയോഗപ്രദമാകുന്ന ചില പ്രോഗ്രാമുകൾ ഇതാ:

• സങ്കീർണ്ണമായ ഓപ്ഷനുകൾ ഉപയോഗിച്ച് കണ്ടെത്തുക
• ഉചിതം
• കണ്ടെത്തുക
• ടെൽനെറ്റ്
• നെറ്റ്കാറ്റ്
• tcpdump
• rsync
• സ്ക്രീൻ
• zgrep, zless
• വിസുഡോ
• ക്രോണ്ടാബ് -ഇ
• മെയിൽ അയയ്ക്കുക

കൂടാതെ, കാലക്രമേണ, പേൾ അല്ലെങ്കിൽ പൈത്തൺ അല്ലെങ്കിൽ അവ രണ്ടും പോലെയുള്ള ഏതെങ്കിലും തരത്തിലുള്ള സ്ക്രിപ്റ്റിംഗ് ഭാഷയിൽ പ്രാവീണ്യം നേടുന്നത് മൂല്യവത്താണ്.

ആർക്കാണ് ഇത് വേണ്ടത്?

ഇന്ന് കമാൻഡ് ലൈനും ഷെൽ സ്ക്രിപ്റ്റിംഗും പഠിക്കുന്നത് മൂല്യവത്താണോ? തീർച്ചയായും അത് വിലമതിക്കുന്നു. FB-യിൽ ജോലി നേടാൻ ആഗ്രഹിക്കുന്ന ഉദ്യോഗാർത്ഥികൾക്കായി Facebook-ന്റെ ആവശ്യകതകളുടെ ഏതാനും ഉദാഹരണങ്ങൾ ഞാൻ തരാം.

=====================================================

ലബോറട്ടറി വർക്ക് നമ്പർ 1 (പൂർത്തിയാക്കാനുള്ള സമയം - 3 മണിക്കൂർ)

വിഷയം: "ആമുഖംഷെൽ”

1. ഷെല്ലിലേക്കുള്ള ആമുഖം

ഷെൽ ഒരു കമാൻഡ് ഇന്റർപ്രെറ്റർ (കമാൻഡ് പ്രോസസർ) ആണ്, അത് ഉപയോക്താവിനും യുണിക്സ് കേർണലിനും ഇടയിലുള്ള ഒരു ഇന്റർഫേസായി പ്രവർത്തിക്കുന്നു. സോളാരിസ് മൂന്ന് പ്രധാന കമാൻഡ് പ്രോസസ്സറുകൾ വാഗ്ദാനം ചെയ്യുന്നു:

സ്ഥിരസ്ഥിതി Bourne ഷെൽ /sbin/sh ആണ്

സി കമാൻഡ് പ്രോസസർ -- /bin/csh

കോർൺ ഷെൽ-- ./bin/ksh

ലിസ്റ്റുചെയ്തവ കൂടാതെ, സോളാരിസ് അധിക ഷെല്ലുകൾ നൽകുന്നു:

ജെ ഷെൽ -- /sbin/jsh

നിയന്ത്രിത കോർൺ l -- / usr/ബിൻ/rsh

ടി-ഷെൽ -- /usr/bin/tcsh

GNU Bourne Again -- /usr/bin/bash

Z-shell - usr/bin/zsh

കമാൻഡ് പ്രൊസസറിന്റെ തിരഞ്ഞെടുപ്പ് വ്യക്തിപരമായ മുൻഗണനയുടെ കാര്യമാണ്.

2. കമാൻഡുകൾ പ്രവർത്തിപ്പിക്കുക

Unix-ലെ ഏത് കമാൻഡിലും സമാരംഭിക്കേണ്ട പ്രോഗ്രാമിന്റെ പേര് (കമാൻഡ്), ഓപ്ഷനുകൾ (കീകൾ), പ്രോഗ്രാമിലേക്ക് കൈമാറിയ ആർഗ്യുമെന്റുകൾ എന്നിവ അടങ്ങിയിരിക്കുന്നു. കമാൻഡ് ലൈൻ സ്‌പെയ്‌സുകളോ ടാബുകളോ ഉപയോഗിച്ച് വേർതിരിച്ചിരിക്കുന്നു.

ഉദാഹരണം

$ /bin/ping –t 10 192.168.2.13

വാദം

ഷെൽ ക്ഷണം

ഒരു പ്രോഗ്രാം ആരംഭിക്കുമ്പോൾ എക്സിക്യൂട്ടബിൾ ഫയലിലേക്കുള്ള പാത വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ, PATH വേരിയബിളിൽ വ്യക്തമാക്കിയിട്ടുള്ള ഡയറക്ടറികളിലൂടെ OS തുടർച്ചയായി നോക്കുന്നു. കാണുന്ന ഡയറക്‌ടറിയിൽ അതേ പേരിലുള്ള ഒരു പ്രോഗ്രാം ഉണ്ടെങ്കിൽ, അത് എക്‌സിക്യൂഷനായി സമാരംഭിക്കും. PATH വേരിയബിളിൽ വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ, നിലവിലെ പ്രവർത്തന ഡയറക്ടറി പ്രോഗ്രാമുകൾക്കായി തിരയില്ല.

! സുരക്ഷാ കാരണങ്ങളാൽ, ഉപയോക്താവിന്റെ നിലവിലെ ഡയറക്ടറിയും ഹോം (വ്യക്തിഗത) ഡയറക്‌ടറികളും PATH വേരിയബിളിലേക്ക് ചേർക്കരുതെന്ന് അഡ്‌മിനിസ്‌ട്രേറ്റർ ശുപാർശ ചെയ്യുന്നു.

ഉദാഹരണങ്ങൾ

മുഴുവൻ പാതയും വ്യക്തമാക്കുന്ന ഒരു പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കുക

$ / usr/ പ്രാദേശികമായ/ ബിൻ/ ente_ പ്രോഗ്രാം

ഉയർന്ന (രക്ഷാകർതൃ) ഡയറക്ടറിയിൽ നിന്ന് ഒരു പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കുന്നു

$ ../ പ്രാദേശികമായ/ ബിൻ/ ente_ പ്രോഗ്രാം

നിലവിലെ ഡയറക്ടറിയിൽ നിന്ന് ഒരു പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കുന്നു

$ ./ ente_ പ്രോഗ്രാം

3. ഷെല്ലിലെ പ്രത്യേക പ്രതീകങ്ങൾ

ചില ഷെൽ പ്രതീകങ്ങൾക്ക് പ്രത്യേക അർത്ഥമുണ്ട്.

3.1 ഫയൽ നാമം ജനറേഷൻ ടെംപ്ലേറ്റുകൾ

? (ചോദ്യചിഹ്നം)ആദ്യത്തെ ഡോട്ട് ഒഴികെ ഏതെങ്കിലും ഒരു പ്രതീകവുമായി പൊരുത്തപ്പെടുന്നു;

(ചതുര ബ്രാക്കറ്റുകൾ)ഒരു കൂട്ടം ചിഹ്നങ്ങൾ നിർവ്വചിക്കുക (ഗ്രൂപ്പിൽ നിന്ന് ഒരു ചിഹ്നം തിരഞ്ഞെടുത്തു);

- (മൈനസ് ചിഹ്നം")സാധുവായ പ്രതീകങ്ങളുടെ ശ്രേണി നിർവചിക്കുന്നു;

! (ആശ്ചര്യചിഹ്നം)ഇനിപ്പറയുന്ന പ്രതീകങ്ങളുടെ ഗ്രൂപ്പിനെ നിരസിക്കുന്നു;

* (നക്ഷത്രചിഹ്നം)ആദ്യ ഡോട്ട് ഒഴികെ എത്ര പ്രതീകങ്ങളുമായി പൊരുത്തപ്പെടുന്നു.

3.2 I/O റീഡയറക്ഷൻ ചിഹ്നങ്ങൾ

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

>, >> - ഔട്ട്പുട്ട് റീഡയറക്ഷൻ;

2>, 2>> - പിശക് സന്ദേശങ്ങളുടെ റീഡയറക്ഷൻ;

| - കൺവെയർ.

3.3 പകരക്കാരനായ പ്രതീകങ്ങൾ

$name_variableq - വേരിയബിൾ സബ്സ്റ്റിറ്റ്യൂഷൻ;

$(കമാൻഡ്)അഥവാ `ടീം` -കമാൻഡ് സബ്സ്റ്റിറ്റ്യൂഷൻ;

~ - ടിൽഡ് സബ്സ്റ്റിറ്റ്യൂഷൻ.

4. തിരയുക

ഫയലുകൾക്കും ഡയറക്‌ടറികൾക്കുമായി വേഗത്തിൽ തിരയാൻ, whois കമാൻഡ് ഉപയോഗിക്കുക; ആഴത്തിലുള്ള തിരയലിനായി, find കമാൻഡ് ഉപയോഗിക്കുക (നിർദ്ദിഷ്ട ആവശ്യകതകൾ നിറവേറ്റുന്ന ഫയലുകൾക്കായി തിരയുക;).

5. ടെക്സ്റ്റ് എഡിറ്റർ vi

ടെക്സ്റ്റ് എഡിറ്റർ vi ഏതൊരു യുണിക്സിലും ഉള്ള ഒരു സാർവത്രിക എഡിറ്ററാണ്. ടെക്സ്റ്റ് ഫയലുകൾ എഡിറ്റ് ചെയ്യുന്നതിനു പുറമേ, കമാൻഡ് ലൈൻ എഡിറ്റുചെയ്യാൻ vi എഡിറ്റർ ഉപയോഗിക്കാം.

vi എഡിറ്ററിന് 3 ഓപ്പറേറ്റിംഗ് മോഡുകൾ ഉണ്ട് (ചിത്രം കാണുക).

vi എഡിറ്ററിലേക്ക് ലോഗിൻ ചെയ്യുന്നു

പുറത്തുകടക്കുക vi

ആദ്യ സ്ഥാനത്തുള്ള “~” (ടിൽഡ്) ചിഹ്നം ഫയലിന്റെ ശൂന്യമായ (നിലവിലില്ലാത്ത) വരികളെ അടയാളപ്പെടുത്തുന്നു.

പ്രധാന മോഡ് കമാൻഡ് മോഡാണ്, അതിൽ ഒരു നിശ്ചിത ശ്രേണി കീകൾ അമർത്തി കമാൻഡുകൾ നൽകപ്പെടുന്നു (അവ ഒരു തരത്തിലും സ്ക്രീനിൽ പ്രദർശിപ്പിക്കില്ല).

കമാൻഡ് മോഡിൽ ടെക്സ്റ്റിലൂടെ നീങ്ങുന്നത് അമ്പടയാളങ്ങളും കീകളും ഉപയോഗിച്ചാണ് (ഇടത്തെ), (താഴേക്ക്), (മുകളിലേക്ക്), (വലത്തേക്ക്).

ചില vi കമാൻഡുകൾ പട്ടികയിൽ പട്ടികപ്പെടുത്തിയിട്ടുണ്ട്.

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

ഇൻപുട്ട് മോഡിൽ, കീബോർഡിൽ ടൈപ്പുചെയ്‌ത എല്ലാ പ്രതീകങ്ങളും വാചകത്തിലേക്ക് ചേർക്കുന്നു.

അവസാന വരി മോഡിൽ, നിങ്ങൾ നൽകുന്ന കമാൻഡ് സ്ക്രീനിന്റെ അവസാന വരിയിൽ ദൃശ്യമാകും.

6. സഹായം

കമാൻഡുകളുടെ ഉദ്ദേശ്യം, അവയുടെ വാക്യഘടന, ഉപയോഗത്തിന്റെ ഉദാഹരണങ്ങൾ മുതലായവയുടെ വിവരണം ഉൾക്കൊള്ളുന്ന ഒരു ഇലക്ട്രോണിക് ഡയറക്ടറി Unix-നുണ്ട്. ഡയറക്‌ടറിയെ man കമാൻഡ് എന്ന് വിളിക്കുന്നു:

7. അടിസ്ഥാന ഷെൽ കമാൻഡുകൾ

WHO- സജീവ ഉപയോക്താക്കളെക്കുറിച്ചുള്ള വിവരങ്ങൾ പ്രദർശിപ്പിക്കുന്നു;

പ്രതിധ്വനി- ടെർമിനലിലേക്കുള്ള ഔട്ട്പുട്ട് സന്ദേശങ്ങൾ;

ബാനർ- വലിയ അക്ഷരങ്ങളിൽ ടെർമിനലിലേക്കുള്ള സന്ദേശങ്ങൾ ഔട്ട്പുട്ട് ചെയ്യുക;

മനുഷ്യൻ- ഓൺലൈൻ സഹായ സംവിധാനത്തിലേക്ക് വിളിക്കുന്നു;

തീയതി - നിലവിലെ തീയതിയുടെ ഔട്ട്പുട്ട്;

എഴുതുക- മറ്റൊരു ഉപയോക്താവിന്റെ ടെർമിനലിലേക്ക് സന്ദേശങ്ങൾ കൈമാറുക;

സന്ദേശം- മറ്റ് ഉപയോക്താക്കളിൽ നിന്നുള്ള സന്ദേശങ്ങൾ പ്രദർശിപ്പിക്കുന്നത് അനുവദിക്കുക/നിരോധിക്കുക;

മെയിൽ- മെയിൽ അയയ്ക്കൽ/സ്വീകരിക്കൽ;

വാർത്ത- സിസ്റ്റം വാർത്തകളുമായി പരിചയപ്പെടൽ;

പിഡബ്ല്യുഡി- നിലവിലെ പ്രവർത്തിക്കുന്ന ഡയറക്ടറിയുടെ സമ്പൂർണ്ണ റൂട്ട് നാമം പ്രദർശിപ്പിക്കുന്നു;

സി.ഡി- പ്രവർത്തന ഡയറക്ടറി മാറ്റുക;

ls- ഡയറക്ടറിയുടെ ഉള്ളടക്കത്തെക്കുറിച്ചുള്ള വിവരങ്ങൾ പ്രദർശിപ്പിക്കുന്നു;

mkdir- ഒരു കാറ്റലോഗ് സൃഷ്ടിക്കുന്നു;

rmdir- ഒരു ഡയറക്ടറി ഇല്ലാതാക്കുന്നു;

സ്പർശിക്കുക- ഫയൽ ടൈംസ്റ്റാമ്പ് അപ്ഡേറ്റ് ചെയ്യുന്നു;

cp- ഫയലുകൾ പകർത്തുന്നു;

പൂച്ച- ഫയലുകളുടെ ഉള്ളടക്കങ്ങൾ സംയോജിപ്പിക്കുകയും പ്രദർശിപ്പിക്കുകയും ചെയ്യുക;

കൂടുതൽ- ഫയൽ ഉള്ളടക്കങ്ങളുടെ പേജ്-ബൈ-പേജ് വീക്ഷണം.

എംവി - ഒരു ഫയൽ നീക്കുകയോ പുനർനാമകരണം ചെയ്യുകയോ ചെയ്യുക;

rm- ഫയൽ ഇല്ലാതാക്കൽ;

അപരനാമം- ഒരു ഓമനപ്പേര് സൃഷ്ടിക്കുന്നു;

tr- സ്വഭാവ പരിവർത്തനം;

പുറത്ത്- നിലവിലെ പൂർത്തീകരണം ഷെൽ-എ;

ടീ- പൈപ്പ്ലൈൻ ഫലങ്ങളുടെ തടസ്സം;

വെട്ടി - ഒരു വരിയിൽ നിന്ന് ഫീൽഡുകൾ തിരഞ്ഞെടുക്കുന്നു;

grep- ടെംപ്ലേറ്റ് പ്രകാരം തിരയുക;

pr- ഒരു നിർദ്ദിഷ്ട ഫോർമാറ്റിൽ സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ടിലേക്ക് ഫയൽ ഔട്ട്പുട്ട് ചെയ്യുക;

അടുക്കുക- അടുക്കുന്നു;

തല- ഫയലിന്റെ ആദ്യ വരികളുടെ ഔട്ട്പുട്ട്;

വാൽ- ഫയലിന്റെ അവസാന വരികളുടെ ഔട്ട്പുട്ട്;

സ്വാഗതം- പ്രതീകങ്ങളുടെയും വാക്കുകളുടെയും വരികളുടെയും എണ്ണം കണക്കാക്കുന്നു;

വായിച്ചു, പ്രതിധ്വനി - വേരിയബിൾ മൂല്യങ്ങൾ വായിക്കുകയും ഔട്ട്പുട്ട് ചെയ്യുകയും ചെയ്യുക;

പരീക്ഷ- ഒരു പദപ്രയോഗത്തിന്റെ അർത്ഥം വിലയിരുത്തൽ;

expr, അനുവദിക്കുക- ഗണിത പദപ്രയോഗങ്ങളുടെ കണക്കുകൂട്ടൽ;

8. ഷെൽ- പ്രോഗ്രാമുകൾ

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

$ chmod +x program_file_name

ഷെൽ പ്രോഗ്രാമുകളിലെ ബ്രാഞ്ചിംഗ് ഇനിപ്പറയുന്ന ഓപ്പറേറ്റർമാരെ ഉപയോഗിച്ച് സംഘടിപ്പിക്കുന്നു:

എങ്കിൽ-പിന്നെ-മറ്റുള്ളവ

ലൂപ്പ് ഓപ്പറേറ്റർമാർ:

വ്യായാമങ്ങൾ

1. താഴെപ്പറയുന്നവയിൽ ഏത് കമാൻഡാണ് സ്ക്രീനിൽ ഒരു സ്വാഗത സന്ദേശം കാണിക്കുന്നത്? ഏതാണ് അല്ലാത്തത്? എന്തുകൊണ്ട്?

$എക്കോ ഹലോ

$ എക്കോ ഹലോ

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

$ ബാനർ ഹലോ

$ ബാനർ ഹലോ, ലോകം

2. കമാൻഡുകൾ ഉപയോഗിച്ച് ഒന്നിലധികം വരികളിൽ ഒരു സന്ദേശം പ്രിന്റ് ചെയ്യുക പ്രതിധ്വനിഒപ്പം ബാനർ.

3. തീയതി രണ്ട് വരികളായി പ്രിന്റ് ചെയ്യുക: ആദ്യ വരിയിൽ ദിവസം, മാസം, വർഷം, രണ്ടാമത്തെ വരിയിൽ നിലവിലെ സമയം, ഒരു കമന്റിനൊപ്പം ഔട്ട്പുട്ട് നൽകുന്നു.

4. കമാൻഡ് ഉപയോഗിച്ച് എഴുതുക, കൺസോളിലേക്ക് ഒരു സന്ദേശം അയയ്ക്കുക. ഒന്നിലധികം ടെർമിനലുകളിലേക്ക് ഒരേസമയം സന്ദേശങ്ങൾ അയയ്ക്കുക.

5. കമാൻഡ് ഉപയോഗിച്ച് സന്ദേശം, നിങ്ങളുടെ ടെർമിനലിൽ സന്ദേശങ്ങൾ അനുവദനീയമാണോ എന്ന് നിർണ്ണയിക്കുക. സന്ദേശങ്ങൾ നിരോധിക്കുക. ആരെങ്കിലും നിങ്ങൾക്ക് സന്ദേശം അയക്കാൻ ശ്രമിച്ചാൽ സിസ്റ്റത്തിന്റെ പ്രതികരണം എന്തായിരിക്കും?

6. നിങ്ങളുടെ പേര് നിർണ്ണയിക്കുക വീട്- കാറ്റലോഗ്.

7. കമാൻഡുകൾ ഉപയോഗിച്ച് /export/home ഡയറക്ടറിയിൽ നിന്ന് ആരംഭിക്കുന്ന ഡയറക്‌ടറി സബ്‌ട്രീ ബ്രൗസ് ചെയ്യുക cd, lsഒപ്പം പിഡബ്ല്യുഡി

8.. നിങ്ങളിൽ സൃഷ്ടിക്കുക വീട്ഫോമിന്റെ ഡയറക്‌ടറി ഉപഡയറക്‌ടറികൾ:

ഫലം പൂക്കൾ

ആപ്പിൾ പിയർ മുന്തിരി റോസ് വയലറ്റ് ഡാൻഡെലിയോൺ

ഇരുണ്ട പച്ച

9. നിങ്ങളുടേതായിരിക്കുന്നത് വീട്-directory, ഒരു കമാൻഡ് ലൈൻ ഉപയോഗിച്ച് ഇനിപ്പറയുന്ന ഉപഡയറക്‌ടറികൾ സൃഷ്ടിക്കുക:

എ ബി സി ഡി

10. നിങ്ങളുടേതായിരിക്കുന്നത് വീട്-ഡയറക്‌ടറി, ഡയറക്‌ടറിയുടെ എല്ലാ ഉപഡയറക്‌ടറികളും ഇല്ലാതാക്കുക എ.

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

12. ഡയറക്ടറിയിൽ ആയിരിക്കുമ്പോൾ എഫ്താഴ്ത്തുന്നു, ഡയറക്ടറി ഇല്ലാതാക്കുക എഫ്അവശിഷ്ടങ്ങൾ.

13. ഫയൽ വായിക്കുക .പ്രൊഫൈൽകമാൻഡുകൾ ഉപയോഗിച്ച് പൂച്ചഒപ്പം കൂടുതൽ.

14. സൃഷ്ടിക്കുക വീട്- ഡയറക്ടറി ടെക്സ്റ്റ് ഫയൽ myfileകമാൻഡ് ഉപയോഗിച്ച് ഒന്നിലധികം വരികളിൽ നിന്ന് പൂച്ച.ഒരു ടെക്സ്റ്റ് ഫയൽ സൃഷ്ടിക്കുക എംവൈഎഫ്ഇലെ,അതേ വരികൾ അതിൽ എഴുതി. നിങ്ങൾക്ക് എത്ര ഫയലുകൾ ലഭിച്ചു? എന്തുകൊണ്ട്?

15. ടാസ്ക് 2.2-ൽ സൃഷ്ടിച്ച ഫയലിന്റെ ഉള്ളടക്കങ്ങൾ കാണുക myfile. ഫയൽ പകർത്തുക myfileഫയൽ ചെയ്യാൻ മൈകോപ്പി.രണ്ട് ഫയലുകളുടെയും ഉള്ളടക്കം കാണുക.

16. ഫയൽ നീക്കുക മൈകോപ്പികാറ്റലോഗിലേക്ക് പൂക്കൾ.

17. ഉള്ളപ്പോൾ വീട്-കാറ്റലോഗ്, ഒരു ലിങ്ക് സൃഷ്ടിക്കുക എംവൈലിങ്ക്ഓരോ ഫയലിനും മൈകോപ്പിഡയറക്ടറിയിൽ സ്ഥിതിചെയ്യുന്നു പൂക്കൾ. ലിങ്ക് ഫയൽ കാണുക.

18. ഫയലിലേക്ക് ഒരു വരി ചേർക്കുക enteലിങ്ക്. ഫയലുകളിൽ ഏതാണ് enteലിങ്ക്,enteപകർത്തുക,enteഫയൽ മാറി? എന്തുകൊണ്ട്?

19. ഏത് കമാൻഡ് ഉപയോഗിച്ച് നിങ്ങൾക്ക് ലിങ്കുകളുടെ എണ്ണം നിർണ്ണയിക്കാനാകും? ഫയലുകൾക്കുള്ള ലിങ്കുകളുടെ എണ്ണം നിർണ്ണയിക്കുക enteലിങ്ക്,enteപകർത്തുക,enteഫയൽ.

ഫയൽ ഇല്ലാതാക്കുക മൈകോപ്പി. ലിങ്ക് ഫയലിന് എന്ത് സംഭവിച്ചു? ഫയലുകൾക്കുള്ള ലിങ്കുകളുടെ എണ്ണം നിർണ്ണയിക്കുക enteലിങ്ക്,enteഫയൽ.

20. ഒരു അപരനാമം സൃഷ്ടിക്കുക dir, നിലവിലെ ഡയറക്‌ടറിയിലെ ഉള്ളടക്കങ്ങൾ ഒരു വിപുലീകൃത ഫോർമാറ്റിൽ പ്രിന്റ് ചെയ്യുന്നു.

21. ലോഗ് ഔട്ട് ചെയ്ത് വീണ്ടും ലോഗിൻ ചെയ്യുക. അപരനാമം പ്രവർത്തിക്കുന്നുണ്ടോ? dir? സെഷനുകൾക്കിടയിൽ വിളിപ്പേര് നഷ്ടപ്പെടുന്നില്ലെന്ന് ഉറപ്പാക്കാൻ എന്താണ് ചെയ്യേണ്ടത്?

22. ഒരു അപരനാമം സൃഷ്ടിക്കുക പോയിന്റ്, ഒരു ഡോട്ടിൽ തുടങ്ങുന്ന പേരുകൾ പ്രവർത്തിക്കുന്ന ഡയറക്ടറിയിലെ ഫയലുകളുടെ ഒരു ലിസ്റ്റ് പ്രിന്റ് ചെയ്യുന്നു.

23. കമാൻഡ് ഉപയോഗിച്ച് സ്പർശിക്കുക, ഒരു പുതിയ ഡയറക്‌ടറിയിൽ ഒരേ സമയം അത്തരം പേരുകളുള്ള ഫയലുകൾ സൃഷ്‌ടിക്കുക:

ടെംപ്ലേറ്റ് എ* 5 ഫയലുകൾ പൊരുത്തപ്പെട്ടു;

ടെംപ്ലേറ്റ് * എ 4 ഫയലുകളുമായി പൊരുത്തപ്പെടുന്നു;

ടെംപ്ലേറ്റ് ??.? പൊരുത്തപ്പെടുന്ന 3 ഫയലുകൾ;

ടെംപ്ലേറ്റ് * aa* 2 ഫയലുകളുമായി പൊരുത്തപ്പെടുന്നു;

ടെംപ്ലേറ്റ്??? ഒരു ഫയലുമായി പൊരുത്തപ്പെട്ടു.

24. ഇനിപ്പറയുന്നവ ചെയ്യാൻ നിങ്ങൾ ഏത് കമാൻഡ് നൽകണം:

a) ഒരു ഡോട്ടിൽ ആരംഭിക്കുന്ന എല്ലാ ഫയലുകളുടെയും പേരുകൾ പ്രദർശിപ്പിക്കുക;

b) അവസാനിക്കുന്ന എല്ലാ ഫയലുകളുടെയും പേരുകൾ പ്രദർശിപ്പിക്കുക ".ടെക്സ്റ്റ്";

c) വാക്ക് അടങ്ങിയ എല്ലാ ഫയലുകളുടെയും പേരുകൾ പ്രദർശിപ്പിക്കുക "ente";

25. നൽകിയിരിക്കുന്ന ഒരു ഫയലിലെ എല്ലാ ചെറിയക്ഷരങ്ങളും വലിയക്ഷരങ്ങൾ ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുക, മറ്റൊന്നിൽ എല്ലാ വലിയക്ഷരങ്ങളും ചെറിയക്ഷരങ്ങൾ ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുക. ഫയലിൽ നിന്ന് ഡ്യൂപ്ലിക്കേറ്റ് സ്‌പെയ്‌സുകൾ ഒഴിവാക്കുക.

26. എന്ന പേരിൽ ഒരു ഫയൽ സൃഷ്ടിക്കുക * . ഈ ഫയൽ മാത്രം ഇല്ലാതാക്കുക. ഫയൽ നെയിം ജനറേഷൻ പ്രതീകങ്ങൾ ഉപയോഗിക്കുമ്പോൾ ശ്രദ്ധിക്കുക!

27. പേരിൽ ഒരു സ്പേസ് ഉള്ള ഒരു ഫയൽ സൃഷ്ടിക്കുക. അത്തരമൊരു ഫയൽ എങ്ങനെ ഇല്ലാതാക്കാം?

28. കമാൻഡ് ഉപയോഗിച്ച് പൂച്ചയഥാർത്ഥ ഉള്ളടക്കങ്ങൾ അതേ ഫയലിന്റെ അവസാനം ചേർത്തുകൊണ്ട് ഒരു ഫയലിന്റെ ഉള്ളടക്കം ഇരട്ടിയാക്കുക. ഡയറക്ടറിയിലേക്ക് പോകുക പൂക്കൾ. ഫയലിലേക്ക് ചേർക്കുക spisokഡയറക്ടറി ഉള്ളടക്ക ലിസ്റ്റ് പൂക്കൾ.ഫയലിന്റെ ഉള്ളടക്കം കാണുക

29. കമാൻഡ് ഉപയോഗിച്ച് വായിക്കാൻ ശ്രമിക്കുക പൂച്ചനിലവിലില്ലാത്ത ഫയൽ. സിസ്റ്റത്തിന്റെ പ്രതികരണം എന്താണ്? പിശക് സന്ദേശങ്ങൾ ഒരു ഫയലിലേക്ക് റീഡയറക്‌ട് ചെയ്‌ത് അതേ കാര്യം ചെയ്യുക myerror. സ്ക്രീനിൽ നിങ്ങൾ എന്താണ് കാണുന്നത്? ഫയൽ കാണുക myerror.

30. നിലവിൽ നിങ്ങളുടെ പ്രവർത്തിക്കുന്ന ഡയറക്‌ടറിയിലുള്ള ഫയലുകളുടെ പേരുകളും അനുമതികളും മാത്രം ലിസ്റ്റുചെയ്യാൻ ഒരു പൈപ്പ്‌ലൈൻ സൃഷ്‌ടിക്കുക.

31. നിർമ്മിച്ച പൈപ്പ്ലൈൻ മാറ്റുക, അങ്ങനെ ലിസ്റ്റ് ഒരു ഫയലിൽ സംരക്ഷിക്കപ്പെടും spisokനിങ്ങളുടെ അവന്റെ വീട്-directory, കൂടാതെ ലിസ്റ്റിലെ ഫയലുകളുടെ എണ്ണം മാത്രം സ്ക്രീനിൽ പ്രദർശിപ്പിച്ചിരിക്കുന്നു.

32. ഒരു ഫയലിന്റെ ഉള്ളടക്കം പ്രദർശിപ്പിക്കുക /etc/passwd, ഉപയോക്തൃനാമ ഫീൽഡ് അനുസരിച്ച് അടുക്കിയിരിക്കുന്നു.

33. ഒരു അപരനാമം സൃഷ്ടിക്കുക ലോഗ് ചെയ്തുഓൺ, ഇത് സിസ്റ്റത്തിൽ പ്രവർത്തിക്കുന്ന ഉപയോക്താക്കളുടെ പേരുകളുടെ അക്ഷരമാലാക്രമത്തിൽ ക്രമീകരിച്ച ലിസ്റ്റ് പ്രദർശിപ്പിക്കും.

33. കമാൻഡുകൾ ഉപയോഗിച്ച് വലിയ അക്ഷരങ്ങളിൽ നിലവിലെ തീയതി പ്രദർശിപ്പിക്കുക തീയതിഒപ്പം ബാനർ.

34. ഒരു വേരിയബിളിലേക്ക് അസൈൻ ചെയ്യുക ഞാൻ.നിങ്ങളുടെ രജിസ്ട്രേഷൻ പേര്. മറ്റൊന്ന് സമാരംഭിക്കുക ഷെൽ. നിങ്ങൾ ഈ വേരിയബിൾ കാണുന്നുണ്ടോ? സൃഷ്ടിച്ചതിൽ ഇത് കാണാൻ നിങ്ങൾ എന്താണ് ചെയ്യേണ്ടത് ഷെൽ? ഒരു വേരിയബിളിന്റെ മൂല്യം മാറ്റുക ഞാൻ.സൃഷ്ടിച്ചതിൽ ഷെൽ. ജനിച്ചവരിൽ നിന്ന് പുറത്തുവരിക ഷെൽ. ഉറവിടത്തിൽ ഈ വേരിയബിളിന്റെ മൂല്യം നോക്കുക ഷെൽ. ഫലം വിശദീകരിക്കുക.

35. എഴുതുക ഷെൽ- പ്രോഗ്രാം വിവരം, ഇത് ഉപയോക്താവിനോട് പേര്, വിലാസം, ദിവസം, മാസം, ജനന വർഷം എന്നിവ രേഖപ്പെടുത്താൻ ആവശ്യപ്പെടും കൂടാതെ നൽകിയ റിവേഴ്സ് ഓർഡറിൽ ഈ വിവരങ്ങൾ പ്രദർശിപ്പിക്കും

36. എഴുതുക ഷെൽ- ഒരു നമ്പർ നൽകുന്നതിനുള്ള ഒരു പ്രോംപ്റ്റ് പ്രദർശിപ്പിക്കുകയും നൽകിയ നമ്പർ ഒരു വേരിയബിളിൽ സൂക്ഷിക്കുകയും ചെയ്യുന്ന ഒരു പ്രോഗ്രാം വൈ, ഒരു സന്ദേശം അച്ചടിക്കുക "Y 7 നേക്കാൾ വലുതാണ്",മൂല്യമാണെങ്കിൽ വൈ 7-ൽ കൂടുതൽ, ഒപ്പം “Y ആണ്അല്ല വലിയ അധികം 7” അല്ലാത്തപക്ഷം.

37. ഇനിപ്പറയുന്ന സ്ഥിതിവിവരക്കണക്കുകൾ പ്രദർശിപ്പിക്കുന്ന ഒരു ഷെൽ പ്രോഗ്രാം എഴുതുക:

a) നിങ്ങളുടെ പേര്;

ബി) അത് സമാരംഭിച്ച ആർഗ്യുമെന്റുകളുടെ എണ്ണം;

c) അതിന്റെ ഓരോ ആർഗ്യുമെന്റുകളും പ്രതീകങ്ങളിൽ ആർഗ്യുമെന്റിന്റെ ദൈർഘ്യവും പ്രിന്റ് ചെയ്യുന്നു;

38. എഴുതുക ഷെൽ- കമാൻഡ് ലൈനിലെ ആർഗ്യുമെന്റുകളുടെ എണ്ണം നിർണ്ണയിക്കുകയും ആർഗ്യുമെന്റുകളുടെ എണ്ണം മൂന്നല്ലെങ്കിൽ ഒരു പിശക് സന്ദേശം പ്രദർശിപ്പിക്കുകയും ചെയ്യുന്ന ഒരു പ്രോഗ്രാം, അല്ലെങ്കിൽ അവയുടെ നമ്പർ മൂന്നാണെങ്കിൽ ആർഗ്യുമെന്റുകൾ തന്നെ.

39. എഴുതുക ഷെൽ- ഒരു ഉപയോക്തൃ ഐഡി നൽകാൻ നിങ്ങളെ പ്രേരിപ്പിക്കുന്ന ഒരു പ്രോഗ്രാം, സിസ്റ്റത്തിൽ ഉപയോഗിക്കുന്നവയ്‌ക്കെതിരെ ഐഡി പരിശോധിക്കുക, പൂർണ്ണമായ പേര് പ്രദർശിപ്പിക്കുക വീട്-directory അല്ലെങ്കിൽ, ഒരു അസാധുവായ ഐഡന്റിഫയറിന്റെ കാര്യത്തിൽ, ഒരു പിശക് സന്ദേശം പ്രദർശിപ്പിക്കുക.

40. ഒരു ഷെൽ പ്രോഗ്രാം എഴുതുക ഹലോ, ഇത് കമാൻഡ് ലൈൻ ആർഗ്യുമെന്റുകൾക്ക് ഇനിപ്പറയുന്ന പ്രതികരണം നൽകുന്നു:

വാദം "-ഡി"- പ്രോഗ്രാം കമാൻഡ് എക്സിക്യൂട്ട് ചെയ്യും തീയതി;

വാദം "-എൽ"- പ്രോഗ്രാം നിലവിലെ ഡയറക്ടറിയുടെ ഉള്ളടക്കങ്ങൾ പ്രദർശിപ്പിക്കും;

കമാൻഡ് ലൈനിൽ ആർഗ്യുമെന്റുകളോ അസാധുവായ ആർഗ്യുമെന്റുകളോ ഇല്ലെങ്കിൽ, പ്രോഗ്രാം അതിന്റെ ഓപ്ഷനുകളെക്കുറിച്ചുള്ള സഹായം പ്രിന്റ് ചെയ്യും.

41. ഒരു പ്രോഗ്രാം എഴുതുക വാക്കുകൾ, ഇത് ഉപയോക്താവ് വാക്ക് നൽകുന്നതുവരെ ഒരു സമയം ഒരു വാക്ക് നൽകാൻ പ്രേരിപ്പിക്കും “ അവസാനിക്കുന്നു” . നിങ്ങൾ നൽകിയ എല്ലാ വാക്കുകളും ഓർക്കുക. ഒരു വാക്ക് നൽകിയ ശേഷം “ അവസാനിക്കുന്നു” നൽകിയ എല്ലാ വാക്കുകളും സ്ക്രീനിൽ പ്രദർശിപ്പിക്കുക.

42. സിസ്റ്റം പ്രോംപ്റ്റ് മാറ്റുക, അതുവഴി നിലവിലുള്ള വർക്കിംഗ് ഡയറക്ടറിയുടെ മുഴുവൻ പാത്ത് നാമവും അതിൽ അടങ്ങിയിരിക്കുന്നു .

43. ഒരു പ്രോഗ്രാം എഴുതുക വൈറസ്, അത് മറ്റൊരു പേരിൽ സ്വയം ഒരു എക്സിക്യൂട്ടബിൾ പകർപ്പ് സൃഷ്ടിക്കുകയും തുടർന്ന് സ്വയം ഇല്ലാതാക്കുകയും ചെയ്യുന്നു.

44. ഒരു പ്രോഗ്രാം എഴുതുക വൈറസ്2 , ഇത് കമാൻഡ് ലാംഗ്വേജ് പ്രോഗ്രാമുകൾക്കായി നിലവിലെ ഡയറക്ടറിയിൽ തിരയുകയും വാക്ക് പ്രദർശിപ്പിക്കുന്നതിനുള്ള ഒരു കമാൻഡ് അവരുടെ ടെക്സ്റ്റിലേക്ക് ചേർക്കുകയും ചെയ്യുന്നു “ അണുബാധയുണ്ടായി!”.

45. ഒരു പ്രോഗ്രാം എഴുതുക വൈറസ്3 , അത് മറ്റ് പ്രോഗ്രാമുകളെ ബാധിക്കാൻ കണ്ടെത്തുന്ന കമാൻഡ് ലാംഗ്വേജ് പ്രോഗ്രാമുകളിലേക്ക് സ്വന്തം കോഡ് ചേർക്കുന്നു.

46. ​​ഒരു പ്രോഗ്രാം എഴുതുക വൈറസ്4 , നിങ്ങളുടെ വൈറസ് പരിഷ്‌ക്കരിക്കുന്നതിലൂടെ, അണുബാധയുണ്ടാകുമ്പോൾ, അണുബാധയുള്ള പ്രോഗ്രാമിൽ നിന്ന് രോഗബാധയുള്ള കോഡ് നീക്കം ചെയ്യപ്പെടും.

47. ഒരു പ്രോഗ്രാം എഴുതുക ആന്റിവൈറസ്, ഇത് നിങ്ങളുടെ വൈറസ് ബാധിച്ച എല്ലാ ഷെൽ പ്രോഗ്രാമുകളും കണ്ടെത്തും.

48. വികസിപ്പിച്ച പ്രോഗ്രാം പരിഷ്‌ക്കരിക്കുക, അതിലൂടെ അത് നിർദ്ദിഷ്ട ഡയറക്‌ടറിയിൽ രോഗബാധിത പ്രോഗ്രാമുകൾ കണ്ടെത്തുക മാത്രമല്ല, രോഗബാധിതമായ പതിപ്പ് അതിന്റെ പേരിൽ അവസാനം ചേർത്ത ഒരു പുതിയ ഫയലിൽ സംരക്ഷിച്ചുകൊണ്ട് അവയെ "സൗഖ്യമാക്കുകയും" ചെയ്യുന്നു. . vir, കൂടാതെ അത്തരം ഒരു ഫയലിൽ നിന്ന് എക്സിക്യൂഷൻ ആട്രിബ്യൂട്ട് നീക്കം ചെയ്യുന്നു.

49. ഒരു പ്രോഗ്രാം എഴുതുക വൈറസ്5 , അത്:

a) ഉപയോക്താവ് കമാൻഡ് നൽകിയാൽ മാത്രമേ നിലവിലെ ഡയറക്‌ടറിയിലും അതിന്റെ ഉപഡയറക്‌ടറികളിലും ഉള്ള ഷെൽ പ്രോഗ്രാമുകളെ വൈറസ് ബാധിക്കുകയുള്ളൂ. ls;

b) ഒരു ടീമിനെപ്പോലെ പെരുമാറും ls, ടെർമിനലിലെ നിങ്ങളുടെ ജോലിയെക്കുറിച്ച് ഒന്നും വെളിപ്പെടുത്താതെ.

50. പ്രോഗ്രാമുകളെ അടിസ്ഥാനമാക്കി ഒരു വൈറസ്6 പ്രോഗ്രാം എഴുതുക വൈറസ്2 -വൈറസ്5 , നിങ്ങൾ വികസിപ്പിച്ച പ്രോഗ്രാമിന് രോഗബാധയുള്ള കോഡ് കണ്ടെത്താനായില്ല ആന്റിവൈറസ്, കൂടാതെ വേരിയബിളിന്റെ ഏത് മൂല്യത്തിനും അണുബാധ സംഭവിക്കും പാത.

51. ഒരു പ്രോഗ്രാം എഴുതുക സൂപ്പർവൈറസ്, മുമ്പത്തെ ടാസ്‌ക്കിൽ വികസിപ്പിച്ച വൈറസ് ഉപയോഗിച്ച് നിങ്ങളുടെ ഫയലുകളെ ബാധിക്കുന്ന ലോഞ്ച്, നിങ്ങൾ സിസ്റ്റത്തിൽ ലോഗിൻ ചെയ്യുമ്പോഴെല്ലാം, നിങ്ങളുടെ സുഹൃത്തുക്കളുടെ ഫയലുകളെ ബാധിക്കാനുള്ള ശ്രമം നടക്കുന്നു. പ്രോഗ്രാം സൂപ്പർവൈറസ് ആദ്യ വിക്ഷേപണത്തിനു ശേഷം സ്വയം മായ്ക്കുന്നു.

52. ഒരു പ്രോഗ്രാം എഴുതുക സൂപ്പർആന്റിവൈറസ്, നിർദിഷ്ട ഡയറക്‌ടറിയിലെയും അതിന്റെ ഉപഡയറക്‌ടറികളിലെയും എല്ലാ വികസിപ്പിച്ച വൈറസുകളിൽ നിന്നുമുള്ള എല്ലാ ഫയലുകളും (അനുയോജ്യമായ ഓപ്‌ഷൻ വ്യക്തമാക്കിയിട്ടുണ്ടെങ്കിൽ) അത് കണ്ടെത്തുകയും പൂർണ്ണമായും "സൗഖ്യമാക്കുകയും" ചെയ്യുന്നു.