Siempre que interactuamos con el shell estamos creando pequeños programas. Cuando a estos pequeños programas los guardamos en un archivo que pueda ejecutarse luego, lo llamamos un "script". Estos scripts sirven, entre otras cosas, para tareas de automatización.
Los scripts de shell son básicamente programas escritos en el lenguaje del shell, se parecen a los archivos .BAT del DOS. Aunque es cierto que, si se van a escribir más de varias decenas de líneas de script, es mejor recurrir a un lenguaje diferente del shell, pensar en que los scripts de shell son solamente pequeños programas sería cometer una injusticia con la flexibilidad y comodidad que ofrecen al usuario.
Normalmente los scripts de shell se crean cuando es necesario combinar en una única acción una tarea rutinaria.
Estos scripts pueden ser muy breves (una sola línea), o bastante largos (varias pantallas). Vamos a empezar con algunos ejemplos muy sencillos.
Creamos un archivo que contenga: who | wc -l, esto lo podemos hacer
utilizando el comando echo, con la salida standard a un archivo, o bien
utilizando el editor vi. El archivo lo llamaremos cuantos.
Para poder ejecutar este pequeño script, tenemos que utilizar el
intérprete del shell. Hay dos formas de hacerlo: sh cuantos,
invocará al sh para que interprete nuestro script y lo ejecute.
El archivo no lo podemos ejecutar directamente, porque al crearlo, lo hemos
creado como archivo de texto, y no tiene permisos de ejecución. Para que
podamos ejecutarlo tenemos que agregarle el permiso: chmod u+x cuantos.
Una vez que le hemos agregado el permiso, nuestro archivo ha pasado a ser un
ejecutable, y se lo puede invocar como a cualquier comando. La línea para
invocarlo será: ./cuantos.
Llama la atención el ./ que tenemos que agregar al principio para poder ejecutar el archivo. Esto simboliza al directorio actual. Lo que estamos haciendo es diciéndole al shell que busque el archivo "cuantos" en el directorio actual. Esto se debe a que el directorio actual no está en la lista de los directorios en los que el shell busca para encontrar un determinado comando.
Los directorios en los que el shell busca son /bin, /usr/bin y algunos otros. Están definidos en una variable llamada PATH.
Para poder ver el contenido de la variable PATH, podemos ejecutar
desde línea de comandos: echo $PATH.
Es importante recalcar que la variable se llama PATH, pero para
ver su contenido le agregamos el símbolo $ adelante, este símbolo es un
metacaracter de shell, como los vistos anteriormente, y le dice al shell que lo
que viene a continuación es una variable.
Así como PATH también existen muchas otras variables. Algunas determinadas por el sistema, y otras determinadas por nosotros.
Llamamos entorno al conjunto de variables, como
el PATH, el nombre de usuario,
el directorio actual, el directorio principal, las preferencias de lenguaje,
etc. que determinan a la consola que estamos utilizando en este momento.
Podemos ver cuales son las variables de nuestro entorno escribiendo:
set.
A estas variables de entorno, nosotros podemos agregar nuevas variables. Para
ello podemos escribir: variable=valor. Y haciendo
echo $variable podremos ver el valor que le asignamos a la variable.
Al ejecutar un programa, este programa recibe una copia de nuestro entorno, donde algunas variables pueden mantenerse (variables exportadas), y otras pueden no estar. Un programa puede modificar las variables que tiene en su entorno, pero no las del entorno anterior. A su vez, dentro de ese programa podemos ejecutar un nuevo programa, que tendrá su propio entorno, con sus propias variables.
Para hacer que los programas hereden las variables que nosotros definamos,
existe un comando llamado export, que nos asegura que los programas que
se ejecuten, reciban esa variable en su entorno.
Ejemplos
echo $variable. Este script, no
mostrará nada, ya que la variable no ha sido exportada todavía. Para que el
script muestre el valor de la variable, debemos ejecutar, en la línea de
comandos: export variable. Al ejecutar el script nuevamente veremos el
valor de la variable.
variable2=valor2;export variable2.
Ejecutar el script, y luego, desde la línea de comandos
echo variable2.
Esto no nos mostrará nada, ya que como dijimos antes, no se puede modificar el
entorno anterior.
cd /; echo $PWD; export PWD. Al
ejecutar el script, notar que por más que el echo nos haya mostrado que
el cd había logrado cambiar de directorio, al volver del script,
permanecemos en el directorio en el que estábamos al ejecutar el script.
Cuando ejecutamos un comando, puede suceder que necesite parámetros. En el caso de los scripts, los parámetros se encuentran en variables especiales que identificamos como $1, $2, $3, etc. El nombre de la variable nos indica la ubicación del parámetro.
Para ver esto en un script muy sencillo, armaremos un script que contenga la
línea echo $1, de forma que -al invocarlo- nos mostrará el
parámetro que le pasemos al ejecutarlo.
Para tener el caso de un script un poco más útil,
vamos a hacer un script que nos permitirá convertir rápidamente
en ejecutables a los próximos scripts que realicemos: chmod +x $1. Le
pondremos de nombre cx.
Para hacer ejecutable este script, vamos a aprovechar lo que ya escribimos y
haremos: sh cx cx.
Podemos mejorar este script, de tal manera que reciba más parámetros y
pueda hacer ejecutables más archivos a la vez. Podríamos escribir, por
ejemplo. chmod +x $1 $2 $3 ..., pero existe una manera más
elegante (y más eficiente): chmod +x $*. Al encontrar el $*, el
shell lo reemplazará por todos los parámetros que haya recibido el script.
Por último, veremos la utilidad de las comillas dobles ("), en su
relación con los parámetros. Usaremos un script que contenga la línea:
echo "Buen día $1". Al ejecutarlo con un parámetro (por ejemplo,
Pedro), la salida del comando será Buen día Pedro.
Si en el ejemplo anterior hubiéramos utilizado comillas simples, la salida
del comando hubiera sido Buen día $1, ya que dentro de las comillas
simples el metacaracter $ no es interpretado, mientras que dentro de
las comillas dobles si.