గ్నూ / లైనక్స్‌లో షెల్ స్క్రిప్ట్‌ను రూపొందించడానికి ఉత్తమ పద్ధతులు

సాధారణంగా, మీరు పని ప్రారంభించినప్పుడు GNU / Linux మరియు / లేదా యునిక్స్ ఆపరేటింగ్ సిస్టమ్‌లతో సర్వర్‌ల అడ్మినిస్ట్రేషన్ ప్రాంతం, సాధారణంగా ఒక వాతావరణంలో పనిచేసే వ్యక్తి (ముఖాలు) ఒక ఇతర నిర్వాహకులు వ్రాసిన షెడ్యూల్ పనుల సమూహం మరియు ఏదో ఒక సమయంలో మనం తప్పక నిర్వహించండి (నిర్వహించండి) కోసం సంస్థ యొక్క క్రొత్త అవసరానికి అనుగుణంగా ఏదైనా సమస్యను పరిష్కరించండి, మెరుగుపరచండి మరియు / లేదా తొలగించండి అతను పనిచేసే చోట. కాబట్టి ఇది క్రొత్తది కాదు సిస్అడ్మిన్ ఏదైనా కార్యాలయంలో, కొన్నింటిని అర్థం చేసుకునే గజిబిజి పనిని మీరు ఎదుర్కొంటారు షెల్ స్క్రిప్ట్ ఇతరులు సృష్టించారు పాత సిస్అడ్మిన్, బాగా వ్రాయబడలేదు, లేదా తార్కిక లేదా వ్రాసే నిర్మాణంలో ఉన్నాయి, అర్థం చేసుకోవడం సులభం కాదు, లేదా చెత్త సందర్భంలో, కమాండ్ ఆదేశాలతో, విలక్షణమైన, పాత, అసమర్థమైన, లేదా ఇబ్బందికరమైన మరియు గందరగోళంగా వ్రాయబడినవి.

షెల్ స్క్రిప్టింగ్అయితే పేలవంగా వ్రాసిన స్క్రిప్ట్‌లను పరిష్కరించడం ఎల్లప్పుడూ క్షణిక కోపం, ఇది ఎవరికైనా బోధిస్తుంది మంచి సిస్అడ్మిన్ ముఖ్యమైన విషయం. ఒకటి సృష్టించబోతున్నట్లయితే a షెల్ స్క్రిప్ట్ ఈ రోజుకు మించి ఉపయోగించడం, ఎల్లప్పుడూ మంచిది వాటిని చాలా ప్రొఫెషనల్ మరియు ప్రామాణిక మార్గంలో రాయండి, తద్వారా కాలక్రమేణా, మరెవరైనా, లేదా వారే చేయగలరు కనీస ప్రయత్నం మరియు జ్ఞానం కనీస సమయంలో అవగాహన మరియు పరిపాలనను సాధిస్తాయి.

అందువల్ల, ప్రచురణల యొక్క ఆచరణాత్మక శ్రేణి తరువాత "షెల్ స్క్రిప్టింగ్ నేర్చుకోండి" ఇక్కడ మేము చాలా ఆచరణాత్మక స్క్రిప్ట్‌లను సరళమైన మరియు ప్రాథమిక ఆదేశాలతో పరిశీలిస్తాము, ఈ కొత్త సిరీస్‌తో ప్రారంభిస్తాము "గ్నూ / లైనక్స్‌లో షెల్ స్క్రిప్ట్‌ను రూపొందించడానికి ఉత్తమ పద్ధతులు", ఇక్కడ మేము దానిలోని ప్రతి చిన్న అంశంపై మరియు చాలా విషయాలకు కారణంపై పూర్తిగా దృష్టి పెడతాము, అనగా, మనం మంచి స్క్రిప్ట్‌లను తయారుచేసే కొన్ని చిట్కాలను కవర్ చేస్తాము, కాని మనకు అంతగా కాదు, కానీ తరువాతి వ్యక్తికి (సిస్అడ్మిన్) వాటిని నిర్వహించాలి. కాబట్టి నేను ఏమి కోడ్ చేస్తున్నానో, ఎలా మరియు ఎందుకు, మరియు అది ఇకపై ఎందుకు పనిచేయదు అనేదానిని గుర్తించడం చాలా శ్రమతో కూడుకున్నది కాదు.

ఈ లో మొదటి (1 వ) పోస్ట్ ఈ కొత్త సిరీస్ "గ్నూ / లైనక్స్ కోసం మంచి షెల్ స్క్రిప్ట్ కోసం ఉత్తమ అభ్యాసాలు" మేము ఏమి జరుగుతుందో దాని గురించి మాట్లాడుతాము షెల్ స్క్రిప్ట్ హెడర్.

=======================================
HEADER - షెల్ యొక్క ఇన్వొకేషన్
=======================================

#! / మార్గం / అర్థం చేసుకోండి [పారామితి-వాదన]

టాప్ లైన్ అనేది గ్నూ / లైనక్స్ కోసం షెల్ స్క్రిప్ట్ ప్రారంభించబడిన ప్రాథమిక నిర్మాణం. దీని అంశాలను ఈ క్రింది విధంగా వర్ణించవచ్చు:

#! => షా-బ్యాంగ్

షా-బ్యాంగ్ (#!) స్క్రిప్ట్ పైభాగంలో సృష్టించబడిన లేదా సృష్టించబడినది a మా ఫైల్ మన ఆదేశాల సమితి అని చెప్పే ఆపరేటింగ్ సిస్టమ్‌కి చెప్పే స్క్రిప్ట్, దాని తరువాత సూచించిన కమాండ్ ఇంటర్‌ప్రెటర్ చేత ఇవ్వబడుతుంది (వివరించబడుతుంది). అక్షర జత #! నిజానికి, ఇది ఒక మేజిక్ సంఖ్య రెండు-బైట్, ప్రత్యేక మార్కర్ ఫైల్ రకాన్ని నియమించండి, మరియు మా విషయంలో, ఎక్జిక్యూటబుల్ షెల్ స్క్రిప్ట్. షా-బ్యాంగ్ వచ్చిన వెంటనే పేరు వస్తుంది వ్యాఖ్యాత అమలు చేయవలసిన మార్గం ఉన్నది మరియు చెప్పిన వ్యాఖ్యాత పేరు. మరో మాటలో చెప్పాలంటే, ఇది స్క్రిప్ట్‌లోని ఆదేశాలను వివరించే ప్రోగ్రామ్‌కు మార్గం, ఇది వ్యాఖ్యాత, ప్రోగ్రామింగ్ భాష లేదా యుటిలిటీ అయినా. ఈ షెల్ అప్పుడు స్క్రిప్ట్‌లోని ఆదేశాలను అమలు చేస్తుంది, పైభాగంలో (షా-బ్యాంగ్ తర్వాత పంక్తి) ప్రారంభమవుతుంది మరియు ఏవైనా వ్యాఖ్యలను విస్మరిస్తుంది. కొన్ని షా-బ్యాంగ్ అవి కావచ్చు:

#! / Bin / sh
#! / Bin / bash
#! / usr / bin / perl
#! / usr / bin / tcl
#! / bin / sed -f
#! / usr / awk -f

పైన వివరించిన ప్రతి పంక్తులు (ఉదాహరణగా) వేరే షెల్‌ను ప్రారంభిస్తాయి. గీత / Bin / sh, ఇన్వోక్ షెల్ అప్రమేయంగా (గ్నూ / లైనక్స్ ఆపరేటింగ్ సిస్టమ్‌లో బాష్) లేదా ఇతర సారూప్యత. ఉపయోగించి #! / Bin / sh, యొక్క డిఫాల్ట్ విలువ బోర్న్ షెల్ యునిక్స్-ఆధారిత ఆపరేటింగ్ సిస్టమ్స్ యొక్క చాలా వాణిజ్య వైవిధ్యాలలో, ఇది స్క్రిప్ట్‌ను సృష్టించేలా చేస్తుంది లైనక్స్ సరిగా లేని ఇతర ఆపరేటింగ్ సిస్టమ్‌లకు పోర్టబుల్, కానీ ఇలాంటి లేదా యునిక్స్ ఆధారంగా, ఇది బాష్ యొక్క నిర్దిష్ట లక్షణాలను త్యాగం చేసినప్పటికీ. అయితే, క్రమం "#! / బిన్ / ష" కట్టుబాటుకు అనుగుణంగా ఉంటుంది POSIX sh ప్రమాణం.

గుర్తుంచుకోండి షా-బ్యాంగ్‌లో ఇచ్చిన మార్గం సరిగ్గా ఉండాలి, లేకపోతే సాధారణంగా దోష సందేశం "ఆజ్ఞ దొరకలేదు", ఇది స్క్రిప్ట్ అమలు యొక్క ఏకైక ఫలితం అవుతుంది. అక్షర జత గుర్తుంచుకో »#! « స్క్రిప్ట్ సాధారణ ఆపరేటింగ్ సిస్టమ్ ఆదేశాల సమితిని మాత్రమే కలిగి ఉంటే, అనగా అంతర్గత షెల్ ఆదేశాలను ఉపయోగించకుండా వదిలివేయవచ్చు. మరియు మరోసారి గుర్తుంచుకోండి »#! / బిన్ / ష« డిఫాల్ట్ షెల్ ఇంటర్ప్రెటర్‌ను ప్రారంభిస్తుంది, ఇది డిఫాల్ట్‌గా ఉంటుంది »#! / బిన్ / బాష్« అతనితో ఒక జట్టులో గ్నూ / లైనక్స్ ఆపరేటింగ్ సిస్టమ్.

వాదనలకు సంబంధించి, ఉపయోగించబడేవి చాలా ఉన్నాయి కాని సర్వసాధారణం: »-E«. ఇది స్క్రిప్ట్‌ను చేస్తుంది ఏదైనా ఆదేశం యొక్క అమలు లోపాలను ధృవీకరించండిo (అమలు రేఖ) మరియు సానుకూలంగా ఉంటే, స్టాప్ మరియు నిష్క్రమణను బలవంతం చేస్తుంది, ఒక విలక్షణమైనది »-F« కోసం ఏ స్క్రిప్ట్‌ను లోడ్ చేయాలో సూచించండి మరియు అరుదైన వాటిలో ఒకటి »-Rm« దాని అమలు పూర్తయిన తర్వాత దాన్ని తొలగించే పని చేస్తుంది. లో పేర్కొనడం మాత్రమే సాధ్యమవుతుంది షా-బ్యాంగ్ వరకు ఒకే వాదన (పరామితి) అమలు చేయవలసిన ప్రోగ్రామ్ పేరు తరువాత.

చివరకు, స్క్రిప్ట్ చెప్పండి మీ కోడ్ యొక్క ముఖ్యమైన భాగాలలో మీరు ఉపయోగించే గ్లోబల్ వేరియబుల్స్, అమలు మార్గం, అధీకృత వినియోగదారు, స్క్రిప్ట్ పేరు వంటి సంఘటనల ధృవీకరణ కోసం. మరియు తో ముగుస్తుంది ప్రోగ్రామ్ యొక్క డేటా, సృష్టికర్త, సంస్థ మరియు ఇతరులతో పాటు, ప్రోగ్రామ్‌కు వర్తించే లైసెన్సింగ్.

నా సలహా (ఉత్తమ పద్ధతులు) ఎంచుకోవడానికి ఉత్తమ షా-బ్యాంగ్ మరియు ఒక శీర్షిక షెల్ స్క్రిప్ట్ అవి:

#! / usr / bin / env bash

ఆదేశాన్ని ఎందుకు ఉపయోగిస్తున్నారు »ఎన్వ్« ఆపరేటింగ్ సిస్టమ్‌కు ఇంటర్‌ప్రెటర్‌ను డిఫాల్ట్‌గా పేర్కొన్న ఖచ్చితమైన మార్గంతో ఉపయోగించమని మేము సూచిస్తున్నాము, ఇది మాకు ఒక షా-బ్యాంగ్ ఇది దాని యొక్క పోర్టబిలిటీని పెంచుతుంది, ఎందుకంటే అన్నిటిలో కాదు OS గ్నూ / లైనక్స్ వ్యాఖ్యాతలు లేదా ప్రోగ్రామ్‌లు ఒకే మార్గాన్ని కలిగి ఉంటాయి. మరియు వాదనలు లేకుండా, ఎందుకంటే దాని కోసం ఆదేశాన్ని ఉపయోగించడం మంచిది సెట్, ఎందుకంటే అతనితో మనం చేయగలం లోపాలు, సాధారణ (-e) లేదా నిర్దిష్ట (+ x / -x) ను ధృవీకరించండి, లేదా పర్యావరణం (-i) లేదా నిర్దిష్ట (-u / –unset) వేరియబుల్స్ కోసం గ్లోబల్ ప్రీసెట్లు క్లియర్ చేయండి. చివరకు, కు నిర్దిష్ట (- o) పరిపూరకరమైన చర్యలను అమలు చేయండి స్క్రిప్ట్ లోపల.

కాబట్టి నా సిఫార్సు చేసిన HEADER ఇలా ఉంటుంది:

#! / usr / bin / env bash
# ఆపరేటింగ్ సిస్టమ్ ద్వారా సంపూర్ణ మార్గంతో బాష్ వ్యాఖ్యాతను సూచించండి.

సెట్ -ఓ ఎర్రెక్సిట్
# ఆదేశం లేదా అమలు యొక్క పంక్తి విఫలమైనప్పుడు ఆపడానికి మరియు మూసివేయమని స్క్రిప్ట్‌కు చెప్పడం.

సెట్ -o నామవాచకం
# స్క్రిప్ట్ అప్రకటిత వేరియబుల్స్ ఉపయోగించటానికి ప్రయత్నించినప్పుడు ఆపడానికి మరియు మూసివేయమని చెప్పడానికి.

-o పైప్‌ఫైల్ సెట్ చేయండి
# సున్నా కాని నిష్క్రమణ కోడ్‌ను తిరిగి ఇచ్చిన చివరి ఆర్డర్ యొక్క నిష్క్రమణ స్థితిని పొందడానికి.

# సెట్ -o xtrace
# ఏమి నడుస్తుందో తెలుసుకోవడానికి. డీబగ్గింగ్ కోసం ఉపయోగపడుతుంది. లోపాలను మాత్రమే తనిఖీ చేయడానికి దీన్ని ప్రారంభించండి.

ఈ సిఫార్సులను అదనంగా పాటించాలని గుర్తుంచుకోండి:

01.- మీ కోడ్‌ను ఇండెంట్ చేయండి: మీ కోడ్‌ను చదవగలిగేలా చేయడం చాలా ముఖ్యం మరియు ఇది చాలా మంది ప్రజలు మరచిపోయినట్లు అనిపిస్తుంది. దృష్టిలో మంచి తార్కిక నిర్మాణాన్ని గ్రహించడానికి అవసరమైన ఇండెంటేషన్లు చేయడానికి ప్రయత్నించండి.

02.- కోడ్ విభాగాల మధ్య ఖాళీలను జోడించండి: ఇది కోడ్‌ను మరింత అర్థమయ్యేలా చేయడంలో సహాయపడుతుంది, ఎందుకంటే మాడ్యూల్స్ లేదా విభాగాల ద్వారా అంతరం కోడ్‌ను చదవగలిగేలా మరియు సులభంగా అర్థం చేసుకోవడానికి సహాయపడుతుంది.

03.- కోడ్ గురించి సాధ్యమైనంతవరకు వ్యాఖ్యానించండి: ప్రతి కమాండ్ ఆర్డర్ (ఎగ్జిక్యూషన్ లైన్) లేదా కోడ్ సెక్షన్ యొక్క ఎగువ (లేదా దిగువ) వద్ద, కోడ్‌లోనే ఏమి జరుగుతుందో వివరించడానికి స్క్రిప్ట్ (ల) యొక్క పనితీరు యొక్క వివరణను జోడించడం అనువైనది.

04.- వాటి ఫంక్షన్ల వివరణాత్మక పేర్లతో వేరియబుల్స్ సృష్టించండి: వివరణాత్మక వేరియబుల్ పేర్లను కేటాయించండి, అది సృష్టించబడే ఫంక్షన్‌ను స్పష్టంగా గుర్తిస్తుంది. మీరు ఒకే కోడ్ బ్లాక్ వెలుపల ఉపయోగించని తాత్కాలిక చరరాశులను సృష్టించినప్పటికీ, అది ఏ విలువలు లేదా విధులను నిర్వహిస్తుందో స్పష్టంగా (నిష్పాక్షికంగా) వివరించే పేరును ఉంచడం ఇంకా మంచిది.

05.- కమాండ్ ప్రత్యామ్నాయం కోసం VARIABLE = $ (కమాండ్) అనే వాక్యనిర్మాణాన్ని ఉపయోగించండి: మీరు మరొక కమాండ్ నుండి ఉద్భవించిన వేరియబుల్ ను సృష్టించాలనుకుంటే, దానిని బాష్ లో చేయడానికి రెండు మార్గాలు ఉన్నాయి. తో బ్యాక్టిక్, అంటే, అక్షరాలతో `` , EJM: VARIABLE = `కమాండ్-ఆప్షన్స్ పారామితులు`, కానీ ఇది ఇప్పటికే తీసివేయబడింది, కాబట్టి వాక్యనిర్మాణం VARIABLE = $ (ఆదేశం) ఇది చాలా ఆధునిక, అంగీకరించబడిన మరియు సిఫార్సు చేయబడిన మార్గం. లేదు -> DATE = `తేదీ +% F` / అవును -> DATE = $ (తేదీ +% F)

06.- పాస్‌వర్డ్‌తో లేదా లేకుండా సూపర్‌యూజర్ మరియు అధీకృత వినియోగదారు ధ్రువీకరణ గుణకాలు మరియు / లేదా వేరియబుల్స్ ఉపయోగించండి: అవసరమైతే భద్రతా స్థాయిలను పెంచడం.

07.- ఆపరేటింగ్ సిస్టమ్ యొక్క ధ్రువీకరణ యొక్క మాడ్యూల్స్ మరియు / లేదా వేరియబుల్స్ ఉపయోగించండి (డిస్ట్రో, వెర్షన్, ఆర్కిటెక్చర్): అనుచితమైన ప్లాట్‌ఫామ్‌లపై ఉపయోగించడాన్ని నిరోధించడానికి.

08.- క్లిష్టమైన లేదా బ్యాచ్ చర్యల (గుణకాలు / విధులు) అమలును నిర్ధారించడానికి గుణకాలు (విధానాలు / విభాగాలు) ఉపయోగించండి: మెరుగుదల లేదా అజాగ్రత్త కారణంగా తప్పులను తగ్గించడానికి.

09.- యూజర్ ఫ్రెండ్లీ ఇంటర్‌ఫేస్‌లను అందించండి (యూజర్ ఫ్రెండ్లీ): మెనూలు మరియు రంగులతో టెర్మినల్ ద్వారా డైలాగ్ మరియు తో జెనిటీ, జిఎక్స్మెసేజ్ ఉన్న ప్రాథమిక వినియోగదారుల కోసం గ్రాఫికల్ ఇంటర్ఫేస్లు. మరియు వీలైతే ధ్వని ప్రకారం గుర్తించదగిన సంఘటనలను గుర్తించే సోనిక్ హెచ్చరికల మద్దతును ఉపయోగించండి. మీ స్క్రిప్ట్ చేయగలిగినంత ప్రయత్నించాను ఎంపికలు / గుణకాలు / విధులను ప్రారంభించడం మరియు నిలిపివేయడం ద్వారా రెండు విధాలుగా పని చేయండి.

10.- స్వాగతం మరియు వీడ్కోలు గుణకాలు (సందేశాలు) చేర్చండి: వినియోగదారుతో ఇంటరాక్టివిటీని పెంచడానికి అవసరమైన సందర్భంలో.

11.- డబుల్ ఎగ్జిక్యూషన్ వెరిఫికేషన్ మాడ్యూల్ చేర్చండి: ఒకే సమయంలో 1 కంటే ఎక్కువసార్లు అమలు చేయకుండా నిరోధించడానికి దాని కోసం ఒక లాక్ ఫైల్‌ను సృష్టించండి.

12.- స్క్రిప్ట్ యొక్క పరిమాణాన్ని బాహ్య విధులు మరియు / లేదా మాడ్యూళ్ళతో హేతుబద్ధీకరించండి: స్క్రిప్ట్ చాలా పెద్దదిగా ఉంటే ఫంక్షన్లను ఉపయోగించి కోడ్‌ను విభజించండి లేదా వాటిని చిన్న స్క్రిప్ట్‌లుగా విభజించండి.

13.- స్క్రిప్ట్‌లోని ఇతర వ్యాఖ్యాతలకు (ప్రోగ్రామింగ్ లాంగ్వేజెస్) కాల్స్ స్పష్టమైన మరియు స్పష్టమైన మార్గంలో ఆహ్వానం: పంక్తులు లేదా గుణకాలు ద్వారా వాటిని స్పష్టంగా ఆహ్వానించండి.

ఉదాహరణకు:

# ================================================== #
#!/bin/bash
#Llamando a un interprete externo a BASH
echo 'El siguiente texto será mostrado por el interprete de PERL'
perl -e 'print "Este texto es mostrado por un script PERL embebido.\n";'
exit 0
# ==================================================#

 

# ==================================================# 
#!/bin/bash #Llamando al interprete de Python. 
echo 'El siguiente es un script de python:'
echo print "Hola, mundo!" | tee $HOME/.testpythonbash.py
python $HOME/.testpythonbash.py exit 0
# ==================================================#

 


# ======================================================= #
#!/bin/bash
# bash-y-perl.sh

echo "Saludos desde la parte BASH del script."
# Es posible añadir mas comandos BASH aqui.

exit 0
# Fin de la parte BASH del script.

###########################################################

#!/usr/bin/perl
# Esta parte del script se invoca con la opcion -x.

print "Saludos desde la parte PERL del script.\n";
# Podemos añadir mas comandos PERL aqui.

# Fin de la parte PERL del script.
# ======================================================= #
 

భవిష్యత్ ప్రచురణలలో పైన వివరించిన ప్రతి పద్ధతులను మరింత వివరంగా విస్తరిస్తాము.

మీకు మరికొన్ని మంచి అభ్యాసాలు తెలిస్తే, మీ స్వంతం లేదా ఇతరులు, మరింత సంపూర్ణమైన సంకలనం చేయడానికి వాటిపై వ్యాఖ్యానించడానికి వెనుకాడరు!

ఈ కొత్త సిరీస్ యొక్క తదుపరి ప్రచురణ వరకు.


వ్యాసం యొక్క కంటెంట్ మా సూత్రాలకు కట్టుబడి ఉంటుంది సంపాదకీయ నీతి. లోపం నివేదించడానికి క్లిక్ చేయండి ఇక్కడ.

6 వ్యాఖ్యలు, మీదే వదిలేయండి

మీ వ్యాఖ్యను ఇవ్వండి

మీ ఇమెయిల్ చిరునామా ప్రచురితమైన కాదు. లు గుర్తించబడతాయి గుర్తించబడతాయి *

*

*

  1. డేటాకు బాధ్యత: మిగ్యుల్ ఏంజెల్ గాటన్
  2. డేటా యొక్క ఉద్దేశ్యం: కంట్రోల్ స్పామ్, వ్యాఖ్య నిర్వహణ.
  3. చట్టబద్ధత: మీ సమ్మతి
  4. డేటా యొక్క కమ్యూనికేషన్: డేటా చట్టపరమైన బాధ్యత ద్వారా తప్ప మూడవ పార్టీలకు తెలియజేయబడదు.
  5. డేటా నిల్వ: ఆక్సెంటస్ నెట్‌వర్క్స్ (EU) హోస్ట్ చేసిన డేటాబేస్
  6. హక్కులు: ఎప్పుడైనా మీరు మీ సమాచారాన్ని పరిమితం చేయవచ్చు, తిరిగి పొందవచ్చు మరియు తొలగించవచ్చు.

  1.   మాక్స్ జె రోడ్రిగెజ్ అతను చెప్పాడు

    ఒక్క వివరాలు, ఇది "షెబాంగ్" is
    చాలా మంచి పోస్ట్, దీర్ఘకాలంలో మంచి అభ్యాసాలు ఎల్లప్పుడూ ప్రామాణీకరించడానికి సహాయపడతాయి.

  2.   ఇక్కడ దాటిన ఒకటి అతను చెప్పాడు

    అన్ని పంపిణీలలో బాష్ డిఫాల్ట్ షెల్ కాదు, అందువల్ల / bin / sh సింబాలిక్ లింక్ ఎల్లప్పుడూ బాష్‌కు సూచించదు. ఉదాహరణకు డెబియన్‌లో (మరియు నేను ఉబుంటు అని అనుకుంటాను):
    $ ls -l / bin / sh
    lrwxrwxrwx 1 రూట్ రూట్ 4 అజా 8 2014 / బిన్ / ష -> డాష్
    కాబట్టి డెబియన్‌లోని డిఫాల్ట్ షెల్ డాష్. ఇక్కడ చూడండి: https://wiki.debian.org/Shell

  3.   పేరులేని అతను చెప్పాడు

    ఉపయోగంలో ఉన్న షెల్ తెలుసుకోవటానికి చిట్కాగా:

    ఎకో $ 0
    ఎకో $ షెల్
    ఎన్వీ | grep షెల్

  4.   జోస్ ఆల్బర్ట్ అతను చెప్పాడు

    మీరు నిజంగానే ఉన్నారు! నేను డెబియన్ 9 మరియు కాశీ లైనక్స్ 2.0 లలో ప్రయత్నించాను మరియు ఇది నిజం! మిమ్మల్ని డాష్ చేస్తుంది. ఇంకా ఎక్కువ సిఫార్సు: #! / Usr / bin / env bash అది మీరు ఉపయోగించాలనుకుంటున్న షెల్ అయితే.

    మరియు మీరు ఖచ్చితంగా చెప్పింది అది షెబాంగ్, కానీ కొన్ని వెబ్‌సైట్లలో (సాంకేతిక సాహిత్యం) వారు దీనిని షాబాంగ్ లేదా ఇతర పదాలు అని పిలుస్తారు, అందుకే నా గందరగోళం. ఉదాహరణ:

    కంప్యూటింగ్‌లో, షెబాంగ్ అనేది స్క్రిప్ట్ ప్రారంభంలో అక్షరాల సంఖ్య గుర్తు మరియు ఆశ్చర్యార్థక గుర్తు (#!) తో కూడిన అక్షర శ్రేణి. దీనిని షా-బ్యాంగ్, [1] [2] హాష్‌బ్యాంగ్, [3] [4] పౌండ్-బ్యాంగ్, [5] లేదా హాష్-ప్లింగ్ అని కూడా పిలుస్తారు

    నుండి: https://en.wikipedia.org/wiki/Shebang_%28Unix%29

    Y చాప్టర్ 2. షా-బ్యాంగ్ తో ప్రారంభమవుతుంది
    నుండి: http://www.tldp.org/LDP/abs/html/sha-bang.html

  5.   జోస్ ఆల్బర్ట్ అతను చెప్పాడు

    అలాగే: బేస్‌నేమ్ $ 0