Bash
Script avec des paramètres

Remarques

Analyse de paramètres multiples

Pour analyser beaucoup de paramètres, la façon de le faire preferred utilise une boucle while, une déclaration de cas, et le décalage.

shift est utilisé pour faire apparaître le premier paramètre de la série, ce qui fait que ce qui était auparavant 2 $ est maintenant 1 $ . Ceci est utile pour traiter les arguments un par un.

#!/bin/bash

# Load the user defined parameters
while [[ $# > 0 ]]
do
        case "$1" in

                -a|--valueA)
                        valA="$2"
                        shift
                        ;;

                -b|--valueB)
                        valB="$2"
                        shift
                        ;;

                --help|*)
                        echo "Usage:"
                        echo "    --valueA \"value\""
                        echo "    --valueB \"value\""
                        echo "    --help"
                        exit 1
                        ;;
        esac
        shift
done

echo "A: $valA"
echo "B: $valB"

Entrées et sorties

$ ./multipleParams.sh --help
Usage:
    --valueA "value"
    --valueB "value"
    --help

$ ./multipleParams.sh
A: 
B:

$ ./multipleParams.sh --valueB 2
A: 
B: 2

$ ./multipleParams.sh --valueB 2 --valueA "hello world"
A: hello world
B: 2

Accès aux paramètres

Lors de l'exécution d'un script Bash, les paramètres transmis au script sont nommés en fonction de leur position: $1 est le nom du premier paramètre, $2 est le nom du deuxième paramètre, etc.

Un paramètre manquant évalue simplement une chaîne vide. La vérification de l'existence d'un paramètre peut être effectuée comme suit:

if [ -z "$1" ]; then
    echo "No argument supplied"
fi

Obtenir tous les paramètres

$@ et $* sont des moyens d'interagir avec tous les paramètres du script. En référence à la page de manuel Bash , nous voyons que:

• $* : Étend les paramètres de position à partir de un. Lorsque l'expansion se produit entre guillemets, elle se développe en un seul mot avec la valeur de chaque paramètre séparée par le premier caractère de la variable spéciale IFS.
• $@ : Étend les paramètres de position à partir de un. Lorsque l'expansion se produit entre guillemets, chaque paramètre se développe en un mot distinct.

Obtenir le nombre de paramètres

$# obtient le nombre de paramètres passés dans un script. Un cas d'utilisation typique serait de vérifier si le nombre d'arguments approprié est transmis:

if [ $# -eq 0 ]; then
    echo "No arguments supplied"
fi

Exemple 1

Parcourez tous les arguments et vérifiez s'ils sont des fichiers:

for item in "$@"
do  
    if [[ -f $item ]]; then
        echo "$item is a file"
    fi  
done

Exemple 2

Parcourez tous les arguments et vérifiez s'ils sont des fichiers:

for (( i = 1; i <= $#; ++ i ))
do
    item=${@:$i:1}

    if [[ -f $item ]]; then
        echo "$item is a file"
    fi  
done

Analyse d'argument utilisant une boucle for

Un exemple simple qui fournit les options:

#!/bin/bash
dr=''
install=false

skip=false
for op in "$@";do
    if $skip;then skip=false;continue;fi
    case "$op" in
        -v|--version)
            echo "$ver_info"
            shift
            exit 0
            ;;
        -h|--help)
            echo "$help"
            shift
            exit 0
            ;;
        -dr|--doc-root)
            shift
            if [[ "$1" != "" ]]; then
                dr="${1/%\//}"
                shift
                skip=true
            else
                echo "E: Arg missing for -dr option"
                exit 1
            fi
            ;;
        -i|--install)
            install=true
            shift
            ;;
        -*)
            echo "E: Invalid option: $1"
            shift
            exit 1
            ;;
    esac
done

Script wrapper

Le script Wrapper est un script qui encapsule un autre script ou une autre commande pour fournir des fonctionnalités supplémentaires ou simplement pour rendre quelque chose de moins fastidieux.

Par exemple, le egrep actuel dans le nouveau système GNU / Linux est remplacé par un script wrapper nommé egrep . Voici à quoi ça ressemble:

#!/bin/sh
exec grep -E "$@"

Ainsi, lorsque vous exécutez egrep dans de tels systèmes, vous exécutez en fait grep -E avec tous les arguments transférés.

Dans le cas général, si vous voulez exécuter un exemple de script / commande exmp avec un autre script mexmp alors le script wrapper mexmp ressemblera à:

#!/bin/sh
exmp "$@" # Add other options before "$@"
# or 
#full/path/to/exmp "$@"

Diviser la chaîne en un tableau dans Bash

Disons que nous avons un paramètre String et que nous voulons le diviser par une virgule

my_param="foo,bar,bash"

Pour diviser cette chaîne par une virgule, nous pouvons utiliser;

IFS=',' read -r -a array <<< "$my_param"

Ici, IFS est une variable spéciale appelée séparateur de champs internes qui définit le ou les caractères utilisés pour séparer un modèle en jetons pour certaines opérations.

Pour accéder à un élément individuel:

echo "${array[0]}"

Pour parcourir les éléments:

for element in "${array[@]}"
do
    echo "$element"
done

Pour obtenir à la fois l'index et la valeur:

for index in "${!array[@]}"
do
    echo "$index ${array[index]}"
done