0

I'm trying to get a (key,multiple-value) structure (some sort of hashmap) in bash, like this :

[   
  [ "abc" : 1, 2, 3, 4 ],
  [ "def" : "w", 33, 2 ]    
]

I'd like to iterate through eack key (some kind of for key in ..., and get each value with something like map["def",2] or map[$key,2].

I've seen a couple of threads talking about single-value hashmap, but nothing about this issue.

I could go with N arrays, N being the amount of key in my map, filled with every field in a row, but I don't want to duplicate code as much as possible.

Thanks in advance !

Edit : I'd like to go through the structure with something like this :

for key in ${map[@]} do;
  echo $key # "abc" then "def"
  for value in ${map[$key,@]} do;
    ...
  done
done
Charles Duffy
  • 280,126
  • 43
  • 390
  • 441
SOKS
  • 190
  • 3
  • 11
  • 2
    Is there a reason you want/need to use bash for this? It really isn't suited for this very well. – Etan Reisner Jan 19 '15 at 13:39
  • Yeah I know, but I really need bash on this one :) – SOKS Jan 19 '15 at 13:42
  • possible duplicate of [multi-dimensional arrays in BASH](http://stackoverflow.com/questions/11233825/multi-dimensional-arrays-in-bash) – ghoti Jan 19 '15 at 13:45
  • Well, it's not that elegant (I didn't expected the solution to be though). I'll try it ! – SOKS Jan 19 '15 at 13:49
  • Which version of bash? If this is 4.3 or later, namevars are available, which make the many-arrays implementation far more tractable. – Charles Duffy Jan 20 '15 at 17:07

2 Answers2

3

Using modern bash features with the multiple-array case:

Assignment (manual):

map_abc=( 1 2 3 4 )
map_def=( w 33 2 )

Assignment (programmatic):

append() {
  local array_name="${1}_$2"; shift; shift
  declare -g -a "$array_name"
  declare -n array="$array_name" # BASH 4.3 FEATURE
  array+=( "$@" )
}
append map abc 1 2 3 4
append map def w 33 2

Iteration (done inside a function to contain the namevar's scope):

iter() {
  for array in ${!map_@}; do
    echo "Iterating over array ${array#map_}"
    declare -n cur_array="$array" # BASH 4.3 FEATURE
    for key in "${!cur_array[@]}"; do
      echo "$key: ${cur_array[$key]}"
    done
  done
}
iter

This can also be done without namevars, but in an uglier and more error-prone fashion. (To be clear, I believe the code given here uses eval safely, but it's easy to get wrong -- if trying to build your own implementation on this template, please be very cautious).

# Compatible with older bash (should be through 3.x).
append() {
  local array_name="${1}_$2"; shift; shift
  declare -g -a "$array_name"

  local args_str cmd_str
  printf -v args_str '%q ' "$@"
  printf -v cmd_str "%q+=( %s )" "$array_name" "$args_str"
  eval "$cmd_str"
}

...and, to iterate in a way compatible with bash back through 3.x:

for array in ${!map_@}; do
  echo "Iterating over array ${array#map_}"

  printf -v cur_array_cmd 'cur_array=( ${%q[@]} )' "$array"
  eval "$cur_array_cmd"

  for key in "${!cur_array[@]}"; do
    echo "$key: ${cur_array[$key]}"
  done
done

This is more computationally efficient than filtering through a single large array (the other answer given) -- and, when namevars are available, arguably results in cleaner code as well.

Charles Duffy
  • 280,126
  • 43
  • 390
  • 441
  • Complete answer, beautiful post, and nice explanations. You deserve 1000 thanks ! Thank you ! – SOKS Jan 22 '15 at 13:18
1

Do-able. The declaration is somewhat ugly

declare -A map=(
    [abc,0]=1
    [abc,1]=2
    [abc,2]=3
    [abc,3]=4
    [def,0]=w
    [def,1]=33
    [def,2]=2
)
key="def"
i=1
echo "${map[$key,$i]}"   # => 33

Iterating: helpful to keep a separate array of "keys":

keys=(abc def)

Then

for key in "${keys[@]}"; do 
    echo "$key"
    for idx in "${!map[@]}"; do 
        if [[ $idx == $key,* ]]; then 
            n=${idx##*,}
            printf "\t%s\t%s\n" "$n" "${map["$idx"]}"
        fi
    done
done

abc
    0   1
    1   2
    2   3
    3   4
def
    1   33
    0   w
    2   2
glenn jackman
  • 238,783
  • 38
  • 220
  • 352