¿Pasar todas las variables de un script de shell a otro?

Digamos que tengo un script de shell / bash llamado test.sh :

#!/bin/bash

TESTVARIABLE=hellohelloheloo
./test2.sh

Mi test2.shaspecto es este:

#!/bin/bash

echo ${TESTVARIABLE}

Esto no funciona. No quiero pasar todas las variables como parámetros, ya que esto es excesivo.

¿Hay una manera diferente?

Básicamente tienes dos opciones:

1. Convierta la variable en una variable de entorno (export TESTVARIABLE ) antes de ejecutar el segundo script.
2. Fuente del segundo script, es decir, . test2.shy se ejecutará en el mismo shell. Esto le permitiría compartir variables más complejas como matrices fácilmente, pero también significa que el otro script podría modificar las variables en el shell de origen.

ACTUALIZAR:

Usar export para establecer una variable de entorno, puede usar una variable existente:

A=10
# ...
export A

Esto debería funcionar en ambos bashy sh. bashTambién permite que se combine así:

export A=10

Esto también funciona en mi sh (que resulta serbash , puede usar echo $SHELLpara verificar). Pero no creo que esté garantizado que funcione en todos sh, así que lo mejor es ir a lo seguro y separarlos.

Cualquier variable que exporte de esta manera será visible en los scripts que ejecute, por ejemplo:

ceniza:

#!/bin/sh

MESSAGE="hello"
export MESSAGE
./b.sh

b.sh:

#!/bin/sh

echo "The message is: $MESSAGE"

Luego:

$ ./a.sh
The message is: hello

El hecho de que ambos sean scripts de shell también es incidental. Las variables de entorno se pueden pasar a cualquier proceso que ejecute, por ejemplo, si usamos python en su lugar, podría verse así:

ceniza:

#!/bin/sh

MESSAGE="hello"
export MESSAGE
./b.py

b.py:

#!/usr/bin/python

import os

print 'The message is:', os.environ['MESSAGE']

Abastecimiento:

En su lugar, podríamos fuente como esta:

ceniza:

#!/bin/sh

MESSAGE="hello"

. ./b.sh

b.sh:

#!/bin/sh

echo "The message is: $MESSAGE"

Luego:

$ ./a.sh
The message is: hello

Esto más o menos "importa" el contenido de b.shdirectamente y lo ejecuta en el mismo shell . Tenga en cuenta que no tuvimos que exportar la variable para acceder a ella. Esto comparte implícitamente todas las variables que tiene, así como permite que el otro script agregue / elimine / modifique variables en el shell. Por supuesto, en este modelo, ambos scripts deben ser del mismo idioma ( sho bash). Para dar un ejemplo de cómo podríamos pasar mensajes de un lado a otro:

ceniza:

#!/bin/sh

MESSAGE="hello"

. ./b.sh

echo "[A] The message is: $MESSAGE"

b.sh:

#!/bin/sh

echo "[B] The message is: $MESSAGE"

MESSAGE="goodbye"

Luego:

$ ./a.sh
[B] The message is: hello
[A] The message is: goodbye

Esto funciona igualmente bien en bash. También facilita compartir datos más complejos que no podría expresar como una variable de entorno (al menos sin un poco de trabajo pesado de su parte), como las matrices o las matrices asociativas.

Fatal Error dio una posibilidad directa: ¡busca tu segundo script! Si le preocupa que este segundo script pueda alterar algunas de sus valiosas variables, siempre puede obtenerlo en una subshell:

( . ./test2.sh )

Los paréntesis harán que la fuente suceda en una subshell, de modo que la shell principal no vea que las modificaciones test2.shpodrían realizarse.

Hay otra posibilidad que definitivamente debería mencionarse aquí: uso set -a.

De la referencia POSIXset :

-a: Cuando esta opción está activada, el atributo de exportación se establecerá para cada variable a la que se realiza una asignación; vea el volumen de Definiciones básicas de IEEE Std 1003.1-2001, Sección 4.21, Asignación de variables . Si la asignación precede al nombre de una utilidad en un comando, el atributo de exportación no persistirá en el entorno de ejecución actual después de que la utilidad se complete, con la excepción de que la precedente de una de las utilidades integradas especiales hace que el atributo de exportación persista después de la ejecución. en ha completado. Si la asignación no precede a un nombre de utilidad en el comando, o si la asignación es el resultado de la operación de los getopts o la lectura utilidades, el atributo de exportación persistirá hasta que la variable se desarme.

Del Manual de Bash :

-a: Marque las variables y funciones que se modifican o crean para exportarlas al entorno de los comandos posteriores.

Entonces en tu caso:

set -a
TESTVARIABLE=hellohelloheloo
# ...
# Here put all the variables that will be marked for export
# and that will be available from within test2 (and all other commands).
# If test2 modifies the variables, the modifications will never be
# seen in the present script!
set +a

./test2.sh

 # Here, even if test2 modifies TESTVARIABLE, you'll still have
 # TESTVARIABLE=hellohelloheloo

Observe que las especificaciones solo especifican que con set -ala variable está marcada para exportación. Es decir:

set -a
a=b
set +a
a=c
bash -c 'echo "$a"'

hará eco cy no una línea vacía ni b(es decir,set +a no desmarca la exportación, ni "guarda" el valor de la asignación solo para el entorno exportado). Este es, por supuesto, el comportamiento más natural.

Conclusión: usar set -a/ set +apuede ser menos tedioso que exportar manualmente todas las variables. Es superior a la obtención del segundo script, ya que funcionará para cualquier comando, no solo los escritos en el mismo lenguaje de shell.

En realidad, hay una manera más fácil que exportar y desarmar u obtener de nuevo (al menos en bash, siempre y cuando esté de acuerdo con pasar las variables de entorno manualmente):

deja a.sh ser

#!/bin/bash
secret="winkle my tinkle"
echo Yo, lemme tell you \"$secret\", b.sh!
Message=$secret ./b.sh

y b.sh be

#!/bin/bash
echo I heard \"$Message\", yo

La salida observada es

[prueba de rob @ Archie] $ ./a.sh
Yo, déjame decirte "guiño mi tintineo", b.sh!
Escuché "guiña mi tintineo", yo

La magia se encuentra en la última línea de a.sh, donde Message, solo por la duración de la invocación de ./b.sh, se establece en el valor de secretfrom a.sh. Básicamente, es un poco como parámetros / argumentos con nombre. Sin embargo, más que eso, incluso funciona para variables como$DISPLAY , que controla en qué servidor X se inicia una aplicación.

Recuerde, la longitud de la lista de variables de entorno no es infinita. En mi sistema con un núcleo relativamente vainilla, xargs --show-limitsme dice que el tamaño máximo del búfer de argumentos es 2094486 bytes. Teóricamente, estás usando scripts de shell incorrectos si tus datos son más grandes que eso (tuberías, ¿alguien?)

Agregando a la respuesta de Fatal Error, hay una forma más de pasar las variables a otro script de shell.

La solución sugerida anteriormente tiene algunos inconvenientes:

1. using Export : Causará que la variable esté presente fuera de su alcance, lo que no es una buena práctica de diseño.
2. using Source : Puede provocar colisiones de nombres o sobrescribir accidentalmente una variable predefinida en algún otro archivo de script de shell que haya originado otro archivo.

Hay otra solución simple disponible para que la usemos. Teniendo en cuenta el ejemplo publicado por usted,

test.sh

#!/bin/bash

TESTVARIABLE=hellohelloheloo
./test2.sh "$TESTVARIABLE"

test2.sh

#!/bin/bash

echo $1

salida

hellohelloheloo

También es importante tener en cuenta que ""son necesarios si pasamos cadenas de varias palabras. Tomando un ejemplo más

master.sh

#!/bin/bash
echo in master.sh
var1="hello world"
sh slave1.sh $var1
sh slave2.sh "$var1"
echo back to master

slave1.sh

#!/bin/bash
echo in slave1.sh
echo value :$1

slave2.sh

#!/bin/bash
echo in slave2.sh
echo value : $1

salida

in master.sh
in slave1.sh
value :"hello
in slave2.sh
value :"hello world"

Ocurre debido a las razones descritas adecuadamente en este enlace.

En Bash, si exporta la variable dentro de una subshell, usando paréntesis como se muestra, evitará filtrar las variables exportadas:

#!/bin/bash

TESTVARIABLE=hellohelloheloo
(
export TESTVARIABLE    
source ./test2.sh
)

La ventaja aquí es que después de ejecutar el script desde la línea de comandos, no verá un $ TESTVARIABLE filtrado en su entorno:

$ ./test.sh
hellohelloheloo
$ echo $TESTVARIABLE
                            #empty! no leak
$

Otra opción está usando eval. Esto solo es adecuado si las cadenas son confiables. El primer script puede hacer eco de las asignaciones variables:

echo "VAR=myvalue"

Luego:

eval $(./first.sh) ./second.sh

Este enfoque es de particular interés cuando el segundo script para el que desea establecer variables de entorno no está en bash y tampoco desea que exportlas variables, tal vez porque sean sensibles y no quiera que persistan.

Otra forma, que es un poco más fácil para mí es usar tuberías con nombre. Las canalizaciones con nombre proporcionan una forma de sincronizar y enviar mensajes entre diferentes procesos.

Avergonzar:

#!/bin/bash
msg="The Message"
echo $msg > A.pipe

B.bash:

#!/bin/bash
msg=`cat ./A.pipe`
echo "message from A : $msg"

Uso:

$ mkfifo A.pipe #You have to create it once
$ ./A.bash & ./B.bash # you have to run your scripts at the same time

B.bash esperará el mensaje y tan pronto como A.bash envíe el mensaje, B.bash continuará su trabajo.