¿Hay alguna manera de imprimir una matriz completa ([clave] = valor) sin recorrer todos los elementos?

Supongamos que he creado una matriz con algunos elementos:

declare -A array
array=([a1]=1 [a2]=2 ... [b1]=bbb ... [f500]=abcdef)

Puedo imprimir toda la matriz con

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

Sin embargo, parece que bash ya sabe cómo obtener todos los elementos de la matriz de una sola vez, tanto claves ${!array[@]}como valores${array[@]} .

¿Hay alguna manera de hacer que bash imprima esta información sin el bucle?

Editar:
typeset -p arrayhace eso!
Sin embargo, no puedo eliminar tanto el prefijo como el sufijo en una sola sustitución:

a="$(typeset -p array)"
b="${a##*(}"
c="${b%% )*}"

¿Hay una forma más limpia de obtener / imprimir solo la parte clave = valor de la salida?

Creo que estás preguntando dos cosas diferentes allí.

¿Hay alguna manera de hacer que bash imprima esta información sin el bucle?

Sí, pero no son tan buenos como simplemente usar el bucle.

¿Hay una forma más limpia de obtener / imprimir solo la parte clave = valor de la salida?

Sí, el forbucle. Tiene las ventajas de que no requiere programas externos, es sencillo y facilita el control del formato de salida exacto sin sorpresas.

Cualquier solución que intente manejar la salida de declare -p( typeset -p) tiene que tratar con a) la posibilidad de que las variables contengan paréntesis o corchetes, b) la cita quedeclare -p debe agregar para hacer que su salida sea una entrada válida para el shell.

Por ejemplo, su expansión b="${a##*(}"come algunos de los valores, si alguna clave / valor contiene un paréntesis de apertura. Esto se debe a que usó ##, lo que elimina el prefijo más largo . Lo mismo para c="${b%% )*}". Aunque, por supuesto, podría igualar la plantilla impresa con declaremás precisión, aún le costaría mucho trabajo si no quisiera todas las citas.

Esto no se ve muy bien a menos que lo necesite.

$ declare -A array=([abc]="'foobar'" [def]='"foo bar"')
$ declare -p array
declare -A array='([def]="\"foo bar\"" [abc]="'\''foobar'\''" )'

Con el forbucle, es más fácil elegir el formato de salida que desee:

# without quoting
$ for x in "${!array[@]}"; do printf "[%s]=%s\n" "$x" "${array[$x]}" ; done
[def]="foo bar"
[abc]='foobar'

# with quoting
$ for x in "${!array[@]}"; do printf "[%q]=%q\n" "$x" "${array[$x]}" ; done
[def]=\"foo\ bar\"
[abc]=\'foobar\'

A partir de ahí, también es simple. cambiar el formato de salida de lo contrario (quite los corchetes alrededor de la clave, coloque todos los pares clave / valor en una sola línea ...). Si necesita citar algo diferente al shell en sí, deberá hacerlo usted mismo, pero al menos tiene los datos sin procesar para trabajar. (Si tiene nuevas líneas en las claves o valores, probablemente necesitará algunas citas).

Con un Bash actual (4.4, creo), también podría usarlo en printf "[%s]=%s" "${x@Q}" "${array[$x]@Q}"lugar de printf "%q=%q". Produce un formato citado algo más agradable, pero por supuesto es un poco más trabajo para recordar escribir. _{(Y cita el caso de la esquina @como clave de matriz, que %qno cita).}

Si el bucle for parece demasiado cansado para escribir, guárdelo como una función en algún lugar (sin citar aquí):

printarr() { declare -n __p="$1"; for k in "${!__p[@]}"; do printf "%s=%s\n" "$k" "${__p[$k]}" ; done ;  }  

Y luego solo usa eso:

$ declare -A a=([a]=123 [b]="foo bar" [c]="(blah)")
$ printarr a
a=123
b=foo bar
c=(blah)

También funciona con matrices indexadas:

$ b=(abba acdc)
$ printarr b
0=abba
1=acdc

declare -p array
declare -A array='([a2]="2" [a1]="1" [zz]="Hello World" [b1]="bbb" [f50]="abcd" )'

2 tenedor

Tal vez esto:

printf "%s\n" "${!array[@]}"
a2
a1
f50
zz
b1

printf "%s\n" "${array[@]}"
2
1
abcd
Hello World
bbb

printf "%s\n" "${!array[@]}" "${array[@]}" | pr -2t
a2                              2
a1                              1
f50                             abcd
zz                              Hello World
b1                              bbb

3 tenedores

o esto:

paste -d= <(printf "%s\n" "${!array[@]}") <(printf "%s\n" "${array[@]}")
a2=2
a1=1
f50=abcd
zz=Hello World
b1=bbb

Sin tenedor

para ser comparado con

for i in "${!array[@]}";do printf "%s=%s\n" "$i" "${array[$i]}";done
a2=2
a1=1
f50=abcd
zz=Hello World
b1=bbb

Comparación de tiempos de ejecución

Como la última sintaxis no usa fork, podrían ser más rápidos:

time printf "%s\n" "${!array[@]}" "${array[@]}" | pr -2t | wc
      5      11      76
real    0m0.005s
user    0m0.000s
sys     0m0.000s

time paste -d= <(printf "%s\n" "${!array[@]}") <(printf "%s\n" "${array[@]}") | wc
      5       6      41
real    0m0.008s
user    0m0.000s
sys     0m0.000s

time for i in "${!array[@]}";do printf "%s=%s\n" "$i" "${array[$i]}";done | wc
      5       6      41
real    0m0.002s
user    0m0.000s
sys     0m0.001s

Pero esta afirmación no se mantiene si la matriz se hace grande; Si la reducción de las horquillas es eficiente para procesos pequeños, el uso de herramientas dedicadas es más eficiente para procesos más grandes.

for i in {a..z}{a..z}{a..z};do array[$i]=$RANDOM;done


time printf "%s\n" "${!array[@]}" "${array[@]}" | pr -2t | wc
  17581   35163  292941
real    0m0.150s
user    0m0.124s
sys     0m0.036s

time paste -d= <(printf "%s\n" "${!array[@]}") <(printf "%s\n" "${array[@]}") | wc
  17581   17582  169875
real    0m0.140s
user    0m0.000s
sys     0m0.004s

time for i in "${!array[@]}";do printf "%s=%s\n" "$i" "${array[$i]}";done | wc
  17581   17582  169875
real    0m0.312s
user    0m0.268s
sys     0m0.076s

Observación

Como ambas soluciones ( bifurcadas ) usan alineación , ninguna de ellas funcionará si alguna variable contiene una nueva línea . En este caso, la única forma es un forbucle.

Si está buscando un shell con mejor soporte de matriz asociativa, intente zsh.

En zsh(donde se agregaron matrices asociativas en 1998, en comparación con 1993 para ksh93 y 2009 para bash), $varo se ${(v)var}expande a los valores (no vacíos) del hash, ${(k)var}a las teclas (no vacías) (en el mismo orden), y ${(kv)var}a las dos claves y valores.

Para preservar los valores vacíos, como para las matrices, debe citar y usar la @bandera.

Entonces, para imprimir las claves y los valores, es solo cuestión de

printf '%s => %s\n' "${(@kv)var}"

Aunque para tener en cuenta un hash posiblemente vacío, debe hacer:

(($#var)) &&  printf '%s => %s\n' "${(@kv)var}"

También tenga en cuenta que zsh usa una sintaxis de definición de matriz mucho más sensata y útil que ksh93's (copiada por bash):

typeset -A var
var=(k1 v1 k2 v2 '' empty '*' star)

Lo que hace que sea mucho más fácil copiar o fusionar matrices asociativas:

var2=("${(@kv)var1}")
var3+=("${(@kv)var2}")
var4=("${@kv)var4}" "${(@kv)var5}")

(no puede copiar fácilmente un hash sin un bucle con bash, y tenga en cuenta que bashactualmente no admite claves vacías o clave / valores con bytes NUL).

Consulte también las zshfunciones de compresión de matrices que normalmente necesitará para trabajar con matrices asociativas:

keys=($(<keys.txt)) values=($(<values.txt))
hash=(${keys:^values})

Dado que la composición tipográfica hace lo que desea, ¿por qué no simplemente editar su salida?

typeset -p array | sed s/^.*\(// | tr -d ")\'\""  | tr "[" "\n" | sed s/]=/' = '/

da

a2 = 2  
a1 = 1  
b1 = bbb 

Dónde

array='([a2]="2" [a1]="1" [b1]="bbb" )'

Detallado, pero es bastante fácil ver cómo funciona el formateo: simplemente ejecute la tubería con progresivamente más comandos sed y tr . Modifíquelos para adaptarse a los gustos bonitos de impresión.

Una opción más es enumerar todas las variables y grep para la que desee.

set | grep -e '^aa='

Lo uso para depurar. Dudo que sea muy eficiente ya que enumera todas las variables.

Si hacía esto a menudo, podría hacerlo una función como esta:

aap() { set | grep -e "^$1="; }

Lamentablemente, cuando verificamos el rendimiento con el tiempo:

$ time aap aa aa=([0]="abc") . real 0m0.014s user 0m0.003s sys 0m0.006s

Por lo tanto, si hicieras esto muy a menudo, querrías la versión NO FORKS de @ F.Hauri porque es mucho más rápido.