Can I export a variable to the environment from a

问题:

suppose that I have this script

export.bash :

#! /usr/bin/env bash
export VAR=\"HELLO, VARIABLE\"

when I execute the script, and try to access to the $VAR I get no value !

echo $VAR

Is there any way to access to the $VAR by just executing export.bash without sourcing it ?

回答1:

Is there any way to access to the $VAR by just executing export.bash without sourcing it ?

Quick answer: No.

But there are several possible workarounds.

The most obvious one, which you\'ve already mentioned, is to use source or . to execute the script in the context of the calling shell:

$ cat set-vars1.sh 
export FOO=BAR
$ . set-vars1.sh 
$ echo $FOO
BAR

Another way is to have the script, rather than setting an environment variable, print commands that will set the environment variable:

$ cat set-vars2.sh
#!/bin/bash

echo export FOO=BAR
$ eval $(./set-vars2.sh)
$ echo $FOO
BAR

Note that the $(...) will join the output into a single line. If you have more than one thing to set, you should add semicolons to the printed commands so they\'re still valid after being joined together.

A third approach is to have a script that sets your environment variable(s) internally and then invokes a specified command with that environment:

$ cat set-vars3.sh
#!/bin/bash

export FOO=BAR
exec \"$@\"
$ ./set-vars3.sh printenv | grep FOO
FOO=BAR

This last approach can be quite useful, though it\'s inconvenient for interactive use since it doesn\'t give you the settings in your current shell (with all the other settings and history you\'ve built up).

回答2:

In order to export out the VAR variable first the most logical and seems working way is to source the variable:

. ./export.bash

or

source ./export.bash

Now when echoing from main shell it works

 echo $VAR
HELLO, VARABLE

We will now reset VAR

export VAR=\"\"
echo $VAR

Now we will execute a script to source the variable then unset it :

./test-export.sh 
HELLO, VARABLE
--
.

the code: cat test-export.sh

    #!/bin/bash
    # Source env variable
    source ./export.bash

    # echo out the variable in test script
    echo $VAR

    # unset the variable 
    unset VAR
    # echo a few dotted lines
    echo \"---\"
    # now return VAR which is blank
    echo $VAR

Here is one way

PLEASE NOTE: The exports are limited to the script that execute the exports in your main console - so as far as a cron job I would add it like the console like below... for the command part still questionable: here is how you would run in from your shell:

On your command prompt (so long as the export.bash has multiple echo values)

IFS=$\'\\n\'; for entries in $(./export.bash); do  export $entries;  done; ./v1.sh 
HELLO THERE
HI THERE

cat v1.sh

#!/bin/bash
echo $VAR
echo $VAR1

Now so long as this is for your usage - you could make the variables available for your scripts at any time by doing a bash alias like this:

myvars ./v1.sh
HELLO THERE
HI THERE

echo $VAR

.

add this to your .bashrc

function myvars() { 
    IFS=$\'\\n\'; 
    for entries in $(./export.bash); do  export $entries;  done; 

    \"$@\"; 

    for entries in $(./export.bash); do variable=$(echo $entries|awk -F\"=\" \'{print $1}\'); unset $variable;
done

}

source your bashrc file and you can do like above any time ...

Anyhow back to the rest of it..

This has made it available globally then executed the script..

simply echo it out then run export on the echo !

cat export.bash

#!/bin/bash
echo \"VAR=HELLO THERE\"

Now within script or your console run:

 export \"$(./export.bash)\"

Try:

echo $VAR
HELLO THERE

Multiple values so long as you know what you are expecting in another script using above method:

cat export.bash

#!/bin/bash
echo \"VAR=HELLO THERE\"
echo \"VAR1=HI THERE\"

cat test-export.sh

#!/bin/bash

IFS=$\'\\n\'
for entries in $(./export.bash); do
   export $entries
done

echo \"round 1\"
echo $VAR
echo $VAR1

for entries in $(./export.bash); do
     variable=$(echo $entries|awk -F\"=\" \'{print $1}\');
     unset $variable
done

echo \"round 2\"
echo $VAR
echo $VAR1

Now the results

 ./test-export.sh 
round 1
HELLO THERE
HI THERE
round 2


.

and the final final update to auto assign read the VARIABLES:

./test-export.sh 
Round 0 - Export out then find variable name - 
Set current variable to the variable exported then echo its value
$VAR has value of HELLO THERE
$VAR1 has value of HI THERE
round 1 - we know what was exported and we will echo out known variables
HELLO THERE
HI THERE
Round 2 - We will just return the variable names and unset them 
round 3 - Now we get nothing back

The script: cat test-export.sh

#!/bin/bash

IFS=$\'\\n\'
echo \"Round 0 - Export out then find variable name - \"
echo \"Set current variable to the variable exported then echo its value\"
for entries in $(./export.bash); do
 variable=$(echo $entries|awk -F\"=\" \'{print $1}\');
 export $entries
 eval current_variable=\\$$variable
 echo \"\\$$variable has value of $current_variable\"
done


echo \"round 1 - we know what was exported and we will echo out known variables\"
echo $VAR
echo $VAR1

echo \"Round 2 - We will just return the variable names and unset them \"
for entries in $(./export.bash); do
 variable=$(echo $entries|awk -F\"=\" \'{print $1}\');
 unset $variable
done

echo \"round 3 - Now we get nothing back\"
echo $VAR
echo $VAR1

回答3:

Found an interesting and neat way to export environment variables from a file:

in env.vars:

foo=test

test script:

eval `cat env.vars`
echo $foo         # => test
sh -c \'echo $foo\' # => 

export eval `cat env.vars`
echo $foo         # => test
sh -c \'echo $foo\' # => test

# a better one
export `cat env.vars`
echo $foo         # => test
sh -c \'echo $foo\' # => test

回答4:

Execute

set -o allexport

Any variables you source from a file after this will be exported in your shell.

source conf-file

When you\'re done execute. This will disable allexport mode.

set +o allexport

回答5:

Another workaround that, depends on the case, it could be useful: creating another bash that inherites the exported variable. It is a particular case of @Keith Thompson answer, will all of those drawbacks.

export.bash:

# !/bin/bash
export VAR=\"HELLO, VARIABLE\"
bash

Now:

./export.bash
echo $VAR

回答6:

The answer is no, but for me I did the following

the script: myExport

#! \\bin\\bash
export $1

an alias in my .bashrc

alias myExport=\'source myExport\' 

Still you source it, but maybe in this way it is more useable and it is interesting for someone else.

回答7:

Maybe you can write a function in ~/.zshrc, ~/.bashrc .

# set my env
[ -s ~/.env ] && export MYENV=`cat ~/.env`
function myenv() { [[ -s ~/.env ]] && echo $argv > ~/.env && export MYENV=$argv }

Beacause of use variable outside, you can avoid write script file.