• Índice

Creando tus propios comandos

Nota: Antes de empezar a leer esta página se recomienda haber leído la relacionada comandos y uso básico de la shell

Una de las principales ventajas de tener agilidad trabajando con la terminal de comandos el Linux es la posibilidad de crearnos nuestras propias herramientas o comandos personalizados. Si hay un grupo de comandos que solemos usar siempre de forma secuencial podemos agruparlos todos dentro de un script o fichero de ordenes. A este fichero le daremos un nombre y a partir de ese momento lo lanzaremos como si fuera un comando del sistema. Este fichero será leído e interpretado por la shell y sus ordenes internas se ejecutarán como si tu mismo las hubieras tecleado en una consola de comandos. Veamos un ejemplo sencillo. Tecla en tu consola nano mifichero para empezar a editar un fichero de texto con este nombre y escribe en su interior:

#!/bin/bash

echo "Hola mundo!" 
echo "Este es mi primer script" 
ls  | tail -1

Este sencillo script muestra por pantalla dos sencillos mensajes usando el comando echo y para terminar vuelva a la pantalla la última línea de la salida producida por el comando ls sobre tu directorio personal.

Una vez escrito lo anterior en tu fichero, guarda los cambios y sal del editor. Para poder ejecutar tu nuevo script bastaría con darle (una sola vez) permisos de ejecución y lanzarlo por el nombre que tenga el fichero con un ‘.’ y una ‘/’ como prefijo.

sergio@maquina: $chmod +x mifichero
sergio@maquina:~$ ./mifichero

Acabas de escribir y lanzar tu primer script. Recuerda que el permiso de ejecución no debes dárselo más veces pues se queda ya asignado al fichero.

Variables

Dentro de nuestros scripts podemos crear variables como si de un programa normal se tratara. Para crear una variable basta con darla un nombre y asignarla un valor. Si más tarde queremos acceder a su valor hemos de usar siempre el prefijo $. Por ejemplo, para crear una variable con un valor y luego imprimirla haremos algo como:

#!/bin/bash

VAREJEMPLO=845 
echo "La variable de ejemplo guarda el valor ${VAREJEMPLO}"

Encerrar la variable entre {} no es obligatorio pero suele recomendarse por claridad. Es importante también remarcar algo que puede parecer obvio o quizás no lo sea tanto: una variable no existe antes de que le asignemos un primer valor y si intentamos imprimirla antes de ese momento, su valor será vacío. En una variable podemos guardar un valor estático de tipo numérico o string y también podemos guardar un valor dinámico. Estos valores son producidos a su vez por al salida de un comando. Para guardar en una variable el valor de salida de un comando usaremos el acento invertido tal y como se ve en el ejemplo:

#!/bin/bash

ULTIMA=`tail -1 fichero.txt`
echo "La última línea del fichero es:$ULTIMA "

Instrucciones condicionales

Otro elemento que podemos incluir en nuestros scripts son instrucciones condicionales o selectivas que tomen un comportamiento u otro en base al valor de una o varias variables. La instrucción básica para esta labor es if. Esta instrucción modifica el código del programa realizando un bloque de operaciones en base al valor de la expresión que lo lidera.

if [ expresión ] then 
    rama de instrucciones 1 
else 
    rama de instruciones 2 
fi

Se evalua la veracidad o la falsedad de la expresión y, en caso de ser esta cierta se ejecutan las instrucciones de la rama 1 y de ser falsa, se ejecutarán las instrucciones de la rama 2. El else y la segunda rama es opcional y en caso de no no existir y de ser falsa la expresión. No se ejecutaría nada y se continuaría con las instrucciones tras el if.

La expresión que acompaña a if se suele enmarcar entre [  y ] . Dentro se han de colocar los dos operandos separados por un operador de comparación. En base al tipo que sean los operandos (cadenas de caracteres o números) se debe elegir un operador u otro. A continuación se muestra una tabla con los principales operadores y el tipo al que se aplican.

  Operador   Significado   Tipo
  ---------- ------------- -----------------------
  ==         Igual         Cadenas de caracteres
  !=         Distinto      Cadenas de caracteres
  -gt        Mayor que     Números
  -lt        Menor que     Números
  -eq        Igual         Números
  -ne        Distinto      Números

Veamos un ejemplo de uso en el que vamos a comparar una variable con un dato de tipo númerico y una variable con un dato de tipo cadena de caracteres.

CICLO="asir" 
NOTA=7

if [ $CICLO != "dam" ]
then
  echo "Solo se evalúa la nota de alumnos de DAM"
else
    if [ $NOTA -gt 4 ] then 
        echo "El alumno ha aprobado 
    else 
        echo "El alumno ha suspendido" 
    fi 
fi

Instrucciones repetitivas

Para aportar todavía más potencia a nuestros scripts podemos utilizar instrucciones iterativas con las que poder repetir una o varias instrucciones en bloque sobre una lista de elementos. Una de las instrucciones iterativas más usadas es la instrucción for. Esta instrucción recibe como parámetros una variable cuyo valor pivota entre una lista de elementos en cada repetición.

for VARIABLE in lista do 
    rama de instrucciones 
done

La rama interna de instrucciones se ejecutará tantas veces como elementos haya en la lista. En cada repetición, VARIABLE tomará uno de los valores de la lista, comenzando con el valor de la izquierda y terminando por el valor de la derecha. Veamos un ejemplo sencillo:

LISTA="perro gato pájaro hurón" 
for ANIMAL in LISTA do 
    echo "Tengo un $ANIMAL" 
done

Una de las curiosidades que pueden darnos mucha versatilidad a nuestros scripts es generar la lista que acompaña a la instrucción for de forma dinámica a través de un comando del sistema usando las comillas invertidas vistas anteriormente. En el ejemplo siguiente hacemos pivotar el valor de la variable LOGIN entre los elementos de una lista, pero esta lista se creará de forma dinámica tras la ejecución en primer lugar del comando ls /home.

for LOGIN in `ls /home`
do
    echo "El usuario $LOGIN tiene su home en /home/$LOGIN"
done

Variables de entorno

Al igual que en nuestros scripts podemos crear cualquier variable, existen variables que se crean durante el arranque de la primera shell que nos da acceso al sistema. Estas variables se llaman variables de entorno y suele ser utilizadas por la shell para guardar información que puede querer consultar durante nuestra sesión, por ejemplo: nuestro nombre de usuario, nuestro editor de textos favorito, la ruta de nuestro directorio personal, etc.

Una de las variables de entorno más importante es la variable PATH. Está predefinida por root y marca las rutas de los directorios donde la shell puede encontrar los ejecutables de los comandos que usamos. Por ejemplo, cuando tecleamos ls, la shell busca un ejecutable con ese nombre entre todas las rutas que tiene guardadas la variable PATH. Podemos consultar que rutas son esas simplente usando echo $PATH en nuestra shell:

sergio@maquina:~$ echo $PATH
/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games

Las rutas nos aparecen separadas por el caracter ‘:’. Si queremos utilizar nuestros propios scripts sin el incómodo prefijo del punto y la barra para marcar su ruta relativa, simplemente basta con que guardemos todos nuestros scripts en un solo directorio (por ejemplo en /home/sergio/bin) y añadamos la ruta de este directorio a las que la variable PATH tenía de antes:

sergio@maquina:~$ export PATH=$PATH:/home/sergio/bin
sergio@maquina:~$ echo $PATH
/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games:/home/sergio/bin

Si no queremos hacer esto cada vez que iniciemos sesión, podemos incluir este último comando al final del fichero .bashrc que se encuentra oculto en nuestro directorio personal.

Un uso muy común de las variables es almacenar datos introducidos por el usuario. Para poder introducir un dato a través de teclado de forma interactiva utilizamos la instrucción read seguido del nombre de variable que queramos leer:

echo "Introduce tu nombre:"
read NOMBRE
echo "Tu nombre es: $NOMBRE"

Para terminar con las variables de entorno puede ser importante conocer la existencia de ciertas variables predefinidas que nos ayudarán en nuestros scripts. Cuando invocamos un script con argumentos (palabras a la derecha del nombre del script en el momento de su invocación) estos pueden ser recuperados en el interior del script usando las variables predefinidas $1 para el primer argumento, $2 para el segundo , $3 para el tercero y así sucesivamente. Para conocer el número de argumento totales con los que ha sido invocado un script podemos usar la variable predefinida $#.

Este obra está bajo una licencia de Creative Commons Reconocimiento-NoComercial-CompartirIgual 4.0 Internacional.