Bash
पैरामीटर्स के साथ स्क्रिप्टिंग

टिप्पणियों

एकाधिक पैरामीटर पार्सिंग

बहुत सारे मापदंडों को पार्स करने के लिए, ऐसा करने का पसंदीदा तरीका थोड़ी देर के लूप, केस स्टेटमेंट और शिफ्ट का उपयोग करना है ।

shift का उपयोग श्रृंखला में पहले पैरामीटर को पॉप करने के लिए किया जाता है, जो $ 2 हुआ करता था , अब $ 1 हो जाएगा। यह एक समय में एक तर्क संसाधित करने के लिए उपयोगी है।

#!/bin/bash

# Load the user defined parameters
while [[ $# > 0 ]]
do
        case "$1" in

                -a|--valueA)
                        valA="$2"
                        shift
                        ;;

                -b|--valueB)
                        valB="$2"
                        shift
                        ;;

                --help|*)
                        echo "Usage:"
                        echo "    --valueA \"value\""
                        echo "    --valueB \"value\""
                        echo "    --help"
                        exit 1
                        ;;
        esac
        shift
done

echo "A: $valA"
echo "B: $valB"

इनपुट और आउटपुट

$ ./multipleParams.sh --help
Usage:
    --valueA "value"
    --valueB "value"
    --help

$ ./multipleParams.sh
A: 
B:

$ ./multipleParams.sh --valueB 2
A: 
B: 2

$ ./multipleParams.sh --valueB 2 --valueA "hello world"
A: hello world
B: 2

एक्सेस करने वाले पैरामीटर्स

बैश स्क्रिप्ट निष्पादित करते समय, स्क्रिप्ट में दिए गए मापदंडों को उनकी स्थिति के अनुसार नाम दिया जाता है: $1 पहले पैरामीटर का नाम है, $2 दूसरे पैरामीटर का नाम है, और इसी तरह।

एक लापता पैरामीटर बस एक खाली स्ट्रिंग का मूल्यांकन करता है। एक पैरामीटर के अस्तित्व की जाँच निम्नानुसार की जा सकती है:

if [ -z "$1" ]; then
    echo "No argument supplied"
fi

सभी मापदंडों को प्राप्त करना

$@ और $* सभी स्क्रिप्ट मापदंडों के साथ बातचीत करने के तरीके हैं। बैश मैन पेज का संदर्भ लेते हुए, हम देखते हैं कि:

• $* : एक से शुरू होकर स्थितीय मापदंडों का विस्तार करता है। जब विस्तार दोहरे उद्धरण चिह्नों के भीतर होता है, तो यह IFS विशेष चर के पहले वर्ण द्वारा अलग किए गए प्रत्येक पैरामीटर के मूल्य के साथ एक शब्द तक फैलता है।
• $@ : एक से शुरू होकर स्थितीय मापदंडों का विस्तार करता है। जब विस्तार दोहरे कोट्स के भीतर होता है, तो प्रत्येक पैरामीटर एक अलग शब्द में फैलता है।

मापदंडों की संख्या प्राप्त करना

$# को स्क्रिप्ट में दिए गए मापदंडों की संख्या मिलती है। एक सामान्य उपयोग मामला यह जांचने के लिए होगा कि क्या उचित संख्या में तर्क पारित किए गए हैं:

if [ $# -eq 0 ]; then
    echo "No arguments supplied"
fi

उदाहरण 1

सभी तर्कों के माध्यम से लूप करें और जांचें कि क्या वे फाइलें हैं:

for item in "$@"
do  
    if [[ -f $item ]]; then
        echo "$item is a file"
    fi  
done

उदाहरण 2

सभी तर्कों के माध्यम से लूप करें और जांचें कि क्या वे फाइलें हैं:

for (( i = 1; i <= $#; ++ i ))
do
    item=${@:$i:1}

    if [[ -f $item ]]; then
        echo "$item is a file"
    fi  
done

एक लूप के लिए उपयोग करते हुए तर्क पार्सिंग

एक सरल उदाहरण जो विकल्प प्रदान करता है:

#!/bin/bash
dr=''
install=false

skip=false
for op in "$@";do
    if $skip;then skip=false;continue;fi
    case "$op" in
        -v|--version)
            echo "$ver_info"
            shift
            exit 0
            ;;
        -h|--help)
            echo "$help"
            shift
            exit 0
            ;;
        -dr|--doc-root)
            shift
            if [[ "$1" != "" ]]; then
                dr="${1/%\//}"
                shift
                skip=true
            else
                echo "E: Arg missing for -dr option"
                exit 1
            fi
            ;;
        -i|--install)
            install=true
            shift
            ;;
        -*)
            echo "E: Invalid option: $1"
            shift
            exit 1
            ;;
    esac
done

आवरण लिपि

रैपर स्क्रिप्ट एक ऐसी स्क्रिप्ट है जो अतिरिक्त कार्यक्षमता प्रदान करने के लिए या कुछ कम थकाऊ बनाने के लिए एक और स्क्रिप्ट या कमांड लपेटती है।

उदाहरण के लिए, नए GNU / Linux सिस्टम में वास्तविक egrep को egrep नामक आवरण स्क्रिप्ट द्वारा प्रतिस्थापित किया जा रहा है। यह कैसा दिखता है:

#!/bin/sh
exec grep -E "$@"

इसलिए, जब आप ऐसे सिस्टम में egrep चलाते हैं, तो आप वास्तव में आगे दिए गए सभी तर्कों के साथ grep -E चला रहे हैं।

सामान्य स्थिति में, यदि आप एक उदाहरण स्क्रिप्ट चलाना चाहते हैं / किसी अन्य स्क्रिप्ट mexmp साथ कमांड exmp करते हैं तो रैपर mexmp स्क्रिप्ट दिखाई देगी:

#!/bin/sh
exmp "$@" # Add other options before "$@"
# or 
#full/path/to/exmp "$@"

बैश में एक सरणी में स्ट्रिंग विभाजित करें

मान लीजिए कि हमारे पास एक स्ट्रिंग पैरामीटर है और हम इसे अल्पविराम से विभाजित करना चाहते हैं

my_param="foo,bar,bash"

इस तार को अल्पविराम द्वारा विभाजित करने के लिए हम उपयोग कर सकते हैं;

IFS=',' read -r -a array <<< "$my_param"

यहाँ, IFS एक विशेष चर है जिसे आंतरिक क्षेत्र विभाजक कहा जाता है जो वर्ण या वर्णों को कुछ परिचालनों के लिए एक पैटर्न को टोकन में अलग करने के लिए परिभाषित करता है।

एक व्यक्तिगत तत्व तक पहुँचने के लिए:

echo "${array[0]}"

तत्वों पर पुनरावृति करने के लिए:

for element in "${array[@]}"
do
    echo "$element"
done

सूचकांक और मूल्य दोनों प्राप्त करने के लिए:

for index in "${!array[@]}"
do
    echo "$index ${array[index]}"
done