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

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 ?

¿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).

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 rest.

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 

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 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 

Ejecutar

 set -o allexport 

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

 source conf-file 

Cuando termines de ejecutar Esto deshabilitará el modo allexport.

 set +o allexport 

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.

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.