Apakah ada cara untuk mencetak seluruh array ([kunci] = nilai) tanpa mengulang semua elemen?

Asumsikan saya telah membuat array dengan beberapa elemen:

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

Saya dapat mencetak kembali seluruh array dengan

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

Namun, tampaknya bash sudah tahu cara mendapatkan semua elemen array dalam satu "go" - baik kunci ${!array[@]}dan nilai ${array[@]}.

Apakah ada cara untuk membuat bash mencetak info ini tanpa loop?

Sunting:
typeset -p arraylakukan itu!
Namun saya tidak bisa menghapus awalan dan sufiks dalam satu substitusi:

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

Apakah ada cara yang lebih bersih untuk mendapatkan / mencetak hanya bagian kunci = nilai dari output?

Saya pikir Anda menanyakan dua hal berbeda di sana.

Apakah ada cara untuk membuat bash mencetak info ini tanpa loop?

Ya, tetapi mereka tidak sebagus hanya menggunakan loop.

Apakah ada cara yang lebih bersih untuk mendapatkan / mencetak hanya bagian kunci = nilai dari output?

Ya itu for simpulnya. Ini memiliki kelebihan yang tidak memerlukan program eksternal, mudah, dan membuatnya lebih mudah untuk mengontrol format output yang tepat tanpa kejutan.

Solusi apa pun yang mencoba menangani output dari declare -p(typeset -p ) harus berurusan dengan a) kemungkinan variabel itu sendiri mengandung tanda kurung atau tanda kurung, b) kutipan yang declare -pharus ditambahkan untuk membuat output itu valid input untuk shell.

Misalnya, ekspansi Anda b="${a##*(}"memakan beberapa nilai, jika ada kunci / nilai yang berisi tanda kurung buka. Ini karena Anda menggunakan ##, yang menghilangkan awalan terpanjang . Sama untukc="${b%% )*}" . Meskipun tentu saja Anda dapat mencocokkan pelat tungku yang dicetak dengan declarelebih tepat, Anda masih akan mengalami kesulitan jika Anda tidak ingin semua kutipannya cocok.

Ini tidak terlihat bagus kecuali Anda membutuhkannya.

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

Dengan forloop, lebih mudah untuk memilih format output sesuka Anda:

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

Dari sana, juga mudah untuk mengubah format output jika tidak (hapus tanda kurung di sekitar kunci, letakkan semua pasangan kunci / nilai pada satu baris ...). Jika Anda perlu mengutip sesuatu selain dari shell itu sendiri, Anda masih perlu melakukannya sendiri, tetapi setidaknya Anda memiliki data mentah untuk dikerjakan. (Jika Anda memiliki baris baru di kunci atau nilai, Anda mungkin perlu mengutip.)

Dengan Bash saat ini (4,4, saya pikir), Anda juga bisa menggunakan printf "[%s]=%s" "${x@Q}" "${array[$x]@Q}"bukan printf "%q=%q". Ini menghasilkan format kutipan yang agak lebih bagus, tetapi tentu saja sedikit lebih banyak pekerjaan yang perlu diingat untuk menulis. _{(Dan itu mengutip kasus sudut @sebagai kunci array, yang %qtidak mengutip.)}

Jika for for tampaknya terlalu lelah untuk ditulis, simpan fungsi di suatu tempat (tanpa mengutip di sini):

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

Dan kemudian gunakan itu:

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

Bekerja dengan array yang diindeks juga:

$ 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 garpu

Mungkin ini:

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 garpu

atau ini:

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

Tanpa garpu

untuk dibandingkan dengan

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

Perbandingan waktu eksekusi

Karena sintaks terakhir tidak menggunakan fork, mereka bisa lebih cepat:

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

Tetapi penegasan ini tidak tetap benar jika array menjadi besar; jika mengurangi garpu efisien untuk proses kecil, menggunakan alat khusus lebih efisien untuk proses yang lebih besar.

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

Ucapan

Karena kedua ( bercabang ) solusi menggunakan perataan , tidak satupun dari mereka akan bekerja jika ada variabel yang berisi baris baru . Dalam hal ini, satu-satunya cara adalah forloop.

Jika Anda mencari shell dengan dukungan array asosiatif yang lebih baik, coba zsh.

Dalam zsh(di mana array asosiatif ditambahkan pada tahun 1998, dibandingkan dengan 1993 untuk ksh93 dan 2009 untuk bash), $varatau ${(v)var}mengembang ke (non-kosong) nilai hash, ${(k)var}untuk (non-kosong) kunci (dalam urutan yang sama), dan ${(kv)var}untuk kedua kunci dan nilai.

Untuk mempertahankan nilai kosong, seperti untuk array, Anda perlu mengutip dan menggunakan @bendera.

Jadi untuk mencetak kunci dan nilai, itu hanya masalah

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

Meskipun untuk memperhitungkan hash yang mungkin kosong, Anda harus melakukan:

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

Perhatikan juga bahwa zsh menggunakan sintaks definisi array yang jauh lebih masuk akal dan berguna daripada ksh93(disalin oleh bash):

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

Yang membuatnya lebih mudah untuk menyalin atau menggabungkan array asosiatif:

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

(Anda tidak dapat dengan mudah menyalin hash tanpa loop dengan bash, dan perhatikan bahwa bashsaat ini tidak mendukung kunci kosong atau kunci / nilai dengan NUL byte).

Lihat juga zshberbagai fitur zipping yang biasanya perlu Anda gunakan dengan array asosiatif:

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

Karena typeset melakukan apa yang Anda inginkan mengapa tidak mengedit outputnya saja?

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

memberi

a2 = 2  
a1 = 1  
b1 = bbb 

Dimana

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

Verbose tetapi cukup mudah untuk melihat bagaimana pemformatan bekerja: cukup jalankan pipeline dengan semakin banyak perintah sed dan tr . Ubah mereka agar sesuai dengan selera cetak yang cantik.

Satu lagi opsi adalah untuk mendaftar semua variabel dan grep untuk yang Anda inginkan.

set | grep -e '^aa='

Saya menggunakan ini untuk debugging. Saya ragu itu sangat berkinerja karena daftar semua variabel.

Jika Anda sering melakukan ini, Anda bisa membuatnya berfungsi seperti ini:

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

Sayangnya ketika kami memeriksa kinerja menggunakan waktu:

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

Karena itu, jika Anda melakukan ini sangat sering, Anda ingin versi NO FORKS dari @ F.Hauri karena jauh lebih cepat.