RESUMEN INTRODUCCION A LOS SHELL SCRIPTS CON BASH EN LINUX

ISO-ASIR

Fuente: http://enavas.blogspot.com/search/label/scripts Ejemplos prácticos por JDPC

PROGRAMACIÓN DE SHELL SCRIPTS EN LINUX

Una de las cosas con la que trabajan 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.

Para seguir la explicación utilizaremos una máquina virtual con linux y crearemos un
directorio de nombre ~ejemplos_sh donde iremos realizando los ejemplos prácticos
sugeridos.

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/bash
echo Este es mi primer script en bash!

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

Práctica: 'ej01.sh':
#!/bin/bash
# Este es mi primer shell script con bash
clear # Borramos la pantalla
echo Hola, me llamo Juan y estudio ASIR en el IES Castelar
echo Adios!
echo
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 (entero, cadena etc).
Veamos a continuación cómo se asigna un valor a una variable:
Ejemplo:
# Asignamos el valor 1 a i
i=1
# Asignamos Hola! a la variable cadena
cadena="Hola!"

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:

Ejemplo:
$ i=4
# Mostramos el valor de la variable i por pantalla
echo $i
echo "El valor asignado a i es $i"

Práctica: 'ej02.sh':

#!/bin/bash
clear
# Asignamos variables
nombre=Juan
ciclo=ASIR
centro="IES Castelar"
echo Hola, me llamo $nombre
echo y estudio $ciclo en el $centro.
echo Adios!
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

Práctica: 'ej03.sh':

#!/bin/bash
# Uso de parametros de entrada
# Llamada: ./ej03.sh param1 param2 param3
echo
echo "Nombre del script \$0 : " $0
echo "Numero de parametros \$# : " $#
echo "El parametro 1 \$1 : " $1
echo "El parametro 2 \$2 : " $2
echo "El parametro 3 \$3 : " $3

4. La salida de los programas

Cuando se ejecuta un programa, un comando UNIX es un programa, podemos, aparte de
redirigir su entrada y su salida, recoger el resultado de su ejecución y su salida.
Otros: $?

Para obtener el resultado (éxito o error) de una ejecución de un comando , podemos utilizar
$?. Esta variable toma valor 0 de salida si la ejecución del comando anterior se ejecutó con
éxito y en caso de fallo tomaría un valor distinto de 0.
Ejemplo:

$ls hola ; echo $? (Si no existe el fichero hola nos devolverá 2)

$ls; echo $? (Lista el directorio y devolverá 0 al no producirse error)

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)) ( o también $ 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

Práctica: 'ej04.sh':

#!/bin/bash
# Uso de Operadores aritméticos
# Llamada: ./ej04.sh operador1 operador2
echo
echo "$1 + $2 = : " $[$1+$2]
echo "$1 * $2 = : " $[$1*$2]
echo "$1 - $2 = : " $[$1-$2]
echo "$1 / $2 = : " $[$1/$2]

Comando para leer valores desde el teclado: read

Práctica: 'ej05.sh':

#!/bin/bash
# Lee los 2 operandos desde terminal con la orden read
# Llamada: ./ej05.sh (nos pedira los 2 numeros)
clear
# el modificador -n hace que no haya retorno de carro en el echo
echo -n "Entra el primer operando : "
read a
# Otra forma: incluir pregunta en el read con el modificador -p
read -p "Entra el segundo operando : " b
echo "$a + $b = : " $[$a+$b]
echo "$a * $b = : " $[$a*$b]
echo "$a - $b = : " $[$a-$b]
6. Operadores de comparación

Comparaciones de cadenas alfanuméricas

Operador Verdad (TRUE) si:

------------------------------------------
cadena1 = cadena2 cadena1 es igual a cadena2
cadena1 != cadena2 cadena1 no es igual a cadena2
cadena1 < cadena2 cadena1 es menor que cadena2
cadena1 > cadena 2 cadena1 es mayor que cadena 2
-n cadena1 cadena1 no es igual al valor nulo (longitud mayorque 0)
-z cadena1 cadena1 tiene un valor nulo (longitud 0)

Comparaciones de valores numéricos

Operador Verdad (TRUE) si:

------------------------------------------
x -lt y x menor que y
x -le y x menor o igual que y
x -eq y x igual que y
x -ge y x mayor o igual que y
x -gt y x mayor que y
x -ne y x no igual que y

Comprobacion de atributos de fichero

Operador Verdad (TRUE) si:

------------------------------------------
-d fichero fichero existe y es un directorio
-e fichero fichero existe
-f fichero fichero existe y es un fichero regular (no un
directorio, u otro tipo de fichero especial)

-r fichero Tienes permiso de lectura en fichero

-s fichero fichero existe y no esta vacio
-w fichero Tienes permiso de escritura en fichero
-x fichero Tienes permiso de ejecucion en fichero (o de busqueda
si es un directorio)

-O fichero Eres el dueño del fichero

-G fichero El grupo del fichero es igual al tuyo.

fichero1 -nt fichero2 fichero1 es mas reciente que fichero2

fichero1 -ot fichero2 fichero1 es mas antiguo que fichero2

Operadores lógicos && y ||

Además de los anteriores, existen los operadores lógicos && (AND, multiplicación lógica)
y || (OR, suma lógica):

$ true && true ; echo $?

$ true || false ; 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
bloque de comandos b1
else
bloque de comandos b2
fi

Práctica: 'ej06.sh':

#!/bin/bash
# Sentencia de comparación IF simple
# Llamada: ./ej06.sh (nos pedira un numero)
clear
read -p "Adivina el numero que pienso : " num
if [ $num -eq 5 ]
then
echo "Has acertado, el número era el $num"
fi

Práctica: 'ej07.sh':

#!/bin/bash
# Sentencia de comparación IF con ELSE
# Llamada: ./ej07.sh (nos pedirá un numero)
clear
read -p "Adivina el número que pienso : " num
if [ $num -eq 5 ]
then
echo "Has acertado, el número era el $num"
else
echo "Lo siento. No has acertado"
echo "Otra vez será"
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 ejecutarán para un determinado patrón y
"esac" es el fin de la sentencia case.

Práctica: 'ej08.sh':

#!/bin/bash
# Sentencia CASE: Ejemplo Menú de Opciones
# Llamada: ./ej08.sh
clear
echo "-------- M E N U -----------"
echo "[1] Listar archivos"
echo "[2] Ver directorio de trabajo"
echo "[3] Crear directorio"
echo "----------------------------"
echo
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;;
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:
# equivalente a seq 1 5
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