SHELL SCRIPTS

CONTENIDO
NUESTRO PRIMER SCRIPT........................................................................................................... 2
USO DE VARIABLES EN LOS SCRIPTS. EXPANSIONES. ................................................................... 3
$(ORDEN) ............................................................................................................................... 4
$((OPERACIÓN ARITMÉTICA)) o $[OPERACIÓN ARITMÉTICA] .................................................. 5
ORDEN LET ............................................................................................................................. 5
ORDEN BC .............................................................................................................................. 6
ESTRUCTURAS CONDICIONALES. ................................................................................................ 7
IF............................................................................................................................................ 7
IF..ELSE................................................................................................................................. 10
IF..ELIF..ELSE ........................................................................................................................ 11
CASE .................................................................................................................................... 14
ESTRUCTURAS ITERATIVAS. (BUCLES). ...................................................................................... 16
FOR ...................................................................................................................................... 16
WHILE Y UNTIL ..................................................................................................................... 20
Shell Scripts Linux

NUESTRO PRIMER SCRIPT

Un script es un conjunto de órdenes (instrucciones) guardadas en un fichero de

texto, que puede ser creado con cualquier editor de texto (vi, nano, gedit, etc.).

Se suelen crear para automatizar tareas del sistema operativo.

Vamos a crear nuestro primer script: para ello, crea un fichero de texto de
nombre primero.sh, con el siguiente contenido: Comentado [JR1]:

#!/bin/bash
echo “Hola Mundo”

La primera línea sirve para indicar que shell utilizamos (en nuestro caso bash) y
donde puede ser encontrado en nuestro sistema (para saberlo, podemos hacer
locate bash). Esta línea debe ser la primera de todos los scripts que
realicemos.

La segunda línea de nuestro script, simplemente utiliza el comando echo para

escribir en pantalla y escribe la línea Hola Mundo.

Una vez creado el fichero, debemos darle permisos de ejecución:

chmod a+x primero.sh

Y para ejecutarlo, debemos llamarlo como ./permiso.sh (el punto barra es para
indicarle que lo busque en el directorio actual, ya que dicho directorio no estará
seguramente incluido en el PATH del sistema).

Si queremos ejecutar un script para comprobar cómo funciona sin hacerlo

ejecutable, podemos hacerlo mediante el comando source primero.

Sin embargo, la orden source solo debe usarse para comprobar el script, una vez
que tengamos el script completo y depurado, debemos darle sus permisos de
ejecución correspondientes.

Las comillas dobles que hemos usado para escribir Hola Mundo no son
necesarias, y podéis comprobar que, si las quitáis, el proceso se ejecuta
exactamente igual. Sin embargo, es una buena práctica encerrar siempre los
textos entre comillas dobles, y en caso de que contengan caracteres especiales
(como el *, el $, etc.), es mejor usar comillas simples, que son más potentes que
las comillas dobles.
Página 2
Shell Scripts Linux

Si tenemos que ejecutar varias líneas y queremos escribirlas en una sola, podemos
hacerlo usando el símbolo punto y coma (;) para indicar que lo siguiente es otra
línea, aunque este en la misma:

echo Hola ; pwd ; echo Adios # esto son tres líneas en una sola.

También podemos hacer lo contrario, escribir una sola línea en varias. Para ello
usamos el carácter contrabarra (\) cuando queramos que nuestra línea se
“rompa” y continúe en la línea de abajo.

echo esto \ es una sola línea \ aunque ocupe 3 en pantalla. # esto es una
línea escrita en tres.

En estos últimos ejemplos he aprovechado para mostraros como se pueden usar

comentarios en los scripts. Basta con usar el símbolo almohadilla (#) donde
queramos, todo lo que quede a la derecha de dicho símbolo es un comentario.

Si usamos # como primer carácter de una línea, toda la línea es de comentario.

USO DE VARIABLES EN LOS SCRIPTS. EXPANSIONES.

Las variables de los shell scripts son muy simples, ya que no tienen tipo definido
ni necesitan ser declaradas antes de poder ser usadas.

Para introducir valor en una variable simplemente se usa su nombre, y para

obtener el valor de una variable se le antepone un símbolo dólar ($).

#!/bin/bash
MENSAJE=”Hola Mundo”
echo $MENSAJE

Este script realiza exactamente la misma función que el anterior, pero usando una
variable.

Se llama expansión al proceso que lleva a cabo el shell antes de ejecutar una
orden.

En el ejemplo anterior, para ejecutar la orden “echo $MENSAJE”, el shell tiene

primero que sustituir $MENSAJE por el valor de esa variable, y a ese proceso se
le llama expansión de parámetros.

Página 3
Shell Scripts Linux

Hay varios tipos de expansiones, que iremos viendo a lo largo de este tema.

$(ORDEN)

Una de las expansiones más utilizadas en Linux es la expansión de comandos,

que permite que la salida de un comando se le pase a otro comando.

La sintaxis es:
$ (comando) o `comando`

Esta expansión permite ejecutar lo que se encuentre entre los paréntesis, y

devuelve su salida.

echo pwd # escribe por pantalla la palabra pwd

echo $(pwd) # ejecuta la orden pwd, y escribe por pantalla su resultado.

Así, por ejemplo, la siguiente instrucción copia el fichero /etc/network/interfaces

en el directorio actual con el nombre red151118.conf (suponiendo que estamos
en la fecha 15 de Noviembre de 2018).

NOMBRE_FICHERO=”red”$(date +%d%m%y)”.conf”
cp /etc/network/interfaces $NOMBRE_FICHERO

El comando date nos da la fecha del sistema en el formato indicado con “+”,
siendo %d% el día, %m el mes y %y el año, todos con dos caracteres.

El efecto conseguido con $(orden) se puede conseguir también usando la tilde

invertida `orden`.

Página 4
Shell Scripts Linux

$((OPERACIÓN ARITMÉTICA)) o $[OPERACIÓN ARITMÉTICA]

Cualquier valor introducido en una variable se considera alfanumérico, así que si

realizamos lo siguiente:

NUMERO=4 # No se debe dejar ningún espacio en la asignación.

echo $NUMERO+3

Obtendremos por pantalla la cadena de caracteres 4+3.

Por tanto, cuando queremos realizar operaciones aritméticas, podemos usar otra
expansión, que en este caso es $((operación aritmética)).

Los dobles paréntesis podemos sustituirlos si queremos por corchetes $[ ].

Esta expansión trata como una expresión aritmética lo que esté incluido entre los
paréntesis, la evalúa y devuelve su valor.

NUMERO=4
echo $[$NUMERO+3] # sería lo mismo poner echo $(($NUMERO+3))

Obtenemos en pantalla el valor 7.

Ejercicio: crea un script llamado suma.sh que sume el valor de dos variables y
muestre el resultado. Ejemplo de salida: 2 + 3 = 5

ORDEN LET

Otro modo de realizar operaciones aritméticas es utilizando el comando let, que

nos permite realizar operaciones sin tener que usar expansiones ni dólares para
las variables.

NUMERO=4
let SUMA=NUMERO+3
echo $SUMA

Obtenemos el mismo valor 7, y como vemos, no hemos usado ni dólar, ni

paréntesis.

Los operadores aritméticos que podemos usar para realizar operaciones son:
Resta (-), Suma (+), División (/), Multiplicación (*) y Módulo o Resto (%).
Página 5
Shell Scripts Linux

Ejercicio: crea un script llamado cuentas.sh que use las variables PRECIO (por
ejemplo 100) y COMENSALES (por ejemplo 5) y muestre por pantalla la siguiente
información:

Precio comida: 100€

Nº Comensales: 5
Cada comensal tiene que pagar 20 euros

ORDEN BC

Para explicar este comando, vamos a hacer una prueba: crear con nano un
fichero con nombre media.sh con el siguiente contenido:

Darle permisos de ejecución y ejecutarlo. Si lo habéis escrito bien veréis como os

da la media aritmética de las tres notas introducidas.

La línea
MEDIA=$[ $SUMA / 3 ]

Podría haberse escrito también como

let MEDIA=SUMA/3

Si ejecutamos el script, veremos que hay un problema, y es que podéis comprobar

como bash no trabaja con decimales, de modo que, si introducimos por ejemplo
10, 10 y 6, nos dirá que la media es 8, mientras que la media realmente es 8,66.

Podemos obligar a que bash trabaje con decimales utilizando un comando que
sirve como calculadora en Linux, este comando es bc, que admite un gran número
de parámetros, pero en este tema vamos a usarlo simplemente para indicar que
queremos obtener decimales en las operaciones.

Página 6
Shell Scripts Linux

Para ello simplemente haremos el siguiente cambio:

MEDIA =$[ $SUMA / 3 ]

Lo sustituiremos por

MEDIA=$( echo “scale=4; $SUMA/3” | bc –l )

Vemos cómo debemos generar una salida con echo, donde el primer campo scale
indica cuantos decimales queremos obtener (4 en este caso), luego y separado
por un punto y coma ponemos la operación aritmética que deseamos realizar, sin
necesidad de poner corchetes, dobles paréntesis o usar let. El resultado de este
echo lo enviamos al comando bc –l mediante una tubería.

El parámetro -l del comando bc le indica que use la librería matemática.

Para entenderlo un poco mejor, probad las siguientes líneas:

Realmente el comando bc espera un fichero que contenga scale y la operación,

por eso se usa el echo con la tubería, que simula el fichero de texto.

ESTRUCTURAS CONDICIONALES.

IF

La principal estructura condicional de los scripts es el if (Sí en inglés):

if [ expresión ]; then
órdenes
fi

Si se cumple la expresión, se ejecutan las órdenes indicadas. La expresión es

cualquier expresión lógica que produzca un resultado verdadero o falso.

Página 7
Shell Scripts Linux

Hay que tener muchísimo cuidado con los espacios en blanco, como en los
corchetes, que llevan espacios en blanco tanto a izquierda como derecha. El
punto y coma sin embargo va pegado al corchete cerrado, y SIEMPRE hay
que poner espacios en blanco en las expresiones.

Si estamos operando con cadenas alfanuméricas, los operadores que podemos

utilizar son los siguientes:

Operadores de comparación de cadenas alfanuméricas

Cadena1 = Cadena2 Verdadero si Cadena1 es IGUAL a Cadena2

Cadena1 != Cadena2 Verdadero si Cadena1 NO es IGUAL a Cadena2

Cadena1 < Cadena2 Verdadero si Cadena1 es MENOR a Cadena2

Cadena1 > Cadena2 Verdadero si Cadena1 es MAYOR que Cadena2

Verdadero si Cadena1 NO ES NULO (tiene algún valor)

-n Variable1

Verdadero si Cadena1 ES NULO (está vacía o no está

-z Variable1
definida)

Ejemplo:

Las comparaciones de cadenas distinguen mayúsculas y minúsculas. Un truco

para hacer comparaciones ignorando si la cadena está en mayúsculas o
minúsculas, es pasar la cadena a comparar toda a mayúsculas o minúsculas. Se
haría así:

OPCION=”Fin”
OPCION_MAYUSCULAS=${OPCION^^}
if [ $OPCION_MAYUSCULAS=”FIN”]; then
echo “Terminado”
fi

Página 8
Shell Scripts Linux

En minúsculas sería así:

OPCION=”Fin”
OPCION_MINUSCULAS=${OPCION,,}
if [ $OPCION_MINUSCULAS=”fin”]; then
echo “Terminado”
fi

Los anteriores operadores sólo son válidos para comparar cadenas, si queremos
comparar valores numéricos, hemos de usar los siguientes operadores:

Operadores de comparación de valores numéricos.

Numero1 -eq Numero2 Verdadero si Numero1 es IGUAL a Numero2. (equal)

Numero1 -ne Numero2 Verdadero si Numero1 NO es IGUAL a Variable2. (not

equal)

Numero1 -lt Numero2 Verdadero si Numero1 es MENOR a Variable2. (less

that)

Numero1 -gt Numero2 Verdadero si Numero1 es MAYOR que Variable2.

(greater that)

Numero1 -le Numero2 Verdadero si Numero1 es MENOR O IGUAL que

Numero2. (less or equal).

Numero1 -ge Numero2 Verdadero si Numero1 es MAYOR O IGUAL que

Numero2. (greater or equal).

Ejemplo:

Página 9
Shell Scripts Linux

Si usamos operadores de comparación numéricos con valores de cadena, el

sistema nos dará un error como el siguiente:

IF..ELSE

La estructura if podemos ampliarla usando la construcción else (en caso contrario)

y elif (en caso contrario si…).

La estructura simple de else es la siguiente:

if [ expresión 1 ]; then
órdenes
else
órdenes
fi
Ejemplo:

Ejercicio: crea un script llamado ordena.sh que, dados dos nombres de personas,
metidos en dos variables, los ordene alfabéticamente y los muestre por pantalla.

Página 10
Shell Scripts Linux

IF..ELIF..ELSE

Una estructura con elif (else if) tiene la siguiente forma:

if [ expresión1 ]; then
Realizar si expresión1 es verdadera

elif [ expresión2 ]; then

Realizar si expresión1 es falsa, pero es verdadera expresión2

elif [ expresión3 ]; then

Realizar si exp1 y exp2 son falsas, pero es verdadera expresión3

else
realizar si todas las expresiones anteriores son falsas
fi

Ejercicio: crea un script llamado hijos.sh que, dado un número de hijos, indique
por pantalla: “Tiene 1 hijo”, “Tiene 2 hijos” o “Tiene 3 o más hijos”.

Hemos visto operadores aritméticos y operadores para cadena, pero en las

expresiones podemos utilizar cualquier operación que nos devuelva un valor
lógico (0 para verdadero).

Por ejemplo, podemos usar la función test del bash, que funciona de la
siguiente forma:

Operaciones condicionales usando test.

-a fichero Verdadero si fichero existe
-d fichero Verdadero si fichero existe, y es un fichero de tipo
directorio
-f fichero Verdadero si fichero existe, y es un fichero regular.
-r fichero Verdadero si fichero existe y se puede leer
-w fichero Verdadero si fichero existe y se puede escribir
-x fichero Verdadero si fichero existe y se puede ejecutar
fichero1 -nt fichero2 Verdadero si fichero1 es más nuevo que fichero2
fichero1 -ot fichero2 Verdadero si fichero1 es más viejo que fichero2

Página 11
Shell Scripts Linux

Si lo necesitamos, podemos anidar expresiones usando tanto AND (&&) como

OR (||).

if [ expresión1 ] && [ expresión2 ]; then

se ejecuta si expresión1 Y expresión2 son verdaderas
fi

if [ expresión1 ] || [ expresión2 ]; then

se ejecuta si expresión1 O expresión2 son verdaderas
fi

También podemos usar el operador not (!) para indicar una negación.

if ! [ expresión1 ]; then
se ejecuta si expresión1 NO es verdadera
fi

Para hacer algunos ejercicios, vamos a explicar cómo le podemos pedir datos al
usuario.

Se hace con la orden read y es muy simple de usar:

read -p “texto de la pregunta” variable

La ejecución del script se parará, mostrará por pantalla el texto de la pregunta, y

dejará que el usuario escriba la respuesta, y cuando pulse INTRO, la respuesta
dada se introducirá como valor de variable.

El comando read también puede ser usado sin el parámetro -p, de la forma read
variable. También podemos hacer que lea un determinado número de caracteres,
sin obligar a que el usuario pulse intro, con el parámetro -n
número_de_caracteres. El parámetro -s silencia el eco (no se ve por pantalla lo
que el usuario escribe).

Ejercicio: crea un script llamado nota.sh que pida una nota por pantalla e
indique si el alumno está suspenso, aprobado, tiene un bien, un notable o un
sobresaliente.

Ejercicio: crea un script llamado impar.sh que pida un número por pantalla, e
indique si el número introducido es par o impar.

Página 12
Shell Scripts Linux

Ejercicio: crea un script llamado multiplo10.sh que pida un número por pantalla
e indique si es un múltiplo de 10 o no.

Ejercicio: crea un script llamado nombreJ.sh que nos pida un nombre por
pantalla y nos diga si dicho nombre comienza por la letra jota mayúscula.

Ejercicio: crea un script llamado capicua.sh, que pida al usuario un número de 3

cifras e indique si es capicúa.

Cuando hacemos un script de varias líneas, es posible que cometamos algún fallo.
Una opción que podemos usar para depurar los scripts y encontrar rápidamente
los errores, es añadir un -x en la llamada al bash de la primera línea. Esto hará que
cada línea antes de ejecutarse sea mostrada por pantalla tal y como la está
interpretando el bash.

#!/bin/bash -x

Para que esto funcione, es necesario que hagamos el script ejecutable, no es

válido si lanzamos el script con la orden source.

Ejercicios:

1. Script que nos diga si en el directorio actual hay más de 10 ficheros o no.

2. Script que nos pida la altura de 3 personas en centímetros, y nos diga por
pantalla la mayor de esas alturas.

3. Script que nos pida por pantalla el nombre de un mes (enero, febrero, etc.) y
nos dirá por pantalla el número de días que tiene ese mes. (Así, si introducimos
diciembre nos responderá “Diciembre tiene 31 días”). Para este script se
considera que no existen los años bisiestos, así que febrero siempre tendrá 28
días.

Página 13
Shell Scripts Linux

CASE

Esta estructura nos permite ejecutar varias acciones, dependiendo del valor de
una variable o expresión.

Sintaxis:
case VARIABLE in
valor1)
se ejecuta si VARIABLE tiene el valor1
;;
valor2)
se ejecuta si VARIABLE tiene el valor2
;;
*)
Se ejecuta si VARIABLE tiene otro valor distinto
;;
esac

Ejemplo:
Script que, dado un código postal, nos dice qué ciudad es.

#!/bin/bash

read -n 5 -p "Introduzca un codigo postal: " CP

echo
case $CP in
30530)
echo "Cieza" ;;
30500)
echo "Molina de Segura" ;;
30509)
echo "Llano de Molina" ;;
*)
echo "Código postal desconocido" ;;
esac

En el case, no solo podemos preguntar por valores directos, sino que también
podemos utilizar comodines.

Página 14
Shell Scripts Linux

Veamos algunos ejemplos:

#!/bin/bash

read -n 5 -p "Introduzca un codigo postal: " CP

echo
case $CP in
[30001-30012]*)
echo "Murcia Capital" ;;
30*)
echo "Region de Murcia";;
28*)
echo "Comunidad de Madrid" ;;

*)
echo "Código postal desconocido" ;;
esac

Otro ejemplo:

Ejercicio: hacer un script llamado horóscopo.sh que nos pida el año en que
nacimos (4 cifras) y nos diga por pantalla que animal nos corresponde según el
horóscopo chino. Para calcularlo debemos dividir el año entre 12 y el resto nos
indicará el animal según la siguiente tabla.

0 El Mono 4 La Rata 8 El Dragón

1 El Gallo 5 El Buey 9 La Serpiente
2 El Perro 6 El Tigre 10 El Caballo
3 El Cerdo 7 El Conejo 11 La Cabra

El mensaje que queremos obtener en pantalla debe ser:

“Si naciste en 1965 te corresponde La Serpiente según el horóscopo chino. “

Página 15
Shell Scripts Linux

ESTRUCTURAS ITERATIVAS. (BUCLES).

Las principales estructuras iterativas que podemos usar en shell scripts son for,
while, until y select.

FOR

La estructura básica de for es la siguiente:

for VARIABLE in conjunto; do

ordenes
done

La variable va tomando los valores del conjunto, uno por uno, y por cada uno de
esos elementos, se repiten las órdenes dadas.

Los valores del conjunto se separan por espacios en blanco o retornos de línea.

Ejemplo: mostrar los días de la semana por pantalla:

For DIA in lunes martes miércoles jueves viernes sábado domingo; do
Echo “Dia de la semana: $DIA”
done

Otro ejemplo, obtener por pantalla los números del 1 al 10:

La potencia del comando for viene de la flexibilidad de valores que admite el

conjunto de valores, ya que podemos crear dicho conjunto con una orden del
sistema operativo.

En el siguiente ejemplo vamos a usar como conjunto, los nombres de los ficheros
con extensión sh del directorio actual:

Página 16
Shell Scripts Linux

El conjunto puede ser cualquier salida de cualquier orden, y formará elementos

utilizando el espacio en blanco como separador de elementos. Fijaros en el
siguiente ejemplo:

Vemos como utilizamos como conjunto el contenido de un fichero. Vemos

también como la línea “jose antonio” la divide en 2 elementos distintos debido al
espacio en blanco.

Una orden muy utilizada con for es la orden seq, que produce una secuencia de
números, con las siguientes posibilidades.

seq último-número
seq primer-número último-número
seq primer-número incremento último-número

Ejemplo: modifiquemos el ejercicio de mostrar los números del 1 al 10 que

hicimos anteriormente, usando esta vez la orden seq.

Página 17
Shell Scripts Linux

Ejercicio: crea un script llamado suma100.sh que sume todos los números del 1
al 100, es decir, 1+2+3+4+5…+100, y muestre por pantalla el siguiente mensaje:
“Los números del 1 al 100 suman … “

Ejercicio: Modificad el anterior ejercicio para que el script sume todos los
números, pero no entre 1 y 100, sino entre dos números que pida el script por
pantalla.

Desde la versión de bash 3.0 se introdujo un cambio en el for que permite utilizar
directamente rangos sin tener que usar la orden seq:

Desde la versión de bash 4.0 se introdujo otro cambio, que permite utilizar
también incrementos en los rangos, de la siguiente manera:

Como vemos, podemos utilizar los rangos de la siguiente forma:

{INICIO..FINAL}
{INICIO..FINAL..INCREMENTO}

El for de bash también permite utilizar el formato basado en trio de expresiones

común al lenguaje C.

for (( expresión-inicio; condición-para-seguir; expresión-de-paso ))

Normalmente utilizaremos este formato de la siguiente forma:

for (( VARIABLE=valor_inicial; condición-para-seguir; incremento ))

Página 18
Shell Scripts Linux

Veamos como ejemplo un script que nos muestra los números pares entre 2 y 40.

Podemos crear un bucle infinito de la siguiente forma:

Podemos utilizar la instrucción break para salirnos inmediatamente de un bucle

for. Fijaros en el siguiente ejemplo:

Este tipo de elementos (bucles infinitos, break, etc.) se consideran como “poco
elegantes” desde el punto de vista de la programación y es mejor acostumbrarse
a no usarlos, ya que existen otro tipo de alternativas más refinadas. Sin embargo,
son herramientas potentes y es conveniente conocerlas.

Imaginemos que queremos copiar a un llavero USB (montado en /media/usbdisk

por ejemplo) todos los scripts que tengamos en nuestro directorio home, sin
importar en que directorio estén, podríamos hacerlo fácilmente con este script:

#!/bin/bash
for programa in $( find ~ -iname “*sh” 2> /dev/null ); do
echo “copiando el script :” $programa
cp $programa /media/usbdisk
done

Página 19
Shell Scripts Linux

Ya que estamos, mejoremos el script anterior para que cree un directorio scripts
en nuestro llaverito, pero únicamente si no existe.

#!/bin/bash
if ! [ -d /media/usbdisk/scripts ]; then
mkdir /media/usbdisk/scripts
fi
for programa in $( find ~ -iname “*sh” 2> /dev/null ); do
echo “copiando el script :” $programa
cp $programa /media/usbdisk
done

WHILE Y UNTIL

Cuando no queremos recorrer un conjunto de valores, sino repetir algo mientras

se cumpla una condición, o hasta que se cumpla una condición, podemos usar
las estructuras while y until.

La estructura del while es la siguiente:

while [ expresión ]; do
órdenes # se repetirán MIENTRAS la expresión sea verdadera
done

La estructura del until es la siguiente:

until [ expresión ]; do
órdenes # se repetirán HASTA que la expresión sea verdadera
done

Ejemplo: script doble.sh, que pide un número y muestra su doble. El script se

ejecutará hasta que se pulse 0.

Página 20
Shell Scripts Linux

Solución con while:

#!/bin/bash

read -p “Dime un número (0 para salir) : “ NUMERO

while [ $NUMERO -ne 0 ]; do
echo “El doble de $NUMERO es :” $(($NUMERO*2))
read -p “Dime un número (0 para salir) : “ NUMERO
done

Ejercicio: modifica el script doble.sh para que realice lo mismo, pero usando la
estructura until, en lugar de while.

Ejercicio: realiza un script que muestre por pantalla los números del 1 al 20,
usando una estructura while o until.

Página 21