GNU / Linux मध्ये शेल स्क्रिप्ट तयार करण्यासाठी उत्तम सराव

सहसा जेव्हा आपण यावर कार्य करण्यास प्रारंभ करता जीएनयू / लिनक्स आणि / किंवा युनिक्स ऑपरेटिंग सिस्टमसह सर्व्हरचे प्रशासन क्षेत्र, एखादा स्वतःस (चेहरे) अशा वातावरणात काम करतो जेथे सामान्यतः ए इतर प्रशासनाने लिहिलेली अनुसूची कार्ये आणि त्या क्षणी आपण नक्कीच केले पाहिजे व्यवस्थापित करा (प्रशासन करा) साठी संस्थेच्या नवीन आवश्यकताचे पालन करण्यासाठी कोणतीही समस्या सोडवा, सुधारित करा आणि / किंवा दूर करा जिथे तो काम करतो. तर हे विचित्र नाही, की कोणतेही नवीन SysAdmin कोणत्याही कामाच्या ठिकाणी, तुम्हाला काही समजून घेण्याच्या अवघड कामांचा सामना करावा लागतो शेल स्क्रिप्ट इतरांनी तयार केलेले जुने SysAdmin, ते चांगले लिहिलेले नाहीत, किंवा तर्कसंगत किंवा लेखन रचनेत आहेत, समजून घेणे सोपे नाही आहे किंवा सर्वात वाईट परिस्थितीत कमांड कमांडसह, अटिपिकल, जुने, अकार्यक्षम किंवा एक विचित्र आणि गोंधळात टाकणारे मार्ग आहे.

तर असमाधानकारकपणे लिहिलेल्या स्क्रिप्ट सोडवित आहे हे नेहमीच क्षणिक त्रास देतात, हे कोणतेही शिकवते चांगले SysAdmin काहीतरी महत्वाचे जर एखादी तयार करणार असेल तर शेल स्क्रिप्ट आजच्या पलीकडे वापरणे नेहमीच चांगले असते त्यांना खूप व्यावसायिक आणि प्रमाणित मार्गाने लिहा, जेणेकरून कालांतराने, दुसरे कोणीही किंवा स्वत: देखील, सोबत करु शकेल किमान प्रयत्न आणि ज्ञान कमीतकमी समज आणि प्रशासन प्राप्त करते.

म्हणून, प्रकाशनांच्या व्यावहारिक मालिकेनंतर "शेल स्क्रिप्टिंग जाणून घ्या" जिथे आम्ही काही अगदी व्यावहारिक स्क्रिप्ट्स सोप्या आणि मूलभूत कमांडसह तपासतो, आम्ही या नावाची नवीन मालिका सुरू करू "जीएनयू / लिनक्समध्ये शेल स्क्रिप्ट तयार करण्यासाठी उत्तम सराव", जिथे आपण त्यातील प्रत्येक छोट्या पैलूवर आणि बर्‍याच गोष्टींचे कारण यावर पूर्णपणे लक्ष केंद्रित करूया, म्हणजेच आपण अशा काही टिप्स समाविष्ट करू ज्या आम्हाला चांगले स्क्रिप्ट बनवू शकतील, परंतु स्वतःसाठीच नव्हे तर पुढच्या व्यक्तीसाठी (SysAdmin) त्यांना व्यवस्थापित करावे लागेल. म्हणून मी काय कोडित करतो, कसे आणि का केले आणि हे आता का कार्य करत नाही हे शोधून काढण्यासाठी आपल्याला कंटाळवाणे व कठीण काम पार पाडण्याची गरज नाही.

या मध्ये प्रथम (पहिली) पोस्ट या नवीन मालिकेची "जीएनयू / लिनक्ससाठी चांगल्या शेल स्क्रिप्टसाठी सर्वोत्तम पद्धती" आम्ही काय मध्ये जावे किंवा काय पाहिजे याबद्दल चर्चा करू शेल स्क्रिप्ट शीर्षलेख.

=======================================
शिर्षक - शेलची भेट
=======================================

#! / पथ / व्याख्या [मापदंड-वितर्क]

शीर्ष ओळ ही मूलभूत रचना आहे जिच्यासह जीएनयू / लिनक्ससाठी शेल स्क्रिप्ट वापरली जाते. त्याचे घटक खालीलप्रमाणे वर्णन केले जाऊ शकतात:

#! => शा-बँग

शा-बँग (#!) स्क्रिप्टच्या शीर्षस्थानी तयार करणे किंवा तयार करणे हे आहे स्क्रिप्ट जी आमच्या ऑपरेटिंग सिस्टमला सांगते की आपली फाईल कमांड्सचा एक संच आहे जी नंतर दिलेल्या कमांड इंटरप्रिटरद्वारे दिले जाईल (स्पष्टीकरण दिले जाईल). पात्रांची जोडी #! प्रत्यक्षात, ते एक आहे जादू क्रमांक दोन बाइट, एक विशेष मार्कर फाईल प्रकार नियुक्त करा, आणि आमच्या बाबतीत, एक्जीक्यूटेबल शेल स्क्रिप्ट. शा-बँग नंतर लगेचच नाव येते इंटरप्रीटर कार्यान्वित करायचा तो पथ आणि त्या दोहों दुभाषेचे नाव आहे. दुसर्‍या शब्दांत सांगायचे तर, हा प्रोग्रामचा मार्ग आहे जो स्क्रिप्टमधील कमांडचा अर्थ लावतो, मग ती इंटरप्रिटर, प्रोग्रामिंग भाषा किंवा उपयोगिता असो. हे शेल नंतर स्क्रिप्टमधील कमांड कार्यान्वित करते, शीर्षस्थानी (शा-बँग नंतरची ओळ) प्रारंभ करते आणि कोणत्याही टिप्पण्यांकडे दुर्लक्ष करते. काही शा-बँग ते असू शकतात:

#! / बिन / श
#! / बिन / बॅश
#! / usr / बिन / पर्ल
#! / usr / बिन / टीसीएल
#! / बिन / सेड-एफ
#! / usr / awk -f

वर वर्णन केलेल्या प्रत्येक ओळी (उदाहरण म्हणून) वेगळ्या शेलची विनंती करतात. ओळ / बिन / शा, विनंती शेल डीफॉल्टनुसार (जीएनयू / लिनक्स ऑपरेटिंग सिस्टमवर बॅश करा) किंवा इतर तत्सम. वापरत आहे #! / बिन / शचे डीफॉल्ट मूल्य बॉर्न शेल UNIX- आधारित ऑपरेटिंग सिस्टमच्या बर्‍याच व्यावसायिक प्रकारांमध्ये ते स्क्रिप्ट तयार करते इतर ऑपरेटिंग सिस्टमसाठी पोर्टेबल जे योग्यरित्या लिनक्स नाहीत, परंतु तत्सम किंवा यावर आधारित किंवा युनिक्स, जरी हे BASH च्या विशिष्ट वैशिष्ट्यांचा त्याग करते. तथापि, क्रम "#! / बिन / शि" रूढीनुसार पॉसिक्स श मानक.

याची नोंद घ्या शा-बँगमध्ये दिलेला मार्ग योग्य असणे आवश्यक आहे, अन्यथा एक त्रुटी संदेश, सहसा "आदेश सापडला नाही", स्क्रिप्ट अंमलबजावणीचा हा एकमेव निकाल असेल. पात्रांची जोडी लक्षात ठेवा »#! « जर स्क्रिप्टमध्ये अंतर्गत शेल निर्देशांचा वापर न करता सर्वसाधारण ऑपरेटिंग सिस्टम आदेशांच्या संचाचा समावेश असेल तर हे वगळले जाऊ शकते. आणि हे पुन्हा एकदा लक्षात ठेवा »#! / बिन / श« डीफॉल्ट शेल इंटरप्रिटरला विनंती करते, जे डीफॉल्ट होते »#! / बिन / बॅश त्याच्यासमवेत जीएनयू / लिनक्स ऑपरेटिंग सिस्टम.

वितर्कांच्या संदर्भात, असे बरेच आहेत जे वापरले जाऊ शकतात परंतु सर्वात सामान्य म्हणजेः »-E«. जे स्क्रिप्ट बनवते कोणत्याही कमांडची अंमलबजावणी त्रुटी मान्य कराo (अंमलबजावणी ओळ) आणि सकारात्मक असल्यास, थांबा आणि बाहेर पडायला भाग पाडते, एक नमुनेदार आहे »-F साठी कोणती स्क्रिप्ट लोड करावी हे दर्शवा आणि एक दुर्मिळ आहे »-आरएम« एकदा अंमलबजावणी पूर्ण झाल्यावर ते हटविणे पूर्ण करते. मध्ये निर्दिष्ट करणे केवळ शक्य आहे शा-बँग पर्यंत एकल वितर्क (मापदंड) कार्यान्वित करण्याच्या कार्यक्रमाच्या नावा नंतर.

आणि शेवटी, स्क्रिप्ट सांगा आपण आपल्या कोडच्या आवश्यक भागांमध्ये ग्लोबल व्हेरिएबल्स वापरु शकता, एक्झिक्यूशन पथ, अधिकृत वापरकर्ता, स्क्रिप्ट नाव यासारख्या इव्हेंटच्या प्रमाणीकरणासाठी. आणि सह समाप्त प्रोग्रामचा डेटा, क्रिएटर, संघटना, इतरांमध्ये तसेच प्रोग्रामला लागू असलेला परवाना.

माझा सल्ला (सर्वोत्तम पद्धती) निवडण्यासाठी सर्वोत्तम शा-बँग आणि शीर्षक ए शेल स्क्रिप्ट ते आहेत:

#! / usr / बिन / एनव्ही बॅश

कमांड का वापरत आहे »एनव्ह« डीफॉल्टनुसार त्याच्यामध्ये निर्दिष्ट केलेल्या अचूक मार्गासह वापरण्यासाठी आम्ही ऑपरेटिंग सिस्टमला दुभाषे दर्शवितो, जो आपल्याला शा-बँग जे त्याची पोर्टेबिलिटी वाढवते, कारण सर्वच नाही ओएस जीएनयू / लिनक्स दुभाषे किंवा प्रोग्राम्सचा एकच मार्ग असतो. आणि युक्तिवादांशिवाय, कारण ही कमांड वापरणे चांगले संच, कारण त्याच्याबरोबर आपण हे करू शकतो वैधता त्रुटी, सामान्य (-e) किंवा विशिष्ट (+ x / -x), किंवा करण्यासाठी पर्यावरण (-i) किंवा विशिष्ट (-u / setunset) व्हेरिएबल्ससाठी ग्लोबल प्रीसेट सेट करा. आणि शेवटी, ते विशिष्ट (- o) पूरक क्रिया कार्यान्वित करा स्क्रिप्ट मध्ये.

तर माझे शिफारस केलेले हेडर हे असेलः

#! / usr / बिन / एनव्ही बॅश
ऑपरेटिंग सिस्टमद्वारे अचूक मार्गाने बॅश इंटरप्रीटर दर्शवा.

सेट -ओ त्रुटी
# आदेशाची अंमलबजावणी किंवा लाइन अयशस्वी झाल्यास स्क्रिप्ट थांबा आणि बंद करण्यास सांगा.

सेट-ओ संज्ञा
स्क्रिप्ट अघोषित व्हेरिएबल्स वापरण्याचा प्रयत्न करतो तेव्हा स्क्रिप्टला थांबविणे आणि बंद करणे सांगणे.

सेट -o पाईपफाईल
# शेवटच्या ऑर्डरची निर्गमन स्थिती मिळविण्यासाठी ज्याने शून्य-निर्गमन कोड परत केला.

# सेट -o xtrace
# काय चालते याचा मागोवा घेण्यासाठी. डीबगिंगसाठी उपयुक्त. केवळ त्रुटी तपासण्यासाठी सक्षम करा.

या शिफारसींचे अतिरिक्तपणे अनुसरण करणे लक्षात ठेवाः

01.- आपला कोड टाका: आपला कोड वाचनीय बनविणे खूप महत्वाचे आहे आणि ही अशी एक गोष्ट आहे जी बरीच लोक विसरतात असेही दिसते. दृष्टीक्षेपात चांगली लॉजिकल स्ट्रक्चर लक्षात घेण्यासाठी आवश्यक इंडेंटेशन बनवण्याचा प्रयत्न करा.

02.- कोडच्या विभागांमधील विभक्त जागा जोडा: हे कोड अधिक समजण्यायोग्य बनविण्यात मदत करू शकते, कारण मॉड्यूलद्वारे किंवा विभागांद्वारे अंतर केल्यामुळे कोड वाचनीय आणि समजण्यास सुलभ होते.

03.- कोडबद्दल शक्य तितक्या टिप्पणी द्या: प्रत्येक कमांड ऑर्डर (एक्झिक्यूशन लाइन) किंवा कोड सेक्शनच्या शीर्षस्थानी (किंवा तळाशी) कोडमध्येच काय होते हे स्पष्ट करण्यासाठी कमांडच्या सीक्वेन्स (ओं) च्या फंक्शनचे वर्णन जोडणे योग्य आहे.

04.- त्यांच्या फंक्शनच्या वर्णनात्मक नावे व्हेरिएबल्स तयार करा. वर्णनात्मक व्हेरिएबल नावे द्या जे ते तयार केले जाणारे फंक्शन स्पष्टपणे ओळखतात. आपण एकल कोड ब्लॉकच्या बाहेर कधीही वापरला जाणार नाही असे तात्पुरते व्हेरिएबल्स तयार केले असले तरीही त्याचे नाव कोणती मूल्ये किंवा कार्ये हाताळते हे स्पष्टपणे (वस्तुनिष्ठपणे) असे नाव देणे चांगले आहे.

05.- आदेश प्रतिस्थापन करीता व्हेरिएबल = $ (आदेश) सिंटॅक्स वापरा: जर आपल्याला एखादा व्हेरिएबल बनवायचा असेल ज्याची व्हॅल्यू दुसर्‍या कमांड मधून आला असेल तर त्यास बॅशमध्ये करण्याचे दोन मार्ग आहेत. सह बॅकटिक, म्हणजेच, पात्रांसह `` , एज्म: व्हेरिएबल = `कमांड -ऑप्शन पॅरामीटर्स`, परंतु हे आधीपासून नापसंत केले आहे, म्हणून वाक्यरचना भिन्न = $ (आदेश) हा सर्वात आधुनिक, स्वीकारलेला आणि शिफारस केलेला मार्ग आहे. नाही -> तारीख = `तारीख +% एफए / येस -> तारीख = $ (तारीख +% फॅ)

06.- संकेतशब्दासह किंवा त्याशिवाय सुपरयुझर आणि अधिकृत वापरकर्त्याचे प्रमाणीकरण मॉड्यूल आणि / किंवा व्हेरिएबल्स वापरा. आवश्यक असल्यास सुरक्षेची पातळी वाढविणे.

07.- ऑपरेटिंग सिस्टमचे वैधता (डिस्ट्रो, आवृत्ती, आर्किटेक्चर) चे मॉड्यूल आणि / किंवा व्हेरिएबल्स वापरा: अयोग्य प्लॅटफॉर्मवर वापर रोखण्यासाठी.

08.- गंभीर किंवा बॅच क्रियांच्या अंमलबजावणीची पुष्टी करण्यासाठी मॉड्यूल (कार्यपद्धती / विभाग) वापरा (विभाग / कार्ये): सुधारणे किंवा निष्काळजीपणामुळे चुका कमी करणे.

09.- वापरकर्ता अनुकूल इंटरफेस प्रदान करा (वापरकर्त्यासाठी अनुकूल): मेनूसह टर्मिनलद्वारे आणि रंगांसह संवाद आणि सह झेनिटी, जीएक्समेसेज असलेल्या बेसिक वापरकर्त्यांसाठी ग्राफिकल इंटरफेस. आणि शक्य असल्यास आवाजाच्या अनुषंगाने ओळखण्यायोग्य घटनांच्या अभिज्ञापक सोनिक अ‍ॅलर्टचा आधार वापरा. मी तुमची स्क्रिप्ट शक्य तितक्या प्रयत्न केला केवळ पर्याय / मॉड्यूल / कार्ये सक्षम आणि अक्षम करून दोन्ही प्रकारे कार्य करा.

१०- स्वागत आणि निरोप मॉड्यूल्स (संदेश) समाविष्ट करा: वापरकर्त्यासह परस्पर संवाद वाढविणे आवश्यक असल्यास.

११- डबल अंमलबजावणी सत्यापन मॉड्यूलचा समावेश करा: एकाच वेळी 1 पेक्षा जास्त वेळा कार्यवाही होण्यापासून प्रतिबंधित करण्यासाठी त्याकरिता लॉक फाइल तयार करा.

१२- बाह्य कार्ये आणि / किंवा मॉड्यूलसह ​​स्क्रिप्टचा आकार तर्कसंगत करा: जर स्क्रिप्ट खूप मोठी असेल तर फंक्शन्सचा वापर करुन कोडचे विभाजन करा किंवा मुख्य स्क्रिप्टद्वारे लहान स्क्रिप्टमध्ये विभाजित करा.

१.. - स्क्रिप्टमधील इतर दुभाष्यांना (प्रोग्रामिंग भाषा) कॉल स्पष्ट आणि स्पष्ट मार्गाने बोलावणे: ओळी किंवा मॉड्यूलद्वारे त्यांना स्पष्टपणे आमंत्रित करा.

उदाहरण:

# ================================================== #
#!/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.
# ======================================================= #
 

भविष्यातील प्रकाशनांमध्ये आम्ही वर वर्णन केलेल्या प्रत्येक पद्धतीचा अधिक तपशीलवार विस्तार करू.

आणि जर आपल्याला काही इतर चांगल्या पद्धती माहित असतील, आपल्या स्वत: च्या किंवा इतरांबद्दल, आणखी संपूर्ण संकलन करण्यासाठी त्यांच्यावर टिप्पणी करण्यास अजिबात संकोच करू नका!

या नवीन मालिकेचे पुढील प्रकाशन होईपर्यंत.