How to set a global environment variable in a bash script?
If I do stuff like
#!/bin/bash
FOO=bar
...or
#!/bin/bash
export FOO=bar
...the vars seem to stay in the local context, whereas I'd like to keep using them after the script has finished executing.
Run your script with .
. myscript.sh
This will run the script in the current shell environment.
export governs which variables will be available to new processes, so if you say
FOO=1
export BAR=2
./runScript.sh
then $BAR will be available in the environment of runScript.sh, but $FOO will not.
source is an alias for .. So you could run source myscript.sh instead, if you wanted to be more explicit.
When you run a shell script, it's done in a sub-shell so it cannot affect the parent shell's environment(1). You want to source the script by doing:
. ./setfoo.sh
This executes it in the context of the current shell, not as a sub shell.
From the bash man page:
. filename [arguments]
source filename [arguments]Read and execute commands from filename in the current shell environment and return the exit status of the last command executed from filename.
If filename does not contain a slash, file names in PATH are used to find the directory containing filename.
The file searched for in PATH need not be executable. When bash is not in POSIX mode, the current directory is searched if no file is found in PATH.
If the sourcepath option to the shopt builtin command is turned off, the PATH is not searched.
If any arguments are supplied, they become the positional parameters when filename is executed.
Otherwise the positional parameters are unchanged. The return status is the status of the last command exited within the script (0 if no commands are executed), and false if filename is not found or cannot be read.
(1) The intent of the export command is not to make variables accessible to the parent of a shell, it's to make them accessible to its children.
Let's say you have two shell scripts as follows, first script1.bash:
xyzzy=plugh # Set the variable.
./script2.bash # Execute in sub-shell.
. ./script2.bash # Execute in THIS shell.
export xyzzy # Mark variable for export.
./script2.bash # Execute in sub-shell again.
Then the script2.bash script which simply echoes the value:
echo "xyzzy=[$xyzzy]"
If you run that, you'll see that only an exported variable is seen in the sub-shell:
xyzzy=[] # Non-exported, not seen in sub-shell.
xyzzy=[plugh] # Non-exported, seen in same shell.
xyzzy=[plugh] # Exported, seen in sub-shell.
As mentioned, sourcing the script in the context of the current shell means the variable is available without export. It also mans you could change the variable there and have it affect the caller, since that caller is not the parent shell, but the same shell.
export <var>).export has nothing to do with it. Thanks for the comment, always appreciate constructive suggestions for improvement.source myscript.sh is also feasible.
Description for linux command source:
source is a Unix command that evaluates the file following the command,
as a list of commands, executed in the current context
source does?
man source in the terminal and you'll get what you want.source. Maybe the OP isn't.
man source may well return No manual entry for source. Try help source instead. This is because source is a command within the bash command language interpreter, so it has no man page of its own. Type help for all commands defined internally by the shell.#!/bin/bash
export FOO=bar
or
#!/bin/bash
FOO=bar
export FOO
man export:
The shell shall give the export attribute to the variables corresponding to the specified names, which shall cause them to be in the environment of subsequently executed commands. If the name of a variable is followed by = word, then the value of that variable shall be set to word.
export FOO = /mydir/barA common design is to have your script output a result, and require the cooperation of the caller. Then you can say, for example,
eval "$(yourscript)"
or perhaps less dangerously
cd "$(yourscript)"
This extends to tools in other languages besides shell script.
To adapt your example, if you save this in A.sh in your PATH and chmod +x it,
#!/bin/sh
echo 'FOO=bar'
you can then
eval "$(A.sh)"
to execute the output (in this case, FOO=bar) in the caller's context.
Obviously, always be careful with eval, and only evaluate strings from a trusted source.
A less adventurous solution is to save
#!/bin/sh
echo 'bar'
as B.sh in your PATH; then the calling script can do the assignment itself, without eval:
FOO=$(B.sh)
Notice how A.sh printed an actual snippet of shell script (the assignment expression) whereas B.sh only prints out the value to be assigned, or otherwise for the caller to use as they see fit.
(Obviously, the example scripts are ridiculously trivial placeholders. In real actual use, you'd use these mechanisms when the script you want to call is complex enough that you want to be able to reuse it.)
In your shell script, write the variables to another file like below and source these files in your ~/.bashrc or ~/.zshrc
echo "export FOO=bar" >> environment.sh
In your ~/.bashrc or ~/.zshrc, source it like below:
source Path-to-file/environment.sh
You can then access it globally.
