Variables inline temporales
Variables en Bash
Seguro que sabes trabajar exportando y fijando variables para tu uso en la shell de tu equipo o incluso cómo usarlas en los scripts de bash.
Quizás lo que no sepas es que existen unas variables que se pueden considerar temporales y tienen un sólo uso ya que se "destruyen" tras su utilización.
Yo las denomino "inline" ya que se usan directamente en la misma línea de la llamada a un comando.
Un problema
Imagínate que tienes ejecutar varias aplicaciones Java pero que por algún motivo cada una necesita usar diferentes librerías para su ejecución.
Podrías crear un script que fuese modificando cada una de las rutas de librerias, por ejemplo mediante un export LD_LIBRARY_PATH=.... justo en la línea anterior a cada llamada a la aplicación.
#!/bin/bash
export LD_LIBRARY_PATH=/opt/app1/libjqk
java -jar /opt/app1/App1.jar
export LD_LIBRARY_PATH=/opt/app2/libjqk
java -jar /opt/app2/App2.jar
export LD_LIBRARY_PATH=/opt/app3/libjqk
java -jar /opt/app3/App3.jar
# Esta usa LD_LIBRARY_PATH del Sistema
java -jar /opt/app4/App4.jar
Podría darse el caso, de que alguna otra aplicación posterior necesitase usar la ruta estandard de librerías que tengas definido en tu sistema, y entonces vas a tener que guardar previamente el valor original en otra variable y luego volverla a restaurar a su valor original para que funcione correctamente, el script te quedaría así:
#!/bin/bash
# guardar LD_LIBRARY_PATH del sistema
LDTEMP=$LD_LIBRARY_PATH
export LD_LIBRARY_PATH=/opt/app1/libjqk
java -jar /opt/app1/App1.jar
export LD_LIBRARY_PATH=/opt/app2/libjqk
java -jar /opt/app2/App2.jar
export LD_LIBRARY_PATH=/opt/app3/libjqk
java -jar /opt/app3/App3.jar
# Restaurar ruta previa del sistema
LD_LIBRARY_PATH=$LDTEMP
java -jar /opt/app4/App4.jar
Si resulta que más abajo, en el proceso del script tienes otra aplicación que usa otra vez LD_LIBRARY_PATH, de vuelta a almacenar la variable y restaurarla cuando lo necesites de nuevo...
Por no hablar de otros problemas de variables de entorno cuando lo vayas a ejecutar, por ejemplo desde un proceso cron
Una solución sencilla en Linux
Pues resulta que en Linux, puedes usar variables temporales que solo existen durante su uso y no afectan a las variables definidas ni en el sistema ni dentro de un script. Es lo que yo llamo "variables inline"
Vamos a comprobarlo de una manera muy fácil para que veas como funciona.
Creamos un script var1-inline.sh y escribimos el siguiente código en él:
#!/bin/bash
echo " >>> $MENSAJE <<<"
Recuerda darle permisos de ejecución: chmod +x var1-inline.sh
Ahora lo vamos a probar directamente:
./var1-inline.sh
>>> <<<
Como no existe ningúna variable en el sistema que se llame $MENSAJE nos muestra el valor vacío.
Ahora vamos a fijar la variable MENSAJE como variable del sistema, volvemos a ejecutar el script y comprobamos si el valor de MENSAJE se ha modificado:
export MENSAJE="Mensaje con valor del Sistema"
./var1-inline.sh
>>> Mensaje con valor del Sistema <<<
echo $MENSAJE
Mensaje con valor del Sistema
Perfecto. Exactamente como nos lo esperabamos.
Ahora vamos a realizar lo mismo, pero vamos a usar una variable inline
El funcionamiento es muy simple, tan solo tienes que escribir la variable y el valor que le quieras asignar, un espacio y el comando o script que quieras que la use, sin afectar a lo que tengas definido.
VARIABLE=valor comando
Veamoslo siguiendo el ejemplo anterior:
export MENSAJE="Mensaje con valor del Sistema"
MENSAJE="Sorprendido" ./var1-inline.sh
>>> Sorprendido <<<
echo $MENSAJE
Mensaje con valor del Sistema
¡ Vaya ! El script ha usado la variable que está en su misma línea de ejecución (inline) y la ha usado internamente.
No hemos necesitado ajustar el valor de la variable ni dentro del script, ni almacenarla y restaurarla desde la terminal. Se ha comportado como una variable temporal de un único uso para el script.
¿Puedo usar más de una variable inline?
Por supuesto, tan sólo tienes que dejar un espacio entre cada variable inline y al final de la línea indicar el comando que las va a usar:
VAR1=valor VAR2=valor VARn=valor comando
Para comprobarlo, vamos a crear un script que se llame variables-inline.sh con el siguiente contenido:
#!/bin/bash
# Si existen variables globales o del sistema se usan
# Excepto para las inline :-)
echo " >>> $VAR_UNO <<<"
echo " >>> $VAR_DOS <<<"
echo " >>> $VAR_TRES <<<"
Recuerda darle permisos de ejecución: chmod +x variables-inline.sh
Comprobamos al igual que antes, creando variables globales y luego usandolas mediante inline y luego comprobando que no ha modificado las definidas en el sistema:
export VAR_UNO="Global 1"
export VAR_DOS="Global 2"
export VAR_TRES="Global 3"
echo $VAR_UNO $VAR_DOS $VAR_TRES
Global 1 Global 2 Global 3
VAR_UNO="UNO" VAR_DOS="DOS" VAR_TRES="TRES" ./variables-inline.sh
>>> UNO <<<
>>> DOS <<<
>>> TRES <<<
echo $VAR_UNO $VAR_DOS $VAR_TRES
Global 1 Global 2 Global 3
Todo esto funciona tanto desde la línea de comandos, como desde dentro de cualquier script en bash.
Facilidad y Seguridad de uso
Como puedes comprobar, es una manera muy fácil de pasarle variables de entorno a cualquier programa que las necesite para modificar su comportamiento.
Además es una forma más segura de invocar a ciertos comandos, pues no modificas ninguna variable de sistema, te evitas fallos en los procesos de asignar nuevos valores a variables del sistema y luego tener que recuperar los valores que tuviesen esas variables inicialmente.
