इस श्रृंखला के पहले लेख में, आपने अपनी पहली, बहुत छोटी, एक-पंक्ति वाली बैश स्क्रिप्ट बनाई और शेल स्क्रिप्ट बनाने के कारणों का पता लगाया। दूसरे लेख में, आपने एक काफी सरल टेम्पलेट बनाना शुरू किया जो अन्य बैश कार्यक्रमों के लिए एक प्रारंभिक बिंदु हो सकता है और इसका परीक्षण करना शुरू कर दिया। तीसरे लेख में, आपने एक साधारण सहायता फ़ंक्शन बनाया और उसका उपयोग किया और फ़ंक्शंस का उपयोग करने और -h जैसे कमांड-लाइन विकल्पों को संभालने के तरीके के बारे में सीखा। ।
श्रृंखला का यह चौथा और अंतिम लेख चर में हो जाता है और उन्हें आरंभ करने के साथ-साथ उचित परिस्थितियों में कार्यक्रम को चलाने में मदद करने के लिए थोड़ा सा विवेक परीक्षण कैसे किया जाता है। याद रखें, इस श्रृंखला का उद्देश्य कार्य कोड बनाना है जिसका उपयोग भविष्य में बैश प्रोग्रामिंग परियोजनाओं के लिए एक टेम्पलेट के लिए किया जाएगा। विचार यह है कि टेम्पलेट में पहले से ही सामान्य तत्वों को उपलब्ध कराकर नई प्रोग्रामिंग परियोजनाओं को शुरू करना आसान बनाया जाए।
चर
बैश शेल, सभी प्रोग्रामिंग भाषाओं की तरह, चर से निपट सकता है। एक चर एक प्रतीकात्मक नाम है जो स्मृति में एक विशिष्ट स्थान को संदर्भित करता है जिसमें किसी प्रकार का मान होता है। एक चर का मान परिवर्तनशील होता है, अर्थात यह परिवर्तनशील होता है। यदि आप चर के उपयोग से परिचित नहीं हैं, तो मेरा लेख पढ़ें बैश के साथ प्रोग्राम कैसे करें:सिंटैक्स और उपकरण इससे पहले कि आप आगे बढ़ें।
पूर्ण? महान! आइए अब चरों का उपयोग करते समय कुछ अच्छे अभ्यासों को देखें।
मैं हमेशा अपनी स्क्रिप्ट में उपयोग किए जाने वाले प्रत्येक चर के लिए प्रारंभिक मान निर्धारित करता हूं। विकल्पों को संसाधित करने से पहले, आप इसे मुख्य प्रोग्राम बॉडी के पहले भाग के रूप में प्रक्रियाओं के तुरंत बाद अपनी टेम्पलेट स्क्रिप्ट में पा सकते हैं। प्रत्येक चर को उचित मान के साथ प्रारंभ करने से उन त्रुटियों को रोका जा सकता है जो तुलना या गणित संचालन में अनियमित चर के साथ हो सकती हैं। चरों की इस सूची को एक स्थान पर रखने से आप उन सभी चरों को देख सकते हैं जो स्क्रिप्ट में होने चाहिए और उनके प्रारंभिक मान।
आपकी छोटी लिपि में केवल एक ही चर है, $विकल्प , अब तक। दिखाए गए अनुसार निम्न पंक्तियों को सम्मिलित करके इसे सेट करें:
################################################################################
################################################################################
# Main program #
################################################################################
################################################################################
# Initialize variables
option=""
################################################################################
# Process the input options. Add options as needed. #
################################################################################
यह सुनिश्चित करने के लिए इसका परीक्षण करें कि सब कुछ वैसा ही काम करता है जैसा उसे करना चाहिए और इस परिवर्तन के परिणामस्वरूप कुछ भी नहीं टूटा है।
स्थिरांक
स्थिरांक भी परिवर्तनशील होते हैं—कम से कम उन्हें तो होना ही चाहिए। हार्ड-कोडेड मानों के बजाय कमांड-लाइन इंटरफ़ेस (CLI) प्रोग्राम में जहाँ भी संभव हो चर का उपयोग करें। यहां तक कि अगर आपको लगता है कि आप किसी विशेष मान (जैसे निर्देशिका नाम, फ़ाइल नाम, या टेक्स्ट स्ट्रिंग) का केवल एक बार उपयोग करेंगे, तो एक वैरिएबल बनाएं और उसका उपयोग करें जहां आपने हार्ड-कोडेड नाम रखा होगा।
उदाहरण के लिए, प्रोग्राम के मुख्य भाग के भाग के रूप में मुद्रित संदेश एक स्ट्रिंग शाब्दिक है, इको "हैलो वर्ल्ड!" . इसे एक चर में बदलें। सबसे पहले, निम्न कथन को वैरिएबल इनिशियलाइज़ेशन सेक्शन में जोड़ें:
Msg="Hello world!"और अब कार्यक्रम की अंतिम पंक्ति को यहां से बदलें:
echo "Hello world!"करने के लिए:
echo "$Msg"परिणामों का परीक्षण करें।
स्वच्छता जांच
सैनिटी चेक केवल उन स्थितियों के लिए परीक्षण होते हैं जिन्हें प्रोग्राम को सही ढंग से काम करने के लिए सही होने की आवश्यकता होती है, जैसे:प्रोग्राम को रूट उपयोगकर्ता के रूप में चलाया जाना चाहिए, या इसे किसी विशेष वितरण और उस डिस्ट्रो के रिलीज पर चलाना चाहिए। रूट . के लिए एक चेक जोड़ें आपके साधारण प्रोग्राम टेम्पलेट में चल रहे उपयोगकर्ता के रूप में।
यह जांचना कि रूट उपयोगकर्ता प्रोग्राम चला रहा है, आसान है क्योंकि प्रोग्राम उस उपयोगकर्ता के रूप में चलता है जो इसे लॉन्च करता है।
आईडी कमांड का उपयोग प्रोग्राम के तहत चल रहे संख्यात्मक उपयोगकर्ता आईडी (यूआईडी) को निर्धारित करने के लिए किया जा सकता है। जब इसका उपयोग बिना किसी विकल्प के किया जाता है तो यह कई बिट जानकारी प्रदान करता है:
[student@testvm1 ~]$ id
uid=1001(student) gid=1001(student) groups=1001(student),5000(dev)
-u . का उपयोग करना विकल्प केवल उपयोगकर्ता का यूआईडी लौटाता है, जो आपके बैश कार्यक्रम में आसानी से प्रयोग करने योग्य है:
[student@testvm1 ~]$ id -u
1001
[student@testvm1 ~]$
प्रोग्राम में निम्न फ़ंक्शन जोड़ें। मैंने इसे सहायता प्रक्रिया के बाद जोड़ा है, लेकिन आप इसे प्रक्रिया अनुभाग में कहीं भी रख सकते हैं। तर्क यह है कि यदि UID शून्य नहीं है, जो हमेशा रूट उपयोगकर्ता का UID होता है, तो प्रोग्राम बाहर निकल जाता है:
################################################################################
# Check for root. #
################################################################################
CheckRoot()
{
if [ `id -u` != 0 ]
then
echo "ERROR: You must be root user to run this program"
exit
fi
}
अब, चेकरूट . में एक कॉल जोड़ें वेरिएबल के इनिशियलाइज़ेशन से ठीक पहले की प्रक्रिया। इसका परीक्षण करें, पहले प्रोग्राम को छात्र उपयोगकर्ता के रूप में चलाएं:
[student@testvm1 ~]$ ./hello
ERROR: You must be root user to run this program
[student@testvm1 ~]$
फिर रूट यूजर के रूप में:
[root@testvm1 student]# ./hello
Hello world!
[root@testvm1 student]#
हो सकता है कि आपको हमेशा इस विशेष विवेक परीक्षण की आवश्यकता न हो, इसलिए चेकरूट . पर कॉल करके कमेंट करें लेकिन सभी कोड को टेम्पलेट में जगह पर छोड़ दें। इस तरह, भविष्य के प्रोग्राम में उस कोड का उपयोग करने के लिए आपको केवल कॉल को अनकम्मेंट करना है।
कोड
ऊपर बताए गए बदलाव करने के बाद, आपका कोड इस तरह दिखना चाहिए:
#!/usr/bin/bash
################################################################################
# scriptTemplate #
# #
# Use this template as the beginning of a new program. Place a short #
# description of the script here. #
# #
# Change History #
# 11/11/2019 David Both Original code. This is a template for creating #
# new Bash shell scripts. #
# Add new history entries as needed. #
# #
# #
################################################################################
################################################################################
################################################################################
# #
# Copyright (C) 2007, 2019 David Both #
# [email protected] #
# #
# This program is free software; you can redistribute it and/or modify #
# it under the terms of the GNU General Public License as published by #
# the Free Software Foundation; either version 2 of the License, or #
# (at your option) any later version. #
# #
# This program is distributed in the hope that it will be useful, #
# but WITHOUT ANY WARRANTY; without even the implied warranty of #
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the #
# GNU General Public License for more details. #
# #
# You should have received a copy of the GNU General Public License #
# along with this program; if not, write to the Free Software #
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA #
# #
################################################################################
################################################################################
################################################################################
################################################################################
# Help #
################################################################################
Help()
{
# Display Help
echo "Add description of the script functions here."
echo
echo "Syntax: scriptTemplate [-g|h|v|V]"
echo "options:"
echo "g Print the GPL license notification."
echo "h Print this Help."
echo "v Verbose mode."
echo "V Print software version and exit."
echo
}
################################################################################
# Check for root. #
################################################################################
CheckRoot()
{
# If we are not running as root we exit the program
if [ `id -u` != 0 ]
then
echo "ERROR: You must be root user to run this program"
exit
fi
}
################################################################################
################################################################################
# Main program #
################################################################################
################################################################################
################################################################################
# Sanity checks #
################################################################################
# Are we rnning as root?
# CheckRoot
# Initialize variables
option=""
Msg="Hello world!"
################################################################################
# Process the input options. Add options as needed. #
################################################################################
# Get the options
while getopts ":h" option; do
case $option in
h) # display Help
Help
exit;;
\?) # incorrect option
echo "Error: Invalid option"
exit;;
esac
done
echo "$Msg"
एक अंतिम अभ्यास
आपने शायद देखा है कि आपके कोड में सहायता फ़ंक्शन उन सुविधाओं को संदर्भित करता है जो कोड में नहीं हैं। अंतिम अभ्यास के रूप में, उन कार्यों को आपके द्वारा बनाए गए कोड टेम्पलेट में जोड़ने का तरीका जानें।
सारांश
इस लेख में, आपने यह जांचने के लिए कुछ फ़ंक्शन बनाए हैं कि आपका प्रोग्राम रूट के रूप में चल रहा है या नहीं। आपका कार्यक्रम थोड़ा अधिक जटिल होता जा रहा है, इसलिए परीक्षण अधिक महत्वपूर्ण होता जा रहा है और पूर्ण होने के लिए अधिक परीक्षण पथों की आवश्यकता है।
इस श्रृंखला में एक बहुत ही न्यूनतम बैश कार्यक्रम और एक समय में एक स्क्रिप्ट को थोड़ा सा कैसे बनाया जाए, इस पर ध्यान दिया गया। परिणाम एक साधारण टेम्पलेट है जो अन्य, अधिक उपयोगी बैश स्क्रिप्ट के लिए शुरुआती बिंदु हो सकता है और इसमें उपयोगी तत्व होते हैं जो नई स्क्रिप्ट शुरू करना आसान बनाते हैं।
अब तक, आपको यह विचार आता है:संकलित कार्यक्रम आवश्यक हैं और एक बहुत ही महत्वपूर्ण आवश्यकता को पूरा करते हैं। लेकिन sysadmins के लिए, हमेशा एक बेहतर तरीका होता है। अपने कार्य की स्वचालन आवश्यकताओं को पूरा करने के लिए हमेशा शेल स्क्रिप्ट का उपयोग करें। शैल स्क्रिप्ट खुली हैं; उनकी सामग्री और उद्देश्य जानने योग्य हैं। विभिन्न आवश्यकताओं को पूरा करने के लिए उन्हें आसानी से संशोधित किया जा सकता है। मुझे अपनी sysadmin भूमिका में ऐसा कुछ भी नहीं मिला है जो मुझे शेल स्क्रिप्ट के साथ पूरा नहीं किया जा सकता है।
इस श्रंखला में आपने अब तक जो बनाया है, वह तो बस शुरुआत है। जैसे ही आप अधिक बैश प्रोग्राम लिखते हैं, आपको कोड के अधिक बिट मिलेंगे जिनका आप अक्सर उपयोग करते हैं और जिन्हें आपके प्रोग्राम टेम्पलेट में शामिल किया जाना चाहिए।
संसाधन
- बैश के साथ प्रोग्राम कैसे करें:सिंटेक्स और टूल्स
- बैश के साथ प्रोग्राम कैसे करें:लॉजिकल ऑपरेटर्स और शेल एक्सपेंशन
- बैश के साथ प्रोग्राम कैसे करें:लूप्स
लेखों की यह श्रृंखला आंशिक रूप से डेविड दोनों के तीन-भाग वाले लिनक्स स्व-अध्ययन पाठ्यक्रम के खंड 2, अध्याय 10 पर आधारित है, लिनक्स का उपयोग और व्यवस्थापन—जीरो टू SysAdmin।