Bash Shell Script - Recherchez un indicateur et saisissez sa valeur

Essayez shFlags – Bibliothèque avancée d'indicateurs de ligne de commande pour les scripts shell Unix.

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

C'est très bon et très souple.

TYPES DE DRAPEAU :Ceci est une liste des DEFINE_* que vous pouvez faire. Tous les drapeaux prennent un nom, une valeur par défaut, une chaîne d'aide et un nom 'court' facultatif (nom à une lettre). Certains drapeaux ont d'autres arguments, qui sont décrits avec le drapeau.

DEFINE_string :prend n'importe quelle entrée et l'interprète comme une chaîne.

DEFINE_boolean :ne prend généralement aucun argument :dites --myflag pour définir FLAGS_myflag sur true, ou --nomyflag pour définir FLAGS_myflag sur false. Vous pouvez également dire --myflag=true ou --myflag=t ou --myflag=0 ou--myflag=false ou --myflag=f ou --myflag=1Passer une option a le même effet que passer l'option une fois.

DEFINE_float :prend une entrée et l'interprète comme un nombre à virgule flottante. Comme le shell ne prend pas en charge les flottants en soi, l'entrée est simplement validée comme étant une valeur à virgule flottante valide.

DEFINE_integer :prend une entrée et l'interprète comme un entier.

DRAPEAUX SPÉCIAUX :Il y a quelques drapeaux qui ont une signification particulière :--help (ou -?) imprime une liste de tous les drapeaux d'une manière lisible par l'homme--flagfile=foo lit les drapeaux de foo. (pas encore implémenté)-- comme dans getopt(), termine le traitement des drapeaux

EXEMPLE D'UTILISATION :

-- 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.

Remarque :j'ai pris ce texte de la documentation de shflags

Voici une interface d'argument de commande simple généralisée que vous pouvez coller en haut de tous vos 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]}"

En exécutant la commande :

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

Le résultat sera ceci :

"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

Fondamentalement, les arguments sont divisés en drapeaux booléens et arguments génériques. En procédant ainsi, un utilisateur peut placer les drapeaux et les booléens n'importe où tant qu'il conserve les arguments génériques (s'il y en a) dans l'ordre spécifié.

Cela me permet, à moi et maintenant à vous, de ne plus jamais avoir à faire à l'analyse d'arguments bash !

Vous pouvez voir un script mis à jour ici

Cela a été extrêmement utile au cours de la dernière année. Il peut maintenant simuler la portée en préfixant les variables avec un paramètre de portée.

Appelez simplement le script comme

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

Il ne semble pas que j'ai implémenté la portée de l'argument, je ne sais pas pourquoi je suppose que je n'en ai pas encore eu besoin.

Utilisez $# pour saisir le nombre d'arguments, s'il est différent de 2 il n'y a pas assez d'arguments fournis :

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

Ensuite, vérifiez si $1 est égal à -t , sinon un indicateur inconnu a été utilisé :

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

Stockez enfin $2 en FLAG :

FLAG=$2

Remarque :usage() est une fonction montrant la syntaxe. Par exemple :

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

Performs some activity
EOF
   exit 1
}

Vous devriez lire ce tutoriel getops.

Exemple avec -a switch qui nécessite un argument :

#!/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

Comme l'a dit greybot (getopt !=getopts ) :

La commande externe getopt(1) n'est jamais sûre à utiliser, sauf si vous savez c'est GNU getopt, vous l'appelez d'une manière spécifique à GNU, et vous vous assurez que GETOPT_COMPATIBLE n'est pas dans l'environnement. Utilisez plutôt getops (shellbuiltin) ou bouclez simplement sur les paramètres de position.