Uso y programación de bash, Parte II.

9. Nuestro primer script.

10.Comentarios.

11.Escritura de la salida estandar.

12. Lectura de la entrada estandar.

13.Operaciones aritméticas.

14.La sentencia if-then-else-fi.

15.El comando test.

16.La sentencia case.

17.La sentencias while y until.

18.La sentencia for.

19.Funciones

20.Despedida de la segunda parte.

9. Nuestro primer script.

Un programa es un conjunto ordenado de instrucciones que realizan
una tarea especifica, en el caso de bash, cada instrucción ejecuta
un comando.

Las tareas para las cuales se utilizan los scripts es bash son
generalmente para mejorar la interfaz de un programa con el usuario.

Nuestro script en bash será un simple archivo de texto,
lo crearemos con el editor que mas nos guste, puede ser vi, pico, joe,
etc, luego ese archivo será leído por bash y lo interpretara
de a una linea por vez.

Cada instrucción de un script en bash debe estar separada
de las demás mediante un carácter de nueva linea (ENTER)
o un punto y coma (;).

Veamos un ejemplo muy sencillo:

Si queremos ver la puertos TCP abiertos, lo podemos realizar
con el comando:

# netstat -a | grep \" LISTEN \"

Para no tener que escribir ese comando a menudo, creamos
un script en bash que lo haga por nosotros.

# cat > puertos
netstat -a | grep \" LISTEN \"
exit 0
CTRL-D
#

CTRL-D es la pulsación de las dos teclas simultáneamente,
esto le indica un \"fin de archivo\" al comando cat.

Si el script es muy largo no es recomendable escribirlo de esta
forma, conviene utilizar un editor de texto.

El comando exit nro. se utiliza para retornar
un valor al proceso padre, que en este caso es el interprete bash donde
ejecutamos el comando, de esta manera el interprete puede leer este valor
de retorno y saber si su ejecución fue exitosa. Normalmente cuando
un programa se ejecuta exitosamente retorna un cero y cuando no pudo realizar
su tarea por algún motivo retorna un valor distinto de cero, este
tema se vera mas adelante detalladamente.

Ya creamos el script, ahora probemos.

# bash puertos
tcp 0 0 *:printer *:* LISTEN
tcp 0 0 *:www *:* LISTEN
tcp 0 0 *:6000 *:* LISTEN
tcp 0 0 *:telnet *:* LISTEN

Para hacer correr el script escribimos bash seguido del nombre
del script, también podemos marcar el archivo como ejecutable y
no habrá que escribir bash delante, de esta manera otro usuario
de la PC ejecutara el script sin saber si es un script en bash, en otro
lenguaje o un binario ejecutable.

Lo marcamos como ejecutable:

# chmod 755 puertos

Lo ejecutamos como cualquier otro programa:

# ./puertos
tcp 0 0 *:printer *:* LISTEN
tcp 0 0 *:www *:* LISTEN
tcp 0 0 *:6000 *:* LISTEN
tcp 0 0 *:telnet *:* LISTEN

Ya tenemos nuestro primer script funcionando !! , aunque
no es muy útil que digamos, en seguida veremos que mediante scripts
en bash se pueden lograr programas muy interesantes.

10. Comentarios.

Existe una forma de poder agregar comentarios al script que nos
aclaren la forma en que funciona, si agregamos un \"#\",
bash ignorara todo lo que le siga hasta el final de la linea.

Hay muchos programadores que no ponen comentarios porque piensan
que es una perdida de tiempo, porque no aportan nada al funcionamiento,
pero es muy útil si por ejemplo, dentro de unos meses retornamos
al código para hacerle cambios, seguramente ya olvidamos muchos
detalles de como funcionaba, los comentarios nos harán recordar
y nos ahorrara mucho tiempo, pues sino tendríamos que ponernos a
investigar su funcionamiento.

También puede suceder que otro programador necesite hacerle
modificaciones, con los comentarios entenderá mas fácilmente
nuestro script para luego modificarlo.

Dicen que los buenos programadores comentan sus programas :))

Ejemplo:

$ cat puertos
#!/bin/bash
#######################################
# Lista los puertos TCP abietos. #
# Autor: ??? #
# creado: 15/7/00 #
#######################################
netstat -a | grep \" LISTEN \" # Se usa \" LISTEN \" en vez de
 # \"LISTEN\" para que no se vean
 # los sockets UNIX.
$

La primer linea del script ( #!/bin/bash ), indica
el path al interprete que se requiere para ser ejecutado, es importante
que sea la ubicación correcta, sino no se ejecutara.

Por ejemplo los scripts en Perl llevan la primer linea:
#!/usr/bin/perl

El comando file reconoce el tipo de script leyendo
esta linea.

$ file puertos
puertos: Bourne-Again shell script text

11. Escritura de la salida estandar.

La salida estandar. y la salida de error que genera cualquier comando
dentro del script, si no se redireccionaron, saldrán por la salida
estandar. del usuario que ejecuto el script, que es normalmente la pantalla.

Puede suceder que necesitemos comunicarle alguna acción
al usuario, para ello disponemos del comando echo, lo único
que hace es enviar sus argumentos a la salida estandar. y agregarle una
carácter de nueva linea al final.

$ echo \'Hola Mundo !!\'
Hola Mundo !!
$

Ejercicio: probar el comando: echo \"Hola Mundo !!\",
que sucede ?, porque pasa eso ?. Pista: ejecutar el comando: !!.

Sintaxis del comando echo:

echo [OPCIONES]... [CADENA] [CADENA]...

CADENA

Pueden ser mas de una CADENA de caracteres, serán impresos
uno a continuación de otro separados por un espacio. Si las CADENAS
de caracteres están separadas por mas de un espacio, bash se los
quitara, dejando una separación de solamente un espacio antes de
pasarle los argumentos al comando echo.

$ echo hola mundo
hola mundo

OPCIONES:

-n : No escribe el carácter final de nueva linea.

$ echo -n \"Prueba de echo.\"
Prueba de echo.$

-e habilita la interpretación de los caracteres especiales que se
explican mas abajo,

Caracteres especiales:

\\a

Alerta (bell).

\\b

Retroceso (backspace).

$ echo -e \"pruebu\\ba\"
prueba

Se ve que el cursor retrocedió y cambio la \"u\" por la \"a\".

\\c

Suprime el carácter de nueva linea (igual que la opción
-n).

echo -e \"prueba\\c\"
prueba$

\\f

Alimentación de Hoja, esto si lo enviamos a una impresora hace
que avance a la próxima hoja.

$ echo -e \"prueba\\fprueba\" | lpr

Imprimirá la palabra prueba al comienzo de dos hojas.

\\n

Nueva Linea, produce un retroceso de carro y un avance de linea.

echo -e \"prueba\\n\"
$

\\r

Retorno de carro.

$ echo -e \"prueba\\rP\"
Prueba

Se produce el retorno de carro y la \"P\" reemplazo a la \"p\".

\\t

Tab horizontal

$ echo -e \"prueba\\tprueba\"
prueba prueba

\\v

Tab vertical

$ echo -e \"prueba\\vprueba\"
prueba
 prueba

\\\\

Barra invertida, se utiliza para escribir en pantalla una barra invertida
cuando esta la opción -e.

$ echo -e \\\\
\\

\\NNN

Se imprime el carácter que posee el código ASCII NNN
(en octal), esto se podría utilizar para imprimir caracteres en
colores :))

Para especificar el color de letra, color de fondo y otras características
de los caracteres en pantalla, se envía una cadena de escape que
contiene dos números que definen dichas características,
de la siguiente manera:

\\033[Numero1;Numero2m

Luego de enviar esta cadena con ambos números que definen
colores, etc, todo los caracteres impresos en pantalla se verán
con los colores y características definidos anteriormente.

Ejemplos:

echo -e \"\\033[1;31mRojo\\033[0;0m\"
Rojo
echo -e \"\\033[1;32mVerde\\033[0;0m\"
Verde
echo -e \"\\033[1;33mAmarillo\\033[0;0m\"
Amarillo
echo -e \"\\033[1;34mAzul\\033[0;0m\"
Azul
echo -e \"\\033[1;5mBlink\\033[0;0m\"
Blink

La cadena de escape al final se utiliza para volver
al color anterior. pueden probar con otros números :))

12. Lectura de la entrada estandar.

En esta sección trataremos como hace el script para leer
datos desde la entrada estandar., normalmente el teclado, existen dos formas:

- La primera es mediante la linea de comandos, como vimos en el punto
5.2, el nombre del script se encuentra en la variable {sp_content}
y los parámetros de la linea de comando se encuentran en las variables

a , o si son mas de 9 parámetros se puede utilizar
la variable $* que contiene todos los parámetros
juntos de la linea de comando.

$ cat linea_comando
echo \"El nombre del script es {sp_content}\"
echo \"El primer parámetro es \"
echo \"El segundo parámetro es \"

Lo ejecutamos:

$ ./linea_comando file1 file2
El nombre del script es linea_comando
El primer parámetro es file1
El segundo parámetro es file2

- La segunda forma de leer valores es interactivamente, ósea mientras
se esta ejecutando el programa, utilizando la sentencia
read.
Su sintaxis es:

read [OPCIONES] var1 var2 var3 ....

read lee una linea desde la entrada estandar., la
primer palabra se asigna a var1, la segunda a var2 y así sucesivamente.

$ read var1 var2
uno dos
$ echo \"var1 vale: $var1 y var2 vale: $var2\"
var1 vale uno y var2 vale dos

Si las palabras ingresadas son menos que la cantidad de variables
en la sentencia read, se les asigna un valor nulo a las sobrantes.

$ read var1 var2
uno
$ echo \"var1 vale: $var1 y var2 vale: $var2\"
var1 vale uno y var2 vale

OPCIONES: veamos algunas interesantes.

-p prompt

Nos muestra un prompt antes de leer desde la entrada estandar. (solo
funciona si se esta leyendo desde una terminal).

$ read -p \"comando> \" COMANDO ; echo \"El comando es: $COMANDO\"
comando> cp
El comando es cp
$

-r Le quita el significado a las barras invertidas.

Si no le indicamos variables a read, la linea ingresada
se guarda en la variable REPLY.

$ read
uno dos tres
$ echo $REPLY
uno dos tres

Para mas documentación sobre read leer la pagina del
manual de bash.

13. Operaciones aritméticas.

Para realizar operaciones aritméticas se utiliza el comando
expr,
su sintaxis es:

expr ARG1 OPERACION ARG2

OPERACION puede ser:

+ Suma
- Resta
/ División
\\* Multiplicación

Importante:

- En la multiplicación se debe anteponer al signo asterisco (*),
una barra invertida para que bash no realice sustitución de nombres
de archivo.

- El resultado del comando expr es enviado a la salida estandar.

- Las variables en bash son todas cadenas de caracteres, no existen
tipos de variables, por lo tanto debemos tener cuidado de no pasarle como
argumentos a expr variable con letras cuando estamos realizando
una operación aritmética, porque nos dará un error

- Entre cada argumento y la operación debe haber un espacio,
para que expr puede distinguir los argumentos y su operando.

Ejemplos:

$ expr 10 + 10
20
$ x=10
$ y=2
$ expr $x / $y
5
$ resta=`expr $x - $y`
$ mult=`expr $x \\* $y`
$ echo \"$x menos $y vale $resta\"
10 menos 2 vale 8
$ echo \"La multiplicación de $x y $y es $mult\"
La multiplicación de 10 y 2 es 20

¿ Como hacemos para calcular por ejemplo: ( 5 + 3
) / 2 ?

Primero calculamos la suma y luego la división.

$ suma=`expr 5 + 3`
$ expr $suma / 2
4

14. La sentencia if-then-else-fi.

Cada aplicación que ejecutamos, cuando finaliza su ejecución,
retorna un valor de estado de finalización, que lo podemos leer
en la variable $?.

Si el comando se ejecuto exitosamente (ósea pudo realizar
lo que se le pidió), la variable $? será cero (0), pero si
se producio algún error será distinto de cero.

$ expr a + b
expr: non-numeric argument
$ echo $?
2

En el ejemplo anterior, para producir un error tratamos de sumar
\"a\" mas \"b\", luego leemos la variable del shell $? y efectivamente vemos
que el ultimo comando ejecutado no fue exitoso, retorno un valor distinto
de cero.

$ expr 2 + 2
4
$ echo $?
0

Aquí vemos que $? vale cero porque expr pudo realizar
la suma exitosamente.

La variable $? siempre contendrá el estado de finalización
del ultimo comando.

Nuestro script también podrá devolver valores mediante
el comando exit numero, donde numero es
el valor que retornara. Si la ejecución del script fue exitosa debemos
finalizarlo con exit 0 y sino con exit y un numero distinto de cero.

La sintaxis de la sentencia if tiene la forma:

if comando1
 then
 comando2
 comando3
 ....
 ...
 else
 comando4
 comando5
 ...
 ...
fi

El comando1 siempre se ejecuta, puede suceder que:

- Si el comando1 finaliza exitosamente (ósea retorna
cero), se ejecutaran los comandos que se encuentran entre el then
y el else (comando2, comando3, ...).

- Si el
comando1 no finaliza exitosamente (retorna un valor
distinto de cero), se ejecutaran los comandos que se encuentran entre el
else
y el fi (comando4, comando5, ...).

El else es opcional, cuando no se encuentra nos queda
así:

if comando1
 then
 comando2
 comando3
 ...
 ...
fi

Si comando1 se ejecuta exitosamente, se ejecutaran los comandos
que se encuentran entre el then y el fi (comando2, comando3,
...).

El fi marca el final del if
y no debe faltar.



Ejemplo:

$ cat usuario
#!/bin/bash
###################################
# verifica si un usuario esta #
# creado #
###################################
read -p \"Ingrese el nombre del usuario: \" usuario
if grep -L ^$usuario: /etc/passwd
 then
 echo \"El usuario ya esta creado\"
 else
 echo \"El usuario no esta creado\"
fi
exit 0
$

Probemos si anda:

$ bash usuario
Ingrese el nombre del usuario: ariel
El usuario ya esta creado
$

15. 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. Su utilización será en conjunto
con la sentencia if para evaluar distintos tipos de expresiones que veremos
en seguida, su sintaxis es:

test EXPRESION

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.

- Evaluación de cadenas de
caracteres.

-z CADENA

verdadero si la longitud de la cadena es cero (nula).

-n CADENA

verdadero si la longitud de la cadena es distinta de cero (no nula).

CADENA1 = CADENA2

verdadero si las cadenas son iguales.

CADENA1 != CADENA2

verdadero si las cadenas son distintas.

CADENA

verdadero si la cadena es no nula.

Ejemplos:

$ STR=\"abcd\"
$ test \"$STR\" = abcd
$ echo $?
0
$ test \"$STR\" != abcd
$ echo $?
1
$ test -z \"\"
$ echo $?
0
$ test -n \"\"
$ echo $?
1
$ test \"\"
$ echo $?
1

Veamos un ejemplo que aclara algunos errores comunes.

$STR = \"abcd \"
$ test $STR = \"abcd \"
$ echo $?
1
$ test \"$STR\" = \"abcd \"
$ echo $?
0

Vemos que STR es \"abcd \", (con un
espacio al final), en el primer test lo comparamos con \"abcd \"
(también con un espacio al final) y debería dar verdadero
pero dio falso, ¿ a que se debe ?

Esto se produce porque el interprete primero realiza la sustitución
del valor de la variable STR y luego remueve el espacio que tiene al final
STR, porque supone que están demás, ósea que el comando
test ejecutado queda así : test \"abcd\" = \"abcd \"
y efectivamente es falso.

Para que esto no suceda, en el segundo test la variable STR
aparece entre comillas (\"$STR\"), de esta manera el interprete
no le quita el espacio final y test recibe el parámetro correctamente
dando la comparación verdadera, esta es la forma correcta de hacerlo.

- Evaluación de números enteros.

Suponemos que INT1 e INT2 contienen caracteres
que representan números enteros.

INT1 -eq INT2

verdadero si INT1 es igual a INT2

INT1 -gt INT2

verdadero si INT1 es mayor que INT2 (greater than)

INT1 -lt INT2

verdadero si INT1 es menor que INT2 (less than).

INT1 -ge INT2

verdadero si INT1 es mayor o igual que INT2 (greater than or equal).

INT1 -le INT2

verdadero si INT1 es menor o igual que INT2 (less than or equal).

$ num1=0222
$ test \"$num1\" -eq 222
$ echo $?
0
$ test \"$num1\" -gt 222
$ echo $?
1

- Evaluación de archivos.

Veamos los mas importantes:

Suponemos que FILE contiene el path y nombre de un archivo.

-b FILE

Verdadero si el archivo existe y es un dispositivo de bloques.

-c FILE

Verdadero si el archivo existe y es un dispositivo de caracteres.

-d FILE

Verdadero si el archivo existe y es un directorio.

-e FILE

Verdadero si el archivo existe.

-f FILE

Verdadero si el archivo existe y es un archivo ordinario

-r FILE

Verdadero si el archivo existe y tenemos permiso de lectura.

-w FILE

Verdadero si el archivo existe y tenemos permiso de escritura.

-x FILE

Verdadero si el archivo existe y tenemos permiso de ejecución.

- Operadores lógicos.

Suponemos que EXP1 y EXP2 contienen expresiones
que se pueden evaluar a verdadero o falso.

!

Negación.

EXP1 -a EXP2

And lógico. verdadero cuando ambas expresiones son verdaderas.

EXP1 -o EXP2

Or lógico, verdadero si cualquiera de las expresiones es valida.

- Utilización abreviada del comando test.

En vez de escribir test EXPRESION, podemos escribir la EXPRESION
entre corchetes( [ ] ) y cumple la misma funcion.

$ str=\"abc\"
$ [ \"$str\" = \"abc\" ]
$ echo $?
0

Esto nos permite escribir las sentencias de control de flujo en bash similares
a otros lenguajes de programación.

$ cat ejemplo
read -p \"Escriba un palabra: \" cadena1
read -p \"Escriba otra: \" cadena2
if [ \"$cadena1\" = \"$cadena2\" ]
 then
 echo \"Las palabras son iguales\"
 else
 echo \"Las palabras son distintas\"
fi
exit 0

Para mas información sobre el comando test ejecutar: man test
o info test.

16. La sentencia case.

Se utiliza cuando una variable debe ser contrastada con varios valores,
su sintaxis es la siguiente:

case value in
 patron1) comando1
 comando2;;
 patron2) comando3
 comando4;;
 ....
 ....
esac

Verifica si value cumple con alguno de los patrones
(patron1, patron2, etc) y ejecuta los comandos asociados con la primer
coincidencia que ocurre. Solo 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 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
exit 0
$

Los gupos de comandos pueden estar relacionados con varios patrones, realizando
una operación OR entre ellos mediante el símbolo
\"|\".

patron1 | patron2) comando1
 comando2;;

17. La sentencias while y until.

La sentencia while se utiliza para ejecutar un grupo de
comandos en forma repetida mientras una condición es verdadera.
Su sintaxis es:

while comando1
 do
 comando2
 comando3
 ...
 ...
 done

Mientras la condición sea verdadera,
se ejecutaran los comandos comprendidos entre do y done
en forma repetida, si la condición da falso el programa sale del
bucle y continuara la ejecución por debajo del while.

El ejemplo anterior tenia el inconveniente que solo podemos ejecutar
una opción del menú por cada ejecución del programa,
ahora le agregaremos un while para poder ejecutar varias opciones sin que
finalice el programa.

#!/bin/bash
##############################
# Genera un menú de opciones #
##############################
while [ \"$OPCION\" != 5 ]
do
 echo \"[1] Listar archivos\"
 echo \"[2] Ver directorio de trabajo\"
 echo \"[3] Crear directorio\"
 echo \"[4] Crear usuario\"
 echo \"[5] Salir\"
 read -p \"Ingrese una opción: \" OPCION
 case $OPCION in
 1) ls;;
 2) pwd;;
 3) read -p \"Nombre del directorio: \" DIRECTORIO
 mkdir $DIRECTORIO;;
 4) if id | grep uid=0
 then
 read -p \"Nombre del usuario: \" NOMBREUSUARIO
 useradd $NOMBREUSUARIO
 else
 echo \"Se necesitan permisos de root\"
 fi;;
 5);;
 *) echo \"Opción ingresada invalida, intente de nuevo\";;
 esac
done
exit 0

Como vimos, la sentencia while hace que el programa
ingrese a un bucle de ejecución hasta que la condición es
falsa, la sentencia until es opuesta, se ejecutara el bucle
hasta que la condición sea verdadera. Su sintaxis es:

until comando1
do
comando2
comando3
....
done

En el ejemplo anterior, si queremos usar until en vez de
while,
deberíamos poner:

until [ \"$OPCION\" = 5 ]

-Bucles infinitos.

Bucles infinitos son aquellos donde la ejecución continua
dentro del bucle indefinidamente, veamos como hacer un bucle infinito mediante
while:

while true
do
comando1
comando2
...
...
done

La condición siempre es verdadera y se ejecutara el
bucle indefinidamente, mediante until seria así:

until false
do
comando1
comando2
...
...
done

Existe la posibilidad de salir de un bucle, independientemente
del estado de la condición, el comando
break produce
el abandono del bucle inmediatamente.

Veamos nuestro ejemplo del menú, utilizando un bucle infinito
y el comando break:

#!/bin/bash
##############################
# Genera un menú de opciones #
##############################
while true
do
 echo \"[1] Listar archivos\"
 echo \"[2] Ver directorio de trabajo\"
 echo \"[3] Crear directorio\"
 echo \"[4] Crear usuario\"
 echo \"[5] Salir\"
 read -p \"Ingrese una opción: \" OPCION
 case $OPCION in
 1) ls;;
 2) pwd;;
 3) read -p \"Nombre del directorio: \" DIRECTORIO
 mkdir $DIRECTORIO;;
 4) if id | grep uid=0
 then
 read -p \"Nombre del usuario: \" NOMBREUSUARIO
 useradd $NOMBREUSUARIO
 else
 echo \"Se necesitan permisos de root\"
 fi;;
 5)
 echo \"Abandonando el programa...\"
 break;;
 *)
 echo \"Opción ingresada invalida, intente de nuevo\";;
 esac
done
exit 0

18. La sentencia for.

Es otro tipo de loop disponible, la diferencia con los anteriores es que
no se basa en una condición, sino que ejecuta el bucle una cantidad
determinada de veces, su sintaxis es la siguiente:

for variable in arg1 arg2 ......argn
 do
 comando1
 comando2
 ...
 ...
 done

Ejemplos:

for LETRA in a b c d e f
do
echo $LETRA
done

Imprimirá las letras de la \"a\" a la \"f\".

La variable del for contendrá cada uno
de los valores especificados después del in en cada
bucle.

Otro ejemplo clásico es que la variable tome en cada
bucle el valor de un parámetro ingresado en la linea de comando.

for PAMETRO in $*
do
echo $PARAMETRO
done

Imprimirá cada uno de los parámetros ingresado en la linea
de comando.

19. Funciones.

Una funcion o subrutina es una agrupación de comandos bajo
un mismo nombre, esto nos permitirá dividir el programa en bloques
y programar cada bloque por separado, o también agrupar una serie
de comandos que se ejecutan a menudo, bajo un mismo nombre, veamos la sintaxis
de una funcion:

nombre_funcion()
{
comando1
comando2
...
...
}

Luego para ejecutar la funcion debemos llamarla por su nombre, igual
que un comando:

...
nombre_funcion
...

Debemos definir cada funcion antes de utilizarla, veamos
el ejemplo anterior pero utilizando funciones:

#!/bin/bash
##############################
# Genera un menú de opciones #
##############################
######### Funciones #############
###############################
# Imprime el menú de opciones #
###############################
imprimir_menú ()
{
echo -e \"\\n\"
echo \"[1] Listar archivos\"
echo \"[2] Ver directorio de trabajo\"
echo \"[3] Crear directorio\"
echo \"[4] Crear usuario\"
echo -e \"[5] Salir\\n\"
read -p \"Ingrese una opción: \" OPCION
}
############################################
# Lista archivos del directorio de trabajo #
############################################
listar_archivos ()
{
ls
}
########################################
# Imprime directorio actual de trabajo #
########################################
imprimir_directorio ()
{
pwd
}
#################
Crea directorio #
#################
crear_directorio ()
{
read -p \"Nombre del directorio a crear: \" DIRECTORIO
mkdir $DIRECTORIO
}
################
# Crea usuario #
################
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
 imprimir_menú
 case $OPCION in
 1) listar_archivos;;
 2) imprimir_directorio;;
 3) crear_directorio;;
 4) crear_usuario ;;
 5) echo \"Abandonando el programa...\"
 break;;
 *) echo \'********************************************\'
 echo \"Opción ingresada no valida, intente de nuevo\"
 echo \'********************************************\';;
 esac
done
exit 0

Utilizando funciones el programa resulta mas fácil de interpretar.

20. Despedida de la segunda parte.

Ya con lo visto se puede comenzar a crear scripts, la practica es
una parte esencial del aprendizaje de cualquier lenguaje de programación
y no es transmisible de una persona a otra, hay que realizar ejercicios
hasta sentirse familiarizado con el lenguaje.

En la tercera parte veremos la utilización de algunas
aplicaciones muy útiles y el uso de la librería dialog, para
crear aplicaciones con ventanas en consola (el programa instalador de Slackware
hace uso de esta librería).

Hasta la próxima !!