बाश में झंडे के साथ तर्क कैसे प्राप्त करें

Question

मुझे पता है कि मैं आसानी से इस तरह के पैरामीटर को बैश में प्राप्त कर सकता हूं:

$0 या $1

मैं प्रत्येक पैरामीटर का उपयोग करने के लिए निर्दिष्ट करने के लिए इस तरह से ध्वज विकल्पों का उपयोग करने में सक्षम होना चाहता हूं:

mysql -u user -h host

स्थिति के बजाय ध्वज द्वारा -u paramमूल्य और -h paramमूल्य प्राप्त करने का सबसे अच्छा तरीका क्या है ?

Comments

यह एक अच्छा विचार पूछने के लिए / पर अधिक की जाँच हो सकता है unix.stackexchange.com रूप में अच्छी तरह

— MRR0GERS

google "bash getopts" के लिए - बहुत सारे ट्यूटोरियल।

— ग्लेन जैकमैन

@ ग्लेन-जैकमैन: मैं निश्चित रूप से अब इसे गूगल करूंगा कि मुझे नाम पता है। Google के बारे में बात है - एक सवाल पूछने के लिए - आपको पहले से ही उत्तर का 50% पता होना चाहिए।

— Stann

Answer 1

यह आमतौर पर मेरे द्वारा इस्तेमाल किया जाने वाला मुहावरा है:

while test $# -gt 0; do
  case "$1" in
    -h|--help)
      echo "$package - attempt to capture frames"
      echo " "
      echo "$package [options] application [arguments]"
      echo " "
      echo "options:"
      echo "-h, --help                show brief help"
      echo "-a, --action=ACTION       specify an action to use"
      echo "-o, --output-dir=DIR      specify a directory to store output in"
      exit 0
      ;;
    -a)
      shift
      if test $# -gt 0; then
        export PROCESS=$1
      else
        echo "no process specified"
        exit 1
      fi
      shift
      ;;
    --action*)
      export PROCESS=`echo $1 | sed -e 's/^[^=]*=//g'`
      shift
      ;;
    -o)
      shift
      if test $# -gt 0; then
        export OUTPUT=$1
      else
        echo "no output dir specified"
        exit 1
      fi
      shift
      ;;
    --output-dir*)
      export OUTPUT=`echo $1 | sed -e 's/^[^=]*=//g'`
      shift
      ;;
    *)
      break
      ;;
  esac
done

मुख्य बिंदु हैं:

• $# तर्कों की संख्या है
• जबकि लूप आपूर्ति किए गए सभी तर्कों को देखता है, केस स्टेटमेंट के अंदर उनके मूल्यों पर मेल खाता है
• शिफ्ट पहले को दूर ले जाता है। आप कई मान लेने के लिए केस स्टेटमेंट के अंदर कई बार शिफ्ट कर सकते हैं।

Comments

क्या करता है --action*और --output-dir*मामलों करते हैं?

— लुसियो

वे पर्यावरण में प्राप्त मूल्यों को सहेजते हैं।

— फ्लेक्सो

@Lucio सुपर पुरानी टिप्पणी है, लेकिन इसे जोड़ने के मामले में कोई और कभी भी इस पृष्ठ पर जाता है। * (वाइल्डकार्ड) उस मामले के लिए है जहाँ कोई व्यक्ति टाइप --action=[ACTION]करता है और साथ ही साथ जहाँ कोई मामले टाइप करता है--action [ACTION]

— सहयोग

*)आप वहां क्यों टूटते हैं, क्या आपको खराब विकल्प से बाहर नहीं निकलना चाहिए या अनदेखा नहीं करना चाहिए? दूसरे शब्दों -bad -o dirमें -o dirभाग कभी संसाधित नहीं होता है।

— newguy

@ अच्छा सवाल। मुझे लगता है कि मैं उन्हें कुछ और चले जाते जाने के लिए कोशिश कर रहा था

— Flexo

Answer 2

यह उदाहरण बैश के अंतर्निहित getoptsकमांड का उपयोग करता है और Google शेल स्टाइल गाइड से है :

a_flag=''
b_flag=''
files=''
verbose='false'

print_usage() {
  printf "Usage: ..."
}

while getopts 'abf:v' flag; do
  case "${flag}" in
    a) a_flag='true' ;;
    b) b_flag='true' ;;
    f) files="${OPTARG}" ;;
    v) verbose='true' ;;
    *) print_usage
       exit 1 ;;
  esac
done

नोट: यदि किसी वर्ण का बृहदान्त्र (जैसे f:) द्वारा अनुसरण किया जाता है , तो उस विकल्प में तर्क होने की उम्मीद है।

उदाहरण का उपयोग: ./script -v -a -b -f filename

स्वीकार किए गए उत्तर के मुकाबले गेटटॉप का उपयोग करने के कई फायदे हैं:

• जबकि हालत बहुत अधिक पठनीय है और दिखाता है कि स्वीकृत विकल्प क्या हैं
• क्लीनर कोड; मापदंडों और स्थानांतरण की संख्या की गिनती नहीं
• आप विकल्पों में शामिल हो सकते हैं (उदाहरण के लिए -a -b -c→ -abc)

हालांकि, एक बड़ा नुकसान यह है कि यह लंबे विकल्पों का समर्थन नहीं करता है, केवल एकल-वर्ण विकल्प।

Comments

एक आश्चर्य है कि क्यों यह जवाब, एक बैश बिलिन का उपयोग करते हुए, शीर्ष एक नहीं है

— विल बार्नवेल

पश्चात के लिए: 'abf: v' के बाद बृहदान्त्र दर्शाता है कि -f एक अतिरिक्त तर्क लेता है (इस मामले में फ़ाइल नाम)।

— ज़ाहबाज़

मुझे इसमें त्रुटि पंक्ति बदलनी थी:?) printf '\nUsage: %s: [-a] aflag [-b] bflag\n' $0; exit 2 ;;

— एंडी

क्या आप कॉलोन के बारे में एक नोट जोड़ सकते हैं? उस पत्र में प्रत्येक अक्षर के बाद, कोई कोलन का अर्थ कोई arg नहीं है, एक कॉलन का अर्थ arg है, और दो colons का अर्थ है वैकल्पिक arg?

— limasxgoesto0

@WillBarnwell एक को ध्यान देना चाहिए कि यह सवाल पूछे जाने के 3 साल बाद जोड़ा गया था, जबकि उसी दिन शीर्ष उत्तर जोड़ा गया था।

— rbennell

Answer 3

getopt आपका दोस्त है .. एक सरल उदाहरण:

function f () {
TEMP=`getopt --long -o "u:h:" "$@"`
eval set -- "$TEMP"
while true ; do
    case "$1" in
        -u )
            user=$2
            shift 2
        ;;
        -h )
            host=$2
            shift 2
        ;;
        *)
            break
        ;;
    esac 
done;

echo "user = $user, host = $host"
}

f -u myself -h some_host

आपके / usr / बिन निर्देशिका में विभिन्न उदाहरण होने चाहिए।

Comments

एक अधिक व्यापक उदाहरण निर्देशिका में पाया जा सकता है /usr/share/doc/util-linux/examples, बहुत कम से कम उबंटू मशीनों पर।

— सर्ज स्ट्रोबोबांट

Answer 4

मुझे लगता है कि यह एक सरल उदाहरण के रूप में काम करेगा, जिसे आप हासिल करना चाहते हैं। बाहरी उपकरणों का उपयोग करने की कोई आवश्यकता नहीं है। टूल में बने बैश आपके लिए काम कर सकते हैं।

function DOSOMETHING {

   while test $# -gt 0; do
           case "$1" in
                -first)
                    shift
                    first_argument=$1
                    shift
                    ;;
                -last)
                    shift
                    last_argument=$1
                    shift
                    ;;
                *)
                   echo "$1 is not a recognized flag!"
                   return 1;
                   ;;
          esac
  done  

  echo "First argument : $first_argument";
  echo "Last argument : $last_argument";
 }

यह आपको झंडे का उपयोग करने की अनुमति देगा ताकि कोई फर्क नहीं पड़ता कि आप किस क्रम में मापदंडों को पार कर रहे हैं जो आपको उचित व्यवहार मिलेगा।

उदाहरण :

 DOSOMETHING -last "Adios" -first "Hola"

आउटपुट:

 First argument : Hola
 Last argument : Adios

आप इस फ़ंक्शन को अपनी प्रोफ़ाइल में जोड़ सकते हैं या स्क्रिप्ट के अंदर रख सकते हैं।

धन्यवाद!

संपादित करें: इसे आ फ़ाइल के रूप में सहेजें और फिर इसे निष्पादित करें yourfile.sh -last "Adios" -first "Hola"

#!/bin/bash
while test $# -gt 0; do
           case "$1" in
                -first)
                    shift
                    first_argument=$1
                    shift
                    ;;
                -last)
                    shift
                    last_argument=$1
                    shift
                    ;;
                *)
                   echo "$1 is not a recognized flag!"
                   return 1;
                   ;;
          esac
  done  

  echo "First argument : $first_argument";
  echo "Last argument : $last_argument";

Comments

मैं कोड से ऊपर का उपयोग करता हूं और जब इसे चलाता हूं तो यह कुछ भी प्रिंट नहीं कर रहा है। ./hello.sh DOSOMETHING -last "Adios" -first "Hola"

— दिनु ०१०१

@ dinu0101 यह एक समारोह है। स्क्रिप्ट नहीं। आपको इसे DOSOMETHING -last "Adios" -first "होला" के रूप में उपयोग करना चाहिए

— Matias Barrios

साभार @Matias समझ लिया। स्क्रिप्ट के अंदर कैसे चला जाए।

— दिनू 01

बहुत बहुत धन्यवाद @Matias

— dinu0101

MacOS पर return 1;अंतिम उदाहरण आउटपुट के साथ प्रयोग करना can only 'return' from a function or sourced script। पर स्विच किया exit 1;काम करता है जैसे कि उम्मीद थी।

— मत्तीस

Answer 5

एक अन्य विकल्प है जो आप लंबे समय का उपयोग करने की अनुमति होगी उदाहरण नीचे की तरह कुछ का उपयोग करने के होगा --image या कम मैं टैग और भी अनुमति देने के संकलित मैं = "example.jpg" या अलग मैं example.jpg बहस में गुजर के तरीके ।

# declaring a couple of associative arrays
declare -A arguments=();  
declare -A variables=();

# declaring an index integer
declare -i index=1;

# any variables you want to use here
# on the left left side is argument label or key (entered at the command line along with it's value) 
# on the right side is the variable name the value of these arguments should be mapped to.
# (the examples above show how these are being passed into this script)
variables["-gu"]="git_user";  
variables["--git-user"]="git_user";  
variables["-gb"]="git_branch";  
variables["--git-branch"]="git_branch";  
variables["-dbr"]="db_fqdn";  
variables["--db-redirect"]="db_fqdn";  
variables["-e"]="environment";  
variables["--environment"]="environment";

# $@ here represents all arguments passed in
for i in "$@"  
do  
  arguments[$index]=$i;
  prev_index="$(expr $index - 1)";

  # this if block does something akin to "where $i contains ="
  # "%=*" here strips out everything from the = to the end of the argument leaving only the label
  if [[ $i == *"="* ]]
    then argument_label=${i%=*} 
    else argument_label=${arguments[$prev_index]}
  fi

  # this if block only evaluates to true if the argument label exists in the variables array
  if [[ -n ${variables[$argument_label]} ]]
    then
        # dynamically creating variables names using declare
        # "#$argument_label=" here strips out the label leaving only the value
        if [[ $i == *"="* ]]
            then declare ${variables[$argument_label]}=${i#$argument_label=} 
            else declare ${variables[$argument_label]}=${arguments[$index]}
        fi
  fi

  index=index+1;
done;

# then you could simply use the variables like so:
echo "$git_user";

Answer 6

मुझे रॉबर्ट मैकमैहन का उत्तर यहाँ सबसे अच्छा लगता है क्योंकि यह उपयोग करने में सबसे आसान लगता है जिसमें आपकी किसी भी स्क्रिप्ट का उपयोग करने के लिए फाइलें शामिल हैं। लेकिन यह if [[ -n ${variables[$argument_label]} ]]संदेश फेंकने वाली रेखा के साथ दोष लगता है , "चर: खराब सरणी सबस्क्रिप्ट"। मेरे पास टिप्पणी करने का प्रतिनिधि नहीं है, और मुझे संदेह है कि यह उचित 'फिक्स' है, लेकिन इसे साफ करने ifमें लपेटना if [[ -n $argument_label ]] ; then।

यहाँ कोड मेरे साथ समाप्त हुआ है, यदि आप एक बेहतर तरीका जानते हैं तो कृपया रॉबर्ट के उत्तर में एक टिप्पणी जोड़ें।

फ़ाइल शामिल करें "झंडे- declares.sh"

# declaring a couple of associative arrays
declare -A arguments=();
declare -A variables=();

# declaring an index integer
declare -i index=1;

फ़ाइल शामिल करें "झंडे- तर्क"

# $@ here represents all arguments passed in
for i in "$@"
do
  arguments[$index]=$i;
  prev_index="$(expr $index - 1)";

  # this if block does something akin to "where $i contains ="
  # "%=*" here strips out everything from the = to the end of the argument leaving only the label
  if [[ $i == *"="* ]]
    then argument_label=${i%=*}
    else argument_label=${arguments[$prev_index]}
  fi

  if [[ -n $argument_label ]] ; then
    # this if block only evaluates to true if the argument label exists in the variables array
    if [[ -n ${variables[$argument_label]} ]] ; then
      # dynamically creating variables names using declare
      # "#$argument_label=" here strips out the label leaving only the value
      if [[ $i == *"="* ]]
        then declare ${variables[$argument_label]}=${i#$argument_label=} 
        else declare ${variables[$argument_label]}=${arguments[$index]}
      fi
    fi
  fi

  index=index+1;
done;

आपका "script.sh"

. bin/includes/flags-declares.sh

# any variables you want to use here
# on the left left side is argument label or key (entered at the command line along with it's value) 
# on the right side is the variable name the value of these arguments should be mapped to.
# (the examples above show how these are being passed into this script)
variables["-gu"]="git_user";
variables["--git-user"]="git_user";
variables["-gb"]="git_branch";
variables["--git-branch"]="git_branch";
variables["-dbr"]="db_fqdn";
variables["--db-redirect"]="db_fqdn";
variables["-e"]="environment";
variables["--environment"]="environment";

. bin/includes/flags-arguments.sh

# then you could simply use the variables like so:
echo "$git_user";
echo "$git_branch";
echo "$db_fqdn";
echo "$environment";

Answer 7

यदि आप पाइथन के अर्गपर्स से परिचित हैं, और बश दलीलों को पार्स करने के लिए अजगर को बुलाने से गुरेज नहीं करते हैं, तो एक ऐसा कोड है, जिसे मैं सच में उपयोगी और सुपर आसान कहलाता हूँ जिसे अर्गपर्स-बैश https:// github -nhoffman/ कहा जाता है। argparse-बैश

उदाहरण उनके example.sh स्क्रिप्ट से लेते हैं:

#!/bin/bash

source $(dirname $0)/argparse.bash || exit 1
argparse "$@" <<EOF || exit 1
parser.add_argument('infile')
parser.add_argument('outfile')
parser.add_argument('-a', '--the-answer', default=42, type=int,
                    help='Pick a number [default %(default)s]')
parser.add_argument('-d', '--do-the-thing', action='store_true',
                    default=False, help='store a boolean [default %(default)s]')
parser.add_argument('-m', '--multiple', nargs='+',
                    help='multiple values allowed')
EOF

echo required infile: "$INFILE"
echo required outfile: "$OUTFILE"
echo the answer: "$THE_ANSWER"
echo -n do the thing?
if [[ $DO_THE_THING ]]; then
    echo " yes, do it"
else
    echo " no, do not do it"
fi
echo -n "arg with multiple values: "
for a in "${MULTIPLE[@]}"; do
    echo -n "[$a] "
done
echo

Answer 8

मैं एक साधारण TLDR का प्रस्ताव करता हूं :; संयुक्त राष्ट्र के लिए उदाहरण।

Bash script बनाएं, जिसे helloworld.sh कहा जाता है

#!/bin/bash

while getopts "n:" arg; do
  case $arg in
    n) Name=$OPTARG;;
  esac
done

echo "Hello $Name!"

आप -nस्क्रिप्ट निष्पादित करते समय एक वैकल्पिक पैरामीटर पास कर सकते हैं ।

स्क्रिप्ट को इस तरह निष्पादित करें:

$ bash helloworld.sh -n 'World'

उत्पादन

$ Hello World!

टिप्पणियाँ

यदि आप कई मापदंडों का उपयोग करना चाहते हैं:

1. विस्तार while getops "n:" arg: doजैसे अधिक paramaters के साथ while getops "n:o:p:" arg: do
2. अतिरिक्त चर असाइनमेंट के साथ केस स्विच का विस्तार करें। जैसे o) Option=$OPTARGऔरp) Parameter=$OPTARG

Answer 9

#!/bin/bash

if getopts "n:" arg; then
  echo "Welcome $OPTARG"
fi

इसे sample.sh के रूप में सहेजें और चलाने का प्रयास करें

sh sample.sh -n John

अपने टर्मिनल में।

Answer 10

मुझे कई झंडों के साथ गेटटॉप का उपयोग करने में परेशानी हुई, इसलिए मैंने यह कोड लिखा। यह झंडे का पता लगाने के लिए, और चर को तर्क देने के लिए उन झंडे का उपयोग करने के लिए एक मोडल चर का उपयोग करता है।

ध्यान दें, यदि ध्वज में तर्क नहीं होना चाहिए, तो CURRENTFLAG सेट करने के अलावा कुछ किया जा सकता है।

    for MYFIELD in "$@"; do

        CHECKFIRST=`echo $MYFIELD | cut -c1`

        if [ "$CHECKFIRST" == "-" ]; then
            mode="flag"
        else
            mode="arg"
        fi

        if [ "$mode" == "flag" ]; then
            case $MYFIELD in
                -a)
                    CURRENTFLAG="VARIABLE_A"
                    ;;
                -b)
                    CURRENTFLAG="VARIABLE_B"
                    ;;
                -c)
                    CURRENTFLAG="VARIABLE_C"
                    ;;
            esac
        elif [ "$mode" == "arg" ]; then
            case $CURRENTFLAG in
                VARIABLE_A)
                    VARIABLE_A="$MYFIELD"
                    ;;
                VARIABLE_B)
                    VARIABLE_B="$MYFIELD"
                    ;;
                VARIABLE_C)
                    VARIABLE_C="$MYFIELD"
                    ;;
            esac
        fi
    done

Answer 11

तो यहाँ यह मेरा समाधान है। मैं हाइफन के बिना बूलियन झंडे को संभालने में सक्षम होना चाहता था, एक हाइफ़न के साथ, और दो हाइफ़न के साथ-साथ एक / दो हाइफ़न के साथ पैरामीटर / मान असाइनमेंट।

# Handle multiple types of arguments and prints some variables
#
# Boolean flags
# 1) No hyphen
#    create   Assigns `true` to the variable `CREATE`.
#             Default is `CREATE_DEFAULT`.
#    delete   Assigns true to the variable `DELETE`.
#             Default is `DELETE_DEFAULT`.
# 2) One hyphen
#      a      Assigns `true` to a. Default is `false`.
#      b      Assigns `true` to b. Default is `false`.
# 3) Two hyphens
#    cats     Assigns `true` to `cats`. By default is not set.
#    dogs     Assigns `true` to `cats`. By default is not set.
#
# Parameter - Value
# 1) One hyphen
#      c      Assign any value you want
#      d      Assign any value you want
#
# 2) Two hyphens
#   ... Anything really, whatever two-hyphen argument is given that is not
#       defined as flag, will be defined with the next argument after it.
#
# Example:
# ./parser_example.sh delete -a -c VA_1 --cats --dir /path/to/dir
parser() {
    # Define arguments with one hyphen that are boolean flags
    HYPHEN_FLAGS="a b"
    # Define arguments with two hyphens that are boolean flags
    DHYPHEN_FLAGS="cats dogs"

    # Iterate over all the arguments
    while [ $# -gt 0 ]; do
        # Handle the arguments with no hyphen
        if [[ $1 != "-"* ]]; then
            echo "Argument with no hyphen!"
            echo $1
            # Assign true to argument $1
            declare $1=true
            # Shift arguments by one to the left
            shift
        # Handle the arguments with one hyphen
        elif [[ $1 == "-"[A-Za-z0-9]* ]]; then
            # Handle the flags
            if [[ $HYPHEN_FLAGS == *"${1/-/}"* ]]; then
                echo "Argument with one hyphen flag!"
                echo $1
                # Remove the hyphen from $1
                local param="${1/-/}"
                # Assign true to $param
                declare $param=true
                # Shift by one
                shift
            # Handle the parameter-value cases
            else
                echo "Argument with one hyphen value!"
                echo $1 $2
                # Remove the hyphen from $1
                local param="${1/-/}"
                # Assign argument $2 to $param
                declare $param="$2"
                # Shift by two
                shift 2
            fi
        # Handle the arguments with two hyphens
        elif [[ $1 == "--"[A-Za-z0-9]* ]]; then
            # NOTE: For double hyphen I am using `declare -g $param`.
            #   This is the case because I am assuming that's going to be
            #   the final name of the variable
            echo "Argument with two hypens!"
            # Handle the flags
            if [[ $DHYPHEN_FLAGS == *"${1/--/}"* ]]; then
                echo $1 true
                # Remove the hyphens from $1
                local param="${1/--/}"
                # Assign argument $2 to $param
                declare -g $param=true
                # Shift by two
                shift
            # Handle the parameter-value cases
            else
                echo $1 $2
                # Remove the hyphens from $1
                local param="${1/--/}"
                # Assign argument $2 to $param
                declare -g $param="$2"
                # Shift by two
                shift 2
            fi
        fi

    done
    # Default value for arguments with no hypheb
    CREATE=${create:-'CREATE_DEFAULT'}
    DELETE=${delete:-'DELETE_DEFAULT'}
    # Default value for arguments with one hypen flag
    VAR1=${a:-false}
    VAR2=${b:-false}
    # Default value for arguments with value
    # NOTE1: This is just for illustration in one line. We can well create
    #   another function to handle this. Here I am handling the cases where
    #   we have a full named argument and a contraction of it.
    #   For example `--arg1` can be also set with `-c`.
    # NOTE2: What we are doing here is to check if $arg is defined. If not,
    #   check if $c was defined. If not, assign the default value "VD_"
    VAR3=$(if [[ $arg1 ]]; then echo $arg1; else echo ${c:-"VD_1"}; fi)
    VAR4=$(if [[ $arg2 ]]; then echo $arg2; else echo ${d:-"VD_2"}; fi)
}


# Pass all the arguments given to the script to the parser function
parser "$@"


echo $CREATE $DELETE $VAR1 $VAR2 $VAR3 $VAR4 $cats $dir

कुछ संदर्भ

• मुख्य प्रक्रिया यहां पाई गई थी ।
• अधिक एक समारोह के लिए सभी तर्क गुजर के बारे में यहाँ ।
• डिफ़ॉल्ट मूल्यों के बारे में अधिक जानकारी यहाँ ।
• बारे में अधिक जानकारी declareकरते हैं $ bash -c "help declare"।
• बारे में अधिक जानकारी shiftकरते हैं $ bash -c "help shift"।