ബാഷിൽ സോഴ്uസിംഗും ഫോർക്കിംഗും തമ്മിലുള്ള വ്യത്യാസം മനസിലാക്കുക

നിങ്ങൾ സ്uക്രിപ്റ്റ് vs സ്uക്രിപ്റ്റ് സോഴ്uസ് ബാഷിൽ പ്രവർത്തിപ്പിക്കുമ്പോൾ എന്താണ് സംഭവിക്കുന്നതെന്ന് വ്യക്തമായി മനസ്സിലാക്കുക എന്നതാണ് ഈ ലേഖനത്തിന്റെ പ്രധാന ലക്ഷ്യം. ആദ്യം, നിങ്ങൾ സ്ക്രിപ്റ്റിനെ വ്യത്യസ്ത രീതികളിൽ വിളിക്കുമ്പോൾ പ്രോഗ്രാം എങ്ങനെയാണ് സമർപ്പിക്കുന്നതെന്ന് ഞങ്ങൾ വ്യക്തമായി മനസ്സിലാക്കും.

ശ്രദ്ധിക്കുക: ഒരു എക്സ്റ്റൻഷൻ ഉപയോഗിച്ച് സ്ക്രിപ്റ്റ് സൃഷ്ടിക്കുന്നതിൽ കാര്യമില്ല. എക്സ്റ്റൻഷനുകൾ ഇല്ലാതെ പോലും സ്ക്രിപ്റ്റ് നന്നായി പ്രവർത്തിക്കും.

അടിസ്ഥാനപരമായി, ഓരോ സ്ക്രിപ്റ്റും ആരംഭിക്കുന്നത് ഷെബാംഗ് (#!) എന്ന വരിയിൽ നിന്നാണ്. ബാഷിലെ ഹാഷ് ചിഹ്നം കമന്റുകളായി വ്യാഖ്യാനിക്കപ്പെടുമെങ്കിലും ഷെബാങ്ങിന് ഒരു പ്രത്യേക അർത്ഥമുണ്ട്. നിങ്ങൾ ഷെബാംഗിൽ സൂചിപ്പിച്ച ഏത് വ്യാഖ്യാതാവിലും പ്രോഗ്രാം സമർപ്പിക്കാൻ ഇത് ബാഷിനോട് പറയുന്നു.

താഴെ ഒരു സാമ്പിൾ പ്രോഗ്രാം ഉണ്ട്, ഞാൻ എന്റെ വ്യാഖ്യാതാവായി ബാഷിനെ വ്യക്തമാക്കുന്നു.

$ cat >> Hello_World.sh
#!/usr/bin/env bash
echo "Hello world"

$ chmod +x Hello_world.sh

ഇപ്പോൾ സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കാൻ, നിങ്ങൾക്ക് ഇത് രണ്ട് തരത്തിൽ ചെയ്യാം.

• സ്ക്രിപ്റ്റ് വിളിക്കാൻ ഒരു ആപേക്ഷിക പാത്ത് ഉപയോഗിക്കുക. സ്ക്രിപ്റ്റ് ഉള്ള ഡയറക്ടറിയിലേക്ക് നീക്കി ./Hello_world.sh.
റൺ ചെയ്യുക.
• സ്ക്രിപ്റ്റ് വിളിക്കാൻ കേവല പാത ഉപയോഗിക്കുക. ഫയൽ സിസ്റ്റത്തിൽ എവിടെ നിന്നും സ്ക്രിപ്റ്റിലേക്കുള്ള മുഴുവൻ പാതയും ടൈപ്പ് ചെയ്യുക.

$ ./Hello_world.sh
$ pwd
$ /home/karthick/Hello_world

ഷെബാംഗ് ഇല്ലാതെ നിങ്ങളുടെ പ്രോഗ്രാം സമർപ്പിക്കാൻ ശ്രമിക്കുമ്പോൾ എന്താണ് സംഭവിക്കുന്നതെന്ന് നോക്കാം. ഷെബാങ്ങിന്റെ അഭാവത്തിൽ, നിങ്ങൾ നിലവിൽ പ്രവർത്തിപ്പിക്കുന്ന ഏത് ഷെല്ലിലേക്കും പ്രോഗ്രാം സമർപ്പിക്കും, എന്റെ കാര്യത്തിൽ, അത് ബാഷ് (/ബിൻ/ബാഷ്) ആണ്.

ഞാൻ ഒരു ഉദാഹരണം കാണിക്കട്ടെ. ഞാൻ ഷെബാംഗ് ഇല്ലാതെ ഒരു പൈത്തൺ സ്uക്രിപ്റ്റ് സൃഷ്uടിക്കുന്നു, ഞാൻ പ്രോഗ്രാമിലേക്ക് വിളിക്കുമ്പോൾ, അത് ഈ പ്രോഗ്രാം പൈത്തൺ ഇന്റർപ്രെറ്ററിന് സമർപ്പിക്കണമെന്ന് ബാഷിന് അറിയില്ല, പകരം അത് നിലവിലെ ഷെല്ലിൽ പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കും.

$ cat > run-py.py
echo $SHELL
print("Hello world")

$ chmod +x run-py.py
$ ./run-py.py

ഈ സാഹചര്യത്തിൽ, ഏത് ഇന്റർപ്രെറ്ററിനാണ് ഇത് സമർപ്പിക്കേണ്ടതെന്ന് സൂചിപ്പിച്ചുകൊണ്ട് നിങ്ങൾക്ക് പ്രോഗ്രാമിലേക്ക് വിളിക്കാം അല്ലെങ്കിൽ എല്ലായ്പ്പോഴും ശുപാർശ ചെയ്യുന്ന ഷെബാംഗ് ലൈൻ ചേർക്കുക.

# which python3
$(which python3) /home/karthick/run_py.py

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

$ ps -ef --forest | grep -i bash

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

വേരിയബിളുകൾ എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്നും വേരിയബിളുകൾ എങ്ങനെ കയറ്റുമതി ചെയ്യാം എന്നതിനെക്കുറിച്ചും കൂടുതൽ മനസ്സിലാക്കാൻ ചുവടെയുള്ള ലേഖനങ്ങൾ നോക്കുക.

• ഷെൽ സ്ക്രിപ്റ്റിംഗിൽ 'ലിനക്സ് വേരിയബിളുകൾ' മനസ്സിലാക്കുകയും എഴുതുകയും ചെയ്യുക
• Bash-ൽ $$, $BASHPID എന്നിവ തമ്മിലുള്ള വ്യത്യാസം മനസിലാക്കുക

സ്ക്രിപ്റ്റ് ഉറവിടം

\Source എന്നത് ഒരു ഷെൽ ബിൽറ്റ്-ഇൻ കമാൻഡ് ആണ്, അത് അതിലേക്ക് ഒരു ആർഗ്യുമെന്റായി പാസ്സാക്കിയ ഫയൽ വായിക്കുകയും നിലവിലെ ഷെൽ പരിതസ്ഥിതിയിൽ കോഡ് പ്രവർത്തിപ്പിക്കുകയും ചെയ്യുന്നു. നിങ്ങൾ കൂടുതലും ഉപയോഗിക്കുന്ന ഉചിതമായ ഒരു ഉപയോഗ കേസ് .bashrc< എന്നതിലെ നിങ്ങളുടെ കോൺഫിഗറേഷൻ പരിഷ്ക്കരിക്കുക എന്നതാണ്. അല്ലെങ്കിൽ .bash_profile കൂടാതെ സോഴ്സ് കമാൻഡ് ഉപയോഗിച്ച് മാറ്റങ്ങൾ വീണ്ടും ലോഡുചെയ്യുന്നു.

$ type -a source

സോഴ്സ് കമാൻഡ് പ്രവർത്തിപ്പിക്കുന്നതിന് രണ്ട് വാക്യഘടന വഴികളുണ്ട്. രണ്ട് വാക്യഘടനകളിൽ നിന്ന് നിങ്ങൾക്ക് ആരെയും തിരഞ്ഞെടുക്കാം, അത് വ്യക്തിഗത ചോയിസാണ്.

$ source FILE_NAME [ARGUMENTS]
$ . FILE_NAME [ARGUMENTS]

ഉറവിടം യഥാർത്ഥത്തിൽ എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് ഞാൻ കാണിച്ചുതരാം. ഞാൻ രണ്ട് ഷെൽ സ്ക്രിപ്റ്റുകൾ സൃഷ്ടിക്കാൻ പോകുന്നു. ആദ്യത്തെ സ്ക്രിപ്റ്റ് (Module.sh) ചില വേരിയബിളുകളും ഫംഗ്ഷനുകളും ഹോൾഡ് ചെയ്യാൻ പോകുന്നു. രണ്ടാമത്തെ സ്ക്രിപ്റ്റ് (Main.sh) വേരിയബിൾ പ്രിന്റ് ചെയ്ത് ഫംഗ്ഷനെ വിളിക്കാൻ പോകുന്നു.

ഫയൽ Module.sh.

#!/usr/bin/env bash

VAR1=$(echo "Welcome to $1")

function f1(){
  echo “Function f1 is called”
}

ഫയൽ Main.sh.

#!/usr/bin/env bash

echo $VAR1
f1

സ്uക്രിപ്റ്റിന് എക്uസിക്യൂഷൻ പെർമിഷൻ സജ്ജീകരിച്ച് പ്രധാന സ്uക്രിപ്റ്റ് \main.sh എന്ന് വിളിക്കുക. ഇപ്പോൾ, ഈ സ്uക്രിപ്റ്റ് നിലവിലെ f1 ഫംഗ്uഷനും VAR1 വേരിയബിളും കണ്ടെത്താൻ ശ്രമിക്കും. ഷെൽ എൻവയോൺമെന്റ്, കമാൻഡ് കണ്ടെത്തിയില്ലെങ്കിൽ പരാജയപ്പെടും.

$ bash main.sh

ഇപ്പോൾ നമുക്ക് സ്ക്രിപ്റ്റിനുള്ളിൽ സോഴ്സ് കമാൻഡ് പ്രവർത്തിപ്പിക്കാം, അത് വേരിയബിളും ഫംഗ്ഷനുകളും നിലവിലെ ഷെൽ എൻവയോൺമെന്റിലേക്ക് ലോഡ് ചെയ്യും, അത് \main.sh വഴി ആക്സസ് ചെയ്യാവുന്നതാണ്.

ഫയൽ Module.sh.

#!/usr/bin/env bash

VAR1=$(echo "Welcome to $1")

function f1(){
  echo "Function f1 is called"
}

ഫയൽ Main.sh.

#!/usr/bin/env bash

source module.sh Tecmint
echo $VAR1
f1

ഇപ്പോൾ സ്ക്രിപ്റ്റ് വീണ്ടും പ്രവർത്തിപ്പിച്ച് നോക്കൂ.

$ bash main.sh

ഞങ്ങളുടെ ഷെൽ സ്ക്രിപ്റ്റുകൾ സൃഷ്ടിക്കുന്നതിൽ മോഡുലാർ പ്രോഗ്രാമിംഗ് സമീപനം പിന്തുടരാൻ ബാഷിൽ ഉറവിടം വളരെ ഉപയോഗപ്രദമാണ്. നമുക്ക് നമ്മുടെ കോഡ് ചെറിയ മൊഡ്യൂളുകളായി വിഭജിക്കുകയും നിരവധി പ്രോഗ്രാമുകളിൽ ഉപയോഗിക്കുകയും ചെയ്യാം. ഈ വഴികളിൽ, നമുക്ക് DRY (Don’t Repeat Yourself) തത്വം പിന്തുടരാം.

ഈ ലേഖനത്തിന് അത്രയേയുള്ളൂ. ബാഷിലെ സോഴ്uസിംഗും ഫോർക്കിംഗും തമ്മിലുള്ള വ്യത്യാസം ഞങ്ങൾ ഹ്രസ്വമായി ചർച്ച ചെയ്തു. ലേഖനത്തിലൂടെ പോയി നിങ്ങളുടെ വിലയേറിയ ഫീഡ്ബാക്ക് ഞങ്ങളുമായി പങ്കിടുക.