1

So I discovered that the most convenient way to pass named arguments to bash functions is via 'temporary env variables' like so: kwd_arg=1 foo. And I want to use this to pass array variables but apparently these two features don't mix as expected & I want to know how to use them together properly.

I've tried the same syntax without a function involved & without 'temporary assignment': both worked. However when used together the array arg is treated as a plain string.

# bash func accepting an env kwd arg
foo() {
    echo ${array_arg[0]}
    echo ${array_arg[1]}
}

# doesn't work, array arg treated as string
array_arg=(1 2) foo
# output:
# (1 2)
#

# when set globally works surprisingly
array_arg=(1 2)
foo
# output:
# 1
# 2

# works of course
echo ${array_arg[0]}
echo ${array_arg[1]}
# output: same as above
Improve this question
20
  • 1
    @profPlum, bash arrays are not stored in the environment, they're stored in heap memory. The environment is a separate memory block allocated by the operating system, not malloc()ed by the running process. Please be specific about exactly which part of your example code shows bash arrays stored in the environment specifically. Commented Jul 22, 2019 at 22:15
  • 2
    @profPlum, assuming you're using a recent bash version, use a nameref: foo() { local -n theArray=$1; echo "${theArray[0]}"; } then initialize the array and pass the array name to the function: array_arg=(1 2); foo array_arg -- however, you must use a different variable name or you'll see a "circular reference" error. Commented Jul 22, 2019 at 22:19
  • 1
    (it's still not an "env var" in the literal sense of being a variable stored in the environment and thus readable by child processes, but insofar as the OP only cares about communicating with a different function in the same process, it should be good enough for the immediate use case). Commented Jul 22, 2019 at 22:20
  • 1
    If your string is genuinely space-delimited, there's no reason not to just pass it that way; you can read it into an array (read -r -a items <<<"$items_str"; for item in "${items[@]}"; do ...; done) on the receiving end. (for item in $items is buggy for reasons touched on in BashPitfalls #1; those issues can be mitigated by turning off globbing before expansion). Commented Jul 22, 2019 at 22:39
  • 1
    You also might consider using Julia as a shell; particularly in your field, Julia is likely to be interesting, as high-performance numeric computing is its primary target field. Commented Jul 24, 2019 at 3:18

1 Answer 1

Reset to default
0

This does not appear to be a good way to pass arrays:

If foo() { declare -p FOO; } then

$ FOO=bar foo
declare -x FOO="bar"            # OK
$ FOO=(a b c) foo
declare -x FOO="(a b c)"        # not an array

but

$ export FOO=(a b c)
$ foo
declare -ax FOO=([0]="a" [1]="b" [2]="c")
Improve this answer
Sign up to request clarification or add additional context in comments.

9 Comments

Try bash -c 'declare -p FOO', and you'll see that it wasn't actually exported at all. Which is what one would expect, since the environment only stores strings at the operating system level.
That the -x part, the variable's export attribute is set.
Yes, the flag is set, but once again, it's not actually exported; a subprocess can't see it. See ideone.com/XR9tRL
Right, arrays can't live in the environment.
At a bash prompt, type help declare. declare -p name just dumps the contents of the variable name, along with it's attributes. The demonstration is to show that you can't put arrays in the environment, only plain "scalar" values.
|

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.