Header Ads Widget

Ticker

6/recent/ticker-posts

Cómo trabajar con variables en Bash

 

Un terminal Linux con texto en verde en un portátil.

Las variables son vitales si desea escribir scripts y comprender qué hará el código que está a punto de cortar 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, simplemente proporcione un nombre y un valor para ella. Los nombres de sus variables deben ser descriptivos y recordarle el valor que tienen. Un nombre de variable no puede empezar con un número ni puede 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

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

Crearemos cuatro variables de cadena y una variable numérica, this_year:

yo = Dave
my_boost = Linux
él = Popeye
his_boost = Espinaca
this_year = 2019

Para ver el valor retenido en una variable, use el echocomando. 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 es para $ mí como $ his_boost es para $ él (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_boostsimplemente 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 es para $ mí como $ his_boost es para $ él (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 citar variables más adelante. Por ahora, aquí hay algunas cosas para recordar:

  • Una variable entre comillas simples ' se trata como una cadena literal y no como una variable.
  • Las 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 un número de variables. El siguiente comando define una nueva variable llamada drink_of_the_Year,y le asigna los valores combinados de las variables my_boostthis_year:

drink_of-the_Year = "$ my_boost $ this_year"
echo drink_of_the-Year

Cómo utilizar variables en scripts

Los scripts quedarían completamente paralizados sin variables. Las variables brindan la flexibilidad que hace que un script sea una solución general, más que específica. Para ilustrar la diferencia, aquí hay un script que cuenta los archivos en el /devdirectorio.

Escriba esto en un archivo de texto y luego guárdelo como fcnt.sh(para "recuento de archivos"):

#! / bin / bash

folder_to_count = / dev

file_count = $ (ls $ folder_to_count | wc -l)

echo $ file_count archivos en $ folder_to_count

Antes de poder ejecutar el script, debe convertirlo en 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 /devdirectorio. Así es como funciona:

  • Se folder_to_countdefine una variable llamada y se configura para contener la cadena "/ dev".
  • Se file_countdefine otra variable, llamada  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 y luego devuelve su valor final. En este ejemplo, ese valor se asigna a la file_countvariable. En lo que respecta a la file_countvariable, se le pasa un valor para mantener; no se preocupa por cómo se obtuvo el valor.
  • El comando evaluado en la sustitución de comandos realiza una lslista de archivos en el directorio de la folder_to_countvariable, que se ha establecido en "/ dev". Entonces, el script ejecuta el comando "ls / dev".
  • El resultado de este comando se canaliza en el wc comando. La -lopción (recuento de líneas) hace  wc que se cuente el número de líneas en la salida del  lscomando. Como cada archivo aparece en una línea separada, este es el recuento de archivos y subdirectorios en el directorio “/ dev”. Este valor se asigna a la file_countvariable.
  • La última línea usa echo para generar el resultado.

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

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

Muchos comandos, como lswc, toman parámetros de línea de comando. Estos proporcionan información al comando, por lo que sabe lo que quiere que haga. Si desea  lstrabajar en su directorio de inicio y también mostrar archivos ocultos, puede usar el siguiente comando, donde la tilde ~y la -aopció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 $1para el primer parámetro, $2como el segundo, y así sucesivamente, hasta $9para el noveno parámetro. (En realidad, también hay un $0, pero está reservado para mantener siempre el guión).

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 archivos en $ folder_to_count

Esta vez, la folder_to_countvariable se le asigna el valor del primer parámetro de línea de comandos, $1.

El resto del guión funciona exactamente como lo hacía antes. En lugar de una solución específica, su script ahora es general. Puede usarlo en cualquier directorio porque no está codificado para funcionar solo con "/ dev".

Así es como hace que el script sea ejecutable:

chmod + x fcnt2.sh

Ahora, pruébelo 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". Esto es alentador y obtiene resultados específicos del 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,, por completo, y solo hacer referencia a lo $1largo, de la siguiente manera:

#! / bin / bash 

file_count = $ (ls $ 1 wc -l) 

echo $ file_count archivos en $ 1

Trabajar con variables especiales

Mencionamos $0, que siempre se establece en el nombre de archivo del script. 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, en las que desea saber el nombre del proceso que agregó una entrada.

Las siguientes son las otras variables preestablecidas especiales:

  • $ # : Cuántos parámetros de la línea de comandos se pasaron al script.
  • $ @ : 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.
  • $ USER : El nombre de usuario del usuario que ejecuta el script.
  • $ HOSTNAME : el nombre de host de la computadora que ejecuta el script.
  • $ SECONDS : el número de segundos que se ha estado ejecutando el script.
  • $ RANDOM : 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? ¡Usted puede! Guarde lo siguiente como un archivo de texto llamado  special.sh:

#! / bin / bash

echo "Había $ # parámetros de línea de comando"
echo "Ellos son: $ @"
echo "El parámetro 1 es: $ 1"
echo "El script se llama: $ 0"
# cualquier proceso anterior para que podamos informar sobre el estado de salida
pwd
echo "pwd devolvió $?"
echo "Esta secuencia de comandos tiene ID de proceso $$"
echo "El script fue iniciado por $ USER"
echo "Se está ejecutando en $ HOSTNAME"
dormir 3
echo "Se ha estado ejecutando durante $ SECONDS segundos"
echo "Número aleatorio: $ RANDOM"
echo "Este es el número de línea $ LINENO del script"

Escriba lo siguiente para que sea ejecutable:

chmod + x special.sh

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

Variables de entorno

Bash usa variables de entorno para definir y registrar las propiedades del entorno que crea cuando se lanza. Estos contienen información a la que Bash puede acceder fácilmente, como su nombre de usuario, ubicación, la cantidad de comandos que puede contener su archivo de historial, su editor predeterminado y mucho más.

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

env | menos

Si se desplaza por la lista, 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 inicie su script, debe exportar esa variable. Le mostraremos cómo hacerlo con dos scripts.

Primero, guarde lo siguiente con el nombre de archivo  script_one.sh:

#! / bin / bash

first_var = alpha
second_var = bravo

# comprobar sus valores
echo "$ 0: first_var = $ first_var, second_var = $ second_var"

exportar first_var
exportar second_var

./script_two.sh

# revisa sus valores nuevamente
echo "$ 0: first_var = $ first_var, second_var = $ second_var"

Esto crea dos variables first_varsecond_var, y asigna algunos valores. Los imprime en la ventana del terminal, exporta las variables y llama script_two.shCuando script_two.shtermina, y el flujo del proceso vuelve a este script, vuelve a imprimir las variables en la ventana de la terminal. Luego, puedes ver si cambiaron.

El segundo script que usaremos es script_two.shEste es el guión que  script_one.shllama. Escriba lo siguiente:

#! / bin / bash

# comprobar sus valores
echo "$ 0: first_var = $ first_var, second_var = $ second_var"

# establecer nuevos valores
first_var = charlie
second_var = delta

# revisa sus valores nuevamente
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, escriba 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 siguen siendo 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 descartan cuando ese script sale. Las variables originales en el primer script no se alteran por nada de lo que suceda con las copias de ellos en el segundo.

Cómo cotizar variables

Es posible que haya notado que cuando los scripts hacen referencia a variables, están entre comillas "Esto permite que las variables sean referenciadas correctamente, por lo que sus valores se utilizan 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. Esto se debe a que, de forma predeterminada, Bash usa un espacio como delimitador.

He 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. Informa que no existe tal comando y abandona la línea. echonos muestra que la site_namevariable no contiene nada, ni siquiera el texto "Cómo hacer".

Vuelva a intentarlo entre 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 a la site_namevariable.

echo es tu amigo

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

Antes de presionar Enter y ejecutar una línea de comandos Bash, pruébelo con echodelante. De esta manera, puede asegurarse de que lo que sucederá sea lo que desea. También puede detectar cualquier error que haya cometido en la sintaxis.

Publicar un comentario

0 Comentarios