Est-il un moyen d'éviter les arguments de position en bash?

La façon la plus courante de le faire est d'attribuer les arguments des variables locales à la fonction, à savoir:

copy() {
    local from=${1}
    local to=${2}

    # ...
}

---

Une autre solution peut être getoptdes options de style de l'analyse.

copy() {
    local arg from to
    while getopts 'f:t:' arg
    do
        case ${arg} in
            f) from=${OPTARG};;
            t) to=${OPTARG};;
            *) return 1 # illegal option
        esac
    done
}

copy -f /tmp/a -t /tmp/b

---

Malheureusement, bash ne peut pas manipuler des options qui serait être plus lisible, c'est à dire:

copy --from /tmp/a --to /tmp/b

Pour cela, vous devez soit utiliser l'externe getopt programme (qui je pense a de l'option de charge uniquement sur les systèmes GNU) ou de mettre en œuvre l'option de l'analyseur à la main, c'est à dire:

copy() {
    local from to

    while [[ ${1} ]]; do
        case "" in
            --from)
                from=${2}
                shift
                ;;
            --to)
                to=${2}
                shift
                ;;
            *)
                echo "Unknown parameter: " >&2
                return 1
        esac

        if ! shift; then
            echo 'Missing parameter argument.' >&2
            return 1
        fi
    done
}

copy --from /tmp/a --to /tmp/b

Voir aussi: à l'aide de getopts en shell bash script pour obtenir de longue et de courte options de ligne de commande

---

Vous pouvez également être paresseux, et il suffit de passer la variable en tant qu'arguments à la fonction, à savoir:

copy() {
    local "${@}"

    # ...
}

copy from=/tmp/a to=/tmp/b

et vous aurez ${from} et ${to} dans la fonction comme des variables locales.

Il suffit de noter que la même question que ci-dessous s'applique — si une variable n'est pas passé, il va être héritées du parent de l'environnement. Vous souhaiterez peut-être ajouter une "ligne de sécurité" comme:

copy() {
    local from to    # reset first
    local "${@}"

    # ...
}

pour s'assurer que ${from} et ${to} sera désactiver lorsqu'il n'est pas passé.

---

Et si quelque chose très mauvais est de votre intérêt, vous pouvez également affecter les arguments comme des variables globales lors de l'appel de la fonction, c'est à dire:

from=/tmp/a to=/tmp/b copy

Ensuite, vous pouvez simplement utiliser ${from} et ${to} dans le copy() fonction. Il suffit de noter, que vous devez ensuite toujours passer tous les paramètres. Sinon, une variable aléatoire peut s'infiltrer dans la fonction.

from= to=/tmp/b copy   # safe
to=/tmp/b copy         # unsafe: ${from} may be declared elsewhere

---

Si vous avez bash 4.1 (je pense), vous pouvez également essayer d'utiliser des tableaux associatifs. Il vous permettra de passer des arguments nommés, mais il sera être moche. Quelque chose comme:

args=( [from]=/tmp/a [to]=/tmp/b )
copy args

Puis dans copy(), vous auriez besoin de saisir le tableau.

Shell fonctions ont accès à toutes les variables disponibles dans leur contexte appelant, sauf pour ces noms de variables qui sont utilisées comme des variables locales à l'intérieur de la fonction elle-même. En outre, tous les non-locale de la variable définie dans une fonction est disponible à l'extérieur une fois que la fonction a été appelée. Considérons l'exemple suivant:

A=aaa
B=bbb

echo "A=$A B=$B C=$C"

example() {
    echo "example(): A=$A B=$B C=$C"

    A=AAA
    local B=BBB
    C=CCC

    echo "example(): A=$A B=$B C=$C"
}

example

echo "A=$A B=$B C=$C"

Cet extrait a la sortie suivante:

A=aaa B=bbb C=
example(): A=aaa B=bbb C=
example(): A=AAA B=BBB C=CCC
A=AAA B=bbb C=CCC

L'inconvénient de cette approche est que les fonctions qui ne sont pas autonomes et que la définition d'une variable en dehors d'une fonction peut avoir des effets secondaires imprévus. Il serait également rendre les choses plus difficiles si vous avez l'envie de transmettre des données à une fonction sans l'affecter à une variable d'abord, puisque cette fonction n'est pas à l'aide de paramètres positionnels plus.

La façon la plus commune pour résoudre ce problème est d'utiliser variables locales pour les arguments et toute variable temporaire dans une fonction:

example() {
   local A="$1" B="$2" C="$3" TMP="/tmp"

   ...
}

Cela évite de polluer l'espace de noms environnement avec la fonction de variables locales.

Je pense que j'ai une solution pour vous.
Avec quelques astuces, vous pouvez passer des paramètres nommés à des fonctions, ainsi que des tableaux.

La méthode que j'ai développée permet d'accéder à des paramètres passés à une fonction comme ceci:

testPassingParams() {

    @var hello
    l=4 @array anArrayWithFourElements
    l=2 @array anotherArrayWithTwo
    @var anotherSingle
    @reference table   # references only work in bash >=4.3
    @params anArrayOfVariedSize

    test "$hello" = "$1" && echo correct
    #
    test "${anArrayWithFourElements[0]}" = "$2" && echo correct
    test "${anArrayWithFourElements[1]}" = "$3" && echo correct
    test "${anArrayWithFourElements[2]}" = "$4" && echo correct
    # etc...
    #
    test "${anotherArrayWithTwo[0]}" = "$6" && echo correct
    test "${anotherArrayWithTwo[1]}" = "$7" && echo correct
    #
    test "$anotherSingle" = "$8" && echo correct
    #
    test "${table[test]}" = "works"
    table[inside]="adding a new value"
    #
    # I'm using * just in this example:
    test "${anArrayOfVariedSize[*]}" = "${*:10}" && echo correct
}

fourElements=( a1 a2 "a3 with spaces" a4 )
twoElements=( b1 b2 )
declare -A assocArray
assocArray[test]="works"

testPassingParams "first" "${fourElements[@]}" "${twoElements[@]}" "single with spaces" assocArray "and more... " "even more..."

test "${assocArray[inside]}" = "adding a new value"

En d'autres termes, non seulement vous pouvez appeler vos paramètres par leurs noms (ce qui représente un plus lisible de base), vous pouvez passer des tableaux (et des références à des variables - cette fonction ne fonctionne qu'en bash 4.3 si)! De Plus, la cartographié les variables sont toutes dans le domaine local, tout comme $1 (et les autres).

Le code qui effectue ce travail est assez léger et fonctionne à la fois en bash 3 et bash 4 (ce sont les seules versions que j'ai testé avec). Si vous êtes intéressé par plus de trucs comme ça qui font de développement avec bash beaucoup plus agréable et plus facile, vous pouvez prendre un coup d'oeil à mon Bash Cadre De L'Infini, le code ci-dessous a été élaboré à cette fin.

Function.AssignParamLocally() {
local commandWithArgs=( $1 )
local command="${commandWithArgs[0]}"
shift
if [[ "$command" == "trap" || "$command" == "l="* || "$command" == "_type="* ]]
then
paramNo+=-1
return 0
fi
if [[ "$command" != "local" ]]
then
assignNormalCodeStarted=true
fi
local varDeclaration="${commandWithArgs[1]}"
if [[ $varDeclaration == '-n' ]]
then
varDeclaration="${commandWithArgs[2]}"
fi
local varName="${varDeclaration%%=*}"
# var value is only important if making an object later on from it
local varValue="${varDeclaration#*=}"
if [[ ! -z $assignVarType ]]
then
local previousParamNo=$(expr $paramNo - 1)
if [[ "$assignVarType" == "array" ]]
then
# passing array:
execute="$assignVarName=( \"\${@:$previousParamNo:$assignArrLength}\" )"
eval "$execute"
paramNo+=$(expr $assignArrLength - 1)
unset assignArrLength
elif [[ "$assignVarType" == "params" ]]
then
execute="$assignVarName=( \"\${@:$previousParamNo}\" )"
eval "$execute"
elif [[ "$assignVarType" == "reference" ]]
then
execute="$assignVarName=\"\$$previousParamNo\""
eval "$execute"
elif [[ ! -z "${!previousParamNo}" ]]
then
execute="$assignVarName=\"\$$previousParamNo\""
eval "$execute"
fi
fi
assignVarType="$__capture_type"
assignVarName="$varName"
assignArrLength="$__capture_arrLength"
}
Function.CaptureParams() {
__capture_type="$_type"
__capture_arrLength="$l"
}
alias @trapAssign='Function.CaptureParams; trap "declare -i \"paramNo+=1\"; Function.AssignParamLocally \"\$BASH_COMMAND\" \"\$@\"; [[ \$assignNormalCodeStarted = true ]] && trap - DEBUG && unset assignVarType && unset assignVarName && unset assignNormalCodeStarted && unset paramNo" DEBUG; '
alias @param='@trapAssign local'
alias @reference='_type=reference @trapAssign local -n'
alias @var='_type=var @param'
alias @params='_type=params @param'
alias @array='_type=array @param'

Arguments envoyés à des fonctions comme un n-uplet d'éléments, de sorte qu'ils n'ont pas de nom en tant que tel, juste des positions. cela permet quelques possibilités intéressantes comme ci-dessous, mais cela signifie que vous êtes coincé avec $1. $2, etc. quant à la carte pour mieux les noms, la question se résume à la taille de la fonction, et comment beaucoup plus clair il fera de la lecture du code. si son complexe, puis le mappage des noms significatifs ($BatchID, $Prenom, $SourceFilePath) est une bonne idée. pour des choses simples, mais cependant, il n'est probablement pas nécessaire. Je certianly ne serait pas la peine si vous utilisez des noms comme $arg1.

maintenant, si vous voulez juste de récupérer les paramètres, vous pouvez effectuer une itération sur eux:

for $arg in "$@"
do
echo "$arg"
done

juste un fait amusant; sauf si vous êtes du traitement d'une liste, vous êtes probablement intéressé à quelque chose de plus utile