కంటెంట్‌లు:
- వ్యాఖ్యలు
- ప్రతిధ్వని కమాండ్
- వేరియబుల్స్
- షరతులతో కూడిన ప్రకటన
- ఉచ్చులు
- విధులు
- స్క్రిప్ట్‌లో ప్రోగ్రామ్‌లను పిలుస్తోంది
- మెనూలను సృష్టిస్తోంది
- కమాండ్ లైన్ ప్రాసెసింగ్
- అంకగణితం
- స్ట్రింగ్ తారుమారు
- స్క్రిప్ట్ నుండి రిటర్న్ కోడ్‌లను తిరిగి ఇవ్వడం మరియు మరొక లిపిలో పట్టుకోవడం
- ఫైల్స్ చదవడం మరియు రాయడం
- గొట్టాలు
వ్యాఖ్యలు
కోడ్‌తో వ్యాఖ్యలను జోడించడం అనేది ఏదైనా ప్రోగ్రామింగ్ భాషలో ఒక ముఖ్యమైన భాగం. అమలు సమయంలో వ్యాఖ్యలు స్క్రిప్ట్‌తో అన్వయించబడవు. కోడ్ బాగా వ్యాఖ్యానించబడితే రీడర్ ఏదైనా కోడ్‌ను సరిగ్గా అర్థం చేసుకోగలడు. మీరు బాష్ స్క్రిప్ట్‌లో అనేక విధాలుగా వ్యాఖ్యను జోడించవచ్చు. మీరు బాష్ స్క్రిప్ట్‌లో సింగిల్-లైన్ మరియు మల్టిపుల్-లైన్ వ్యాఖ్యలను ఎలా జోడించవచ్చో ఈ భాగంలో చూపబడింది. బాష్ వ్యాఖ్య ఉపయోగం తెలుసుకోవడానికి కింది స్క్రిప్ట్‌తో బాష్ ఫైల్‌ని సృష్టించండి. ఇక్కడ, సింగిల్-లైన్ వ్యాఖ్యను జోడించడానికి ‘#’ చిహ్నం ఉపయోగించబడుతుంది మరియు బహుళ-లైన్ వ్యాఖ్యలను జోడించడానికి ‘:’ తో సింగిల్ కోట్ (‘) ఉపయోగించబడుతుంది.
bash_comment.sh
#!/బిన్/బాష్
#సంఖ్యను ఇన్‌పుట్‌గా తీసుకోండి
బయటకు విసిరారు 'ఒక సంఖ్యను నమోదు చేయండి'
చదవండికు
:'
ఇన్పుట్ నంబర్‌ని తనిఖీ చేయండి
10 కంటే తక్కువ లేదా 10 కంటే ఎక్కువ లేదా 10 కి సమానం
'
ఉంటే [[ $ a -లిట్ 10 ]]
అప్పుడు
బయటకు విసిరారు 'సంఖ్య 10 కన్నా తక్కువ'
ఎలిఫ్ [[ $ a -జిటి 10 ]]
అప్పుడు
బయటకు విసిరారు 'సంఖ్య 10 కంటే ఎక్కువ'
లేకపోతే
బయటకు విసిరారు 'సంఖ్య 10 కి సమానం'
ఉంటుంది
అవుట్పుట్:
స్క్రిప్ట్ రన్ చేయండి.
$బాష్bash_comment.sh
ఇక్కడ, ఇన్పుట్ విలువ 3, 10 మరియు 90 లతో మూడు సార్లు స్క్రిప్ట్ అమలు చేయబడుతుంది. కింది అవుట్పుట్ కనిపిస్తుంది.
మీరు బాష్ వ్యాఖ్యానించడం గురించి మరింత తెలుసుకోవాలనుకుంటే, మీరు తనిఖీ చేయవచ్చు ఈ ట్యుటోరియల్ .
ప్రతిధ్వని ఆదేశం
టెర్మినల్‌లో అవుట్‌పుట్‌ను ముద్రించడానికి బాష్‌లో `ఎకో` కమాండ్ ఉపయోగించబడుతుంది. Optionsట్‌పుట్‌ను వివిధ మార్గాల్లో ముద్రించడానికి బాష్‌లోని ఎకో కమాండ్‌తో వివిధ ఎంపికలను ఉపయోగించవచ్చు. `Echo` కమాండ్ యొక్క రెండు సాధారణ ఉపయోగాలను తెలుసుకోవడానికి కింది స్క్రిప్ట్‌తో బాష్ ఫైల్‌ను సృష్టించండి. ఇక్కడ, మొదటి `ఎకో` కమాండ్ ఒక సాధారణ టెక్స్ట్ డేటాను కొత్త లైన్‌తో ప్రింట్ చేస్తుంది మరియు రెండవ ఎకో కమాండ్ కొత్త లైన్ లేకుండా సాధారణ టెక్స్ట్‌ను ప్రింట్ చేస్తుంది.
echo_test.sh
#!/బిన్/బాష్#మొదటి వచనాన్ని ముద్రించండి
బయటకు విసిరారు 'కొత్త పంక్తితో వచనాన్ని ముద్రించండి'
#రెండవ వచనాన్ని ముద్రించండి
బయటకు విసిరారు -n 'కొత్త పంక్తి లేకుండా వచనాన్ని ముద్రించండి'
అవుట్పుట్:
స్క్రిప్ట్ రన్ చేయండి.
$బాష్echo_test.shపై ఆదేశాన్ని అమలు చేసిన తర్వాత కింది అవుట్పుట్ కనిపిస్తుంది.
బాష్‌లో `ఎకో` కమాండ్ యొక్క అనేక ఇతర ఉపయోగాలు ఉన్నాయి. `ఎకో` కమాండ్ గురించి మరింత తెలుసుకోవడానికి మీరు ఈ ట్యుటోరియల్‌ని తనిఖీ చేయవచ్చు.
వేరియబుల్స్
వేరియబుల్ డిక్లరేషన్ అనేది ఏదైనా ప్రోగ్రామింగ్ లాంగ్వేజ్‌లో అవసరమైన భాగం. బాష్ వేరియబుల్స్ వివిధ రకాలుగా ప్రకటించబడతాయి. వేరియబుల్‌లో విలువ కేటాయించబడినప్పుడు వేరియబుల్ ప్రారంభంలో ఎటువంటి గుర్తు ఉపయోగించబడదు. వేరియబుల్ విలువను చదివే సమయంలో వేరియబుల్ పేరుతో '$' గుర్తు ఉపయోగించబడుతుంది. వేరియబుల్‌ను టెర్మినల్ నుండి ఉపయోగించవచ్చు లేదా ఏదైనా బాష్ స్క్రిప్ట్‌లో ఉపయోగించవచ్చు.
కింది ఆదేశాలు అనే స్ట్రింగ్ వేరియబుల్‌ను ప్రకటిస్తాయి mystr టెర్మినల్‌లోని వేరియబుల్ విలువను ఒక నిర్దిష్ట విలువతో మరియు తదుపరి ప్రింట్‌తో.
$mystr='నాకు బాష్ ప్రోగ్రామింగ్ అంటే ఇష్టం'$బయటకు విసిరారు $ mystr
అవుట్పుట్:
కింది స్క్రిప్ట్‌తో బాష్ ఫైల్‌ను సృష్టించండి. రెండు వేరియబుల్స్ ఇక్కడ ప్రకటించబడ్డాయి. ఇవి $ a మరియు $ బి . నిల్వ చేసిన ఇన్పుట్ విలువ ఉంటే $ a సమానముగా $ బి అప్పుడు సందేశం, సంఖ్యలు సమానంగా ఉంటాయి లేకపోతే ముద్రించబడుతుంది సంఖ్యలు సమానంగా లేవు ముద్రించబడుతుంది.
var.sh
#!/బిన్/బాష్బయటకు విసిరారు 'ఒక సంఖ్యను నమోదు చేయండి'
చదవండికు
బి=100
ఉంటే [[ $ a -ఎక్యూ $ బి ]]
అప్పుడు
బయటకు విసిరారు 'సంఖ్యలు సమానం'
లేకపోతే
బయటకు విసిరారు 'సంఖ్యలు సమానం కాదు'
ఉంటుంది
అవుట్పుట్:
స్క్రిప్ట్ రన్ చేయండి.
$బాష్var.sh56 మరియు 100 విలువలతో పై ఆదేశం రెండుసార్లు అమలు చేయబడుతుంది. కింది అవుట్పుట్ కనిపిస్తుంది.
మీరు బాష్ వేరియబుల్స్ గురించి మరింత తెలుసుకోవాలనుకుంటే, మీరు చెక్ చేయవచ్చు ఈ ట్యుటోరియల్ .
షరతులతో కూడిన ప్రకటన
మరొక ప్రోగ్రామింగ్ లాంగ్వేజ్ లాగా, మీరు బాష్‌లో షరతులతో కూడిన స్టేట్‌మెంట్‌ను ఉపయోగించవచ్చు. ' If-then-else 'మరియు' కేసు స్టేట్‌మెంట్‌లు ప్రధానంగా ఏదైనా ప్రోగ్రామింగ్ లాంగ్వేజ్‌లో కండిషన్ స్టేట్‌మెంట్‌లను అమలు చేయడానికి ఉపయోగిస్తారు. ఉపయోగించి షరతులతో కూడిన ప్రకటనను ఉపయోగించడం 'ఉంటే' ఈ ట్యుటోరియల్ యొక్క ఈ విభాగంలో ప్రకటన చూపబడింది. షరతులతో కూడిన స్టేట్‌మెంట్ ఉపయోగించబడే కింది స్క్రిప్ట్‌తో బాష్ ఫైల్‌ను సృష్టించండి. ఇక్కడ, రెండు విలువలు వినియోగదారు నుండి ఇన్‌పుట్‌గా తీసుకోబడతాయి మరియు వేరియబుల్స్‌లో నిల్వ చేయబడతాయి, $ కోడ్ , మరియు $ వయస్సు . విలువను తనిఖీ చేయడానికి 'if' స్టేట్‌మెంట్ ఉపయోగించబడుతుంది $ వయస్సు కంటే ఎక్కువ లేదా సమానం 18 మరియు విలువ $ కోడ్ ఉంది 1100 . రెండు షరతులు నిజమైతే, సందేశం, మీరు సినిమా చూడటానికి అర్హులు లేకపోతే ముద్రించబడుతుంది మీకు సినిమా చూడటానికి అర్హత లేదు ముద్రించబడుతుంది.
cond.sh
#!/బిన్/బాష్బయటకు విసిరారు 'మీ కోడ్‌ని నమోదు చేయండి'
చదవండికోడ్
బయటకు విసిరారు 'మీ వయస్సు నమోదు చేయండి'
చదవండివయస్సు
ఉంటే [[ $ వయస్సు -ఇవ్వండి 18 && $ కోడ్ -ఎక్యూ '1100' ]]
అప్పుడు
బయటకు విసిరారు 'మీరు సినిమా చూడటానికి అర్హులు'
లేకపోతే
బయటకు విసిరారు 'మీకు సినిమా చూడటానికి అర్హత లేదు'
ఉంటుంది
అవుట్పుట్:
స్క్రిప్ట్ రన్ చేయండి.
$బాష్cond.shవిభిన్న ఇన్పుట్ విలువలను తీసుకున్న తర్వాత కింది అవుట్పుట్ కనిపిస్తుంది. 1100 కోడ్‌గా ఇవ్వబడింది మరియు మొదటి అమలు కోసం 5 వయస్సుగా ఇవ్వబడుతుంది మరియు ఈ విలువలకు కండిషన్ తప్పుగా ఉంటే. 1100 కోడ్‌గా ఇవ్వబడింది మరియు రెండవ అమలు కోసం వయస్సుగా 45 ఇవ్వబడుతుంది, అది షరతుకు నిజం అవుతుంది.
మీరు బాష్ షరతులతో కూడిన ప్రకటన గురించి మరింత తెలుసుకోవాలనుకుంటే, మీరు ఈ ట్యుటోరియల్‌ని తనిఖీ చేయవచ్చు.
ఉచ్చులు
స్క్రిప్ట్ యొక్క కొన్ని భాగాలు అనేకసార్లు అమలు చేయవలసి వచ్చినప్పుడు లూప్ టాస్క్ చేయడానికి ఉపయోగించబడుతుంది. ఇతర భాషల మాదిరిగానే బాష్ మూడు రకాల లూప్స్ డిక్లరేషన్‌కు మద్దతు ఇస్తుంది. ఇవి లూప్‌ల కోసం, అయితే మరియు వరకు. ప్రోగ్రామింగ్ అవసరాల ఆధారంగా, ఒక నిర్దిష్ట లూప్ స్క్రిప్ట్‌లో ఉపయోగించబడుతుంది. ఈ మూడు రకాల లూప్‌ల ఉపయోగాలు సాధారణ ఉదాహరణలను ఉపయోగించి ఈ విభాగంలో చూపబడ్డాయి.
లూప్ కోసం ఉపయోగించడం
కింది స్క్రిప్ట్‌తో బాష్ ఫైల్‌ను సృష్టించండి కోసం` లూప్ పునరావృతం కోసం ఉపయోగించబడుతుంది. `కోసం` లూప్ ప్రధానంగా డేటా జాబితా లేదా శ్రేణిని పునరుద్దరించడానికి ఉపయోగించబడుతుంది. ఇక్కడ, వారం రోజుల పేరు యొక్క జాబితా ఉపయోగించబడుతుంది మరియు ప్రతి వారం రోజు పేరు లూప్ కోసం ఉపయోగించడం ద్వారా పునరావృతమవుతుంది. `if` వారం రోజుల పేరు ఆధారంగా ఒక నిర్దిష్ట సందేశాన్ని ముద్రించడానికి స్టేట్‌మెంట్ ఉపయోగించబడుతుంది.
s.sh కోసం
#లూప్ యొక్క ప్రతి పునరావృతంలో ఒక వారం రోజు పేరు చదవండికోసంరోజులోసోమవారం మంగళవారం బుధవారం గురువారం శుక్రవారం శనివారం ఆదివారం
చేయండి
#వారం రోజు పేరు సోమవారం లేదా గురువారం అని తనిఖీ చేయండి
ఉంటే [[ $ రోజు=='సోమవారం' || $ రోజు=='గురువారం' ]]
అప్పుడు
బయటకు విసిరారు 'సమావేశం జరుగుతోంది$ రోజుఉదయం 9:30 గంటలకు '
#వారం రోజు పేరు మంగళవారం లేదా బుధవారం లేదా శుక్రవారం అని తనిఖీ చేయండి
ఎలిఫ్ [[ $ రోజు=='మంగళవారం' || $ రోజు=='బుధవారం' || $ రోజు=='శుక్రవారం' ]]
అప్పుడు
బయటకు విసిరారు 'శిక్షణ$ రోజుఉదయం 11:00 గంటలకు '
లేకపోతే
#ఇతర రోజులకు ‘హాలిడే’ అని ముద్రించండి
బయటకు విసిరారు '$ రోజుసెలవు ఉంది '
ఉంటుంది
పూర్తి
అవుట్పుట్:
స్క్రిప్ట్ రన్ చేయండి.
$బాష్s.sh కోసంస్క్రిప్ట్ అమలు చేసిన తర్వాత కింది అవుట్పుట్ కనిపిస్తుంది.
మీరు బాష్ ఫర్ లూప్ గురించి ఎక్కువగా తెలుసుకోవాలనుకుంటే, మీరు ఈ ట్యుటోరియల్‌ని తనిఖీ చేయవచ్చు.
అయితే లూప్‌ని ఉపయోగించడం
కింది స్క్రిప్ట్‌తో బాష్ ఫైల్‌ను సృష్టించండి అయితే ` లూప్ పునరావృతం కోసం ఉపయోగించబడుతుంది. ఈ స్క్రిప్ట్ 1 నుండి 20 వరకు ఉన్న సంఖ్యలను 5 ద్వారా సమానంగా మరియు భాగించగల ముద్రణ చేస్తుంది. $ కౌంటర్ లూప్ యొక్క పునరుక్తిని నియంత్రించడానికి వేరియబుల్ ఉపయోగించబడుతుంది మరియు ఈ వేరియబుల్ విలువ ప్రతి పునరుక్తిలో 1 ద్వారా పెరుగుతుంది. ఎప్పుడు `if` షరతు నిజమవుతుంది, అది విలువను ప్రింట్ చేస్తుంది $ కౌంటర్ .
#!/బిన్/బాష్#సందేశాన్ని ముద్రించండి
బయటకు విసిరారు 'సమానమైన మరియు 5 ద్వారా భాగించగల సంఖ్యలను ముద్రించండి'
#కౌంటర్‌ను ప్రారంభించండి
కౌంటర్=1
$ కౌంటర్ విలువ 20 కంటే తక్కువగా లేదా సమానంగా ఉండే వరకు లూప్‌ను సూచించండి
అయితే [ $ కౌంటర్ -ది ఇరవై ]
చేయండి
#$ కౌంటర్ 2 మరియు 5 ద్వారా భాగించబడుతుందని తనిఖీ చేయండి
ఉంటే [[ $ కౌంటర్%2-ఎక్యూ 0 && $ కౌంటర్%5-ఎక్యూ 0 ]]
అప్పుడు
#కొత్త లైన్ లేకుండా $ కౌంటర్ ముద్రించండి
బయటకు విసిరారు '$ కౌంటర్'
ఉంటుంది
#1 ద్వారా $ కౌంటర్‌ని పెంచండి
((కౌంటర్ ++))
పూర్తి
బయటకు విసిరారు 'పూర్తి'
అవుట్పుట్:
$బాష్కాగా. s1-20 లోపు సంఖ్యలు మాత్రమే ఉన్నాయి. అవి సమానమైనవి మరియు 5 ద్వారా భాగించబడతాయి. స్క్రిప్ట్‌ను అమలు చేసిన తర్వాత కింది అవుట్పుట్ కనిపిస్తుంది.
మీరు బాష్ యొక్క మరింత ఉపయోగం గురించి తెలుసుకోవాలనుకుంటే ఉండగా` లూప్ అప్పుడు మీరు తనిఖీ చేయవచ్చు ఈ ట్యుటోరియల్ .
లూప్ వరకు ఉపయోగించడం
కింది స్క్రిప్ట్‌తో బాష్ ఫైల్‌ను సృష్టించండి వరకు` లూప్ పునరావృతం కోసం ఉపయోగించబడుతుంది. ఈ స్క్రిప్ట్ అన్ని బేసి సంఖ్యలను 0 నుండి 20 వరకు ప్రింట్ చేస్తుంది. $ n లూప్‌ను మళ్ళించడానికి ఈ స్క్రిప్ట్‌లో వేరియబుల్ ఉపయోగించబడుతుంది.
వరకు. ఎస్
#!/బిన్/బాష్#వేరియబుల్‌ను ప్రారంభించండి, n
ఎన్=ఇరవై
#$ N విలువ 0 కంటే ఎక్కువగా ఉండే వరకు లూప్‌ను పునరావృతం చేయండి
వరకు [ $ n -లిట్ 0 ]
చేయండి
#N విలువ బేసి అని తనిఖీ చేయండి
ఉంటే [[ $ n%2-జిటి 0 ]]
అప్పుడు
బయటకు విసిరారు $ n
ఉంటుంది
#N విలువను 1 ద్వారా పెంచండి
((ఎన్=$ n-1))
పూర్తి
అవుట్పుట్:
స్క్రిప్ట్ రన్ చేయండి.
$బాష్వరకు. ఎస్స్క్రిప్ట్ అన్ని సరి సంఖ్యలను 20 నుండి 1 వరకు ప్రింట్ చేస్తుంది. స్క్రిప్ట్ అమలు చేసిన తర్వాత కింది అవుట్పుట్ కనిపిస్తుంది.
విధులు
కోడ్ యొక్క బ్లాక్ స్క్రిప్ట్‌లో అనేకసార్లు అమలు చేయవలసి వచ్చినప్పుడు ఫంక్షన్ టాస్క్ చేయడానికి ఉపయోగించబడుతుంది. ఫంక్షన్‌లో నిర్వచించిన స్క్రిప్ట్ ఒకే స్క్రిప్ట్‌ను అనేకసార్లు జోడించడం కంటే చాలాసార్లు అమలు చేయాల్సిన అవసరం వచ్చినప్పుడు మాత్రమే మీరు ఫంక్షన్‌ను పేరు ద్వారా పిలవాలి. ప్రారంభ మరియు ముగింపు మొదటి బ్రాకెట్ ఫంక్షన్‌ను బాష్ స్క్రిప్ట్‌లో ప్రకటించడానికి ఫంక్షన్ పేరుతో ఉపయోగించబడుతుంది. ఫంక్షన్‌ను కేవలం బాష్‌లోని ఫంక్షన్ పేరు ద్వారా పిలవవచ్చు. బాష్ మరొక ప్రామాణిక ప్రోగ్రామింగ్ లాంగ్వేజ్ లాగా ఫంక్షన్ ఆర్గ్యుమెంట్‌కు మద్దతు ఇవ్వదు. కానీ ఈ విభాగంలో చూపిన విధంగా వేరొక విధంగా బాష్ ఫంక్షన్‌కు విలువ పంపబడుతుంది. రిటర్న్ స్టేట్‌మెంట్‌తో లేదా రిటర్న్ స్టేట్‌మెంట్‌ను ఉపయోగించకుండా ఫంక్షన్ నుండి విలువను తిరిగి పొందవచ్చు.
బాష్ స్క్రిప్ట్‌లో ఫంక్షన్‌లను ఎలా డిక్లేర్ చేయవచ్చు మరియు కాల్ చేయవచ్చో తెలుసుకోవడానికి కింది స్క్రిప్ట్‌తో బాష్ ఫైల్‌ను సృష్టించండి. స్క్రిప్ట్‌లో మూడు విధులు ప్రకటించబడ్డాయి. మొదటి ఫంక్షన్ సాధారణ సందేశాన్ని ముద్రించడానికి ప్రకటించబడింది, ప్రారంభకులకు బాష్ ప్రోగ్రామింగ్ . వేరియబుల్‌లో స్ట్రింగ్ విలువను కేటాయించడానికి రెండవ ఫంక్షన్ ప్రకటించబడింది, $ return_str అది ప్రింట్ చేస్తుంది, LinuxHint తో బాష్ ప్రోగ్రామింగ్ నేర్చుకోండి ఫంక్షన్‌కు కాల్ చేసిన తర్వాత. మూడవ ఫంక్షన్ ఆర్గ్యుమెంట్ విలువను సర్కిల్ రేడియస్‌గా చదవడానికి డిక్లేర్ చేయబడింది, అది ఫంక్షన్‌కు కాల్ చేసే సమయంలో అందించబడుతుంది. ఇక్కడ, స్థానిక ఆర్గ్యుమెంట్ విలువను చదవడానికి ఉపయోగించబడుతుంది. ఈ ఫంక్షన్ సూత్రం ఉపయోగించి వ్యాసార్థం విలువ ఆధారంగా వృత్తం యొక్క వైశాల్యాన్ని లెక్కిస్తుంది, .r2 మరియు లెక్కించిన ప్రాంతం విలువను ముద్రించండి.
func.sh
#!/బిన్/బాష్#ఒక సాధారణ ఫంక్షన్‌ని ప్రకటించండి
ఫంక్షన్print_ సందేశం()
{
బయటకు విసిరారు 'ప్రారంభకులకు బాష్ ప్రోగ్రామింగ్'
}
#స్ట్రింగ్ విలువను తిరిగి ఇవ్వడానికి ఫంక్షన్‌ని ప్రకటించండి
ఫంక్షన్ret_strdata()
{
#స్ట్రింగ్ విలువతో వేరియబుల్‌ను ప్రారంభించండి
return_str='LinuxHint తో బాష్ ప్రోగ్రామింగ్ నేర్చుకోండి'
}
ఆర్గ్యుమెంట్ విలువను చదవడానికి ఫంక్షన్‌ని ప్రకటించండి
ఫంక్షన్ఏరియాను లెక్కించండి()
#ఆమోదించిన ఆర్గ్యుమెంట్ విలువను చదవండి
స్థానిక వ్యాసార్థం=$ 1
ప్రాంతం= $(బయటకు విసిరారు $ వ్యాసార్థం*$ వ్యాసార్థం*3.14
#సాధారణ సందేశాన్ని ముద్రించడానికి ఫంక్షన్‌కు కాల్ చేయండి
print_ సందేశం
#వేరియబుల్‌లో స్ట్రింగ్ విలువను కేటాయించే ఫంక్షన్‌కు కాల్ చేయండి
ret_strdata
#వేరియబుల్ విలువను ముద్రించండి
బయటకు విసిరారు $ return_str
#వ్యాసార్థం విలువను చదవండి
బయటకు విసిరారు 'వ్యాసార్థం విలువను నమోదు చేయండి'
చదవండిపని
#వ్యాసార్థ విలువతో ఫంక్షన్‌కు కాల్ చేయండి
ఏరియాను లెక్కించండి$ rad
అవుట్పుట్:
స్క్రిప్ట్ రన్ చేయండి.
$బాష్func.shస్క్రిప్ట్ అమలు చేసిన తర్వాత కింది అవుట్పుట్ కనిపిస్తుంది. ఫంక్షన్లకు కాల్ చేయడం ద్వారా మొదటి రెండు పంక్తులు ముద్రించబడతాయి, print_ సందేశం () మరియు ret_strdata () . ఫంక్షన్‌కు కాల్ చేయడం ద్వారా చివరి పంక్తి ముద్రించబడుతుంది, ఏరియాను లెక్కించండి () తీసుకున్న ఇన్పుట్ వ్యాసార్థం విలువతో.
బాష్ ఫంక్షన్ నుండి స్ట్రింగ్‌ను తిరిగి ఇవ్వడం గురించి మీరు తెలుసుకోవాలనుకుంటే, మీరు చేయవచ్చు ఈ ట్యుటోరియా ది.
స్క్రిప్ట్‌లో ప్రోగ్రామ్‌లను పిలుస్తోంది
మీరు ఏదైనా బాష్ స్క్రిప్ట్‌లో ఇతర ప్రోగ్రామ్‌లను కాల్ చేయడానికి అనేక రకాల ఆదేశాలను ఉపయోగించవచ్చు మూలం, బాష్, పరిణామం, కార్యనిర్వహణ , మొదలైనవి మూడు బాష్ ఫైల్స్ అనుకుందాం, add.sh , subtract.sh, గుణించండి. ఎస్ మరియు డివిజన్. ఎస్ కూడిక, తీసివేత, గుణకారం మరియు విభజన చేయడానికి రూపొందించబడింది. ఇక్కడ, subtract.sh మరియు డివిజన్. s కమాండ్ లైన్ ఆర్గ్యుమెంట్‌లను చదవండి. ఈ నాలుగు ఫైళ్ల స్క్రిప్ట్ క్రింద ఇవ్వబడింది.
add.sh
#!/బిన్/బాష్‌కు=60
బి=40
((ఫలితం=$ a+$ బి))
బయటకు విసిరారు 'అదనంగా$ a+$ బి=$ ఫలితం'
subract.sh
#!/బిన్/బాష్‌కు=$ 1
బి=$ 2
((ఫలితం=$ a-$ బి))
బయటకు విసిరారు 'తీసివేత$ a-$ బి=$ ఫలితం'
గుణించండి. s
#!/బిన్/బాష్((ఫలితం=$ 1*$ 2))
బయటకు విసిరారు '$ 1 మరియు $ 2 గుణకారం$ ఫలితం'
విభజించు. s
#!/బిన్/బాష్‌కు=$ 1
బి=2
((ఫలితం=$ a/$ బి))
బయటకు విసిరారు 'యొక్క విభజన$ aద్వారా$ బిఉంది$ ఫలితం'
అనే బాష్ ఫైల్‌ను సృష్టించండి, callpro.sh కింది స్క్రిప్ట్‌తో సోర్స్, బాష్, ఎవల్ మరియు ఎగ్జిక్యూట్ కమాండ్‌లను ఉపయోగించి పేర్కొన్న బాష్ ఫైల్‌లను కాల్ చేయండి. కింది స్క్రిప్ట్‌ను అమలు చేయడానికి ముందు మీరు పై నాలుగు ఫైల్‌ల అమలు అనుమతిని సెట్ చేయాలి. కాల్ చేయడానికి `సోర్స్` కమాండ్ ఉపయోగించబడుతుంది add.sh ఫైల్. subtract.sh ఫైల్‌ను అమలు చేయడానికి `bash` ఆదేశం ఉపయోగించబడుతుంది. multiply.sh ఫైల్‌ను అమలు చేయడానికి `eval` ఆదేశం ఉపయోగించబడుతుంది. `Eval` కమాండ్ కోసం రెండు ఇన్పుట్ విలువలు కమాండ్ లైన్ ఆర్గ్యుమెంట్‌లుగా పంపబడతాయి. చివరి ఆదేశం అనేది exec ఆదేశం, ఇది సంపూర్ణ మార్గంలో మాత్రమే పనిచేస్తుంది. దీని కోసం, div.sh ఫైల్ యొక్క పూర్తి మార్గం పేరు స్క్రిప్ట్‌లో ఇవ్వబడింది.
callpro.sh
#!/బిన్/బాష్స్క్రిప్ట్ 1='add.sh'
స్క్రిప్ట్ 2='subtract.sh'
స్క్రిప్ట్ 3='multiply.sh'
స్క్రిప్ట్ 4='/home/fahmida/code/divide.sh'
మూలం '$ స్క్రిప్ట్ 1'
బాష్ $ స్క్రిప్ట్ 2 యాభై ఇరవై
బయటకు విసిరారు 'విలువను నమోదు చేయండి'
చదవండికు
బయటకు విసిరారు 'B విలువను నమోదు చేయండి'
చదవండిబి
పరిణామం బాష్ $ స్క్రిప్ట్ 3 $ a $ బి
కార్యనిర్వహణ $ స్క్రిప్ట్ 4 30
అవుట్పుట్:
స్క్రిప్ట్ రన్ చేయండి.
$బాష్callpro.shస్క్రిప్ట్ అమలు చేసిన తర్వాత కింది అవుట్పుట్ కనిపిస్తుంది.
మెనూలను సృష్టిస్తోంది
సాధారణ మెనూని సృష్టించడానికి బాష్‌లో ఉపయోగకరమైన ఆదేశం ఉంది `ఎంచుకోండి` కమాండ్ ఈ ఆదేశాన్ని ఉపయోగించడం ద్వారా వివిధ రకాల మెనూలను సృష్టించవచ్చు. ఈ ఆదేశం ద్వారా మెనుని సృష్టించడానికి ఒక నిర్దిష్ట డేటా జాబితా ఉపయోగించబడుతుంది. కింది కోడ్‌తో బాష్ ఫైల్‌ని సృష్టించి దీని ఉపయోగం చూడండి `ఎంచుకోండి` మెనుని సృష్టించడానికి ఆదేశం. ఈ ఉదాహరణలో, ఐదు అంశాల జాబితా మెనూగా ముద్రించబడుతుంది మరియు జాబితా నుండి ఏదైనా భాషను ఎంచుకోవడానికి వినియోగదారుని ప్రాంప్ట్ చేస్తుంది. ఎంచుకున్న విలువ వేరియబుల్‌లో నిల్వ చేయబడుతుంది, $ భాష అది తరువాత ఇతర స్ట్రింగ్‌తో కలపడం ద్వారా ముద్రించబడుతుంది. స్క్రిప్ట్ వినియోగదారుని నొక్కే వరకు భాషను ఎంచుకోవడానికి నిరంతరం అడుగుతుంది 6 స్క్రిప్ట్ నుండి ముగించడానికి.
menu.sh
#!/బిన్/బాష్వినియోగదారు కోసం #ముద్రణ సందేశం
బయటకు విసిరారు 'మీకు ఇష్టమైన భాషను ఎంచుకోండి'
# మెను ఐటెమ్ జాబితాను నిర్వచించండి
ఎంచుకోండిభాషలోసి# జావా PHP పైథాన్ బాష్ నిష్క్రమణ
చేయండి
#ఎంచుకున్న విలువను ముద్రించండి
ఉంటే [[ $ భాష=='బయటకి దారి' ]]
అప్పుడు
బయటకి దారి 0
లేకపోతే
బయటకు విసిరారు 'ఎంచుకున్న భాష$ భాష'
ఉంటుంది
పూర్తి
అవుట్పుట్:
స్క్రిప్ట్ రన్ చేయండి.
$బాష్menu.shకింది అవుట్పుట్ ప్రకారం, వినియోగదారు PHP ని ముద్రించిన మొదటిసారి 3 ని నొక్కారు మరియు స్క్రిప్ట్ నుండి ముగిసిన రెండవ సారి 6 నొక్కారు.
మీరు `ఎంపిక` తో బాష్ మెను సృష్టి గురించి మరింత తెలుసుకోవాలనుకుంటే, మీరు ఈ ట్యుటోరియల్‌ని సందర్శించవచ్చు.
కమాండ్ లైన్ ప్రాసెసింగ్
కమాండ్ లైన్ నుండి స్క్రిప్ట్‌ను అమలు చేసేటప్పుడు కొన్నిసార్లు మనం ఇన్పుట్ విలువలను అందించాలి. ఈ పనిని బాష్‌లో రెండు విధాలుగా చేయవచ్చు. ఆర్గ్యుమెంట్ వేరియబుల్స్ ఉపయోగించడం ఒక మార్గం మరియు గెటోప్ట్స్ ఫంక్షన్ ఉపయోగించడం మరొక మార్గం. ఆర్గ్యుమెంట్ వేరియబుల్ ఉపయోగించి టెర్మినల్ నుండి కమాండ్ లైన్ ఇన్పుట్ డేటాను చదవడం ఈ విభాగంలో చూపబడింది.
పఠనం కమాండ్ లైన్ ఆర్గ్యుమెంట్ విలువను చూడటానికి క్రింది స్క్రిప్ట్‌తో బాష్ ఫైల్‌ను సృష్టించండి. ఈ స్క్రిప్ట్ మూడు కమాండ్ లైన్ ఆర్గ్యుమెంట్‌లను చదువుతుంది, ఇవి వేరియబుల్స్‌లో నిల్వ చేయబడతాయి, $ operand1, $ operand2 మరియు $ operator. స్క్రిప్ట్ సరిగ్గా అమలు చేయడానికి, మొదటి మరియు మూడవ ఆర్గ్యుమెంట్ విలువలు సంఖ్యగా ఉండాలి మరియు రెండవ ఆర్గ్యుమెంట్ విలువ తప్పనిసరిగా నాలుగు అంకగణిత ఆపరేటర్లలో ఏదైనా ('+', '-', '/', 'x'). ఉంటే స్టేట్‌మెంట్ $ ఆపరేటర్ విలువను తనిఖీ చేస్తుంది మరియు ఆపరేటర్ ఆధారంగా ఆపరేషన్ చేస్తుంది మరియు విలువను ప్రింట్ చేస్తుంది.
cl1.sh
#!/బిన్/బాష్#ఆర్గ్యుమెంట్ వేరియబుల్స్ ముద్రించండి
బయటకు విసిరారు 'వాదన విలువలు: $ 1 $ 2 $ 3'
# వాదన విలువలను నిల్వ చేయండి
ఆపరేండ్ 1=$ 1
ఆపరేండ్ 2=$ 3
ఆపరేటర్=$ 2
#అంకగణిత ఆపరేషన్ చేయడానికి 2 వ కమాండ్ ఆర్గ్యుమెంట్ విలువను తనిఖీ చేయండి
ఉంటే [[ $ ఆపరేటర్=='+' ]]
అప్పుడు
((ఫలితం=$ operand1+$ operand2))
ఎలిఫ్ [[ $ ఆపరేటర్=='-' ]]
అప్పుడు
((ఫలితం=$ operand1-$ operand2))
ఎలిఫ్ [[ $ ఆపరేటర్=='x' ]]
అప్పుడు
((ఫలితం=$ operand1*$ operand2))
ఎలిఫ్ [[ $ ఆపరేటర్=='/' ]]
అప్పుడు
((ఫలితం=$ operand1/$ operand2))
ఉంటుంది
# ఫలితాన్ని ముద్రించండి
బయటకు విసిరారు -మరియు 'ఫలితం =$ ఫలితం'
అవుట్పుట్:
స్క్రిప్ట్ రన్ చేయండి.
$బాష్cl1.shనాలుగు రకాల అంకగణిత ఆపరేటర్లకు నాలుగు సార్లు స్క్రిప్ట్ అమలు చేయబడుతుంది. ఆర్గ్యుమెంట్ విలువల కోసం కింది అవుట్పుట్ కనిపిస్తుంది, 6 + 3, 6 - 3, 6 x 3 మరియు 6 /3 .
వాదన విలువలు బాష్‌లో పేరు-విలువ జతతో పంపబడతాయి. పేరుతో వాదన విలువలను ఎలా చదవాలో చూపించడానికి క్రింది స్క్రిప్ట్‌తో బాష్ ఫైల్‌ను సృష్టించండి. స్క్రిప్ట్ రెండు ఆర్గ్యుమెంట్ వేరియబుల్స్ చదువుతుంది. పేరుతో వాదన విలువలు స్క్రిప్ట్ యొక్క మొదటి స్టేట్‌మెంట్‌లో ముద్రించబడతాయి. తరువాత, కమాండ్ లైన్ ఆర్గ్యుమెంట్ విలువలను కలిగి ఉన్న శ్రేణిని మళ్ళించడానికి ఒక ఫర్ లూప్ ఉపయోగించబడుతుంది. శ్రేణిలోని ప్రతి మూలకం `కట్` ఆదేశాన్ని ఉపయోగించి కీ-విలువ జతగా విభజించబడింది. తరువాత, కేస్ స్టేట్‌మెంట్ కీ విలువ ఆధారంగా నిర్దిష్ట సందేశాన్ని ముద్రించడానికి ఉపయోగించబడుతుంది.
cl2.sh
. #! /am/బాష్#ఆర్గ్యుమెంట్ వేరియబుల్స్ ముద్రించండి
బయటకు విసిరారు 'వాదన విలువలు: $ 1 $ 2'
#లూప్ కోసం ఉపయోగించి ప్రతి వాదనను విడిగా చదవండి
కోసంకోపంలో '[ఇమెయిల్ రక్షించబడింది]'
చేయండి
#వాదన పేరు మరియు విలువ వేరు
కీ= $(బయటకు విసిరారు $ ఆర్గ్ | కట్ -f1 -డి=)
విలువ= $(బయటకు విసిరారు $ ఆర్గ్ | కట్ -f2 -డి=)
ఆర్గ్యుమెంట్ పేరు ఆధారంగా #ముద్రణ సందేశం
కేసు $ కీ లో
పేరు) బయటకు విసిరారు 'విద్యార్థి పేరు =$ విలువ';;
గుర్తు) బయటకు విసిరారు 'పొందిన మార్క్ =$ విలువ' ;;
*)
esac
పూర్తి
అవుట్పుట్:
కింది కమాండ్ లైన్ ఆర్గ్యుమెంట్‌లతో స్క్రిప్ట్‌ను అమలు చేయండి.
$బాష్cl2.shపేరు= అబీర్ హుస్సేన్గుర్తు=90పై ఆదేశాలలో రెండు కమాండ్ లైన్ ఆర్గ్యుమెంట్‌లు అందించబడ్డాయి. ఇవి పేరు = అబీర్ హోస్సేన్ మరియు గుర్తు = 90 . పేరు మరియు మార్కులు స్క్రిప్ట్ ద్వారా వేరు చేయబడతాయి మరియు అవుట్పుట్ ఫార్మాట్ చేసిన తర్వాత రెండు విలువలు ముద్రించబడతాయి.
ఉపయోగించి కమాండ్ లైన్ ఆర్గ్యుమెంట్‌లను ప్రాసెస్ చేస్తోంది గెటాప్‌లు ఈ ట్యుటోరియల్‌లో ఫంక్షన్ చర్చించబడలేదు. మీరు ఉపయోగించడం ద్వారా కమాండ్ లైన్ ప్రాసెసింగ్ గురించి తెలుసుకోవాలనుకుంటే గెటాప్‌లు ఫంక్షన్ అప్పుడు మీరు సందర్శించవచ్చు ఈ ట్యుటోరియల్ .
అంకగణితం
అంకగణిత ఆపరేషన్ చేయడం అనేది ఏదైనా ప్రోగ్రామింగ్ భాష యొక్క సాధారణ అవసరం. బాష్ మరో ప్రామాణిక ప్రోగ్రామింగ్ లాంగ్వేజ్ కంటే భిన్నమైన రీతిలో అంకగణిత ఆపరేషన్ చేస్తుంది. బాష్‌లో అంకగణిత కార్యకలాపాలు చేయడానికి అనేక మార్గాలు ఉన్నాయి. అంకగణిత ఆపరేషన్ చేసే సాధారణ మార్గాలలో ఒకటి ఈ విభాగంలో చూపబడింది. కింది స్క్రిప్ట్‌తో బాష్ ఫైల్‌ను సృష్టించండి. ఈ స్క్రిప్ట్‌లో నాలుగు రకాల అంకగణిత కార్యకలాపాలు చూపబడ్డాయి. స్క్రిప్ట్ ప్రారంభంలో డబుల్ ఫస్ట్ బ్రాకెట్లను ఉపయోగించడం ద్వారా ఒక సాధారణ సమ్మషన్ మరియు డివిజన్ ఆపరేషన్లు చూపబడతాయి. తరువాత, ప్రీ-ఇంక్రిమెంట్ ఆపరేషన్ చూపబడింది. చివరగా, స్క్రిప్ట్ చివరి భాగంలో షార్ట్ హ్యాండ్ ఆపరేటర్‌ను ఉపయోగించే మార్గం చూపబడింది.
arith.sh
#!/బిన్/బాష్# మొత్తాన్ని లెక్కించండి
ఫలితం= $((యాభై+25))
# సమ్మషన్ విలువను ముద్రించండి
బయటకు విసిరారు మొత్తం =$ ఫలితం'
# విభజనను లెక్కించండి
ఫలితం= $((యాభై/25))
# విభజన విలువను ముద్రించండి
బయటకు విసిరారు 'విభజన =$ ఫలితం'
# N కి విలువను కేటాయించండి
ఎన్=10
# ప్రీ-ఇంక్రిమెంట్ చేయడం
((--ఎన్))
# N విలువను ముద్రించండి
బయటకు విసిరారు 'తగ్గింపు తర్వాత విలువ =$ N'
# షార్ట్‌హ్యాండ్ ఆపరేటర్‌ను ఉపయోగించడం
((N +=10 ))
# N విలువను ముద్రించండి
బయటకు విసిరారు 10 = జోడించిన తర్వాత విలువ$ N'
అవుట్పుట్:
స్క్రిప్ట్ రన్ చేయండి.
$బాష్arith.shస్క్రిప్ట్ అమలు చేసిన తర్వాత కింది అవుట్పుట్ కనిపిస్తుంది.
ఈ పై స్క్రిప్ట్‌లో డబుల్ బ్రాకెట్లను ఉపయోగించడం ద్వారా అన్ని అంకగణిత కార్యకలాపాలు జరుగుతాయి. కానీ మీరు ఉపయోగించవచ్చు ' వీలు ',' expr 'మరియు' bc 'బాష్‌లో అంకగణిత ఆపరేషన్ చేయాలని ఆదేశం. మీరు బాష్ అంకగణిత కార్యకలాపాల కోసం ఈ ఆదేశాల గురించి మరింత తెలుసుకోవాలనుకుంటే, మీరు ఈ ట్యుటోరియల్‌ని సందర్శించవచ్చు.
స్ట్రింగ్ మానిప్యులేషన్
బాష్‌లోని స్ట్రింగ్ డేటాతో అనేక రకాల పనులు చేయవచ్చు. కొన్ని స్ట్రింగ్‌ని పోల్చడం, స్ట్రింగ్‌ను పోల్చడం, స్ట్రింగ్‌ను విభజించడం, స్ట్రింగ్ కేసును మార్చడం మొదలైనవి. ఈ ట్యుటోరియల్ యొక్క ఈ విభాగంలో కొన్ని సాధారణ స్ట్రింగ్ అవకతవకలు చర్చించబడ్డాయి.
కాంకటేటింగ్ స్ట్రింగ్
రెండు లేదా అంతకంటే ఎక్కువ తీగలను కలపడాన్ని స్ట్రింగ్ కాన్కాంటేషన్ అంటారు. స్ట్రింగ్ ఒకదాని తర్వాత ఒకటి ఉంచడం ద్వారా బాష్‌లో కలిసి ఉంటుంది. స్ట్రింగ్ కాంకెనేషన్ వినియోగాన్ని చూపించడానికి కింది స్క్రిప్ట్‌తో బాష్ ఫైల్‌ను సృష్టించండి. రెండు స్ట్రింగ్ వేరియబుల్స్ ప్రారంభించబడ్డాయి మరియు వేరియబుల్స్ కలిపిన తర్వాత ప్రింట్ చేయబడతాయి. ఇక్కడ, కంటెంట్ $ స్ట్రింగ్ 1 మరియు $ స్ట్రింగ్ 2 విలీనం మరియు ముద్రించబడతాయి.
concat.sh
#!/బిన్/బాష్#మొదటి స్ట్రింగ్ వేరియబుల్‌ను ప్రారంభించండి
స్ట్రింగ్ 1='నాకు ఇష్టం '
#రెండవ స్ట్రింగ్ వేరియబుల్‌ను ప్రారంభించండి
స్ట్రింగ్ 2='బాష్ ప్రోగ్రామింగ్'
#రెండు తీగలను కలిపిన తర్వాత ముద్రించండి
బయటకు విసిరారు '$ స్ట్రింగ్ 1$ స్ట్రింగ్ 2'
అవుట్పుట్:
స్క్రిప్ట్ రన్ చేయండి.
$బాష్concat.shస్క్రిప్ట్ అమలు చేసిన తర్వాత కింది అవుట్పుట్ కనిపిస్తుంది.
మీరు ఈ ట్యుటోరియల్ నుండి స్ట్రింగ్ కాన్కాంటేషన్ గురించి మరింత తెలుసుకోవచ్చు.
స్ట్రింగ్‌ని పోల్చడం
స్ట్రింగ్ డేటాను పోల్చడానికి బాష్ వివిధ రకాల ఆపరేటర్‌లను ఉపయోగిస్తుంది. రెండు స్ట్రింగ్ డేటాను ఎలా సరిపోల్చాలో చూపడానికి క్రింది స్క్రిప్ట్‌తో బాష్ ఫైల్‌ను సృష్టించండి. స్ట్రింగ్ విలువ మరొక స్ట్రింగ్‌తో పోల్చిన స్క్రిప్ట్‌లో ఇన్‌పుట్‌గా తీసుకోబడుతుంది. విలువ సరిపోలితే ఒక సందేశం, మీకు పైథాన్ అంటే ఇష్టం లేకపోతే ముద్రించబడుతుంది మీకు పెర్ల్ అంటే ఇష్టం ముద్రించబడుతుంది.
సరిపోల్చండి. s
#!/బిన్/బాష్బయటకు విసిరారుఏదైనా స్ట్రింగ్ విలువను నమోదు చేయండి
చదవండిటెక్స్ట్
#ఇన్పుట్ డేటా పైథాన్‌తో సమానమని తనిఖీ చేయండి
ఉంటే [ $ టెక్స్ట్=='పైథాన్' ];అప్పుడు
బయటకు విసిరారు 'మీకు పైథాన్ అంటే ఇష్టం.'
లేకపోతే
బయటకు విసిరారు 'మీకు పెర్ల్ అంటే ఇష్టం'
ఉంటుంది
అవుట్పుట్:
స్క్రిప్ట్ రన్ చేయండి.
$బాష్సరిపోల్చండి. sఇన్పుట్ విలువ 'PERL' ఉన్న స్క్రిప్ట్‌ను అమలు చేసిన తర్వాత కింది అవుట్పుట్ కనిపిస్తుంది.
నుండి స్ట్రింగ్ పోలిక గురించి మీరు మరింత తెలుసుకోవచ్చు ఈ ట్యుటోరియల్ .
విభజన స్ట్రింగ్
స్ట్రింగ్ డేటాను విభజించడానికి బాష్‌లో అంతర్నిర్మిత స్ప్లిట్ ఫంక్షన్ లేదు. స్ట్రింగ్ డేటాను వివిధ రకాల డీలిమిటర్‌ల ఆధారంగా బాష్‌లో అనేక విధాలుగా విభజించవచ్చు. స్ట్రింగ్ డేటాను బాష్‌గా ఎలా విభజించవచ్చో చూపించడానికి క్రింది స్క్రిప్ట్‌తో బాష్ ఫైల్‌ను సృష్టించండి. స్ట్రింగ్ విలువ ఇన్‌పుట్‌గా తీసుకోబడుతుంది. ఈ స్క్రిప్ట్ విలువను విభజిస్తుంది $ టెక్స్ట్ స్థలం ఆధారంగా. ఇక్కడ, ది IFS వేరియబుల్ డీలిమిటర్ సెట్ చేయడానికి ఉపయోగించబడుతుంది. `చదవండి` కమాండ్ టెక్స్ట్ విలువను విభజించడానికి మరియు విలువలను శ్రేణిలో నిల్వ చేయడానికి ఇక్కడ ఉపయోగించబడుతుంది. కోసం లూప్ శ్రేణిని మళ్ళించడానికి మరియు ప్రతి మూలకం యొక్క విలువను ముద్రించడానికి ఉపయోగించబడుతుంది.
స్ప్లిట్.ష్
#!/బిన్/బాష్#స్ట్రింగ్ విలువను ఇన్పుట్ చేయండి
బయటకు విసిరారుస్ట్రింగ్ విలువను నమోదు చేయండి
చదవండిటెక్స్ట్
# డీలిమిటర్ సెట్ చేయండి
IFS=''
#స్పేస్ డీలిమిటర్ ఆధారంగా $ టెక్స్ట్ విలువను శ్రేణిగా విభజించండి
చదవండి -వరకుఅరె<<< '$ టెక్స్ట్'
# శ్రేణి యొక్క ప్రతి విలువను ముద్రించండి
కోసంవిలువలో '$ {arr [@]}';
చేయండి
printf '$ విలువ n'
పూర్తి
అవుట్పుట్:
స్క్రిప్ట్ రన్ చేయండి.
$బాష్స్ప్లిట్.ష్ఇన్పుట్ తీసుకున్న తర్వాత కింది అవుట్పుట్ కనిపిస్తుంది, బాష్ ప్రోగ్రామింగ్ నేర్చుకోండి . ఈ ఇన్పుట్ విలువ మూడు పదాల టెక్స్ట్. కాబట్టి, స్ట్రింగ్ మూడు భాగాలుగా విభజించబడింది.
నుండి స్ట్రింగ్ పోలిక గురించి మీరు మరింత తెలుసుకోవచ్చు ఈ ట్యుటోరియల్ .
స్ట్రింగ్ కేసును మార్చడం
స్ట్రింగ్ డేటా కేసును మార్చడానికి చాలా స్క్రిప్టింగ్ భాషలలో అంతర్నిర్మిత విధులు ఉన్నాయి. కానీ స్ట్రింగ్ డేటా కేసును ఉపయోగించడం ద్వారా బాష్‌లో మార్చవచ్చు `tr` ఆదేశం లేదా ఉపయోగించడం ద్వారా ': ఎగువ' మరియు ': తక్కువ' కీలకపదాలు. బాష్‌లో కేసును మార్చే మార్గాలను తెలుసుకోవడానికి కింది స్క్రిప్ట్‌తో బాష్ ఫైల్‌ను సృష్టించండి. ఇక్కడ, మొదటి స్ట్రింగ్ డేటా ఉపయోగించి పెద్ద అక్షరానికి మార్చబడుతుంది '^^' గుర్తు మరియు రెండవ స్ట్రింగ్ ఉపయోగించడం ద్వారా చిన్న అక్షరానికి మార్చబడుతుంది `tr` కమాండ్ `tr` కమాండ్ స్ట్రింగ్‌లోని అన్ని పెద్ద అక్షరాలను శోధిస్తుంది మరియు అక్షరాలను చిన్న అక్షరంగా మారుస్తుంది.
కేసు. ఎస్
#!/బిన్/బాష్#మొదటి స్ట్రింగ్ డేటాను ప్రారంభించండి
టెక్స్ట్ 1='[ఇమెయిల్ రక్షించబడింది]'
#అక్షరాలన్నింటినీ పెద్ద అక్షరాలకు మార్చడం ద్వారా $ text1 విలువను ముద్రించండి
బయటకు విసిరారు $ {ఇమెయిల్ ^^}
#రెండవ స్ట్రింగ్ డేటాను ప్రారంభించండి
టెక్స్ట్ 2= 'బాష్ ప్రోగ్రామింగ్ బేసిక్స్'
#అన్ని పెద్ద అక్షరాలను చిన్న అక్షరాలకు మార్చడం ద్వారా $ టెక్స్ట్ 2 విలువను ముద్రించండి
బయటకు విసిరారు $ టెక్స్ట్ 2 | NS [: ఎగువ:] [: తక్కువ:]
అవుట్పుట్:
స్క్రిప్ట్ రన్ చేయండి.
$బాష్కేసు. ఎస్స్క్రిప్ట్ అమలు చేసిన తర్వాత కింది అవుట్పుట్ కనిపిస్తుంది.
నుండి స్ట్రింగ్ పోలిక గురించి మీరు మరింత తెలుసుకోవచ్చు ఈ ట్యుటోరియల్ .
లూప్ ద్వారా స్ట్రింగ్ డేటాను చదవడం
స్ట్రింగ్ డేటా ఏదైనా ప్రోగ్రామింగ్ లాంగ్వేజ్ కోసం అక్షర శ్రేణిగా పనిచేస్తుంది. ఎలా ' కోసం ఈ విభాగంలో బాష్‌లో స్ట్రింగ్ డేటాను చదవడానికి లూప్ ఉపయోగించవచ్చు. లూప్ కోసం ఉపయోగించడం ద్వారా స్ట్రింగ్ విలువలోని ప్రతి భాగాన్ని చదవడానికి కింది స్క్రిప్ట్‌తో ఒక బేస్ ఫైల్‌ని సృష్టించండి.
readstr.sh
#!/బిన్/బాస్# లూప్ కోసం ఉపయోగించడం ద్వారా టెక్స్ట్ యొక్క ప్రతి పదాన్ని చదవండి
కోసంవిలువలోబాష్ ప్రోగ్రామింగ్కోసంబిగినర్స్
చేయండి
బయటకు విసిరారు $ విలువ
పూర్తి
అవుట్పుట్:
స్క్రిప్ట్ రన్ చేయండి.
$బాష్readstr.shస్క్రిప్ట్ అమలు చేసిన తర్వాత కింది అవుట్పుట్ కనిపిస్తుంది.
నుండి లూప్‌ని ఉపయోగించడం ద్వారా స్ట్రింగ్ డేటాను మళ్ళించడం గురించి మీరు మరింత తెలుసుకోవచ్చు ఈ ట్యుటోరియల్ .
టాప్ కి వెళ్ళు
స్క్రిప్ట్ నుండి రిటర్న్ కోడ్‌లను తిరిగి ఇవ్వడం మరియు మరొక లిపిలో పట్టుకోవడం
ఒక బాష్ స్క్రిప్ట్ స్క్రిప్ట్ కాల్ చేయడం మరియు ఉపయోగించడం ద్వారా మరొక స్క్రిప్ట్ నుండి రిటర్న్ కోడ్‌లను క్యాచ్ చేయవచ్చు '$?' తిరిగి విలువ చదవడానికి. అనుకోండి, ఒక బాష్ ఫైల్ పేరు పెట్టబడింది first.sh అమలు చేసిన తర్వాత కోడ్‌ను అందిస్తుంది. పేరుతో మరొక బాష్ ఫైల్‌ను సృష్టించండి రెండవ.ష మరియు తిరిగి విలువను పట్టుకోవడానికి మరియు కొన్ని ఇతర పనులను చేయడానికి క్రింది స్క్రిప్ట్‌ను జోడించండి. రెండు ఫైళ్ల కోడ్ క్రింద ఇవ్వబడింది. first.sh ఫైల్ నుండి కాల్ చేయబడుతుంది రెండవ.ష స్క్రిప్ట్ ప్రారంభంలో ఫైల్. first.sh ఇన్పుట్ విలువ ఆధారంగా నిష్క్రమణ కోడ్‌ను అందిస్తుంది. సెకండ్.ఎస్ కోడ్‌ను క్యాచ్ చేస్తుంది '$?' మరియు 1 తో సరిపోల్చండి. రెండు విలువలు సమానంగా ఉంటే అది ముద్రించబడుతుంది, ఇన్పుట్ సంఖ్య 100 కంటే ఎక్కువ లేకపోతే అది ముద్రించబడుతుంది, ఇన్పుట్ సంఖ్య 100 కంటే తక్కువ లేదా సమానం .
first.sh
#!/బిన్/బాష్బయటకు విసిరారు 'సంఖ్యా విలువను నమోదు చేయండి'
చదవండిఎన్
# ఇన్పుట్ విలువ 100 కంటే తక్కువ లేదా సమానంగా ఉందో లేదో తనిఖీ చేయండి
ఉంటే [[ $ n -ది 100 ]]
అప్పుడు
బయటకి దారి 0
లేకపోతే
బయటకి దారి 1
ఉంటుంది
రెండవ.ష
#! /బిన్/బాష్#ఫైల్‌ను అమలు చేయండి, first.sh
బాష్ 'first.sh'
#రిటర్న్ కోడ్ 1 కి సమానమో కాదో చెక్ చేయండి
ఉంటే [ $? -ఎక్యూ 1 ]
అప్పుడు
బయటకు విసిరారు 'ఇన్పుట్ నంబర్ 100 కంటే ఎక్కువ'
లేకపోతే
బయటకు విసిరారు 'ఇన్పుట్ సంఖ్య 100 కంటే తక్కువ లేదా సమానం'
ఉంటుంది
అవుట్పుట్:
స్క్రిప్ట్ రన్ చేయండి.
$బాష్రెండవ.షస్క్రిప్ట్ను 55 మరియు 110 ద్వారా రెండుసార్లు అమలు చేసినప్పుడు కింది అవుట్పుట్ కనిపిస్తుంది.
ఫైల్స్ చదవడం మరియు రాయడం
ఫైల్స్ చదవడం మరియు రాయడం అనేది బాష్ ప్రోగ్రామింగ్ యొక్క సాధారణ అవసరాలు. ఫైల్‌ని చదవడానికి లేదా వ్రాయడానికి బాష్‌కు వేరే భాషలాంటి అంతర్నిర్మిత ఫంక్షన్ లేదు. బాష్‌లో ఫైల్‌ను చదవడానికి అనేక మార్గాలు ఉన్నాయి. బాష్‌లో ఫైల్‌ను చదవడానికి లేదా వ్రాయడానికి అత్యంత సాధారణ మార్గం `పిల్లి` కమాండ్ కానీ ఈ ఆదేశం ఫైల్ యొక్క మొత్తం కంటెంట్‌ను ఒకేసారి చదవడానికి ఉపయోగించబడుతుంది. మీరు ఏదైనా లూప్‌ను ఉపయోగించడం ద్వారా ఏదైనా ఫైల్ లైన్‌ను లైన్ ద్వారా కూడా చదవవచ్చు మరియు `చదవండి` కమాండ్ దారిమార్పు ఆపరేటర్‌ని ఉపయోగించి, '>' , మీరు బాష్‌లోని ఏదైనా ఫైల్‌లో డేటాను వ్రాయవచ్చు. మీరు ఏదైనా ఫైల్‌లో డేటాను జోడించాలనుకుంటే, మీరు ఉపయోగించాల్సి ఉంటుంది '>>' ఆపరేటర్. పఠనం మరియు వ్రాత ఫైల్ కార్యకలాపాలు రెండూ ఈ విభాగం యొక్క తదుపరి భాగంలో చూపబడ్డాయి.
బాష్‌లో ఫైల్‌ని చదువుతోంది
ఇప్పటికే ఉన్న ఫైల్‌ను చదవడానికి కింది స్క్రిప్ట్‌తో బాష్ ఫైల్‌ని సృష్టించండి hardware.txt '. ఈ ఫైల్ యొక్క కంటెంట్ క్రింద ఇవ్వబడింది. స్క్రిప్ట్‌లో, ఫైల్ యొక్క మొత్తం కంటెంట్ ద్వారా చదవబడుతుంది `పిల్లి` మొదటి మరియు తరువాత ఆదేశం, అయితే లూప్ ఫైల్ లైన్‌ను లైన్ ద్వారా చదవడానికి ఉపయోగించబడుతుంది.
hardware.txt
మానిటర్కీబోర్డ్
మౌస్
స్కానర్
ప్రింటర్
readfile.sh
#!/బిన్/బాష్బయటకు విసిరారు 'పిల్లి ఆదేశాన్ని ఉపయోగించి ఫైల్‌ని చదవడం'
# `Cat` ఆదేశాన్ని ఉపయోగించి ఫైల్ కంటెంట్‌ని చదవండి
విషయము='పిల్లిhardware.txt'
బయటకు విసిరారు $ కంటెంట్
బయటకు విసిరారు 'లూప్‌ని ఉపయోగించి లైన్ ద్వారా ఫైల్‌ని చదవడం'
# ఫైల్ పేరు కేటాయించండి
ఫైల్ పేరు='hardware.txt'
# లూప్ యొక్క ప్రతి పునరుక్తి ద్వారా ఫైల్ యొక్క ప్రతి పంక్తి చదవబడుతుంది
అయితే చదవండిలైన్;
చేయండి
# లైన్ ప్రింట్ చేయండి
బయటకు విసిరారు $ లైన్
పూర్తి<$ ఫైల్ పేరు
అవుట్పుట్:
కింది ఆదేశాలను అమలు చేయండి.
$పిల్లిhardware.txt$బాష్readfile.sh
ఇక్కడ, మొదటి కమాండ్ ఫైల్ యొక్క కంటెంట్‌ను ప్రింట్ చేస్తుంది, hardware.txt ఏ బాష్ స్క్రిప్ట్‌ను అమలు చేయకుండా మరియు రెండవ కమాండ్ స్క్రిప్ట్‌ను అమలు చేస్తుంది readfile.sh మరియు ఉపయోగించి ఫైల్ యొక్క కంటెంట్‌ను రెండు సార్లు ప్రింట్ చేయండి `పిల్లి` ఆదేశం మరియు `చదవండి` అయితే లూప్‌తో ఆదేశం. మీరు దీనిని సందర్శించవచ్చు ట్యుటోరియల్ లైన్ ద్వారా ఫైల్ చదవడం గురించి మరింత తెలుసుకోవడానికి.
బాష్‌లో ఫైల్ రాయడం
కొత్త ఫైల్‌లో కొత్త కంటెంట్‌ని వ్రాయడానికి మరియు ఆ ఫైల్‌లో డేటాను జోడించడానికి కింది స్క్రిప్ట్‌తో బాష్ ఫైల్‌ను సృష్టించండి.
Writfile.sh
#!/బిన్/బాష్బయటకు విసిరారు 'కొంత వచనాన్ని నమోదు చేయండి'
#స్ట్రింగ్ డేటాను చదవండి
చదవండిstr1
#మొదటిసారిగా ఫైల్‌లో ఇన్పుట్ డేటాను జోడించండి
బయటకు విసిరారు $ str1 >test.txt
బయటకు విసిరారు 'ఇంకొక వచనాన్ని నమోదు చేయండి'
#మరొక స్ట్రింగ్ డేటాను చదవండి
చదవండిstr2
#ఫైల్ చివర ఇన్పుట్ డేటాను జోడించండి
బయటకు విసిరారు $ str2 >>test.txt
#ఫైల్ యొక్క పూర్తి కంటెంట్‌ను చూపించు
బయటకు విసిరారు 'పిల్లిtest.txt'
అవుట్పుట్:
స్క్రిప్ట్ రన్ చేయండి.
$బాష్Writfile.shస్క్రిప్ట్ అమలు చేసిన తర్వాత కింది అవుట్పుట్ కనిపిస్తుంది.
గొట్టాలు
ఏదైనా కమాండ్ అవుట్‌పుట్‌ను ఇతర కమాండ్ ఇన్‌పుట్‌కు మళ్ళించడానికి పైప్ ఉపయోగించబడుతుంది. నిర్దిష్ట అవుట్‌పుట్‌ను రూపొందించడానికి వివిధ రకాల బాష్ ఆదేశాల మధ్య దీనిని ఉపయోగించవచ్చు. ప్రామాణిక ఇన్పుట్ పైపు ద్వారా లైనక్స్‌లో ప్రామాణిక అవుట్‌పుట్‌తో కనెక్ట్ చేయబడింది. కావలసిన అవుట్పుట్ పొందడానికి మీరు పైప్ (|) గుర్తుతో కమాండ్‌ను వరుసగా సెట్ చేయాలి. పైప్ ఉపయోగించి రెండు లేదా అంతకంటే ఎక్కువ కమాండ్‌లను ఒకే కమాండ్‌లో అమలు చేయవచ్చు. ఒకే పని చేయడానికి మీరు పైపు లేకుండా బహుళ లైన్లలో బహుళ ఆదేశాలను అమలు చేయాలి. కాబట్టి, అనేక రకాలైన పనులను చిన్న రూపంలో చేయడానికి పైపును ఉపయోగించడం చాలా ప్రయోజనకరంగా ఉంటుంది.
వాక్యనిర్మాణం:
ఆదేశం 1|ఆదేశం 2|...ఇక్కడ, కమాండ్ 1 యొక్క అవుట్పుట్ కమాండ్ 2 యొక్క ఇన్‌పుట్‌గా పాస్ చేయబడుతుంది.
ఈ విభాగం యొక్క తదుపరి భాగంలో పైపుతో మరియు పైపు లేకుండా ఒకే రకమైన పని జరుగుతుంది. అనే టెక్స్ట్ ఫైల్ అనుకుందాం మార్కులు. టెక్స్ట్ కింది డేటాతో ఇవ్వబడింది.
మార్కులు. టెక్స్ట్
అస్రాఫ్ CSE-409 79కబీర్ CSE-304 95
కీ CSE-101 67
అస్రాఫ్ CSE-304 88
కీ CSE-409 90
అస్రాఫ్ CSE-101 92
మీరు ఫైల్ యొక్క డేటాను క్రమబద్ధీకరించాలి మరియు విద్యార్థి పేరు 'K' యొక్క ఎంట్రీని కనుగొని ప్రింట్ చేయాలి అవును ' . తదుపరి విభాగంలో చూపిన పైపును ఉపయోగించకుండా మీరు బహుళ ఆదేశాలను అమలు చేయడం ద్వారా ఈ పనిని చేయవచ్చు. కావలసిన అవుట్పుట్ పొందడానికి కింది ఆదేశాలను అమలు చేయాలి. మొదటి ఆదేశం ఫైల్‌ను క్రమబద్ధీకరిస్తుంది. రెండవ కమాండ్ ఎంట్రీ ‘K’ ని శోధిస్తుంది అవును ' ఉపయోగించి` పట్టు కమాండ్ మరియు అవుట్‌పుట్‌ను నిల్వ చేయండి ఒక temp.txt ఫైల్. మూడవ ఆదేశం a యొక్క మొత్తం పంక్తులను లెక్కిస్తుంది temp.txt ఉపయోగించి ఫైల్ `wc` కమాండ్
$క్రమబద్ధీకరించుమార్కులు. టెక్స్ట్$పట్టు 'కేయా'మార్కులు. టెక్స్ట్>temp.txt
$wc -దిtemp.txt
అవుట్పుట్:
విద్యార్థి యొక్క రెండు ఎంట్రీలు, ‘కేయా’ ఫైల్‌లో ఉన్నాయి. కాబట్టి పై ఆదేశాలను అమలు చేసిన తర్వాత, కింది అవుట్పుట్ కనిపిస్తుంది.
మీరు పై మూడు ఆదేశాలను సులభంగా విలీనం చేయవచ్చు మరియు కింది ఆదేశంలో చూపిన పైపుతో ఒకే ఆదేశాన్ని అమలు చేయడం ద్వారా అదే అవుట్‌పుట్‌ను పొందవచ్చు. అవుట్పుట్ పొందడానికి ఇక్కడ తాత్కాలిక ఫైల్ అవసరం లేదు. ఇక్కడ, `యొక్క అవుట్పుట్ క్రమబద్ధీకరించు `కమాండ్ ఇన్‌పుట్‌గా పంపబడుతుంది పట్టు `కమాండ్ మరియు అవుట్పుట్` పట్టు `కమాండ్ ఇన్‌పుట్‌గా పంపబడుతుంది `wc` కమాండ్
$క్రమబద్ధీకరించుమార్కులు. టెక్స్ట్| పట్టు 'కేయా' | wc -దిఅవుట్పుట్:
ఎగువ ఆదేశాన్ని అమలు చేస్తున్న Afttr మునుపటి కమాండ్ యొక్క అవుట్పుట్ వంటి కింది అవుట్పుట్ మీకు లభిస్తుంది. కమాండ్ యొక్క అవుట్పుట్ 2 అవుతుంది.
ముగింపు:
బాష్ స్క్రిప్టింగ్ భాష యొక్క అత్యంత ఉపయోగకరమైన మరియు అవసరమైన విషయాలు ఈ ట్యుటోరియల్‌లో కవర్ చేయడానికి ప్రయత్నించబడ్డాయి. ఆశిస్తున్నాము, ఈ ట్యుటోరియల్ చదివిన తర్వాత మరియు బాష్ స్క్రిప్ట్‌ను మరింత సమర్ధవంతంగా వ్రాయగలిగిన తర్వాత పాఠకుడు ప్రయోజనం పొందుతాడు.