Bash Shell Script:busque una bandera y tome su valor

Pruebe shFlags:biblioteca avanzada de indicadores de línea de comandos para scripts de shell de Unix.

http://code.google.com/p/shflags/

Es muy bueno y muy flexible.

TIPOS DE BANDERAS:Esta es una lista de DEFINE_*'s que puede hacer. Todas las banderas toman un nombre, un valor predeterminado, una cadena de ayuda y un nombre 'corto' opcional (nombre de una letra). Algunas banderas tienen otros argumentos, que se describen con la bandera.

DEFINE_string:toma cualquier entrada y la interpreta como una cadena.

DEFINE_boolean:normalmente no acepta ningún argumento:diga --myflag para establecer FLAGS_myflag en verdadero, o --nomyflag para establecer FLAGS_myflag en falso. Alternativamente, puede decir --myflag=true o --myflag=t o --myflag=0 o --myflag=false o --myflag=f o --myflag=1Pasar una opción tiene el mismo efecto que pasar la opción una vez.

DEFINE_float:toma una entrada y la interpreta como un número de coma flotante. Como Shell no admite flotantes en sí, la entrada simplemente se valida como un valor de punto flotante válido.

DEFINE_integer:toma una entrada y la interpreta como un número entero.

BANDERAS ESPECIALES:Hay algunas banderas que tienen un significado especial:--ayuda (o -?) imprime una lista de todas las banderas en una forma legible por humanos--flagfile=foo lee las banderas de foo. (aún no implementado)-- como en getopt(), finaliza el procesamiento de banderas

EJEMPLO DE USO:

-- begin hello.sh --
 ! /bin/sh
. ./shflags
DEFINE_string name 'world' "somebody's name" n
FLAGS "[email protected]" || exit $?
eval set -- "${FLAGS_ARGV}"
echo "Hello, ${FLAGS_name}."
-- end hello.sh --

$ ./hello.sh -n Kate
Hello, Kate.

Nota:tomé este texto de la documentación de shflags

Aquí hay una interfaz de argumento de comando simple generalizada que puede pegar en la parte superior de todos sus scripts.

#!/bin/bash

declare -A flags
declare -A booleans
args=()

while [ "$1" ];
do
    arg=$1
    if [ "${1:0:1}" == "-" ]
    then
      shift
      rev=$(echo "$arg" | rev)
      if [ -z "$1" ] || [ "${1:0:1}" == "-" ] || [ "${rev:0:1}" == ":" ]
      then
        bool=$(echo ${arg:1} | sed s/://g)
        booleans[$bool]=true
        echo \"$bool\" is boolean
      else
        value=$1
        flags[${arg:1}]=$value
        shift
        echo \"$arg\" is flag with value \"$value\"
      fi
    else
      args+=("$arg")
      shift
      echo \"$arg\" is an arg
    fi
done


echo -e "\n"
echo booleans: ${booleans[@]}
echo flags: ${flags[@]}
echo args: ${args[@]}

echo -e "\nBoolean types:\n\tPrecedes Flag(pf): ${booleans[pf]}\n\tFinal Arg(f): ${booleans[f]}\n\tColon Terminated(Ct): ${booleans[Ct]}\n\tNot Mentioned(nm): ${boolean[nm]}"
echo -e "\nFlag: myFlag => ${flags["myFlag"]}"
echo -e "\nArgs: one: ${args[0]}, two: ${args[1]}, three: ${args[2]}"

Ejecutando el comando:

bashScript.sh firstArg -pf -myFlag "my flag value" secondArg -Ct: thirdArg -f

La salida será esta:

"firstArg" is an arg
"pf" is boolean
"-myFlag" is flag with value "my flag value"
"secondArg" is an arg
"Ct" is boolean
"thirdArg" is an arg
"f" is boolean


booleans: true true true
flags: my flag value
args: firstArg secondArg thirdArg

Boolean types:
    Precedes Flag(pf): true
    Final Arg(f): true
    Colon Terminated(Ct): true
    Not Mentioned(nm): 

Flag: myFlag => my flag value

Args: one => firstArg, two => secondArg, three => thirdArg

Básicamente, los argumentos se dividen en indicadores booleanos y argumentos genéricos. Al hacerlo de esta manera, un usuario puede colocar los indicadores y los valores booleanos en cualquier lugar siempre que mantenga los argumentos genéricos (si los hay) en el orden especificado.

¡Permitiéndome a mí y ahora a ti nunca más lidiar con el análisis de argumentos de bash!

Puedes ver un script actualizado aquí

Esto ha sido enormemente útil durante el último año. Ahora puede simular el alcance prefijando las variables con un parámetro de alcance.

Simplemente llame al script como

replace() (
  source $FUTIL_REL_DIR/commandParser.sh -scope ${FUNCNAME[0]} "[email protected]"
  echo ${replaceFlags[f]}
  echo ${replaceBooleans[b]}
)

No parece que haya implementado el alcance del argumento, no estoy seguro de por qué supongo que aún no lo he necesitado.

Usa $# para obtener el número de argumentos, si no es igual a 2, no se proporcionan suficientes argumentos:

if [ $# -ne 2 ]; then
   usage;
fi

A continuación, comprueba si $1 es igual a -t , de lo contrario, se utilizó una bandera desconocida:

if [ "$1" != "-t" ]; then
  usage;
fi

Finalmente almacena $2 en FLAG :

FLAG=$2

Nota:usage() es alguna función que muestra la sintaxis. Por ejemplo:

function usage {
   cat << EOF
Usage: script.sh -t <application>

Performs some activity
EOF
   exit 1
}

Deberías leer este tutorial de getopts.

Ejemplo con -a interruptor que requiere un argumento:

#!/bin/bash

while getopts ":a:" opt; do
  case $opt in
    a)
      echo "-a was triggered, Parameter: $OPTARG" >&2
      ;;
    \?)
      echo "Invalid option: -$OPTARG" >&2
      exit 1
      ;;
    :)
      echo "Option -$OPTARG requires an argument." >&2
      exit 1
      ;;
  esac
done

Como dijo greybot(getopt !=getopts ) :

El comando externo getopt(1) nunca es seguro de usar, a menos que sabe es GNU getopt, lo llamas de una manera específica de GNU, y se asegura de que GETOPT_COMPATIBLE no esté en el entorno. Use getopts (shellbuiltin) en su lugar, o simplemente recorra los parámetros posicionales.