mjhjmtu

If you don't mind being limited to single-letter argument names i.e. my_script -p '/some/path' -a5, then in bash you could use the built-in getopts, e.g.

#!/bin/bash

while getopts ":a:p:" opt; do
 case $opt in
 a) arg_1="$OPTARG"
 ;;
 p) p_out="$OPTARG"
 ;;
 ?) echo "Invalid option -$OPTARG" >&2
 ;;
 esac
done

printf "Argument p_out is %sn" "$p_out"
printf "Argument arg_1 is %sn" "$arg_1"

Then you can do

$ ./my_script -p '/some/path' -a5
Argument p_out is /some/path
Argument arg_1 is 5

There is a helpful Small getopts tutorial or you can type help getopts at the shell prompt.

I stole this from drupal.org, but you could do something like this:

while [ $# -gt 0 ]; do
 case "$1" in
 --p_out=*)
 p_out="$1#*="
 ;;
 --arg_1=*)
 arg_1="$1#*="
 ;;
 *)
 printf "***************************n"
 printf "* Error: Invalid argument.*n"
 printf "***************************n"
 exit 1
 esac
 shift
done

The only caveat is that you have to use the syntax my_script --p_out=/some/path --arg_1=5.

I use this script and works like a charm:

for ARGUMENT in "$@"
do

 KEY=$(echo $ARGUMENT | cut -f1 -d=)
 VALUE=$(echo $ARGUMENT | cut -f2 -d=) 

 case "$KEY" in
 STEPS) STEPS=$VALUE ;;
 REPOSITORY_NAME) REPOSITORY_NAME=$VALUE ;; 
 *) 
 esac 


done

echo "STEPS = $STEPS"
echo "REPOSITORY_NAME = $REPOSITORY_NAME"

Usage

bash my_scripts.sh STEPS="ABC" REPOSITORY_NAME="stackexchange"

Console result :

STEPS = ABC
REPOSITORY_NAME = stackexchange

STEPS and REPOSITORY_NAME are ready to use in the script.

It does not matter what order the arguments are in.

Hope this helps.

With zsh, you'd use zparseopts:

#! /bin/zsh -
zmodload zsh/zutil
zparseopts -A ARGUMENTS -p_out: -arg_1:

p_out=$ARGUMENTS[--p_out]
arg1=$ARGUMENTS[--arg_1]

printf 'Argument p_out is "%s"n' "$p_out"
printf 'Argument arg_1 is "%s"n' "$arg_1"

But you'd call the script with myscript --p_out foo.

Note that zparseopts doesn't support abbreviating long options or the --p_out=foo syntax like GNU getopt(3) does.

I just came up with this script

while [ $# -gt 0 ]; do

 if [[ $1 == *"--"* ]]; then
 v="$1/--/"
 declare $v="$2"
 fi

 shift
done

pass it like my_script --p_out /some/path --arg_1 5 and then in the script you can use $arg_1 and $p_out.

If a function or an application has more than zero arguments, it always has a last argument.

If you want to read option flag and value pairs, as in:
$ ./t.sh -o output -i input -l last

And you want to accept a variable number of option/value pairs,

And do not want a huge "if .. then .. else .. fi" tree,

Then after checking for an argument count of non-zero and even,

Write a while loop with these four eval statements as the body, followed by a case statement using the two values determined in each pass through the loop.

The tricky part of the scripting is demonstrated here:

#!/bin/sh 

# For each pair - this chunk is hard coded for the last pair.
eval TMP="'$'$#"
eval "PICK=$TMP"
eval TMP="'$'$(($#-1))"
eval "OPT=$TMP"

# process as required - usually a case statement on $OPT
echo "$OPT n $PICK"

# Then decrement the indices (as in third eval statement) 

:<< EoF_test
$ ./t.sh -o output -i input -l last
-l 
last
$ ./t.sh -o output -l last
-l 
last
$ ./t.sh -l last
-l 
last
EoF_test