El Scripting Básico

Scripts Shell en Pocas Palabras

Un script shell es un archivo de comandos ejecutables que ha sido almacenado en un archivo
de texto. Cuando el archivo se ejecuta, se ejecuta cada comando. Los scripts shell tienen
acceso a todos los comandos del shell, incluyendo la lógica. Un script (o «secuencia de
comandos» en español), por lo tanto, puede detectar la presencia de un archivo o buscar una
salida particular y cambiar su comportamiento en consecuencia. Se pueden crear scripts para
automatizar partes repetitivas de tu trabajo, que ahorran tu tiempo y aseguran consistencia
cada vez que utilices el script. Por ejemplo, si ejecutas los mismos cinco comandos todos los
días, puedes convertirlos en un script shell que reduce tu trabajo a un comando.
Un script puede ser tan simple como un único comando:

echo “Hello, World!”

El script, test.sh, consta de una sola línea que imprime la cadena Hello, World! (o
«¡Hola, Mundo!» en español) en la consola.
Ejectutar un script puede hacerse, ya sea pasándolo como un argumento a tu shell o
ejecuándolo directamente:

sysadmin@localhost:~$ sh test.sh
Hello, World!
sysadmin@localhost:~$ ./test.sh
-bash: ./test.sh: Permission denied
sysadmin@localhost:~$ chmod +x ./test.sh
sysadmin@localhost:~$ ./test.sh
Hello, World!

En el ejemplo anterior, en primer lugar, el script se ejecuta como un argumento del shell. A
continuación, se ejecuta el script directamente desde el shell. Es raro tener el directorio actual
en la ruta de búsqueda binaria $PATH, por lo que el nombre viene con el prefijo ./ para
indicar que se debe ejecutar en el directorio actual.
El error Permission denied (o «Permiso denegado» en español) significa que el script no
ha sido marcado como ejecutable. Un comando chmod rápido después y el script funciona. El
comando chmod se utiliza para cambiar los permisos de un archivo, que se explica en detalle
en un capítulo posterior.
Hay varios shells con su propia sintaxis de lenguaje. Por lo tanto, los scripts más complicados
indicarán un shell determinado, especificando la ruta absoluta al intérprete como la primera
línea, con el prefijo #!, tal como lo muestra el siguiente ejemplo:

#!/bin/sh
echo “Hello, World!”

o
#!/bin/bash
echo “Hello, World!”

 
Los dos caracteres #! se llaman tradicionalmente el hash y el bang respectivamente, que
conduce a la forma abreviada «shebang» cuando se utilizan al principio de un script.
Por cierto, el shebang (o crunchbang) se utiliza para los scripts shell tradicionales y otros
lenguajes basados en texto como Perl, Ruby y Python. Cualquier archivo de texto marcado
como ejecutable se ejecutará bajo el intérprete especificado en la primera línea mientras se
ejecuta el script directamente. Si el script se invoca directamente como argumento a un
intérprete, como sh script o bash script, se utilizará el shell proporcionado,
independientemente de lo que está en la línea del shebang.
Ayuda sentirse cómodo utilizando un editor de texto antes de escribir los scripts shell, ya que
se necesitarás crear los archivos de texto simple. Las herramientas de oficina tradicionales
como LibreOffice, que dan salida a archivos que contienen la información de formato y otra
información, no son adecuadas para esta tarea.

Editar los Scripts Shell

UNIX tiene muchos editores de texto y las ventajas del uno sobre el otro se debaten muy a
menudo. Dos de ellos vienen mencionados específicamente en el programa del curso de los
aspectos esenciales de LPI: El editor de GNU nano es un editor muy sencillo y bien adaptado
para editar pequeños archivos de texto. El Visual Editor, vi, o su versión más reciente, VI
mejorado (vim), es un editor muy potente pero tiene un arduo proceso de aprendizaje.
Nosotros nos centraremos en el nano.
Introduce nano test.sh y verás una pantalla similar a esta:

GNU nano 2.2.6 File: test.sh modified

#!/bin/sh

echo "Hello, World!"

echo -n "the time is "
date

^G Get Help ^O WriteOut ^R Read File ^Y Prev Page ^K Cut Text ^C Cur P
o
^X Exit ^J Justify ^W Where Is ^V Next Page ^U UnCut Text^T To Sp
ell
El editor nano tiene algunas características que debes conocer. Simplemente escribes con tu
teclado, utiliza las flechas para moverte y el botón suprimir/retroceso para borrar texto. A lo
largo de la parte inferior de la pantalla puedes ver algunos comandos disponibles, que son
sensibles al contexto y cambian dependiendo de lo que estás haciendo. Si te encuentras
directamente en la máquina Linux, o sea no te conectas a través de la red, puedes utilizar el
ratón para mover el cursor y resaltar el texto.
Para familiarizarte con el editor, comienza a escribir un script shell sencillo dentro del
editor nano:

GNU nano 2.2.6 File: test.sh modified

#!/bin/sh

echo "Hello, World!"

echo -n "the time is "
date

^G Get Help ^O WriteOut ^R Read File ^Y Prev Page ^K Cut Text ^C Cur P
o
^X Exit ^J Justify ^W Where Is ^V Next Page ^U UnCut Text^T To Sp
ell

Ten en cuenta que la opción de la parte inferior izquierda es ^X Exit que significa
«presiona control y X para salir». Presione Ctrl con X y la parte inferior cambiará:

Save modified buffer (ANSWERING "No" WILL DESTROY CHANGES) ?

Y Yes
N No ^C Cancel

En este punto, puedes salir del programa sin guardar los cambios pulsando la tecla N o
guardar primero pulsando Y para guardar. El valor predeterminado es guardar el archivo con
el nombre de archivo actual. Puedes presionar la tecla Entrar para guardar y salir.
Después de guardar regresarás al shell prompt. Regresa al editor. Esta vez
pulsa Ctrl y O para guardar tu trabajo sin salir del editor. Los prompts son iguales en gran
parte, salvo que estás de nuevo en el editor.
Esta vez utiliza las teclas de la flecha para mover el cursor a la línea que contiene el texto
«The time is» (o «La hora es» en español). Presiona Control y K dos veces para cortar las
dos últimas líneas al búfer de copia. Mueve el cursor a la línea restante y
presiona Control y U una vez para pegar el búfer de copia a la posición actual. Esto hace que
el script muestre la hora actual antes de saludarte y te ahorra tener que volver a escribir las
líneas.
Otros comandos útiles que puedas necesitar son:

Comando Descripción

Ctrl + W buscar en el documento

Ctrl + W, buscar y reemplazar

luego Control + R

Ctrl + G mostrar todos los comandos posibles

Ctrl + Y/V página hacia arriba / abajo

Ctrl + C mostrar la posición actual en el archivo y el tamaño del

archivo

El Scripting Básico
Anteriormente en este capítulo tuviste tu primera experiencia de scripting y recibiste una
introducción a un script muy básico que ejecuta un comando simple. El script comenzó con la
línea shebang, que le dice al Linux que tiene que utilizar el /bin/bash (lo que es Bash) para
ejecutar un script.
Aparte de ejecutar comandos, hay 3 temas que debes conocer:

 Las variables, que contienen información temporal en el script

  Las condicionales, que te dejan hacer varias cosas basadas en las pruebas
que vas introduciendo
 Los Loops, que te permiten hacer lo mismo una y otra vez

Las Variables
Las variables son una parte esencial de cualquier lenguaje de programación. A continuación
se muestra un uso muy simple de las variables:

#!/bin/bash

ANIMAL="penguin"
echo "My favorite animal is a $ANIMAL"
Después de la línea shebang está una directiva para asignar un texto a una variable. El
nombre de la variable es ANIMAL y el signo de igual asigna la cadena penguin (o «pingüino»
en español). Piensa en una variable como una caja en la que puedes almacenar cosas.
Después de ejecutar esta línea, la caja llamada ANIMAL contiene la palabra penguin.
Es importante que no haya ningún espacio entre el nombre de la variable, el signo de igual y el
elemento que se asignará a la variable. Si le pones espacio, obtendrás un error como
«command not found». No es necesario poner la variable en mayúsculas pero es una
convención útil para separar las variables de los comandos que se ejecutarán.
A continuación, el script despliega una cadena en la consola. La cadena contiene el nombre
de la variable precedido por un signo de dólar. Cuando el intérprete ve el signo de dólar
reconoce que va a sustituir el contenido de la variable, lo que se llama interpolación. La salida
del script es My favorite animal is a penguin (o «My animal favorito es un pingüino»
en español.)
Así que recuerda esto: Para asignar una variable, usa el nombre de la variable. Para acceder
al contenido de la variable, pon el prefijo del signo de dólar. ¡A continuación, vamos a mostrar
una variable a la que se asigna el contenido de otra variable!

#!/bin/bash
ANIMAL=penguin
SOMETHING=$ANIMAL
echo "My favorite animal is a $SOMETHING"

ANIMAL contiene la cadena penguin (como no hay espacios, se muestra la sintaxis

alternativa sin usar las comillas). A SOMETHING se le asigna el contenido de ANIMAL (porque
a la variable ANIMAL le procede el signo de dólar).
Si quieres, puedes asignar una cadena interpolada a una variable. Esto es bastante común en
las grandes secuencias de comandos, ya que puedes construir un comando más grande y
ejecutarlo!
Otra forma de asignar una variable es utilizar la salida de otro comando como el contenido de
la variable incluyendo el comando entre los comillas invertidas:

#!/bin/bash
CURRENT_DIRECTORY=`pwd`
echo "You are in $CURRENT_DIRECTORY"

Este patrón a menudo se utiliza para procesar texto. Puedes tomar el texto de una variable o
un archivo de entrada y pasarlo por otro comando como sed o awk para extraer ciertas partes
y guardar el resultado en una variable.
Es posible obtener entradas del usuario de su script y asignarlo a una variable mediante el
comando read (o «leer» en español):

#!/bin/bash

echo -n "What is your name? "

read NAME
echo "Hello $NAME!"

El comando read puede aceptar una cadena directo desde el teclado o como parte de la
redirección de comandos tal como aprendiste en el capítulo anterior.
Hay algunas variables especiales además de las establecidas. Puedes pasar argumentos a tu
script:

#!/bin/bash
echo "Hello $1"

El signo de dólar seguido de un número N corresponde al argumento Nth pasado al script. Si

invocas al ejemplo anterior con ./test.sh el resultado será Hola Linux. La
variable $0 contiene el nombre del script.
Después de que un programa se ejecuta, ya sea un binario o un script, devuelve el exit code
(o «código de salida» en español) que es un número entero entre 0 y 255. Puedes probarlo
con la variable $? para ver si el comando anterior se ha completado con éxito.

sysadmin@localhost:~$ grep -q root /etc/passwd

sysadmin@localhost:~$ echo $?
0
sysadmin@localhost:~$ grep -q slartibartfast /etc/passwd
sysadmin@localhost:~$ echo $?
1

Se utilizó el comando grep para buscar una cadena dentro de un archivo con el indicador -q,
que significa «silencioso» (o «quiet» en inglés). El grep, mientras se ejecuta en modo
silencioso, devuelve 0, si la cadena se encontró y 1 en el caso contrario. Esta información
puede utilizarse en un condicional para realizar una acción basada en la salida de otro
comando.
Además puedes establecer el código de salida de tu propio script con el comando exit:

#!/bin/bash
# Something bad happened!
exit 1

El ejemplo anterior muestra un comentario #. Todo lo que viene después de la etiqueta hash
se ignora, se puede utilizar para ayudar al programador a dejar notas. El comando exit
1 devuelve el código de salida 1 al invocador. Esto funciona incluso en el shell. Si ejecutas
este script desde la línea de comandos y luego introduces echo $?, verás que devolverá 1.
Por convención, un código de salida de 0 significa «todo está bien». Cualquier código de
salida mayor que 0 significa que ocurrió algún tipo de error, que es específico para el
programa. Viste que grep utiliza 1 lo que significa que la cadena no se encontró.
Condicionales
Ahora que puedes ver y definir las variables, es hora de hacer que tus propios scripts tengan
diferentes funciones basadas en pruebas, llamado branching (o «ramificación» español). La
instrucción if (o «si» en español) es el operador básico para implementar un branching.
La instrucción if se ve así:

if somecommand; then
# do this if somecommand has an exit code of 0
fi

El siguiente ejemplo ejecutará «somecommand» (en realidad, todo hasta el punto y coma) y si
el código de salida es 0, entonces se ejecutará el contenido hasta el cierre fi. Usando lo que
sabes acerca del grep, ahora puedes escribir un script que hace cosas diferentes, basadas en
la presencia de una cadena en el archivo de contraseñas:

#!/bin/bash

if grep -q root /etc/passwd; then

echo root is in the password file
else
echo root is missing from the password file
fi

De los ejemplos anteriores podrías recordar que el código de salida del grep es 0 si se
encuentra la cadena. El ejemplo anterior utiliza esto en una línea para imprimir un mensaje
si root está en el archivo passwd, u otro mensaje si no es así. La diferencia aquí es que en
lugar de un fi para cerrar, el bloque if, hay un else. Esto te permite realizar una acción si la
condición es verdadera, y otra si la condición es falsa. El bloque else siempre debe cerrarse
con la palabra clave fi.
Otras tareas comunes son buscar la presencia de un archivo o directorio y comparar cadenas
y números. Podrías iniciar un archivo de registro si no existe, o comparar el número de líneas
en un archivo con la última vez que se ejecutó. El comando if es claramente de ayuda aquí,
pero ¿qué comando debes usar para hacer la comparación?
El comando test te da un acceso fácil los operadores de prueba de comparación y archivos.
Por ejemplo:

Comando Descripción

test –f 0 si el archivo existe

/dev/ttyS0
Comando Descripción

test ! –f 0 si el archivo no existe

/dev/ttyS0

test –d /tmp 0 si el directorio existe

test –x `which sustituir la ubicación de ls y luego (probar) test, si el usuario

ls`
puede ejecutar

test 1 –eq 1 0 si tiene éxito la comparación numérica

test ! 1 –eq 1 NO – 0 si la comparación falla

test 1 –ne 1 Más fácil, ejecutar test (probar) si hay desigualdad numérica

test “a” = “a” 0 si tiene éxito la comparación de cadenas

test “a” != “a” 0 si las cadenas son diferentes

test 1 –eq 1 –o 2 -o es OR: cualquiera de las opciones pueden ser igual

–eq 2

test 1 –eq 1 –a 2 -a es AND: ambas comparaciones deben ser iguales

–eq 2

Es importante tener en cuenta que el test ve las comparaciones de números enteros y

cadenas de manera distinta. 01 y 1 son iguales por comparación numérica, pero no para
comparación de cadenas o strings. Siempre debes tener cuidado y recordar qué tipo de
entrada esperas.
Hay muchas más pruebas, como –gt para mayor que, formas de comprobar si un archivo es
más reciente que los otros y muchos más. Para más información consulta la página test man.
La salida de test es bastante largo para un comando que se usa con tanta frecuencia, por lo
que tiene un alias llamado [ (corchete cuadrado izquierdo). Si incluyes tus condiciones en
corchetes, es lo mismo que si ejecutaras el test. Por lo tanto, estas instrucciones son
idénticas.
if test –f /tmp/foo; then
if [ -f /tmp/foo]; then

Mientras que la última forma es de uso más frecuente, es importante entender que el corchete
es un comando en sí que funciona de manera semejante al test excepto que requiere el
corchete cuadrado de cierre.
La instrucción if tiene una forma final que te permite hacer varias comparaciones al mismo
tiempo usando elif (abreviatura de elseif).

#!/bin/bash

if [ "$1" = "hello" ]; then

echo "hello yourself"
elif [ "$1" = "goodbye" ]; then
echo "nice to have met you"
echo "I hope to see you again"
else
echo "I didn't understand that"
fi

El código anterior compara el primer argumento pasado al script. Si es hello, se ejecuta el

primer bloque. Si no es así, el script de comandos comprueba si es goodbye e invoca con el
comando echo con un diferente mensaje entonces. De lo contrario, se envía un tercer
mensaje. Ten en cuenta que la variable $1 viene entre comillas y se utiliza el operador de
comparación de cadenas en lugar de la versión numérica (-eq).
Las pruebas if/elif/else pueden ser bastante detalladas y complicadas. La
instrucción case proporciona una forma distinta de hacer las pruebas múltiples más fáciles.

#!/bin/bash

case "$1" in
hello|hi)
echo "hello yourself"
;;
goodbye)
echo "nice to have met you"
echo "I hope to see you again"
;;
*)
 echo "I didn't understand that"
esac

La instrucción case comienza con la descripción de la expresión que se analiza: case

EXPRESSION in. La expresión aquí es $1 entre comillas.
A continuación, cada conjunto de pruebas se ejecutan como una coincidencia de patrón
terminada por un paréntesis de cierre. El ejemplo anterior primero busca hello o hi;
múltiples opciones son separadas por la barra vertical | que es un operador OR en muchos
lenguajes de programación. Después de esto, se ejecutan los comandos si el patrón devuelve
verdadero y se terminan con dos signos de punto y coma. El patrón se repite.
El patrón * es igual a else, ya que coincide con cualquier cosa. El comportamiento de la
instrucción case es similar a la instrucción if/elif/else en que el proceso se detiene tras
la primera coincidencia. Si ninguna de las otras opciones coincide, el patrón * asegurá que
coincida con la última.
Con una sólida comprensión de las condicionales puedes hacer que tus scripts tomen acción
sólo si es necesario.

Los Loops
Los loops (o «ciclos o bucles» en español) permiten que un código se ejecute repetidas veces.
Pueden ser útiles en numerosas situaciones, como cuando quieres ejecutar los mismos
comandos sobre cada archivo en un directorio, o repetir alguna acción 100 veces. Hay dos
loops principales en los scripts del shell: el loop for y el loop while.
Los loops for se utilizan cuando tienes una colección finita que quieres repetir, como una lista
de archivos o una lista de nombres de servidor:

#!/bin/bash

SERVERS="servera serverb serverc"

for S in $SERVERS; do
echo "Doing something to $S"
done

Primero, el script establece una variable que contiene una lista de nombres de servidor
separada por espacios. La instrucción for entonces cicla (realiza «loops») sobre la lista de los
servidores, cada vez que establece la variable Scon el nombre del servidor actual. La elección
de la S es arbitraria, pero ten en cuenta que la S no tiene un signo de dólar, pero en
el $SERVERS sí lo tiene, lo que muestra que se $SERVERS se extenderá a la lista de
servidores. La lista no tiene que ser una variable. Este ejemplo muestra dos formas más para
pasar una lista.

#!/bin/bash
for NAME in Sean Jon Isaac David; do
echo "Hello $NAME"
done

for S in *; do
echo "Doing something to $S"
done

El primer loop es funcionalmente el mismo que en el ejemplo anterior, excepto que la lista se
pasa directamente al loop for en lugar de usar una variable. Usar una variable ayuda a que el
script sea más claro, ya que una persona fácilmente puede realizar cambios en la variable en
lugar de ver el loop.
El segundo loop utiliza comodín * que es un file glob. El shell expande eso a todos los
archivos en el directorio actual.
El otro tipo de loop, un loop while, opera en una lista de tamaño desconocido. Su trabajo es
seguir ejecutándose y en cada iteración realizar un test para ver si se tiene que ejecutar otra
vez. Lo puedes ver como «mientras que una condición es verdadera, haz cosas».

#!/bin/bash
i=0
while [ $i -lt 10 ]; do
echo $i
i=$(( $i + 1))
done
echo "Done counting"

El ejemplo anterior muestra un loop while que cuenta de 0 a 9. Un contador de variables, i,

arranca en 0. Luego, un loop while se ejecuta con un testsiendo «is $i less than 10?» (o
«¿es $i menor que 10?») ¡Ten en cuenta que el loop while utiliza la misma notación que la
instrucción if.
Dentro del loop while el valor actual de i es mostrado en pantalla, y luego se le añade 1 a
través del comando $((aritmética)) y se asigna de regreso al i. Una vez que i llega a
10, la instrucción while regresa falso y el proceso continuará después del loop.