En primer lugar, trabajar con variables en bash es vital si quieres escribir scripts y comprender lo que el código que estás a punto de cortar y pegar desde la web le hará a tu computadora con Linux. De esta manera, nunca está de más aprender qué tipo de cosas puedes hacer desde ordenador, comprendiendo todos los códigos de la línea de comandos.
Y hablando de comandos, te invitamos a leer nuestro artículo acerca de cómo aprender a usar el comando echo de Linux fácilmente. Solo tienes que hacer clic en el enlace y podrás tener toda la información que necesitas.
Trabajar con variables en bash: ¿Qué son las variables 101?
Para que puedas entenderlo sencillamente, las variables son símbolos que se les asigna un nombre, las cuales representan una cadena o un valor numérico. Cuando las utilizas en los comandos y expresiones, se trata como si hubieses escrito el valor que contienen en lugar del nombre de la variable.
Para crear una variable, solamente debes darle un nombre y un valor. Los nombres de tus variables deben ser descriptivos y recordarte el valor que tienen. Un nombre de variable no puede comenzar con un número ni tampoco puede contener espacios. No obstante, sí puede comenzar con un guión bajo. Aparte de esto, puedes utilizar cualquier combinación de caracteres alfanuméricos en mayúsculas y minúsculas.
¿Cómo puedes usar variables en scripts?
Los guiones estarían completamente cortados e incompletos sin variables. De este modo, las variables proporcionan la flexibilidad que hace que un script sea una solución general, más que específica. Para que puedas entender la diferencia, aquí tienes un script que cuenta los archivos en el directorio / dev.
Solo tienes que escribir esto en un archivo de texto y guardarlo como fcnt.sh (para «conteo de archivos»):
#!/bin/bash
folder_to_count=/dev
file_count=$(ls $folder_to_count | wc -l)
echo $file_count files in $folder_to_count
Antes de poder ejecutar el script, debes hacerlo ejecutable, como te mostramos con el siguiente comando.
chmod +x fcnt.sh
Ahora, debes escribir lo siguiente para ejecutar el script:
./fcnt.sh
Este script imprime el número de archivos en el directorio / dev. Así es como funciona
1.- Se define una variable llamada folder_to_count, y está configurada para contener la cadena «/ dev».
2.- Hay otra variable llamada file_count. Esta variable toma su valor de una sustitución de comando. Esta es la línea de comando entre paréntesis $(). Debes tener en cuenta que hay un signo de dólar $ antes del primer paréntesis. Esta construcción $() evalúa los comandos entre paréntesis y luego devuelve su valor final. Ese valor se asigna a la variable file_count. En lo que respecta a la variable file_count, se le ha pasado un valor para retener; no le preocupa cómo se obtuvo el valor.
3.- El comando evaluado en la sustitución de dicho comando, realiza una lista de archivos llamados ls en el directorio en la variable folder_to_count. La cual se ha establecido en «/ dev». Entonces, el script ejecuta el comando «ls / dev».
4.- La salida de este comando se canaliza al comando wc. La opción -l (recuento de líneas) hace que wc cuente el número de líneas en la salida del comando ls. Como cada archivo aparece en una línea separada, este es el recuento de archivos y subdirectorios en el directorio principal «/ dev». Este valor se asigna a la variable file_count.
5.- La línea final usa echo para generar el resultado.
Pero esto solo funciona para el directorio «/ dev». ¿Cómo puedes hacer que el script funcione con cualquier directorio? Todo lo que se necesita es un pequeño cambio en la línea de comandos.
Pasos para que puedas utilizar los parámetros de la línea de comandos en scripts
Muchos comandos como ls y wc, toman parámetros de la línea de comandos propiamente dicha. Estos a su vez, proporcionan información al comando, para que sepa lo que quieres que haga.
De esta manera, si quieres que ls funcione en tu directorio de inicio y también muestre archivos ocultos, puedes utilizar el siguiente comando, en donde la opción tilde ~ y -a (all) son parámetros de línea de comando.
ls ~ -a.
Estos scripts pueden aceptar parámetros de línea de comando y se hace referencia a ellos como: $1 para el primer parámetro, $2 para el segundo. Y así sucesivamente, hasta $9 para el noveno parámetro. En realidad, también hay $0, pero está reservado para mantener siempre el script.
Puedes hacer referencia a los parámetros de la línea de comandos en un script tal como lo harías con las variables regulares. Ahora, modifica tu script, como te mostramos a continuación y guárdalo con el nuevo nombre fcnt2.sh.
#!/bin/bash.
folder_to_count=$1.
file_count=$(ls $folder_to_count | wc -l).
echo $file_count files in $folder_to_count.
Esta vez, a la variable folder_to_count se le asigna el valor del primer parámetro de línea de comando, $1. El resto del script funciona exactamente igual que antes. Así que en lugar de una solución específica, tu script ahora es general. Puedes utilizarlo en cualquier directorio porque no está codificado para trabajar solo con «/ dev».
Así es como haces que el script sea ejecutable.
chmod +x fcnt2.sh.
Ahora, pruébalo con algunos directorios. Puede hacer «/ dev» primero para que te asegures de obtener el mismo resultado que antes. Solamente debes escribir lo siguiente.
1.- ./fnct2.sh /dev.
2.- ./fnct2.sh /etc.
3.- ./fnct2.sh /bin.
Como vez, obtienes el mismo resultado que antes para el directorio «/ dev». Esto es muy buena noticia. También, obtienes resultados específicos del directorio para cada uno de los otros parámetros de la línea de comandos. Para que puedas acortar el script, puedes prescindir de la variable folder_to_count en conjunto y solo hacer referencia a $1 de la siguiente manera.
#!/bin/bash.
file_count=$(ls $1 wc -l).
echo $file_count files in $1.
Trabajar con variables en bash: variables especiales
Anteriormente te hicimos mención al parámetro $0, que siempre se establece en el nombre de archivo del script. Esto te permite usar dicho script para hacer cosas como imprimir tu nombre correctamente, incluso si este se renombra. Hacer esto es muy útil en situaciones de registro, en las que quieres conocer el nombre del proceso que agregaste a una entrada.
Las siguientes son las otras variables preestablecidas especiales:
1.- $#: hace referencia a cuántos parámetros de línea de comando se pasaron al script.
2.- $@: todos los parámetros de la línea de comandos pasados al script.
3.- $?: se refiere al estado de salida del último proceso que se ejecutó.
4.- $$: el ID de proceso (PID) del script actual.
5.- $USER: Puedes ver el nombre de usuario del usuario que ejecuta el script.
6.- $HOSTNAME: el nombre de host de la computadora que ejecuta el script.
7.- $SECONDS: La cantidad de segundos que el script ha estado ejecutándose.
8.- $RANDOM: devuelve un número aleatorio.
9.- $LINENO: se usa para devolver el número de línea actual del script.
Trabajar con variables en bash: variables de entorno
En primer lugar, bash usa variables de entorno para definir y registrar las propiedades del entorno que crea cuando se inicia. A esta información de retención bash puedes acceder fácilmente, como tu nombre de usuario, configuración regional, la cantidad de comandos que puede contener tu archivo de historial, tu editor predeterminado y muchas cosas más.
Para que puedas ver las variables de entorno activas en tu sesión de bash, solo tienes que usar este comando.
env | less.
Si te desplazas por la lista, puedes encontrar algunos que podrían ser útiles para hacer referencia en tus scripts.
Trabajar con variables en bash¿De qué manera puedes exportar variables?
Cuando se ejecuta un script, está en su propio proceso y las variables que utiliza no se pueden ver fuera de dicho proceso. De tal manera que si quieres compartir una variable con otro script que inicia tu script, debes exportar dicha variable. No te preocupes, pues te mostraremos cómo hacerlo con dos sencillos scripts. En primer lugar, guarda lo siguiente con el nombre de archivo script_one.sh.
#!/bin/bash.
first_var=alpha.
second_var=bravo.
# check their values.
echo «$0: first_var=$first_var, second_var=$second_var».
export first_var.
export second_var.
./script_two.sh.
# check their values again.
echo «$0: first_var=$first_var, second_var=$second_var».
Esta acción creará dos variables, las cuales son: first_var y second_var. También asigna algunos valores. Los imprime en la ventana de terminal, exporta las variables y llama al script_two.sh. Cuando script_two.sh finaliza y el flujo del proceso vuelve a este script, nuevamente imprime las variables en la ventana del terminal. Entonces, puedes ver si cambiaron.
#!/bin/bash.
# check their values.
echo «$0: first_var=$first_var, second_var=$second_var».
# set new values.
first_var=charlie.
second_var=delta.
# check their values again.
echo «$0: first_var=$first_var, second_var=$second_var».
Este segundo script imprime los valores de las dos variables, les asigna nuevos valores y luego los imprime nuevamente. Para que puedas ejecutar estos scripts, debes escribir lo siguiente para que sean ejecutables.
chmod +x script_one.sh.
chmod +x script_two.sh.
Y ahora, escribe lo siguiente para iniciar script_one.sh.
./script_one.sh.
Como podrás ver, esto es lo que te dice la salida
1.- script_one.sh; imprime los valores de las variables, que son “alfa” y “bravo”.
2.- script_two.sh; imprime los valores de las variables alfa y bravo, tal como las recibió.
3.- script_two.sh; los cambia a las variables “charlie” y “delta”.
4.- script_one.sh; imprime los valores de las variables, que siguen siendo alfa y bravo.
Lo que sucede en el segundo script permanece en el segundo script. Es como si se enviaran copias de las variables al segundo script. Pero se descartan cuando ese script finaliza. Las variables originales en el primer script no se alteran por nada que les suceda a las copias en el segundo.
¡echo es tu amigo!
Puede llevar algún tiempo para que te acostumbres a la sustitución de comandos y recordar cuándo incluir el signo de dólar. Antes de presionar Enter y ejecutar una línea de comandos de bash, debes probarlo con el comando echo delante del mismo. De esta forma puedes asegurarte de que lo que vaya a suceder es lo que quieres. También, puedes detectar cualquier error que hayas cometido en la sintaxis de la línea de comandos y eso es todo.