Une fonction bash qui prend des arguments comme les autres langages?

J'ai une fonction bash pour définir $PATHcomme ça -

assign-path()
{
    str=$1
    # if the $PATH is empty, assign it directly.
    if [ -z $PATH ]; then
        PATH=$str;
    # if the $PATH does not contain the substring, append it with ':'.
    elif [[ $PATH != *$str* ]]; then
        PATH=$PATH:$str;
    fi
}

Mais le problème est que je dois écrire une fonction différente pour différentes variables (par exemple, une autre fonction pour le $CLASSPATHmême, assign-classpath()etc.). Je n'ai pas trouvé de moyen de passer l'argument à la fonction bash pour pouvoir y accéder par référence.

Ce serait mieux si j'avais quelque chose comme -

assign( bigstr, substr )
{
    if [ -z bigstr ]; then
        bigstr=substr;
    elif [[ bigstr != *str* ]]; then
        bigstr=bigstr:substr;
    fi
}

Une idée, comment réaliser quelque chose comme ci-dessus en bash?

Dans bashvous pouvez utiliser ${!varname}pour développer la variable référencée par le contenu d'une autre. Par exemple:

$ var=hello
$ foo () { echo "${!1}"; }
$ foo var
hello

Depuis la page de manuel:

${!prefix*}
${!prefix@}
       Names matching prefix.  Expands to the names of variables whose names
       begin with prefix, separated by the first character of the IFS special
       variable.  When @ is used  and the expansion appears within double quotes,
       each variable name expands to a separate word.

De plus, pour définir une variable référencée par le contenu (sans les dangers de eval), vous pouvez utiliser declare. Par exemple:

$ var=target
$ declare "$var=hello"
$ echo "$target"
hello

Ainsi, vous pourriez écrire votre fonction comme ceci (attention car si vous utilisez declaredans une fonction, vous devez donner -gou la variable sera locale):

shopt -s extglob

assign()
{
  target=$1
  bigstr=${!1}
  substr=$2

  if [ -z "$bigstr" ]; then
    declare -g -- "$target=$substr"
  elif [[ $bigstr != @(|*:)$substr@(|:*) ]]; then
    declare -g -- "$target=$bigstr:$substr"
  fi
}

Et utilisez-le comme:

assign PATH /path/to/binaries

Notez que j'ai également corrigé un bogue où si substrest déjà une sous-chaîne d'un des membres séparés par deux points de bigstr, mais pas son propre membre, alors il ne serait pas ajouté. Par exemple, cela permettrait d'ajouter /binà une PATHvariable contenant déjà /usr/bin. Il utilise les extglobensembles pour correspondre soit au début / à la fin de la chaîne, soit à deux points, puis à toute autre chose. Sans extglob, l'alternative serait:

[[ $bigstr != $substr && $bigstr != *:$substr &&
   $bigstr != $substr:* && $bigstr != *:$substr:* ]]

Nouveau dans bash 4.3, est l' -noption de declare& local:

func() {
    local -n ref="$1"
    ref="hello, world"
}

var='goodbye world'
func var
echo "$var"

Cela s'imprime hello, world.

Vous pouvez utiliser evalpour définir un paramètre. Une description de cette commande peut être trouvée ici . L'utilisation suivante de evalest incorrecte:

faux(){
  eval 1 $ = 2 $
}

En ce qui concerne l'évaluation supplémentaire, evaldevez-vous utiliser

attribuer(){
  eval $ 1 = '$ 2'
}

Vérifiez les résultats de l'utilisation de ces fonctions:

$ X1 = '$ X2'
$ X2 = '$ X3'
$ X3 = 'xxx'
$ 
$ echo: $ X1:
: $ X2:
$ echo: $ X2:
: $ X3:
$ echo: $ X3:
: xxx:
$ 
$ faux Y $ X1
$ echo: $ Y:
: $ X3:
$ 
$ affecter Y $ X1
$ echo: $ Y:
: $ X2:
$ 
$ assign Y "monde bonjour"
$ echo: $ Y:
: hallo world:
$ # les éléments suivants peuvent être inattendus
$ affecter Z $ Y
$ echo ": $ Z:"
:Bonjour:
$ # vous devez donc citer le deuxième argument si c'est une variable
$ affecter Z "$ Y"
$ echo ": $ Z:"
: hallo world:

Mais vous pouvez atteindre votre objectif sans utiliser eval. Je préfère cette façon plus simple.

La fonction suivante effectue la substitution de la bonne manière (j'espère)

augmenter(){
  COURANT local = 1 $
  AUGMENT local = 2 $
  local NOUVEAU
  if [[-z $ CURRENT]]; ensuite
    NOUVEAU = $ AUGMENT
  elif [[! (($ CURRENT = $ AUGMENT) || ($ CURRENT = $ AUGMENT: *) || \
    ($ CURRENT = *: $ AUGMENT) || ($ CURRENT = *: $ AUGMENT: *))]]; ensuite
    NOUVEAU = $ COURANT: $ AUGMENT
  autre
    NOUVEAU = $ COURANT
    Fi
  écho "$ NOUVEAU"
}

Vérifiez la sortie suivante

augmenter / usr / bin / bin
/ usr / bin: / bin

augmenter / usr / bin: / bin / bin
/ usr / bin: / bin

augmenter / usr / bin: / bin: / usr / local / bin / bin
/ usr / bin: / bin: / usr / local / bin

augmenter / bin: / usr / bin / bin
/ bin: / usr / bin

augmenter / bin / bin
/poubelle


augmenter / usr / bin: / bin
/ usr / bin :: / bin

augmenter / usr / bin: / bin: / bin
/ usr / bin: / bin:

augmenter / usr / bin: / bin: / usr / local / bin: / bin
/ usr / bin: / bin: / usr / local / bin:

augmenter / bin: / usr / bin: / bin
/ bin: / usr / bin:

augmenter / bin: / bin
/poubelle:


augmenter: / bin
::/poubelle


augmenter "/ usr lib" "/ usr bin"
/ usr lib: / usr bin

augmenter "/ usr lib: / usr bin" "/ usr bin"
/ usr lib: / usr bin

Vous pouvez maintenant utiliser la augmentfonction de la manière suivante pour définir une variable:

PATH = `augmenter PATH / bin`
CLASSPATH = `augmenter CLASSPATH / bin`
LD_LIBRARY_PATH = `augmenter LD_LIBRARY_PATH / usr / lib`

Avec quelques astuces, vous pouvez réellement transmettre des paramètres nommés aux fonctions, ainsi que des tableaux (testés dans bash 3 et 4).

La méthode que j'ai développée vous permet d'accéder aux paramètres passés à une fonction comme celle-ci:

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 constitue un noyau plus lisible), vous pouvez en fait passer des tableaux (et des références à des variables - cette fonctionnalité ne fonctionne que dans bash 4.3 cependant)! De plus, les variables mappées sont toutes dans la portée locale, tout comme $ 1 (et autres).

Le code qui fait ce travail est assez léger et fonctionne à la fois en bash 3 et bash 4 (ce sont les seules versions avec lesquelles je l'ai testé). Si vous êtes intéressé par plus de trucs comme celui-ci qui rendent le développement avec bash beaucoup plus agréable et plus facile, vous pouvez jeter un œil à mon framework Bash Infinity , le code ci-dessous a été développé à cet effet.

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'

assign () 
{ 
    if [ -z ${!1} ]; then
        eval $1=$2
    else
        if [[ ${!1} != *$2* ]]; then
            eval $1=${!1}:$2
        fi
    fi
}

$ echo =$x=
==
$ assign x y
$ echo =$x=
=y=
$ assign x y
$ echo =$x=
=y=
$ assign x z
$ echo =$x=
=y:z=

Cela correspond-il?

Les arguments nommés ne sont tout simplement pas comment la syntaxe de Bash a été conçue. Bash a été conçu pour être une amélioration itérative du shell Bourne. En tant que tel, il doit s'assurer que certaines choses fonctionnent autant que possible entre les deux coques. Donc, il n'est pas censé être plus facile de créer un script dans l'ensemble, il est juste censé être meilleur que Bourne tout en garantissant que si vous prenez un script d'un environnement Bourne, bashc'est aussi simple que possible. Ce n'est pas anodin car de nombreux obus traitent toujours Bourne comme une norme de facto. Étant donné que les gens écrivent leurs scripts pour être compatibles avec Bourne (pour cette portabilité), le besoin reste en vigueur et ne changera probablement jamais.

Vous feriez probablement mieux de regarder un script shell différent (comme pythonou quelque chose) entièrement si c'est possible. Si vous rencontrez les limites d'une langue, vous devez commencer à utiliser une nouvelle langue.

Avec la shsyntaxe standard (fonctionnerait dans bash, et pas seulement dans bash), vous pourriez faire:

assign() {
  eval '
    case :${'"$1"'}: in
      (::) '"$1"'=$2;;   # was empty, copy
      (*:"$2":*) ;;      # already there, do nothing
      (*) '"$1"'=$1:$2;; # otherwise, append with a :
    esac'
}

Comme pour les solutions utilisant bashdes declare, c'est sûr tant qu'il $1contient un nom de variable valide.

SUR LES ARGS NOMMÉES:

Cela se fait très simplement et bashn'est pas du tout requis - c'est le comportement d'affectation spécifié par POSIX de base via l'expansion des paramètres:

: ${PATH:=this is only assigned to \$PATH if \$PATH is null or unset}

Pour faire une démonstration dans le même esprit que @Graeme, mais de manière portable:

_fn() { echo "$1 ${2:-"$1"} $str" ; }

% str= ; _fn "${str:=hello}"
> hello hello hello

Et là, je ne fais que str=pour m'assurer qu'il a une valeur nulle, car l'expansion des paramètres a la protection intégrée contre la réaffectation de l'environnement shell en ligne si elle est déjà définie.

SOLUTION:

Pour votre problème spécifique, je ne pense pas que des arguments nommés soient nécessaires, bien qu'ils soient certainement possibles. Utilisez $IFSplutôt:

assign() { oFS=$IFS ; IFS=: ; add=$* 
    set -- $PATH ; for p in $add ; do { 
        for d ; do [ -z "${d%"$p"}" ] && break 
        done ; } || set -- $* $p ; done
    PATH= ; echo "${PATH:="$*"}" ; IFS=$oFS
}

Voici ce que j'obtiens lorsque je l'exécute:

% PATH=/usr/bin:/usr/yes/bin
% assign \
    /usr/bin \
    /usr/yes/bin \
    /usr/nope/bin \
    /usr/bin \
    /nope/usr/bin \
    /usr/nope/bin

> /usr/bin:/usr/yes/bin:/usr/nope/bin:/nope/usr/bin

% echo "$PATH"
> /usr/bin:/usr/yes/bin:/usr/nope/bin:/nope/usr/bin

% dir="/some crazy/dir"
% p=`assign /usr/bin /usr/bin/new "$dir"`
% echo "$p" ; echo "$PATH"
> /usr/bin:/usr/yes/bin:/usr/nope/bin:/nope/usr/bin:/some crazy/dir:/usr/bin/new
> /usr/bin:/usr/yes/bin:/usr/nope/bin:/nope/usr/bin:/some crazy/dir:/usr/bin/new

Remarquez qu'il n'a ajouté que les arguments qui n'étaient pas déjà inclus $PATHou qui ont précédé? Ou même qu'il a fallu plus d'un argument du tout? $IFSest pratique.

Je ne trouve rien de tel que le rubis, le python, etc. mais cela me semble plus proche

foo() {
  BAR="$1"; BAZ="$2"; QUUX="$3"; CORGE="$4"
  ...
}

La lisibilité est meilleure à mon avis, 4 lignes sont excessives pour déclarer vos noms de paramètres. Ressemble également aux langues modernes.