ముందస్తు అవసరాలు:
ఈ గైడ్‌లో ప్రదర్శించబడిన దశలను నిర్వహించడానికి, మీకు ఈ క్రింది భాగాలు అవసరం:
- ఒక ఫంక్షనల్ Linux సిస్టమ్. గురించి మరింత తెలుసుకోవడానికి VirtualBoxని ఉపయోగించి Ubuntu VMని సెటప్ చేయడం .
- a కి యాక్సెస్ సుడో ప్రత్యేక హక్కుతో రూట్ కాని వినియోగదారు .
- తగిన టెక్స్ట్ ఎడిటర్. ఉదాహరణకి: ఎందుకు / నియోవిమ్ , నానో , ఉత్కృష్టమైన వచనం , VSCodium , మొదలైనవి
ఎగ్జిక్యూటివ్ కమాండ్
exec కమాండ్ దానికదే ప్రత్యేక సాధనం కాదు:
$ ఏది కార్యనిర్వాహకుడు
బదులుగా, ఇది బాష్ షెల్ యొక్క అంతర్గత ఆదేశం:
$ మనిషి కార్యనిర్వాహకుడు
మ్యాన్ పేజీ నుండి వివరణ సూచించినట్లుగా, ఒక ఆదేశం పేర్కొనబడితే, exec దానితో షెల్‌ను భర్తీ చేస్తుంది, అదనపు ప్రక్రియ ఏదీ ఉండదు. exec కమాండ్ యొక్క ప్రవర్తనను సవరించే కొన్ని ఎంపికలు అందుబాటులో ఉన్నాయి.
ప్రాథమిక వినియోగం
డిఫాల్ట్‌గా, కమాండ్‌ని అమలు చేస్తున్నప్పుడల్లా, బాష్ సబ్‌షెల్‌ను సృష్టిస్తుంది మరియు ఆదేశాన్ని ఫోర్క్ చేస్తుంది.
$ ప్రతిధ్వని $$ && నిద్ర 999 
ఇక్కడ, echo కమాండ్ ప్రస్తుత షెల్ యొక్క PIDని ప్రింట్ చేస్తుంది. బాష్ షెల్ (PID: 978) స్లీప్ కమాండ్ (PID: 8369)తో పని చేయడానికి ఒక కొత్త చైల్డ్ ప్రాసెస్‌ను అందిస్తుంది.
ఇప్పుడు, మనం స్లీప్ కమాండ్‌ను exec ఉపయోగించి అమలు చేస్తే?
$ ప్రతిధ్వని $$ && కార్యనిర్వాహకుడు నిద్ర 999 
పేరెంట్ బాష్ ప్రక్రియ స్లీప్ కమాండ్ ద్వారా భర్తీ చేయబడుతుంది. విజయవంతంగా అమలు చేయబడిన తర్వాత, అది షెల్‌కు తిరిగి రాదు. బదులుగా, సెషన్ రద్దు చేయబడింది.
స్వచ్ఛమైన పర్యావరణం
డిఫాల్ట్ బాష్ కాన్ఫిగరేషన్ ట్వీక్‌లు మరియు ఎన్విరాన్మెంట్ వేరియబుల్స్‌తో వస్తుంది. నిర్దిష్ట దృష్టాంతంలో (డీబగ్గింగ్, ఉదాహరణకు), మీరు మీ స్క్రిప్ట్/ప్రోగ్రామ్‌ను శుభ్రమైన వాతావరణంలో అమలు చేయాలనుకోవచ్చు. ఎగ్జిక్యూటివ్ సహాయంతో, మేము ప్రస్తుతానికి బదులుగా క్లీన్ షెల్ ఉదాహరణను ప్రారంభించవచ్చు.
ముందుగా, ప్రస్తుతం కాన్ఫిగర్ చేయబడిన అన్ని ఎన్విరాన్మెంట్ వేరియబుల్స్ జాబితా చేయడానికి printenv ఆదేశాన్ని ఉపయోగించండి:
$ ప్రింటెంవ్ 
ఇప్పుడు, క్లీన్ ఇన్‌స్టాన్స్‌ని ప్రారంభించడానికి execని ఉపయోగించండి:
$ కార్యనిర్వాహకుడు -సి బాష్$ printenv
విభిన్న షెల్‌ను ప్రారంభిస్తోంది
బాష్ మరియు 'sh' కాకుండా, అనేక ఇతర షెల్ ప్రోగ్రామ్‌లు అందుబాటులో ఉన్నాయి, ఒక్కొక్కటి వాటి ప్రత్యేక పెర్క్‌లతో ఉంటాయి. ప్రోగ్రామ్/స్క్రిప్ట్‌కి నిర్దిష్ట షెల్ అవసరమైతే, మీరు ప్రస్తుత బాష్ షెల్‌ను కావలసిన దానితో భర్తీ చేయడానికి execని ఉపయోగించవచ్చు.
కింది ఉదాహరణలో, మేము బాష్‌ని “sh”తో భర్తీ చేస్తాము:
$ pstree -p$ కార్యనిర్వాహకుడు sh
$ pstree -p
స్క్రిప్ట్‌లలో Execని ఉపయోగించడం
ప్రాథమిక అంశాలు అందుబాటులోకి రావడంతో, మనం ఇప్పుడు మన షెల్ స్క్రిప్ట్‌లలో execని ఉపయోగించడం ప్రారంభించవచ్చు.
ఉదాహరణ 1: వివిధ షెల్‌లతో పని చేయడం
కింది స్క్రిప్ట్‌ని తనిఖీ చేయండి:
#!/బిన్/బాష్ప్రతిధ్వని $SHELL
ప్రతిధ్వని 'echo zsh విజయవంతంగా ప్రారంభించబడింది' > zsh.sh
కార్యనిర్వాహకుడు zsh zsh.sh
ఇక్కడ, మొదటి ఎకో కమాండ్ ప్రస్తుత షెల్‌ను ప్రింట్ చేస్తుంది. డిఫాల్ట్‌గా, అది బాష్ అయి ఉండాలి. అప్పుడు, “zsh.sh” స్క్రిప్ట్‌ను అమలు చేయడానికి exec కమాండ్ “zsh”ని ప్రారంభిస్తుంది.
కింది స్క్రిప్ట్‌ను అమలు చేయండి:
$ . / test.sh 
ఉదాహరణ 2: ఇప్పటికే ఉన్న ప్రక్రియను భర్తీ చేయడం
కమాండ్/ప్రోగ్రామ్‌కు కాల్ చేసినప్పుడల్లా, బాష్ కొత్త ప్రక్రియను సృష్టిస్తుంది. చాలా సందర్భాలలో, ఇది ఆందోళన కలిగించే విషయం కాదు. అయినప్పటికీ, చాలా పరిమిత వనరుతో (ఉదాహరణకు పొందుపరిచిన హార్డ్‌వేర్) సిస్టమ్‌తో పని చేస్తున్నప్పుడు, మెమరీలో ఉన్న ప్రక్రియను భర్తీ చేయడానికి execని ఉపయోగించడం సహాయపడుతుంది.
కింది స్క్రిప్ట్‌ని తనిఖీ చేయండి:
#!/బిన్/బాష్pstree -p
కార్యనిర్వాహకుడు pstree -p
ప్రతిధ్వని 'హలో వరల్డ్'
ఇక్కడ, మొదటి pstree కమాండ్ ప్రాసెస్ ట్రీ యొక్క అసలు లేఅవుట్‌ను చూపుతుంది. exec కమాండ్ అమలు చేయబడిన తర్వాత, రెండవ pstree కమాండ్ నడుస్తున్న షెల్‌ను భర్తీ చేస్తుంది. చివరి లైన్‌లోని ఎకో కమాండ్ అమలు కాలేదు.
కింది స్క్రిప్ట్‌ను అమలు చేయండి:
$ . / test.sh 
ఇది స్క్రిప్ట్‌లో భాగం కాబట్టి, విజయవంతంగా అమలు చేయబడిన తర్వాత మేము అసలు షెల్‌కి తిరిగి వస్తాము.
ఎగ్జిక్యూటివ్ కమాండ్ పేరెంట్ షెల్‌ను వేరే కమాండ్/ప్రోగ్రామ్‌తో భర్తీ చేసినందున, దాని తర్వాత ఏదైనా కోడ్ చెల్లదు. వాటిని మీ స్క్రిప్ట్‌లలో ఉపయోగిస్తున్నప్పుడు జాగ్రత్తగా ఉండండి.
ఉదాహరణ 3: లాగింగ్
బాష్ షెల్ ఏదైనా రన్నింగ్ ప్రోగ్రామ్/స్క్రిప్ట్‌కి 3 ప్రత్యేకమైన ఫైల్ డిస్క్రిప్టర్‌లను అందిస్తుంది:
- STDOUT (1): ప్రామాణిక అవుట్‌పుట్, సాధారణ అవుట్‌పుట్‌ను నిల్వ చేస్తుంది
- STDERR (2): ప్రామాణిక లోపం, ఎర్రర్ సందేశాలను నిల్వ చేస్తుంది
- STDIN (0): ప్రామాణిక ఇన్పుట్
execని ఉపయోగించి, మేము ఈ ఫైల్ డిస్క్రిప్టర్‌లను వేరే స్థానానికి దారి మళ్లించవచ్చు, ఉదాహరణకు: లాగ్ ఫైల్‌లు. ఇది సాధారణంగా డీబగ్గింగ్ మరియు లాగింగ్‌లో సహాయపడుతుంది.
సాధారణంగా, మీరు STDOUT మరియు STDERRని లాగ్ ఫైల్‌కి దారి మళ్లించాలనుకుంటే, మీరు దారి మళ్లింపు ఆపరేటర్‌ని ఉపయోగిస్తారు:
$ ప్రతిధ్వని $$ | టీ test.log$ సన్యాసి 2 >& 1 | టీ test.log
మీరు లాగ్ చేయాలనుకుంటున్న ప్రతి పాయింట్ వద్ద ఈ పద్ధతికి దారి మళ్లింపు అవసరం. ఈ సమస్యను పరిష్కరించడానికి, షెల్ సెషన్ కోసం శాశ్వత దారిమార్పును సృష్టించడానికి మేము exec ఆదేశాన్ని ఉపయోగించవచ్చు. కింది ఉదాహరణను పరిశీలించండి:
#!/బిన్/బాష్> test.log
కార్యనిర్వాహకుడు 1 >> test.log
కార్యనిర్వాహకుడు 2 >& 1
ప్రతిధ్వని 'హలో వరల్డ్'
తప్పు_ఆదేశం
ఇక్కడ, మొదటి పంక్తి ఖాళీ లాగ్ ఫైల్‌ను సృష్టిస్తుంది. మొదటి ఎగ్జిక్యూటివ్ కమాండ్ లాగ్ ఫైల్‌కు STDOUT యొక్క శాశ్వత దారిమార్పును ఏర్పాటు చేస్తుంది. రెండవ exec కమాండ్ STDERRని STDOUTకి దారి మళ్లిస్తుంది.
ఈ సెటప్‌తో, అన్ని అవుట్‌పుట్‌లు మరియు దోష సందేశాలు లాగ్ ఫైల్‌లోకి డంప్ చేయబడతాయి:
$ / test.sh$ పిల్లి test.log
స్క్రిప్ట్ నిరంతర లాగ్ ఎంట్రీలను రూపొందిస్తే?
#!/బిన్/బాష్> test.log
కార్యనిర్వాహకుడు 1 >> test.log
కార్యనిర్వాహకుడు 2 >& 1
అయితే నిజం
చేయండి
ప్రతిధ్వని $RANDOM
నిద్ర 5
పూర్తి
ఇక్కడ, మొదటి భాగంలో, మేము మా లాగ్ ఫైల్‌కి STDOUT మరియు STDERR యొక్క శాశ్వత దారి మళ్లింపును సృష్టిస్తాము. 'Ctrl + C'ని ఉపయోగించి మనం బలవంతంగా మూసివేసే వరకు అనంతమైన అయితే లూప్ echo ఆదేశాన్ని అమలు చేస్తుంది. $RANDOM వేరియబుల్ అనేది ఒక ప్రత్యేక వేరియబుల్, ఇది యాక్సెస్ చేయబడిన ప్రతిసారీ యాదృచ్ఛిక స్ట్రింగ్‌ను అందిస్తుంది.
నవీకరిస్తున్న లాగ్ ఎంట్రీని తనిఖీ చేయడానికి, కింది టెయిల్ ఆదేశాన్ని ఉపయోగించండి:
$ తోక -ఎఫ్ test.log 
ఈ దారి మళ్లింపు షెల్ సెషన్‌కు మాత్రమే ఉంటుందని గమనించండి.
ఉదాహరణ 4: ఫైల్ నుండి ఇన్పుట్
మేము శాశ్వత STDOUT మరియు STDERR దారిమార్పులను ఎలా సృష్టించామో అదే విధంగా, మేము STDIN కోసం కూడా ఒకదాన్ని సృష్టించవచ్చు. అయినప్పటికీ, ఇన్పుట్ కోసం STDIN ఉపయోగించబడుతుంది కాబట్టి, అమలు కొంచెం భిన్నంగా ఉంటుంది.
కింది స్క్రిప్ట్‌లో, మేము ఫైల్ నుండి STDINని తీసుకుంటాము:
#!/బిన్/బాష్ప్రతిధ్వని 'ప్రతిధ్వని' హలో వరల్డ్ '' > ఇన్పుట్
కార్యనిర్వాహకుడు < ఇన్పుట్
చదవండి లైన్_1
eval $లైన్_1
ఇక్కడ, మొదటి పంక్తిలో, దారి మళ్లింపును ఉపయోగించి ఇన్పుట్_స్ట్రింగ్ ఫైల్ యొక్క కంటెంట్‌ను రూపొందించడానికి మేము ఎకోను ఉపయోగిస్తాము. exec కమాండ్ input_string యొక్క కంటెంట్‌ను ప్రస్తుత షెల్ సెషన్‌లోని STDINకి దారి మళ్లిస్తుంది. స్ట్రింగ్ చదివిన తర్వాత, మేము $line_1 యొక్క కంటెంట్‌ను షెల్ కోడ్‌గా పరిగణించడానికి evalని ఉపయోగిస్తాము.
కింది స్క్రిప్ట్‌ని అమలు చేయండి:
$ . / test.sh 
ముగింపు
మేము బాష్‌లో ఎగ్జిక్యూటివ్ కమాండ్ గురించి చర్చించాము. మేము దానిని స్క్రిప్ట్‌లలో ఉపయోగించే వివిధ మార్గాలను కూడా ప్రదర్శించాము. మేము బహుళ షెల్‌లతో పని చేయడానికి, మెమరీ సమర్థవంతమైన స్క్రిప్ట్‌లను సృష్టించడానికి మరియు ఫైల్ డిస్క్రిప్టర్‌లను దారి మళ్లించడానికి execని ఉపయోగించడాన్ని ప్రదర్శించాము.
ఇది బాష్ స్క్రిప్టింగ్‌ని ఉపయోగించి సాధించగలిగే దానిలో ఒక చిన్న భాగం మాత్రమే. నుండి బాష్ స్క్రిప్టింగ్ గురించి మరింత తెలుసుకోండి బాష్ ప్రోగ్రామింగ్ ఉప-వర్గం.
హ్యాపీ కంప్యూటింగ్!