ఈ రోజు మనం బాష్ స్క్రిప్ట్‌ల గురించి మాట్లాడుతాము. ఈ - , బాష్ షెల్ కోసం వ్రాయబడింది. zsh, tcsh, ksh వంటి ఇతర షెల్‌లు ఉన్నాయి, అయితే మేము బాష్‌పై దృష్టి పెడతాము. ఈ పదార్థం ప్రతి ఒక్కరికీ ఉద్దేశించబడింది, పని చేసే సామర్థ్యం మాత్రమే షరతు Linux.
కమాండ్ లైన్ స్క్రిప్ట్‌లు అదే ఆదేశాల సేకరణలు, వీటిని కీబోర్డ్ నుండి నమోదు చేయవచ్చు, ఫైల్‌లలోకి సేకరించవచ్చు మరియు కొన్ని సాధారణ ప్రయోజనంతో ఏకం చేయవచ్చు. ఈ సందర్భంలో, బృందాల పని ఫలితాలు స్వతంత్ర విలువను కలిగి ఉండవచ్చు లేదా ఇతర జట్లకు ఇన్‌పుట్ డేటాగా ఉపయోగపడతాయి. తరచుగా చేసే చర్యలను ఆటోమేట్ చేయడానికి స్క్రిప్ట్‌లు శక్తివంతమైన మార్గం.
కాబట్టి, మేము కమాండ్ లైన్ గురించి మాట్లాడినట్లయితే, సెమికోలన్ ద్వారా వేరు చేయబడిన వాటిని నమోదు చేయడం ద్వారా ఒకేసారి అనేక ఆదేశాలను అమలు చేయడానికి ఇది మిమ్మల్ని అనుమతిస్తుంది:
pwd ; whoami
వాస్తవానికి, మీరు దీన్ని మీ టెర్మినల్‌లో ప్రయత్నించినట్లయితే, రెండు ఆదేశాలతో కూడిన మీ మొదటి బాష్ స్క్రిప్ట్ ఇప్పటికే వ్రాయబడింది. ఇది ఇలా పనిచేస్తుంది. ముందుగా జట్టు pwd ప్రస్తుత పని డైరెక్టరీ గురించి సమాచారాన్ని ప్రదర్శిస్తుంది, ఆపై కమాండ్ whoamiమీరు లాగిన్ చేసిన వినియోగదారు గురించి సమాచారాన్ని చూపుతుంది.
ఈ విధానాన్ని ఉపయోగించి, మీరు ఒక లైన్‌లో మీకు నచ్చినన్ని ఆదేశాలను మిళితం చేయవచ్చు, ప్రోగ్రామ్‌కు పంపగల గరిష్ట ఆర్గ్యుమెంట్‌ల సంఖ్య మాత్రమే పరిమితి. కింది ఆదేశాన్ని ఉపయోగించి మీరు ఈ పరిమితిని నిర్వచించవచ్చు:
getconf ARG_MAXకమాండ్ లైన్ ఒక గొప్ప సాధనం, కానీ మీకు అవసరమైన ప్రతిసారీ మీరు ఆదేశాలను నమోదు చేయాలి. మనం ఒక ఫైల్‌లో కమాండ్‌ల సెట్‌ను వ్రాసి, వాటిని అమలు చేయడానికి ఆ ఫైల్‌ని పిలిచినట్లయితే? నిజానికి, మనం మాట్లాడుతున్న ఫైల్‌ని కమాండ్ లైన్ స్క్రిప్ట్ అంటారు.
బాష్ స్క్రిప్ట్‌లు ఎలా పని చేస్తాయి
ఆదేశాన్ని ఉపయోగించి ఖాళీ ఫైల్‌ను సృష్టించండి touch. దాని మొదటి లైన్ మనం ఏ షెల్ ఉపయోగించబోతున్నామో సూచించాలి. మాకు ఆసక్తి ఉంది bash, కాబట్టి ఫైల్ యొక్క మొదటి పంక్తి ఇలా ఉంటుంది:
#!/bin/bash
షెల్ ప్రాసెస్ చేయని వ్యాఖ్యలను సూచించడానికి ఈ ఫైల్‌లోని ఇతర పంక్తులు హాష్ చిహ్నాన్ని ఉపయోగిస్తాయి. అయితే, మొదటి పంక్తి ప్రత్యేక సందర్భం, హాష్ తర్వాత ఆశ్చర్యార్థకం గుర్తు ఉంటుంది (ఈ క్రమాన్ని అంటారు ) మరియు మార్గం bash, స్క్రిప్ట్ ప్రత్యేకంగా సృష్టించబడిన సిస్టమ్‌కు సూచించండి bash.
షెల్ ఆదేశాలు లైన్ ఫీడ్ ద్వారా వేరు చేయబడతాయి, వ్యాఖ్యలు హాష్ గుర్తుతో వేరు చేయబడతాయి. ఇది ఇలా కనిపిస్తుంది:
#!/bin/bash
# This is a comment
pwd
whoamiఇక్కడ, కమాండ్ లైన్‌లో వలె, మీరు సెమికోలన్‌లతో వేరు చేయబడిన ఒక లైన్‌లో ఆదేశాలను వ్రాయవచ్చు. అయితే, మీరు వేర్వేరు లైన్లలో ఆదేశాలను వ్రాస్తే, ఫైల్ చదవడం సులభం. ఏదైనా సందర్భంలో, షెల్ వాటిని ప్రాసెస్ చేస్తుంది.
స్క్రిప్ట్ ఫైల్ అనుమతులను సెట్ చేస్తోంది
ఫైల్‌కి పేరు పెట్టి సేవ్ చేయండి myscript, మరియు బాష్ స్క్రిప్ట్‌ని రూపొందించే పని దాదాపు పూర్తయింది. ఇప్పుడు మిగిలి ఉన్నది ఈ ఫైల్‌ని ఎక్జిక్యూటబుల్ చేయడమే, లేకపోతే, మీరు దీన్ని అమలు చేయడానికి ప్రయత్నిస్తే, మీరు లోపాన్ని ఎదుర్కొంటారు. Permission denied.
తప్పుగా కాన్ఫిగర్ చేయబడిన అనుమతులతో స్క్రిప్ట్ ఫైల్‌ను అమలు చేయడానికి ప్రయత్నిస్తోంది
ఫైల్‌ని ఎక్జిక్యూటబుల్‌గా చేద్దాం:
chmod +x ./myscriptఇప్పుడు దీన్ని అమలు చేయడానికి ప్రయత్నిద్దాం:
./myscriptఅనుమతులను సెట్ చేసిన తర్వాత ప్రతిదీ తప్పక పని చేస్తుంది.
బాష్ స్క్రిప్ట్ విజయవంతంగా అమలవుతోంది
సందేశం అవుట్పుట్
Linux కన్సోల్‌కు వచనాన్ని అవుట్పుట్ చేయడానికి, ఆదేశాన్ని ఉపయోగించండి echo. ఈ వాస్తవం యొక్క పరిజ్ఞానాన్ని ఉపయోగించుకుందాం మరియు మా స్క్రిప్ట్‌ను సవరించండి, దానిలో ఇప్పటికే ఉన్న ఆదేశాల ద్వారా అవుట్పుట్ చేయబడిన డేటాకు వివరణలను జోడించి:
#!/bin/bash
# our comment is here
echo "The current directory is:"
pwd
echo "The user logged in is:"
whoamiనవీకరించబడిన స్క్రిప్ట్‌ను అమలు చేసిన తర్వాత ఇది జరుగుతుంది.
స్క్రిప్ట్ నుండి సందేశాలను అవుట్పుట్ చేయడం
ఇప్పుడు మనం ఆదేశాన్ని ఉపయోగించి వివరణాత్మక గమనికలను ప్రదర్శించవచ్చు echo. Linux సాధనాలను ఉపయోగించి ఫైల్‌ను ఎలా సవరించాలో మీకు తెలియకపోతే లేదా మీరు ఇంతకు ముందు ఆదేశాన్ని చూడకపోతే echo, ఒక్కసారి దీనిని చూడు stuff.
వేరియబుల్స్ ఉపయోగించడం
ఇతర కమాండ్‌ల ద్వారా ఉపయోగం కోసం ఆదేశాల ఫలితాలు వంటి సమాచారాన్ని స్క్రిప్ట్ ఫైల్‌లో నిల్వ చేయడానికి వేరియబుల్స్ మిమ్మల్ని అనుమతిస్తాయి.
వాటి ఫలితాలను నిల్వ చేయకుండా వ్యక్తిగత ఆదేశాలను అమలు చేయడంలో తప్పు ఏమీ లేదు, కానీ ఈ విధానం దాని సామర్థ్యాలలో చాలా పరిమితంగా ఉంటుంది.
బాష్ స్క్రిప్ట్‌లలో రెండు రకాల వేరియబుల్స్ ఉపయోగించబడతాయి:
- ఎన్విరాన్మెంట్ వేరియబుల్స్
- వినియోగదారు వేరియబుల్స్
ఎన్విరాన్మెంట్ వేరియబుల్స్
కొన్నిసార్లు షెల్ ఆదేశాలు కొన్ని సిస్టమ్ డేటాతో పని చేయాల్సి ఉంటుంది. ప్రస్తుత వినియోగదారు హోమ్ డైరెక్టరీని ఎలా ప్రదర్శించాలో ఇక్కడ ఒక ఉదాహరణ ఉంది:
#!/bin/bash
# display user home
echo "Home for the current user is: $HOME"
దయచేసి మనం సిస్టమ్ వేరియబుల్‌ని ఉపయోగించవచ్చని గమనించండి $HOME డబుల్ కోట్‌లలో, ఇది సిస్టమ్‌ను గుర్తించకుండా నిరోధించదు. మీరు పై దృష్టాంతాన్ని అమలు చేస్తే ఇది మీకు లభిస్తుంది.
స్క్రిప్ట్‌లో ఎన్విరాన్మెంట్ వేరియబుల్‌ని ఉపయోగించడం
మీరు స్క్రీన్‌పై డాలర్ గుర్తును ప్రదర్శించాల్సిన అవసరం ఉంటే? దీన్ని ప్రయత్నిద్దాం:
echo "I have $1 in my pocket"
సిస్టమ్ కోట్ చేయబడిన స్ట్రింగ్‌లో డాలర్ చిహ్నాన్ని గుర్తిస్తుంది మరియు మేము వేరియబుల్‌ను సూచించినట్లు ఊహిస్తుంది. స్క్రిప్ట్ నిర్వచించబడని వేరియబుల్ విలువను ప్రదర్శించడానికి ప్రయత్నిస్తుంది $1. ఇది మనకు అవసరం లేదు. ఏం చేయాలి?
ఈ పరిస్థితిలో, డాలర్ గుర్తుకు ముందు ఎస్కేప్ క్యారెక్టర్, బ్యాక్‌స్లాష్ ఉపయోగించడం సహాయపడుతుంది:
echo "I have $1 in my pocket"స్క్రిప్ట్ ఇప్పుడు ఆశించిన దానినే అవుట్పుట్ చేస్తుంది.
డాలర్ చిహ్నాన్ని ప్రింట్ చేయడానికి ఎస్కేప్ సీక్వెన్స్‌ని ఉపయోగించడం
వినియోగదారు వేరియబుల్స్
ఎన్విరాన్మెంట్ వేరియబుల్స్‌తో పాటు, బాష్ స్క్రిప్ట్‌లు స్క్రిప్ట్‌లో మీ స్వంత వేరియబుల్స్‌ని నిర్వచించడానికి మరియు ఉపయోగించడానికి మిమ్మల్ని అనుమతిస్తాయి. స్క్రిప్ట్ ఎగ్జిక్యూషన్ పూర్తయ్యే వరకు ఇటువంటి వేరియబుల్స్ విలువను కలిగి ఉంటాయి.
సిస్టమ్ వేరియబుల్స్ మాదిరిగా, వినియోగదారు వేరియబుల్స్ డాలర్ గుర్తును ఉపయోగించి యాక్సెస్ చేయవచ్చు:
TNW-CUS-FMP - మా సేవలపై 10% తగ్గింపు కోసం ప్రోమో కోడ్, 7 రోజుల్లో యాక్టివేషన్ కోసం అందుబాటులో ఉంటుంది
#!/bin/bash
# testing variables
grade=5
person="Adam"
echo "$person is a good boy, he is in grade $grade"అటువంటి స్క్రిప్ట్‌ని అమలు చేసిన తర్వాత ఇది జరుగుతుంది.
స్క్రిప్ట్‌లోని కస్టమ్ వేరియబుల్స్
కమాండ్ ప్రత్యామ్నాయం
బాష్ స్క్రిప్ట్‌ల యొక్క అత్యంత ఉపయోగకరమైన లక్షణాలలో ఒకటి కమాండ్ అవుట్పుట్ నుండి సమాచారాన్ని సంగ్రహించడం మరియు దానిని వేరియబుల్స్‌కు కేటాయించడం, ఈ సమాచారాన్ని స్క్రిప్ట్ ఫైల్‌లో ఎక్కడైనా ఉపయోగించడానికి మిమ్మల్ని అనుమతిస్తుంది.
దీన్ని చేయడానికి రెండు మార్గాలు ఉన్నాయి.
- బ్యాక్‌టిక్ "`"ని ఉపయోగించడం
- డిజైన్ ద్వారా
$()
మొదటి విధానాన్ని ఉపయోగిస్తున్నప్పుడు, బ్యాక్‌టిక్ స్థానంలో ఒక్క కొటేషన్ గుర్తును చేర్చకుండా జాగ్రత్త వహించండి. ఆదేశం అటువంటి రెండు చిహ్నాలలో తప్పనిసరిగా జతచేయబడాలి:
mydir=`pwd`రెండవ విధానంలో, అదే విషయం ఇలా వ్రాయబడింది:
mydir=$(pwd)మరియు స్క్రిప్ట్ ఇలా కనిపించవచ్చు:
#!/bin/bash
mydir=$(pwd)
echo $mydir
దాని ఆపరేషన్ సమయంలో, కమాండ్ యొక్క అవుట్పుట్ pwdవేరియబుల్‌లో సేవ్ చేయబడుతుంది mydir, కమాండ్ ఉపయోగించి దీనిలోని విషయాలు echo, కన్సోల్‌కి వెళ్తుంది.
కమాండ్ ఫలితాలను వేరియబుల్‌లో సేవ్ చేసే స్క్రిప్ట్
గణిత కార్యకలాపాలు
స్క్రిప్ట్ ఫైల్‌లో గణిత కార్యకలాపాలను నిర్వహించడానికి, మీరు వంటి నిర్మాణాన్ని ఉపయోగించవచ్చు $((a+b)):
#!/bin/bash
var1=$(( 5 + 5 ))
echo $var1
var2=$(( $var1 * 2 ))
echo $var2
స్క్రిప్ట్‌లో గణిత కార్యకలాపాలు
ఉంటే-అప్పుడు నియంత్రణ నిర్మాణం
కొన్ని సందర్భాల్లో, మీరు కమాండ్ ఎగ్జిక్యూషన్ ప్రవాహాన్ని నియంత్రించాలి. ఉదాహరణకు, ఒక నిర్దిష్ట విలువ ఐదు కంటే ఎక్కువగా ఉంటే, మీరు ఒక చర్యను చేయవలసి ఉంటుంది, లేకపోతే మరొకటి. ఇది చాలా సందర్భాలలో వర్తిస్తుంది మరియు ఇక్కడ నియంత్రణ నిర్మాణం మాకు సహాయం చేస్తుంది if-then. దాని సరళమైన రూపంలో ఇది ఇలా కనిపిస్తుంది:
if команда
then
команды
fiఇక్కడ ఒక పని ఉదాహరణ:
#!/bin/bash
if pwd
then
echo "It works"
fi
ఈ సందర్భంలో, ఆదేశం అమలు చేయబడితే pwdవిజయవంతంగా పూర్తవుతుంది, "ఇది పని చేస్తుంది" అనే వచనం కన్సోల్‌లో ప్రదర్శించబడుతుంది.
మనకున్న జ్ఞానాన్ని ఉపయోగించుకుని మరింత సంక్లిష్టమైన స్క్రిప్ట్‌ను రాసుకుందాం. మనం నిర్దిష్ట వినియోగదారుని కనుగొనవలసి ఉందని అనుకుందాం /etc/passwd, మరియు మీరు దానిని కనుగొనగలిగితే, అది ఉనికిలో ఉందని నివేదించండి.
#!/bin/bash
user=likegeeks
if grep $user /etc/passwd
then
echo "The user $user Exists"
fiఈ స్క్రిప్ట్‌ని అమలు చేసిన తర్వాత ఇది జరుగుతుంది.
వినియోగదారు శోధన
ఇక్కడ మేము ఆదేశాన్ని ఉపయోగించాము grepఫైల్‌లో వినియోగదారుని శోధించడానికి /etc/passwd. జట్టు అయితే grepమీకు తెలియనిది, దాని వివరణను కనుగొనవచ్చు .
ఈ ఉదాహరణలో, వినియోగదారు కనుగొనబడితే, స్క్రిప్ట్ సంబంధిత సందేశాన్ని ప్రదర్శిస్తుంది. వినియోగదారు కనుగొనబడకపోతే ఏమి చేయాలి? ఈ సందర్భంలో, స్క్రిప్ట్ మాకు ఏమీ చెప్పకుండా కేవలం అమలును పూర్తి చేస్తుంది. అతను దీని గురించి కూడా మాకు చెప్పాలని మేము కోరుకుంటున్నాము, కాబట్టి మేము కోడ్‌ను మెరుగుపరుస్తాము.
if-then-else నియంత్రణ నిర్మాణం
ప్రోగ్రామ్ విజయవంతమైన శోధన మరియు వైఫల్యం రెండింటి ఫలితాలను నివేదించగలిగేలా చేయడానికి, మేము నిర్మాణాన్ని ఉపయోగిస్తాము if-then-else. ఇది ఎలా పని చేస్తుందో ఇక్కడ ఉంది:
if команда
then
команды
else
команды
fi
మొదటి కమాండ్ సున్నాని అందించినట్లయితే, అది విజయవంతంగా అమలు చేయబడిందని అర్థం, షరతు నిజం మరియు అమలు శాఖలో కొనసాగదు else. లేకపోతే, సున్నా కాకుండా వేరే ఏదైనా తిరిగి వచ్చినట్లయితే, అది వైఫల్యాన్ని సూచిస్తుంది లేదా తప్పుడు ఫలితాన్ని సూచిస్తుంది, తర్వాత ఆదేశాలు else.
కింది స్క్రిప్ట్‌ని వ్రాస్దాం:
#!/bin/bash
user=anotherUser
if grep $user /etc/passwd
then
echo "The user $user Exists"
else
echo "The user $user doesn’t exist"
fi
అతని ఉరి కాలువలో పడింది else.
if-then-else నిర్మాణంతో స్క్రిప్ట్‌ను అమలు చేస్తోంది
సరే, మరింత క్లిష్టమైన పరిస్థితుల గురించి మనల్ని మనం ప్రశ్నించుకుందాం. మీరు ఒక షరతును కాదు, అనేక షరతులను తనిఖీ చేయవలసి వస్తే ఏమి చేయాలి? ఉదాహరణకు, కావలసిన వినియోగదారు కనుగొనబడితే, ఒక సందేశం ప్రదర్శించబడాలి, కొన్ని ఇతర షరతులు నెరవేరినట్లయితే, మరొక సందేశం ప్రదర్శించబడాలి మరియు మొదలైనవి. అటువంటి పరిస్థితిలో, సమూహ పరిస్థితులు మాకు సహాయపడతాయి. ఇది ఇలా కనిపిస్తుంది:
if команда1
then
команды
elif команда2
then
команды
fi
మొదటి ఆదేశం దాని విజయవంతమైన అమలును సూచించే సున్నాని తిరిగి ఇస్తే, మొదటి బ్లాక్‌లోని ఆదేశాలు అమలు చేయబడతాయి then, లేకుంటే, మొదటి షరతు తప్పు అయితే మరియు రెండవ కమాండ్ సున్నాని తిరిగి ఇస్తే, రెండవ బ్లాక్ కోడ్ అమలు చేయబడుతుంది.
#!/bin/bash
user=anotherUser
if grep $user /etc/passwd
then
echo "The user $user Exists"
elif ls /home
then
echo "The user doesn’t exist but anyway there is a directory under /home"
fi
అటువంటి స్క్రిప్ట్‌లో, మీరు ఉదాహరణకు, ఆదేశాన్ని ఉపయోగించి కొత్త వినియోగదారుని సృష్టించవచ్చు useradd, శోధన ఫలితాలను ఇవ్వకుంటే, లేదా ఏదైనా ఉపయోగకరంగా ఉంటే.
సంఖ్యల పోలిక
స్క్రిప్ట్‌లలో మీరు సంఖ్యా విలువలను సరిపోల్చవచ్చు. సంబంధిత ఆదేశాల జాబితా క్రింద ఉంది.
n1 -eq n2ఒకవేళ నిజమని చూపుతుందిn1అంతేn2.
n1 -ge n2ఒకవేళ నిజమని చూపుతుందిn1ఎక్కువ లేదా సమానంగాn2.
n1 -gt n2ఒకవేళ నిజమని చూపుతుందిn1కంటే ఎక్కువn2.
n1 -le n2ఒకవేళ నిజమని చూపుతుందిn1తక్కువ లేదా సమానంn2.
n1 -lt n2n1 కంటే తక్కువ ఉంటే నిజం చూపుతుందిn2.
n1 -ne n2ఒకవేళ నిజమని చూపుతుందిn1సమానం కాదుn2.
ఉదాహరణగా, పోలిక ఆపరేటర్లలో ఒకదానిని ప్రయత్నిద్దాం. వ్యక్తీకరణ చతురస్రాకార బ్రాకెట్లలో జతచేయబడిందని గమనించండి.
#!/bin/bash
val1=6
if [ $val1 -gt 5 ]
then
echo "The test value $val1 is greater than 5"
else
echo "The test value $val1 is not greater than 5"
fiఇది ఈ కమాండ్ అవుట్పుట్ చేస్తుంది.
స్క్రిప్ట్‌లలోని సంఖ్యల పోలిక
వేరియబుల్ విలువ val15 కంటే ఎక్కువ, శాఖ అమలులో ముగుస్తుంది thenకంపారిజన్ ఆపరేటర్ మరియు సంబంధిత సందేశం కన్సోల్‌లో ప్రదర్శించబడుతుంది.
స్ట్రింగ్ పోలిక
స్క్రిప్ట్‌లు స్ట్రింగ్ విలువలను కూడా సరిపోల్చవచ్చు. పోలిక ఆపరేటర్లు చాలా సరళంగా కనిపిస్తారు, కానీ స్ట్రింగ్ కంపారిజన్ ఆపరేషన్‌లు కొన్ని లక్షణాలను కలిగి ఉంటాయి, వీటిని మేము దిగువన టచ్ చేస్తాము. ఇక్కడ ఆపరేటర్ల జాబితా ఉంది.
str1 = str2సమానత్వం కోసం స్ట్రింగ్‌లను పరీక్షిస్తుంది, స్ట్రింగ్‌లు ఒకేలా ఉంటే నిజమని తిరిగి వస్తుంది.
str1 != str2స్ట్రింగ్‌లు ఒకేలా లేకుంటే ఒప్పు అని చూపుతుంది.
str1 < str2ఒకవేళ నిజమని చూపుతుందిstr1కంటే తక్కువstr2.
str1 > str2ఒకవేళ నిజమని చూపుతుందిstr1మించిstr2.
-n str1పొడవు ఉంటే నిజాన్ని చూపుతుందిstr1సున్నా పైన.
-z str1పొడవు ఉంటే నిజాన్ని చూపుతుందిstr1సున్నాకి సమానం.
స్క్రిప్ట్‌లోని స్ట్రింగ్‌లను పోల్చడానికి ఇక్కడ ఒక ఉదాహరణ ఉంది:
#!/bin/bash
user ="likegeeks"
if [$user = $USER]
then
echo "The user $user is the current logged in user"
fiస్క్రిప్ట్‌ను అమలు చేయడం వలన, మేము ఈ క్రింది వాటిని పొందుతాము.
స్క్రిప్ట్‌లలో స్ట్రింగ్‌లను పోల్చడం
స్ట్రింగ్ కంపారిజన్‌లో ప్రస్తావించదగిన ఒక ఫీచర్ ఇక్కడ ఉంది. అవి, ">" మరియు "<" ఆపరేటర్లు తప్పనిసరిగా బ్యాక్‌స్లాష్‌తో తప్పించుకోవాలి, లేకుంటే స్క్రిప్ట్ సరిగ్గా పని చేయదు, అయినప్పటికీ దోష సందేశాలు కనిపించవు. స్క్రిప్ట్ ">" గుర్తును అవుట్పుట్ దారి మళ్లింపు కమాండ్‌గా వివరిస్తుంది.
ఈ ఆపరేటర్‌లతో పని చేయడం కోడ్‌లో ఎలా ఉంటుందో ఇక్కడ ఉంది:
#!/bin/bash
val1=text
val2="another text"
if [ $val1 > $val2 ]
then
echo "$val1 is greater than $val2"
else
echo "$val1 is less than $val2"
fiస్క్రిప్ట్ ఫలితాలు ఇక్కడ ఉన్నాయి.
స్ట్రింగ్ పోలిక, హెచ్చరిక ఇవ్వబడింది
స్క్రిప్ట్ అమలు చేయబడినప్పటికీ, హెచ్చరికను జారీ చేస్తుందని దయచేసి గమనించండి:
./myscript: line 5: [: too many arguments
ఈ హెచ్చరికను వదిలించుకోవడానికి, మేము ముగించాము $val2 డబుల్ కోట్స్‌లో:
#!/bin/bash
val1=text
val2="another text"
if [ $val1 > "$val2" ]
then
echo "$val1 is greater than $val2"
else
echo "$val1 is less than $val2"
fiఇప్పుడు ప్రతిదీ తప్పక పని చేస్తుంది.
స్ట్రింగ్ పోలిక
">" మరియు "<" ఆపరేటర్ల యొక్క మరొక లక్షణం వారు పెద్ద అక్షరం మరియు చిన్న అక్షరాలతో ఎలా పని చేస్తారు. ఈ లక్షణాన్ని అర్థం చేసుకోవడానికి, కింది కంటెంట్‌తో టెక్స్ట్ ఫైల్‌ను సిద్ధం చేద్దాం:
Likegeeks
likegeeks
పేరు పెట్టి కాపాడుకుందాం myfile, ఆపై టెర్మినల్‌లో కింది ఆదేశాన్ని అమలు చేయండి:
sort myfileఇది ఫైల్ నుండి పంక్తులను ఇలా క్రమబద్ధీకరిస్తుంది:
likegeeks
Likegeeks
జట్టు sort, డిఫాల్ట్‌గా, స్ట్రింగ్‌లను ఆరోహణ క్రమంలో క్రమబద్ధీకరిస్తుంది, అంటే, మా ఉదాహరణలోని చిన్న అక్షరం పెద్ద అక్షరం కంటే చిన్నది. ఇప్పుడు అదే తీగలను సరిపోల్చే స్క్రిప్ట్‌ను సిద్ధం చేద్దాం:
#!/bin/bash
val1=Likegeeks
val2=likegeeks
if [ $val1 > $val2 ]
then
echo "$val1 is greater than $val2"
else
echo "$val1 is less than $val2"
fiమీరు దీన్ని అమలు చేస్తే, ప్రతిదీ మరొక విధంగా ఉందని తేలింది - చిన్న అక్షరం ఇప్పుడు పెద్ద అక్షరం కంటే పెద్దది.
స్క్రిప్ట్ ఫైల్‌లో క్రమబద్ధీకరణ ఆదేశం మరియు స్ట్రింగ్‌లను పోల్చడం
పోలిక ఆదేశాలలో, పెద్ద అక్షరాలు చిన్న అక్షరాల కంటే చిన్నవి. ఇక్కడ స్ట్రింగ్ పోలిక అనేది అక్షరాల ASCII కోడ్‌లను పోల్చడం ద్వారా జరుగుతుంది, క్రమబద్ధీకరణ క్రమం అక్షర కోడ్‌లపై ఆధారపడి ఉంటుంది.
జట్టు sort, క్రమంగా, సిస్టమ్ లాంగ్వేజ్ సెట్టింగ్‌లలో పేర్కొన్న క్రమబద్ధీకరణ క్రమాన్ని ఉపయోగిస్తుంది.
ఫైల్ తనిఖీలు
బహుశా కింది ఆదేశాలు బాష్ స్క్రిప్ట్‌లలో ఎక్కువగా ఉపయోగించబడతాయి. ఫైల్‌లకు సంబంధించి వివిధ పరిస్థితులను తనిఖీ చేయడానికి అవి మిమ్మల్ని అనుమతిస్తాయి. ఈ ఆదేశాల జాబితా ఇక్కడ ఉంది.
-d fileఫైల్ ఉనికిలో ఉందా మరియు డైరెక్టరీ కాదా అని తనిఖీ చేస్తుంది.
-e fileఫైల్ ఉందో లేదో తనిఖీ చేస్తుంది.
-f fileఫైల్ ఉనికిలో ఉందా మరియు ఫైల్ కాదా అని తనిఖీ చేస్తుంది.
-r fileఫైల్ ఉందో లేదో మరియు చదవగలిగేలా తనిఖీ చేస్తుంది.
-s file Пఫైల్ ఉనికిలో ఉందో లేదో తనిఖీ చేస్తుంది మరియు ఖాళీగా లేదు.
-w fileఫైల్ ఉనికిలో ఉందో లేదో మరియు వ్రాయదగినదో తనిఖీ చేస్తుంది.
-x fileఫైల్ ఉనికిలో ఉందా మరియు ఎక్జిక్యూటబుల్ కాదా అని తనిఖీ చేస్తుంది.
file1 -nt file2ఇది కొత్తదా అని తనిఖీ చేస్తుందిfile1ఎక్కువfile2.
file1 -ot file2పాతది ఉంటే తనిఖీ చేస్తుందిfile1ఎక్కువfile2.
-O fileఫైల్ ఉనికిలో ఉందో లేదో తనిఖీ చేస్తుంది మరియు ప్రస్తుత వినియోగదారు స్వంతం.
-G fileఫైల్ ఉనికిలో ఉందో లేదో మరియు దాని గ్రూప్ ID ప్రస్తుత వినియోగదారు గ్రూప్ IDతో సరిపోలుతుందో లేదో తనిఖీ చేస్తుంది.
ఈ కమాండ్‌లు, అలాగే ఈరోజు చర్చించబడిన అనేక ఇతర విషయాలు గుర్తుంచుకోవడం సులభం. వారి పేర్లు, వివిధ పదాల సంక్షిప్తాలు, వారు చేసే తనిఖీలను నేరుగా సూచిస్తాయి.
ఆచరణలో ఉన్న ఆదేశాలలో ఒకదానిని ప్రయత్నిద్దాం:
#!/bin/bash
mydir=/home/likegeeks
if [ -d $mydir ]
then
echo "The $mydir directory exists"
cd $ mydir
ls
else
echo "The $mydir directory does not exist"
fiఈ స్క్రిప్ట్, ఇప్పటికే ఉన్న డైరెక్టరీ కోసం, దాని కంటెంట్‌లను ప్రదర్శిస్తుంది.
డైరెక్టరీ యొక్క కంటెంట్‌లను జాబితా చేయడం
మిగిలిన ఆదేశాలతో మీరే ప్రయోగాలు చేయవచ్చని మేము నమ్ముతున్నాము; అవన్నీ ఒకే సూత్రం ప్రకారం ఉపయోగించబడతాయి.
ఫలితాలు
ఈ రోజు మనం బాష్ స్క్రిప్ట్‌లు రాయడం ఎలా ప్రారంభించాలో గురించి మాట్లాడాము మరియు కొన్ని ప్రాథమిక విషయాలను కవర్ చేసాము. నిజానికి, బాష్ ప్రోగ్రామింగ్ అంశం చాలా పెద్దది. ఈ వ్యాసం 11 మెటీరియల్‌ల పెద్ద సిరీస్‌లో మొదటి భాగం యొక్క అనువాదం. మీరు ప్రస్తుతం కొనసాగించాలనుకుంటే, ఈ మెటీరియల్‌ల అసలైన వాటి జాబితా ఇక్కడ ఉంది. సౌలభ్యం కోసం, మీరు ఇప్పుడే చదివిన అనువాదం ఇక్కడ చేర్చబడింది.
- — ఇక్కడ మేము బాష్ స్క్రిప్ట్‌లను సృష్టించడం ఎలా ప్రారంభించాలో మాట్లాడుతున్నాము, వేరియబుల్స్ యొక్క ఉపయోగం పరిగణించబడుతుంది, షరతులతో కూడిన నిర్మాణాలు, లెక్కలు, సంఖ్యల పోలికలు, స్ట్రింగ్‌లు మరియు ఫైల్‌ల గురించి సమాచారాన్ని కనుగొనడం వంటివి వివరించబడ్డాయి.
- — ఇక్కడ లూప్‌ల కోసం మరియు సమయంలో పని చేసే లక్షణాలు బహిర్గతం చేయబడ్డాయి.
- — ఈ మెటీరియల్ కమాండ్ లైన్ పారామితులు మరియు స్క్రిప్ట్‌లకు పంపబడే కీలకు అంకితం చేయబడింది, వినియోగదారు నమోదు చేసిన మరియు ఫైల్‌ల నుండి చదవగలిగే డేటాతో పని చేస్తుంది.
- - ఇక్కడ మేము ఫైల్ డిస్క్రిప్టర్‌ల గురించి మరియు వాటితో పని చేయడం, ఇన్‌పుట్, అవుట్పుట్, ఎర్రర్ స్ట్రీమ్‌లు మరియు అవుట్పుట్ దారి మళ్లింపు గురించి మాట్లాడుతున్నాము.
- — ఈ మెటీరియల్ Linux సిగ్నల్స్, స్క్రిప్ట్‌లలో వాటి ప్రాసెసింగ్ మరియు షెడ్యూల్‌లో స్క్రిప్ట్‌లను ప్రారంభించడం కోసం అంకితం చేయబడింది.
- — ఇక్కడ మీరు స్క్రిప్ట్‌లలో ఫంక్షన్‌లను సృష్టించడం మరియు ఉపయోగించడం మరియు లైబ్రరీలను అభివృద్ధి చేయడం గురించి తెలుసుకోవచ్చు.
- — ఈ వ్యాసం సెడ్ స్ట్రీమింగ్ టెక్స్ట్ ఎడిటర్‌తో పనిచేయడానికి అంకితం చేయబడింది.
- — ఈ మెటీరియల్ awk డేటా ప్రాసెసింగ్ భాషలో ప్రోగ్రామింగ్‌కు అంకితం చేయబడింది.
- — ఇక్కడ మీరు బాష్ స్క్రిప్ట్‌లలో సాధారణ వ్యక్తీకరణలను ఉపయోగించడం గురించి చదువుకోవచ్చు.
- — ఇక్కడ వినియోగదారులకు పంపబడే సందేశాలతో పని చేయడానికి సాంకేతికతలు ఉన్నాయి, అలాగే డిస్క్ పర్యవేక్షణ కోసం ఒక పద్ధతి.
- — ఈ మెటీరియల్ ఎక్స్‌పెక్ట్ టూల్‌కు అంకితం చేయబడింది, దీనితో మీరు ఇంటరాక్టివ్ యుటిలిటీలతో పరస్పర చర్యను ఆటోమేట్ చేయవచ్చు. ప్రత్యేకించి, మేము ఆశించే స్క్రిప్ట్‌లు మరియు బాష్ స్క్రిప్ట్‌లు మరియు ఇతర ప్రోగ్రామ్‌లతో వాటి పరస్పర చర్య గురించి మాట్లాడుతున్నాము.
ఈ కథనాల శ్రేణి యొక్క విలువైన లక్షణాలలో ఒకటి, సరళమైన, ఏ స్థాయి వినియోగదారులకైనా అనువైనది నుండి ప్రారంభించి, ఇది క్రమంగా చాలా తీవ్రమైన అంశాలకు దారి తీస్తుంది, ఇది Linux కమాండ్ లైన్ స్క్రిప్ట్‌ల సృష్టిలో ప్రతి ఒక్కరికీ ముందుకు సాగడానికి అవకాశం ఇస్తుంది. .
ప్రియమైన పాఠకులారా! బాష్ ప్రోగ్రామింగ్ గురువులు తమ నైపుణ్యం యొక్క ఎత్తులను ఎలా చేరుకున్నారు అనే దాని గురించి మాట్లాడమని, వారి రహస్యాలను పంచుకోవాలని మేము కోరతాము మరియు వారి మొదటి స్క్రిప్ట్‌ను వ్రాసిన వారి నుండి ముద్రలు అందుకోవడానికి మేము ఎదురుచూస్తున్నాము.
నమోదు చేసుకున్న వినియోగదారులు మాత్రమే సర్వేలో పాల్గొనగలరు. దయచేసి.
నేను మిగిలిన కథనాల శ్రేణిని అనువదించాలా?
-
అవును!
-
లేదు అవసరం లేదు
1030 మంది వినియోగదారులు ఓటు వేశారు. 106 మంది వినియోగదారులు దూరంగా ఉన్నారు.
మూలం: www.habr.com