SCRIPTS EN LINUX

INDICE
1- Que es el shell script?...........................................................................
3
2- Cmo ejecutar un script?......................................................................
3
3- Cdigo de un script.................................................................................
4
Ejemplos....................................................................................... 5
3.1- Depuracin............................................................................ 6
3.2- Estructuras condicionales...................................................... 6
3.3- Operaciones algebricas........................................................ 9
4- Bucles FOR..............................................................................................
11
5- Bucles WHILE..........................................................................................
13
5.1- Comando test........................................................................ 13
5.2- While..................................................................................... 15
5.3- Until...........................................................................................................
17
6- Parametros posicionales........................................................................
18
7- IFS Delimitador.......................................................................................
19
8- Arrays.....................................................................................................
20
9- Funciones...............................................................................................
21
10- Leer un fichero.......................................................................................
23
11- Creacin de demonios...........................................................................
24
11.1- Ejecutar un demonio o script sin contrasea.....................
27
12- Uso del Cron........................................................................................... 27
13- Colores en la consola.............................................................................
29

CREACIN DE SCRIPTS EN LINUX

Definicin de Script: Un script es un archivo que incluye un conjunto de
comandos. Son ejecutados desde la primera lnea hasta la ltima (de forma
secuencial).
1- QU ES EL SHELL SCRIPT?
Un Shell Script es un script para la shell de comandos (terminal). Para crear un
script vasta con un editar un fichero nuevo y en el nombre poner .sh Ejemplo:
HolaMundo.sh
Un vez creado, empezamos a editarlo. Se puede utilizar un editor de textos grfico
como gedit o un editor en terminal como vim, nano o emacs.
En la primera lnea del script se debe indicar que shell que vas a usar (
/bin/bash/, /usr/bin/perl , etc ) Aunque da igual la que uses lo importante es el
contenido:
#! /bin/bash
#! Se conoce con el nombre de Sha Bang.
Se denomina sha-bang a la secuencia #! con la que se inician los scripts. Su
funcin es indicarle al sistema que se trata de un conjunto de comandos para que
sean interpretados. En realidad, es un nmero mgico de dos bytes. El nmero
mgico es un marcador especial para indicar el tipo de archivo, en este caso,
indica que se trata de un script de shell ejecutable.
Para introducir comentarios se debe poner #. Por cada linea que deseis poner un
comentario, lo primero que debe tener es #. Es importante aadir comentarios
comentando la utilidad del script o las variables que se crean.
2- CMO EJECUTAR UN SCRIPT?
Antes de poder ejecutarlo, debemos darle permisos de ejecucin. (+x) por ello,
haremos uso del comando chmod y damos permisos de ejecucin, si se desea,
se pueden dar a todos los usuarios y grupos.
chmod 755 /ruta_del_script Para el usuario propietario
chmod 777 /ruta_del_script Para cualquier usuario

Una vez hecho todo lo anterior, usaremos:

./nombredelscript.sh
Pero tambin podemos usar si es un shell script:
sh nombredelscript.sh
3- CDIGO DE UN SCRIPT
Ya tenemos el script creado, le hemos puesto la cabecera y le hemos cambiado
los permisos, ya solo falta meter el cdigo.
Vamos a empezar desarrollando lo esencial para ir desarrollando estructuras ms
complejas:
Lo primero es saber cmo dar valor a una variable. Es tan sencillo como poner:
nombre_variable=valor
Si deseas guardar la salida de un programa solo tienes que ponerlo entre tildes
invertidas:
nombre_variable=`comando`
Tambien hay un comando que lee por teclado las variables ( read ). Para ponerlo:
read [opciones] nombre_variable1 nombre_variable2 nombre_variableN
ejemplo:
read -p Introduce el nombre y los apellidos nombre apellidos
Tiene un montn de opciones pero estas son las ms importantes y usadas:
Opcin
-n num_car

Explicacin
Nmero mximo de caracteres que puedes introducir por
teclado

Opcin

Explicacin
Muestra por pantalla una frase para tu saber que debes
-p frase
introducir
Especificas cual va a ser el delimitador, es decir si dices
que el delimitador sera ; pues todo lo que venga antes
-d delimitador de un ; lo coger una variable y todo lo que venga
despus de ese delimitador hasta el prximo ; lo coger
otra variable.
Cuando queremos utilizar el valor de una variable en el cdigo, nos referiremos a
ste como:
$nombre_variable
EJEMPLOS 1
Estos son algunos de los ejemplos de esta primera parte. Para ejecutarlos slo
hay que crear un archivo .sh y copiar las letras negras, lo azul es la sugerencia
para el nombre del script.
A lo largo de los ejemplos se introducen algunos comandos bsicos de Linux.
HolaMundo.sh
#! /bin/bash
clear
echo Hola mundo ,este es mi primer script
ScriptUno.sh
#! /bin/bash
clear
nombre=Perico
apellidos=Palotes
echo Te llamas $nombre $apellidos
Fecha.sh
#! /bin/bash
clear
fecha=`date | cut -d -f 1,2,3`
hora=`date | cut -d -f 4`
echo Hoy es $fecha y son las $hora

OtroScript.sh
#! /bin/bash
clear
# IFS es una variable de entorno que determina el delimitador de
#campos
# (que por defecto vale ),en este script queremos
# cambiarlo a , para escribir por teclado nombre,apellidos
IFS=,
read -p Introduce el nombre,apellidos : nombre apellidos
echo El nombre es $nombre y los apellidos son $apellidos

3.1- Depuracin
Depuracin de programas es el proceso de identificar y corregir errores de
programacin.
En ingls se le conoce como debugging, ya que se asemeja a la eliminacin de
bichos (bugs), manera en que se conoce informalmente a los errores de
programacin. Se dice que el trmino bug proviene de la poca de las
computadoras de bulbos, en las cuales los problemas se generaban por los
insectos que eran atrados por las luces y estropeaban el equipo.
Depurar el cdigo sirve para ver como se ejecuta paso por paso el script, que
valores toman sus variables, si has cometido un fallo saber en que parte del
cdigo ha sido, etc. No es algo que se deba hacer obligatoriamente por cada script
realizado (sera demasiado pesado) pero te facilita mucho a la hora de buscar el
problema que te surja.
Hay dos formas :
1. En la lnea #! /bin/bash -x | -v
2. En el comando sh
SINTAXIS:
sh [OPCIONES] [nombre_script]
Opcin
Explicacin
-x Para saber donde se produce un error en nuestro script. Muestra

Opcin

-n
-e
-v

Explicacin
las instrucciones antes de ejecutarlas por consola y sustituyendo
las variables
Chequea la sintaxis de nuestro script, (no lo ejecuta).
Obliga a finalizar el script en caso de que algun comando falle.
Muestra las lneas de entrada segn se leen sin sustituir las
variables.

3.2- Estructuras condicionales

Estructura bsica de una condicin if-else:
if condicion
then
comando1
comando2
...
comandon
else
comando1
comando2
...
comandon
fi
Como se ve la condicin si (if) se cierra con su correspondiente fi que al parecer
un juego de palabras es fcil de recordar.
Entonces si la condicin se cumple entrara por el then, en caso de que no, por el
else. Pero este es un mtodo simple, luego tenemos uno ms complejo con if
anidados, sera:

if condicion
then
instrucciones
elif condicion
then
instrucciones
elif condicion
then
instrucciones

fi
Ahora lo que hace es evaluar la condicin, si es verdadera entra por el
then, pero si no y se da el caso de otra condicin entrara por el elif, los
elif no se cierran, solamente el fi final corresponde a la apertura del if.
La condicin es cualquier cosa que de un return (que devuelva) algo
que sea 0 o verdadero.
Notese el uso del archivo /dev/null como archivo vaco para comprobar
algunascondicionales.
Vemos como podemos hacer un script para comprobar que realmente
la ruta es un directorio.
CompruebaDirectorio.sh
#! /bin/bash
clear
if `cd /tmp/prueba/ >/dev/null`
then
echo Pues si, es un directorio y contiene
ls -l
else
echo Pues no, no es un directorio
fi
Este script es un claro ejemplo de como comprobar si un usuario y un
grupo existen en el sistema, vemos tambin el uso que se le da al elif.
ExisteGrupoUsuario.sh
#! /bin/bash
clear
read -p Introduce usuario user
read -p Introduce grupo group
if `grep -e ^$user:.* /etc/passwd >/dev/null`
then
if `grep -e ^$group:.* /etc/group >/dev/null`
then
echo Usuario y grupo ya existen en el sistema
fi
elif `grep -e ^$group:.* /etc/group >/dev/null`
then
echo usuario no existe, grupo si!!
else
echo Ni grupo ni usuario existen
fi

Condicionales case
En esta estructura se compara palabra con caso1, caso2, etc., hasta encontrar la
que coincida, en la que se ejecutarn las instrucciones del caso. Si no se
encontrara ninguna, se pasara a la seccin *), que es opcional. Esta estructura
puede irnos muy bien cuando, por ejemplo, queramos que un determinado script
realice unas acciones u otras segn el parmetro que le pasemos. Los parmetros
los podemos referenciar a partir de $1 para el primero, $2 para el segundo y as
consecutivamente. Para los bucles podemos utilizar alguna de las siguientes
estructuras:
case palabra in
caso1)
instrucciones ;;
caso2)
instrucciones ;;
*)
instrucciones
esac
Para aquellos que sepan de programacin, funciona igual que los switch,
esta estructura sirve para dependiendo de la expresin se cumple un
determinado caso, es decir, segnsea el valor de esa expresin se har un
caso u otro. Esto se ve mejor con un ejemplo:
tecla.sh
#! /bin/bash
clear
read -n 1 -p Pulsa una tecla tecla
case $tecla in
[a-z,A-Z]) echo Ha introducido una letra ;;
[0-9]) echo Ha introducido un numero ;;
*) echo Ha introducido un caracter especial ;;
esac
Este script sirve para comprobar que tecla has pulsado, primero pide por
teclado la tecla que ser guardada en la variable tecla, y se usa en el case.
Si la tecla es una letra se har todos los comandos que hayan en el caso [ az,A-Z ]( ya que una letra puede ser cualquiera, hace falta abarcar a todas las
posibilidades por eso se pone el intervalo de a-z y A-Z ), si la tecla es un
nmero se har todos los comandos que haya en el caso [0-9 ]( ya que
puede ser cualquier nmero, hace falta abarcar a todas las posibilidades por
eso se pone el intervalo de 0-9 ) y si la tecla no es un nmero ni una letra, se
ejecutan todos los comandos del caso *.

Se pone el * cuando no se va a cumplir el resto de casos. Es muy importante

saber que las dobles comas ( ;; )se pone obligatoriamente al final de cada
caso ya que marcan el final de ese caso, sino el programa no funcionar.
Cuando hagis una condicional debis poner al final el esac ya que es el
cierre del case. Se suele utilizar mucho esta estructura para mostrar un
men al usuario. Ejemplo:
ejmploMenu.sh
#! /bin/bash
clear
echo 1.Ejemplo de menu uno
echo 2.Ejemplo de menu dos
read -n 1 -p Introduce una opcion opcion
case $opcion in
1) exit 1 ;;
2) exit 2 ;;
*) echo No has introducido ni un dos ni un uno ;;
esac
Tener que poner tantos echo es bastante molesto, por eso hay un comando
que te ahorra hacer ese esfuerzo (select):
select variable in caso 1 caso 2 caso N
do
break
done
case $variable in
"caso 1") comandos ;;
"caso 2") comandos ;;
"caso N") comandos;;
Esac
El break sirve para que solo te muestre una vez el men. Cuando usas
select no hace falta pedir que introduzcas nada, ya que eso lo hace
automticamente. El prompt que te muestra select es #? pero se puede
cambiar, poniendo otro valor a PS3. Por ltimo veamos el ejemplo anterior
con select:
ejemploMenu.sh
#! /bin/bash
clear
PS3=Introduce una opcion
select opcion in 1.Ejemplo de menu uno 2.Ejemplo de menu
dos
do

break
done
case $opcion in
1) exit 1 ;;
2) exit 2 ;;
*) echo No has introducido ni un dos ni un uno ;;
esac
3.3-

Operaciones algebraicas

Uso de expr el cual utilizaremos en multitud de ocasiones para hacer

operaciones aritmticas, u operaciones con cadenas y un sinfn de cosas
expr operacin_a_evaluar
1.Operaciones numricas:
expr num1 + num2
expr num1 - num2
expr num1 * num2
expr num1 / num2
expr num1 >= num2
expr num1 > num2
expr num1 <= num2
expr num1 < num2
expr num1 != num2

> Devuelve la suma de num1 + num2

> Devuelve la resta de num1 - num2
> Devuelve el producto de num1 * num2
> Devuelve la divisin de num1 / num2
> Devuelve 0(true) si num1 >= num2
> Devuelve 0(true) si num1 > num2
> Devuelve 0(true) si num1 < num2
> Devuelve 0(true) si num1 < num2
> Devuelve 0(true) si num1 es distinto de num2

ExprEjemplo.sh
#! /bin/bash
clear
PS3=Introduce Opcin:
select opcion suma resta
do
break
done
read -p Introduce dos nmeros num1 num2
case $opcion in
suma)
echo La suma de $num1 y $num2 es `expr $num1 + $num2` ;;
resta)
echo La resta de $num1 y $num2 es `expr $num1 - $num2` ;;

esac
2.Operaciones con cadenas:
.
expr length cadena > N de caracteres de esa cadena

expr index cadena_donde_busca cadena_a_buscar > Devuelve la

posicin donde encuentra los caracteres a buscar dentro de la cadena, si
no, devuelve un 0.
ExprEjemplo2.sh
#! /bin/bash
clear
frase=Buenos das, estamos aprendiendo a programar
echo La longitud de la cadena es `expr length $frase`
read -p Introduce alguna cadena que buscar buscar
if [ ! -z $buscar ]
then
echo Los caracteres $buscar se encuentran en la pos `expr index
$frase $buscar`
fi

3.expr match cadena_donde_busca patrn_caracteres_buscar >

Funciona igual que el index pero los caracteres pueden ser una expresin
regular
ExprEjemplo3.sh
#! /bin/bash
clear
frase=Buenos das, estamos aprendiendo a programar
echo La longitud de la cadena es `expr length $frase`
read -p Introduce alguna cadena que buscar buscar
if [ ! -z $buscar ]
then
echo Los caracteres $buscar se encuentran en la pos `expr match
$frase [a-z,A-Z]*$buscar` de la frase
fi

expr substr cadena posicin n_caracteres > Extrae de una cadena una
subcadena de la cadena indicada a partir de esa posicin y de longitud
ese nmero de caracteres.
ExprEjemplo4.sh
#! /bin/bash
clear
read -n 9 -p Introduce tu NIF (FORMATO: 00000000A) nif
echo El DNI de $nif es `expr substr $nif 1 8`
echo La letra del $nif es `expr substr $nif 9 1`
Instrucciones iterativas (Bucles)

Los bucles son procesos de repeticin iterativa Los bucles son un tipo de
estructuras de programacin (algoritmos) tremendamente tiles, que realizan
una serie de comportamientos repetitivos (iterativos) mientras o hasta que se
cumpla la condicin. Esto hace que ahorremos muchas lneas de cdigo,
entre otras cosas: orden, estructuracin, etc.
Esta tcnica tambin es denominada rizo o looping. Su homologo en
MSDOS seria el GOTO y sus etiquetas, que cumplira la misma funcin, con
la nica diferencia es que el GOTO por lo normal esta mal visto en la
programacin estructurada, debido a que se "pierde" la estructuracin
secuencial del algoritmo del programa. En Linux contamos con verdaderas
sentencias de control para el uso de bucles , son las siguientes:
Bucles for
El bucle se ejecuta para cada uno de los valores que toma la variable en esa
lista.
for variable in valor1 valor2 valorN
do
comando1

[ break | continue ]
Done
Break: Rompe el bucle y no da ms opcin a que la variable se ejecute.
Continue: Salta al siguiente valor de la lista.
Planetas.sh
#! /bin/bash
clear
for planeta in "Jupiter 10" "Venus 30" "Saturno 15" "Mercurio 1" Luna Tierra
do
if [ "$planeta" = Tierra ]
then
break
elif [ "$planeta" = Luna ]
then
continue
else
echo "El planeta "$planeta"0.000.000 Km del Sol"
fi
done
echo "fin del script"

Y su ejecucin sera:
El planeta Jpiter 100.000.000 Km del Sol

El planeta Venus 300.000.000 Km del Sol

El planeta Saturno 150.000.000 Km del Sol
El planeta Mercurio 10.000.000 Km del Sol
fin del script
En continue puedes especificar el bucle en el que quieres que la variable
salte, hablo de bucles anidados. Por defecto, poner continue es como
poner continue 1, la variable del actual bucle salta al siguiente valor, veamos
un ejemplo de ello:
PlanetasBacteria.sh
#! /bin/bash
clear
for planeta in Venus Saturno Jupiter Tierra Luna Sol Marte
do
for bacterias in Pepito Anemo Coli Streptos
do
if [ "$planeta" = "Tierra" ]
then
exit 45
elif [ "$bacterias" = "Pepito" ]
then
echo "El planeta $planeta tiene la bacteria .... $bacterias"
continue 2
else
echo "El planeta $planeta tiene la bacteria .... $bacterias"
fi
done
done

El resultado de su ejecucin sera:

El planeta Venus tiene la bacteria .... Pepito
El planeta Saturno tiene la bacteria .... Pepito
El planeta Jpiter tiene la bacteria .... Pepito
Otra de las particularidades de este bucle es que puede ejecutarse a la
forma de un bucle en java
(( valores ))
for(( variable=valor; condicin; incremento ))
do
comando
...
[ break | continue ]
...
done

Es igual que en java pero con doble parntesis.

Contador.sh
#! /bin/bash
clear
read -p "Introduce un numero " numero
for(( a=0; a <= $numero; a++ ))
do
echo -e "$a \n"
done
HacerPing.sh
#! /bin/bash
clear
read -p "IP registradas en la red (1,32,33,35,37)? " aula
echo
if [ $aula -eq 1 -o $aula -eq 32 -o $aula -eq 35 -o $aula -eq 37 ]
then
for(( equipo=1; equipo <= 254; equipo++ ))
do
buscar=`ping -n 1 192.168.$aula.$equipo | grep "milisegundos"`
if [ -n "$buscar" ]
then
#
echo La IP 192.168.$aula.$equipo no es de la red 192.168.$aula
#
else
echo La IP 192.168.$aula.$equipo " " es de la red 192.168.$aula
fi
done
else
echo "Valor incorrecto"
exit 1
fi

5- BUCLES WHILE
Antes de aprender a hacer un script utilizando los bucles while, debemos
conocer el funcionamiento del comando test, pues es muy usado en este tipo
de bucles.
5.1- Comando test
Este comando sirve para expresar condiciones y evaluarlas, si son correctas
origina cdigos de salida = 0 y si son falsas = 1
El comando pretende abreviar un poco en algunos casos, por eso se suele
utilizar su forma corta:
test expresiones > [ expresin ]

Hay que tener en cuenta que la forma es:

[(espacio)expresin(espacio)]
Ya que si no se ponen los espacios en blanco dara lugar a error.
Un ejemplo de su uso:
test -f /home/alumno && echo Existe directorio
La salida sera:
Existe Directorio
En la forma resumida se puede escribir:
[ -f /home/albertjh/googleearth ] && echo fichero existe
fichero existe
Expresiones test
Estas son algunas de las ms comunes:
Comprobacin directorios:
-f /ruta/nombre
-l /ruta/nombre
-d /ruta/
-x /ruta/nombre
-u /ruta/nombre
-g /ruta/nombre
-s /ruta/nombre

> Comprueba si es un fichero normal

> Comprueba si es un enlace suave
> Comprueba que existe el directorio
> Comprueba si es un ejecutable
> Comprueba si tiene activados los permisos suid
> Comprueba si tiene activados los permisos sgid
> comprueba que su tamao es mayor a 0

Comprobacin de cadenas:
cadena = cadena2
-z cadena
-n cadena
cadena != cadena2

> Comprueba si son iguales

> Comprueba si est vaca
> Comprueba si tiene informacin
> Comprueba que son diferentes

Comprobacin de expresiones numricas:

exp -eq exp2
exp -ge exp2
exp -ne exp2
exp -gt exp2

> Comprueba si son iguales

> Comprueba si exp >= exp2
> Comprueba si exp distinto de exp2
> Comprueba si exp > exp2

exp -le exp2

exp -lt exp2

> Comprueba si exp <= exp2

> Comprueba si exp < exp2

Para concatenar expresiones a evaluar:

-o
-a
!

= OR
= AND
= NOT

Algunos ejemplos del uso de test:

numeros.sh
#! /bin/bash
clear
IFS=","
read -p "Introduce dos numeros separados por comas " num1 num2
if [ $num1 -eq $num2 ]
then
echo "Los nmeros son iguales"
elif [ $num1 -gt $num2 ]
then
echo "El $num1 > que $num2"
elif [ $num1 -lt $num2 ]
then
echo "El $num1 < que $num2"
fi

BuscaFich.sh
#! /bin/bash
clear
read -p "Introduce directorio a buscar... " direct
read -p "Nombre de fichero a buscar... " nombre
if [ ! -d $direct ]
then
echo "$direct no existe"
else
find $direct -name "$nombre"
fi
5.2- While
Las instrucciones se realizaran mientras (la condicin se cumpla). Cuando
se deje de cumplir, el bucle se saldr y finalizara. La condiciones que se
pueden poner en el while son con el comando test , poniendo un true
( poniendo un true en el while se crea un bucle infinito) o poner un comando

con comillas invertidas. El break se pone solo si quieres salir bruscamente

del bucle. El while se estructura de la siguiente forma:
while condicion
do
instruccin1
instruccin2
.....
break
done
Calculadora.sh
#! /bin/bash
clear
opcion=2
while [ $opcion -ne 5 ]
do
echo "1.suma"
echo "2.resta"
echo "3.multiplicacion"
echo "4.division"
echo "5.salir"
echo
read -n 1 -p "Introduce una opcion " opcion
case $opcion in
1) read -p "Introduce el 1 numero " numero1
read -p "Introduce el 2 numero " numero2
echo "El resultado es `expr $numero1 + $numero2`" ;;
2) read -p "Introduce el 1 numero " numero1
read -p "Introduce el 2 numero " numero2
echo "El resultado es `expr $numero1 - $numero2`" ;;
3) read -p "Introduce el 1 numero " numero1
read -p "Introduce el 2 numero " numero2
echo "El resultado es `expr $numero1 '*' $numero2`" ;;
4) read -p "Introduce el 1 numero " numero1
read -p "Introduce el 2 numero " numero2
echo "El resultado es `expr $numero1 '/' $numero2`" ;;
esac
echo
done
Este script funciona como una calculadora, posee 5 opciones (suma, resta,
multiplicacin, divisin y salir), nos interesa que podamos realizar tantas
veces como queramos cualquier clculo hasta que pulsemos un 5 por lo
tanto es necesario una estructura repetitiva. El 5 es para salir por lo tanto el
bucle se repetir hasta que la variable opcion valga 5 ( es decir, cuando
introduzcas por teclado un 5 ) por eso hay que usar el comando test

( [ $opcion -ne 5 ] ) , cuando eso ocurra ya no se cumple la condicin del

while y el programa finaliza
Si en el while vas a poner una variable, debe declararse antes ya que sino
no entra, darle cualquier valor. Si no se le da valor antes, la variable no
valdr nada (en el ejemplo anterior hubiera fallado ya que ests diciendo que
se hace el bucle mientras no sea igual a 5, sin embargo al dar valor a la
variable opcin antes del while, entra)
BucleInfinito.sh
#! /bin/bash
clear
while true
do
read -p "Introduce la palabra fin para salir del bucle " fin
if [ "$fin" = "fin" ]
then
exit 2;
fi
done
Este script es un ejemplo de como hacer un bucle infinito, hasta que no
escribas un fin, no saldr del programa.
BucleInfinito1.sh
opcion=0
while [ $opcion -ne 4 ] || [ $opcion -ne 0 ]
do
clear
echo "Menu (selecciona un editor)"
echo "1-vi"
echo "2-emacs"
echo "3-joe"
echo "4-Salir"
echo
echo -n "Introduzca una opcion: "
read opcion
case $opcion in
1)echo "Ejecutando editor VI";Vi;;
2)echo "Ejecutando editor emacs";emacs;;
3)echo "Ejecutando editor joe";joe;;
4)echo "Fin de programa";exit;;
*)echo "Opcion no valida";;
esac
done

Aqu vemos de forma clara el funcionamiento de la sentencia while (bucle) y

el case (ifs anidados). Si no se comprende el algoritmo en su primer vistazo,
seria bueno que lo probase en su ordenador y comprobar su funcionamiento.
Lo que hace este programilla, es preguntar por el editor que se desea usar
en LINUX. Usted introduce un numero y este es almacenado en la variable
"opcin". Si introduce un 1, ejecuta el VI, si es un 2 ser el emacs, y si es un
3 se tratara del joe. Si el usuario pulsa el 4 o el numero 0, automticamente
sale del case y llegara al done puesto que la condicin no se cumplir.
Con el while se puede leer lnea por lnea un fichero, para ello lo nico que
hay que hacer es poner un redireccionamiento de entrada en el done con la
ruta del fichero que queremos leer ( esto es muy til, ya que puedes crear
usuarios a partir de un fichero, etc. Tan solo tenis que poner done <
/ruta_fichero ).
LecturaFichero.sh
#! /bin/bash
clear
numLinea=0
linea="nada"
while [ ! -z "$linea" ]
do
read linea
if [ ! -z "$linea" ]
then
numLinea=`expr $numLinea + 1`
echo "$numLinea. $linea"
fi
done < /etc/passwd
La funcin de este script es enumerar las lineas del fichero /etc/passwd,
leer lnea por lnea hasta que encuentre una lnea que est vaca, cuando
la encuentre dejar de leer el fichero, a pesar de que haya o no ms lneas
despus de la lnea en blanco (aunque como es el fichero de los usuario
registrados en el sistema, la nica lnea en blanco que habr ser la ltima
del fichero ). Se debe tener en cuenta que antes del bucle se ha inicializado
la variable lnea.
5.3- Until
Las instrucciones se ejecutan hasta (until) que la conduccin se cumpla.
Seria el bucle inverso al while. La estructura repetitiva until es de la siguiente
forma:
until condicion

do
instruccin1
instruccin2
.....
break
done
La estructura until se usa para repetir un conjunto de comando hasta que se
cumpla la condicin, cuando se cumple el script sale del until. Las
condiciones y el break es lo mismo que en el while, si se usa una variable
en el until se debe declarar antes.
until.sh
#!/bin/bash
cont=5
until [ $cont -lt 1 ];
do
echo Vuelta numero : $cont
let cont=cont-1
done
Este script recorre un contador desde 5 hasta 1, indicando en cada
iteracin, en la vuelta que nos encontramos.
Vuelta
Vuelta
Vuelta
Vuelta
Vuelta

numero
numero
numero
numero
numero

:
:
:
:
:

5
4
3
2
1

listar_for.sh
#!/bin/sh
#
echo "---------- BUCLE TIPO FOR -----------"
var=1
for f in $(ls /etc/*.conf)
do
echo linea de salida $var: $f
var=`expr $var + 1`
done
Este script lista el directorio, utilizarlo como entrada y mostrarlo lnea a lnea.

mibackup.sh
#!/bin/sh
#
echo "---------- Captura fecha -----------"
fecha=$(date +%Y%m%d)
#
echo "---------- Haciendo Tar -----------"
tar cvf backup$fecha.tar $HOME/Documentos $HOME/Descargas
#
echo "----------- Comprimiendo -----------"
zip backup$fecha.tar.zip backup$fecha.tar
#
echo "---------- Envindolos a zip -------"
cp ./backup$fecha.tar.zip tmp/
#
echo "----------- Limpiando --------------"
rm -f ./backup$fecha.tar
rm -f ./backup$fecha.tar.zip
#
echo "----------- Final
-------------"
Este script realiza un backup de solo ciertos directorios (Documentos y
Descargas), luego los comprime usando zip y los envia a un area de
almacenamiento (unidad previamente montada en /mnt/zipdrive, unidad de
RED previamente montada en /mnt/red, etc), y adems con que el nombre
del archivo contenga la fecha del da
6- PARMETROS POSICIONALES
Se denominan parmetros posesinales porque preceden y son gestionados
de acuerdo a su posicion.
Forma de ejcutar los parmetros posicionales
$ ./Script valor1 valor2 ... valorN
Los parmetros posicionales son valores que se le pasan al script desde la
lnea de comandos cuando se ejecuta y que le permite al programa operar
con ellos. Se numeran en orden del 1 al 12, pero a partir del 10 hay que
encerrarlo entre llaves, ej. ${11}
VariablesParametros.sh

echo
echo
echo
echo
echo
echo

"Parametro 1: $1"
"Parametro 2: $2"
"Parametro 3: $3"
"Todos los parmetros pasados son: $*"
"El numero de parmetros pasados es: $#"
"El nombre del script (parmetro 0) es: $0"

Ejecutemos con
./VariablesParametros.sh Medellin Antioquia Colombia
Dentro del script podramos operar con estos parmetros puesto que son
almacenados en variables del tipo: $n . Con lo que la variable $1 devolvera
el primer parmetro dado al script, Medellin, $2 daria Antioqiuia, y $3
Colombia.
Variables-Parametoros
Variables-Parametoros
Opcin
Explicacin
$1-$9 Parametros posesinales. Muestra el contenido de las variables
$* Recupera todos los parametros pasados.
$# Recupera el numero total de parmetros que se le pasan al script.
$0 Recupera el nombre del script.
BorrarFicheroParametros.sh
#! /bin/bash
# Al ejecutar como 1 parmetro un directorio, 2 como fichero a
borrar
clear
if [ $# -ne 2 ]
then
echo "Debes ejecutarlo asi: $0 directorio nombreFichero";
exit 65
elif [ ! -d $1 ]
then
echo "El parmetro 1 no es un directorio!! "; exit 65
elif [ ! -f $1/$2 ]
then
echo "El parmetro 2 no es un fichero!"; exit 65
else
echo "Borrando el fichero... "
rm -fi $1/$2
fi

Vamos comprobando poco a poco si es un directorio correcto, si lo es,

pasamos a comprobar el fichero, y si lo es lo borramos.
ParametrosBucle.sh
#! /bin/bash
clear
if [ ! -d $1 ]; then
echo "Directorio no existe"; exit 65
else
for fichero in `ls $1`
do
echo $fichero
if [ -f $1/$fichero ]; then
echo $1/$fichero es un fichero
rm -fi $1/$fichero
fi
done
fi
Shift
Este comando desplaza los elementos a la izquierda, lo que hace que el
primero y se pierda, un ejemplo:
ParametrosBucleShift.sh
#! /bin/bash
clear
while [ $1 != ]
do
echo $1 $2 $3 $4 $5 $6 $7 $8 $9 ${10} ${11} ${12}
shift
done
./ParametrosBucleShift.sh 1 dos tres 4 5 seis siete 8 nueve 10 11 Doce

El resultado es curioso, sera el siguiente:

1 dos tres 4 5 seis siete 8 nueve 10 11 doce
dos tres 4 5 seis siete 8 nueve 10 11 doce
tres 4 5 seis siete 8 nueve 10 11 doce
4 5 seis siete 8 nueve 10 11 doce
5 seis siete 8 nueve 10 11 doce
seis siete 8 nueve 10 11 doce
siete 8 nueve 10 11 doce

8 nueve 10 11 doce
nueve 10 11 doce
10 11 doce
11 doce
doce

8- ARRAYS
Las arrays de los script funcionan de la misma forma que los
arrays de cualquier lenguaje de programacin. Una array es un conjunto o
agrupacin de valores cuyo acceso se realiza por ndices, en un script se
puede almacenar en un mismo array todo tipo de cosas, nmeros, cadenas,
caracteres, etc.
En las arrays el primer elemento que se almacena lo hace en la posicin 0
(en el ejemplo seria Paco). En los script no hace falta declarar el tamao de
la array, puedes insertar tantos valores como desees. Para declarar una
array es:
declare -a nombre_array
declare -a nombres
La opcin -a sirve para decir que lo que vas a declarar es una array.
Para darle valores se puede hacer de dos formas:
1. Darle valores posicin por posicin.
nombre_array[posicion]=valor
nombres[3]=Manolo
2.Darle todos los valores de golpe ( aunque tambin se puede decir la
posicin deseada en la que quieres guardar uno de los valores ).
nombre_array=( valor1 valor2 valor3 [posicion]=valor4 .... valorN )
nombres=( Maria Alberto Rodrigo [7]=Paco )

Para ver el contenido de la array en una posicin:

${nombre_array[posicion]}
${nombres[0]}
Para saber cuantos elementos contiene la array:

${#nombre_array[*]}
${#nombres[*]}
Para recuperar todos los elementos de una array:
${nombre_array[*]}
${nombres[*]}
A continuacin un ejemplo de arrays:
arrays.sh
#! /bin/bash
clear
contador=0
declare -a usuario=( Alberto John Roberto Laura Sergio Cristian
Dani )
for valor in ${usuario[*]}
do
echo "El usuario $contador vale $valor"
contador=`expr $contador + 1`
done

9- FUNCIONES
En el mbito de la programacin, una funcin es un tipo subalgoritmo, es el
trmino para describir una secuencia de rdenes que hacen una tarea
especfica de una aplicacin ms grande.
Es la forma en la que ms me gusta programar, modulando todo en partes
pequeas para despus obtener una mayor, con lo cual el programar algo se
hace fcil y divertido.
function nombreFuncion (){
comando1
comando2 .........
[ return codigoSalida ]
}
Tambin se especifica sin poner function, pero puede llegar a dar problemas
as que se recomienda ponerlo.

El cdigo de salida especificado por un return es el cdigo de salida del

resultado de la ejecucin de todos los comandos en la funcin. Si no se
especifica un return devolver el de la ltima salida de esa funcin.
Dentro de una funcin se pueden definir variables locales (solo reconocidas
por esa funcin) y se especifican as:
local nombreVariable
Importante, las funciones se declaran al principio de los scripts!
sumaFuncion.sh
#! /bin/bash
clear
function suma() {
local resultado
read -p "Introduce el primer numero: " num1
read -p "Introduce el segundo numero: " num2
resultado=`expr $num1 + $num2`
return $resultado
}
#Cuerpo del script
echo "Llamo a la funcion suma"
suma
echo "El resultado es $?"
En el paso de parmetros en una funcin no se pueden definir como en otros
lenguajes las variables que le pasas dentro de los parntesis, sino que se
pasan los valores ponindolos a continuacin del nombre de la funcin:
nombreFuncion valor1 valor2 valor 3 ...
Dentro de una funcin esos valores se recogen como:
valor1=$1 valor2=$2 ...

#! /bin/bash
clear
function suma() {
local resultado
resultado=`expr $1 + $2`
return $resultado

}
#Cuerpo del script
read -p "Introduce el primer numero: " num1
read -p "Introduce el segundo numero: " num2
echo "Llamo a la funcion suma"
suma $num1 $num2
echo "El resultado es $?"

13- COLORES EN LA CONSOLA

Tenemos varios tipos de colores, se distinguen por background (el fondo) y
foreground (las letras). Esto se puede hacer metiendolo en variables o a
mano.
Segn la secuencia de escape ANSI, podemos cambiar el color del
background con \033[x;4xm y el foreground con \033[x;3xm
\033 indica la marca de escape ANSI y lo siguiente es la secuencia de
colores.
La lista de los posibles colores vara segn la terminal y el entorno grfico,
pero por defecto son:
Negro
Azul
Verde
Cyan
Rojo
Purpura
Marron
Gris claro
Blanco

0;30
0;34
0;32
0;36
0;31
0;35
0;33
0;37
1;37

Gris
Azul
Verde
Cyan
Rojo
Purpura
Amarillo

oscuro
claro
claro
claro
claro
claro

1;30
1;34
1;32
1;36
1;31
1;35
1;33

Los colores ms intensos empiezan por cero: [0-9];xx , al igual que los
colores que son x;x[0-9] esto solo es una pequea demostracin de colores.
Sin embargo la cadena de intensidad de colores tiene una pequea
curiosidad:
0
1y6
2y8
3
4

es intenso
es normal
es color de fondo de la bash (oculto)
negativo
inverso

5
7

parpadeante
intercambio de foreground por background

Pero en consolas grficas:

1y4
6
7
8

subrayado
tachado
inverso
oculto

Existe el problema de que cuando se pone un color, al terminar

la secuencia todo lo dems se queda de ese color si no se sustituye por otro,
para que esto no ocurra podemos recurrir a poner al final del todo un: \
033[0m as quedar el color de la consola inicial.
As pues sabiendo esta tabla de valores, podemos escribir un par de lneas:
$ PS1="\[\033[1;34m\][\u@\h:\w]$\[\033[0m\] "
[usuario@sunny02:~]$
Como puedes ver se ha cambiado el prompt por el color azul. Pero tambin
se puede combinar con el fondo de esta manera:
$ PS1="\[\033[44;1;31m\][\u@\h:\w]$\[\033[0m\] "
De esta forma podemos poner las letras rojas y el fondo azul. Utilizando
esto, podemos crear scripts con colores y que queden muy vistosos.
Recordar que para hacer echos poniendo las secuencias de escape, deben
utilizar la opcin -e
Un ejemplo muy curioso, que combina colores con un sleep, para hacer
creer al usuario que est cargado algo y que sale ok:
#! /bin/bash
clear
echo "CARGANDO, ESPERE POR FAVOR"
echo ""
for (( j=1; j<=10; j++ ))
do echo -e "EJEMPLO $j \c"
for (( i=0; i<=30; i++ ))
do echo -e "\033[0;34m.\c"
sleep 0.05
done
echo -e "\c"

echo -e "\t\033[0 32m [OK]\033[0m"

done
echo "\033[0;32mCARGADO CON EXITO\033[0m"
CARGANDO, ESPERE POR FAVOR
EJEMPLO 1 . [OK]
EJEMPLO 2 . [OK]
EJEMPLO 3 . [OK]
EJEMPLO 4 . [OK]
EJEMPLO 5 . [OK]
EJEMPLO 6 . [OK]
EJEMPLO 7 . [OK]
EJEMPLO 8 . [OK]
EJEMPLO 9 . [OK]
EJEMPLO 10 [OK]
CARGADO CON XITO