ലബോറട്ടറി വർക്ക് നമ്പർ 1: OS കുടുംബത്തിൻ്റെ കമാൻഡ് ലാംഗ്വേജ് പ്രൊസസറിലേക്കുള്ള ആമുഖംവിൻഡോസ്.
കൈമാറാൻ വേണ്ടി ലബോറട്ടറി ജോലി, സൈദ്ധാന്തിക മെറ്റീരിയലിൽ നൽകിയിരിക്കുന്ന എല്ലാ ഉദാഹരണങ്ങളും വിദ്യാർത്ഥി സൃഷ്ടിച്ച ബാറ്റ് ഫയലുകളുടെ രൂപത്തിൽ അധ്യാപകന് അവതരിപ്പിക്കണം.
ചോദ്യങ്ങൾ:
- ഒരു ബാച്ച് ഫയൽ നിർവ്വചിക്കണോ? ബാച്ച് ഫയലിന് എന്ത് വിപുലീകരണമാണ് ഉള്ളത്?
- ഔട്ട്പുട്ട് റീഡയറക്ഷൻ ഓർഗനൈസുചെയ്യുമ്പോൾ >, >> എന്നിവ ഉപയോഗിക്കുന്നത് തമ്മിലുള്ള വ്യത്യാസം എന്താണ്?
- ഒരു ബാച്ച് ഫയലിൽ ഒരു നീണ്ട വരി എങ്ങനെ പൊതിയാം?
- ഒരു ബാച്ച് ഫയലിലേക്ക് പാരാമീറ്ററുകൾ എങ്ങനെയാണ് കൈമാറുന്നത്? പരാമീറ്ററുകളുള്ള ഒരു കമാൻഡ് ഫയലിൻ്റെ ഒരു ഉദാഹരണം നൽകുക.
- ഉദ്ദേശ്യം വിശദീകരിക്കുക കമാൻഡുകൾ സജ്ജമാക്കുക. വേരിയബിളുകൾ ഉപയോഗിക്കുന്നതിൻ്റെ പ്രയോജനം എന്താണ്? സെറ്റ് കമാൻഡ് ഉപയോഗിക്കുന്ന ഒരു ബാച്ച് ഫയലിൻ്റെ ഉദാഹരണം നൽകുക.
- ഒരു ബാച്ച് ഫയലിൻ്റെ പാരാമീറ്ററുകൾ അതിൻ്റെ വേരിയബിളുകളിൽ നിന്ന് എങ്ങനെ വ്യത്യാസപ്പെട്ടിരിക്കുന്നു?
- ഏതൊക്കെ സന്ദർഭങ്ങളിൽ for കമാൻഡ് ഉപയോഗിക്കാം? ഫോർ കമാൻഡ് ഉപയോഗിക്കുന്ന ഒരു ബാച്ച് ഫയലിൻ്റെ ഉദാഹരണം നൽകുക.
- ഒരു ബാച്ച് ഫയലിൽ നിന്ന് മറ്റൊരു ബാച്ച് ഫയലിനെ വിളിക്കാൻ ഉപയോഗിക്കുന്ന കമാൻഡ് ഏതാണ്? അത്തരമൊരു ബാച്ച് ഫയലിൻ്റെ (കളുടെ) ഒരു ഉദാഹരണം നൽകുക.
ഇനിപ്പറയുന്ന ചോദ്യങ്ങൾക്ക് ഉത്തരം തയ്യാറാക്കാൻ അധിക മെറ്റീരിയൽ ഉപയോഗിക്കുക:
- ഇതിനർത്ഥം: നിരുപാധികമായ മുൻഗണനയോടെ മറ്റേതെങ്കിലും കഥാപാത്രത്തിൽ നിന്ന് രക്ഷപ്പെടുക.
- ഓപ്പറേറ്റർമാരുടെ ഉദ്ദേശ്യം വിശദീകരിക്കുക:<, >, >>, &, && ഒപ്പം ||.
"എക്സിക്യൂട്ടബിൾ ഫയലുകൾഡോസ്"
(ഭാഷ ബാച്ച് ഫയലുകൾ MS-DOS).
ദിശകൾ : കമാൻഡ് ലൈൻ എമുലേറ്ററിന് കീഴിലാണ് ടാസ്ക് നടപ്പിലാക്കുന്നത്വിൻഡോസ് എക്സ് പി.
ആമുഖം
ഓപ്പറേഷൻ റൂമിൽ MS-DOS സിസ്റ്റംകൂടാതെ Microsoft കുടുംബത്തിൻ്റെ എല്ലാ ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളിലും വിൻഡോസ് ഏറ്റവും ലളിതമായിബാച്ച് ഫയലുകൾ എന്ന് വിളിക്കപ്പെടുന്നവ ഫയലുകളുടെ (ഡയറക്‌ടറികളും) പ്രോസസ്സിംഗ് ഓട്ടോമേറ്റ് ചെയ്യുന്നതിനുള്ള ഒരു മാർഗമായി വർത്തിക്കുന്നു. ബിൽറ്റ്-ഇൻ ഫയലുകൾക്കിടയിൽ പോലും ഉപയോക്താവിൻ്റെ ജോലി ഓട്ടോമേറ്റ് ചെയ്യുന്നതിനുള്ള ഒരേയൊരു മാർഗ്ഗം ബാച്ച് ഫയലുകളല്ല. കുടുംബത്തിൻ്റെ ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളിൽ മൈക്രോസോഫ്റ്റ് വിൻഡോസ്, പതിപ്പ് 98 മുതൽ ആരംഭിക്കുന്നു, ഉണ്ട് കൂടുതൽ വിൻഡോസ്സ്ക്രിപ്റ്റ് (ഇംഗ്) ഹോസ്റ്റ്. കൂടാതെ, വ്യാഖ്യാനിച്ച ഭാഷയായ പേൾ, പൈത്തൺ അല്ലെങ്കിൽ റൂബി എന്നിവ ഈ ആവശ്യങ്ങൾക്കായി ഉപയോഗിക്കാം. ഫണ്ടുകൾ കൈമാറി, വളരെ ശക്തമാണ്, പക്ഷേ പ്രോഗ്രാമിംഗ് കഴിവുകൾ ആവശ്യമാണ്, അതായത്. ഒരു നല്ല അമേച്വർ തലത്തിലെങ്കിലും പ്രോഗ്രാമുകൾ രചിക്കുകയും പ്രധാനമായും ഡീബഗ് ചെയ്യുകയും ചെയ്യുക. പ്രത്യേക പരിശീലനമില്ലാതെ ബാച്ച് ഫയലുകൾ ഉപയോഗിക്കുന്നത് ആർക്കും ആക്സസ് ചെയ്യാവുന്നതാണ്; ശ്രദ്ധയും സാമാന്യബുദ്ധിയും മതി.
കമാൻഡ് പ്രൊസസർ
മൈക്രോസോഫ്റ്റ് വികസിപ്പിച്ചെടുത്തത് ഉൾപ്പെടെ നിരവധി ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളിൽ ഒരു കമാൻഡ് പ്രൊസസർ ഉൾപ്പെടുന്നു. കീബോർഡിൽ നിന്ന് ഉപയോക്താവ് നൽകുന്ന കമാൻഡുകൾക്ക് പ്രതികരണമായി വിവിധ പ്രവർത്തനങ്ങളുടെ നിർവ്വഹണം ആരംഭിക്കുന്ന ഒരു പ്രോഗ്രാമിൻ്റെ പേരാണ് ഇത്. അടിസ്ഥാനപരമായി, ചില പാരാമീറ്ററുകൾ ഉപയോഗിച്ച് ആവശ്യമായ പ്രോഗ്രാമുകൾ സമാരംഭിക്കുന്നത് ഈ പ്രവർത്തനങ്ങൾ ഉൾക്കൊള്ളുന്നു. എന്നാൽ ചില കമാൻഡുകൾ നേരിട്ട് കമാൻഡ് പ്രൊസസർ മുഖേന എക്സിക്യൂട്ട് ചെയ്യപ്പെടുന്നു. അടിസ്ഥാനപരമായി, കമാൻഡ് എക്സിക്യൂഷൻ്റെ സന്ദർഭവും ക്രമവും നിയന്ത്രിക്കാൻ സഹായിക്കുന്ന കമാൻഡുകൾ ഇവയാണ്. കമാൻഡ് ലൈനിൽ നിന്ന് പ്രവർത്തിപ്പിക്കാൻ സാങ്കേതികമായി സാധ്യമായ ഏതൊരു പ്രോഗ്രാമും ഷെൽ ഒരു കമാൻഡായി കണക്കാക്കുന്നു. ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിൽ യഥാർത്ഥത്തിൽ നിർമ്മിച്ച നേറ്റീവ് കമാൻഡുകളും അതിന് മുകളിൽ ഇൻസ്റ്റാൾ ചെയ്ത പ്രോഗ്രാമുകളും തമ്മിൽ ഇത് വേർതിരിക്കുന്നില്ല.
ടാസ്ക് നമ്പർ 1
കമാൻഡ് പ്രോസസർ ആരംഭിക്കുന്നതിന്:
- ബട്ടണിൽ ക്ലിക്ക് ചെയ്യുകആരംഭിക്കുക . പ്രധാന മെനു സ്ക്രീനിൽ പ്രദർശിപ്പിക്കും.
- പ്രധാന മെനുവിൽ നിന്ന് റൺ തിരഞ്ഞെടുക്കുക. സ്ക്രീനിൽ ഒരു ഡയലോഗ് ബോക്സ് ദൃശ്യമാകുംപ്രോഗ്രാം ആരംഭിക്കുന്നു.
- ഓപ്പൺ ഫീൽഡിൽ, സ്ട്രിംഗ് നൽകുക cmd.
- ബട്ടണിൽ ക്ലിക്ക് ചെയ്യുകശരി . ഒരു കമാൻഡ് പ്രൊസസർ വിൻഡോ സ്ക്രീനിൽ ദൃശ്യമാകും.
കമാൻഡ് ലൈനും കമാൻഡുകളും
കമാൻഡ് പ്രോസസർ വിൻഡോ അതിൻ്റെ യഥാർത്ഥ രൂപത്തിൽ ഇരുണ്ടതായി കാണപ്പെടുന്നു, മാത്രമല്ല ഇത് ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നത് മിക്ക ആളുകൾക്കും വളരെ സൗകര്യപ്രദമല്ല. ഉപയോഗിക്കാൻ വളരെ എളുപ്പമാണ് ഫയൽ മാനേജർമാർശൈലിയിലാണ് നോർട്ടൺ കമാൻഡർഅഥവാബഹുദൂരം . അവർ രണ്ട് മാർഗങ്ങളും നൽകുന്നു ദ്രുത നാവിഗേഷൻഫയൽ സിസ്റ്റത്തിൽ, കമാൻഡുകൾ നൽകുന്നതിനുള്ള കാലയളവ്.
ടാസ്ക് നമ്പർ 2
കമാൻഡ് നൽകുന്നതിന്:
- കമാൻഡ് ലൈനിൽ കമാൻഡ് ടെക്സ്റ്റ് ടൈപ്പ് ചെയ്യുക (ഉദാഹരണത്തിന്, കമാൻഡ് dir ).
- കീ അമർത്തുകനൽകുക.
കമാൻഡ് പ്രൊസസറും ഓപ്പറേറ്റിംഗ് സിസ്റ്റം കമാൻഡുകളും രണ്ടാമത്തേതിൻ്റെ ഓപ്പറേറ്റിംഗ് ഡോക്യുമെൻ്റേഷനിൽ വിവരിച്ചിരിക്കുന്നു. ഈ ഡോക്യുമെൻ്റേഷൻ ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിൽ തന്നെ ഭാഗികമായി അടങ്ങിയിരിക്കുന്നു. ഇത് ആക്സസ് ചെയ്യുന്നതിന്, സഹായ കമാൻഡ് ഉപയോഗിക്കുക. ഈ കമാൻഡ് ഒരു ലിസ്റ്റ് പ്രദർശിപ്പിക്കുന്നു ലഭ്യമായ കമാൻഡുകൾ. ഒരു നിർദ്ദിഷ്ട കമാൻഡിൻ്റെ ഒരു വിവരണം ലഭിക്കുന്നതിന്, നിങ്ങൾ അതിൻ്റെ പേര് ഹെൽപ്പ് കമാൻഡിൻ്റെ ഒരു പരാമീറ്ററായി വ്യക്തമാക്കണം (അല്ലെങ്കിൽ കമാൻഡ് വ്യക്തമാക്കുകയും ഒരു സ്‌പെയ്‌സ് ഉപയോഗിച്ച് വേർതിരിക്കുകയും ചെയ്യുക /?).
ടാസ്ക് നമ്പർ 3
ലഭ്യമായ കമാൻഡുകളുടെ ലിസ്റ്റ് കാണുന്നതിന്:
- കമാൻഡ് ടെക്സ്റ്റ് ടൈപ്പ് ചെയ്യുകസഹായം കമാൻഡ് ലൈനിൽ.
- കീ അമർത്തുകനൽകുക.
I/O റീഡയറക്ഷൻ
ഹെൽപ്പ് കമാൻഡ് എക്സിക്യൂട്ട് ചെയ്യുന്നതിൻ്റെ ഫലം ഒരു സ്ക്രീനിൽ യോജിച്ചതല്ല (ഫോർ കമാൻഡിൻ്റെ വിവരണ വാചകത്തിലും ഇതേ പ്രശ്നം സംഭവിക്കുന്നു). ഔട്ട്പുട്ട് ഒരു ഫയലിലേക്ക് റീഡയറക്ട് ചെയ്യുന്നതിലൂടെ ഈ അസൗകര്യം ഒഴിവാക്കാനാകും.
ടാസ്ക് നമ്പർ 4
ഒരു കമാൻഡിൻ്റെ ഫലം ഒരു ഫയലിലേക്ക് റീഡയറക്ട് ചെയ്യുന്നതിന്, ചിഹ്നം ഉപയോഗിക്കുക >:
- FAR തുറക്കുക (ആരംഭ മെനു വഴിയോ "ഒരു പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കുക" എന്നതിൽ ഫാർ കമാൻഡ് നൽകുന്നതിലൂടെയോ - ടാസ്ക് നമ്പർ 1 കാണുക)
- നിങ്ങളിലേക്ക് പോകുക പ്രവർത്തിക്കുന്ന ഫോൾഡർ(ദൂരെഇ : Alt+F1 അമർത്തുക, "Z: network" ഡ്രൈവ് തിരഞ്ഞെടുത്ത് നിങ്ങളുടെ ഫോൾഡറിലേക്ക് നീക്കുക
- കീബോർഡ് കുറുക്കുവഴി അമർത്തുക Ctrl+O (ഷെല്ലിലേക്ക് മടങ്ങാൻ കമാൻഡ് പ്രോംപ്റ്റിലേക്ക് പോകുക FAR, വീണ്ടും Ctrl + O അമർത്തുക)
- കമാൻഡ് ടെക്സ്റ്റ് ടൈപ്പ് ചെയ്യുകസഹായം > എ. ടെക്സ്റ്റ് കമാൻഡ് ലൈനിൽ.
- കീ അമർത്തുകനൽകുക.
- ബഹുദൂരം പുതുതായി സൃഷ്ടിച്ച ഫയൽഎ. ടെക്സ്റ്റ്.
- കമാൻഡ് ടെക്സ്റ്റ് ടൈപ്പ് ചെയ്യുകസഹായം >> എ. ടെക്സ്റ്റ് കമാൻഡ് ലൈനിൽ.
- കീ അമർത്തുകനൽകുക.
- ഫലം നോക്കുക: ഒരു ഫയൽ മാനേജർ വഴി തുറക്കുകബഹുദൂരം പുതുതായി സൃഷ്ടിച്ച ഫയൽഎ. ടെക്സ്റ്റ് (അനുയോജ്യമായ ഫയൽ തിരഞ്ഞെടുത്ത് കീ അമർത്തുകഎഫ് 4).
- > ഉം >> ഉപയോഗിക്കുന്നതും തമ്മിലുള്ള വ്യത്യാസം എന്താണെന്ന് നിർണ്ണയിക്കുക (ഇത് ചെയ്യുന്നതിന്, അനുബന്ധ കമാൻഡുകൾ നിരവധി തവണ എക്സിക്യൂട്ട് ചെയ്യാം, ഓരോ തവണയും ലഭിച്ച ഫലം നിങ്ങൾ വിലയിരുത്തേണ്ടതുണ്ട്)?
- ലഭ്യമായ കമാൻഡുകളുടെ ലിസ്റ്റ് പരിശോധിക്കുക.
ടാസ്ക് നമ്പർ 5
ടീമുകൾ എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് അറിയുകനീക്കി റെൻ:
- ഈ കമാൻഡുകൾക്കുള്ള സഹായം അവലോകനം ചെയ്യുക.
- നിങ്ങളുടെ പ്രവർത്തന ഡയറക്ടറിയിൽ ഡയറക്ടറികൾ സൃഷ്‌ടിക്കുകപെട്ടിയും മേശയും.
- ബോക്സ് ഡയറക്ടറിയിൽ, ഒരു ഫയൽ ടെസ്റ്റ് സൃഷ്ടിക്കുക 1. txt.
- ഫയൽ നീക്കുകടെസ്റ്റ് 1.txt കമാൻഡ് ഉപയോഗിച്ച് ബോക്സ് ഡയറക്ടറിയിൽ നിന്ന് ടേബിൾ ഡയറക്ടറിയിലേക്ക്:ബോക്സ്\ ടെസ്റ്റ് 1.txt പട്ടിക നീക്കുക.
- ഫയലിൻ്റെ പേര് മാറ്റുകടെസ്റ്റ് ഫയൽ ചെയ്യുന്നതിന് 1.txt പരീക്ഷിക്കുക 2.txt കമാൻഡ് ഉപയോഗിച്ച്:റെൻ ടെസ്റ്റ് 1.txt ടെസ്റ്റ് 2.txt.
നിലവിലെ ഡയറക്ടറി. കേവലവും ആപേക്ഷികവുമായ പാതകൾ
ഫയൽ കമാൻഡുകൾ ഉപയോഗിച്ച് പ്രവർത്തിക്കുമ്പോൾ, നിലവിലെ ഡയറക്ടറിയുടെ ആശയം വളരെ പ്രധാനമാണ്. ഒരു കമാൻഡ് പാരാമീറ്ററായി ഒരു ഫയൽ വ്യക്തമാക്കുമ്പോൾ, അവയെ ചൂണ്ടിക്കാണിക്കാൻ സാധ്യമായ രണ്ട് വഴികളിൽ ഒന്ന് ഞങ്ങൾ എപ്പോഴും ഉപയോഗിക്കുന്നു എന്നതാണ് വസ്തുത. കേവല പാത, അല്ലെങ്കിൽ ഒരു ആപേക്ഷിക പാത. പൂർണ്ണ പാതയിൽ ഡ്രൈവിൽ (അല്ലെങ്കിൽ കമ്പ്യൂട്ടറിൻ്റെ നെറ്റ്‌വർക്ക് നാമം) ആരംഭിക്കുന്ന എല്ലാം ഞങ്ങൾ സൂചിപ്പിക്കുന്നു, ഉദാഹരണത്തിന് d:\misha\box\പരീക്ഷ 1.txt. കമാൻഡ് നൽകുമ്പോൾ നിലവിലുള്ള ഡയറക്ടറി ഏതായാലും, മുഴുവൻ പാതയും അതേ ഫയലുമായി പൊരുത്തപ്പെടും. വേണ്ടി ആപേക്ഷിക പാതനിലവിലെ ഡയറക്ടറി ആരംഭ പോയിൻ്റായി പ്രവർത്തിക്കുന്നു. ആപേക്ഷിക പാതയുടെ ഏറ്റവും ലളിതമായ കേസ് ഫയൽ നാമമാണ്. കമാൻഡ് എക്സിക്യൂഷൻ്റെ സന്ദർഭത്തിൽ, നിലവിലെ ഡയറക്ടറിയിൽ സ്ഥിതിചെയ്യുന്ന ആ പേരുള്ള ഒരു ഫയൽ എന്നാണ് ഇതിനർത്ഥം.
നിലവിലുള്ള ഡയറക്ടറിയിലേക്ക് ഒരു ആപേക്ഷിക പാത എഴുതാൻ ഉണ്ട് സോപാധിക നൊട്ടേഷൻ. (ഡോട്ട്). നിലവിലെ ഡയറക്ടറി അടങ്ങുന്ന ഡയറക്ടറിയിലേക്ക് ആപേക്ഷിക പാത രേഖപ്പെടുത്തുന്നതിന്, ഒരു സോപാധിക നൊട്ടേഷൻ ഉണ്ട് .. (രണ്ട് ഡോട്ടുകൾ). ടീംപകർത്തുക *.* .\ പട്ടിക എല്ലാ ഫയലുകളും നിലവിലെ ഡയറക്ടറിയിൽ നിന്ന് ഒരു ഡയറക്ടറിയിലേക്ക് പകർത്തുന്നുമേശ , അതിനടുത്തായി സ്ഥിതിചെയ്യുന്നു.
ബാച്ച് ഫയലുകൾ
ഇതുവരെ, ഉദാഹരണങ്ങൾ നൽകുമ്പോൾ, ഞങ്ങൾ ഓരോ തവണയും മാനുവലായി കമാൻഡുകൾ നൽകുന്നുവെന്ന് ഞങ്ങൾ അനുമാനിച്ചു. ഒരു വലിയ എണ്ണം ഫയലുകൾ പ്രോസസ്സ് ചെയ്യുമ്പോൾ അല്ലെങ്കിൽ ഒരേ കമാൻഡുകൾ വ്യവസ്ഥാപിതമായി നടപ്പിലാക്കുമ്പോൾ, ഇത് ബുദ്ധിമുട്ടാണ്. അതിനാൽ, കമാൻഡ് ഫയലുകൾ എക്സിക്യൂട്ട് ചെയ്യാനുള്ള കഴിവ് കമാൻഡ് പ്രൊസസർ നൽകുന്നു.കമാൻഡുകൾ ടൈപ്പ് ചെയ്യുന്ന ഒരു ടെക്സ്റ്റ് ഫയലാണ് കമാൻഡ് ഫയൽ(അല്ലെങ്കിൽ കുറഞ്ഞത് ഒരു കമാൻഡെങ്കിലും). ഉദാഹരണം ബാച്ച് ഫയൽ:
സഹായം പകർത്തുക > copy.help
നീക്കാൻ സഹായിക്കുക > move.help
md msdos-സഹായം
നീക്കുക *.സഹായം msdos-സഹായം
ടാസ്ക് നമ്പർ 6
- ഈ കമാൻഡുകൾ എക്സിക്യൂട്ട് ചെയ്യുമ്പോൾ എന്താണ് സംഭവിക്കുന്നതെന്ന് വിശദീകരിക്കുക.
കമാൻഡ് ഫയലുകൾ നൽകുന്നത് പതിവാണ് ബാറ്റ് വിപുലീകരണം. ഈ തരത്തിലുള്ള ഫയലുകൾ കമാൻഡ് പ്രോസസർ തിരിച്ചറിയുന്നത് ഇങ്ങനെയാണ്. ഈ ഫയലിനെ വിളിക്കാം, ഉദാഹരണത്തിന്, make-help.bat.
ബാച്ച് ഫയൽ പ്രവർത്തിപ്പിക്കാൻ:
- ഒരു കമാൻഡായി അവൻ്റെ പേര് നൽകുക. ഇതിനുശേഷം, ബാച്ച് ഫയൽ എക്സിക്യൂട്ട് ചെയ്യും.
ഒരു ബാച്ച് ഫയലിൽ, ഓരോ കമാൻഡും ഒരു വരി എടുക്കുന്നു. കൂടുതൽ കൃത്യമായി പറഞ്ഞാൽ, തുടർച്ചയായി നിരവധി ലൈനുകളിൽ ഒരു കമാൻഡ് സ്ഥാപിക്കാൻ ഒരു മാർഗമുണ്ട്; ഇത് ചെയ്യുന്നതിന്, ഓരോ ലൈൻ ബ്രേക്കിനും തൊട്ടുമുമ്പ് നിങ്ങൾ "തൊപ്പി" പ്രതീകം ^ ഇടണം. (ഓരോ തൊപ്പിയും അതിൻ്റെ വരിയിലെ അവസാന പ്രതീകമായിരിക്കണം; അതിന് ശേഷം സ്‌പെയ്‌സുകളോ ടാബുകളോ ഉണ്ടാകരുത്.) ഉദാഹരണം:
നിലവിലുണ്ടെങ്കിൽ Z:\test.txt ^
test.txt ^ പകർത്തുക
Z:\test\
ഒരു ബാച്ച് ഫയൽ എക്സിക്യൂട്ട് ചെയ്യുമ്പോൾ, കമാൻഡ് പ്രോസസർ അത് മുകളിൽ നിന്ന് താഴേക്ക് ആദ്യ വരി മുതൽ അവസാനം വരെ സ്കാൻ ചെയ്യുകയും കമാൻഡുകൾ അവ നേരിടുന്ന ക്രമത്തിൽ നടപ്പിലാക്കുകയും ചെയ്യുന്നു. അവ ഓരോന്നും സ്വമേധയാ നൽകിയതുപോലെ അത് അവയെ മൊത്തത്തിൽ നിർവഹിക്കുന്നു.
ആവശ്യമെങ്കിൽ, നിയന്ത്രണങ്ങൾ ഉപയോഗിച്ച് കമാൻഡ് എക്സിക്യൂഷൻ്റെ ക്രമം മാറ്റാവുന്നതാണ്.
ലോഞ്ച് ചെയ്യേണ്ട ബാച്ച് ഫയൽ സ്ഥിതിചെയ്യുന്ന ഡയറക്ടറിയും നിലവിലെ ഡയറക്ടറിയും ആശയക്കുഴപ്പത്തിലാക്കരുത്. നിലവിലെ ഡയറക്ടറി വർക്ക് ആണെന്ന് പറയാം, അതിൽ ടൂൾസ് ഡയറക്ടറി അടങ്ങിയിരിക്കുന്നു, ടൂൾസ് ഡയറക്ടറി കമാൻഡ് ഫയലുകൾ സംഭരിക്കുന്നു. കമാൻഡ് ടൂളുകൾ\collect-images.bat ഉപയോഗിച്ച് നിങ്ങൾ അവയിലൊന്ന് സമാരംഭിക്കുന്നു. അതിനാൽ, ഈ ബാച്ച് ഫയലിൻ്റെ "കാഴ്ചപ്പാടിൽ നിന്ന്", നിലവിലെ ഡയറക്ടറി ഇപ്പോഴും പ്രവർത്തിക്കും, ടൂളുകളല്ല.
ബാച്ച് ഫയലും അതിൻ്റെ ഔട്ട്പുട്ടും കമൻ്റ് ചെയ്യുന്നു.
echo, rem കമാൻഡുകൾ
ഒരു ബാച്ച് ഫയൽ അടിസ്ഥാനപരമായി ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിൻ്റെ കമാൻഡ് പ്രോസസ്സർ ഭാഷയിൽ എഴുതിയ ഒരു പ്രോഗ്രാമാണ്. പ്രോഗ്രാമിൻ്റെ വാചകം അഭിപ്രായങ്ങളോടൊപ്പം നൽകണം, അതിനാൽ കുറച്ച് സമയത്തിന് ശേഷം നിങ്ങൾ അതിലേക്ക് മടങ്ങുമ്പോൾ, ഈ പ്രോഗ്രാം എന്തുകൊണ്ട് ആവശ്യമാണെന്നും അത് എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്നും നിങ്ങൾ വേദനയോടെ ഓർക്കേണ്ടതില്ല.
MS-DOS കമാൻഡ് സിസ്റ്റം അഭിപ്രായങ്ങൾ സൃഷ്ടിക്കുന്നതിനുള്ള rem കമാൻഡ് നൽകുന്നു. ഇത് ഒരു ഡമ്മി കമാൻഡാണ്, അത് പ്രവർത്തനങ്ങളൊന്നും ചെയ്യേണ്ടതില്ല, എന്നാൽ നിങ്ങളുടെ പേരിന് ശേഷം വരിയിൽ അനിയന്ത്രിതമായ വാചകം എഴുതാൻ നിങ്ങളെ അനുവദിക്കുന്നു. മാത്രമല്ല, കമാൻഡ് പ്രൊസസർ അതിനെ ഒരു വാക്യഘടന പിശകായി കാണുന്നില്ല.
ഉദാഹരണം:
rem ************************************************* ****
rem സഹായ ഫയലുകൾ സൃഷ്ടിക്കുന്നു
സഹായം പകർത്തുക > copy.help
നീക്കാൻ സഹായിക്കുക > move.help
md msdos-സഹായം
നീക്കുക *.സഹായം msdos-സഹായം
ബാച്ച് ഫയലിനെ "ഖണ്ഡികകളായി" വിഭജിക്കുന്ന ശൂന്യമായ വരികൾ ശ്രദ്ധിക്കുക. ഈ ലളിതമായ ട്രിക്ക് നിങ്ങളുടെ ബാച്ച് ഫയൽ കൂടുതൽ വായിക്കാവുന്നതാക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു.
മുകളിലുള്ള ബാച്ച് ഫയൽ എക്സിക്യൂട്ട് ചെയ്യുമ്പോൾ, എല്ലാ കമാൻഡുകളും എക്സിക്യൂട്ട് ചെയ്യുമ്പോൾ സ്ക്രീനിൽ പ്രദർശിപ്പിക്കും, അത് എല്ലായ്പ്പോഴും സൗകര്യപ്രദമല്ല. @echo ഓഫ് കമാൻഡ് ഉപയോഗിച്ച് കമാൻഡ് ഇഷ്യൂസ് പ്രവർത്തനരഹിതമാക്കാം. എക്കോ കമാൻഡിന് മുമ്പുള്ള "ഡോഗ്" ചിഹ്നം അർത്ഥമാക്കുന്നത് ഈ കമാൻഡ് തന്നെ "സൈലൻ്റ്" മോഡിൽ എക്സിക്യൂട്ട് ചെയ്യണം എന്നാണ്. ഞങ്ങൾ എക്കോ ഓഫ് കമാൻഡ് ഉപയോഗിക്കാതെ, ഓരോ കമാൻഡിനും മുന്നിൽ ഒരു "നായ" ഇടുക.
മിക്ക കേസുകളിലും, സ്ക്രീനിൽ (അല്ലെങ്കിൽ ഒരു ഫയലിൽ) ചില സന്ദേശങ്ങൾ പ്രദർശിപ്പിക്കാൻ ഒരു ബാച്ച് ഫയൽ നിങ്ങൾ ആഗ്രഹിക്കുന്നു. ചില സന്ദർഭങ്ങളിൽ ഇവ പിശക് സന്ദേശങ്ങളായിരിക്കാം, മറ്റുള്ളവയിൽ ബാച്ച് ഫയലിൻ്റെ ഉപയോക്താവിന് എന്താണ് സംഭവിക്കുന്നതെന്ന് വിശദീകരിക്കുന്ന വിവര സന്ദേശങ്ങൾ. ഈ നിമിഷം. സന്ദേശങ്ങൾ പ്രദർശിപ്പിക്കാൻ ഒരേ എക്കോ കമാൻഡ് ഉപയോഗിക്കുന്നു. പ്രദർശിപ്പിക്കേണ്ട സന്ദേശത്തിൻ്റെ വാചകം അതിലേക്ക് ഒരു പാരാമീറ്ററായി കൈമാറുന്നു. മെച്ചപ്പെട്ട ബാച്ച് ഫയലിൻ്റെ ഉദാഹരണം:
@എക്കോ ഓഫ്
rem ************************************************* ****
rem കോപ്പി ആൻഡ് മൂവ് കമാൻഡുകൾക്കായി സഹായ ഫയലുകൾ സൃഷ്ടിക്കുന്നു
rem ************************************************* ****
@echo സഹായ ഫയലുകൾ സൃഷ്ടിക്കുന്നു. ഒരു നിമിഷം...
rem സഹായ ഫയലുകൾ സൃഷ്ടിക്കുന്നു
പകർത്താൻ സഹായിക്കുക > പകർത്തുക . സഹായം
നീക്കാൻ സഹായിക്കുക > നീക്കുക . സഹായം
rem സഹായ ഫയലുകൾ സംഭരിക്കുന്നതിന് ഒരു ഡയറക്ടറി സൃഷ്ടിക്കുക
md msdos-സഹായം
rem സഹായ ഫയലുകൾ തയ്യാറാക്കിയ ഡയറക്ടറിയിലേക്ക് നീക്കുക
നീക്കുക *.സഹായം msdos-സഹായം
പ്രതിധ്വനി പൂർത്തിയായി!
ഒരു കമാൻഡ് ഫയലിലേക്ക് പാരാമീറ്ററുകൾ കൈമാറുന്നു
ഉപയോക്തൃ-നിർദിഷ്ട കമാൻഡ് വിവരിക്കുന്നതിനുള്ള സഹായം ആദ്യം സൃഷ്ടിക്കുകയും തുടർന്ന് അത് നോട്ട്പാഡിലേക്ക് ലോഡുചെയ്യുകയും ചെയ്യുന്ന ഒരു ബാച്ച് ഫയൽ സൃഷ്ടിക്കാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നുവെന്ന് പറയാം. അടുത്ത തവണ ബാച്ച് ഫയൽ പ്രവർത്തിപ്പിക്കുമ്പോൾ ഏത് കമാൻഡിലാണ് നമുക്ക് താൽപ്പര്യമുള്ളതെന്ന് എങ്ങനെയെങ്കിലും പറയുക എന്നതാണ് തന്ത്രം.
ഈ പ്രശ്നം പരിഹരിക്കുന്നതിന്, ഒരു പാരാമീറ്റർ പ്രോസസ്സിംഗ് സംവിധാനം നൽകിയിരിക്കുന്നു. ഇത് വളരെ ലളിതമായി പ്രവർത്തിക്കുന്നു. ഒരു കമാൻഡ് ഫയൽ പ്രവർത്തിപ്പിക്കുമ്പോൾ, ഉപയോക്താവ് നിരവധി പാരാമീറ്ററുകൾ വ്യക്തമാക്കിയിട്ടുണ്ടെങ്കിൽ, കമാൻഡ് ഫയലിൻ്റെ വാചകത്തിൽ അവയിൽ ആദ്യത്തേത് % 1 എൻട്രിയും രണ്ടാമത്തേത് % 2 എന്ന എൻട്രിയും മൂന്നാമത്തേത് % 3 എന്ന എൻട്രിയും ഉപയോഗിച്ച് സൂചിപ്പിക്കുന്നു. തുടങ്ങിയവ. സ്വാഭാവിക സംഭാഷണത്തിൽ സർവ്വനാമങ്ങൾ ഉപയോഗിക്കുന്ന അതേ രീതിയിൽ തന്നെ കമാൻഡ് ഫയലിൻ്റെ ടെക്സ്റ്റിൽ ഈ നൊട്ടേഷനുകൾ ഞങ്ങൾ ഉപയോഗിക്കുന്നു.
പ്രശ്നം പരിഹരിക്കുന്ന കമാൻഡ് ഫയലിൻ്റെ ടെക്സ്റ്റ് ചുവടെ നൽകിയിരിക്കുന്നു. സഹായ കമാൻഡ് ശ്രദ്ധിക്കുക. കമാൻഡ് ഫയലിൻ്റെ ആദ്യ പാരാമീറ്റർ അതിൻ്റെ പരാമീറ്ററായി അതിലേക്ക് കൈമാറുന്നു.
@എക്കോ ഓഫ്
rem ഉപയോഗിച്ച് ഒരു ഫയൽ രൂപപ്പെടുത്തുക കമാൻഡ് വിവരണം,
rem ആരുടെ പേര് ഒരു പാരാമീറ്ററായി പാസ്സാക്കുന്നു
സഹായം % 1 > help.tmp
rem നോട്ട്പാഡ് എഡിറ്ററിലേക്ക് വിവരണ ഫയൽ ലോഡ് ചെയ്യുക
നോട്ട്പാഡ് help.tmp
ഈ ബാച്ച് ഫയലിന് show-help.bat എന്ന് നാമകരണം ചെയ്തുവെന്ന് കരുതുക. നോട്ട്പാഡിലേക്ക് ഒരു കമാൻഡ് വിവരണം ലോഡുചെയ്യുന്നതിന്, ഉദാഹരണത്തിന്, dir, നമ്മൾ കമാൻഡ് ഇനിപ്പറയുന്ന രീതിയിൽ നൽകണം: show-help.bat dir
ഇനിപ്പറയുന്ന കമാൻഡ് ഫയൽ ആദ്യത്തെ പാരാമീറ്ററിൽ വ്യക്തമാക്കിയ പേരിനൊപ്പം ഒരു ഡയറക്ടറി സൃഷ്ടിക്കുകയും രണ്ടാമത്തെ പാരാമീറ്ററിൽ വ്യക്തമാക്കിയ കമാൻഡ് വിവരിക്കുന്ന വാചകം ഉപയോഗിച്ച് അതിൽ ഒരു ഫയൽ എഴുതുകയും ചെയ്യുന്നു:
rem രണ്ട് പരാമീറ്ററുകളുള്ള ഒരു കമാൻഡ് ഫയലിൻ്റെ ഉദാഹരണം
rem ആദ്യ പാരാമീറ്റർ വ്യക്തമാക്കിയ പേരിൽ ഒരു ഡയറക്ടറി സൃഷ്ടിക്കുക
md% 1
rem കമാൻഡിൻ്റെ വിവരണത്തോടെ അതിൽ ഒരു ഫയൽ സൃഷ്ടിക്കുക,
rem രണ്ടാമത്തെ പാരാമീറ്റർ വ്യക്തമാക്കുന്നു
സഹായം %2 >%1\%2.help
ഈ ബാച്ച് ഫയൽ പ്രവർത്തിപ്പിക്കുമ്പോൾ ഉപയോക്താവ് രണ്ടിനേക്കാൾ നാല് പാരാമീറ്ററുകൾ വ്യക്തമാക്കിയാൽ എന്ത് സംഭവിക്കും? കുഴപ്പമില്ല, അവർ ഒന്നിലും ഇടപെടില്ല, അവ ഉപയോഗിക്കില്ല. ഉപയോക്താവ് ആദ്യ പാരാമീറ്റർ മാത്രം വ്യക്തമാക്കിയാൽ എന്ത് സംഭവിക്കും? രണ്ടാമത്തെ പാരാമീറ്റർ ശൂന്യമായിരിക്കും. ഇഫക്റ്റ് ഇതായിരിക്കും: ബാച്ച് ഫയൽ എക്സിക്യൂട്ട് ചെയ്യപ്പെടും, പക്ഷേ % 2 എൻട്രിയുടെ സ്ഥാനത്ത് ഒന്നുമില്ല എന്ന മട്ടിൽ. ഹെൽപ്പ് കമാൻഡ് എല്ലാ കമാൻഡുകളുടെയും ഒരു ലിസ്റ്റ് സൃഷ്ടിക്കുകയും അതിനൊപ്പം ഒരു ഫയലിൽ സ്ഥാപിക്കുകയും ചെയ്യും ശൂന്യമായ പേര്ഒപ്പം വിപുലീകരണം .സഹായം. ഒരു പരാമീറ്ററുകളും വ്യക്തമാക്കാതെ ഉപയോക്താവ് ഈ ഫയൽ പ്രവർത്തിപ്പിക്കുകയാണെങ്കിൽ, കമാൻഡ് പ്രൊസസർ md കമാൻഡ് (ഒരു ഡയറക്ടറി സൃഷ്ടിക്കാൻ ഉദ്ദേശിച്ചുള്ളത്) എക്സിക്യൂട്ട് ചെയ്യാൻ ശ്രമിക്കുമ്പോൾ, ഒരു സന്ദേശം വാക്യഘടന പിശക്, md കമാൻഡിന് ഒരു പരാമീറ്റർ ഉണ്ടായിരിക്കണം.
അതിനാൽ, പാരാമീറ്ററുകൾ ഉപയോഗിക്കുന്നത് മികച്ച അവസരങ്ങൾ സൃഷ്ടിക്കുന്നു, പക്ഷേ കാര്യങ്ങളെ ഗണ്യമായി സങ്കീർണ്ണമാക്കും. ബാച്ച് ഫയൽ എല്ലായ്പ്പോഴും ശരിയായി പ്രവർത്തിക്കുന്നതിന്, ഉപയോക്താവിൻ്റെ നിർദ്ദിഷ്ട പാരാമീറ്ററുകളുടെ കൃത്യത പരിശോധിക്കുകയും അപൂർണ്ണമായ അല്ലെങ്കിൽ തെറ്റായ ഇൻപുട്ട് ഡാറ്റയോട് എങ്ങനെയെങ്കിലും പ്രതികരിക്കുകയും ചെയ്യേണ്ടത് ആവശ്യമാണ്.
വേരിയബിളുകൾ. കമാൻഡ് സജ്ജമാക്കുക
ഒരു വേരിയബിൾ എന്നത് പേരിട്ടിരിക്കുന്ന മൂല്യമാണ്. ഒരു വേരിയബിൾ പ്രഖ്യാപിക്കാനും അതേ സമയം അതിന് ഒരു മൂല്യം നൽകാനും, സെറ്റ് കമാൻഡ് ഉപയോഗിക്കുക. ഈ കമാൻഡിൻ്റെ ഒരു ഉദാഹരണം ഇനിപ്പറയുന്ന ലിസ്റ്റിംഗിൽ കാണിച്ചിരിക്കുന്നു.
rem CHM ഫോർമാറ്റിലുള്ള സഹായ ഫയലുകളുടെ കംപൈലർ
help_compiler= സജ്ജമാക്കുക
ഒരു വേരിയബിളിൻ്റെ മൂല്യം എക്‌സ്‌ട്രാക്‌റ്റുചെയ്യുന്നതിന്, ചുവടെ കാണിച്ചിരിക്കുന്നതുപോലെ അതിൻ്റെ പേര് രണ്ട് ശതമാനം ചിഹ്നങ്ങൾക്കിടയിൽ സ്ഥാപിച്ചിരിക്കുന്നു.
rem CHM ഫോർമാറ്റിലുള്ള സഹായ ഫയലുകളുടെ കംപൈലർ
help_compiler= സജ്ജമാക്കുക സി:\പ്രോഗ്രാം ഫയലുകൾ\HTML സഹായ വർക്ക്ഷോപ്പ്\hhc.exe
"വെയർഹൗസ്" മൊഡ്യൂളിനായുള്ള rem പ്രോജക്റ്റ് സഹായ ഫയൽ
set store_hpj=”Z:\store.hpj”
rem പ്രൊജക്റ്റ് ഹെൽപ്പ് ഫയൽ "സെയിൽസ്" മൊഡ്യൂളിനായി
set sales_hpj=”Z:\sales.hpj”
rem സഹായ ഫയലുകൾ കംപൈൽ ചെയ്യുക
%help_compiler% %store_hpj%
%help_compiler% %sales_hpj%
വേരിയബിളുകൾ ഉപയോഗപ്രദമാകുന്നത് എന്തുകൊണ്ടാണെന്ന് ഈ ഉദാഹരണം കാണിക്കുന്നു.
ഒന്നാമതായി, ഒരു നീണ്ട ശകലത്തിന് പകരം ഒരു ബാച്ച് ഫയലിനുള്ളിൽ അതിൻ്റെ പര്യായമായ ഒരു ചെറിയ ശകലം ഉപയോഗിക്കാൻ അവർ നിങ്ങളെ അനുവദിക്കുന്നു (ഉദാഹരണത്തിന്, സഹായ ഫയൽ കംപൈലറിലേക്കുള്ള പാത); ഇത് സൗകര്യപ്രദമാണ്.
രണ്ടാമതായി, ഭാവിയിൽ മാറിയേക്കാവുന്ന ശകലങ്ങളുടെ കമാൻഡ് ഫയലിൻ്റെ വാചകത്തിൽ ആവർത്തനം ഒഴിവാക്കാൻ അവ നിങ്ങളെ അനുവദിക്കുന്നു.
ബാച്ച് ഫയൽ പാരാമീറ്ററുകളും വേരിയബിളുകളാണ്, പക്ഷേ അവ സാധാരണ വേരിയബിളുകളിൽ നിന്ന് വ്യത്യസ്തമാണ്, ബാച്ച് ഫയൽ സമാരംഭിക്കുമ്പോൾ അവയുടെ മൂല്യങ്ങൾ സജ്ജീകരിച്ചിരിക്കുന്നു. ഭാവിയിൽ, വേരിയബിളുകളെക്കുറിച്ച് സംസാരിക്കുമ്പോൾ, പ്രത്യേകിച്ച് അവയുടെ മൂല്യങ്ങളുമായി പ്രവർത്തിക്കുമ്പോൾ, ഞങ്ങൾ കമാൻഡ് ഫയൽ പാരാമീറ്ററുകൾ അർത്ഥമാക്കും, കുറഞ്ഞത് ഇതിനെക്കുറിച്ച് വ്യക്തമായ റിസർവേഷനുകളുടെ അഭാവത്തിൽ.
ബാച്ച് ഫയലുകൾ എഴുതുമ്പോൾ, ഇനിപ്പറയുന്ന സാങ്കേതികത പലപ്പോഴും ഉപയോഗിക്കുന്നു: കുറച്ച് പുതിയ അർത്ഥവത്തായ മൂല്യം ലഭിക്കുന്നതിന്, നിരവധി വേരിയബിൾ മൂല്യങ്ങൾ വശങ്ങളിലായി സൂചിപ്പിച്ചിരിക്കുന്നു (അല്ലെങ്കിൽ ചില ചിഹ്നങ്ങളോ വരികളോ ഉപയോഗിച്ച് വിഭജിച്ചിരിക്കുന്നു).
ഉദാഹരണം:
help_compiler = സി:\പ്രോഗ്രാം ഫയലുകൾ\HTML സഹായ വർക്ക്ഷോപ്പ്\hhc.exe" സജ്ജമാക്കുക
project_path=”Z:\ സജ്ജമാക്കുക<ваша_папка>\സഹായം"
വ്യവസ്ഥകൾ പരിശോധിച്ച് ഓപ്ഷനുകൾ തിരഞ്ഞെടുക്കുന്നു. if and goto കമാൻഡുകൾ
ചില വ്യവസ്ഥകൾക്കനുസരിച്ച് എക്സിക്യൂട്ട് ചെയ്യുന്നതോ അല്ലെങ്കിൽ എക്സിക്യൂട്ട് ചെയ്യാത്തതോ ആയ ഒരു ബാച്ച് ഫയലിലെ കമാൻഡുകളുടെ ഗ്രൂപ്പുകൾ തിരഞ്ഞെടുക്കാൻ if കമാൻഡ് നിങ്ങളെ അനുവദിക്കുന്നു. ഇതെന്തിനാണു?
അവസ്ഥ പരിശോധന ഏതാണ്ട് ആവശ്യമായ അളവ്പാരാമീറ്ററുകൾ ഉപയോഗിക്കുന്ന ബാച്ച് ഫയലുകൾ സൃഷ്ടിക്കുമ്പോൾ. ജോലി ആരംഭിക്കുന്നതിന് മുമ്പ്, ബാച്ച് ഫയലിന് ശരിയായ പാരാമീറ്ററുകൾ കൈമാറിയിട്ടുണ്ടെന്ന് ഉറപ്പാക്കേണ്ടതുണ്ട്. അല്ലാത്തപക്ഷം, അത് തെറ്റായി അല്ലെങ്കിൽ നിഷ്ഫലമായോ എക്സിക്യൂട്ട് ചെയ്യപ്പെടാനുള്ള ഉയർന്ന അപകടസാധ്യതയുണ്ട്, മാത്രമല്ല പ്രശ്നം എന്താണെന്ന് ഉപയോക്താവ് ചിന്തിക്കുകയും ചെയ്യും. കൂടാതെ, ഒരു ബാച്ച് ഫയൽ ഏതെങ്കിലും ഡാറ്റ ഇല്ലാതാക്കുകയോ നീക്കുകയോ അല്ലെങ്കിൽ പുനരാലേഖനം ചെയ്യുകയോ ചെയ്താൽ, പാരാമീറ്ററുകൾ തെറ്റാണെങ്കിൽ പോലും അത് കേടുപാടുകൾ വരുത്തും.
ഇനിപ്പറയുന്ന ഉദാഹരണം നിങ്ങൾക്ക് ഇതിനകം പരിചിതമായ സഹായ ഫയൽ കംപൈലേഷൻ കമാൻഡ് ഫയൽ കാണിക്കുന്നു. കമാൻഡ് ഫയലിൻ്റെ തുടക്കത്തിൽ ആദ്യത്തെ പാരാമീറ്ററിൻ്റെ ശൂന്യതയ്ക്കുള്ള ഒരു പരിശോധന ചേർത്തിരിക്കുന്നു. ഈ വാക്യഘടനയുടെ സവിശേഷത ശ്രദ്ധിക്കുക: താരതമ്യ പ്രവർത്തനം ഇരട്ട തുല്യ ചിഹ്നം ഉപയോഗിക്കുന്നു. ആദ്യ പാരാമീറ്റർ ശൂന്യമല്ലെങ്കിൽ, goto കമാൻഡ് എക്സിക്യൂട്ട് ചെയ്യുന്നു, അത് ഷെല്ലിനെ നിർദ്ദിഷ്ട ലേബലിലേക്ക് "എറിയുന്നു". IN ഈ സാഹചര്യത്തിൽഈ ലേബലിൻ്റെ പേര് കംപൈൽ എന്നാണ്. ഒരു ലേബൽ ദൃശ്യമാകുന്നിടത്ത്, അതിൻ്റെ പേരിന് മുമ്പായി ഒരു കോളൻ ഉണ്ടെന്ന് ശ്രദ്ധിക്കുക, എന്നാൽ ഗോട്ടോ കമാൻഡിൽ അത് ഇല്ല. ആദ്യ പാരാമീറ്റർ ശൂന്യമാണെങ്കിൽ, ഷെൽ അടുത്ത വരിയിലേക്ക് നീങ്ങുന്നു, അത് ഒരു പിശക് സന്ദേശം നൽകുന്നു. തുടർന്ന് അടുത്തതിലേക്ക്, അത് ഫയലിൻ്റെ അവസാനഭാഗത്തേക്ക് ഫിനിഷ് എന്ന ലേബലിലേക്ക് മാറ്റുന്നു.
@എക്കോ ഓഫ്
ഇല്ലെങ്കിൽ "%1"=="" കംപൈൽ ചെയ്യുക
echo സഹായ ഫയലിൻ്റെ പ്രോജക്ടിൻ്റെ പേര് വ്യക്തമാക്കിയിട്ടില്ല
rem, ബാച്ച് ഫയലിൻ്റെ അവസാനത്തിലേക്ക് പോകുക
rem to ഫിനിഷ് മാർക്ക്
പൂർത്തിയാക്കണം
rem ഇതൊരു കംപൈൽ എന്ന ലേബലാണ്
: സമാഹരിക്കുക
സഹായ ഫയൽ കമ്പൈലറിലേക്കുള്ള rem പാത്ത്
help_compiler = "c:\Program Files\HTML സഹായ വർക്ക്ഷോപ്പ്\hhc.exe" സജ്ജമാക്കുക
സഹായ ഫയൽ പ്രോജക്റ്റുകൾ സ്ഥിതി ചെയ്യുന്ന ഡയറക്ടറിയിലേക്കുള്ള പാത rem
project_path=”Z:\ സജ്ജമാക്കുക<ваша_папка>\സഹായം"
rem ഒരു നിർദ്ദിഷ്ട പ്രോജക്റ്റ് പ്രോസസ്സ് ചെയ്യുന്നതിന് കംപൈലറിനെ വിളിക്കുക,
rem ആരുടെ പേര് ആദ്യ പാരാമീറ്ററിൽ പാസ്സാക്കിയിരിക്കുന്നു
%help_compiler% %project_path%\% 1.hpj
rem ഇതൊരു പേരുള്ള ലേബലാണ്പൂർത്തിയാക്കുക
: പൂർത്തിയാക്കുക
പരാമീറ്റർ പരിശോധിക്കുന്നതിനുള്ള നിർദ്ദിഷ്ട രീതി ഏറ്റവും വിജയകരമല്ല.
ആദ്യം, ഉപയോക്താവ് ഒരു പാരാമീറ്ററായി നിലവിലില്ലാത്ത ഫയലിൻ്റെ പേര് തെറ്റായി വ്യക്തമാക്കിയാൽ, ബാച്ച് ഫയൽ ഇതിൽ തൃപ്തിപ്പെടുകയും കംപൈൽ ചെയ്യാൻ ശ്രമിക്കുകയും ചെയ്യും. അത്തരമൊരു ഫയൽ യഥാർത്ഥത്തിൽ നിലവിലുണ്ടോ എന്ന് പരിശോധിക്കുന്നതാണ് മികച്ച മാർഗം. ഈ ആവശ്യത്തിനായി, MS-DOS കമാൻഡ് ഭാഷ നൽകുന്നു പ്രത്യേക വാക്ക്നിലവിലുണ്ട്. അതിനാൽ, എഴുതുന്നതാണ് നല്ലത്: നിലവിലുണ്ടെങ്കിൽ %1.hpj goto compile.
രണ്ടാമതായി, ഗോട്ടോ കമാൻഡിൻ്റെയും (നിരുപാധിക ജമ്പ് എന്ന് വിളിക്കപ്പെടുന്നവ) ലേബലുകളുടെയും സജീവ ഉപയോഗം കോഡിനെ വളരെയധികം ആശയക്കുഴപ്പത്തിലാക്കുന്നു. സാങ്കേതികമായി, അവ മോശമല്ല, എന്നാൽ ഈ ശൈലിയിൽ എഴുതിയ ഒരു ബാച്ച് ഫയൽ ഡീബഗ്ഗ് ചെയ്യുകയും പരിപാലിക്കുകയും ചെയ്യുന്നത് തികച്ചും അസൗകര്യമാണ്. അതിനാൽ, പ്രോഗ്രാമർമാർ വളരെക്കാലമായി നിരുപാധികമായ ജമ്പിംഗ് അഭികാമ്യമല്ലാത്ത സാങ്കേതികതയായി കണക്കാക്കുന്നു. പ്രോഗ്രാമിംഗ് ശൈലിയുടെ വീക്ഷണകോണിൽ നിന്ന് കൂടുതൽ ശരിയായത് ചുവടെ കാണിച്ചിരിക്കുന്നു, ഘടനാപരമായ പതിപ്പ്, അത് if...else construct ഉപയോഗിക്കുന്നു. ഇത് ഇതുപോലെ പ്രവർത്തിക്കുന്നു: വ്യവസ്ഥ ശരിയാണെങ്കിൽ, if ന് ശേഷമുള്ള പരാൻതീസിസിലെ കമാൻഡുകൾ എക്സിക്യൂട്ട് ചെയ്യുന്നു, തെറ്റാണെങ്കിൽ, മറ്റൊന്നിന് ശേഷമുള്ള പരാൻതീസിസിലെ കമാൻഡുകൾ എക്സിക്യൂട്ട് ചെയ്യുന്നു.
@എക്കോ ഓഫ്
rem പരാമീറ്റർ സജ്ജീകരിച്ചിട്ടുണ്ടോയെന്ന് പരിശോധിക്കുക
നിലവിലില്ലെങ്കിൽ % 1.hpj (
Rem പാരാമീറ്റർ ശൂന്യമാണെങ്കിൽ, ഞങ്ങൾ ഒരു പിശക് സന്ദേശം പ്രദർശിപ്പിക്കുന്നു
) വേറെ (
കംപൈലേഷൻ കമാൻഡുകൾ ചുവടെയുണ്ട്
സഹായ ഫയൽ കമ്പൈലറിലേക്കുള്ള റെം പാത്ത്
help_compiler = "C:\Program Files\HTML സഹായ വർക്ക്ഷോപ്പ്\hhc.exe" സജ്ജമാക്കുക
സഹായ ഫയൽ പ്രോജക്റ്റുകൾ സ്ഥിതി ചെയ്യുന്ന ഡയറക്ടറിയിലേക്കുള്ള പാത rem
project_path=”Z:\ സജ്ജമാക്കുക<ваша_папка>\സഹായം"
rem ഒരു നിർദ്ദിഷ്ട പ്രോജക്റ്റ് പ്രോസസ്സ് ചെയ്യുന്നതിന് കംപൈലറിനെ വിളിക്കുക,
ആദ്യ പാരാമീറ്ററിൽ പേര് നൽകിയ റെം
%help_compiler% %project_path%\% 1.hpj
ചെക്കുകളുമായി പ്രവർത്തിക്കുന്നതിനുള്ള മറ്റൊരു ഉദാഹരണം നൽകാം. ഇനിപ്പറയുന്ന ബാച്ച് ഫയൽ സഹായ ഫയലുകൾ എന്ന പേരിൽ ഒരു ഡയറക്ടറി സൃഷ്ടിക്കുന്നു (കംപൈൽ ചെയ്ത സഹായ ഫയലുകൾ അതിലേക്ക് വലിച്ചെറിയുമെന്ന് കരുതുക). മാത്രമല്ല, അതേ പേരിൽ ഒരു ഡയറക്ടറി നിലവിലുണ്ടെങ്കിൽ (നിങ്ങൾ നഷ്‌ടപ്പെടാൻ ആഗ്രഹിക്കാത്ത പഴയ സഹായ ഫയലുകൾ അതിൽ അടങ്ങിയിരിക്കാം: പുതിയവ മോശമായാൽ എന്ത് ചെയ്യും?), ബാച്ച് ഫയൽ അതിന് bak വിപുലീകരണം നൽകുന്നു. . എന്നാൽ help-files.bak എന്ന ഡയറക്ടറി നിലവിലുണ്ടെങ്കിൽ, ബാച്ച് ഫയൽ അത് ഇല്ലാതാക്കുന്നു (ഞങ്ങൾക്ക് ഒരു ബാക്കപ്പ് കോപ്പി മതിയെന്ന് ഞങ്ങൾ അനുമാനിക്കും).
നിലവിലുണ്ടെങ്കിൽ help-files.bak rd help-files.bak
നിലവിലുണ്ടെങ്കിൽ സഹായ ഫയലുകൾ റെൻ സഹായ ഫയലുകൾ help-files.bak
md സഹായ ഫയലുകൾ
ബൾക്ക് ഫയൽ പ്രോസസ്സിംഗ്. കമാൻഡിനായി
ഒരേ തരത്തിലുള്ള ആവർത്തിച്ചുള്ള പ്രവർത്തനങ്ങളുടെ നിർവ്വഹണം സംഘടിപ്പിക്കാൻ ഫോർ കമാൻഡ് നിങ്ങളെ അനുവദിക്കുന്നു. ഇനിപ്പറയുന്ന ലിസ്റ്റിംഗിൽ കാണിച്ചിരിക്കുന്നതുപോലെ ഒന്ന് മുതൽ പത്ത് വരെയുള്ള അക്കങ്ങൾ പ്രദർശിപ്പിക്കാൻ നിങ്ങൾക്ക് ഇത് ഉപയോഗിക്കാം.
(1,1,10) ൽ /l %%i എന്നതിന് %%i എക്കോ ചെയ്യുക
ഐ എന്ന വേരിയബിളിനെ ലൂപ്പ് കൗണ്ടർ എന്ന് വിളിക്കുന്നു. ഫോർ കമാൻഡിൻ്റെ അദ്വിതീയ വാക്യഘടന കാരണം, ലൂപ്പ് കൗണ്ടറിൻ്റെ പേരിൽ ഒരു അക്ഷരം ഉണ്ടായിരിക്കണം. മാത്രമല്ല, ഞങ്ങൾ ഒരു ബാച്ച് ഫയൽ എഴുതുകയാണെങ്കിൽ, ലൂപ്പ് കൗണ്ടറിൻ്റെ പേരിന് മുന്നിൽ ഇരട്ട ശതമാനം അടയാളം ഇടേണ്ടതുണ്ട്, എന്നാൽ ഞങ്ങൾ കമാൻഡ് ലൈനിൽ ഒരു കമാൻഡ് ടൈപ്പുചെയ്യുകയാണെങ്കിൽ, ഒരൊറ്റ ഒന്ന്.
ഈ കമാൻഡിൻ്റെ യുക്തി ഇപ്രകാരമാണ്. ലൂപ്പ് കൗണ്ടറിൻ്റെ മാറ്റത്തിൻ്റെ പരിധിയിലുള്ള വാക്കിന് ശേഷം സൂചിപ്പിച്ചിരിക്കുന്നു. IN ഈ ഓപ്ഷൻകമാൻഡുകൾ സംഖ്യകളുടെ മൂന്നിരട്ടിയാണ്: കൗണ്ടറിൻ്റെ പ്രാരംഭ മൂല്യം, കൗണ്ടിംഗ് ഘട്ടം, കൗണ്ടറിൻ്റെ പരിധി മൂല്യം. ഒരു കമാൻഡ് എക്സിക്യൂട്ട് ചെയ്യുമ്പോൾ, കമാൻഡ് പ്രോസസർ ആദ്യം വേരിയബിൾ i ന് മൂല്യം 1 നൽകും, തുടർന്ന് ലൂപ്പിൻ്റെ ഓരോ ഘട്ടത്തിലും അത് 10 കവിയുന്നത് വരെ 1 വർദ്ധിപ്പിക്കും. വ്യക്തമായും, അത്തരം പത്ത് ഘട്ടങ്ങൾ ഉണ്ടാകും. കൗണ്ടിംഗ് സ്റ്റെപ്പായി ഞങ്ങൾ നമ്പർ 2 വ്യക്തമാക്കിയിരുന്നെങ്കിൽ, ലൂപ്പ് അഞ്ച് തവണ എക്സിക്യൂട്ട് ചെയ്യുമായിരുന്നു. ലൂപ്പിൻ്റെ ഓരോ ഘട്ടത്തിലും, do എന്ന വാക്കിന് ശേഷം എഴുതിയ ലൂപ്പിൻ്റെ ബോഡി എക്സിക്യൂട്ട് ചെയ്യുന്നു. മുകളിലുള്ള ഉദാഹരണത്തിൽ, ഇതാണ് എക്കോ കമാൻഡ്, ഇത് ലൂപ്പ് കൗണ്ടറിൻ്റെ നിലവിലെ മൂല്യം പ്രദർശിപ്പിക്കുന്നു.
യഥാർത്ഥത്തിൽ ഇതുപോലൊന്ന് ആവശ്യമുള്ള ഒരു സാഹചര്യത്തെക്കുറിച്ച് നിങ്ങൾക്ക് ചിന്തിക്കാം, പക്ഷേ സാധാരണയായി ഫോർ കമാൻഡ് ഫയലുകളിലൂടെ ആവർത്തിക്കാനും പ്രോസസ്സ് ചെയ്യാനും ഉപയോഗിക്കുന്നു. വളരെ ലളിതമായ സന്ദർഭങ്ങളിൽ, വൈൽഡ്കാർഡ് പ്രതീകങ്ങൾ ഉപയോഗിച്ചാണ് ബൾക്ക് ഫയൽ പ്രോസസ്സിംഗ് നടത്തുന്നത് എന്ന് പറയണം. നിലവിലെ ഡയറക്ടറിയിലെ എല്ലാ ഫയലുകൾക്കുമായി .htm എന്ന വിപുലീകരണത്തെ .html ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കണമെങ്കിൽ, നമ്മൾ ren *.htm *.html കമാൻഡ് നൽകുക. എന്നാൽ ഒരേ കാര്യം ഒരു ഡയറക്‌ടറിയിലല്ല, ഒരു ഡയറക്ടറി ട്രീയിലാണ് ചെയ്യേണ്ടതെങ്കിൽ, for കമാൻഡ് ഇല്ലാതെ നിങ്ങൾക്ക് ചെയ്യാൻ കഴിയില്ല. നിലവിലെ ഡയറക്ടറിയുടെ വെബ്‌സൈറ്റ് ഉപഡയറക്‌ടറിയിലെ എല്ലാ htm ഫയലുകൾക്കുമായി ഇനിപ്പറയുന്ന ബാച്ച് ഫയൽ ഈ പ്രവർത്തനം നടത്തുന്നു. കൂടുതൽ കൃത്യമായി പറഞ്ഞാൽ, വെബ്‌സൈറ്റിനുള്ളിൽ സ്ഥിതിചെയ്യുന്ന മുഴുവൻ ഡയറക്ടറി ട്രീയിലും.
/r വെബ്‌സൈറ്റിനായി %%i-ൽ (*.htm) ചെയ്യുക %%i %%~ni.html
/r സ്വിച്ച് വെബ്‌സൈറ്റ് ഡയറക്‌ടറിയിലും അതിൻ്റെ എല്ലാ ഇൻ്റേണലുകളിലും സഞ്ചരിക്കേണ്ടതിൻ്റെ ആവശ്യകതയെ സൂചിപ്പിക്കുന്നു. നിങ്ങൾ അത് വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ (എന്നാൽ നിങ്ങൾക്ക് ഒരു ഡയറക്ടറി വ്യക്തമാക്കാൻ അനുവാദമില്ല), അപ്പോൾ നിലവിലുള്ള ഡയറക്ടറിയിലെ ഫയലുകൾ മാത്രമേ പ്രോസസ്സ് ചെയ്യപ്പെടുകയുള്ളൂ. കമാൻഡിൻ്റെ ഈ പതിപ്പിലെ ലൂപ്പ് കൗണ്ടറിനായുള്ള മൂല്യങ്ങളുടെ ശ്രേണി വെബ്‌സൈറ്റിൻ്റെ ഡയറക്ടറി (കൂടുതൽ കൃത്യമായി പറഞ്ഞാൽ, ട്രീ) ഉള്ളിൽ സ്ഥിതിചെയ്യുന്ന .htm വിപുലീകരണമുള്ള എല്ലാ ഫയലുകളുടെയും സെറ്റാണ്. ഒറ്റനോട്ടത്തിൽ വിചിത്രമായി തോന്നുന്ന ~ni എന്ന നൊട്ടേഷൻ അർത്ഥമാക്കുന്നത് i എന്ന വേരിയബിളിൻ്റെ മൂല്യത്തിൽ നിന്ന് ഫയലിൻ്റെ പേര് മാത്രം വേർതിരിച്ചെടുത്താൽ മതി എന്നാണ്. MS-DOS കമാൻഡ് ഭാഷ അത്തരം നിരവധി മോഡിഫയറുകൾ നൽകുന്നു, ഉദാഹരണത്തിന്, എൻട്രി ~xi ഫയൽ എക്സ്റ്റൻഷനെ സൂചിപ്പിക്കുന്നു. എല്ലാ മോഡിഫയറുകളും ഫോർ കമാൻഡ് സഹായത്തിൽ വിവരിച്ചിരിക്കുന്നു.
ഒരു ലൂപ്പിൻ്റെ ബോഡിയിൽ പരാൻതീസിസിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്ന നിരവധി കമാൻഡുകൾ അടങ്ങിയിരിക്കാം.
@എക്കോ ഓഫ്
/r വെബ്‌സൈറ്റിനായി %%i (*.htm) ചെയ്യുക (
rem ഫയലിൻ്റെ പേര് പ്രിൻ്റ് ചെയ്യുക
എക്കോ %%i
Rem ഫയലിൻ്റെ പേര് മാറ്റുക
റെൻ %%i %%~ni.html
മറ്റൊരു ബാച്ച് ഫയലിലേക്ക് നിയന്ത്രണം കൈമാറുന്നു. കോൾ കമാൻഡ്
ഒരു ബാച്ച് ഫയലിൽ നിന്ന് മറ്റൊരു ബാച്ച് ഫയലിനെ വിളിക്കാൻ സാധിക്കും. ഇതിനായി കോൾ കമാൻഡ് ഉപയോഗിക്കുന്നു. കൊള്ളാം, കോളിംഗ് ബാച്ച് ഫയലിൽ വ്യക്തമാക്കിയിരിക്കുന്ന വേരിയബിളുകൾ വിളിക്കപ്പെടുന്നവയ്ക്ക് "ദൃശ്യമാണ്". തിരിച്ചും, വിളിച്ച ഫയൽ അതിൻ്റെ ജോലി പൂർത്തിയാക്കി കോളർക്ക് നിയന്ത്രണം തിരികെ നൽകിയ ശേഷം, രണ്ടാമത്തേത് "ഹെറിറ്റൻസ്" എന്ന് വിളിക്കുന്ന വേരിയബിളുകൾ "കാണും". ബാച്ച് ഫയൽ ഡെവലപ്പറെ ഇതുപോലുള്ള എന്തെങ്കിലും ചെയ്യാൻ ഇത് അനുവദിക്കുന്നു: നിരവധി കമാൻഡ് ഫയലുകൾ ഒരേ മൂല്യങ്ങൾ ഉപയോഗിക്കേണ്ടതുണ്ടെങ്കിൽ, ഉദാഹരണത്തിന്, ചില ഫയലുകളിലേക്കുള്ള പാതകൾ, അവ ഒരു പ്രത്യേക കമാൻഡ് ഫയലിൽ സ്ഥാപിക്കാൻ കഴിയും, അത് ഒരു കോൺഫിഗറേഷൻ ഫയലിൻ്റെ പങ്ക് വഹിക്കും. പ്രവർത്തിക്കുന്ന ഓരോ കമാൻഡ് ഫയലും കോൺഫിഗറേഷൻ ഫയലിലേക്കുള്ള ഒരു കോളിൽ തുടങ്ങും. വഴി മാറുമ്പോൾ ഒന്നിൽ മാത്രം മാറ്റം വരുത്തിയാൽ മതിയെന്നതാണ് നേട്ടം കോൺഫിഗറേഷൻ ഫയൽ, പല തൊഴിലാളികളിലേക്കും അല്ല.
"കോൺഫിഗറേഷൻ" ബാച്ച് ഫയൽ config.bat.
സഹായ ഫയൽ കമ്പൈലറിലേക്കുള്ള rem പാത്ത്
help_compiler = "C:\Program Files\HTML സഹായ വർക്ക്ഷോപ്പ്\hhc.exe" സജ്ജമാക്കുക
സഹായ ഫയൽ പ്രോജക്റ്റുകൾ സ്ഥിതി ചെയ്യുന്ന ഡയറക്ടറിയിലേക്കുള്ള പാത rem
project_path = "Z:\ സജ്ജമാക്കുക<ваша_папка>\സഹായം"
"പ്രവർത്തിക്കുന്ന" ബാച്ച് ഫയൽ.
@എക്കോ ഓഫ്
rem വേരിയബിളുകൾ സജ്ജീകരിക്കുന്നു
config.bat എന്ന് വിളിക്കുക
rem പരാമീറ്റർ സജ്ജീകരിച്ചിട്ടുണ്ടോയെന്ന് പരിശോധിക്കുക
നിലവിലില്ലെങ്കിൽ % 1.hpj (
Rem പാരാമീറ്റർ ശൂന്യമാണെങ്കിൽ, ഞങ്ങൾ ഒരു പിശക് സന്ദേശം പ്രദർശിപ്പിക്കുന്നു
എക്കോ അത്തരം സഹായ ഫയൽ പ്രോജക്റ്റ് നിലവിലില്ല.
) വേറെ (
കംപൈലേഷൻ കമാൻഡുകൾ ചുവടെയുണ്ട്
ഒരു നിർദ്ദിഷ്ട പ്രോജക്റ്റ് പ്രോസസ്സ് ചെയ്യുന്നതിന് Rem കംപൈലറിനെ വിളിക്കുക,
ആദ്യ പാരാമീറ്ററിൽ പേര് നൽകിയ റെം
%help_compiler% %project_path%\% 1.hpj
കുറിപ്പുകൾ
FAR കമാൻഡുകൾ (കീബോർഡ് കുറുക്കുവഴികൾ):
- Ctrl+ O കൺസോളിനും ഷെല്ലിനും ഇടയിൽ മാറുക
- ഇടത് പാനലിനായി Alt+F1 ഡ്രൈവ് തിരഞ്ഞെടുക്കുക
- Alt+F2 പാനലിനായി ഡ്രൈവ് തിരഞ്ഞെടുക്കുക
- F1 സഹായം
- എഫ് 2 എഡിറ്റുചെയ്ത ഫയൽ സംരക്ഷിക്കുന്നു
- എഫ് 3 കാണുന്നതിനായി ഫയൽ തുറക്കുക
- എഫ് 4 എഡിറ്റിംഗിനായി ഫയൽ തുറക്കുക
- ഷിഫ്റ്റ് + എഫ് 4 സൃഷ്ടിക്കുക പുതിയ ഫയൽ
- F5 കോപ്പി ഫയൽ/ഡയറക്ടറി
- F5 ഫയൽ/ഡയറക്ടറി നീക്കുക
- എഫ് 7 സൃഷ്ടിക്കുക പുതിയ കാറ്റലോഗ്
- F8 നിലവിലെ (തിരഞ്ഞെടുത്ത) ഫയൽ/ഡയറക്ടറി ഇല്ലാതാക്കുക
- F9 പ്രധാന (മുകളിൽ) മെനു
- എഫ് 10 ഔട്ട്പുട്ട്
- പ്രോഗ്രാമിനൊപ്പം നിലവിലുള്ള (തിരഞ്ഞെടുത്ത) ഫയൽ സമാരംഭിക്കുക (കമാൻഡ് ഫയൽ ഉൾപ്പെടെ)
കമാൻഡ് ഷെൽ ഭാഷ(ഷെൽ, ഷെൽ എന്ന് വിവർത്തനം ചെയ്തിരിക്കുന്നത്) യഥാർത്ഥത്തിൽ വളരെ ഉയർന്ന തലത്തിലുള്ള പ്രോഗ്രാമിംഗ് ഭാഷയാണ്. ഈ ഭാഷയിൽ, ഉപയോക്താവ് കമ്പ്യൂട്ടറിനെ നിയന്ത്രിക്കുന്നു. സാധാരണഗതിയിൽ, ലോഗിൻ ചെയ്ത ശേഷം, നിങ്ങൾ ആശയവിനിമയം ആരംഭിക്കുന്നു കമാൻഡ് ഷെൽ. കമാൻഡുകൾ സ്വീകരിക്കാൻ ഷെൽ തയ്യാറാണ് എന്നതിൻ്റെ സൂചനയാണ് സ്ക്രീനിൽ അത് പ്രദർശിപ്പിക്കുന്ന പ്രോംപ്റ്റർ. ഏറ്റവും ലളിതമായ സാഹചര്യത്തിൽ ഇത് ഒരു ഡോളറാണ് ("$"). ഷെൽ ആവശ്യമില്ല, ഒരേയൊരു കമാൻഡ് ഭാഷയാണ് (മൊബൈൽ സിസ്റ്റം സ്റ്റാൻഡേർഡ് ആയ 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 എന്നത്, ഫ്ലാഗുകളാണ് ("-" എന്നത് ഫ്ലാഗുകളുടെ അടയാളമാണ്, 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 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 എന്നത് കമാൻഡ് ഫയലിൻ്റെ പേരാണ്. -v സ്വിച്ച് -n സ്വിച്ചുമായി സംയോജിച്ച് ഉപയോഗിക്കാവുന്നതാണ്, ഇത് തുടർന്നുള്ള കമാൻഡുകൾ നടപ്പിലാക്കുന്നത് തടയുന്നു (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 തുടർച്ചയായി സമാനമായ ഫയലുകൾ ഫയൽ_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` ; echo 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" എന്ന് ടൈപ്പ് ചെയ്യുമ്പോൾ ഓപ്ഷനുകൾ പാരാമീറ്ററുകൾ കമാൻഡ് ഫയലിലേക്ക് കൈമാറാൻ കഴിയും. ഷെൽ പൊസിഷണൽ പാരാമീറ്ററുകൾ ഉപയോഗിക്കുന്നു (അതായത്, അവ ദൃശ്യമാകുന്ന ക്രമം പ്രധാനമാണ്). കമാൻഡ് ഫയലിൽ, പരാമീറ്ററുകളുമായി ബന്ധപ്പെട്ട വേരിയബിളുകൾ (ഷെൽ വേരിയബിളുകൾക്ക് സമാനമായത്) "$" എന്ന ചിഹ്നത്തിൽ ആരംഭിക്കുന്നു, തുടർന്ന് 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 ഭാഷാ വ്യാഖ്യാതാവിനെ വിളിക്കുന്നു. ഉപയോക്താവിൻ്റെ രജിസ്ട്രേഷൻ ഡയറക്ടറിയിൽ ഒരു .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") ഫയലുകളിലേക്ക് അയച്ചു ഫയൽ_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 തടസ്സം "കമാൻഡ് ലിസ്റ്റ്" സിഗ്നലുകൾ ട്രാപ്പ് ചെയ്യുക സിസ്റ്റത്തിൽ തടസ്സങ്ങൾ സംഭവിക്കുകയാണെങ്കിൽ, സിഗ്നലുകൾ "സിഗ്നലുകളിൽ" ഒരു സ്പേസ് കൊണ്ട് വേർതിരിച്ചിരിക്കുന്നു, തുടർന്ന് "കമാൻഡ് ലിസ്റ്റ്" എക്സിക്യൂട്ട് ചെയ്യും, അതിനുശേഷം (കമാൻഡ് ലിസ്റ്റിൽ "എക്സിറ്റ്" കമാൻഡ് എക്സിക്യൂട്ട് ചെയ്തിട്ടില്ലെങ്കിൽ) നിയന്ത്രണം തടസ്സപ്പെടുത്തൽ പോയിൻ്റിലേക്ക് മടങ്ങുക, കമാൻഡ് ഫയലിൻ്റെ എക്സിക്യൂഷൻ തുടരും. ഉദാഹരണത്തിന്, ഒരു കമാൻഡ് ഫയലിൻ്റെ നിർവ്വഹണത്തെ തടസ്സപ്പെടുത്തുന്നതിന് മുമ്പ് "/tmp" ലെ ഫയലുകൾ ഇല്ലാതാക്കേണ്ടത് ആവശ്യമാണെങ്കിൽ, ഇത് "ട്രാപ്പ്" കമാൻഡ് ഉപയോഗിച്ച് ചെയ്യാം: ട്രാപ്പ് "rm /tmp/* ; എക്സിറ്റ് 1" 1 2 15 ഫയലിലെ മറ്റ് കമാൻഡുകൾക്ക് മുമ്പുള്ളതാണ്. ഇവിടെ, ഫയലുകൾ ഇല്ലാതാക്കിയ ശേഷം, കമാൻഡ് ഫയൽ എക്സിറ്റ് ചെയ്യും. വിദ്യാർത്ഥികൾ, ബിരുദ വിദ്യാർത്ഥികൾ, അവരുടെ പഠനത്തിലും ജോലിയിലും വിജ്ഞാന അടിത്തറ ഉപയോഗിക്കുന്ന യുവ ശാസ്ത്രജ്ഞർ നിങ്ങളോട് വളരെ നന്ദിയുള്ളവരായിരിക്കും. പോസ്റ്റ് ചെയ്തത് http://www.allbest.ru/ റെയിൽവേ ഗതാഗതത്തിനുള്ള ഫെഡറൽ ഏജൻസി സൈബീരിയൻ സ്റ്റേറ്റ് ട്രാൻസ്പോർട്ട് യൂണിവേഴ്സിറ്റി വകുപ്പ് " വിവരസാങ്കേതികവിദ്യഗതാഗതം » ലബോറട്ടറി വർക്ക് നമ്പർ 1 "ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിൻ്റെ കമാൻഡ് ലാംഗ്വേജ്" "ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങൾ" എന്ന വിഷയത്തിൽ ജോലിയുടെ ലക്ഷ്യം കമാൻഡ് മോഡിൽ MS WINDOWS പരിതസ്ഥിതിയിൽ പ്രവർത്തിക്കുന്നതിൽ പ്രായോഗിക കഴിവുകൾ നേടുക എന്നതാണ് ജോലിയുടെ ലക്ഷ്യം. പുരോഗതി കമാൻഡ് ലൈൻ മോഡിലേക്ക് പുറത്തുകടന്നു (ആരംഭിക്കുക/പ്രോഗ്രാമുകൾ/ആക്സസറികൾ/കമാൻഡ് പ്രോംപ്റ്റ് അല്ലെങ്കിൽ Start/Run/cmd.exe) ഞങ്ങൾ പ്രവർത്തിക്കുന്ന OS-ൻ്റെ പതിപ്പ് ഞങ്ങൾ ആവശ്യപ്പെട്ടു. (സി) 2011 മൈക്രോസോഫ്റ്റ് കോർപ്പറേഷൻ. എല്ലാ അവകാശങ്ങളും നിക്ഷിപ്തം. C:\Users\Home>ver മൈക്രോസോഫ്റ്റ് വിൻഡോസ് സി:\ഉപയോക്താക്കൾ\ഹോം> മോണിറ്റർ സ്ക്രീൻ (CLS) വൃത്തിയാക്കി. ഞങ്ങൾ ഫ്ലാഷ് ഡ്രൈവ് ഫോർമാറ്റ് ചെയ്തു, മുമ്പ് അതിൻ്റെ ഉള്ളടക്കങ്ങൾ ഒരു പ്രത്യേക ഡയറക്ടറിയിൽ സംരക്ഷിച്ചു ഹാർഡ് ഡ്രൈവ്. സി:\ഉപയോക്താക്കൾ\ഹോം>ഫോർമാറ്റ് f: /q എഫ് ഡ്രൈവിലേക്ക് പുതിയ ഡിസ്ക് ചേർക്കുക: ENTER അമർത്തുക... ഫയൽ സിസ്റ്റം തരം: NTFS. ദ്രുത ഫോർമാറ്റ്: 14786 MB വോളിയം ലേബൽ (32 പ്രതീകങ്ങൾ, ENTER - ലേബൽ ആവശ്യമില്ല): ഫയൽ സിസ്റ്റം ഘടനകൾ സൃഷ്ടിക്കുന്നു. ഫോർമാറ്റിംഗ് പൂർത്തിയായി. ഡിസ്കിൽ ആകെ 14.4 GB. ലഭ്യമാണ്: 14.4 GB. ഫ്ലാഷ് ഡ്രൈവ് ലേബൽ സജ്ജമാക്കുക. C:\Users\Home>label f:Rebrikova ഡയറക്ടറികളിൽ പ്രവർത്തിക്കാൻ കമാൻഡുകൾ ഉപയോഗിച്ച്, ഞങ്ങൾ ഇനിപ്പറയുന്നവ ചെയ്തു: ഒരു ഫ്ലാഷ് ഡ്രൈവിൽ ഒരു COP ഡയറക്ടറി സൃഷ്ടിച്ചു; C:\Users\Home>md f:\COP ഹാർഡ് ഡ്രൈവിൻ്റെ ഉപഡയറക്‌ടറിയിലെ ഉള്ളടക്കങ്ങൾ അതിലേക്ക് പകർത്തി (ഈ സാഹചര്യത്തിൽ, ഒരു ഫ്ലാഷ് ഡ്രൈവിൻ്റെ ഉള്ളടക്കം); C:\Users\Home>xcopy physics f:\COP ഭൗതികശാസ്ത്രം\22lab.docx ഭൗതികശാസ്ത്രം\6lab.docx ഭൗതികശാസ്ത്രം\Fizika.docx ഭൗതികശാസ്ത്രം\ഒപ്റ്റിക്സ്. Atomic Physics.pdf ഭൗതികശാസ്ത്രം\Thematic മെറ്റീരിയലുകൾ on physics.pdf പകർത്തിയ ഫയലുകൾ: 5. സി:\ഉപയോക്താക്കൾ\ഹോം> COP ഡയറക്ടറി സ്ക്രീനിൽ പ്രദർശിപ്പിച്ചു, ഡയറക്ടറി എൻട്രികളുടെ ഘടന പഠിച്ചു (ഡയറക്ടറിയിലെ ഉള്ളടക്കങ്ങൾ പരിഷ്‌ക്കരിച്ച തീയതി പ്രകാരം പ്രദർശിപ്പിക്കും, ഡയറക്ടറികൾ സൂചിപ്പിച്ചിരിക്കുന്നു C:\Users\Home>dir f:\COP f:\COP എന്ന ഫോൾഡറിൻ്റെ ഉള്ളടക്കം 09.10.2014 04:43 09.10.2014 04:43 , 9 നാശം (തടഞ്ഞുകിടക്കുന്നില്ല), 15 വധശിക്ഷയുടെ അവസാനം. തടസ്സങ്ങളിൽ നിന്ന് പരിരക്ഷിക്കുന്നതിന്, ഫോർമാറ്റ് ഉള്ള ഒരു "ട്രാപ്പ്" കമാൻഡ് ഉണ്ട്:വിജ്ഞാന അടിത്തറയിൽ നിങ്ങളുടെ നല്ല സൃഷ്ടികൾ അയയ്ക്കുക ലളിതമാണ്. ചുവടെയുള്ള ഫോം ഉപയോഗിക്കുക
5 ഫയലുകൾ 2,627,427 ബൈറ്റുകൾ
DIR കമാൻഡിനുള്ള സഹായവുമായി പരിചയപ്പെടുകയും COP ഡയറക്ടറിയിലെ ഉള്ളടക്കങ്ങൾ പേരിനനുസരിച്ച് അടുക്കുകയും ചെയ്തു
C:\Users\Home>dir f:\COP /O:N
F ഉപകരണത്തിലെ വോളിയത്തിന് ഒരു റെബ്രിക്കോവ് ലേബൽ ഉണ്ട്
വോളിയം സീരിയൽ നമ്പർ: 22C0-2266
f:\COP എന്ന ഫോൾഡറിൻ്റെ ഉള്ളടക്കം
09.10.2014 04:43
09.10.2014 04:43
05/04/2014 12:48 43 213 22laba.docx
04/14/2014 09:29 49 283 6laba.docx
06/24/2014 16:08 583 602 Fizika.docx
04/20/2014 18:34 436 220 ഒപ്റ്റിക്സ്. Atomic Physics.pdf
04/20/2014 18:32 1 515 109 physics.pdf-ലെ തീമാറ്റിക് മെറ്റീരിയലുകൾ
5 ഫയലുകൾ 2,627,427 ബൈറ്റുകൾ
2 ഫോൾഡറുകൾ 10 695 479 296 ബൈറ്റുകൾ സൗജന്യം
കൂടാതെ ഫയൽ വലുപ്പം അനുസരിച്ച്:
C:\Users\Home>dir f:\COP /O:S
F ഉപകരണത്തിലെ വോളിയത്തിന് ഒരു റെബ്രിക്കോവ് ലേബൽ ഉണ്ട്
വോളിയം സീരിയൽ നമ്പർ: 22C0-2266
f:\COP എന്ന ഫോൾഡറിൻ്റെ ഉള്ളടക്കം
09.10.2014 04:43
09.10.2014 04:43
05/04/2014 12:48 43 213 22laba.docx
04/14/2014 09:29 49 283 6laba.docx
04/20/2014 18:34 436 220 ഒപ്റ്റിക്സ്. Atomic Physics.pdf
06/24/2014 16:08 583 602 Fizika.docx
04/20/2014 18:32 1 515 109 physics.pdf-ലെ തീമാറ്റിക് മെറ്റീരിയലുകൾ
5 ഫയലുകൾ 2,627,427 ബൈറ്റുകൾ
2 ഫോൾഡറുകൾ 10 695 479 296 ബൈറ്റുകൾ സൗജന്യം
ഔട്ട്പുട്ട് റീഡയറക്ഷൻ കമാൻഡ് ഉപയോഗിച്ച്, ഫ്ലാഷ് ഡ്രൈവിൻ്റെ റൂട്ട് ഡയറക്ടറിയുടെ DIR.DAT ഫയലിലേക്ക് COP ഡയറക്ടറി എഴുതി;
DIR.DAT ഫയലിൻ്റെ ഉള്ളടക്കങ്ങൾ സ്ക്രീനിൽ പ്രദർശിപ്പിക്കുക;
C:\Users\Home>dir f:\COP>f:dir.dat
സി:\ഉപയോക്താക്കൾ\ഹോം>പകർപ്പ് f:dir.dat കോൺ
F ഉപകരണത്തിലെ വോളിയത്തിന് ഒരു റെബ്രിക്കോവ് ലേബൽ ഉണ്ട്
വോളിയം സീരിയൽ നമ്പർ: 22C0-2266
f:\COP എന്ന ഫോൾഡറിൻ്റെ ഉള്ളടക്കം
09.10.2014 04:43
09.10.2014 04:43
05/04/2014 12:48 43 213 22laba.docx
04/14/2014 09:29 49 283 6laba.docx
06/24/2014 16:08 583 602 Fizika.docx
04/20/2014 18:34 436 220 ഒപ്റ്റിക്സ്. Atomic Physics.pdf
04/20/2014 18:32 1 515 109 physics.pdf-ലെ തീമാറ്റിക് മെറ്റീരിയലുകൾ
5 ഫയലുകൾ 2,627,427 ബൈറ്റുകൾ
2 ഫോൾഡറുകൾ 10 695 479 296 ബൈറ്റുകൾ സൗജന്യം
പകർത്തിയ ഫയലുകൾ: 1.
DIR.DAT ഫയൽ ഇല്ലാതാക്കി;
C:\Users\Home>del f:dir.dat
പൈപ്പ്ലൈൻ ഉപയോഗിച്ച്, ഡ്രൈവ് സി: റൂട്ട് ഡയറക്ടറിയുടെ ഉപഡയറക്‌ടറികളുടെ പേരുകൾ സ്ക്രീനിൽ പ്രദർശിപ്പിച്ചു (DIR | "DIR" കണ്ടെത്തുക);
സി:\ഉപയോക്താക്കൾ\ഹോം>DIR | "DIR" കണ്ടെത്തുക
09.10.2014 04:37
09.10.2014 04:37
21.09.2014 11:09
24.09.2014 18:29
09.10.2014 04:36
21.09.2014 11:09
07.10.2014 19:08
21.09.2014 11:09
21.09.2014 11:09
26.09.2014 18:42
21.09.2014 11:09
21.09.2014 11:09
21.09.2014 11:09
09.10.2014 04:37
സി:\ഉപയോക്താക്കൾ\ഹോം>
ഫ്ലാഷ് ഡ്രൈവിലെ COP ഡയറക്ടറി ഇല്ലാതാക്കി.
C:\Users\Home>del f:\COP
f:\COP\*, തുടരണോ ? വൈ
C:\Users\Home>rd f:\COP
വ്യത്യസ്ത ഡയറക്ടറികളിൽ നിന്നുള്ള പ്രോഗ്രാമുകൾ സമാരംഭിക്കുന്നതിൽ ഞങ്ങൾ പ്രാവീണ്യം നേടിയിട്ടുണ്ട്:
നിലവിലെ ഡയറക്ടറിയിൽ നിന്ന് o;
C:\Users\Home>iTunes64Setup.exe
പാത്ത് സൂചിപ്പിക്കുന്ന ഏതെങ്കിലും ഡയറക്ടറിയിൽ നിന്ന്;
C:\Users\Home>iTunes64Setup.exe
o PATH കമാൻഡ് ഉപയോഗിച്ച്.
C:\Users\Home>path iTunes64Setup.exe
ഫയലുകളും ഡിസ്കുകളും ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നതിനുള്ള കമാൻഡുകൾ ഉപയോഗിച്ച്, ഞങ്ങൾ ഇനിപ്പറയുന്ന പ്രവർത്തനങ്ങൾ നടത്തി:
ഒരു ഫ്ലാഷ് ഡ്രൈവിൽ ഒരു TEXT ഡയറക്ടറി സൃഷ്ടിച്ച് അതിൽ രണ്ട് ടെക്സ്റ്റ് ഫയലുകൾ സൃഷ്ടിച്ചു (1.TXT, 2.TXT);
C:\Users\Home>md f:text
C:\Users\Home>copy con f:\text\1.txt
പകർത്തിയ ഫയലുകൾ: 1.
C:\Users\Home>copy con f:\text\2.txt
പകർത്തിയ ഫയലുകൾ: 1.
സൃഷ്ടിച്ചതിൻ്റെ സംയോജനം നടത്തി ടെക്സ്റ്റ് ഫയലുകൾ, തത്ഫലമായുണ്ടാകുന്ന ഫയലിന് A.TXT എന്ന് പേരിട്ടു;
C:\Users\Home>copy f:\text\1.txt+f:\text\2.txt a.txt
പകർത്തിയ ഫയലുകൾ: 1.
A.TXT ഫയൽ 1.TXT എന്ന ഫയലുമായി ലൈൻ ബൈ ലൈൻ ആയി താരതമ്യം ചെയ്ത് A.PRT ഫയലിൽ താരതമ്യ ഫലം രേഖപ്പെടുത്തുക, താരതമ്യത്തിൻ്റെ ഫലം വിശദീകരിക്കുക;
C:\Users\Home>FC f:\text\1.txt f:\text\a.txt
"എഫ്‌സി" എന്നത് ആന്തരികമോ ബാഹ്യമോ അല്ല
C:\WINDOWS\SYSTEM32 ഫോൾഡറിൽ നിന്ന് ഫ്ലാഷ് ഡ്രൈവിൻ്റെ റൂട്ട് ഡയറക്ടറിയിലേക്ക് "ഡിസ്ക്" എന്ന് തുടങ്ങുന്ന ബാഹ്യ വിൻഡോസ് കമാൻഡുകളുടെ എക്സിക്യൂട്ടബിൾ ഫയലുകൾ പകർത്തി;
C:\Users\Home>cd c:\windows\system32
c:\Windows\System32>copy disk*.* f:
പകർത്തിയ ഫയലുകൾ: 7.
o ഒരു ഫ്ലാഷ് ഡിസ്ക് പരിശോധന നടത്തി (CHKDSK അല്ലെങ്കിൽ SCANDISK);
സി:\ഉപയോക്താക്കൾ\ഹോം>chkdsk f:
"chkdsk" ആന്തരികമോ ബാഹ്യമോ അല്ല
ടീം, എക്സിക്യൂട്ടബിൾ പ്രോഗ്രാംഅല്ലെങ്കിൽ ബാച്ച് ഫയൽ.
സി:\ഉപയോക്താക്കൾ\ഹോം>സ്കാൻഡിസ്ക് എഫ്:
"സ്കാൻഡിസ്ക്" ആന്തരികമോ ബാഹ്യമോ അല്ല
കമാൻഡ്, എക്സിക്യൂട്ടബിൾ പ്രോഗ്രാം, അല്ലെങ്കിൽ ബാച്ച് ഫയൽ.
A.TXT ഫയൽ ഇല്ലാതാക്കി.
c:\Users\Home>del f:\text\a.txt
പരിസ്ഥിതി ഏരിയ വേരിയബിളുകളുടെ മൂല്യങ്ങൾ പ്രദർശിപ്പിക്കുകയും അവ റിപ്പോർട്ടിൽ നൽകുകയും ചെയ്തു. ഞങ്ങൾ ഒരു പുതിയ വേരിയബിൾ ടൗൺ എഴുതി അതിന് "നോവോസിബിർസ്ക്" എന്ന മൂല്യം നൽകി. ഫോർമാറ്റിംഗ് കമാൻഡ് ഡയറക്ടറിഫയൽ
c:\Users\Home>set town=Novosibirsk
c:\Users\Home>echo %town%
നോവോസിബിർസ്ക്
നിങ്ങളുടെ കമ്പ്യൂട്ടറിൻ്റെ നെറ്റ്‌വർക്ക് കാർഡിൻ്റെ (IPCONFIG) IP വിലാസം ഞങ്ങൾ നിർണ്ണയിച്ചു.
c:\Users\Home>IPCONFIG
"IPCONFIG" എന്നത് ഒരു ആന്തരിക അല്ലെങ്കിൽ ബാഹ്യ കമാൻഡ്, എക്സിക്യൂട്ടബിൾ പ്രോഗ്രാമോ ബാച്ച് ഫയലോ അല്ല.
Allbest.ru-ൽ പോസ്‌റ്റുചെയ്‌തു
...സമാനമായ രേഖകൾ
സോഫ്റ്റ്വെയർ ഡിസൈൻ. ഒരു ഫയൽ ഡയറക്ടറിയുടെ പ്രാരംഭ രൂപീകരണത്തിൻ്റെ സ്കീം, ഒരു ഫയൽ ഡയറക്ടറി പ്രദർശിപ്പിക്കുക, ഫയലുകൾ ഇല്ലാതാക്കുക, ഡയറക്ട് സെലക്ഷൻ രീതി ഉപയോഗിച്ച് പേരുകൾ, സൃഷ്ടി തീയതി, വലുപ്പം എന്നിവ പ്രകാരം ഫയലുകൾ അടുക്കുക. ഒരു ഫയൽ സിസ്റ്റത്തിൽ ഒരു ഡയറക്ടറി കൈകാര്യം ചെയ്യുന്നു.
കോഴ്‌സ് വർക്ക്, 01/08/2014 ചേർത്തു
വിൻഡോസ് 95 നെറ്റ്‌വർക്ക് ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിൻ്റെ പൊതു സവിശേഷതകളും കഴിവുകളും ഒഎസ് ഒബ്‌ജക്റ്റുകൾ, അവയുടെ വർഗ്ഗീകരണം, ഇനങ്ങൾ. Word ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നതിനും പ്രമാണങ്ങൾ സൃഷ്ടിക്കുന്നതിനും സംരക്ഷിക്കുന്നതിനുമുള്ള നിയമങ്ങൾ. ഡാറ്റയുടെ രൂപീകരണവും ഇൻപുട്ടും എക്സൽ പട്ടികകൾ. ഡിസ്കുകൾ ഫോർമാറ്റിംഗ്.
ടെസ്റ്റ്, 02/25/2009 ചേർത്തു
പോലുള്ള വ്യത്യസ്ത സവിശേഷതകൾ ഇൻപുട്ട് ഘടനഫയൽ സിസ്റ്റത്തിൽ നിന്ന് സ്വതന്ത്രമായ ഡയറക്ടറി. ഡയറക്ടറി ഉള്ളടക്കങ്ങളും ഫയൽ വിവരങ്ങളും വീണ്ടെടുക്കുന്നു. പ്രോഗ്രാം അൽഗോരിതത്തിൻ്റെ ഒരു ബ്ലോക്ക് ഡയഗ്രം വികസിപ്പിക്കൽ. ടാസ്ക് നടപ്പിലാക്കാൻ സോഫ്റ്റ്വെയർ പഠിക്കുന്നു.
കോഴ്‌സ് വർക്ക്, 07/22/2014 ചേർത്തു
വിൻഡോസ് ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിൻ്റെ ഒബ്ജക്റ്റുകൾക്കൊപ്പം പ്രവർത്തിക്കുന്നു: അടിസ്ഥാന ആശയങ്ങളും ഹോട്ട് കീകളും. ഫയലുകളും ഫോൾഡറുകളും സൃഷ്ടിക്കുകയും എഡിറ്റ് ചെയ്യുകയും ചെയ്യുക. സ്ക്രീൻഷോട്ടുകളും ഗ്രാഫിക്സും പെയിൻ്റ് എഡിറ്റർ. നോട്ട്പാഡിൽ ലളിതമായ ടെക്സ്റ്റ് ഡോക്യുമെൻ്റുകൾ എഡിറ്റുചെയ്യുന്നു. ഒരു കാൽക്കുലേറ്റർ ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നു.
ലബോറട്ടറി ജോലി, 11/30/2010 ചേർത്തു
വിൻഡോസ് 2000/XP/2003 ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിൻ്റെ ഇൻസ്റ്റാളേഷൻ. റിമോട്ട് ഇൻസ്റ്റലേഷൻ സേവന ഘടകങ്ങൾ. OS-ൻ്റെ സ്വയമേവ (ശ്രദ്ധിക്കാത്ത) ഇൻസ്റ്റാളേഷൻ പൊതു കാറ്റലോഗ്സെർവറിൽ. മൂന്നാം കക്ഷി സോഫ്റ്റ്വെയർ ഉപയോഗിച്ച് സൃഷ്ടിച്ച ഒരു ഇമേജിൽ നിന്ന് OS-ഉം ആപ്ലിക്കേഷനുകളും ഇൻസ്റ്റാൾ ചെയ്യുന്നു.
സംഗ്രഹം, 04/03/2010 ചേർത്തു
API പ്രോഗ്രാമിംഗിലേക്കുള്ള ആമുഖം. കീബോർഡ് സന്ദേശങ്ങൾ ASCII കോഡുകളിലേക്ക് വിവർത്തനം ചെയ്യുന്നു. API ഫംഗ്ഷനുകൾ ഉപയോഗിച്ച് 32-ബിറ്റ് അസംബ്ലറിലെ പ്രോഗ്രാമിൻ്റെ വാചകം. ഒരു ഡയലോഗ് ബോക്സ് സൃഷ്ടിക്കുന്നതിനുള്ള പ്രവർത്തനം. തുറക്കുന്നതിനുള്ള ഡ്രൈവ്, ഡയറക്ടറി, ഫയലിൻ്റെ പേര് എന്നിവ നിർണ്ണയിക്കുന്നു.
കോഴ്‌സ് വർക്ക്, 05/18/2014 ചേർത്തു
വിൻഡോസ് മാനേജ്മെൻ്റ്ഒരു ടൂൾകിറ്റായി ഉപകരണം വിൻഡോസ് മാനേജ്മെൻ്റ്, അതിൻ്റെ പൊതു സവിശേഷതകളും കഴിവുകളും, പ്രവർത്തന സവിശേഷതകൾ. ക്ലാസുകൾ, ഇവൻ്റുകൾ, WMI സുരക്ഷ. അന്വേഷണങ്ങളുടെ ഫലമായി ലഭിച്ച ഒബ്‌ജക്റ്റുകളും ശേഖരങ്ങളും ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നു.
കോഴ്‌സ് വർക്ക്, 04/26/2011 ചേർത്തു
നോർട്ടൺ കമാൻഡർ ഷെൽ പരിതസ്ഥിതിയിൽ ജോലി ചെയ്യുന്നതിൻ്റെ സവിശേഷതകൾ. ഓപ്പറേറ്റിംഗ് സിസ്റ്റവുമായുള്ള ഇടപെടൽ. ഉള്ളടക്കങ്ങളുടെ കാറ്റലോഗ് പട്ടിക പ്രദർശിപ്പിക്കുന്നതിനുള്ള ഫോർമാറ്റ്. ഡയറക്ടറി ട്രീ പാനലിൽ ഡിസ്ക് വിവരങ്ങൾ കാണുക. മോഡ് പെട്ടെന്നുള്ള കാഴ്ചഫയലുകൾ. പാനലുകളുടെ ഡിസ്പ്ലേ നിയന്ത്രിക്കുന്നു.
സംഗ്രഹം, 05/17/2009 ചേർത്തു
വിൻഡോസ് ഓപ്പറേറ്റിംഗ് സിസ്റ്റം പുനഃസ്ഥാപിക്കുന്നതിനുള്ള രീതികൾ, അവയുടെ ഗുണങ്ങളും ദോഷങ്ങളും. വിൻഡോസ് എക്സ്പിയും അക്രോണിസ് ഡിസ്കും ഉപയോഗിച്ച് റിക്കവറി കൺസോൾ ഉപയോഗിച്ച് ബൂട്ട് ചെയ്യുമ്പോൾ OS വീണ്ടെടുക്കുന്നു യഥാർത്ഥ ചിത്രം. സിസ്റ്റം ഫയലുകളുടെ സമഗ്രത പരിശോധിക്കുന്നു.
അവതരണം, 06/20/2014 ചേർത്തു
വിൻഡോസ് 95 ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിൻ്റെ രൂപം. ഫയലുകൾക്ക് പേരിടുന്നതിനുള്ള നിയമങ്ങൾ. ഡിസ്കിൽ ഫയലുകൾ സംഭരിക്കുന്ന ക്രമം. ഫയൽ സംഭരണവും ഡയറക്ടറി ഓർഗനൈസേഷൻ സിസ്റ്റവും. മൾട്ടി ലെവൽ ഹൈറാർക്കിക്കൽ ഫയൽ സിസ്റ്റം. മുഴുവൻ ഫയലിൻ്റെ പേര്. വിൻഡോസ് ഫോൾഡർ ശ്രേണി.
ഒരു കമ്പ്യൂട്ടർ, അതിൻ്റെ പ്രവർത്തന പ്രക്രിയകൾ, ഇൻ്റേണൽ മെമ്മറി, ഉപയോക്തൃ പ്രവർത്തനങ്ങൾ എന്നിവ നിയന്ത്രിക്കുന്നതിനുള്ള ഒരു സിസ്റ്റം. OS-നെ അടുത്തറിയാൻ ഞങ്ങൾ വായനക്കാരനെ ക്ഷണിക്കുന്നു ഈ വശം.
ഇത് എന്താണ്?
തീർച്ചയായും, ഒന്നാമതായി, ഓപ്പറേറ്റിംഗ് സിസ്റ്റം ഒരു നിയന്ത്രണ സംവിധാനമാണ്. ഞങ്ങൾ കൂടുതൽ നൽകും പൂർണ്ണ നിർവചനം OS: നിയന്ത്രണ, പ്രോസസ്സിംഗ് ആപ്ലിക്കേഷനുകളുടെ ഒരു സമുച്ചയം. ഒരു വശത്ത്, അവർ ഉപകരണങ്ങൾക്കിടയിൽ ഒരു ഇൻ്റർഫേസായി പ്രവർത്തിക്കുന്നു കമ്പ്യൂട്ടിംഗ് സിസ്റ്റംഒപ്പം അപേക്ഷകൾ, പ്രോഗ്രാമുകൾ. മറുവശത്ത്, ചില ഉപകരണങ്ങളും കമ്പ്യൂട്ടിംഗ് പ്രക്രിയകളും കൈകാര്യം ചെയ്യുന്നതിനുള്ള ഒരു സംവിധാനമാണ് ഓപ്പറേറ്റിംഗ് സിസ്റ്റം. കമ്പ്യൂട്ടിംഗ് പ്രക്രിയകൾക്കിടയിൽ കമ്പ്യൂട്ടിംഗ് ഉറവിടങ്ങൾ ഫലപ്രദമായി വിതരണം ചെയ്യുന്നതും സിസ്റ്റത്തിലെ കണക്കുകൂട്ടലുകൾ വിശ്വസനീയമായി സംഘടിപ്പിക്കുന്നതും OS ആണ്.
നമ്മൾ തിരിയുകയാണെങ്കിൽ ലോജിക്കൽ ഘടനസാധാരണ കമ്പ്യൂട്ടിംഗ് സിസ്റ്റം, അപ്പോൾ OS സ്വന്തം മൈക്രോ ആർക്കിടെക്ചർ ഉള്ള ഉപകരണങ്ങൾക്കിടയിൽ ഒരു ഇൻ്റർമീഡിയറ്റ് സ്ഥാനം വഹിക്കും, യന്ത്രഭാഷ, ഉൾച്ചേർത്ത ഫേംവെയറുകൾ ഒരു വശത്തും ആപ്ലിക്കേഷൻ ആപ്ലിക്കേഷനുകൾ മറുവശത്തും.
സോഫ്റ്റ്വെയർ ഡെവലപ്പർമാരെ സംബന്ധിച്ചിടത്തോളം, ഉപകരണങ്ങളുടെ പ്രവർത്തനത്തിൻ്റെയും നടപ്പാക്കലിൻ്റെയും സവിശേഷതകളിൽ നിന്ന് സംഗ്രഹിക്കാൻ OS അവരെ അനുവദിക്കുന്നു, ആവശ്യമായ ഏറ്റവും കുറഞ്ഞ ഫംഗ്ഷണൽ സെറ്റ് നൽകുന്നു.
മിക്ക കമ്പ്യൂട്ടിംഗ് സിസ്റ്റങ്ങളിലും, ഓപ്പറേറ്റിംഗ് സിസ്റ്റം നിയന്ത്രണ സംവിധാനമാണ്. ഇത് സോഫ്റ്റ്വെയറിൻ്റെ പ്രധാന, ഏറ്റവും പ്രധാനപ്പെട്ട (ചില സന്ദർഭങ്ങളിൽ മാത്രം) ഭാഗമാണ്. സിസ്റ്റം പിന്തുണ. നിങ്ങൾ തിരിയുകയാണെങ്കിൽ നിർദ്ദിഷ്ട ഉദാഹരണങ്ങൾ, പിന്നെ ഏറ്റവും ജനപ്രിയമായ OS മൈക്രോസോഫ്റ്റ് ഉൽപ്പന്നമായിരിക്കും - വിൻഡോസ് ("വിൻഡോസ്").
ഓപ്പറേറ്റിംഗ് സിസ്റ്റം മാനേജ്മെൻ്റ്
പലർക്കും ഈ ചോദ്യത്തിൽ താൽപ്പര്യമുണ്ട്: ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങൾ കൈകാര്യം ചെയ്യുന്നതിന് പ്രത്യേക പ്രോഗ്രാമുകൾ ഉണ്ടോ? വാക്യത്തിൻ്റെ ഈ നിർമ്മാണം തെറ്റാണ്. എല്ലാത്തിനുമുപരി, ഓപ്പറേറ്റിംഗ് സിസ്റ്റം തന്നെ കമ്പ്യൂട്ടർ ഉറവിടങ്ങൾ നിയന്ത്രിക്കുകയും ഉപയോക്താവും ഉപകരണവും തമ്മിൽ ഒരു സംഭാഷണം സ്ഥാപിക്കുകയും ചെയ്യുന്ന ഒരു കൂട്ടം പ്രോഗ്രാമുകളാണ്.
അതുകൊണ്ടാണ് എല്ലാം എണ്ണയും വെണ്ണയും: നിയന്ത്രണത്തിൻ്റെ നിയന്ത്രണം. ഒരു കോംപ്ലക്സ് ഉണ്ട് ആപ്ലിക്കേഷൻ പ്രോഗ്രാമുകൾ, ഓപ്പറേറ്റിംഗ് സിസ്റ്റം "നിയന്ത്രിക്കുന്നത്".
അടിസ്ഥാന OS സവിശേഷതകൾ
ഓപ്പറേറ്റിംഗ് സിസ്റ്റം - കമ്പ്യൂട്ടർ റിസോഴ്സ് മാനേജ്മെൻ്റ്. ഈ പ്രധാന ദൌത്യംഒ.എസ്. അതിൽ നിന്ന് ഒരു സെറ്റ് നേരെ ഒഴുകുന്നു ഇനിപ്പറയുന്ന പ്രവർത്തനങ്ങൾ:
- നിർവ്വഹണം വിവിധ അഭ്യർത്ഥനകൾപ്രോഗ്രാമുകൾ. ഉദാഹരണത്തിന്: വിവരങ്ങളുടെ ഇൻപുട്ടും ഔട്ട്പുട്ടും, ആപ്ലിക്കേഷൻ പ്രോഗ്രാമുകളും ആപ്ലിക്കേഷനുകളും ആരംഭിക്കുന്നതും നിർത്തുന്നതും, സ്വതന്ത്രമാക്കൽ, മെമ്മറി അനുവദിക്കൽ തുടങ്ങിയവ.
- പെരിഫറൽ ഉപകരണങ്ങളിലേക്ക് സ്റ്റാൻഡേർഡ് ആക്സസ് നൽകുന്നു (ഉദാഹരണത്തിന്, I/O ഉപകരണങ്ങൾ).
- കമ്പ്യൂട്ടർ റാം കൈകാര്യം ചെയ്യുന്നു: സജീവമായ പ്രക്രിയകൾക്കിടയിൽ ഇത് വിതരണം ചെയ്യുന്നു, വെർച്വൽ മെമ്മറിയുടെ പൊതു ഓർഗനൈസേഷൻ.
- അസ്ഥിരമല്ലാത്ത മീഡിയയിൽ സ്ഥിതി ചെയ്യുന്ന ഡാറ്റയിലേക്കുള്ള ആക്സസ് നിയന്ത്രിക്കുന്നു. ഉദാഹരണത്തിന്, ഒപ്റ്റിക്കലിൽ ഹാർഡ് ഡ്രൈവുകൾഇത്യാദി.
- സിസ്റ്റം പിശകുകളെക്കുറിച്ചുള്ള വിവരങ്ങൾ സംരക്ഷിക്കുന്നു.
- ഒരു ഉപയോക്തൃ ഇൻ്റർഫേസ് നൽകുന്നു.
കമാൻഡ് ഭാഷകൾ - ഉപയോക്താവുമായുള്ള സംഭാഷണം
ഓപ്പറേറ്റിംഗ് സിസ്റ്റം ഡാറ്റ എങ്ങനെയാണ് കൈകാര്യം ചെയ്യുന്നത്? മിക്ക ഇൻ്ററാക്ടീവ് സിസ്റ്റങ്ങളിലെയും പോലെ, പ്രത്യേക കമാൻഡ് ഭാഷകൾ ഉപയോഗിച്ച് ഉപയോക്താവിന് OS-ൻ്റെ പ്രവർത്തനത്തെ സ്വാധീനിക്കാൻ കഴിയും.
ഇത് എന്താണ്? ഒരു വ്യക്തി സംവേദനാത്മക സംവിധാനവുമായി സംവദിക്കുന്ന ഭാഷയാണ് കമാൻഡ് ലാംഗ്വേജ്. എന്തുകൊണ്ട് ടീം? ടെർമിനലിൽ ഒരു വ്യക്തി നൽകുകയും സിസ്റ്റത്തിലേക്ക് അയയ്ക്കുകയും ചെയ്യുന്ന ഓരോ വരിയും OS-മായി ബന്ധപ്പെട്ട് ഒരു ഉപയോക്തൃ കമാൻഡായി കണക്കാക്കപ്പെടുന്നു.
കമാൻഡ് ഭാഷകളുടെ ഇടം പുറത്ത് നിന്ന് നോക്കുകയാണെങ്കിൽ പൊതു സംവിധാനംമനുഷ്യ-കമ്പ്യൂട്ടർ ഇടപെടലിൻ്റെ ഭാഷകൾ, തുടർന്ന് അവയെ വ്യാഖ്യാനിച്ചതായി തരംതിരിക്കും. അവരുടെ എതിരാളികൾ കോംപ്ലിമെൻ്ററി ഭാഷകളാണ്.
അവ തമ്മിലുള്ള വ്യത്യാസം നമുക്ക് പരിഗണിക്കാം: അധിക ഭാഷാ നിർമ്മിതികൾ ഉപയോഗിക്കാതെ തന്നെ ഒറ്റപ്പെട്ട സംസ്കരണത്തിനുള്ള സാധ്യത പ്രദാനം ചെയ്യുന്ന തരത്തിൽ ഏതെങ്കിലും നിർമ്മാണം അടച്ചിരിക്കണമെങ്കിൽ ഒരു ഭാഷയെ കോംപ്ലിമെൻ്ററി എന്ന് വിളിക്കുന്നു. അല്ലെങ്കിൽ, ധാരണ ഉറപ്പാക്കാൻ കഴിയില്ല. അത്തരമൊരു ആവശ്യകത നിറവേറ്റാതെ പോലും വ്യാഖ്യാനിച്ച ഭാഷകൾ മനസ്സിലാക്കാവുന്നതേയുള്ളൂ.
പ്രോസസ്സ് മാനേജ്മെൻ്റ്
ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളിലെ പ്രോസസ്സ് മാനേജ്മെൻ്റ് നോക്കാം. അവയുമായി ബന്ധപ്പെട്ട ഇനിപ്പറയുന്ന പ്രവർത്തനങ്ങൾ OS നിയന്ത്രിക്കുന്നു:
- പ്രക്രിയകൾ സൃഷ്ടിക്കുന്നതും ഇല്ലാതാക്കുന്നതും.
- സമന്വയം.
- ആസൂത്രണം.
- ആശയവിനിമയം.
- തടസ്സങ്ങൾ പരിഹരിക്കുന്നു.
"ജീവിതത്തിൽ" പ്രക്രിയ അതിൻ്റെ സ്വന്തം അവസ്ഥയെ പലതവണ മാറ്റുന്നു എന്നത് ശ്രദ്ധിക്കേണ്ടതാണ്:
- പുതിയത്. പുതുതായി സൃഷ്ടിച്ച പ്രക്രിയ.
- എക്സിക്യൂട്ടബിൾ. ഈ സമയത്ത്, പ്രോഗ്രാം കമാൻഡുകൾ സിപിയുവിൽ എക്സിക്യൂട്ട് ചെയ്യുന്നു.
- കാത്തിരിക്കുന്നു. ചില ഇവൻ്റ് പൂർത്തിയാകുന്നതിനായി പ്രക്രിയ കാത്തിരിക്കുകയാണ്. മിക്കപ്പോഴും, അവസാന പ്രവർത്തനം I/O ഓപ്പറേഷനാണ്.
- തയ്യാറാണ്. CPU സ്വതന്ത്രമാകുന്നതിനായി കാത്തിരിക്കുന്ന ഒരു പ്രക്രിയ.
- പൂർത്തിയാക്കി. പ്രക്രിയ അതിൻ്റെ പ്രവർത്തനം പൂർണ്ണമായും പൂർത്തിയാക്കി.
അത്തരത്തിലുള്ള ഒരു അവസ്ഥയിൽ നിന്ന് മറ്റൊന്നിലേക്കുള്ള മാറ്റം ഏകപക്ഷീയമായിരിക്കില്ല എന്നത് ശ്രദ്ധിക്കുക.
പല ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളിലും, ഓരോ പ്രക്രിയയെക്കുറിച്ചുള്ള വിവരങ്ങൾ ഒരു പ്രത്യേക ഓപ്പറേറ്റിംഗ് പ്രോസസ്സ് പട്ടികയിൽ സംഭരിച്ചിരിക്കുന്നു. അവ ഓരോന്നും ഒരു പ്രത്യേക സെറ്റ് ഡാറ്റ ഉപയോഗിച്ച് ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിൽ പ്രതിനിധീകരിക്കുന്നു. പ്രക്രിയയുടെ നിലവിലെ അവസ്ഥയെ ചിത്രീകരിക്കുന്ന മൂല്യങ്ങളുടെയും പാരാമീറ്ററുകളുടെയും ഒരു കൂട്ടമാണിത്. കമ്പ്യൂട്ടറിലൂടെ ഒരു നിർദ്ദിഷ്ട പ്രക്രിയ കടന്നുപോകുന്നത് നിയന്ത്രിക്കാൻ ഇത് OS ഉപയോഗിക്കുന്നു.
ഈ കേസിൽ കമ്പ്യൂട്ടേഷണൽ പ്രക്രിയ എങ്ങനെ സൃഷ്ടിക്കപ്പെടുന്നു? രണ്ട് വഴികളുണ്ട്: ഒരു കമാൻഡ് ഉപയോഗിച്ച് അല്ലെങ്കിൽ ഒരു ബാച്ച് ഫയൽ വഴി കീബോർഡിൽ നിന്ന് നേരിട്ട് നൽകുക. ഈ പ്രക്രിയയിൽ, കുറഞ്ഞത്, ആപ്ലിക്കേഷൻ ഡൗൺലോഡ് ചെയ്യുന്നതും പ്രത്യേക നിയന്ത്രണ ബ്ലോക്കുകൾ സൃഷ്ടിക്കുന്നതും ഉൾപ്പെടുന്നു.
ഇതിൻ്റെ ഫലമായി, ഉയർന്ന നിലവാരമുള്ള പുതിയ പ്രക്രിയ, അത് പിന്നീട് മൾട്ടി-പ്രോഗ്രാം മിക്സിൽ ഉൾപ്പെടുത്തിയിട്ടുണ്ട്. ഇതിനുശേഷം, OS അത് കാണാൻ തുടങ്ങുന്നു. പ്രക്രിയ തന്നെ ഒരുക്കത്തിലാണ്.
OS പ്രോസസ്സ് ടേബിൾ
ഈ പ്രക്രിയകൾ ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിൻ്റെ നിയന്ത്രണത്തിൽ പ്രവർത്തിക്കുകയും പ്രവർത്തിക്കുകയും ചെയ്യുന്നു. നമുക്ക് സങ്കൽപ്പിക്കാം ചെറിയ മേശ OS പ്രക്രിയകൾ:
- വിഭാഗം "പ്രോസസ് കൺട്രോൾ": രജിസ്റ്ററുകൾ, പ്രോഗ്രാം കൗണ്ടറുകൾ, സ്റ്റാക്ക് പോയിൻ്ററുകൾ, പ്രോസസ്സ് നില, പ്രോസസ് മുൻഗണന, ഷെഡ്യൂളിംഗ് പാരാമീറ്ററുകൾ, പ്രോസസ്സ് ഐഡൻ്റിഫയറുകൾ, പാരൻ്റ് പ്രോസസുകൾ, പ്രോസസ് ഗ്രൂപ്പുകൾ, പ്രോസസ്സ് ആരംഭ സമയം, ഉപയോഗിച്ച പ്രോസസ്സർ സമയം.
- വിഭാഗം "മെമ്മറി മാനേജ്മെൻ്റ്": ടെക്സ്റ്റ് സെഗ്‌മെൻ്റുകളിലേക്കുള്ള പോയിൻ്ററുകൾ, ഡാറ്റ സെഗ്‌മെൻ്റുകളിലേക്കുള്ള പോയിൻ്ററുകൾ, സെഗ്‌മെൻ്റുകൾ സ്റ്റാക്ക് ചെയ്യുന്നതിനുള്ള പോയിൻ്ററുകൾ.
- "ഫയൽ മാനേജ്മെൻ്റ്": പ്രവർത്തിക്കുന്ന ഡയറക്ടറികൾ, റൂട്ട് ഡയറക്ടറി, ഉപയോക്തൃ ഐഡികൾ, ഫയൽ ഹാൻഡിലുകൾ, ഗ്രൂപ്പ് ഐഡികൾ.
മെമ്മറി മാനേജ്മെൻ്റ്
നമുക്ക് മറ്റൊന്ന് നോക്കാം പ്രധാന വശം: ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളിലെ മെമ്മറി മാനേജ്മെൻ്റ്.
മൾട്ടിപ്രോഗ്രാം ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളുടെ ഏറ്റവും ശ്രദ്ധാപൂർവ്വമായ മാനേജ്മെൻ്റ് ആവശ്യമുള്ള ഏറ്റവും പ്രധാനപ്പെട്ട ഉറവിടമാണ് മെമ്മറി എന്നത് ശ്രദ്ധിക്കേണ്ടതാണ്. എന്താണ് അത് ഉറപ്പാക്കുന്നത്? പ്രത്യേക വേഷം? ആപ്ലിക്കേഷനുകളിൽ നിന്നും പ്രോഗ്രാമുകളിൽ നിന്നുമുള്ള നിർദ്ദേശങ്ങൾ കമ്പ്യൂട്ടർ മെമ്മറിയിലാണെങ്കിൽ മാത്രമേ പ്രോസസ്സറിന് അവ നടപ്പിലാക്കാൻ കഴിയൂ.
ആദ്യകാല ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളിൽ, മെമ്മറി മാനേജ്മെൻ്റ് ലളിതമായിരുന്നു: പ്രോഗ്രാമും അതിൻ്റെ ആവശ്യമായ ഡാറ്റയും ചിലതിൽ നിന്ന് ലോഡ് ചെയ്തു ബാഹ്യ സംഭരണംകമ്പ്യൂട്ടർ മെമ്മറിയിലേക്ക് ഡാറ്റ (ഒപ്റ്റിക്കൽ ഡിസ്ക്, പഞ്ച്ഡ് ടേപ്പ്, മാഗ്നറ്റിക് ടേപ്പ് മുതലായവ). മൾട്ടിപ്രോഗ്രാമിംഗിൻ്റെ ആവിർഭാവത്തോടെ സ്ഥിതിഗതികൾ സമൂലമായി മാറി. ഒരു പുതിയ ടാസ്ക് ഉയർന്നുവന്നിരിക്കുന്നു: പ്രവർത്തിക്കുന്ന നിരവധി ആപ്ലിക്കേഷനുകൾക്കിടയിൽ കമ്പ്യൂട്ടർ മെമ്മറി വിതരണം ചെയ്യുന്നു.
മെമ്മറി മാനേജ്മെൻ്റിൽ OS- ൻ്റെ പ്രധാന ചുമതലകൾ
ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളിലെ മാനേജ്മെൻ്റ് ടൂളുകളെ കുറിച്ച് നമ്മൾ സംസാരിക്കുന്നത് തുടരുന്നു. കമ്പ്യൂട്ടർ മെമ്മറി കൈകാര്യം ചെയ്യുന്നതിൽ OS- ൻ്റെ പ്രധാന ജോലികൾ നമുക്ക് ഹൈലൈറ്റ് ചെയ്യാം:
- സ്വതന്ത്രവും ഉപയോഗിച്ചതുമായ മെമ്മറി സെഗ്‌മെൻ്റുകൾ നിരീക്ഷിക്കുന്നു.
- നിർദ്ദിഷ്ട പ്രക്രിയകൾക്ക് മെമ്മറി അനുവദിക്കുകയും അവ അവസാനിപ്പിക്കുമ്പോൾ അത് സ്വതന്ത്രമാക്കുകയും ചെയ്യുന്നു.
- രണ്ട് കോഡുകളുടെയും സ്ഥാനചലനം, റാമിൽ നിന്ന് ഡിസ്കിലേക്ക് ഡാറ്റ പ്രോസസ്സ് ചെയ്യുക - പൂർണ്ണമോ ഭാഗികമോ. എല്ലാ പ്രക്രിയകളും ഉൾക്കൊള്ളാൻ പ്രധാന മെമ്മറിയുടെ അളവ് പര്യാപ്തമല്ലെങ്കിൽ ഇത് ഉപയോഗിക്കുന്നു. OP റിലീസ് ചെയ്യുമ്പോൾ, ഓപ്പറേറ്റിംഗ് സിസ്റ്റം പ്രക്രിയകളെ അവയുടെ സ്ഥാനത്തേക്ക് തിരികെ നൽകുന്നു.
- ഫിസിക്കൽ മെമ്മറിയുടെ പ്രത്യേക സോണുകളിലേക്ക് പ്രോഗ്രാമുകളുടെയും ആപ്ലിക്കേഷനുകളുടെയും വിലാസങ്ങൾ സജ്ജീകരിക്കുന്നു.
പിസി മെമ്മറി മാനേജ്മെൻ്റിനുള്ള അധിക ഒഎസ് ഫംഗ്ഷനുകൾ
നമുക്ക് പരിഗണിക്കാം അധിക ജോലികൾഈ സാഹചര്യത്തിൽ സിസ്റ്റം നിർവഹിക്കുന്നത്:
- ഉപകരണ മെമ്മറിയുടെ ഡൈനാമിക് അലോക്കേഷൻ. എക്സിക്യൂഷൻ സമയത്തേക്ക് അധിക മെമ്മറി അനുവദിക്കുന്നതിനുള്ള അപേക്ഷകൾ നിറവേറ്റുക എന്നാണ് ഇതിനർത്ഥം.
- പുതിയ വിവരങ്ങളുടെ സൃഷ്ടി സേവന ഘടനകൾ- ബഫറുകൾ, ത്രെഡ്, പ്രോസസ്സ് ഡിസ്ക്രിപ്റ്ററുകൾ.
- മെമ്മറി സംരക്ഷണം. മറ്റൊരു പ്രവർത്തനവുമായി ബന്ധപ്പെട്ട ഡാറ്റ എഴുതുന്നതിൽ നിന്നോ വായിക്കുന്നതിൽ നിന്നോ ഒരു നിർദ്ദിഷ്ട റണ്ണിംഗ് പ്രക്രിയയെ തടയുന്നത് ഉൾക്കൊള്ളുന്നു.
ഞങ്ങൾ ഇതിനകം പറഞ്ഞതുപോലെ, എല്ലാ പ്രക്രിയകൾക്കും മതിയായ റാം ഇല്ല. അതിനാൽ, OS ഒരു ബാഹ്യ ഡിസ്ക് ഒന്നിനെ ബന്ധിപ്പിക്കുന്നു. ഇതാണ് അടുത്ത ഘട്ടങ്ങൾസംവിധാനങ്ങൾ:
- പേജിംഗ്. ഇവിടെ പ്രക്രിയ പൂർണ്ണമായും മെമ്മറിയിലേക്ക് ലോഡ് ചെയ്യുന്നു കൂടുതൽ ജോലി.
- വെർച്വൽ മെമ്മറി. ഈ സാഹചര്യത്തിൽ, ചില ചുമതലകൾ നിർവഹിക്കുന്നതിന് പ്രക്രിയ ഭാഗികമായി ലോഡ് ചെയ്യുന്നു.
വലിയ പ്രക്രിയകൾ OS-ൽ താൽക്കാലികമായി മാത്രമേ അൺലോഡ് ചെയ്യൂ എന്ന് ഒരിക്കൽ കൂടി ശ്രദ്ധിക്കാം HDD. റാം സ്വതന്ത്രമാക്കിയ ശേഷം, സിസ്റ്റം അവരെ അവരുടെ സ്ഥലത്തേക്ക് തിരികെ നൽകുന്നു.
ഒരു കമ്പ്യൂട്ടറിനെ നിയന്ത്രിക്കുന്ന ഒരു മുഴുവൻ സോഫ്‌റ്റ്‌വെയറാണ് ഓപ്പറേറ്റിംഗ് സിസ്റ്റം. അതായത്, അതിൻ്റെ മെമ്മറി, പ്രക്രിയകൾ, വിഭവങ്ങൾ. മറ്റൊന്ന് പ്രധാന പ്രവർത്തനം OS: ഒരു വ്യക്തിയുമായോ ഉപയോക്താവുമായോ ഒരു കമ്പ്യൂട്ടർ സിസ്റ്റത്തിൻ്റെ ഇടപെടൽ നിർമ്മിക്കുക. ഉപയോഗിച്ചാണ് ഇത് കൈവരിക്കുന്നത് പ്രത്യേക ഉപകരണങ്ങൾ- കമാൻഡ് ഭാഷകൾ.
മിക്ക ഇൻ്ററാക്ടീവ് സിസ്റ്റങ്ങളെയും പോലെ, പരമ്പരാഗത UNIX ഉപയോക്തൃ ഇൻ്റർഫേസും കമാൻഡ് ഭാഷകളുടെ ഉപയോഗത്തെ അടിസ്ഥാനമാക്കിയുള്ളതാണ്. ഇത് കുറച്ച് ടാറ്റോളജിക്കൽ ആയി പറഞ്ഞാൽ, ഉപയോക്താവ് സിസ്റ്റവുമായി ഇടപഴകുന്ന ഭാഷയാണ് കമാൻഡ് ലാംഗ്വേജ് എന്ന് നമുക്ക് പറയാം. സംവേദനാത്മക മോഡ്. ടെർമിനലിൽ നിന്ന് നൽകുകയും സിസ്റ്റത്തിലേക്ക് അയയ്ക്കുകയും ചെയ്യുന്ന ഓരോ വരിയും ഉപയോക്താവിൽ നിന്ന് സിസ്റ്റത്തിലേക്കുള്ള കമാൻഡായി കണക്കാക്കാമെന്നതിനാൽ അത്തരമൊരു ഭാഷയെ കമാൻഡ് ലാംഗ്വേജ് എന്ന് വിളിക്കുന്നു. UNIX OS-ൻ്റെ നേട്ടങ്ങളിലൊന്ന്, ഈ ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിൻ്റെ കമാൻഡ് ഭാഷകൾ നന്നായി നിർവചിക്കപ്പെട്ടതും പ്രോഗ്രാമിംഗ് ഭാഷകളോട് അടുപ്പിക്കുന്ന സവിശേഷതകളും ഉൾക്കൊള്ളുന്നു എന്നതാണ്.
മനുഷ്യ-കമ്പ്യൂട്ടർ ഇടപെടൽ ഭാഷകളുടെ പൊതുവായ ദിശയുടെ വീക്ഷണകോണിൽ നിന്ന് കമാൻഡ് ഭാഷകളുടെ വിഭാഗം പരിഗണിക്കുകയാണെങ്കിൽ, അവ സ്വാഭാവികമായും വ്യാഖ്യാനിച്ച ഭാഷകളുടെ കുടുംബത്തിൽ പെടുന്നു. കമ്പൈൽ ചെയ്തതും വ്യാഖ്യാനിച്ചതുമായ കമ്പ്യൂട്ടർ ഭാഷകൾ തമ്മിലുള്ള വ്യത്യാസം നമുക്ക് ചുരുക്കമായി വിവരിക്കാം. ഏതെങ്കിലും പൂർണ്ണമായ ഭാഷാ നിർമ്മിതിക്ക് അധിക ഭാഷാ നിർമ്മിതികൾ ആവശ്യമില്ലാതെ ഒറ്റപ്പെട്ട രീതിയിൽ പ്രോസസ്സ് ചെയ്യാൻ കഴിയുന്ന തരത്തിൽ അടച്ചിരിക്കണമെങ്കിൽ ഒരു ഭാഷ സമാഹരിച്ചതായി പറയപ്പെടുന്നു. അല്ലാത്തപക്ഷം, ഭാഷാ ഘടനയെക്കുറിച്ച് മനസ്സിലാക്കാൻ ഉറപ്പില്ല.
വ്യാഖ്യാനിച്ച ഭാഷകളുടെ പ്രധാന നേട്ടം, അവ ഉപയോഗിക്കുമ്പോൾ, പ്രോഗ്രാം “കൂടുതൽ” (ഘട്ടം ഘട്ടമായുള്ള മോഡിൽ) എഴുതുന്നു എന്നതാണ്. മുമ്പത്തെ ഘട്ടത്തോടുള്ള സിസ്റ്റത്തിൻ്റെ പ്രതികരണത്തെ ആശ്രയിച്ച് ഒരു വ്യക്തി തൻ്റെ അടുത്ത ഘട്ടത്തെക്കുറിച്ച് തീരുമാനമെടുക്കുന്നു. തത്വത്തിൽ, സമാഹരിച്ചതോ വ്യാഖ്യാനിച്ചതോ ആയ ഭാഷകൾക്കുള്ള മുൻഗണന വ്യക്തിയുടെ വ്യക്തിപരമായ അഭിരുചിയുടെ കാര്യമാണ്.
ഏത് പ്രോഗ്രാമും ഒരു വികസിത കമാൻഡ് ഭാഷയിൽ എഴുതാൻ കഴിയുമെങ്കിലും മിക്ക കേസുകളിലും വാക്കിൻ്റെ സാധാരണ അർത്ഥത്തിൽ പ്രോഗ്രാമിംഗിനായി ഉപയോഗിക്കുന്നില്ല എന്നതാണ് കമാൻഡ് ഭാഷകളുടെ പ്രത്യേകത. ആവർത്തിച്ചുള്ള പതിവ് നടപടിക്രമങ്ങൾ സംരക്ഷിക്കുന്നതിനായി കമാൻഡ് ഫയലുകൾ (UNIX OS ടെർമിനോളജിയിലെ സ്ക്രിപ്റ്റുകൾ അല്ലെങ്കിൽ സ്ക്രിപ്റ്റുകൾ) രചിക്കുന്നതിനുള്ള കഴിവ് ഉപയോഗിച്ച്, സിസ്റ്റവുമായുള്ള നേരിട്ടുള്ള ഇടപെടലിനായി പ്രാഥമികമായി ഉപയോഗിക്കുന്നതാണ് കമാൻഡ് ഭാഷ ഉപയോഗിക്കുന്നതിൻ്റെ ശരിയായ ശൈലി.
കമാൻഡ് ലാംഗ്വേജ് കൺസ്ട്രക്‌റ്റുകൾ പ്രോസസ്സ് ചെയ്യാൻ രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്ന പ്രോഗ്രാമുകളെ കമാൻഡ് ഇൻ്റർപ്രെറ്ററുകൾ എന്ന് വിളിക്കുന്നു. കംപൈൽ ചെയ്ത പ്രോഗ്രാമിംഗ് ഭാഷകളിൽ നിന്ന് വ്യത്യസ്തമായി (സി അല്ലെങ്കിൽ പാസ്കൽ പോലുള്ളവ), അവയിൽ ഓരോന്നിനും സാധാരണയായി നിരവധി കംപൈലറുകൾ ഉണ്ട്, ഒരു കമാൻഡ് ഭാഷ സാധാരണയായി അനുബന്ധ വ്യാഖ്യാതാവുമായി അഭേദ്യമായി ബന്ധപ്പെട്ടിരിക്കുന്നു. ഷെൽ കുടുംബത്തിൽ പെടുന്ന UNIX OS കമാൻഡ് ഭാഷകളുടെ വിവിധ പ്രതിനിധികളെക്കുറിച്ച് ഞങ്ങൾ ചുവടെ സംസാരിക്കുമ്പോൾ, ഓരോ തവണയും ഞങ്ങൾ അതേ പേരിൽ അനുബന്ധ വ്യാഖ്യാതാവിനെ അർത്ഥമാക്കും.
