Есть ли способ напечатать весь массив ([ключ] = значение) без зацикливания на всех элементах?

Предположим, я создал массив с некоторыми элементами:

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

Я могу напечатать весь массив с

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

Однако, похоже, bash уже знает, как получить все элементы массива за один раз - и ключи, ${!array[@]}и значения ${array[@]}.

Есть ли способ заставить bash распечатать эту информацию без цикла?

Редактировать:
typeset -p arrayделает это!
Однако я не могу удалить префикс и суффикс в одной замене:

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

Есть ли более чистый способ получить / напечатать только часть ключа = значение вывода?

Я думаю, что вы спрашиваете две разные вещи там.

Есть ли способ заставить bash распечатать эту информацию без цикла?

Да, но они не так хороши, как просто использование цикла.

Есть ли более чистый способ получить / напечатать только часть ключа = значение вывода?

Да, forпетля. Он имеет преимущества, заключающиеся в том, что ему не требуются внешние программы, он прост и позволяет довольно просто контролировать точный формат вывода без неожиданностей.

Любое решение, которое пытается обработать вывод declare -p( typeset -p), должно иметь дело с а) возможностью того, что сами переменные содержат скобки или скобки, б) кавычки, которые declare -pнужно добавить, чтобы сделать вывод допустимым для оболочки.

Например, ваше расширение b="${a##*(}"съедает некоторые значения, если какой-либо ключ / значение содержит открывающую скобку. Это потому, что вы использовали ##, который удаляет самый длинный префикс. То же самое для c="${b%% )*}". Хотя вы, конечно declare, могли бы точно соответствовать шаблону, напечатанному более точно, вам все равно было бы трудно, если бы вы не хотели, чтобы все цитаты были такими.

Это выглядит не очень хорошо, если вам это не нужно.

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

С помощью forцикла легче выбрать выходной формат, как вам нравится:

# 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\'

Оттуда также просто изменить формат вывода (удалите скобки вокруг ключа, поместите все пары ключ / значение в одну строку ...). Если вам нужно цитировать что-то, кроме самой оболочки, вам все равно придется делать это самостоятельно, но, по крайней мере, у вас есть необработанные данные для работы. (Если у вас есть новые строки в ключах или значениях, вам, вероятно, понадобятся некоторые цитаты.)

С текущей версией Bash (я думаю, 4.4) вы также можете использовать printf "[%s]=%s" "${x@Q}" "${array[$x]@Q}"вместо printf "%q=%q". Он производит несколько более приятный формат в кавычках, но, конечно, немного больше работы, чтобы не забыть написать. _{(И он цитирует угловой регистр @как ключ массива, который %qне заключает в кавычки.)}

Если цикл for кажется слишком утомительным для записи, сохраните его где-нибудь (без кавычек):

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

А потом просто используйте это:

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

Работает и с индексированными массивами:

$ 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 вилки

Может быть, это:

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 вилки

или это:

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

Без вилки

сравнивать с

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

Сравнение времени выполнения

Поскольку последний синтаксис не использует fork, они могут быть быстрее:

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

Но это утверждение не остается верным, если массив становится большим; если редукция вилки эффективна для небольших процессов, использование специальных инструментов более эффективно для больших процессов.

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

замечание

Поскольку оба ( разветвленных ) решения используют выравнивание , ни одно из них не будет работать, если какая-либо переменная содержит символ новой строки . В этом случае единственным способом является forпетля.

Если вы ищете оболочку с лучшей поддержкой ассоциативных массивов, попробуйте zsh.

В zsh(где ассоциативные массивы были добавлены в 1998 г. по сравнению с 1993 г. для ksh93 и 2009 г. для bash) $varили ${(v)var}расширяются до (непустых) значений хэша, ${(k)var}до (непустых) ключей (в том же порядке), и ${(kv)var}оба ключа и значения.

Чтобы сохранить пустые значения, как для массивов, вам нужно заключить в кавычки и использовать @флаг.

Таким образом, чтобы напечатать ключи и значения, это просто вопрос

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

Хотя, чтобы учесть возможно пустой хеш, вы должны сделать:

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

Также обратите внимание, что zsh использует гораздо более разумный и полезный синтаксис определения массива, чем ksh93s (скопированный bash):

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

Что значительно упрощает копирование или объединение ассоциативных массивов:

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

(вы не можете легко скопировать хеш без цикла с bash, и обратите внимание, что в bashнастоящее время не поддерживаются пустые ключи или ключ / значения с байтами NUL).

Смотрите также zshфункции архивирования массивов, которые вам обычно нужны для работы с ассоциативными массивами:

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

Поскольку typeset делает то, что вы хотите, почему бы просто не отредактировать его вывод?

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

дает

a2 = 2  
a1 = 1  
b1 = bbb 

где

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

Подробно, но довольно легко увидеть, как работает форматирование: просто выполните конвейер с постепенно увеличивающимся количеством команд sed и tr . Измените их, чтобы они соответствовали красивым вкусам печати.

Еще один вариант - перечислить все переменные и grep для той, которую вы хотите.

set | grep -e '^aa='

Я использую это для отладки. Я сомневаюсь, что он очень производительный, поскольку в нем перечислены все переменные.

Если бы вы делали это часто, вы могли бы сделать это такой функцией:

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

К сожалению, когда мы проверяем производительность, используя время:

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

Поэтому, если бы вы делали это очень часто, вы бы хотели версию @ F.Hauri NO FORKS, потому что она намного быстрее.