10

Is it possible to declare and export a array from a single statement within a function?

My current workaround is to first declare, then to export.

f() { foo=(1 2 3); export foo; }; f; export -p | grep foo=
declare -ax foo='([0]="1" [1]="2" [2]="3")'

I observe that:

f() { export bar=(1 2 3); }; f; export -p | grep bar=
<no output>

and:

f() { export baz="(1 2 3)"; }; f; export -p | grep baz=
declare -x baz="(1 2 3)" # not an array

I use v3.2.48(1)-release and can't upgrade.

Some background:

I have a friend with whome I am trying to study "some" Django.

He's more clueless than me at the command line and needs the following, on OSX hackintosh:

  • launch an interactive shell
  • find the PATH variable including the django bin dir, as per my specification
  • find an updated PYTHONPATH env var, with the various django libs visible
  • a nice interactive ipython shell to start typing commands in after double-clicking
  • (tricky) an interactive shell to fall back to once he CTRL-D exits from ipython

On Windows, I would alias a command shortcut, like cmd.exe, set custom environment variables and start ipython. This works: after exiting ipython one still finds oneself in a command interpreter.

Is this possible at all with OSX's standard bash? I played with bash -c but many things don't work, like changing into a directory, being able to exit python and stay in a terminal, etc. Also played with -s.

Improve this question
3
  • The third one is totally expected behaviour; you assign a string to baz so baz is categorically not an array. Commented Apr 5, 2013 at 4:21
  • @JonathanLeffler: absolutely. It was just an attempt at showing how clueless I am about how to do that, in the spirit "show us what you have tried already and where you failed". Showing some "effort", that's all. Commented Apr 5, 2013 at 4:24
  • What's ironic is that I have quite a bit of follow up to do on this but I have run out of questions I can ask in 30 days! :) I should probably open a TinoSino account #2 to support my continued self-learning.. ;) Commented Apr 5, 2013 at 4:55

3 Answers 3

Reset to default
10

You can't export an array in Bash (or any other shell). Bash will never export an array to the environment (until maybe implemented someday, see the bugs section in the manpage).

There are a couple things going on here. Again, setting the -x attribute on an array is nonsensical because it won't actually be exported. The only reason you're seeing those results is because you defined the array before localizing it, causing it to drop down to the next-outermost scope in which that name has been made local (or the global scope).

So to be clear, whenever you use a declaration command, you're always creating a local except when you use export or readonly with a non-array assignment as an argument, because these are POSIX, which doesn't specify either locals or arrays.

function f {
    typeset -a a # "a" is now local to "f"
    g
    printf 'Now back in "f": %s\n' "$(typeset -p a)"
}

function g {
    a=(1 2 3)                               # Assigning f's localized "a"
    typeset -a a                            # A new local a
    printf 'In "g": %s\n' "$(typeset -p a)" # g's local is now empty.
    a=(a b c)                               # Now set g's local to a new value.
    printf 'Still in "g": %s\n' "$(typeset -p a)"
}

f

# In "g": declare -a a='()'
# Still in "g": declare -a a='([0]="a" [1]="b" [2]="c")'
# Now back in "f": declare -a a='([0]="1" [1]="2" [2]="3")'

It seems if you give an array as an argument to export then Bash will make it local like any other declaration command. Basically don't use export to define an array. export is a POSIX builtin and its behavior is undefined for arrays, which is probably why bash just treats it as though you had used typeset -ax a=(1 2 3). Use typeset, local, or declare. There's really no way to know what's "correct", or even compare with other shells. ksh93 is the only other that accepts array assignments as arguments to declaration commands, and its behavior doesn't agree with Bash.

The important thing to understand is that the environment has nothing to do with it, you're just playing with the quirks of locals when trying to do nonstandard things with POSIX-only commands.

In order to actually get the effect you want, you may use typeset -p.

function f {
    typeset -a "${1}=(1 2 3)"
    typeset -p "$1"
}

typeset -a arr
eval "$(f arr)"
typeset -p arr

Bash guarantees you'll get out the correct result, but I find this isn't very useful and rarely use this approach. It's usually better to just let the caller define a local and use dynamic scope do the work (as you've already discovered... just do it without exporting).

In Bash 4.3 you can use typeset -n, which is really the most correct way to handle this.

Improve this answer
Sign up to request clarification or add additional context in comments.

5 Comments

If you can't export an array, how do you interpret the output from the examples I gave where the export -p command reports declare -ax bar='([0]="1" [1]="2" [2]="3")' for the result of an exported array called bar? Is that a string that can be evaluated as an array, or is it an array? (Also, is the bugs section you refer to in the online bash manual?)
@JonathanLeffler export isn't a good measure of what's actually in the environment, it just says what has the export attribute. printenv bar or bash -c 'typeset -p bar' should show nothing. In both the first and second examples, you see only the local bar. export in the 2nd acts like declare due to the array assignment argument. In the 3rd example, you see the same global bar from both export -p calls. That they've been given an export attribute is inconsequential in all cases. I was referring to the bottom of the plain old man page: "Array variables may not (yet) be exported."
OK. I'm used to shells that tell the truth rather than make things up as they go along; there are times when I'm disillusioned with bash. Trying the env command instead of export -p reveals that f() { declare -a bar=(1 2 3); export bar; env | grep bar=; }; f; export -p | grep bar= produces no output. So, I've no idea any more what the export command thinks it is doing. In real shells, it reports on the exported variables — things that are in the environment. Apparently, bash's version of export doesn't think it needs to be accurate about such issues.
@JonathanLeffler Well, it is consistent insofar as POSIX things are concerned (except bugs). It seems clear that since arrays can't be exported, the -x is just benign, like -t on variables. Nobody has implemented exporting arrays, and probably won't. That you can't count on the max environment variable size on all platforms is part of the reason. ksh just exports the 0th element (being consistent with treatment of arrays with no subscript specified). I only use export when actually aiming for strict POSIX conformance.
Thank you. This is a great answer. I had a lot of trouble finding this on SO, but I am so very glad I did.
3

The first option seems to be the only one that's going to work. I experimented with bash 4.2 as well as 3.2.48. The interesting information, to me, were these minor variants of your examples:

$ f() { declare -a bar=(1 2 3); export bar; export -p | grep bar=; }; f; export -p | grep bar=
declare -ax bar='([0]="1" [1]="2" [2]="3")'
$ f() { export  bar=(1 2 3); export -p | grep bar=; }; f; export -p | grep bar=
declare -ax bar='([0]="1" [1]="2" [2]="3")'
$ f() { bar=(1 2 3); export bar; export -p | grep bar=; }; f; export -p | grep bar=
declare -ax bar='([0]="1" [1]="2" [2]="3")'
declare -ax bar='([0]="1" [1]="2" [2]="3")'
$ unset bar
$ f() { bar=(1 2 3); }; f; set | grep bar=
bar=([0]="1" [1]="2" [2]="3")
    bar=(1 2 3)
$

In these examples, I test the export inside the function as well as outside the function. Because the variables are being defined in the function, they appear to be scope-limited to the function. The exception is when the variable is defined before any attributes are applied — the last two functions. There a global variable is created, and then exported (in one case).

So, if you're going to get the array exported from the function, you have to create it without the declare or export statements (because those make the variable local to the function), and then export it.

I hope that explains it; I can see fuzzily what's going on and it makes sense, after a fashion. I'm not sure I explained it as well as it should be explained.

In the declare section of the bash manual, it says:

When used in a function, declare makes each name local, as with the local command.

There isn't equivalent wording in the export. However, the observed behaviour is as if export is implemented by declare -x.

Improve this answer

2 Comments

I had resorted to doing it in separate steps after being puzzled by many experiments, most of them I did not report, very much like yours as well. We seem to have a followed a similar thought process for "trying to understand what's going on". I am very thankful for your answer and generous investment in time to look at this for me so I am upvoting in gratitude but if somebody has also a much cleared explanation.. I think the "accept" should go to him/her, agree? Let's leave it open for an elegant explanation, in case there is one..
An array could not be exported (still - 2016). The command you were using inside the function: bar=(1 2 3); export bar; export -p | grep "bar=" also "seems" to work outside the function. But a check of the env: env | grep "bar=" just comes out empty. It correctly reports scalar variables as exported: export baz=23; env| grep "baz=". Thus, the attribute is false/unreliable. The bash manual still has the line: Array variables may not (yet) be exported. almost at the end.
1

If I want to export the array MY_ARRAY, I use:

[[ $MY_ARRAY ]] && export A_MY_ARRAY=$(declare -p MY_ARRAY)

at caller side and 

[[ $A_MY_ARRAY =~ ^declare ]] && eval $A_MY_ARRAY

at sub script.

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.