Bash
Skripting mit Parametern

Bemerkungen

Mehrere Parameter analysieren

Um viele Parameter zu analysieren, verwenden Sie hierfür eine while- Schleife, eine Case- Anweisung und eine Shift- Methode.

shift wird verwendet, um den ersten Parameter der Serie aufzurufen, wobei der Wert von $ 2 jetzt $ 1 ist . Dies ist nützlich, um Argumente einzeln zu bearbeiten.

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

Eingänge und Ausgänge

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

Zugriff auf Parameter

Wenn Sie ein Bash-Skript ausführen, werden die an das Skript übergebenen Parameter entsprechend ihrer Position benannt: $1 ist der Name des ersten Parameters, $2 ist der Name des zweiten Parameters und so weiter.

Ein fehlender Parameter wird einfach zu einer leeren Zeichenfolge ausgewertet. Das Vorhandensein eines Parameters kann folgendermaßen überprüft werden:

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

Alle Parameter abrufen

$@ und $* können Sie mit allen Skriptparametern interagieren. In Bezug auf die Bash-Manpage sehen wir Folgendes:

• $* : Wird bis zu den Positionsparametern erweitert, beginnend mit einem. Wenn die Erweiterung in Anführungszeichen erfolgt, wird sie zu einem einzelnen Wort erweitert, wobei der Wert jedes Parameters durch das erste Zeichen der IFS-Sondervariablen getrennt wird.
• $@ : Wird bis zu den Positionsparametern erweitert, beginnend mit einem. Wenn die Erweiterung in Anführungszeichen erfolgt, wird jeder Parameter zu einem separaten Wort erweitert.

Anzahl der Parameter abrufen

$# ruft die Anzahl der in ein Skript übergebenen Parameter ab. Ein typischer Anwendungsfall wäre, zu prüfen, ob die entsprechende Anzahl von Argumenten übergeben wird:

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

Beispiel 1

Durchlaufen Sie alle Argumente und prüfen Sie, ob es sich um Dateien handelt:

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

Beispiel 2

Durchlaufen Sie alle Argumente und prüfen Sie, ob es sich um Dateien handelt:

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

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

Argumentanalyse mit einer for-Schleife

Ein einfaches Beispiel, das die Optionen bietet:

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

Wrapper-Skript

Das Wrapper-Skript ist ein Skript, das ein anderes Skript oder einen Befehl einschließt, um zusätzliche Funktionen bereitzustellen oder einfach etwas weniger langweilig zu machen.

Beispielsweise wird das eigentliche egrep im neuen GNU / Linux-System durch ein Wrapper-Skript mit dem Namen egrep . So sieht es aus:

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

Wenn Sie also egrep in solchen Systemen ausführen, führen Sie eigentlich grep -E mit allen weitergeleiteten Argumenten aus.

Wenn Sie ein Beispielskript / Befehl exmp mit einem anderen Skript mexmp exmp möchten, mexmp das Wrapper mexmp Skript im mexmp wie folgt aus:

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

String in ein Array in Bash aufteilen

Nehmen wir an, wir haben einen String-Parameter und möchten ihn per Komma teilen

my_param="foo,bar,bash"

Um diese Zeichenfolge durch Kommas zu trennen, können wir verwenden;

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

Hier ist IFS eine spezielle Variable namens Internes Feldtrennzeichen, die das Zeichen oder die Zeichen definiert, mit denen ein Muster für einige Operationen in Token unterteilt wird.

Zugriff auf ein einzelnes Element:

echo "${array[0]}"

Um die Elemente zu durchlaufen:

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

Um sowohl den Index als auch den Wert zu erhalten:

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