பாஷில் சோர்சிங் மற்றும் ஃபோர்கிங் இடையே வித்தியாசத்தைக் கற்றுக்கொள்ளுங்கள்


இந்த கட்டுரையின் முக்கிய கவனம் என்னவென்றால், நீங்கள் ஸ்கிரிப்டை vs மூலத்தை ஸ்கிரிப்டை பாஷில் இயக்கும்போது என்ன நடக்கிறது என்பதை தெளிவாக புரிந்துகொள்வது. முதலில், நீங்கள் ஸ்கிரிப்டை வெவ்வேறு வழிகளில் அழைக்கும்போது நிரல் எவ்வாறு சமர்ப்பிக்கப்படுகிறது என்பதை நாங்கள் தெளிவாக புரிந்துகொள்வோம்.

குறிப்பு: நீட்டிப்புடன் ஸ்கிரிப்டை உருவாக்குவது ஒரு பொருட்டல்ல. நீட்டிப்புகள் இல்லாமல் கூட ஸ்கிரிப்ட் நன்றாக இயங்கும்.

அடிப்படையில், ஒவ்வொரு ஸ்கிரிப்டும் ஒரு ஷெபாங் (#!) எனப்படும் ஒரு வரியுடன் தொடங்குகிறது. பாஷில் உள்ள ஹாஷ் சின்னம் கருத்துகளாக விளக்கப்படும், ஆனால் ஷெபாங்கிற்கு ஒரு சிறப்பு அர்த்தம் உள்ளது. ஷெபாங்கில் நீங்கள் குறிப்பிட்ட எந்த மொழிபெயர்ப்பாளரிடமும் நிரலைச் சமர்ப்பிக்க இது பாஷைக் கூறுகிறது.

கீழே ஒரு மாதிரி நிரல் மற்றும் நான் எனது மொழிபெயர்ப்பாளராக பாஷைக் குறிப்பிடுகிறேன்.

$ 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

ஷெபாங் இல்லாமல் உங்கள் நிரலை சமர்ப்பிக்க முயற்சிக்கும்போது என்ன நடக்கிறது என்பதை இப்போது பார்ப்போம். ஷெபாங் இல்லாதிருந்தால், நீங்கள் இயங்கும் தற்போதைய ஷெல்லுக்கு நிரல் சமர்ப்பிக்கப்படும், என் விஷயத்தில், இது பாஷ் (/ பின்/பாஷ்) ஆகும்.

ஒரு உதாரணத்தை நிரூபிக்கிறேன். நான் ஷெபாங் இல்லாமல் ஒரு பைதான் ஸ்கிரிப்டை உருவாக்கி வருகிறேன், நான் நிரலை அழைக்கும் போது, இந்த திட்டத்தை பைத்தான் மொழிபெயர்ப்பாளரிடம் சமர்ப்பிக்க வேண்டும் என்று பாஷ் அறியவில்லை, அதற்கு பதிலாக அது தற்போதைய ஷெல்லில் நிரலை இயக்கும்.

$ 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

ஸ்கிரிப்டை எவ்வாறு அழைப்பது என்பது இப்போது உங்களுக்குத் தெரியும், அடுத்த கட்டமாக நாம் ஸ்கிரிப்டை அழைக்கும்போது என்ன நடக்கிறது என்பதைப் புரிந்துகொள்வது. மேலே உள்ள எடுத்துக்காட்டுகளில் காட்டப்பட்டுள்ளபடி ஸ்கிரிப்டை நீங்கள் செயல்படுத்தும்போது, அது ஒரு குழந்தை செயல்முறையை உருவாக்கும் (முட்கரண்டி) மற்றும் ஸ்கிரிப்ட் குழந்தை செயல்முறைக்கு சமர்ப்பிக்கப்படும். நான் ஒரு மாதிரி ஸ்கிரிப்டை இயக்கினேன், அது பின்வரும் கட்டளையை இயக்கும் மற்றும் ஸ்கிரிப்ட் ஒரு குழந்தை செயல்முறைக்கு சமர்ப்பிக்கப்பட்டதைக் காட்டுகிறது.

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

ஸ்கிரிப்ட்டின் ஒரு பகுதியாக பல குழந்தை செயல்முறைகள் இருக்கலாம், அது எங்கள் குறியீட்டைப் பொறுத்தது. சந்தா உருவாக்கிய சுற்றுச்சூழல் மாறிகள் முடிந்ததும் கைவிடப்படும் என்பதை கவனத்தில் கொள்ள வேண்டும். ஒரு குழந்தை செயல்முறை பெற்றோர் செயல்முறையால் உருவாக்கப்பட்ட மாறிகளை ஏற்றுமதி செய்வதன் மூலம் அணுகலாம். ஆனால் பெற்றோர் செயல்முறை குழந்தை செயல்முறையால் உருவாக்கப்பட்ட மாறிகளை அணுக முடியாது.

மாறிகள் எவ்வாறு இயங்குகின்றன மற்றும் மாறிகளை எவ்வாறு ஏற்றுமதி செய்வது என்பது பற்றி மேலும் அறிய கீழேயுள்ள கட்டுரைகளைப் பாருங்கள்.

  • ஷெல் ஸ்கிரிப்ட்டில் ‘லினக்ஸ் மாறிகள்’ புரிந்துகொண்டு எழுதுதல்
  • பாஷில் $$மற்றும் AS 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

ஸ்கிரிப்டிற்கான செயல்பாட்டு அனுமதியை அமைத்து, முக்கிய ஸ்கிரிப்டை main "main.sh" என்று அழைக்கவும். இப்போது, இந்த ஸ்கிரிப்ட் f1 மற்றும் மாறக்கூடிய VAR1 செயல்பாட்டைக் கண்டறிய முயற்சிக்கும். ஷெல் சூழல் மற்றும் கட்டளை கிடைக்கவில்லை.

$ bash main.sh

இப்போது ஸ்கிரிப்டுக்குள் மூல கட்டளையை இயக்குவோம், இது தற்போதைய ஷெல் சூழலில் மாறி மற்றும் செயல்பாடுகளை ஏற்றும், மேலும் இது main "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 (உங்களை மீண்டும் செய்ய வேண்டாம்) கொள்கையைப் பின்பற்றலாம்.

இந்த கட்டுரைக்கு அதுதான். பாஷில் ஆதாரம் மற்றும் முட்கரண்டி ஆகியவற்றுக்கு இடையிலான வித்தியாசத்தை நாங்கள் சுருக்கமாக விவாதித்தோம். கட்டுரையின் வழியாக சென்று உங்கள் மதிப்புமிக்க கருத்தை எங்களுடன் பகிர்ந்து கொள்ளுங்கள்.