లైనక్స్uలో సింపుల్ షెల్ స్క్రిప్ట్uలను ఎలా సృష్టించాలి


షెల్ స్క్రిప్ట్uలను సృష్టించడం అనేది లైనక్స్ వినియోగదారులు వారి వేళ్ల కొన వద్ద కలిగి ఉండవలసిన అత్యంత ముఖ్యమైన నైపుణ్యాలలో ఒకటి. పునరావృతమయ్యే పనులను ఆటోమేట్ చేయడంలో షెల్ స్క్రిప్ట్uలు అపారమైన పాత్ర పోషిస్తాయి, లేకపోతే లైన్ ద్వారా లైన్uను అమలు చేయడం శ్రమతో కూడుకున్నది.

ఈ ట్యుటోరియల్uలో, ప్రతి లైనక్స్ యూజర్ కలిగి ఉండవలసిన కొన్ని ప్రాథమిక షెల్ స్క్రిప్టింగ్ ఆపరేషన్లను మేము హైలైట్ చేస్తాము.

1. సింపుల్ షెల్ స్క్రిప్ట్uను సృష్టించండి

షెల్ స్క్రిప్ట్ ASCII వచనాన్ని కలిగి ఉన్న ఫైల్. మేము సరళమైన షెల్ స్క్రిప్ట్uను సృష్టించడం ద్వారా ప్రారంభిస్తాము మరియు దీన్ని చేయడానికి, మేము టెక్స్ట్ ఎడిటర్uని ఉపయోగిస్తాము. విమ్ ఎడిటర్ చాలా ఉన్నాయి.

అమలు చేసినప్పుడు Hello "హలో వరల్డ్" ను ప్రదర్శించే సరళమైన స్క్రిప్ట్uని సృష్టించడం ద్వారా మేము ప్రారంభిస్తాము.

$ vim hello.sh

కింది కంటెంట్uను ఫైల్uలో అతికించి సేవ్ చేయండి.

#!/bin/bash
# Print Hello world message
echo "Hello World!"

షెల్ స్క్రిప్ట్ లైన్ ద్వారా లైన్ ద్వారా వెళ్దాం.

  • మొదటి పంక్తి - #!/Bin/bash - ను షెబాంగ్ హెడర్ అంటారు. స్క్రిప్ట్uను అర్థం చేసుకోవడానికి ఏ ప్రోగ్రామ్ ఉపయోగించబడుతుందో సూచించే ప్రత్యేక నిర్మాణం ఇది. ఈ సందర్భంలో, ఇది/బిన్/బాష్ సూచించిన బాష్ షెల్ అవుతుంది. పైథాన్ వంటి ఇతర స్క్రిప్టింగ్ భాషలు ఉన్నాయి, వీటిని <కోడ్> #! >.
  • రెండవ పంక్తి వ్యాఖ్య. వ్యాఖ్య అనేది షెల్ స్క్రిప్ట్ ఏమి చేస్తుందో వివరించే ఒక ప్రకటన మరియు స్క్రిప్ట్ రన్ అయినప్పుడు అమలు చేయబడదు. వ్యాఖ్యలు ఎల్లప్పుడూ # అనే హాష్ గుర్తుతో ముందు ఉంటాయి.
  • చివరి పంక్తి టెర్మినల్uలో ‘హలో వరల్డ్’ సందేశాన్ని ముద్రించే ఆదేశం.

చూపిన విధంగా chmod కమాండ్ ఉపయోగించి ఎగ్జిక్యూట్ పర్మిషన్ కేటాయించడం ద్వారా స్క్రిప్ట్ ఎగ్జిక్యూటబుల్ చేయడమే తదుపరి దశ.

$ chmod +x  hello.sh

చివరగా, కమాండ్లలో దేనినైనా ఉపయోగించి షెల్ స్క్రిప్ట్uను అమలు చేయండి:

$ bash hello.sh
OR
$ ./hello.sh

2. కోడ్uను అమలు చేయడానికి షరతులతో కూడిన స్టేట్uమెంట్uలను ఉపయోగించడం

ఇతర ప్రోగ్రామింగ్ భాషల మాదిరిగానే, షరతులతో కూడిన స్టేట్uమెంట్uలు నిర్ణయాలు తీసుకోవడానికి బాష్ స్క్రిప్టింగ్uలో ఉపయోగించబడతాయి, వాక్యనిర్మాణంలో స్వల్ప వ్యత్యాసం మాత్రమే ఉంటుంది. మేము if, if-else, మరియు elif షరతులతో కూడిన ప్రకటనలను కవర్ చేయబోతున్నాము.

సింగిల్ లేదా బహుళ షరతులను పరీక్షించడానికి if స్టేట్మెంట్ ఉపయోగించవచ్చు. ఒకే షరతును పరీక్షించడానికి if స్టేట్మెంట్ యొక్క ప్రాథమిక వాడకంతో మేము ప్రారంభిస్తాము. If స్టేట్మెంట్ if ... fi బ్లాక్స్ ద్వారా నిర్వచించబడుతుంది.

if command
then
  statement
fi

దిగువ షెల్ లిపిని పరిశీలిద్దాం.

#!/bin/bash
echo 'Enter the score'
read x

if [[ $x == 70 ]]; then
  echo 'Good job!'
fi

పై షెల్ స్క్రిప్ట్ వినియోగదారుని వేరియబుల్ x లో నిల్వ చేసిన స్కోర్uను అందించమని అడుగుతుంది. స్కోరు 70 కి అనుగుణంగా ఉంటే, స్క్రిప్ట్ output "మంచి పని!" అవుట్పుట్ను తిరిగి ఇస్తుంది. పోలిక ఆపరేటర్ == వేరియబుల్ x లో నిల్వ చేయబడిన స్కోరు నమోదు చేయబడిందా అని పరీక్షించడానికి ఉపయోగిస్తారు. 100 నుండి.

మీరు ఉపయోగించగల ఇతర పోలిక ఆపరేటర్లు:

  • -eq - కు సమానం
  • -ne - కు సమానం కాదు
  • -lt -
  • కన్నా తక్కువ
  • -le -
  • కంటే తక్కువ లేదా సమానం
  • -lt -
  • కన్నా తక్కువ
  • -ge -
  • కంటే గొప్పది లేదా సమానం

ఉదాహరణకు, ఇన్పుట్ స్కోరు 50 కంటే తక్కువ విలువ ఉంటే దిగువ ఇఫ్-స్టేట్మెంట్ బ్లాక్ ‘వర్క్ హార్డ్’ ను ప్రింట్ చేస్తుంది.

if [[ $x -lt 50 ]]; then
  echo 'Work Harder!'
fi

మీకు 2 సాధ్యమైన ఫలితాలను కలిగి ఉన్న పరిస్థితుల కోసం: - ఇది లేదా అది - if-else స్టేట్మెంట్ ఉపయోగపడుతుంది.

if command
then
  statement1
else
  statement2
fi

దిగువ స్క్రిప్ట్ ఇన్uపుట్ స్కోర్uను చదువుతుంది మరియు ఇది 70 కంటే ఎక్కువ లేదా సమానంగా ఉందో లేదో తనిఖీ చేస్తుంది.

స్కోరు 70 కంటే ఎక్కువ లేదా సమానంగా ఉంటే, మీకు ‘గొప్ప ఉద్యోగం, మీరు ఉత్తీర్ణులయ్యారు!’ సందేశం వస్తుంది. అయితే, స్కోరు 70 కంటే తక్కువగా ఉంటే, అవుట్పుట్ ‘మీరు విఫలమయ్యారు’ ముద్రించబడుతుంది.

#!/bin/bash

echo 'Enter the score'

read x

if [[ $x -ge 70 ]]; then
  echo 'Great job, You passed!'
else
  echo  'You failed'
fi

బహుళ పరిస్థితులు మరియు విభిన్న ఫలితాలు ఉన్న పరిస్థితులలో, if-elif-else స్టేట్మెంట్ ఉపయోగించబడుతుంది. ఈ ప్రకటన క్రింది ఆకృతిని తీసుకుంటుంది.

if condition1
then
  statement1
elif condition2
then
  statement2
else
  statement3
fi

ఉదాహరణకు, లాటరీ కోసం మనకు స్క్రిప్ట్ ఉంది, అది నమోదు చేసిన సంఖ్య 90, 60 లేదా 30 గా ఉందో లేదో తనిఖీ చేస్తుంది.

#!/bin/bash

echo 'Enter the score'

read x

if [[ $x -eq 90 ]];
then
  echo “You have won the First Prize”

elif [[ $x -eq 60 ]];
then
  echo “You have won the Second Prize”

elif [[ $x -eq 30 ]];
then 
  echo “You have won the Second Prize”
else
  echo “Please try again”
fi

3. AND లాజిక్uతో If స్టేట్uమెంట్ ఉపయోగించడం

రెండు షరతులు సంతృప్తి చెందితే ఒక పనిని అమలు చేయడానికి మీరు AND లాజిక్ ఆపరేటర్uతో పాటు if స్టేట్uమెంట్uను ఉపయోగించవచ్చు. && ఆపరేటర్ AND తర్కాన్ని సూచించడానికి ఉపయోగించబడుతుంది.

#!/bin/bash

echo 'Please Enter your user_id'
read user_id

echo 'Please Enter your tag_no'
read tag_id

if [[ ($user_id == “tecmint” && $tag_id -eq 3990) ]];
then
  echo “Login successful”
else
  echo “Login failure”
fi

5. లేదా లాజిక్uతో ఇఫ్ స్టేట్uమెంట్ ఉపయోగించడం

OR తర్కాన్ని ఉపయోగిస్తున్నప్పుడు, అది || గుర్తు ద్వారా ప్రాతినిధ్యం వహిస్తుంది, conditions హించిన ఫలితాలను ఇవ్వడానికి షరతులలో ఒకటి స్క్రిప్ట్uతో సంతృప్తి చెందాలి.

#!/bin/bash

echo 'Please enter a random number'
read number

if [[ (number -eq 55 || number -eq 80) ]];
then
 echo 'Congratulations! You’ve won'
else
 echo 'Sorry, try again'
fi

లూపింగ్ నిర్మాణాలను ఉపయోగించండి

ఒక నిర్దిష్ట ఫలితం సాధించే వరకు బాష్ లూప్uలు వినియోగదారులను వరుస పనులను చేయడానికి అనుమతిస్తాయి. పునరావృతమయ్యే పనులను చేయడంలో ఇది ఉపయోగపడుతుంది. ఈ విభాగంలో, ఇతర ప్రోగ్రామింగ్ భాషలలో కూడా మీరు కనుగొనే కొన్ని ఉచ్చులను చూద్దాం.

ఇది పని చేయడానికి సులభమైన ఉచ్చులలో ఒకటి. వాక్యనిర్మాణం చాలా సులభం:

while  <some test>
do
 commands
done

దిగువ ఉన్న లూప్ అమలు చేసినప్పుడు 1 నుండి 10 వరకు ఉన్న అన్ని సంఖ్యలను జాబితా చేస్తుంది.

#!/bin/bash
# A simple while loop
counter=1
while [ $counter -le 10 ]
 do
echo $counter
 ((counter++))
done

అయితే లూప్ గురించి చర్చించండి:

వేరియబుల్ కౌంటర్ 1 కి ప్రారంభించబడింది. మరియు వేరియబుల్ 10 కన్నా తక్కువ లేదా సమానంగా ఉన్నప్పుడు, షరతు సంతృప్తి చెందే వరకు కౌంటర్ విలువ పెరుగుతుంది. లైన్ ఎకో $కౌంటర్ 1 నుండి 10 వరకు ఉన్న అన్ని సంఖ్యలను ప్రింట్ చేస్తుంది.

టైమ్ లూప్ మాదిరిగా, కోడ్uను పునరావృతంగా అమలు చేయడానికి ఒక ఫర్ లూప్ ఉపయోగించబడుతుంది. అనగా. వినియోగదారు నిర్వచించిన సాధ్యమైనంత ఎక్కువ సార్లు కోడ్ అమలును పునరావృతం చేయండి.

వాక్యనిర్మాణం:

for var in 1 2 3 4 5 N
do
 command1
 command2
done

దిగువ ఉన్న లూప్ 1 నుండి 10 వరకు మళ్ళిస్తుంది మరియు వాటి విలువలను తెరపై ప్రాసెస్ చేస్తుంది.

దీన్ని సాధించడానికి మంచి మార్గం ఏమిటంటే, అన్ని సంఖ్యలను టైప్ చేయడానికి బదులుగా చూపిన విధంగా డబుల్ కర్లీ కలుపులను {} ఉపయోగించి శ్రేణిని నిర్వచించడం.

#!/bin/bash
# Specify range in a for loop

for num in {1..10}
do
  echo $num
done

బాష్ స్థాన పారామితులు

స్థాన పరామితి అనేది ఒక ప్రత్యేక వేరియబుల్, ఇది షెల్uపై విలువలు దాటినప్పుడు స్క్రిప్ట్uలో సూచించబడుతుంది కాని కేటాయించబడదు. స్థాన పారామితులు $0 $1 $2 $3 …… నుండి $9 వరకు నడుస్తాయి. $9 విలువకు మించి, పారామితులను వంకర బ్రాకెట్లలో జతచేయాలి ఉదా. & # 36 {10}, & # 36 {11}… మరియు మొదలైనవి.

స్క్రిప్ట్uను అమలు చేసేటప్పుడు, position 0 అయిన మొదటి స్థాన పరామితి షెల్ స్క్రిప్ట్ పేరును తీసుకుంటుంది. $1 పారామితి టెర్మినల్uపై పంపబడిన మొదటి వేరియబుల్uను తీసుకుంటుంది, $2 రెండవది, $3 మూడవది మరియు మొదలైనవి.

చూపిన విధంగా స్క్రిప్ట్ test.sh ను సృష్టిద్దాం.

#!/bin/bash
echo "The name of the script is: " $0
echo "My first name is: " $1
echo "My second name is: " $2

తరువాత, స్క్రిప్ట్uను అమలు చేయండి మరియు మొదటి మరియు రెండవ పేరును వాదనలుగా అందించండి:

# bash test.sh James Kiarie

అవుట్పుట్ నుండి, ముద్రించిన మొదటి వేరియబుల్ షెల్ స్క్రిప్ట్ పేరు అని మనం చూడవచ్చు, ఈ సందర్భంలో, test.sh. ఆ తరువాత, షెల్ లిపిలో నిర్వచించిన స్థాన పారామితులకు అనుగుణంగా పేర్లు ముద్రించబడతాయి.

వేరియబుల్uకు విలువను స్పష్టంగా కేటాయించటానికి బదులుగా ఎంటర్ చేసిన డేటాను అనుకూలీకరించడానికి అవి మీకు సహాయపడటానికి స్థాన పారామితులు ఉపయోగపడతాయి.

షెల్ కమాండ్ నిష్క్రమణ సంకేతాలు

నిష్క్రమణ కోడ్ అంటే ఏమిటి అనే సాధారణ ప్రశ్నకు సమాధానం ఇవ్వడం ద్వారా ప్రారంభిద్దాం.

వినియోగదారు లేదా షెల్ స్క్రిప్ట్ చేత షెల్ మీద అమలు చేయబడిన ప్రతి ఆదేశానికి నిష్క్రమణ స్థితి ఉంటుంది. నిష్క్రమణ స్థితి పూర్ణాంకం.

0 యొక్క నిష్క్రమణ స్థితి కమాండ్ ఎటువంటి లోపాలు లేకుండా విజయవంతంగా అమలు చేయబడిందని సూచిస్తుంది. 1 నుండి 255 మధ్య ఏదైనా ఆదేశం విఫలమైందని లేదా విజయవంతంగా అమలు చేయలేదని చూపిస్తుంది.

కమాండ్ యొక్క నిష్క్రమణ స్థితిని కనుగొనడానికి, $? షెల్ వేరియబుల్ ఉపయోగించండి.

1 పాయింట్ల నిష్క్రమణ స్థితి సాధారణ లోపం లేదా సుడో అనుమతులు లేకుండా ఫైళ్ళను సవరించడం వంటి అనుమతించలేని లోపాలు.

కమాండ్ లేదా బిల్టిన్ షెల్ వేరియబుల్ యొక్క తప్పు వాడకానికి 2 పాయింట్ల నిష్క్రమణ స్థితి.

127 నిష్క్రమణ స్థితి చట్టవిరుద్ధమైన ఆదేశాన్ని సూచిస్తుంది, ఇది సాధారణంగా ‘ఆదేశం కనుగొనబడలేదు’ లోపాన్ని ఇస్తుంది.

స్క్రిప్ట్uలోని షెల్ ఆదేశాల ప్రాసెస్ అవుట్uపుట్

బాష్ స్క్రిప్టింగ్uలో, మీరు కమాండ్ యొక్క అవుట్uపుట్uను భవిష్యత్ ఉపయోగం కోసం వేరియబుల్uలో నిల్వ చేయవచ్చు. దీనిని షెల్ కమాండ్ ప్రత్యామ్నాయం అని కూడా పిలుస్తారు మరియు ఈ క్రింది మార్గాల్లో సాధించవచ్చు.

variable=$(command)
OR
variable=$(/path/to/command)
OR
variable=$(command argument 1 argument 2 ...)

ఉదాహరణకు, మీరు ఈ రోజు అనే వేరియబుల్uలో తేదీ ఆదేశాన్ని నిల్వ చేయవచ్చు మరియు ప్రస్తుత తేదీని వెల్లడించడానికి షెల్ స్క్రిప్ట్uకు కాల్ చేయవచ్చు.

#!/bin/bash

today=$(date)

echo “Today is $today”

మరొక ఉదాహరణ తీసుకుందాం. మీరు మీ Linux సిస్టమ్uలో చెల్లుబాటు అయ్యే లాగిన్ వినియోగదారులను కనుగొనాలనుకుందాం. మీరు దాని గురించి ఎలా వెళ్తారు? మొదట, అన్ని వినియోగదారుల జాబితా (సిస్టమ్, ప్రాసెస్ మరియు లాగిన్ యూజర్లు రెండూ)/etc/passwd ఫైల్uలో నిల్వ చేయబడతాయి.

ఫైల్uను వీక్షించడానికి, మీరు/బిన్/బాష్ లక్షణంతో వినియోగదారుల కోసం శోధించడానికి grep ఆదేశాన్ని ఉపయోగించాలి మరియు పేర్ల యొక్క మొదటి 10 అక్షరాలను ప్రదర్శించడానికి చూపిన విధంగా కట్-సి 1-10 ఆదేశాన్ని ఉపయోగించాలి.

మేము పిల్లి ఆదేశాన్ని login_users వేరియబుల్uకు నిల్వ చేసాము.

#!/bin/bash
login_users=$(cat /etc/passwd | grep /bin/bash | cut -c 1-10)
echo 'This is the list of login users:
echo $login_users

ఇది సాధారణ షెల్ స్క్రిప్ట్uలను సృష్టించే మా ట్యుటోరియల్uను ముగింపుకు తెస్తుంది. మీరు ఈ విలువైనదాన్ని కనుగొన్నారని మేము ఆశిస్తున్నాము.