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

ഉപദേശം സ്‌കൂളിലോ യൂണിവേഴ്‌സിറ്റിയിലോ ഹോം പ്രോജക്‌റ്റായി ചുവടെയുള്ള കോഡ് സമർപ്പിക്കുകയോ (പരിഷ്‌കരിച്ച രൂപത്തിൽ പോലും) ഉപയോഗിക്കുകയോ ചെയ്യരുത്. ഒറിജിനൽ ലേഖനത്തെക്കുറിച്ച് പല അധ്യാപകരും അറിയുകയും നിങ്ങളെ വഞ്ചിക്കുന്നത് പിടിക്കുകയും ചെയ്യും.

ഷെൽ ജീവിത ചക്രം

ഷെൽ അതിന്റെ ജീവിതകാലത്ത് മൂന്ന് പ്രധാന പ്രവർത്തനങ്ങൾ ചെയ്യുന്നു:

1. ആരംഭിക്കൽ: ഈ ഘട്ടത്തിൽ, അത് അതിന്റെ കോൺഫിഗറേഷൻ ഫയലുകൾ വായിക്കുകയും നടപ്പിലാക്കുകയും ചെയ്യുന്നു. അവർ അവളുടെ സ്വഭാവം മാറ്റുന്നു.
2. വ്യാഖ്യാനം: ഷെൽ പിന്നീട് stdin-ൽ നിന്നുള്ള കമാൻഡുകൾ വായിക്കുകയും അവ നടപ്പിലാക്കുകയും ചെയ്യുന്നു.
3. ഷട്ട്ഡൗൺ: അടിസ്ഥാന കമാൻഡുകൾ എക്സിക്യൂട്ട് ചെയ്ത ശേഷം, ഇത് ഷട്ട്ഡൗൺ കമാൻഡുകൾ പ്രവർത്തിപ്പിക്കുകയും മെമ്മറി സ്വതന്ത്രമാക്കുകയും പുറത്തുകടക്കുകയും ചെയ്യുന്നു.

ഈ മൂന്ന് പ്രവർത്തനങ്ങളാണ് ഞങ്ങളുടെ കമാൻഡ് ഷെല്ലിന്റെ അടിസ്ഥാനമായി ഞങ്ങൾ ഉപയോഗിക്കുന്നത്. ഞങ്ങൾ ചേർക്കില്ല അധിക ഫയലുകൾകോൺഫിഗറേഷനും ഷട്ട്ഡൗൺ കമാൻഡും. ഞങ്ങൾ ലൂപ്പ് ഫംഗ്ഷൻ വിളിച്ച് ജോലി പൂർത്തിയാക്കും. ഒരു വാസ്തുവിദ്യാ വീക്ഷണകോണിൽ നിന്ന് ഇത് ശ്രദ്ധിക്കേണ്ടതാണ്. ജീവിത ചക്രംഒരു ലൂപ്പിനെക്കാൾ സങ്കീർണ്ണമാണ്.

Int main(int argc, char **argv) ( // കോൺഫിഗറേഷൻ ഫയലുകൾ ലഭ്യമാണെങ്കിൽ ലോഡ് ചെയ്യുക. // ഒരു കമാൻഡ് ലൂപ്പ് ആരംഭിക്കുക. lsh_loop(); // ഷട്ട് ഡൗൺ / മെമ്മറി ക്ലിയർ ചെയ്യുക. EXIT_SUCCESS മടങ്ങുക; )

മുകളിലുള്ള ഉദാഹരണത്തിൽ നിങ്ങൾക്ക് lsh_loop() ഫംഗ്ഷൻ കാണാം, അത് കമാൻഡുകൾ വഴി ലൂപ്പ് ചെയ്യും. ചുവടെയുള്ള നടപ്പാക്കൽ ഞങ്ങൾ നോക്കാം.

അടിസ്ഥാന ഷെൽ ലൂപ്പ്

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

1. വായിക്കുക: സ്റ്റാൻഡേർഡ് സ്ട്രീമുകളിൽ നിന്ന് ഒരു കമാൻഡ് വായിക്കുക.
2. പാഴ്‌സിംഗ്: ഇൻപുട്ട് സ്‌ട്രിംഗിലെ പ്രോഗ്രാമും ആർഗ്യുമെന്റുകളും തിരിച്ചറിയുന്നു.
3. എക്സിക്യൂട്ട് ചെയ്യുക: അംഗീകൃത കമാൻഡ് പ്രവർത്തിപ്പിക്കുക.

ഈ ആശയം lsh_loop() ഫംഗ്ഷനിൽ നടപ്പിലാക്കുന്നു:

അസാധുവായ lsh_loop(void) (char *line; char **args; int status; do (printf("> "); line = lsh_read_line(); args = lsh_split_line(line); status = lsh_execute(args); free(line ); സ്വതന്ത്ര (ആർഗ്സ്); ) അതേസമയം (സ്റ്റാറ്റസ്);

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

ഒരു വരി വായിക്കുന്നു

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

#നിർവചിക്കുക LSH_RL_BUFSIZE 1024 char *lsh_read_line(void) ( int bufsize = LSH_RL_BUFSIZE; int പൊസിഷൻ = 0; char *buffer = malloc(sizeof(char) * bufsize); int c; (!printfsize) : മെമ്മറി അലോക്കേഷൻ പിശക്\n"); എക്സിറ്റ് (EXIT_FAILURE); ) അതേസമയം (1) ( // അക്ഷരം വായിക്കുക c = getchar(); // EOF അഭിമുഖീകരിക്കുമ്പോൾ, അത് ഒരു നൾ ടെർമിനേറ്റർ ഉപയോഗിച്ച് മാറ്റി പകരം ബഫർ നൽകുകയാണെങ്കിൽ (c) == ഇഒഎഫ് = ബഫ്‌സൈസ്) (ബഫ്‌സൈസ് += LSH_RL_BUFSIZE; ബഫർ = റീലോക്ക് (ബഫർ, ബഫ്‌സൈസ്); എങ്കിൽ (! ബഫർ) ( fprintf(stderr, "lsh: മെമ്മറി അലോക്കേഷൻ പിശക്\n"); പുറത്തുകടക്കുക (EXIT_FAILURE); ) ) ) )

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

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

C സ്റ്റാൻഡേർഡ് ലൈബ്രറിയുടെ പുതിയ പതിപ്പുകൾ പരിചയമുള്ളവർ, മുകളിലെ കോഡിൽ നടപ്പിലാക്കിയ മിക്ക ജോലികളും ചെയ്യുന്ന ഒരു getline() ഫംഗ്‌ഷൻ stdio.h-ന് ഉണ്ടെന്ന് ശ്രദ്ധിച്ചേക്കാം. ഈ സവിശേഷത 2008 വരെ സി ലൈബ്രറിയിലേക്കുള്ള ഒരു ഗ്നു വിപുലീകരണമായിരുന്നു, തുടർന്ന് ഇത് സ്പെസിഫിക്കേഷനിലേക്ക് ചേർത്തു, അതിനാൽ മിക്ക ആധുനിക യുണിക്സ് സിസ്റ്റങ്ങളും ഇതിനോടകം തന്നെ വരുന്നു. ഗെറ്റ്‌ലൈൻ ഉപയോഗിച്ച് പ്രവർത്തനം നിസ്സാരമായിത്തീരുന്നു:

Char *lsh_read_line(void) ( char *line = NULL; ssize_t bufsize = 0; // getline മെമ്മറി ഗെറ്റ്‌ലൈൻ അനുവദിക്കും (&line, &bufsize, stdin); റിട്ടേൺ ലൈൻ; )

പാഴ്സിംഗ് സ്ട്രിംഗുകൾ

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

ഇപ്പോൾ നമ്മൾ ചെയ്യേണ്ടത് സ്‌പേസുകൾ ഡിലിമിറ്ററുകളായി ഉപയോഗിച്ച് സ്ട്രിംഗിനെ കഷണങ്ങളായി വിഭജിക്കുക എന്നതാണ്. ഇതിനർത്ഥം നമുക്ക് ക്ലാസിക് ലൈബ്രറി ഫംഗ്ഷൻ strtok ഉപയോഗിക്കാമെന്നാണ്.

#LSH_TOK_BUFSIZE 64 നിർവചിക്കുക #LSH_TOK_DELIM "\t\r\n\a" char **lsh_split_line(char *line) ( int bufsize = LSH_TOK_BUFSIZE, പൊസിഷൻ = 0; char **ടോക്കണുകൾ = malloc (ബഫ്‌സ്* ചാരിസ് * വലുപ്പം) ); ചാർ * ടോക്കൺ; എങ്കിൽ (! ടോക്കണുകൾ) ( fprintf(stderr, "lsh: മെമ്മറി അലോക്കേഷൻ പിശക്\n"); പുറത്തുകടക്കുക (EXIT_FAILURE); ) ടോക്കൺ = strtok(ലൈൻ, LSH_TOK_DELIM); അതേസമയം (ടോക്കൺ != NULL) ( ടോക്കണുകൾ = ടോക്കൺ; സ്ഥാനം++; എങ്കിൽ (സ്ഥാനം >= bufsize) (bufsize += LSH_TOK_BUFSIZE; ടോക്കണുകൾ = realloc (ടോക്കണുകൾ, bufsize * sizeof(char*)); എങ്കിൽ (! ടോക്കണുകൾ) ( fprintf(stderr, "lsh: മെമ്മറി അലോക്കേഷൻ പിശക് \n"); പുറത്തുകടക്കുക(EXIT_FAILURE); ) ) ടോക്കൺ = strtok(NULL, LSH_TOK_DELIM); ) ടോക്കണുകൾ = NULL; ടോക്കണുകൾ തിരികെ നൽകുക; )

ഈ ഫംഗ്‌ഷൻ നടപ്പിലാക്കുന്നത് സംശയാസ്പദമായ രീതിയിൽ lsh_read_line() ന് സമാനമാണ്, നല്ല കാരണവുമുണ്ട്! അതേ തന്ത്രം തന്നെയാണ് ഇവിടെയും ഉപയോഗിച്ചിരിക്കുന്നത്, എന്നാൽ നൾ ടെർമിനേറ്റഡ് ക്യാരക്ടർ അറേയ്‌ക്ക് പകരം ഞങ്ങൾ ഒരു നൾ ടെർമിനേറ്റഡ് പോയിന്റർ അറേ ഉപയോഗിക്കുന്നു.

strtok എന്ന് വിളിച്ച് ഞങ്ങൾ പാർട്ടീഷൻ ചെയ്യാൻ തുടങ്ങുന്നു. ഇത് സ്ട്രിംഗിന്റെ ആദ്യ ഭാഗത്തേക്ക് (ടോക്കൺ) ഒരു പോയിന്റർ നൽകുന്നു. പൊതുവേ, strtok() സ്ട്രിംഗിലെ സ്ഥലങ്ങളിലേക്ക് പോയിന്ററുകൾ നൽകുകയും ഓരോ ടോക്കണിന്റെയും അവസാനം നൾ ടെർമിനേറ്ററുകൾ സ്ഥാപിക്കുകയും ചെയ്യുന്നു. ഞങ്ങൾ ഈ പോയിന്ററുകൾ ഒരു പ്രത്യേക അറേയിൽ സംഭരിക്കുന്നു.

ആവശ്യമെങ്കിൽ, ഞങ്ങൾ പോയിന്റർ അറേ വീണ്ടും അനുവദിക്കും. strtok ടോക്കണുകൾ തിരികെ നൽകുന്നത് നിർത്തുന്നത് വരെ ഞങ്ങൾ പ്രക്രിയ ആവർത്തിക്കുന്നു, കൂടാതെ ഒരു നൾ ടെർമിനേറ്റർ ഉപയോഗിച്ച് ടോക്കൺ അറേ അവസാനിപ്പിക്കും.

നിർവ്വഹിക്കുന്നതിന് തയ്യാറായ ഒരു കൂട്ടം ടോക്കണുകൾ ഞങ്ങളുടെ പക്കലുണ്ട്.

കമാൻഡ് ഷെല്ലുകൾ എങ്ങനെ പ്രോസസ്സുകൾ ആരംഭിക്കുന്നു

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

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

മറ്റെല്ലാ പ്രക്രിയകളും Init അല്ലാത്തതിനാൽ, പ്രോസസ്സുകൾ ആരംഭിക്കാൻ ഒരു പ്രായോഗിക മാർഗമേയുള്ളൂ: ഫോർക്ക്() സിസ്റ്റം കോൾ. ഈ ഫംഗ്ഷൻ വിളിക്കുമ്പോൾ, ഓപ്പറേറ്റിംഗ് സിസ്റ്റം പ്രക്രിയയുടെ തനിപ്പകർപ്പ് ഉണ്ടാക്കുകയും സമാന്തരമായി പ്രവർത്തിക്കുകയും ചെയ്യുന്നു. യഥാർത്ഥ പ്രക്രിയയെ "പാരന്റ്" എന്നും പുതിയ പ്രക്രിയയെ "കുട്ടി" എന്നും വിളിക്കുന്നു. ഫോർക്ക്() ചൈൽഡ് പ്രോസസിലേക്ക് 0 തിരികെ നൽകുകയും അതിന്റെ കുട്ടിയുടെ പ്രോസസ് ഐഡന്റിഫയർ (പിഐഡി) രക്ഷിതാവിന് നൽകുകയും ചെയ്യുന്നു. അങ്ങനെ ആരെങ്കിലും പുതിയ പ്രക്രിയനിലവിലുള്ള ഒന്നിന്റെ പകർപ്പിൽ നിന്ന് മാത്രമേ സൃഷ്ടിക്കാൻ കഴിയൂ.

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

ഈ രണ്ട് സിസ്റ്റം കോളുകൾ യുണിക്സിൽ മിക്ക പ്രോഗ്രാമുകളും പ്രവർത്തിപ്പിക്കുന്നത് സാധ്യമാക്കുന്നു. ആദ്യം, നിലവിലുള്ള പ്രക്രിയ മാതാപിതാക്കളിലേക്കും കുട്ടിയിലേക്കും മാറുന്നു, തുടർന്ന് ചൈൽഡ് പ്രോസസ് ഒരു പുതിയ പ്രോഗ്രാം ഉപയോഗിച്ച് സ്വയം മാറ്റിസ്ഥാപിക്കുന്നതിന് exec() ഉപയോഗിക്കുന്നു. പാരന്റ് പ്രോസസിന് മറ്റ് കാര്യങ്ങൾ ചെയ്യുന്നത് തുടരാനും സ്വന്തം ട്രാക്ക് സൂക്ഷിക്കാനും കഴിയും കുട്ടികളുടെ ഘടകങ്ങൾവെയിറ്റ്() സിസ്റ്റം കോൾ ഉപയോഗിക്കുന്നു.

അതെ, ധാരാളം വിവരങ്ങൾ ഉണ്ട്. പ്രോഗ്രാം ലോഞ്ച് കോഡ് നോക്കാം:

Int lsh_launch(char **args) ( pid_t pid, wpid; int status; pid = fork(); if (pid == 0) (// Child process if (execvp(args, args) == -1) (perror ("lsh"); ) പുറത്തുകടക്കുക(EXIT_FAILURE); ) അല്ലെങ്കിൽ (pid< 0) { // Ошибка при форкинге perror("lsh"); } else { // Родительский процесс do { wpid = waitpid(pid, &status, WUNTRACED); } while (!WIFEXITED(status) && !WIFSIGNALED(status)); } return 1; }

ഈ ഫംഗ്‌ഷൻ ഞങ്ങൾ നേരത്തെ സൃഷ്‌ടിച്ച ആർഗ്യുമെന്റുകളുടെ ഒരു ലിസ്റ്റ് എടുക്കുന്നു. ഇത് പിന്നീട് പ്രോസസ്സ് അൺവൈൻഡ് ചെയ്യുകയും റിട്ടേൺ മൂല്യം സംഭരിക്കുകയും ചെയ്യുന്നു. ഫോർക്ക്() തിരിച്ചെത്തിയാൽ, നമുക്ക് രണ്ട് സമാന്തര പ്രക്രിയകളുണ്ട്. ചൈൽഡ് പ്രോസസ്സ് ആദ്യ if അവസ്ഥയുമായി പൊരുത്തപ്പെടുന്നു (ഇവിടെ pid == 0).

ചൈൽഡ് പ്രോസസ്സിൽ, കമാൻഡ് പ്രവർത്തിപ്പിക്കാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നു, ഉപയോക്താവ് വ്യക്തമാക്കിയത്. അതിനാൽ, ഞങ്ങൾ exec സിസ്റ്റം കോളിന്റെ ഒരു വകഭേദം ഉപയോഗിക്കുന്നു, execvp. വ്യത്യസ്ത വകഭേദങ്ങൾഎക്സിക്യൂട്ടീവ് വ്യത്യസ്ത കാര്യങ്ങൾ ചെയ്യുന്നു. ചിലത് സ്ട്രിംഗ് ആർഗ്യുമെന്റുകളുടെ ഒരു വേരിയബിൾ നമ്പർ എടുക്കുന്നു, മറ്റുള്ളവർ സ്ട്രിംഗുകളുടെ ഒരു ലിസ്റ്റ് എടുക്കുന്നു, മറ്റുള്ളവ പ്രോസസ്സ് പ്രവർത്തിക്കുന്ന പരിസ്ഥിതി വ്യക്തമാക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു. ഈ പ്രത്യേക വേരിയന്റ് ഒരു പ്രോഗ്രാമിന്റെ പേരും ഒരു അറേയും (വെക്റ്റർ എന്നും വിളിക്കുന്നു, അതിനാൽ "v") സ്ട്രിംഗ് ആർഗ്യുമെന്റുകൾ (ആദ്യത്തേത് പ്രോഗ്രാമിന്റെ പേരായിരിക്കണം) എടുക്കുന്നു. "p" എന്നതിനർത്ഥം, പ്രോഗ്രാം ഫയലിലേക്ക് റൺ ചെയ്യാനുള്ള മുഴുവൻ പാതയും നൽകുന്നതിനുപകരം, ഞങ്ങൾ അതിന്റെ പേര് മാത്രം വ്യക്തമാക്കും, കൂടാതെ ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തോട് അത് സ്വയം അന്വേഷിക്കാൻ പറയുകയും ചെയ്യും.

exec -1 (അല്ലെങ്കിൽ മറ്റേതെങ്കിലും മൂല്യം) നൽകുകയാണെങ്കിൽ, ഒരു പിശക് സംഭവിച്ചു. അതിനാൽ പ്രോഗ്രാമിന്റെ പേരിനൊപ്പം പിശക് സന്ദേശം അച്ചടിക്കാൻ ഞങ്ങൾ പെറർ ഉപയോഗിക്കുന്നു, അതിനാൽ പിശക് എവിടെയാണ് സംഭവിച്ചതെന്ന് വ്യക്തമാകും. തുടർന്ന് ഞങ്ങൾ പ്രക്രിയ അവസാനിപ്പിക്കുന്നു, പക്ഷേ ഷെൽ പ്രവർത്തിക്കുന്നത് തുടരും.

രണ്ടാമത്തെ അവസ്ഥ (pid< 0) проверяет, произошла ли в процессе выполнения fork() ошибка. Если ошибка есть, мы выводим сообщение об этом на экран, но программа продолжает работать.

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

ഷെൽ ബിൽഡിനുകൾ

lsh_loop() ഫംഗ്‌ഷൻ lsh_execute() എന്ന് വിളിക്കുന്നത് നിങ്ങൾ ശ്രദ്ധിച്ചിരിക്കാം, എന്നാൽ മുകളിൽ ഞങ്ങൾ ഞങ്ങളുടെ ഫംഗ്‌ഷനെ lsh_launch() എന്ന് വിളിക്കുന്നു. ഇത് മനഃപൂർവമായിരുന്നു! ഷെൽ എക്സിക്യൂട്ട് ചെയ്യുന്ന മിക്ക കമാൻഡുകളും പ്രോഗ്രാമുകളാണ് - എന്നാൽ എല്ലാം അല്ല. ചില കമാൻഡുകൾ ഷെല്ലിൽ തന്നെ നിർമ്മിച്ചിരിക്കുന്നു.

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

അതുപോലെ, എക്സിറ്റ് എന്ന് പേരുള്ള ഒരു പ്രോഗ്രാമിന് അതിനെ വിളിച്ച കമാൻഡ് ഷെല്ലിൽ നിന്ന് പുറത്തുകടക്കാൻ കഴിയില്ല. ഈ കമാൻഡ് ഷെല്ലിലും നിർമ്മിക്കണം. കൂടാതെ, മിക്ക ഷെല്ലുകളും ~/.bashrc പോലുള്ള കോൺഫിഗറേഷൻ സ്ക്രിപ്റ്റുകൾ ഉപയോഗിച്ചാണ് ക്രമീകരിച്ചിരിക്കുന്നത്. ഷെൽ എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്നതിനെ മാറ്റുന്ന കമാൻഡുകൾ ഈ സ്ക്രിപ്റ്റുകൾ ഉപയോഗിക്കുന്നു. ഷെല്ലിനുള്ളിൽ തന്നെ നടപ്പിലാക്കിയിട്ടുണ്ടെങ്കിൽ, കമാൻഡുകൾക്ക് തന്നെ ഷെല്ലിന്റെ പ്രവർത്തന രീതി മാറ്റാൻ കഴിയും.

അതനുസരിച്ച്, ഷെല്ലിലേക്ക് ചില കമാൻഡുകൾ ചേർക്കുന്നത് അർത്ഥമാക്കുന്നു. ഈ ഷെല്ലിൽ ഞങ്ങൾ cd, എക്സിറ്റ്, സഹായം എന്നിവ ചേർക്കും. ഈ ഫംഗ്‌ഷനുകൾ നടപ്പിലാക്കുന്നത് ഇതാ:

/* ഷെൽ ബിൽറ്റ്-ഇന്നുകൾക്കുള്ള ഫംഗ്‌ഷനുകൾ പ്രഖ്യാപിക്കുന്നു: */ int lsh_cd(char **args); int lsh_help(char **args); int lsh_exit(char **args); /* ബിൽറ്റ്-ഇൻ കമാൻഡുകളുടെ ലിസ്റ്റ് തുടർന്ന് അനുബന്ധ പ്രവർത്തനങ്ങൾ */ char *builtin_str = ( "cd", "help", "exit" ); int (*builtin_func) (char **) = ( &lsh_cd, &lsh_help, &lsh_exit ); int lsh_num_builtins() ( return sizeof(builtin_str) / sizeof(char *); ) /* ബിൽറ്റ്-ഇൻ ഫംഗ്‌ഷനുകളുടെ നടപ്പിലാക്കലുകൾ */ int lsh_cd(char **args) ( if (args == NULL) ( fprintf(stderr, " lsh: \"cd\"\n"); ) മറ്റുള്ളവ (chdir(args) != 0) (perror("lsh"); ) റിട്ടേൺ 1; ) int lsh_help(char **args) ( int i ; printf("LSH by Stephen Brennan\n"); printf("പ്രോഗ്രാമിന്റെ പേരും അതിന്റെ ആർഗ്യുമെന്റുകളും ടൈപ്പ് ചെയ്ത് എന്റർ അമർത്തുക.\n"); printf("ബിൽറ്റ്-ഇൻ കമാൻഡുകളുടെ ഒരു ലിസ്റ്റ് ഇതാ: \n"); (i = 0; i< lsh_num_builtins(); i++) { printf(" %s\n", builtin_str[i]); } printf("Используйте команду man для получения информации по другим программам.\n"); return 1; } int lsh_exit(char **args) { return 0; }

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

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

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

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

lsh_execute() ഫംഗ്‌ഷൻ നടപ്പിലാക്കുന്നതാണ് പസിലിന്റെ അവസാനത്തെ നഷ്‌ടമായ ഭാഗം, അത് ഒന്നുകിൽ ഒരു നേറ്റീവ് അല്ലെങ്കിൽ മറ്റൊരു പ്രോസസ്സ് സമാരംഭിക്കുന്നു.

Int lsh_execute(char **args) (int i; എങ്കിൽ (args == NULL) (// ഒരു ശൂന്യമായ കമാൻഡ് നൽകി. റിട്ടേൺ 1; ) എന്നതിന് (i = 0; i< lsh_num_builtins(); i++) { if (strcmp(args, builtin_str[i]) == 0) { return (*builtin_func[i])(args); } } return lsh_launch(args); }

കമാൻഡ് ഇൻലൈൻ ചെയ്തിട്ടുണ്ടോ എന്ന് കോഡ് പരിശോധിക്കുന്നു. അങ്ങനെയാണെങ്കിൽ, അത് അത് സമാരംഭിക്കുന്നു, അല്ലാത്തപക്ഷം പ്രക്രിയ സമാരംഭിക്കുന്നതിന് lsh_launch() എന്ന് വിളിക്കുന്നു.

അതെല്ലാം ഒന്നിച്ചു ചേർക്കുന്നു

കമാൻഡ് ഷെല്ലിലേക്ക് പോകുന്ന കോഡ് അത്രയേയുള്ളൂ. നിങ്ങൾ ലേഖനം ശ്രദ്ധാപൂർവ്വം വായിച്ചാൽ, ഷെൽ എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് നിങ്ങൾ മനസ്സിലാക്കിയിരിക്കണം. ഷെൽ (ലിനക്സിൽ) പരീക്ഷിക്കുന്നതിന്, നിങ്ങൾ ഈ കോഡ് സെഗ്‌മെന്റുകൾ main.c ഫയലിലേക്ക് പകർത്തി കംപൈൽ ചെയ്യേണ്ടതുണ്ട്. ഒരു lsh_read_line() നടപ്പിലാക്കൽ മാത്രം ഉൾപ്പെടുത്തുന്നത് ഉറപ്പാക്കുക. നിങ്ങൾ ഇനിപ്പറയുന്ന തലക്കെട്ട് ഫയലുകൾ ഉൾപ്പെടുത്തേണ്ടതുണ്ട്:

• #ഉൾപ്പെടുന്നു
  • waitpid() ഉം അനുബന്ധ മാക്രോകളും
• #ഉൾപ്പെടുന്നു
  • chdir()
  • ഫോർക്ക്()
  • എക്സിക്()
  • pid_t
• #ഉൾപ്പെടുന്നു
  • malloc()
  • realloc()
  • സൗ ജന്യം()
  • പുറത്ത്()
  • execvp()
  • EXIT_SUCCESS, EXIT_FAILURE
• #ഉൾപ്പെടുന്നു
  • fprintf()
  • printf()
  • stderr
  • getchar()
  • തെറ്റ്()
• #ഉൾപ്പെടുന്നു
  • strcmp()
  • strtok()

ഫയൽ കംപൈൽ ചെയ്യുന്നതിന്, ഒരു ടെർമിനലിൽ gcc -o main main.c എന്ന് ടൈപ്പ് ചെയ്യുക, തുടർന്ന് പ്രവർത്തിപ്പിക്കാൻ ./main എന്ന് ടൈപ്പ് ചെയ്യുക.

കൂടാതെ, എല്ലാ ഉറവിടങ്ങളും GitHub-ൽ ലഭ്യമാണ്.

സംഗ്രഹിക്കുന്നു

വ്യക്തമായും, ഈ ഷെൽ മൾട്ടിഫങ്ഷണൽ അല്ല. അവളുടെ ചില ഒഴിവാക്കലുകൾ:

• ആർഗ്യുമെന്റുകൾ സ്‌പെയ്‌സുകളാൽ മാത്രമേ വേർതിരിച്ചിട്ടുള്ളൂ, ഉദ്ധരണികൾക്കോ ​​ബാക്ക്‌സ്ലാഷുകൾക്കോ ​​പിന്തുണയില്ല;
• വഴിതിരിച്ചുവിടലോ പൈപ്പ് ലൈനുകളോ ഇല്ല;
• കുറച്ച് അന്തർനിർമ്മിത പ്രവർത്തനങ്ങൾ;
• ഫയൽനാമത്തിന് പകരം വയ്ക്കുന്നതല്ല.

സിസ്റ്റം കോളുകൾ മനസിലാക്കാൻ, നിങ്ങൾ മാനുവൽ റഫർ ചെയ്യാൻ ഞങ്ങൾ ശുപാർശ ചെയ്യുന്നു: man 3p. C, Unix സ്റ്റാൻഡേർഡ് ലൈബ്രറികൾ നിങ്ങൾക്ക് വാഗ്ദാനം ചെയ്യുന്ന ഇന്റർഫേസ് എന്താണെന്ന് നിങ്ങൾക്ക് അറിയില്ലെങ്കിൽ, POSIX സ്പെസിഫിക്കേഷൻ, പ്രത്യേകിച്ച് സെക്ഷൻ 13 നോക്കാൻ ഞങ്ങൾ ശുപാർശ ചെയ്യുന്നു.

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

എക്കോ ഹലോ!

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

Sh ഫയൽ_1

ശ്രീ< file1

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

ഫയൽ_1

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

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

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

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

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

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 ഫയൽ_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

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

    ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങൾ ലിനക്സ് കുടുംബം, മറ്റേതൊരു 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, case മുതലായവ ഉൾപ്പെടുന്നു. സ്വാഭാവികമായും, വ്യത്യസ്ത ഷെൽ ഓപ്ഷനുകൾക്കായി അന്തർനിർമ്മിത കമാൻഡുകൾ വ്യത്യാസപ്പെടാം. ബിൽറ്റ്-ഇൻ കമാൻഡുകൾക്ക് പുറമേ, ഇത് ഉപയോഗിക്കാൻ കഴിയും സോഫ്റ്റ്വെയർ മൊഡ്യൂളുകൾ, വ്യക്തിഗത എക്സിക്യൂട്ടബിൾ ഫയലുകൾ അല്ലെങ്കിൽ ഫയലുകൾ സ്ക്രിപ്റ്റുകൾഅഥവാ രംഗങ്ങൾ- സാധാരണ ടെക്സ്റ്റ് ഫയലുകൾ, തുടർച്ചയായി നടപ്പിലാക്കിയ ഷെൽ കമാൻഡ് ലൈനുകൾ അടങ്ങിയിരിക്കുന്നു. ചില സ്ക്രിപ്റ്റുകൾ (സ്ക്രിപ്റ്റുകൾ) ടാസ്ക് ഷെഡ്യൂളർ പോലെയുള്ള 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-ൽ താഴെയോ ഉള്ള ഉപയോക്തൃ ഐഡി ഉപയോഗിക്കുന്നു. IN ഈ ഉദാഹരണത്തിൽ, പരിസ്ഥിതി വേരിയബിൾ എല്ലാവർക്കും സജ്ജമാക്കും പ്രാദേശിക ഉപയോക്താക്കൾ 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ഒപ്പം കഴിയുന്നത്ര സ്റ്റാൻഡേർഡിനോട് അടുക്കാൻ ശ്രമിക്കുന്നു പോസിക്സ്, ഇത് പ്രോഗ്രാമിംഗിനും ഉപയോഗത്തിനും നിരവധി മെച്ചപ്പെടുത്തലുകൾക്ക് കാരണമായി സംവേദനാത്മക മോഡ്. ആധുനിക നടപ്പാക്കലിൽ ബാഷ്ഒരു കമാൻഡ് ലൈൻ എഡിറ്റിംഗ് മോഡ് ഉണ്ട്, പരിധിയില്ലാത്ത വലിപ്പംകമാൻഡ് ഹിസ്റ്ററി, ടാസ്‌ക് മാനേജ്‌മെന്റ് ടൂളുകൾ, അപരനാമങ്ങൾ ഉപയോഗിക്കാനുള്ള കഴിവ്, ബിൽറ്റ്-ഇൻ കമാൻഡുകളുടെ വിപുലമായ ലിസ്റ്റ്, ഷെൽ ഫംഗ്‌ഷനുകൾ മുതലായവ. പൊതുവെ, ബാഷ്ലിനക്സ് പരിതസ്ഥിതിയിൽ ഏറ്റവും കൂടുതൽ ഉപയോഗിക്കുന്ന സാധാരണ ഉപയോക്താവിന്റെ ആവശ്യങ്ങൾക്ക് ഏറ്റവും അനുയോജ്യമാണ്.

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

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

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

തുടക്കത്തിൽ, ഇത് 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 സ്റ്റാൻഡേർഡ് ലൈബ്രറിയിൽ നിന്നുള്ള ഒരു ഫംഗ്ഷൻ വിവരിക്കുന്നു, കൂടാതെ 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-ന്റെ ആവശ്യകതകളുടെ ഏതാനും ഉദാഹരണങ്ങൾ ഞാൻ തരാം.

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

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

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

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

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

എന്താണ് ഷെൽ

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

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

സാധാരണ ഷെൽ തരം:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

• ഹോസ്റ്റ്നാമം - നിങ്ങൾ നിലവിൽ ഉള്ള മെഷീന്റെ (സെർവർ) പേര് പ്രദർശിപ്പിക്കുന്നു;
• 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 സ്റ്റാൻഡേർഡ് ലൈബ്രറിയിൽ നിന്നുള്ള ഒരു ഫംഗ്ഷൻ വിവരിക്കുന്നു, കൂടാതെ 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-ന്റെ ആവശ്യകതകളുടെ ഏതാനും ഉദാഹരണങ്ങൾ ഞാൻ തരാം.