En zsh, ¿cómo paso matrices anónimas a funciones?

Question

En zsh, ¿cómo paso matrices anónimas a funciones? p.ej. buscando algo como:

foo() {
  echo ${1[2]} '\n';
}

a=(abc def ghi)
foo $a

--> def

O idealmente:

foo (abc def ghi)

Answer 1

Resolvió una solución alternativa:

foo() {
  local a=$1
  local b=$2

  echo ${(j:---:)${=b}}

  foreach d in ${${=b}}
  do
      echo $d
  done
}

Donde el parámetro2 es una cadena de texto separado en blanco, p. 'un badkljf odod'

Answer 2

No puedes. Las funciones toman parámetros posicionales como cualquier otro comando.

Tenga en cuenta también que su solución alternativa no permite ninguno de los " array " elementos para contener espacios en blanco.

Lo más limpio que se me ocurre es requerir que la persona que llama cree una matriz local y luego la lea desde la función:

$ foo() {
   for element in $FOO_ARRAY
   do
       echo "[$element]"
   done
}
$ local FOO_ARRAY; FOO_ARRAY=(foo bar baz quux)
$ foo
[foo]
[bar]
[baz]
[quux]

Sé que bash hace acrobacias similares para su sistema de finalización, y creo que zsh también podría hacerlo. No es demasiado inusual.

Answer 3

Puede pasar el nombre de la matriz a la función y luego la función puede leer la matriz interpretando el nombre como un nombre variable. Es una técnica que también es útil para cosas como matrices asociativas en bash. ZSH lo hace muy fácil de hacer, ya que el operador (P) interpretará la variable de la manera deseada.

Un ejemplo lo aclarará. Si define esta función:

function i_want_array () {
    local array_name=$1

    echo "first array element is: " ${(P)${array_name}[1]}
}

Entonces el siguiente código lo ejecutará:

% a=(one two three)
% i_want_array "a"
first array element is:  one

Y solo para aclarar, esto funciona operando en la matriz real, por lo que cualquier espacio en blanco se maneja correctamente:

% a=("one two" three)
% i_want_array "a"
first array element is:  one two

Answer 4

No resuelto con una matriz anónima ... ¡¡Pero intenté esto en !! BASH !! ...

function join {
  local tmp=($1)

  for (( i=0 ; i<${#tmp[@]}-1 ; i++ )) ; do
    echo -n ${tmp[$i]}$2
  done

  echo ${tmp[$i]}
}

test="abc def ghi"

join "$test" "|"

Answer 5

Si solo necesita un parámetro de matriz: como argumentos de cola.

foo() {
  : if you have any leading non-array args, grab those first:
  local arg1="$1"
  shift
  local arg2="$1"
  shift
  : now $@ is your array arg
  echo $@[2] '\n';
}

a=(abc def ghi)
foo "arg 1" arg2 $a

--> def