for databaseName in a b c d e f; do
  # do something like: echo $databaseName
done 

See Bash Loops for, while and until for details.

If you don't need the data to be stored in an array but you also want to use every record for other things, you can loop normally through the data with a process substitution:

while IFS= read -r value _;
do
        echo "$value" >> list
done < <(grep "$1" /orch/servers)

With read -r value _ we are storing the first field in $value and the rest in the throw away variable $_.

You'd want a mapping of "keys" to "values", where "values" are the lists of strings, and the "keys" are ARGENT, BIENETRE…

You're on the right path with aoarrs, because you could use that array as associative array:

declare -A aoarrs
aoarrs[ARGENT]=$ARGENT
aoarrs[BIENETRE]=$BIENETRE

and then just iterate over all keys in that array using something like for key in ${!aoarrs[@]}….

Sadly, bash doesn't, for whatever reason, allow lists to be elements of these associative arrays.

So, things suck. You can for example join the elements of your lists with a reserved character to split them later on (that's stupid because it means you can't have all characters in your string, or need to start escaping them), or you build your own functions that take lists of strings, append them to a large array and then you implement your own associative lookup function on that container (that would be stupid; not only would it be slow, it would also require you to write relatively much code in a relatively ill-suited language). It would look terrible. Here's an example which I write down without testing it, because it's ugly enough that I need to get it out of my head, but don't want to deal with it any further:

#!/bin/bash
###############################
#        UNTESTED STUFF       #
# If you think this code is   #
# acceptable, consider doing  #
# something good for yourself #
# once in a while             #
###############################
declare -A index
declare -A lengths
declare -a storage

# Adds an entry to our our custom container
# 
# Usage:
# add_key_values KEY "list element 1" "list element 2" …
function add_key_values() {
  local key="$1"
  shift
  local -n valuelist=$@

  # get the length of the passed list, to save it
  local lengthlist=${#valuelist[@]}


  # get the end of the current storage, that's where we start adding
  # our list
  local start_index=${#storage[@]}

  # finally, actually store the list items in the storage
  for item in "${valuelist[@]}"; do
    storage+=("${item}")
  done
  lengths["${key}"]=$lengthlist
  index["${key}"]=$start_index
}

# Retrieve a list from the storage
# Sadly, bash is not a proper programming language, because what it calls
# "functions" don't do the one thing that a function needs to do:
# return a value for an argument. There's just no "return" mechanism in bash.
# 
# Returns an empty list if the key wasn't found.
#
# So, after sobbing a bit, we just say
# Usage:
# get_values $key
# Overwrites the `ret_val` variable with the list that was saved earlier
function get_values() {
  # prepare ret_val
  declare -g -a ret_val=()

  local key=$1

  # We return (with ret_val empty) if key isn't present
  # frigging bash doesn't have a "is key present in associative array" function…
  # so this is the workaround to check whether there's $key in $index.
  # seriously.
  local teststring
  teststring="$(printf 'index[%s]' "${key}")"
  # you need quite modern bash to even get the "is defined" -v test
  [[ -v "${teststring}" ]] || return

  # let's get all the elements from storage and append them to ret_val
  local start=${index[$key]}
  local length=${lengths[$key]}
  for idx in $(seq $(( start - 1 )) $((start - 1 + length)) ); do 
    ret_val+=("${storage[idx]}")
  done
}

####################
# EXAMPLE USAGE
####################
add_key_values "ARGENT" "Nous devons économiser de l'argent." "Je dois économiser de l'argent."
add_key_values "BIENETRE" ("Comment vas-tu?" "Tout va bien ?")

for key in ${!index[@]}; do
  echo "the list for value $key contains"
  get_values "${key}"
  for element in ${ret_val[@]}; do
    echo "element: ${element}"
  done
done

The next option is magic that involves "indirect addressing" of variables by name using eval. That's kind of evil, and stupid, and there's very many posts on here that hint at "if you're at that point, then maybe use a proper programming language instead of bash".

I'd concur with that: This whole problem would literally be done in four lines of python, with the first two lines would be storing "ARGENT" and "BIENETRE" and their lists into a dict. Or really, in any other common language that's not bash (or C, for that matter), associative arrays are less bad.

set etc bin var
while [ "$#" -gt 1 ]
do    [ "$1" = bin ] &&
      set "$@" sbin
      printf %s\\n "$1"
shift;done 

That will iterate over your list, tack sbin onto the end of said list conditionally, and include sbin in the iterable content.

As you’ve presumably learned by now from your research, bash doesn’t support multi-dimensional arrays per se, but it does support “associative” arrays.  These are basically indexed by a string, rather than a number, so you can have, for example,

grade[John]=100
grade[Paul]=100
grade[George]=90
grade[Ringo]=80

As demonstrated (but not explained very well) in the accepted answer of the question you linked to, indices of associative arrays can contain commas, and so a common trick is to concatenate your individual indices (0-1 × 0-3) into a string, separated by commas.  While this is more cumbersome than ordinary arrays, it can be effective:

$ declare -A a              <-- Create the associative array.
$ a[0,0]=1
$ a[0,1]=2
$ a[0,2]=3
$ a[0,3]=4
$ a[1,0]=5
$ a[1,1]=6
$ a[1,2]=7
$ a[1,3]=8
$ for i in 0 1
> do
>     echo ${a[$i,2]}
> done
3                           <-- And here’s your output.
7

It's fun to play with bash, but bash seems to have some issues to follow your imagination ;)

list_a=( 1 2 )
list_b=( 3 4 )

for key in "${list_a[@]}" "${list_b[@]}"; do
  echo "the key is: $key"
done

Output :

the key is: 1
the key is: 2
the key is: 3
the key is: 4