Trabajando con variables en Linux

En los sistemas Linux se almacenan muchos valores importantes en lo que llamamos "variables", pero en realidad hay varios tipos de variables y algunos comandos interesantes que pueden ayudarlo a trabajar con ellos. En una publicación anterior, analizamos las variables de entorno y dónde están definidas. En esta publicación, veremos las variables que se usan en la línea de comando y dentro de los scripts.

Variables de usuario

Si bien es bastante fácil configurar una variable en la línea de comando, hay algunos trucos interesantes. Para configurar una variable, todo lo que necesita hacer es algo como esto:

$ myvar = 11 $ myvar2 = "once" 

Para mostrar los valores, simplemente haga esto:

$ echo $ myvar 11 $ echo $ myvar2 once 

También puedes trabajar con tus variables. Por ejemplo, para incrementar una variable numérica, puede usar cualquiera de estos comandos:

$ myvar = $ ((myvar + 1)) $ echo $ myvar 12 $ ((myvar = myvar + 1)) $ echo $ myvar 13 $ ((myvar + = 1)) $ echo $ myvar 14 $ ((myvar ++)) $ echo $ myvar 15 $ let "myvar = myvar + 1" $ echo $ myvar 16 $ let "myvar + = 1" $ echo $ myvar 17 $ let "myvar ++" $ echo $ myvar 18 

Con algunos de estos, puede agregar más de 1 al valor de una variable. Por ejemplo:

$ myvar0 = 0 $ ((myvar0 ++)) $ echo $ myvar0 1 $ ((myvar0 + = 10)) $ echo $ myvar0 11 

Con todas estas opciones, probablemente encontrará al menos una que sea fácil de recordar y conveniente de usar..

Tú también puedes desarmado una variable, básicamente indefinida.

$ unset myvar $ echo $ myvar 

Otra opción interesante es que puede configurar una variable y hacerla solo lectura. En otras palabras, una vez que se establece en solo lectura, su valor no se puede cambiar (al menos no sin una maliciosa línea de comandos muy complicada). Eso significa que tampoco puedes desarmarlo.

$ readonly myvar3 = 1 $ echo $ myvar3 1 $ ((myvar3 ++)) -bash: myvar3: variable de solo lectura $ unset myvar3 -bash: unset: myvar3: no puede desarmar: variable de solo lectura 

Puede usar cualquiera de esas opciones de configuración e incremento para asignar y manipular variables dentro de los scripts, pero también hay algunas muy útiles variables internas para trabajar dentro de scripts. Tenga en cuenta que no puede reasignar sus valores o incrementarlos.

Variables internas

Hay bastantes variables que se pueden usar dentro de los scripts para evaluar argumentos y mostrar información sobre el script en sí..

  • $ 1, $ 2, $ 3, etc. representan los argumentos primero, segundo, tercero, etc. del script.
  • $ # representa el número de argumentos.
  • $ * representa la cadena de argumentos.
  • $ 0 representa el nombre del script en sí.
  • PS representa el código de retorno del comando ejecutado anteriormente (0 = éxito).
  • $$ muestra la ID del proceso para el script.
  • $ PPID muestra la ID del proceso para su shell (el proceso principal para el script).

Algunas de estas variables también funcionan en la línea de comando pero muestran información relacionada:

  • $ 0 muestra el nombre del shell que está utilizando (por ejemplo, -bash).
  • $$ muestra la ID de proceso para su shell.
  • $ PPID muestra la ID del proceso para el proceso padre de su shell (para mí, esto es sshd).

Si arrojamos todas estas variables en un script solo para ver los resultados, podríamos hacer esto:

#! / bin / bash echo $ 0 echo $ 1 echo $ 2 echo $ # echo $ * echo $? echo $$ echo $ PPID 

Cuando llamamos a este script, veremos algo como esto:

$ tryme one two three / home / shs / ​​bin / tryme <== script name one <== first argument two <== second argument 3 <== number of arguments one two three <== all arguments 0 <== return code from previous echo command 10410 <== script's process ID 10109 <== parent process's ID 

Si verificamos el ID del proceso del shell una vez que el script termina de ejecutarse, podemos ver que coincide con el PPID que se muestra dentro del script:

$ echo $$ 10109 <== shell's process ID 

Por supuesto, es más probable que usemos estas variables de maneras considerablemente más útiles que simplemente mostrar sus valores. Veamos algunas formas en que podríamos hacer esto.

Verificando si se han proporcionado argumentos:

si [$ # == 0]; entonces echo "$ 0 nombre de archivo" salida 1 fi 

Verificando si un proceso en particular se está ejecutando:

ps -ef | grep apache2> / dev / null if [$? ! = 0]; entonces echo Apache no está ejecutando la salida fi 

Verificación de que existe un archivo antes de intentar acceder a él:

si [$ # -lt 2]; luego repita "Uso: $ 0 líneas nombre de archivo" salir 1 fi si [! -f $ 2]; luego repita "Error: archivo $ 2 no encontrado", salga de la otra cabeza 2 - $ 1 $ 2 fi 

Y en este pequeño script, verificamos si se ha proporcionado el número correcto de argumentos, si el primer argumento es numérico y si el segundo argumento es un archivo existente.

#! / bin / bash if [$ # -lt 2]; luego repita "Uso: $ 0 líneas nombre de archivo" salir 1 fi si [[$ 1! = [0-9] *]]; entonces echo "Error: $ 1 no es numérico" salga 2 fi si [! -f $ 2]; luego echo "Error: archivo $ 2 no encontrado" salir 3 más echo arriba del encabezado del archivo - $ 1 $ 2 fi 

Renombrar variables

Al escribir un guión complicado, a menudo es útil asignar nombres a los argumentos del guión en lugar de seguir refiriéndose a ellos como $ 1, $ 2, etc. En la línea 35, alguien que lea su guión podría haber olvidado lo que representa $ 2. Será mucho más fácil para esa persona si asigna un valor de parámetro importante a $ filename o $ numlines.

#! / bin / bash if [$ # -lt 2]; luego repita "Uso: $ 0 líneas nombre de archivo" salir 1 más numlines = $ 1 nombre de archivo = $ 2 fi if [[$ numlines! = [0-9] *]]; entonces echo "Error: $ numlines no es numérico" salga 2 fi si [! -f $ nombre de archivo]; luego echo "Error: archivo $ nombre de archivo no encontrado" salir 3 más echo parte superior del encabezado del archivo - $ numlines $ nombre de archivo fi 

Por supuesto, este script de ejemplo no hace más que ejecutar el comando head para mostrar las líneas X superiores en un archivo, pero está destinado a mostrar cómo se pueden usar los parámetros internos dentro de los scripts para ayudar a garantizar que el script se ejecute bien o falle al menos algo de claridad.

[Vea los Consejos de Linux de dos minutos de Sandra Henry-Stocker para aprender a dominar una gran cantidad de comandos de Linux] Únase a las comunidades de Network World en Facebook y LinkedIn para comentar temas que son lo más importante.