Unable to use an Array as environment variable

Arrays are bash specific. Environment variables are name-value pairs.

Read the specifications on environment variables, which says, in part:

The value of an environment variable is a string of characters. For a C-language program, an array of strings called the environment shall be made available when a process begins. The array is pointed to by the external variable environ, which is defined as:

extern char **environ;

These strings have the form name=value; names shall not contain the character '='.

Current Array Export Situation 10/2021

Array export is not fully implemented yet. You can clone the source code with command git clone https://git.savannah.gnu.org/git/bash.git ~/bash-src. Look into the bash source ~/bash-src/config-top.h for the commented line 154:

/* Define to 1 if you want to be able to export indexed arrays to processes
   using the foo=([0]=one [1]=two) and so on */
/* #define ARRAY_EXPORT 1 */

and furthermore the code section in ~/bash-src/variables.c at line 429 which says

#if defined (ARRAY_VARS)
#  if ARRAY_EXPORT
      /* Array variables may not yet be exported. */
      if (*string == '(' && string[1] == '[' && string[strlen (string) - 1] == ')')
    {
      string_length = 1;
      temp_string = extract_array_assignment_list (string, &string_length);
      temp_var = assign_array_from_string (name, temp_string, 0);
      FREE (temp_string);
      VSETATTR (temp_var, (att_exported | att_imported));
      array_needs_making = 1;
    }
      else
#  endif /* ARRAY_EXPORT */
#endif

so basically some more work has to be put into this issue.

Workaround

Meanwhile you can export the BASH_ENV variable which can point to an environment script. I put mine into /etc/bash.environment and declare system-wide arrays there. Your ~/.bashrc could contain something like export BASH_ENV="~/.bash.environment", now every bash process executed by the current user will source this file.

As @they mentioned below an according ~/.bashrc configuration to take effect on interactive AND noninteractive shells is needed:

[ -r "~/.bash.environment" ] \
&& source "~/.bash.environment" \
&& export BASH_ENV="~/.bash.environment"

And finally your environment:

# ~/.bash.environment
export HELLO="ee"
export HELLOO=(aaa bbbb ccc)

Non-persistent Workaround

A non-persistent solution for passing arrays quick and dirty could look like so, that you assign the named pipe created by process substitution <() to BASH_ENV environment variable:

BASH_ENV=<(declare -p HELLO HELLOO) your_script.sh

Best wishes

We can convert an array like ${foo[]} into a multitude of numbered variables like $foo_0, $foo_1, $foo_2, and export these as environment variables.

In the receiving process, we can iterate from 0 over these variables and rebuild the array, stopping when we hit an unset variable.

The export_array and import_array functions in the following Bash example take a single argument: the name of the array like foo. The numbered variables use that as the base name.

export_array()
{
  local name=$1
  local -n a=$name
  local i

  # iterate over array, turning each element into numbered variable.
  for ((i = 0; i < "${#a[@]}"; i++)); do
     eval export ${name}_$i=\${a[i]}
  done

  # continue iterating increasing values of i, removing any numbered
  # variables that happen to be set, until encountering an unset one.
  for ((; ; i++)); do
     eval [ \"\${${name}_$i+x}\" != x ] && break
     eval unset ${name}_$i
  done
}

import_array()
{
  local name=$1
  local -n a=$name
  local i


  # clear the array
  a=()

  # iterate over numbered variables, breaking when hitting an unset one.
  # assign each one to the an array element
  for ((i = 0; ; i++)); do
     eval [ \"\${${name}_$i+x}\" != x ] && break
     eval a[$i]=\$${name}_$i
  done
}

unexport_array()
{
  local name=$1

  # iterate over numbered variables starting from 0, unsetting
  # them, stopping at the first one that is already unset
  for ((i = 0; ; i++)); do
     eval [ \"\${${name}_$i+x}\" != x ] && break
     eval unset ${name}_$i
  done
}

There; we don't have to wait for Bash to implement anything. This can probably be made to work on old Bash 3.x.

Basic test:

$ array=("a b c"  "d e"  "f '\" g" "h
> i")
$ export_array array
$ env | grep array
array_2=f '" g
array_3=h
array_0=a b c
array_1=d e
$ array=(x)
$ import_array array
$ printf "[%s] " "${array[@]}" ; printf "\n"
[a b c] [d e] [f '" g] [h
i]