¿Puedo exportar una variable al entorno desde un script bash sin obtenerla?

Supongamos que tengo este script

export.bash :

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

Cuando ejecuto el script e intento acceder al $VAR, no obtengo ningún valor.

echo $VAR

¿Hay alguna forma de acceder al archivo$VAR simplemente ejecutando export.bash sin obtenerlo ?

¿Hay alguna forma de acceder al $VARsimplemente ejecutando export.bashsin obtenerlo?

Respuesta rápida: no.

Pero hay varias soluciones posibles.

El más obvio, que ya ha mencionado, es usar sourceo .ejecutar el script en el contexto del shell de llamada:

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

Otra forma es tener el script, en lugar de establecer una variable de entorno, comandos de impresión que establecerán la variable de entorno:

$ cat set-vars2.sh
#!/bin/bash
echo export FOO=BAR
$ eval "$(./set-vars2.sh)"
$ echo "$FOO"
BAR

Un tercer enfoque es tener un script que establezca las variables de entorno internamente y luego invoque un comando específico con ese entorno:

$ cat set-vars3.sh
#!/bin/bash
export FOO=BAR
exec "$@"
$ ./set-vars3.sh printenv | grep FOO
FOO=BAR

Este último enfoque puede ser bastante útil, aunque es inconveniente para el uso interactivo, ya que no le brinda la configuración en su shell actual (con todas las demás configuraciones e historial que ha creado).

Para exportar primero la variable VAR, la forma más lógica y que parece funcionar es obtener la variable:

. ./export.bash

o

source ./export.bash

Ahora cuando hace eco desde el shell principal funciona

 echo $VAR
HELLO, VARABLE

Ahora reiniciaremos VAR

export VAR=""
echo $VAR

Ahora ejecutaremos un script para obtener la variable y luego la desarmaremos:

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

el código: 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

Aquí hay una manera

TENGA EN CUENTA: Las exportaciones se limitan al script que ejecuta las exportaciones en su consola principal, por lo que en lo que respecta a un trabajo cron, lo agregaría como la consola como a continuación ... para la parte del comando aún cuestionable: así es como lo haría corre desde tu caparazón:

En el símbolo del sistema (siempre que export.bash tenga varios valores de eco)

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

Ahora, siempre que sea para su uso, puede hacer que las variables estén disponibles para sus scripts en cualquier momento haciendo un alias bash como este:

myvars ./v1.sh
HELLO THERE
HI THERE

echo $VAR

.

agregue esto a su .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

}

fuente de su archivo bashrc y puede hacer lo anterior en cualquier momento ...

De todos modos volviendo al resto ...

Esto lo ha hecho disponible globalmente y luego ejecutó el script.

¡simplemente repítelo y luego ejecuta export en el eco!

gato export.bash

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

Ahora dentro del script o su consola ejecute:

 export "$(./export.bash)"

Tratar:

echo $VAR
HELLO THERE

Múltiples valores siempre que sepa lo que espera en otro script utilizando el método anterior:

gato 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

Ahora los resultados

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


.

y la actualización final final para la asignación automática lee las 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

El 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

Ejecutar

set -o allexport

Cualquier variable que obtenga de un archivo después de esto se exportará a su shell.

source conf-file

Cuando termines, ejecuta. Esto deshabilitará el modo allexport.

set +o allexport

Encontró una forma interesante y ordenada de exportar variables de entorno desde un archivo:

en env.vars:

foo=test

script de prueba:

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

Otra solución alternativa que, según el caso, podría ser útil: crear otro bash que herede la variable exportada. Es un caso particular de respuesta @Keith Thompson, tendrá todos esos inconvenientes.

export.bash:

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

Ahora:

./export.bash
echo $VAR

La respuesta es no, pero para mí hice lo siguiente

el script: myExport

#! \bin\bash
export $1

un alias en mi .bashrc

alias myExport='source myExport' 

Aún así lo obtienes, pero tal vez de esta manera es más útil y es interesante para otra persona.

Tal vez pueda escribir una función en ~ / .zshrc, ~ / .bashrc.

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

Debido al uso de variables externas, puede evitar escribir un archivo de script.