Bash
नियंत्रण संरचनाएं

वाक्य - विन्यास

• ["$ 1" = "$ 2"] #A "[" ब्रैकेट वास्तव में एक कमांड है। इस वजह से इसके लिए और उसके बाद एक जगह की आवश्यकता होती है।
• परीक्षण "$ 1" = "$ 2" # टेस्ट "[" कमांड का एक पर्याय है

पैरामीटर

टिप्पणियों

अगर बयान

if [[ $1 -eq 1 ]]; then
    echo "1 was passed in the first parameter"
elif [[ $1 -gt 2 ]]; then
    echo "2 was not passed in the first parameter"
else
    echo "The first parameter was not 1 and is not more than 2."
fi

समापन fi आवश्यक है, लेकिन elif और / या else खंड छोड़ा जा सकता है।

then से पहले अर्धविराम एक पंक्ति में दो आदेशों के संयोजन के लिए मानक वाक्यविन्यास हैं; उन्हें केवल तभी छोड़ा जा सकता है जब then अगली पंक्ति में ले जाया जाए।

यह समझना महत्वपूर्ण है कि कोष्ठक [[ वाक्य रचना का हिस्सा नहीं हैं, लेकिन एक कमांड के रूप में माना जाता है; यह इस आदेश से बाहर निकलने का कोड है जिसका परीक्षण किया जा रहा है। इसलिए, आपको हमेशा कोष्ठक के चारों ओर रिक्त स्थान शामिल करना चाहिए।

इसका मतलब यह भी है कि किसी भी आदेश के परिणाम का परीक्षण किया जा सकता है। यदि कमांड से निकास कोड शून्य है, तो कथन को सत्य माना जाता है।

if grep "foo" bar.txt; then
    echo "foo was found"
else
    echo "foo was not found"
fi

गणितीय अभिव्यक्तियाँ, जब डबल कोष्ठक के अंदर रखी जाती हैं, उसी तरह 0 या 1 भी लौटाती हैं, और इसका परीक्षण भी किया जा सकता है:

if (( $1 + 5 > 91 )); then
    echo "$1 is greater than 86"
fi

if एकल कोष्ठक के साथ कथन हैं, if आप भर में भी आ सकते हैं। ये POSIX मानक में परिभाषित किए गए हैं और Bash सहित सभी POSIX- संगत गोले में काम करने की गारंटी है। वाक्य रचना बाश में बहुत समान है:

if [ "$1" -eq 1 ]; then
    echo "1 was passed in the first parameter"
elif [ "$1" -gt 2 ]; then
    echo "2 was not passed in the first parameter"
else
    echo "The first parameter was not 1 and is not more than 2."
fi

घुमाव के दौरान

#! /bin/bash

i=0

while [ $i -lt 5 ] #While i is less than 5
do
    echo "i is currently $i"
    i=$[$i+1] #Not the lack of spaces around the brackets. This makes it a not a test expression
done #ends the loop

देखें कि परीक्षण के दौरान कोष्ठक के चारों ओर रिक्त स्थान हैं (बाद के बयान के बाद)। ये रिक्त स्थान आवश्यक हैं।

यह लूप आउटपुट:

i is currently 0
i is currently 1
i is currently 2
i is currently 3
i is currently 4

पाश के लिए

#! /bin/bash

for i in 1 "test" 3; do #Each space separated statement is assigned to i
    echo $i
done

अन्य कमांड लूप ओवर पर स्टेटमेंट जेनरेट कर सकते हैं। "संख्याओं में फेरबदल के लिए लूप का उपयोग करना" उदाहरण देखें।

यह आउटपुट:

1
test
3

संख्याओं की सूची को अलग करने के लिए लूप का उपयोग करना

#! /bin/bash

for i in {1..10}; do # {1..10} expands to "1 2 3 4 5 6 7 8 9 10"
    echo $i
done

यह निम्न आउटपुट देता है:

1
2
3
4
5
6
7
8
8
10

सी-स्टाइल सिंटैक्स के साथ लूप के लिए

लूप के for C- शैली का मूल प्रारूप है:

for (( variable assignment; condition; iteration process ))

टिप्पणियाँ:

• लूप के for सी-स्टाइल के अंदर चर के असाइनमेंट में सामान्य असाइनमेंट के विपरीत रिक्त स्थान हो सकते हैं
• लूप के for C- स्टाइल के अंदर चर $ पहले नहीं हैं।

उदाहरण:

for (( i = 0; i < 10; i++ ))
do
    echo "The iteration number is $i"
done

इसके अलावा हम सी-शैली के अंदर कई चर पर कार्रवाई कर सकते हैं for पाश:

for (( i = 0, j = 0; i < 10; i++, j = i * i ))
do
    echo "The square of $i is equal to $j"
done

लूप तक

जब तक स्थिति सही नहीं होती तब तक लूप निष्पादित होता है

i=5
until [[ i -eq 10 ]]; do #Checks if i=10
    echo "i=$i" #Print the value of i
    i=$((i+1)) #Increment i by 1
done

आउटपुट:

i=5
i=6
i=7
i=8
i=9

जब i लूप के सही होने तक 10 की स्थिति में पहुंच जाता i और लूप समाप्त हो जाता है।

जारी रखें और तोड़ें

जारी रखने के लिए उदाहरण

for i in [series]
do
    command 1
    command 2
    if (condition) # Condition to jump over command 3
            continue # skip to the next value in "series"
    fi
    command 3
done

ब्रेक के लिए उदाहरण

for i in [series]
do
    command 4
    if (condition) # Condition to break the loop
    then
            command 5 # Command if the loop needs to be broken
            break
    fi
    command 6 # Command to run if the "condition" is never true 
done

एक सरणी पर लूपिंग

for पाश:

arr=(a b c d e f)
for i in "${arr[@]}";do
    echo "$i"
done

या

for ((i=0;i<${#arr[@]};i++));do
    echo "${arr[$i]}" 
done

while लूप:

i=0
while [ $i -lt ${#arr[@]} ];do
    echo "${arr[$i]}"
    i=$(expr $i + 1)
done

या

i=0
while (( $i < ${#arr[@]} ));do
    echo "${arr[$i]}"
    ((i++))
done

लूप ब्रेक

कई लूप तोड़ें:

arr=(a b c d e f)
for i in "${arr[@]}";do
    echo "$i"
    for j in "${arr[@]}";do
        echo "$j"
        break 2
    done
done

आउटपुट:

a
a

सिंगल लूप तोड़ें:

arr=(a b c d e f)
for i in "${arr[@]}";do
    echo "$i"
    for j in "${arr[@]}";do
        echo "$j"
        break
    done
done

आउटपुट:

a
a
b
a
c
a
d
a
e
a
f
a

केस के साथ स्विच स्टेटमेंट

case स्टेटमेंट के साथ आप एक वैरिएबल के विरुद्ध मानों का मिलान कर सकते हैं।

case में दिए गए तर्क का विस्तार किया गया है और प्रत्येक पैटर्न के खिलाफ मिलान करने का प्रयास किया गया है।

यदि कोई मिलान पाया जाता है, तो आदेश तक ;; निष्पादित कर रहे हैं।

case "$BASH_VERSION" in
 [34]*)
    echo {1..4}
    ;;  
  *)
    seq -s" " 1 4
esac

पैटर्न नियमित अभिव्यक्ति नहीं हैं लेकिन शेल पैटर्न मिलान (उर्फ ग्लब्स) हैं।

सूची-के-शब्द पैरामीटर के बिना लूप के लिए

for arg; do
    echo arg=$arg
done

शब्दों की एक सूची के बिना लूप के for पैरामीटर इसके बजाय स्थितीय मापदंडों पर पुनरावृत्ति करेगा। दूसरे शब्दों में, उपरोक्त उदाहरण इस कोड के बराबर है:

for arg in "$@"; do
    echo arg=$arg
done

दूसरे शब्दों में, यदि आप for i in "$@"; do ...; done खुद को लिखने के for i in "$@"; do ...; done पकड़ते हैं for i in "$@"; do ...; done , बस भाग in छोड़, और for i; do ...; done बस के for i; do ...; done लिख for i; do ...; done ।

कमांड सूचियों का सशर्त निष्पादन

कमांड सूचियों के सशर्त निष्पादन का उपयोग कैसे करें

किसी भी अंतर्निहित कमांड, अभिव्यक्ति, या फ़ंक्शन, साथ ही किसी भी बाहरी कमांड या स्क्रिप्ट को सशर्त रूप से && (और) का उपयोग करके निष्पादित किया जा सकता है || (या) ऑपरेटर।

उदाहरण के लिए, यह केवल वर्तमान निर्देशिका को प्रिंट करेगा यदि cd कमांड सफल था।

cd my_directory && pwd

इसी तरह, अगर cd कमांड विफल हो जाती है तो यह बाहर निकल जाएगा, तबाही को रोक सकता है:

cd my_directory || exit
rm -rf *

इस तरह से कई बयानों को जोड़ते समय, यह याद रखना महत्वपूर्ण है कि (कई सी-शैली भाषाओं के विपरीत) इन ऑपरेटरों की कोई पूर्वता नहीं है और बाएं-सहयोगी हैं ।

इस प्रकार, यह कथन उम्मीद के मुताबिक काम करेगा ...

cd my_directory && pwd || echo "No such directory"

• यदि cd सफल होता है, तो && pwd निष्पादित होता है और वर्तमान कार्यशील निर्देशिका नाम मुद्रित होता है। जब तक pwd विफल (एक दुर्लभ) || echo ... निष्पादित नहीं किया जाएगा।
• अगर cd विफल होता है, && pwd को छोड़ दिया जाएगा और || echo ... चलेगी।

लेकिन यह नहीं होगा (यदि आप सोच रहे हैं if...then...else ) ...

cd my_directory && ls || echo "No such directory"

• अगर cd विफल हो जाता है, && ls छोड़ दिया जाता है और || echo ... निष्पादित किया जाता है।
• यदि cd सफल होता है, तो && ls निष्पादित किया जाता है।
  • यदि ls सफल होता है, || echo ... को नजरअंदाज किया जाता है। (अब तक तो सब ठीक है)
  • लेकिन ... अगर ls विफल रहता है, || echo ... भी निष्पादित किया जाएगा।

    यह ls , cd नहीं, यह पिछले कमांड है ।

कमांड सूचियों के सशर्त निष्पादन का उपयोग क्यों करें

सशर्त निष्पादन एक बाल की तुलना में तेजी से होता है if...then लेकिन इसका मुख्य लाभ फ़ंक्शंस और स्क्रिप्ट को जल्दी या "शॉर्ट सर्किट" से बाहर निकलने की अनुमति देता है।

C जैसी कई भाषाओं के विपरीत, जहाँ मेमोरी को स्पष्ट रूप से स्ट्रक्चर्स और वैरिएबल्स के लिए आवंटित किया जाता है और इस तरह (और इस तरह डीलॉक्लेट किया जाना चाहिए), bash कवर के तहत इसे हैंडल करता है। ज्यादातर मामलों में, हमें फंक्शन छोड़ने से पहले कुछ भी साफ नहीं करना पड़ता है। स्टैक पर रिटर्न एड्रेस पर एक return स्टेटमेंट फंक्शन के लिए लोकल और पिकअप एक्जीक्यूशन के बारे में सब कुछ बताएगा।

फ़ंक्शंस से लौटना या जितनी जल्दी हो सके स्क्रिप्ट से बाहर निकलना, इस प्रकार कोड के अनावश्यक निष्पादन से बचने के द्वारा प्रदर्शन में काफी सुधार कर सकता है और सिस्टम लोड को कम कर सकता है। उदाहरण के लिए...

my_function () {

    ### ALWAYS CHECK THE RETURN CODE

    # one argument required. "" evaluates to false(1)
    [[ "$1" ]]             || return 1

    # work with the argument. exit on failure
    do_something_with "$1" || return 1
    do_something_else      || return 1

    # Success! no failures detected, or we wouldn't be here
    return 0
}