Cómo trabajar con variables en Bash

Fatmawati Achmad Zaenuri / Shutterstock

Las variables son vitales si desea escribir scripts y comprender qué hará el código que está a punto de copiar y pegar desde la web en su computadora Linux. ¡Te ayudaremos a empezar!

Variables 101

Las variables son símbolos con nombre que representan una cadena o un valor numérico. Cuando los usa en comandos y expresiones, se tratan como si hubiera escrito el valor que contienen en lugar del nombre de la variable.

Para crear una variable, todo lo que necesita hacer es proporcionarle un nombre y un valor. Los nombres de sus variables deben ser descriptivos y recordarle el valor que contienen. Un nombre de variable no puede comenzar con un número ni contener espacios. Sin embargo, puede comenzar con un guión bajo. Aparte de eso, puede utilizar cualquier combinación de caracteres alfanuméricos en mayúsculas y minúsculas.

Ejemplos de

Aquí vamos a crear cinco variables. El formato es escribir el nombre, el signo igual =y el valor. Tenga en cuenta que no hay espacio antes o después del signo igual. Dar un valor a una variable a menudo se llama asignar un valor a la variable.

Vamos a crear cuatro variables de cadena y una variable numérica, this_year:

me=Dave

my_boost=Linux

him=Popeye

his_boost=Spinach

this_year=2019

PARA ver valor mantenido en una variable, use el echo pedido. Debe preceder el nombre de la variable con un signo de dólar $ siempre que haga referencia al valor que contiene, como se muestra a continuación:

echo $my_name

echo $my_boost

echo $this_year

Usemos todas nuestras variables a la vez:

echo "$my_boost is to $me as $his_boost is to $him (c) $this_year"

Los valores de las variables reemplazan sus nombres. También puede cambiar los valores de las variables. Para asignar un nuevo valor a la variable, my_boost, simplemente repita lo que hizo cuando asignó su primer valor, así:

my_boost=Tequila

Si vuelve a ejecutar el comando anterior, ahora obtiene un resultado diferente:

echo "$my_boost is to $me as $his_boost is to $him (c) $this_year"

Por lo tanto, puede usar el mismo comando que hace referencia a las mismas variables y obtener resultados diferentes si cambia los valores contenidos en las variables.

Hablaremos de la citación de variables más adelante. Por ahora, aquí hay algunas conclusiones:

• Una variable entre comillas simples ' se trata como una cadena literal y no como una variable.
• Variables entre comillas " se tratan como variables.
• Para obtener el valor contenido en una variable, debe proporcionar el signo de dólar $.
• Una variable sin el signo de dólar $ solo proporciona el nombre de la variable.

También puede crear una variable que tome su valor de una variable existente o de varias variables. El siguiente comando define una nueva variable llamada drink_of_the_Year, y le asigna los valores combinados de my_boost y this_year variables:

drink_of-the_Year="$my_boost $this_year"

echo drink_of_the-Year

Cómo usar variables en scripts

Los scripts quedarían completamente paralizados sin variables. Las variables proporcionan la flexibilidad que hace que un script sea una solución general en lugar de una solución específica. Para ilustrar la diferencia, aquí hay un script que cuenta los archivos en el /dev directorio telefónico.

Escríbalo en un archivo de texto y luego guárdelo como fcnt.sh (para «número 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, debe hacerlo ejecutable, como se muestra a continuación:

chmod +x fcnt.sh

Escriba lo siguiente para ejecutar el script:

./fcnt.sh

Esto imprime el número de archivos en el /dev directorio telefónico. Así es como funciona:

• Una variable llamada folder_to_count está definido y configurado para contener la cadena «/ dev».
• Otra variable, llamada file_count, se define. Esta variable toma su valor de una sustitución de comando. Esta es la frase de comando entre paréntesis $( ). Tenga en cuenta que hay un signo de dólar $ antes del primer paréntesis. Esta construcción $( ) evalúa los comandos entre paréntesis, luego devuelve su valor final. En este ejemplo, este valor se asigna al file_count variable. Hasta que file_count variable se refiere, ha pasado un valor para mantener; no se preocupa por cómo se obtuvo el valor.
• El comando evaluado en la sustitución del comando realiza una ls lista de archivos en el directorio en el folder_to_count variable, que se ha establecido en «/ dev». Entonces, el script ejecuta el comando «ls / dev».
• La salida de este comando se redirige a la wc pedido. los -l (número de líneas) causa de la opción wc Para contar el número de líneas en la salida de ls pedido. Dado que cada archivo se enumera en una línea separada, este es el número de archivos y subdirectorios en el directorio «/ dev». Este valor se asigna a file_count variable.
• La última línea usa echo para mostrar el resultado.

Pero esto solo funciona para el directorio «/ dev». ¿Cómo podemos hacer que el script funcione con cualquier directorio? Todo lo que se necesita es un pequeño cambio.

Cómo utilizar los parámetros de la línea de comandos en los scripts

Muchos comandos, como ls y wc, tome los parámetros de la línea de comando. Estos proporcionan información al pedido, por lo que sabe lo que quiere que haga. Si quieres ls para trabajar en su directorio personal y también para mostrar archivos ocultos, puede utilizar el siguiente comando, donde la tilde ~ y el -a La opción (todos) son parámetros de línea de comando:

ls ~ -a

Nuestros scripts pueden aceptar parámetros de línea de comandos. Se hace referencia a ellos como $1 para el primer parámetro, $2 como el segundo, y así sucesivamente, hasta $9 para el noveno parámetro. (De hecho, hay un $0, también, pero esto está reservado para mantener siempre el script).

Puede hacer referencia a los parámetros de la línea de comandos en un script tal como lo haría con las variables normales. Modifiquemos nuestro script, como se muestra a continuación, y guárdelo 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 el folder_to_count la variable recibe el valor del primer parámetro de la línea de comando, $1.

El resto del script funciona exactamente igual que antes. En lugar de una solución específica, su secuencia de comandos ahora es general. Puede usarlo en cualquier directorio, ya que no está codificado para funcionar solo con «/ dev».

A continuación, se explica cómo hacer que el script sea ejecutable:

chmod +x fcnt2.sh

Ahora inténtelo con algunos directorios. Puede hacer «/ dev» primero para asegurarse de obtener el mismo resultado que antes. Escriba lo siguiente:

./fnct2.sh /dev

./fnct2.sh /etc

./fnct2.sh /bin

Obtiene el mismo resultado (207 archivos) que antes para el directorio «/ dev». Eso es alentador, y está obteniendo resultados específicos de directorio para cada uno de los otros parámetros de la línea de comandos.

Para acortar el script, puede prescindir de la variable, folder_to_count, absolutamente, y solo referencia $1 a lo largo, de la siguiente manera:

#!/bin/bash 

file_count=$(ls $1  wc -l) 

echo $file_count files in $1

Trabajar con variables especiales

Mencionamos $0, que siempre se establece en el nombre del archivo de secuencia de comandos. Esto le permite usar el script para hacer cosas como imprimir su nombre correctamente, incluso si se le cambia el nombre. Esto es útil en situaciones de registro, donde desea saber el nombre del proceso que agregó una entrada.

Aquí están las otras variables predefinidas especiales:

• PS: cuántos parámetros de la línea de comandos se pasaron al script.
• PS: Todos los parámetros de la línea de comandos pasados ​​al script.
• PS: el estado de salida del último proceso que se ejecutó.
• $$: El ID de proceso (PID) del script actual.
• $ USUARIO: El nombre de usuario del usuario que ejecuta el script.
• $ HOSTNAME: el nombre de host de la computadora que ejecuta el script.
• $ SEGUNDOS: número de segundos que se ejecutó el script.
• $ AL AZAR: devuelve un número aleatorio.
• $ LINENO: Devuelve el número de línea actual del script.

Quieres verlos todos en un solo guión, ¿no es así? ¡Usted puede! Guarde lo siguiente como un archivo de texto llamado, special.sh:

#!/bin/bash

echo "There were $# command line parameters"
echo "They are: $@"
echo "Parameter 1 is: $1"
echo "The script is called: $0"
# any old process so that we can report on the exit status
pwd
echo "pwd returned $?"
echo "This script has Process ID $$"
echo "The script was started by $USER"
echo "It is running on $HOSTNAME"
sleep 3
echo "It has been running for $SECONDS seconds"
echo "Random number: $RANDOM"
echo "This is line number $LINENO of the script"

Escriba lo siguiente para que sea ejecutable:

chmod +x special.sh

Ahora puede ejecutarlo con varios parámetros de línea de comando diferentes, como se muestra a continuación.

Variables de entorno

Bash usa variables de entorno para establecer y guardar las propiedades del entorno que crea cuando se inicia. Esta información de retención a la que Bash puede acceder fácilmente, como su nombre de usuario, ubicación, cuántos comandos puede contener su archivo de historial, su editor predeterminado y más.

Para ver las variables de entorno activas en su sesión de Bash, use este comando:

env | less

Si se desplaza hacia abajo, es posible que encuentre algunos que serían útiles para hacer referencia en sus scripts.

Cómo exportar variables

Cuando se ejecuta un script, está en su propio proceso y las variables que utiliza no se pueden ver fuera de ese proceso. Si desea compartir una variable con otro script que lanza su script, debe exportar esa variable. Le mostraremos cómo hacer esto con dos scripts.

Primero, guarde 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"

Esto crea dos variables, first_var y second_vary asigna valores. Los imprime en la ventana del terminal, exporta las variables y llama script_two.sh. Cuando script_two.sh finaliza y el flujo del proceso vuelve a ese script, imprime las variables nuevamente en la ventana de terminal. Entonces puedes ver si han cambiado.

El segundo script que usaremos es script_two.sh. Este es el guión que script_one.shllamadas. Escriba lo siguiente:

#!/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 ejecutar estos scripts, debe 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

Esto es lo que nos dice la salida:

• script_one.sh imprime los valores de las variables, que son alfa y bravo.
• script_two.sh imprime los valores de las variables (alfa y bravo) tal como las recibió.
• script_two.sh los cambia a charlie y delta.
• script_one.sh imprime los valores de las variables, que siempre son alfa y bravo.

Lo que sucede en el segundo guión permanece en el segundo guión. Es como si se enviaran copias de las variables al segundo script, pero se eliminan cuando termina ese script. Las variables originales del primer guión no se modifican por lo que sucede con sus copias en el segundo.

Cómo citar variables

Es posible que haya notado que cuando los scripts se refieren a variables, están entre comillas. ". Esto permite que las variables sean referenciadas correctamente, de modo que sus valores se utilicen cuando se ejecuta la línea en el script.

Si el valor que asigna a una variable incluye espacios, deben estar entre comillas cuando los asigne a la variable. De hecho, de forma predeterminada, Bash usa un espacio como delimitador.

Aquí un ejemplo :

site_name=How-To Geek

Bash ve el espacio antes de «Geek» como una indicación de que se está iniciando un nuevo comando. Señala que no existe tal comando y aborta la línea. echo nos muestra que el site_name La variable no contiene nada, ni siquiera el texto «Cómo hacer».

Vuelva a intentarlo con comillas alrededor del valor, como se muestra a continuación:

site_name="How-To Geek"

Esta vez se reconoce como un valor único y se asigna correctamente al site_name variable.

echo es tu amigo

Puede llevar algún tiempo acostumbrarse a sustituir comandos, citar variables y recordar cuándo incluir el signo de dólar.

Antes de presionar Enter y ejecutar una línea de comando Bash, pruébelo con echo en frente de ella. De esta manera, puede asegurarse de que lo que va a suceder sea lo que desea. También puede detectar errores que pueda haber cometido en la sintaxis.