pasar - ¿Puedo exportar una variable al entorno desde un script bash sin buscarlo?

variables de entorno linux bash

Question

supongamos que tengo este script

export.bash :

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

cuando ejecuto el script, y trato de acceder al $VAR ¡no obtengo ningún valor!

echo $VAR

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

Answer 1

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

Respuesta rápida: No.

Pero hay varias soluciones posibles.

El más obvio, que ya has mencionado, es usar source o . para ejecutar la secuencia de comandos en el contexto de la shell de llamada:

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

Otra forma es hacer que el script, en lugar de establecer una variable de entorno, imprima comandos que establecerán la variable de entorno:

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

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

Tenga en cuenta que $(...) se unirá a la salida en una sola línea. Si tiene que configurar más de una cosa, debe agregar punto y coma a los comandos impresos para que sigan siendo válidos después de unirlos.

Un tercer enfoque es tener una secuencia de comandos que establece las variables de su entorno internamente y luego invoca 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 no es conveniente para el uso interactivo, ya que no proporciona la configuración en su caparazón actual (con todas las otras configuraciones y el historial que ha creado).

Answer 2

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

Answer 3

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 fuente, pero tal vez de esta manera es más útil y es interesante para otra persona.

Answer 4

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

export.bash:

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

Ahora:

./export.bash
echo $VAR

Answer 5

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

. ./export.bash

o

source ./export.bash

Ahora cuando se hace eco desde el shell principal funciona

 echo $VAR
HELLO, VARABLE

Ahora restableceremos VAR

export VAR=""
echo $VAR

Ahora ejecutaremos un script para generar la variable y luego desarmarla:

./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 están limitadas a la secuencia de comandos que ejecuta las exportaciones en la consola principal, por lo que en cuanto a un trabajo cron, lo agregaría como la consola siguiente ... para la parte del comando aún cuestionable: así es como lo haría corre desde tu caparazón:

En su símbolo del sistema (siempre que export.bash tenga múltiples 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 esto sea para su uso, puede hacer que las variables estén disponibles para sus scripts en cualquier momento haciendo un alias de 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 su archivo bashrc y puede hacer lo anterior en cualquier momento ...

De todos modos, volvamos al resto.

Esto lo hizo disponible globalmente y luego ejecutó el script.

¡simplemente repítelo y luego ejecute Exportar en el eco!

cat export.bash

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

Ahora dentro de la secuencia de comandos o la consola se ejecuta:

 export "$(./export.bash)"

Tratar:

echo $VAR
HELLO THERE

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

cat export.bash

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

prueba de gato-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 última actualización final para asignar automáticamente leer 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 guión: 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

Answer 6

Tal vez puedas 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 a la variable de uso externa, puede evitar escribir el archivo de script.