• Objet : Gérer des paramètres utilisateur
• Niveau requis :

  débutant, avisé
• Commentaires : Créer un script acceptant des paramètres de position, nommés et booléens.
• Débutant, à savoir : Utiliser GNU/Linux en ligne de commande, tout commence là !.

Voici quelques exemples permettant de créer des scripts bash possédants une gestion plus fine des paramètres d'entrées qu'un simple $@.

Avec ces scripts, vous pourrez supporter :

1. Des paramètres de position

./script.sh arg_1

1. Des paramètres appelant une valeur

./script.sh -a valeur_a --long_parametre_b valeur_b

1. Des paramètres booléens

./script -o

Le détail de fonctionnement des scripts est inclut en commentaire.

./parametre_booleen.sh -o

Vrai

./parametre_booleen.sh

Faux

parametre_booleen.sh

#!/bin/bash
 
# Paramètre booléén forme courte et longue -o/--long_option
 
# On recherche une correspondance soit avec la forme courte, soit avec la longue.
# On ajoute des espaces autour des variables pour une comparaison stricte et ne pas identifier de sous chaine.
 
if [[ " $@ " =~ " -o " ]] || [[ " $@ " =~ " --long_option " ]] ; then
    PARAM=true # On peut affecter une valeur booléenne 
fi
 
if [ -n "$PARAM" ]; then # Si la chaîne est non-nulle (~ que la variable a été crée (~ remplie))
    echo "Vrai"
else
    echo "Faux"
fi

./parametre_nomme.sh -a val_a

param_a = val_a

./parametre_nomme.sh

param_a =

parametre_nomme.sh

#!/bin/bash
# Paramètre attendant une valeur (named parameter)
 
params=( "$@" ) # copie de du tableau des Paramètres
 
for i in $(seq $#); do  # On itère un à un sur tout les paramètres 
    j=$(($i-1)) # seq commence à compter à 1, le premier paramètre est à 0.
    if [[ " ${params[$j]} " =~ " -a " ]] || [[ " ${params[$j]} " =~ " --long_a " ]] ; then
        PARAM_A=${params[$i]} # On récupère la paramètre succédant la clé "-a", soit "value_a"
    fi
done
 
echo "param_a = $PARAM_A"

./all_parameters_type.sh -a val_a --long_b val_b -o pos_1 pos_2

positional :  pos_1 pos_2
param_a : val_a
param_b : val_b
option_o : true

all_parameters_type.sh

#!/bin/bash
 
help_msg () {
    echo """
usage: script [-h] [-o] [-a NAMED_A] [-b NAMED_B] 
 
Description
 
Paramètres optionnels
  -h, --help              show this help message and exit
  -a NAMED_A, --long_a NAMED_A    
                          Le paramètre PARAM_A
  -b NAMED_B, --long_b NAMED_B            
                          Le paramètre PARAM_B
  -o, --option            L'option OPTION_O
"""
}
 
# get named parameters
 
# On utilisera par la suite la fonction shift, qui "consomme" les arguments du tableau $@
# si $@ = "-a value_a --long_b value_b"
# Executer :
# shift
# Consomme le premier argument ("-a"):
# $@ = "value_a --long_b value_b"
# 
# $# compte le nombre d'argument restants, et parconséquent est réduit de 1 à chaque "shift"
 
 
# Prenons un exemple simple, "dans l'ordre d'écriture de la fonction"
# Soit la commande: 
#
#      ./script.sh -a value_a --long_b value_b -o positionnal
#
# La variable $@ contient alors "-a value_a --long_ value_b -o positionnal"
 
 
# On initialise la liste des paramètres de position
POSITIONAL=""
 
# On boucle tant qu'il y a des arguments
while [ $# -gt 0 ] ; do     # $# Nombre d'arguments passés en paramètre du script
    key="$1"                # => key = "-a", le premier argument
    case $key in            # Teste $key pour les cas suivant:
        -h|--help)
            help_msg        # execute la fonction help ()
            exit 0          # et quitte le script
            ;;
        -a|--long_a)        # la clé "-a" est reconnue
            PARAM_A="$2"    # la valeur du paramètre PARAM_A vient juste après, soit $2
            shift           # consomme un arguement, $@ ne contient plus que "value_a -b value_b"
            shift           # consomme un deuxième arguement, $@ = "-b value_b"
            ;;              # On peut passer au tour suivant, avec $key prenant la valeur $1, soit "-b"
        -b|--long_b)        # (2e tour) : $key à la valeur "-b" et est reconnue
            PARAM_B="$2"    # Comme précédemment, on prend l'argument suivant $key/$1 soit $2
            shift           # Et on consomme la clé ("-b")
            shift           # Puis la valeur du paramètres ("value_b")
            ;;
        -o|--option)        # (3e tour) : la clé "-o" est reconnue
            OPTION_O=true   # On affecte une valeur booléenne (on pourra la:tester avec [ -z OPTION_O ] par exemple )
            shift           # Cette fois ci on ne passe qu'un paramètres, puisqu'il n'y a pas de valeur donnée
            ;;
        *)                                  # La clé ne correspond à aucun autre cas
          if ! [[ "$key" =~ "^-" ]]; then   # Si elle ne commence pas par un "-"
              POSITIONAL="$POSITIONAL $key" # C'est un paramètre positionnel, on l'ajoute à la liste
              shift                         # On passe le paramètres (1 seul shift)
          else                                    # Si la clé commence par "-"
              echo "Argument non défini : '$key'" # C'est quelle ne fait pas partie de la liste définie plus haut
              exit 1                              # On arrète le programme
          fi
    esac
done    # FIN! Biensûr l'exemple est arrangé dans le "bon ordre", mais la position des arguments n'a pas d'importance.
 
# Paramètres parsés
echo "positional : $POSITIONAL"  # Contient : "positionnal"
echo "param_a : $PARAM_A"        # Contient : "value_a"
echo "param_b : $PARAM_B"        # Contient : "value_b"
echo "option_o : $OPTION_O"      # Contient : "true"

Dans le cas de paramètres inconnus à l'avance, ou pour un script plus leger, cette fonction permet de trier les différnet arguments en fonction de leur type supposé (positional(arg), named (-n arg), option (-o)) et les stocke dans 3 variables différentes.

A defaut, un groupe `-n arg` est considéré comme named et non comme un option + positional

Par exemple:

1. `–named value_1 value_2` ⇒ `–long value_1` est supposé comme groupe named, `value_2` est supposé positional
2. `–option –long value` ⇒ `–option` est considéré comme option, `–long value`, comme un groupe named

tri sommaire des arguments (!robustesse!)

split_args -a value_a pos_1 -o --long_b value_b pos_2

POSITIONAL :  pos_1 pos_2
NAMED : -a value_a --long_b value_b
OPTION :  -o

fonction_split_args

split_args () {
    POSITIONAL_ARGS=""
    NAMED_ARGS=""
    OPTION_ARGS=""
    while [ $# -gt 0 ] ; do
 
        if [[ "$1" =~ ^- ]]; then
            if ! [[ "$2" =~ ^- ]] && [ -n "$2" ] ; then
                NAMED_ARGS="$NAMED_ARGS $1 $2"
                shift
            else
                OPTION_ARGS="$OPTION_ARGS $1"
            fi
        else
            POSITIONAL_ARGS="$POSITIONAL_ARGS $1"
        fi
        shift
    done
}