Bash
Scripting met parameters

Opmerkingen

Meerdere parameters parseren

Om veel parameters te ontleden, is de voorkeursmethode om dit te doen een while- lus, een case- statement en een shift .

shift wordt gebruikt om de eerste parameter in de reeks te laten verschijnen, wat vroeger $ 2 was , nu $ 1 . Dit is handig voor het één voor één verwerken van argumenten.

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

Ingangen en uitgangen

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

Toegang tot parameters

Bij het uitvoeren van een Bash-script krijgen parameters die in het script worden doorgegeven een naam in overeenstemming met hun positie: $1 is de naam van de eerste parameter, $2 is de naam van de tweede parameter, enzovoort.

Een ontbrekende parameter resulteert eenvoudig in een lege string. Het controleren van het bestaan van een parameter kan als volgt worden gedaan:

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

Alle parameters ophalen

$@ en $* zijn manieren om te communiceren met alle scriptparameters. Verwijzend naar de Bash man-pagina zien we dat:

• $* : Breidt uit naar de positionele parameters, beginnend bij één. Wanneer de uitbreiding binnen dubbele aanhalingstekens plaatsvindt, wordt deze uitgebreid tot een enkel woord met de waarde van elke parameter gescheiden door het eerste teken van de speciale variabele IFS.
• $@ : Breidt uit naar de positionele parameters, beginnend bij één. Wanneer de uitbreiding binnen dubbele aanhalingstekens plaatsvindt, wordt elke parameter uitgebreid naar een afzonderlijk woord.

Het aantal parameters verkrijgen

$# haalt het aantal parameters op dat in een script wordt doorgegeven. Een typisch geval is om te controleren of het juiste aantal argumenten is doorgegeven:

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

voorbeeld 1

Doorloop alle argumenten en controleer of dit bestanden zijn:

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

Voorbeeld 2

Doorloop alle argumenten en controleer of dit bestanden zijn:

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

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

Argument parsing met behulp van een for-lus

Een eenvoudig voorbeeld dat de opties biedt:

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

Wrapper-script is een script dat een ander script of commando omhult om extra functionaliteiten te bieden of gewoon om iets minder saai te maken.

De werkelijke egrep in het nieuwe GNU / Linux-systeem wordt bijvoorbeeld vervangen door een wrapper-script met de naam egrep . Zo ziet het eruit:

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

Dus als je egrep in dergelijke systemen uitvoert, egrep je eigenlijk grep -E met alle doorgegeven argumenten.

Als u in het algemeen een voorbeeldscript / exmp wilt uitvoeren met een ander script mexmp , ziet het wrapper mexmp script er als volgt uit:

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

Splitstring in een array in Bash

Laten we zeggen dat we een String-parameter hebben en deze willen splitsen op komma

my_param="foo,bar,bash"

Om deze string door komma's te splitsen kunnen we gebruiken;

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

Hier is IFS een speciale variabele met de naam Intern veldscheidingsteken die het teken of de tekens definieert die worden gebruikt om een patroon in tokens te scheiden voor sommige bewerkingen.

Om toegang te krijgen tot een individueel element:

echo "${array[0]}"

Om de elementen te herhalen:

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

Om zowel de index als de waarde te krijgen:

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