The Inside Out

Reduciendo el tipeo de comandos: uso de áliases y de scripts

En todos los tutoriales hemos hablado de comandos de consola, comandos que muchas veces son bastante largos de tipear y recordar, especialmente si empezamos a agregar opciones a cada uno. Para solucionar esto, lo más efectivo es el uso de áliases o scripts. Un alias (plural áliases, creemos) es un "acceso directo" de consola. Se definen en un archivo determinado, y al escribirlos reemplazan su nombre por el comando especificado. Un script es un archivo ejecutable, escrito en lenguaje de shell (Bash es también, además de un shell, un lenguaje en el que programar), que contiene comandos y estructuras. Los scripts pueden ser tan simples como una sucesión de comandos, o tan complejos como se quiera. Veremos primero los aliases para dar una introducción.

Aliases de shell

La manera más simple de crear un alias (y la más inútil) es usar el comando alias:

alias list="ls -la"

hace que, desde ese momento, ejecutar list nos devuelva el resultado de ls -la. Desgraciadamente, apenas cierre su terminal el alias se perderá. Esto puede servir para testear un alias rápidamente, sin hacer cambios "definitivos". Para hacer esto permanente, tendrá que editar su archivo de preferencias del shell, ~/.bashrc.

Como lo mejor es siempre la práctica, vamos a crear un alias y ver qué podemos hacer con él. Abra con un editor de texto el archivo .bashrc de su directorio personal (/home/su_usuario/, por si no lo recuerda) y baje hasta la última línea. Este archivo en nuestro caso se ve de la siguiente manera, y contiene, como podrá ver, varios áliases:

# .bashrc

# User specific aliases and functions

alias daleclick="/usr/sbin/pppd call daleclick"
alias desconecta="killall pppd"
alias claws="/usr/local/bin/athlon-sylpheed"

# Source global definitions

if [ -f /etc/bashrc ]; then
	. /etc/bashrc
fi

Como ve, para crear un alias se debe escribir alias nombre="comando" o alias nombre='comando'. El uso de comillas simples o dobles depende de si en el comando debe usar comillas dobles o simples respectivamente (para decirlo de manera simple, consulte info bash para más datos sobre los áliases)

En este ejemplo, crearemos un alias para poder abrir rápidamente una consola aterm con Midnight Commander desde otra. Esto requiere, obviamente, que haya instalado los paquetes aterm y mc. Además, deberá estar corriendo un administrador de ventanas para usar el alias.

El comando entonces será alias consola="/usr/bin/aterm -tr -trsb -sh 40 -fg grey -e '/usr/bin/mc'"
Después de guardar el archivo, simplemente ejecute el comando bash para cargar las actualizaciones que acaba de hacer. Ahora puede ejecutar el alias consola.

Scripts de Bash

En principio, un script de shell puede hacer el mismo trabajo de un alias: simplemente cree en su directorio personal un subdirectorio llamdo bin, y en él guarde, por ejemplo, el archivo siguiente:

#!/bin/bash
/usr/bin/aterm -tr -trsb -sh 40 -fg grey -e '/usr/bin/mc'

llame al archivo consola.bash y ejecute el comando chmod -766 consola.bash (esto suponiendo que se encuentre en el directorio bin, de otro modo, escriba la ruta al archivo). Ahora podrá ejecutar el comando consola del mismo modo que si fuese un alias.

Por supuesto, usar scripts sólo como accesos directos es perderse el 99% de sus posibilidades. Para aprovechar realmente la capacidad del shell debería aprender a programar en él, consultando el manual y algún sitio sobre programación para principiantes. BASH permite el uso y creación de variables de distintos tipos, dispone de lazos y condicionales, y en resumen es un buen acercamiento a la programación. Digamos que aprender BASH u otro de los numerosos shells disponibles es lo que debe hacer para avanszar en GNU/Linux después de aprender a escribir código HTML a mano.

Para no dejarlo con las ganas (un tutorial de programación completo está más allá del alcance de este tutorial) veremos algunos scripts simples.

Scripting básico

Cree con un editor de texto un archivo llamado script1.sh. La extensión .sh no es necesaria, pero ayuda a ver que el archivo es un script de shell. Guarde el archivo en el directorio /home/su_usuario/bin/ (si el directorio no existe, créelo). Ahora escriba en él lo siguiente:

#!/bin/bash
echo "Adiós, Mundo!"
exit

Cierre el archivo y ejecute el siguiente comando:

chmod 0755 ~/bin/script1.sh

Eso cambia los permisos del archivo y lo hace ejecutable por el dueño (su usuario). Ahora ejecútelo simplemente escribiendo script1.sh en la línea de comandos. Verá lo siguiente:

[rogelio@Edhellond bin]$ script1.sh 
Adios, Mundo!
[rogelio@Edhellond bin]$

Paremos ahora un momento. Veamos los pasos a cumplir para tener un script funcionante:

1. Escribir el archivo con un editor de textos y guardarlo (preferentemente en un directorio de ejecutables, como /usr/local/bin/, o ~/bin/
2. Cambiar los permisos del script a ejecutable con chmod 0755 script
3. Correr el programa
4. Corregirlo si hace falta (no hay que repetir todos los pasos) y volver a correrlo

En realidad, la única diferencia si no guarda el archivo en un directorio de ejecutables (uno que esté en su path) es que deberá escribir la ruta completa al archivo para ejecutarlo. Es por eso que todos los scripts configure de los paquetes para compilar deben ejecutarse con ./configure: le estamos diciendo al shell "ejecutá el archivo que está en este directorio, no otro".

Ahora que sabemos a grandes rasgos cómo crear un script "por fuera", veamos lo que debe contener.

La primera línea del script que hemos visto es #!/bin/bash, y le dice al shell que el script debe interpretarse con el ejecutable /bin/bash por más que el shell usado sea otro (hay al menos otros 6 shells bastante populares, entre ellos ksh, ash y el propio sh). Recuerde agregar esa línea en sus scripts.

Debajo de esa línea, vemos un comando, echo. El comando echo repite en la pantalla (o en otro destino si es redireccionado) lo que lleva como argumento. En este caso, el script escribe "Adios, Mundo!", y termina (eso hace el comando exit). Note que, por ahora, nos abstuvimos de usar acentos o símbolos como ¡ que no forman parte del código ASCII simple de caracteres. Pruebe en su shell si el usar acentos no es problema.

Veamos ahora algo más interesante. El siguiente script le pregunta su nombre, lo escribe con un saludo y escribe la fecha y hora:

#!/bin/bash
# Creamos dos variables a usar más tarde.
Fecha=`date +%A`
Hora=`date +%T`
# Ahora empezamos a usar comandos.
echo "¡Hola!"
echo "¿Cuál es su nombre?"
echo "Por favor escríbalo y presione Enter"
read Nombre
# Aquí usamos las variables obtenidas
echo "¡Hola $Nombre,"
echo "es $Fecha y son las $Hora."
echo "Bienvenido a $HOSTNAME!"
exit

Veamos un poco. Para empezar, aparte de la primera línea, cualquier otra que empiece con un numeral (#) es un comentario. Los comentarios no son interpretados por el shell, sirven para que usted sepa lo que el script está haciendo.
Luego de los comentarios, vemos dos variables, llamadas Fecha y Hora. Es importante que escriba las líneas sin dejar espacios: Fecha = `date +%A` no funcionará. Así mismo, debe escribir los comandos a interpretar entre acentos graves. Hay tres símbolos importantes: las comillas ", los apóstrofes o comillas simples ' y los acentos graves `. Cada uno sirve para propósitos distintos: los acentos marcan que lo que contienen debe ejecutarse y el resultado tomarse como valor.
Además, vemos el comando read, que sirve para tomar texto de la pantalla (entre otras cosas). Aquí, usamos la variable Nombre para guardar lo que escribimos a read.
Al final, usamos un echo para unir todo. Note cómo usamos las variables: para usar el valor que una variable contiene, la escribimos con un signo $ delante. La variable $HOSTNAME es una variable de sistema que contiene el nombre que su PC recibe, y por eso no debimos crearla al principio del script.
El resultado de ejecutar el script es el que sigue:

[rogelio@Edhellond bin]$ script2.sh 
¡Hola!
¿Cuál es su nombre? Por favor 
escríbalo y presione Enter
Rogelio Feliz
¡Hola Rogelio Feliz,
es miércoles y son las 16:36:21.
Bienvenido a Edhellond.TierraMedia.Arda!
[rogelio@Edhellond bin]$

Uso de scripts de limpieza

Con lo que hemos explicado, y algún conocimiento de comandos extra, ya puede empezar a hacer scripts simples de mantenimiento. Por ejemplo, podríamos hacer un script que borre los archivos terminados en tilde (archivos de respaldo creados por editores de texto) en el directorio actual y sus subdirectorios:

#!/bin/bash 
echo "Este script borra todo archivo de respaldo
echo "del directorio actual y sus subdirectorios,"
echo "pidiéndole confirmación."
# Podríamos quitar la opción -i,
# pero es algo peligroso para el primer intento.
# Cuando note que funciona bien, puede eliminar 
# la confirmación de borrado.
rm ~/*~ -riv
rm ./.*~ -riv
echo "Operación terminada"
exit

Y el resultado de ejecutar script3.sh (sí, es un nombre inspirado) es:

[rogelio@Edhellond rogelio]$ script3.sh
Este script borra todos los archivos de respaldo
del directorio actual y sus subdirectorios,
pidiéndole confirmación.
rm: no se puede efectuar `lstat' sobre `./*~': No such file or directory
rm: ¿borrar el fichero regular `./.xinitrc~'? (s/n) s
`./.xinitrc~' borrado
Operación terminada
[rogelio@Edhellond rogelio]

Note que nos avisa que no existen archivos de respaldo "normales" en el directorio. Después, la segunda pasada borra los archivos ocultos de respaldo. Por supuesto, hay maneras bastante más eficientes de hacer esto, pero se las dejamos "como ejercicio".

Sabemos que esto no es más que la punta del iceberg. Esperamos que las posibilidades que le dejamos ver le den la curiosidad para aprender más. En la web debería poder encontrar montones de recursos sobre creación de scripts, empezando por manuales de uso de Linux, y llegando a tomos dedicados exclusivamente al shell.