Shell script

4. Programación shell
Ahora que sabemos manejarnos con el shell y conocemos unos pocos comandos, vamos a comenzar
a hacer pequeños programas que interpretará el shell.
En esta parte necesitaremos un editor de texto plano, como pueden ser: vi, emacs, joe, mcedit, nano,
kwrite, gedit, etc. Cualquiera de ellos vale, siempre que guardemos el texto como text/plain.
4.1. Mira mamá, soy un script!
Vamos a crear un fichero, script.sh, con el siguiente contenido:
#!/bin/sh
echo Mira mamá, soy un script!
Intentamos ejecutarlo con ./script.sh y no funciona. Esto es porque la extensión sh no es lo que
hace que sea ejecutable. Para que se pueda ejecutar tenemos que darle permisos de ejecución:
$ chmod +x script.sh
Ahora sí es ejecutable.
El programa consta de dos lineas:
• Un comentario, desde la aparición de # hasta el final de esa linea, donde se indica al shell
con la secuencia #!/bin/sh que /bin/sh es el programa que se debe usar para ejecutar este
fichero.
• Un comando que muestra un texto en stdin. Es la primera linea "ejecutable", ya que los
comentarios son ignorados por el intérprete.
4.2. Variables
Una variable es un contenedor. Consta de un identificador que la distingue de otra (su nombre) y de
un contenido. La relación entre variable y contenido es de equivalencia.
Por lo general las variables en shell no tienen tipos asociados y se definen de la siguiente forma:
identificador = contenido
Ejemplos:
# i vale 1
i=1
# I vale echo
I=echo
# msg vale Hola mundo!
msg="Hola mundo!"
Cuidado: si dejamos espacios entre el = y el identificador o el valor el shell creerá que son
comandos a ejecutar y no la asignación de una variable.
Para acceder al contenido de una variable empleamos $ delante de su identificador:
$identificador

Ejemplos:
$ i=1 ; echo $i
$ msg="Mola mundo!" ; echo $msg
$ fu=echo; $fu goo!
Cuando empleamos $identificador el shell busca el valor almacenado en la variable asociada a ese
identificador y lo utiliza para reemplazar esa ocurrencia de $identificador.
4.3. Linea de comandos
Cuando se ejecuta nuestro programa en shell hay una serie de variables que siempre estarán
disponibles, entre ellas las que nos permiten acceder a los distintos argumentos con los que fue
ejecutado nuestro script.
$0
contiene el nombre nombre de nuestro script
$#
el número de parámetros con los que se ha invocado al shell
$n
los parámetros, con n de 1 a 9 (a $#)
$$
el PID de nuestro proceso
$*
todos los parámetros menos $0
4.4. La salida de los programas
Cuando se ejecuta un programa, un comando UNIX es un programa, podemos, a parte de redirigir
su entrada y su salida, recoger el resultado de su ejecución y su salida.
El resultado es un valor numérico, por lo general cero si todo ha ido bien, y distinto de cero si ha
habido alguna clase de error.
La salida del programa es lo que obtendríamos en stdin y stdout.
$?
resultado del último programa ejecutado
Ejemplo:
$ ls pirulotropical 2> /dev/null ; echo $?
$ ls > /dev/null ; echo $?
$(comando)
la salida de comando (esto es equivalente al uso de comillas invertidas, pero por
simplicidad vamos a utilizar esta versión)
Ejemplo:
$ salida_ls=$(ls) ; echo $salida_ls

exit ENTERO
termina nuestro programa con el valor de salida ENTERO
Ejercicio 1: realizar un script que dado un directorio, cree un archivo tar comprimido con gzip y con
nombre igual a la fecha en formato yyyy-mm-dd seguido del nombre del directorio acabado en
.tar.gz. Ejemplo: aplicado sobre tmp obtendríamos -> 2004-04-03tmp.tar.gz.
4.5. Operaciones aritméticas
Para que el shell evalue una operación aritmética y no la tome como argumentos de un comando,
por ejemplo:
$ echo 1+1
Si queremos que sustituya la operación por su valor emplearemos:
$((expresión))
evalua la expresión aritmética y reemplaza el bloque por el resultado
Ejemplo:
$ echo $((1+1))
Algunos operadores aritméticos soportados:
+ suma
* mutiplicación
- resta
/ división entera
% resto de la división entera
( ) agrupar operaciones
Ejercicio 2: realizar un script que dado un número 'n' muestre los diez primeros elementos de su
tabla de multiplicar, mostrando el resultado en la forma: i x n = resultado.
4.6. Condicionales
Existe un comando para evaluar condiciones, y que nos permitirá que nuestros programas "tomen
decisiones":
test expresion
[ expresion ]
Este comando evalua expresion, y si evalua a cierto, devuelve cero (true), o en otro caso 1 (false).
Si no hay expresión, test siempre devuelve falso. Este comportamiento puede ser algo confuso, ya
en lógica los valores cierto y falso suelen ser al contrario.
test soporta gran cantidad de operadores, algunos son:
-d fichero
cierto si fichero existe y es un directorio
-e fichero
cierto si fichero existe, independientemente del tipo que sea
-f fichero
cierto si fichero existe y es un fichero normal
-r fichero
cierto si fichero existe y se puede leer
-s fichero

cierto si fichero existe y tiene tamaño mayor que cero
-w fichero
cierto si fichero existe y es se puede escribir sobre él
-x fichero
cierto si fichero existe y es ejecutable
n1 -eq n2
cierto si los enteros n1 y n2 son iguales
n1 -ne n2
cierto si los enteros n1 y n2 no son iguales
n1 -gt n2
cierto si el enteros n1 es mayor que n2
n1 -ge n2
cierto si los enteros n1 y n2 son iguales o n1 es mayor
que n2
n1 -lt n2
cierto si el enteros n1 es menor que n2
n1 -le n2
cierto si los enteros n1 y n2 son iguales o n1 es menor
que n2
s1 = s2
cierto si las cadenas de texto s1 y s2 son idénticas
s1 != s2
cierto si las cadenas de texto s1 y s2 no son idénticas
s1 < s2
cierto si la cadena de texto s1 es menor que s2
s1 > s2
cierto si la cadena de texto s1 es mayor que s2
-n cadena
cierto si la longitud de la cadena de texto es distinta de cero
! expresion
cierto si expresion es falsa (negación)
expresion1 -a expresion2
cierto si expresion1 y expresion2 son ciertas
expresion1 -o expresion2
cierto si expresion1 o expresion2 son ciertas
Además existen los operadores lógicos && (AND, multiplicación lógica) y || (OR, suma lógica),
que se puede aplicar al valor de salida de los programas:
$ true && true ; echo $?
$ true && false ; echo $?
$ false && true ; echo $?
$ false && false ; echo $?
$ true || true ; echo $?
$ true || false ; echo $?
$ false || true ; echo $?
$ false || false ; echo $?
El sistema de evaluación del shell es perezoso y va de izquierda a derecha. Si se encuentra la suma
lógica true || ALGO, ALGO no se evaluará porque se asume que cierto o falso o cierto o cierto
siempre es cierto (toma ya).
4.6.1. if ... then ... [ else ... ]
Esta es la principal estructura que nos permitirá ejecutar un bloque de código, o (alternativamente)

otro, dependiendo de como se evalue una condición.
if CONDICION; then
bloque de comandos
fi
if CONDICION; then
bloque de comandos b1
else
fi
En el primer caso el bloque de comandos se ejecutará solo si la condición es evaluada a cierto. En el
segundo caso el bloque b1 se ejecutará si la condición es evaluada a cierto, y sino se ejecutará el
bloque b2.
La condición puede ser, por ejemplo, una llamada al comando test o una operación lógica entre los
valores de salida de diferentes comandos.
read linea
# comparamos cadenas de texto, así que usamos comillas
if [ "$linea" = "secreto" ]; then
echo bingo!
fi
if ! $(ping -c 1 192.168.0.100 > /dev/null); then
echo La máquina 192.168.0.100 no responde
else
echo La máquina 192.168.0.100 está ahí!
fi
Ejercicio 3: realizar un script que, dado un número, indique si es o no divisible entre 101. Si no se
proporciona un número debe mostrar como usar el programa.
4.7. Bucles
El shell aporta mecanismos para realizar tareas repetitivas mediante el empleo de estructuras que
permiten repetir un bloque de comandos.
4.7.1. for ... in ...
Esta estructura permite repetir un bloque de comandos asignando valores de una serie a una variable
en cada iteración.
for VARIABLE in SERIE; do
bloque de comandos
done
En cada iteración la variable VARIABLE toma un valor de SERIE, que en caso de no contener
elementos hará que no se ejecute nada y se devuelva un valor 0. En caso de que se ejecuten
comandos, el resultado devuelto tras el bucle es el del último comando ejecutado.
Ejemplos de bucle:
# equivalente a seq 1 5
for i in 1 2 3 4 5; do
echo $i
done

# lo mismo pero con palabras
for palabra in uno dos tres cuatro cinco; do
echo $palabra
done
Ejercicio 4: realizar un script que dado un número 'n' muestre los diez primeros elementos de su
tabla de multiplicar, mostrando el resultado en la forma: i x n = resultado. Emplear un bucle y seq
(si está disponible). Si no se proporciona un número, mostrar como se usa el programa.
Ejercicio 5: realizar un script que dado una lista de directorios, cree un archivo tar comprimido con
gzip con nombre igual a la fecha en formato yyyy-mm-dd.tar.gz. Además se generará un fichero
yyyy-mm-dd.lst con los nombres de los directorios contenidos en el archivo tar, UNO POR LINEA
usando un bucle. Si el fichero lst existe, mostrar un error y terminar el programa. Si alguno de los
elementos no es un directorio, mostrar un error y finalizar el programa.
4.7.2. Rompiendo un bucle: break
En cualquier momento un bucle puede ser interrumpido mediante el uso de break, de forma que
tras ser ejecutado ese comando el control pasa al siguiente comando después del done.
Ejemplo de uso de break:
for elemento in *; do
echo Primer elemento $elemento
break
echo Esto nunca se llega a ejecutar
done
echo Seguimos con el programa
4.7.3. while ...
Se trata de otra estructura de bucle que permite ejecutar un bloque de comandos mientras se evalue
una condición a cierto:
while CONDICION; do
bloque de comandos
done
Cada iteración se evalua la condición y en el momento que no sea cierta, el bucle termina.
Ejemplos de bucles:
i=1
while [ $i -lt 6 ]; do
echo $i
i=$(($i+1))
done
# lee de stdin hasta que se introduzca 'quit'
read linea
while [ "$linea" != "quit" ]; do
read linea
done

Ejercicio 6: realizar un script que permita adivinar al usuario cual es su PID. El script pide un
número al usuario y cada vez que lo haga debe indicar al usuario si el PID es mayor o menor que el
número introducido. Cuando se adivina el valor, se deben mostrar los intentos empleados.
Introducción a la creación de shell scripts con bash
Una de las cosas con la que trabajamos mucho los administradores linux es la programación de shell
scripts, dado que éstos nos dan la posibilidad de preparar tareas que simplifican nuestro trabajo
diario.
Veamos a continuación un pequeño guión introductorio sobre programación de shell scripts.
Para escribir un shell script necesitamos un editor de texto plano, como por ejemplo: nano o gedit.
En realidad nos vale cualquier editor de texto, siempre y cuando el archivo lo guardemos como
text/plain.
1. Cómo se crea un script
Vamos a crear un fichero al que llamaremos script.sh. Para ello, abrimos nano, gedit o cualquier
otro editor de texto y escribimos:
#!/bin/sh
echo Este es mi primer script en bash!
Podemos ejecutarlo haciendo una llamada al shell y pasando como parámetro el nombre del script:
$ sh script.sh
También podemos hacerlo ejecutable dándole permisos de ejecución:
$ chmod +x script.sh
Una vez añadido el permiso de ejecución, ya podemos ejecutarlo directamente:
$ ./script.sh
Pero si lo que queremos es poder llamarlo desde cualquier lugar, lo copiaremos a un directorio de
ficheros ejecutables, como por ejemplo: /usr/bin o /usr/local/bin.
Si observamos el código fuente de nuestro pequeño script, veremos que consta de dos líneas:
• En la primera se indica el shell que se va a usar como intérprete para este script: #!/bin/sh.
Esta siempre debe ser la primera línea de un shell script.
• La segunda línea contiene el comando echo, que muestra un mensaje por pantalla.
2. Variables
Una variable es un contenedor que almacena un valor. Utilizamos variables para guardar valores
que necesitaremos en nuestro script. Un detalle que debemos indicar es que las variables en shell

script no tienen tipos asociados.
Veamos a continuación cómo se asigna un valor a una variable:
Ejemplos:
# Asignamos el valor 1 a i
i=1
# Asignamos Bienvenidos a la programación de shell scripts! a la variable cadena
cadena="Bienvenidos a la programación de shell scripts!"
Una cuestión importante: No podemos dejar espacios entre la variable y el igual o el igual y el
valor, porque el shell lo interpretará como un comando y nos dará error.
Veamos ahora como podemos obtener el valor de una variable.
Para acceder al contenido de una variable empleamos $ delante de su identificador:
Ejemplos:
$ i=4
# Mostramos el valor de la variable i por pantalla
echo $i
echo "El valor asignado a i es $i"
3. Uso de parámetros en scripts
Podemos usar parámetros en nuestros scripts. Dichos parámetros nos permitirán pasar valores
externos que utilizaremos dentro:
$0 contiene el nombre nombre de nuestro script
$# contiene el número de parámetros con los que se ha invocado al shell
$n contiene los parámetros, con n de 1 a 9 (a $#)
{$n} cuando n > 9, tenemos qu especificar los parámetros entre llaves
$$ contiene el PID de nuestro proceso
$* todos los parámetros menos $0
4. La salida de los programas
Cuando se ejecuta un programa, un comando UNIX es un programa, podemos, a parte de redirigir
su entrada y su salida, recoger el resultado de su ejecución y su salida.
El resultado es un valor numérico, por lo general cero si todo ha ido bien, y distinto de cero si ha
habido alguna clase de error.
- Para obtener el resultado de la ejecución del último comando, utilizamos $?
Ejemplo:
mkdir /home/alumnos/$idalumno > /dev/null ; echo $?
if [ $?=0 ]; then
echo "El directorio $idalumno se ha creado sin problemas"
fi
- Para obtener la salida de un comando, utilizamos $(comando) o comillas invertidas: `comando`

Ejemplo:
$ directorioactual=`pwd`
$ echo $directorioactual
- Para devolver el resultado de ejecución de un script, utilizamos exit valor, donde valor debe ser
un numéro entero.
Ejemplo:
exit 0 # Termina el programa y devuelve cero como valor de salida
5. Operadores aritméticos
Si queremos que el shell evalúe una operación aritmética y no la tome como argumentos de un
comando, escribiremos la expresión observando la siguiente sintaxis: $((expresion))
Al escribir la expresión de este modo, el shell la evalúa y la reemplaza por su valor.
Ejemplo:
$ echo $((1+1))
Algunos de los operadores aritméticos soportados son:
+ la suma
* la mutiplicación
- la resta
/ la división entera
% el resto de la división entera
( ) los paréntesis nos sirven para agrupar operaciones
6. Operadores de comparación
Podemos hacer comprobaciones sobre ficheros utilizando el comando test.
El comando test evalúa una expresión y retorna un valor que será cero si la expresión es verdadera o
distinto de cero si la expresión es falsa.
Este comando tiene la siguiente sintaxis:
test expresion
[ expresion ]
donde EXPRESION puede ser una evaluación: de cadenas de caracteres, números enteros, archivos
(evaluamos permisos y existencia del archivo) u operadores lógicos que permiten realizar una
combinación de varias evaluaciones.
- Utilización abreviada del comando test.
En vez de escribir test EXPRESION, podemos escribir la EXPRESION entre corchetes( [ ] ) y el

resultado será exactamente el mismo.
Ejemplo:
$ str="abc"
$ [ "$str" = "abc" ]
$ echo $?
Habitualmente el comando test se utiliza en conjunto con la sentencia if para evaluar distintos tipos
de expresiones que veremos a continuación.
6.1. Operadores sobre ficheros
-d fichero cierto si fichero existe y es un directorio
-e fichero cierto si fichero existe, independientemente del tipo que sea
-f fichero cierto si fichero existe y es un fichero normal
-r fichero cierto si fichero existe y se puede leer
-s fichero cierto si fichero existe y tiene tamaño mayor que cero
-w fichero cierto si fichero existe y es se puede escribir sobre él
-x fichero cierto si fichero existe y es ejecutable
6.2. Operadores lógicos
! expresion cierto si expresion es falsa (negación)
expresion1 -a expresion2 cierto si expresion1 y expresion2 son ciertas
expresion1 -o expresion2 cierto si expresion1 o expresion2 son ciertas
6.3. Operadores de comparación de números enteros
n1 -eq n2 cierto si los enteros n1 y n2 son iguales
n1 -ne n2 cierto si los enteros n1 y n2 no son iguales
n1 -gt n2 cierto si el enteros n1 es mayor que n2
n1 -ge n2 cierto si los enteros n1 y n2 son iguales o n1 es mayor que n2
n1 -lt n2 cierto si el enteros n1 es menor que n2
n1 -le n2 cierto si los enteros n1 y n2 son iguales o n1 es menor que n2

6.4. Operadores de comparación de cadenas
s1 = s2 cierto si las cadenas de texto s1 y s2 son idénticas
s1 != s2 cierto si las cadenas de texto s1 y s2 no son idénticas
s1 <> s2 cierto si la cadena de texto s1 es mayor que s2
-n cadena cierto si la longitud de la cadena de texto es distinta de cero
6.5. Operadores lógicos && y ||
Además de los anteriores, existen los operadores lógicos && (AND, multiplicación lógica) y ||
(OR, suma lógica), que se puede aplicar al valor de salida de los programas:
$ true && true ; echo $?
$ true && false ; echo $?
$ false && true ; echo $?
$ false && false ; echo $?
$ true || true ; echo $?
$ true || false ; echo $?
$ false || true ; echo $?
$ false || false ; echo $?
7. Sentencias de comparación
7.1. Sentencia if
Esta sentencia nos permitirá ejecutar un bloque de código, o u otro, dependiendo de como se evalue
una condición.
La forma más simple tiene la siguiente sintaxis:
if CONDICION; then
bloque de comandos
fi
En este primer caso el bloque de comandos se ejecutará solo si la condición es evaluada a cierto.
Una segunda posibilidad es utilizar else:
if CONDICION; then
else
fi
En este segundo caso el bloque de comandos b1 se ejecutará si la condición es cierta. Si la
condición fuera falsa, se ejecutará el bloque de comandos b2.
La condición puede ser, por ejemplo, una llamada al comando test o una operación lógica entre los
valores de salida de diferentes comandos.
Ejemplo:

read numero
# comparamos cadenas de texto, así que usamos comillas
if [ $numero -eq 5 ]; then
echo Acerté tu número. Es el 5.
fi
7.2. Sentencia case
Se utiliza cuando el valor de una variable ha de ser contrastado con varios valores. Su sintaxis es la
siguiente:
case variable in
patron1) comando1
comando2;;
patron2) comando3
comando4;;
....
....
esac
Comprueba si variable coincide con algunos de los patrones (patron1, patron2,...) y ejecuta los
comandos asociados con la primera coincidencia que tiene lugar.
Sólo se ejecuta un único grupo de comandos.
El ";;" es el delimitador de los comandos que se ejecutaran para un determinado patrón y
"esac" es el fin de la sentencia case.
Un ejemplo clásico de uso de la sentencia case es la creación de un menú:
!/bin/bash
##############################
# Genera un menú de opciones #
##############################
echo "[1] Listar archivos"
echo "[2] Ver directorio de trabajo"
echo "[3] Crear directorio"
echo "[4] Crear usuario"
read -p "Ingrese una opción: " OPCION
case $OPCION in

1) ls;;
2) pwd;;
3) read -p "Ingrese nombre del directorio a crear: " DIRECTORIO
mkdir $DIRECTORIO;;
4) if id | grep uid=0
then
read -p "Ingrese el nombre del usuario a crear: " NOMBREUSUARIO
useradd $NOMBREUSUARIO
else
echo "Se necesitan permisos de root"
fi;;
*) echo "Opción ingresada no valida, intentelo de nuevo"
exit 1;;
esac
8. Bucles
El shell nos aporta mecanismos para realizar tareas repetitivas mediante el empleo de estructuras
que permiten repetir un bloque de comandos.
8.1. El bucle for
Esta estructura permite repetir un bloque de comandos asignando valores de una serie a una variable
en cada iteración.
for VARIABLE in SERIE; do
bloque de comandos
done
En cada iteración la variable VARIABLE toma un valor de SERIE, que en caso de no contener
elementos hará que no se ejecute nada y se devuelva un valor 0.
En caso de que se ejecuten comandos, el resultado devuelto tras el bucle es el del último comando
ejecutado.
Podemos especificar los valores de la serie de dos formas:
• Nombrando todos los elementos de la serie:for i in 1 2 3 4 5; do
• Utilizando la sentencia seq:for i in seq 1 5; do
Ejemplos:
for i in 1 2 3 4 5; do
echo $i

done
for i in seq 1 5; do
echo $i
done
# con cadenas de texto
for palabra in uno dos tres cuatro cinco; do
echo $palabra
done
8.2. El bucle while
Es otra estructura de bucle que permite ejecutar un bloque de comandos mientras se evalúe una
condición a cierto:
while CONDICION; do
bloque de comandos
done
Cada iteración se evalua la condición y en el momento que no sea cierta, el bucle termina.
Ejemplos de bucles:
i=1
while [ $i -le 10 ]; do
echo $i
i=$(($i+1))
done
# leemos de stdin hasta que se introduzca la palabra 'salir'
read linea
while [ $linea != "salir" ]; do
read linea
done
8.3. Rompiendo la ejecución del bucle: break
Podemos interrumpir un bucle en cualquier momento mediante el uso de la sentencia break, de
forma que tras ser ejecutado ese comando el control pasa al siguiente comando después del done.
Ejemplo de uso de break:
for elemento in *; do
echo Primer elemento $elemento
break
echo Esto nunca se llega a ejecutar
done
echo Seguimos con el programa
9. Funciones
Una función o subrutina es una agrupación de comandos bajo un mismo nombre. Lo que nos
permitirá dividir el programa en bloques y programar cada bloque por separado, o agrupar una serie
de comandos que se ejecutan a menudo bajo un mismo nombre.
Veamos cuál es la sintaxis de una función:
nombre_funcion()

{
comando1
comando2
...
...
}
Luego, para ejecutar la función debemos llamarla por su nombre, igual que un comando:
...
nombre_funcion
...
Eso sí, debemos tener en cuenta que es necesario definir cada función antes de utilizarla. Veamos un
ejemplo:
mostrar_menu ()
{
echo -e "n"
echo "[1] Crear usuario"
echo -e "[2] Salirn"
read -p "Elija una opción: " OPCION
}
crear_usuario ()
{
if [ id | grep uid=0 ]; then
read -p "Nombre del usuario a crear: " NOMBREUSUARIO
useradd $NOMBREUSUARIO
else
echo '*****************************'
echo "Se necesitan permisos de root"
echo '*****************************'

fi
}
############# Programa principal #################
while true; do
mostrar_menu
case $OPCION in
1) crear_usuario ;;
2) echo "Abandonando el programa..."
break;;
*) echo '********************************************'
echo "Opción ingresada no valida, intente de nuevo"
echo '********************************************';;
esac
done

Shell script

Más contenido relacionado

La actualidad más candente (20)

Destacado (6)

Similar a Shell script (20)

Shell script