¿Una función bash que toma argumentos como otros idiomas?

Tengo una función bash para establecer $PATHasí:

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
}

Pero el problema es que tengo que escribir diferentes funciones para diferentes variables (por ejemplo, otra función para me $CLASSPATHgusta, assign-classpath()etc.). No pude encontrar una manera de pasar argumentos a la función bash para poder acceder a ella por referencia.

Sería mejor si tuviera algo como ...

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

Alguna idea, ¿cómo lograr algo como lo anterior en bash?

En bashpuede utilizar ${!varname}para expandir la variable referenciada por el contenido de otra. P.ej:

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

Desde la página del manual:

${!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.

Además, para establecer una variable referenciada por los contenidos (sin los peligros de eval), puede usar declare. P.ej:

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

Por lo tanto, podría escribir su función de esta manera (tenga cuidado porque si usa declareuna función, debe dar -go la variable será local):

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
}

Y úsalo como:

assign PATH /path/to/binaries

Tenga en cuenta que también he corregido un error en el que si substrya es una subcadena de uno de los miembros separados por dos puntos bigstr, pero no su propio miembro, entonces no se agregaría. Por ejemplo, esto permitiría agregar /bina una PATHvariable que ya contiene /usr/bin. Utiliza los extglobconjuntos para hacer coincidir el principio / final de la cadena o dos puntos y luego cualquier otra cosa. Sin extglob, la alternativa sería:

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

Nuevo en bash 4.3, es la -nopción de declare& local:

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

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

Eso se imprime hello, world.

Puede usar evalpara establecer un parámetro. Una descripción de este comando se puede encontrar aquí . El siguiente uso deeval es incorrecto:

incorrecto(){
  eval $ 1 = $ 2
}

Con respecto a la evaluación adicional eval, debe usar

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

Verifique los resultados del uso de estas funciones:

$ X1 = '$ X2'
$ X2 = '$ X3'
$ X3 = 'xxx'
PS 
$ echo: $ X1:
: $ X2:
$ echo: $ X2:
: $ X3:
$ echo: $ X3:
: xxx:
PS 
$ incorrecto Y $ X1
$ echo: $ Y:
: $ X3:
PS 
$ asignar Y $ X1
$ echo: $ Y:
: $ X2:
PS 
$ asignar Y "hola mundo"
$ echo: $ Y:
: hola mundo:
$ # lo siguiente puede ser inesperado
$ asignar Z $ Y
$ echo ": $ Z:"
:Hola:
$ # por lo que debe citar el segundo argumento si es una variable
$ asignar Z "$ Y"
$ echo ": $ Z:"
: hola mundo:

Pero puede lograr su objetivo sin el uso de eval. Prefiero esta manera que es más simple.

La siguiente función hace la sustitución de la manera correcta (espero)

aumentar(){
  CORRIENTE local = $ 1
  AUMENTO local = $ 2
  local NUEVO
  si [[-z $ CORRIENTE]]; luego
    NUEVO = $ AUGMENT
  elif [[! (($ CORRIENTE = $ AUGMENT) || ($ CORRIENTE = $ AUGMENT: *) || \
    ($ CORRIENTE = *: $ AUMENTO) || ($ CORRIENTE = *: $ AUGMENT: *))]]; luego
    NUEVO = $ CORRIENTE: $ AUMENTO
  más
    NUEVO = $ CORRIENTE
    fi
  echo "$ NUEVO"
}

Comprueba la siguiente salida

aumentar / usr / bin / bin
/ usr / bin: / bin

aumentar / usr / bin: / bin / bin
/ usr / bin: / bin

augment / usr / bin: / bin: / usr / local / bin / bin
/ usr / bin: / bin: / usr / local / bin

augment / bin: / usr / bin / bin
/ bin: / usr / bin

aumento / bin / bin
/compartimiento


aumentar / usr / bin: / bin
/ usr / bin :: / bin

aumentar / usr / bin: / bin: / bin
/ usr / bin: / bin:

augment / usr / bin: / bin: / usr / local / bin: / bin
/ usr / bin: / bin: / usr / local / bin:

augment / bin: / usr / bin: / bin
/ bin: / usr / bin:

aumento / bin: / bin
/compartimiento:


aumentar: / bin
::/compartimiento


aumentar "/ usr lib" "/ usr bin"
/ usr lib: / usr bin

aumentar "/ usr lib: / usr bin" "/ usr bin"
/ usr lib: / usr bin

Ahora puede usar la augmentfunción de la siguiente manera para establecer una variable:

RUTA = `aumentar RUTA / bin`
CLASSPATH = `aumentar CLASSPATH / bin`
LD_LIBRARY_PATH = `aumentar LD_LIBRARY_PATH / usr / lib`

Con algunos trucos, puede pasar parámetros con nombre a funciones, junto con arreglos (probados en bash 3 y 4).

El método que desarrollé le permite acceder a los parámetros pasados ​​a una función como esta:

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 otras palabras, no solo puede llamar a sus parámetros por sus nombres (lo que compensa un núcleo más legible), sino que también puede pasar matrices (y referencias a variables; ¡esta función solo funciona en bash 4.3)! Además, todas las variables asignadas están en el ámbito local, igual que $ 1 (y otras).

El código que hace que esto funcione es bastante ligero y funciona tanto en bash 3 como en bash 4 (estas son las únicas versiones con las que lo he probado). Si está interesado en más trucos como este que hacen que desarrollar con bash sea mucho más fácil y fácil, puede echar un vistazo a mi Bash Infinity Framework , el código a continuación fue desarrollado para ese propósito.

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=

¿Esto encaja?

Los argumentos con nombre simplemente no son cómo se diseñó la sintaxis de Bash. Bash fue diseñado para ser una mejora iterativa sobre el shell Bourne. Como tal, debe asegurarse de que ciertas cosas funcionen entre los dos depósitos tanto como sea posible. Por lo tanto, no está destinado a ser más fácil de escribir en general, solo está destinado a ser mejor que Bourne al tiempo que garantiza que si lleva un script de un entorno Bourne a bashlo más fácil posible. Eso no es trivial ya que muchos proyectiles todavía tratan a Bourne como un estándar de facto. Dado que las personas escriben sus scripts para que sean compatibles con Bourne (para esta portabilidad), la necesidad sigue vigente y es poco probable que cambie.

Probablemente sea mejor mirar un script de shell diferente (como pythono algo) por completo si es factible. Si se encuentra con las limitaciones de un idioma, debe comenzar a usar un nuevo idioma.

Con la shsintaxis estándar (funcionaría en bash, y no solo en bash), podría hacer:

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

Al igual que para las soluciones que usan bash's declare, es seguro siempre que $1contenga un nombre de variable válido.

EN ARGOS NOMBRADOS:

Esto se hace de manera muy simple y bashno se requiere en absoluto: este es el comportamiento básico de asignación especificado por POSIX a través de la expansión de parámetros:

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

Para hacer una demostración de una manera similar a @Graeme, pero de forma portátil:

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

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

Y allí solo hago str=para asegurarme de que tenga un valor nulo, porque la expansión de parámetros tiene la protección incorporada contra la reasignación del entorno de shell en línea si ya está configurado.

SOLUCIÓN:

Para su problema específico, no creo que los argumentos nombrados sean necesarios, aunque ciertamente son posibles. Use en su $IFSlugar:

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
}

Esto es lo que obtengo cuando lo ejecuto:

% 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

¿Notó que solo agregó los argumentos que aún no estaban incluidos $PATHo que aparecieron antes? ¿O incluso que tomó más de un argumento? $IFSes útil

No puedo encontrar nada como rubí, pitón, etc., pero esto se siente más cerca de mí.

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

La legibilidad es mejor en mi opinión, 4 líneas son excesivas para declarar los nombres de sus parámetros. También se parece más a los idiomas modernos.