22/11/13 Curso Básico de UNIX - Programación del Shell

Curso Básico de UNIX

Programación del Shell

Comandos multilínea
El archivo de comandos (script)
Comentarios en los scripts
Comandos de programación
true
false
if
for
case
while
until
exit
expr
test
read
Parámetros
Depuración
Preguntas y Ejercicios
Bibliografía y Referencias

El intérprete de comandos o "shell" de UNIX es también un lenguage de programación completo. La

programación de shell se usa mucho para realizar tareas repetidas con frecuencia. Los diseñadores de
sistemas suelen escribir aplicaciones en el lenguaje de base del sistema operativo, C en el caso de UNIX,
por razones de rapidez y eficiencia. Sin embargo, el shell de UNIX tiene un excelente rendimiento en la
ejecución de "scripts" (guiones); ésta es la denominación aplicada a los programas escritos en el lenguaje
del shell. Se han creado aplicaciones completas usando solamente scripts.

Comandos multilínea.

Una línea de comando termina con un caracter nuevalínea. El caracter nuevalínea se ingresa digitando la
tecla ENTER. Varios comandos pueden escribirse en una misma línea usando el separador ";"
echo $LOGNAME; pwd; date

Si un comando no cabe en una línea, la mayoría de los intérpretes continúan la digitación en la línea
siguiente. Para establecer específicamente que un comando continúa en la línea siguiente, hay dos formas,
mutuamente excluyentes (se usa una u otra, pero no ambas al mismo tiempo):
­ terminar la primera línea con \ :

iie.fing.edu.uy/~vagonbar/unixbas/shprog.htm 1/13
22/11/13 Curso Básico de UNIX - Programación del Shell

$ echo $LOGNAME \
> $HOME
que muestra algo como
jperez /home/jperez
­ dejar una comilla sin cerrar:
$ echo "$LOGNAME
> $HOME"
que produce el mismo resultado.

En los ejemplos anteriores hemos escrito los indicadores de comando. Al continuar el comando en la
segunda línea, el indicador de comandos cambia de $a >, es decir, del indicador de comando de primer
nivel PS1 al indicador de comando de segundo nivel PS2. Si no se quiere terminar el comando multilínea,
puede interrumpirse el ingreso con Ctrl­C, volviendo el indicador de comando a PS1 inmediatamente.

El archivo de comandos (script).

Es cómodo poder retener una lista larga de comandos en un archivo, y ejecutarlos todos de una sola vez
sólo invocando el nombre del archivo. Crear el archivo misdatos.shcon las siguientes líneas:
# misdatos.sh
# muestra datos relativos al usuario que lo invoca
#
echo "MIS DATOS."
echo " Nombre: "$LOGNAME
echo "Directorio: "$HOME
echo -n "Fecha: "
date
echo
# fin misdatos.sh

El símbolo #indica comentario. Para poder ejecutar los comandos contenidos en este archivo, es preciso
dar al mismo permisos de ejecución:
chmod ug+x misdatos.sh
La invocación (ejecución) del archivo puede realizarse dando el nombre de archivo como argumento a
bash
bash misdatos.sh
o invocándolo directamente como un comando
misdatos.sh
Puede requerirse indicar una vía absoluta o relativa, o referirse al directorio actual,
./misdatos.sh
si el directorio actual no está contenido en la variable PATH.

Comentarios en los scripts.

En un script todo lo que venga después del símbolo # y hasta el próximo caracter nuevalínea se toma como
comentario y no se ejecuta.
echo Hola todos # comentario hasta fin de línea
sólo imprime "Hola todos".
# cat /etc/passwd
no ejecuta nada, pues el símbolo #convierte toda la línea en comentario.

iie.fing.edu.uy/~vagonbar/unixbas/shprog.htm 2/13
22/11/13 Curso Básico de UNIX - Programación del Shell

Los scripts suelen encabezarse con comentarios que indican el nombre de archivo y lo que hace el script.
Se colocan comentarios de documentación en diferentes partes del script para mejorar la comprensión y
facilitar el mantenimiento. Un caso especial es el uso de #en la primera línea para indicar el intérprete con
que se ejecutará el script. El script anterior con comentarios quedaría así:

#!/bin/bash
# misdatos.sh
#
# muestra datos propios del usuario que lo invoca
#
echo "MIS DATOS."
echo " Nombre: "$LOGNAME
echo "Directorio: "$HOME
echo -n "Fecha: "
date # muestra fecha y hora
echo # línea en blanco para presentación
# fin misdatos.sh

La primera línea indica que el script será ejecutado con el intérprete de comandos bash. Esta indicación
debe ser siempre la primera línea del script y no puede tener blancos.

Estructuras básicas de programación.

Las estructuras básicas de programación son sólo dos: la estructura repetitiva y la estructura alternativa.
Cada forma tiene sus variaciones, y la combinación de todas ellas generan múltples posibilidades, pero
detrás de cualquiera de ellas, por compleja que parezca, se encuentran siempre repeticiones o alternativas.

Estructura repetitiva: se realiza una acción un cierto número de veces, o mientras dure una condición.

mientras haya manzanas,

pelarlas;

desde i = 1 hasta i = 7
escribir dia_semana(i);

Esta escritura informal se denomina "pseudocódigo", por contraposición al término "código", que sería la
escritura formal en un lenguaje de programación. En el segundo ejemplo, dia_semana(i)sería una
función que devuelve el nombre del día de la semana cuando se le da su número ordinal.

Estructura alternativa: en base a la comprobación de una condición, se decide una acción diferente para
cada caso.

si manzana está pelada,

comerla,
en otro caso,
pelarla;

# oráculo
caso $estado en

iie.fing.edu.uy/~vagonbar/unixbas/shprog.htm 3/13
22/11/13 Curso Básico de UNIX - Programación del Shell

soltero)
escribir "El casamiento será su felicidad";
casado)
escribir "El divorcio le devolverá la felicidad";
divorciado)
escribir "Sólo será feliz si se vuelve a casar";
fin caso

Funciones: una tarea que se realiza repetidamente dentro del mismo programa puede escribirse aparte e
invocarse como una "función". Para definir una función es preciso elegir un nombre y escribir un trozo de
código asociado a ese nombre. La función suele recibir algún valor como "parámetro" en base al cual
realiza su tarea. Definida así la función, para usarla basta escribir su nombre y colocar el valor del
parámetro entre paréntesis.

función area_cuadrado (lado)

devolver lado * lado;

función dia_semana(día_hoy)
caso $dia_hoy en
1)
devolver "Lunes";;
2)
devolver "Martes";;
3)
devolver "Miércoles";:
4)
devolver "Jueves";;
5)
devolver "Viernes;;
6)
devolver "Sábado";;
7)
devolver "Domingo";;
fin caso;

Comandos de programación.

En esta sección veremos los comandos típicos de programación del shell. Obsérvese que el shell toma la
convención inversa de C para cierto y falso: cierto es 0, y falso es distinto de 0. El shell adopta esta
convención porque los comandos retornan 0 cuando no hubo error. Veremos dos comandos, truey
false, que retornan siempre estos valores; se usan en algunas situaciones de programación para fijar una
condición.

true

Este comando no hace nada, sólo devuelve siempre 0, el valor verdadero. La ejecución correcta de un
comando cualquiera devuelve 0.
true
echo $?
muestra el valor 0; la variable $? retiene el valor de retorno del último comando ejecutado.

iie.fing.edu.uy/~vagonbar/unixbas/shprog.htm 4/13
22/11/13 Curso Básico de UNIX - Programación del Shell

false

Este comando tampoco hace nada sólo devuelve siempre 1; cualquier valor diferente de 0 se toma como
falso. Las diversas condiciones de error de ejecución de los comandos devuelven valores diferentes de 0; su
significado es propio de cada comando.
false
echo $?
muestra el valor 1.

if

El comando ifimplementa una estructura alternativa. Su sintaxis es

if expresión ; then comandos1 ; [else comandos2 ;] fi
o también
if expresión
then
comandos1
[else
comandos2]
fi

Si se usa la forma multilínea cuando se trabaja en la línea de comandos, el indicador cambia a > hasta que
termina el comando.

La expresión puede ser cualquier expresión lógica o comando que retorne un valor; si el valor retornado es
0 (cierto) los comandos1se ejecutan; si el valor retornado es distinto de 0 (falso) los comandos1no se
ejecutan. Si se usó la forma opcional con elsese ejecutan los comandos2.
if true; then echo Cierto ; else echo Falso ; fi
siempre imprime Cierto; no entra nunca en else.
if false; then echo Cierto ; else echo Falso ; fi
siempre imprime Falso, no entra nunca en then.

Construcciones más complejas pueden hacerse usando elifpara anidar alternativas. Escribir en un archivo
las líneas que siguen

# ciertofalso.sh: escribe cierto o falso según parámetro numérico

#
if [ $1 = "0" ]
then
echo "Cierto: el parámetro es 0."
else
echo "Falso: el parámetro no es 0."
fi

Convertir el script en ejecutable. Invocar este script con

./ciertofalso.sh N
donde N es un número entero 0, 1, 2, etc. La variable $1 hace referencia a este parámetro de invocación.
Verificar el resultado.

iie.fing.edu.uy/~vagonbar/unixbas/shprog.htm 5/13
22/11/13 Curso Básico de UNIX - Programación del Shell

Crear y ejecutar el siguiente script:

# trabajo.sh: dice si se trabaja según el día

# invocar con parámetros:
# domingo, feriado, u otro nombre cualquiera
#
if [ $1 = "domingo" ]
then
echo "no se trabaja"
elif [ $1 = "feriado" ]
then
echo "en algunos se trabaja"
else
echo "se trabaja"
fi

for

Este comando implementa una estructura repetitiva, en la cual una secuencia de comandos se ejecuta una y
otra vez. Su sintaxis es
for variable in lista ; do comandos ; done

Se puede probar en la línea de comandos:

for NUMERO in 1 2 3 4 ; do echo $NUMERO ; done
for NOMBRE in alfa beta gamma ; do echo $NOMBRE ; done
for ARCH in * ; do echo Nombre archivo $ARCH ; done
El caracter * es expandido por el shell colocando en su lugar todos los nombres de archivo del directorio
actual.

Crear y probar el siguiente script.

# listapal.sh: lista de palabras

# muestra palabras de una lista interna
#
LISTA="silla mesa banco cuadro armario"
for I in $LISTA
do
echo $I
done
# fin listapal.sh

En el siguiente script, el comando exprcalcula expresiones aritméticas; notar su sintaxis.

# contarch.sh
# muestra nombres y cuenta archivos en el directorio actual
#
CUENTA=0
for ARCH in *
do
echo $ARCH
CUENTA=`expr $CUENTA + 1` # agrega 1 a CUENTA

iie.fing.edu.uy/~vagonbar/unixbas/shprog.htm 6/13
22/11/13 Curso Básico de UNIX - Programación del Shell

done
echo Hay $CUENTA archivos en el directorio `pwd`
# fin contarch.sh

case

Este comando implementa alternativas o "casos"; elige entre múltiples secuencias de comandos la secuencia
a ejecutar. La elección se realiza encontrando el primer patrón con el que aparea una cadena de caracteres.
Su sintaxis es

case $CADENA in
patrón1)
comandos1;;
patrón2)
comandos2;;
...
*)
comandosN;;
esac

El patrón * se coloca al final; aparea cualquier cadena, y permite ejecutar comandosNcuando ninguna de
las opciones anteriores fue satisfecha. Crear el siguiente script:

# diasemana.sh: nombres de los días de la semana

# invocar con número del 0 al 6; 0 es domingo
case $1 in
0) echo Domingo;;
1) echo Lunes;;
2) echo Martes;;
3) echo Miércoles;;
4) echo Jueves;;
5) echo Viernes;;
6) echo Sábado;;
*) echo Debe indicar un número de 0 a 6;;
esac

Invocarlo como
diasemana.sh N
donde N es cualquier número de 0 a 6, otro número, o una cadena cualquiera. Verificar el comportamiento.

Crear el archivo estacion.shcon estas líneas:

# estacion.sh
# indica la estación del año aproximada según el mes
#
case $1 in
diciembre|enero|febrero)
echo Verano;;
marzo|abril|mayo)
echo Otoño;;
junio|julio|agosto)
echo Invierno;;

iie.fing.edu.uy/~vagonbar/unixbas/shprog.htm 7/13
22/11/13 Curso Básico de UNIX - Programación del Shell

setiembre|octubre |noviembre)
echo Primavera;;
*)
echo estacion.sh: debe invocarse como
echo estacion.sh mes
echo con el nombre del mes en minúscula;;
esac
# fin estacion.sh

El valor $1 es el parámetro recibido en la línea de comando. La opción *) aparea con cualquier cadena, por
lo que actúa como "en otro caso"; es útil para dar instrucciones sobre el uso del comando. En las opciones, |
actúa como OR; pueden usarse también comodines * y ?. Invocar el script:
bash estacion.sh octubre
bash estacion.sh

¿Cómo podría modificarse el script anterior para que aceptara el mes en cualquier combinación de
mayúsculas y minúsculas?

while

Este comando implementa una estructura repetitiva en la cual el conjunto de comandos se ejecuta mientras
se mantenga válida una condición (while = mientras). La condición se examina al principio y luego cada
vez que se completa la secuencia de comandos. Si la condición es falsa desde la primera vez, los comandos
no se ejecutan nunca. Su sintaxis es
while condición ; do comandos ; done

En el guión que sigue la expresión entre paréntesis rectos es una forma de invocar el comando test, que
realiza una prueba devolviendo cierto o falso. El operador -lt, "lower than", significa "menor que".
Observar su sintaxis, sobre todo la posición de los espacios en blanco, obligatorios.

# crear1.sh
# crea archivos arch1....arch9, los lista y luego borra
VAL=1
while [ $VAL -lt 10 ] # mientras $VAL < 10
do
echo creando archivo arch$VAL
touch arch$VAL
VAL=`expr $VAL + 1`
done
ls -l arch[0-9]
rm arch[0-9]
# fin crear1.sh

until

Este comando implementa una estructura repetitiva en la cual el conjunto de comando se ejecuta hasta que
se cumpla una condición. En cuanto la condición se cumple, dejan de ejecutarse los comandos. La
condición se examina al principio; si es verdadera, los comandos no se ejecutan. Notar la diferencia con
while. Su sintaxis es
until condición ; do comandos ; done

iie.fing.edu.uy/~vagonbar/unixbas/shprog.htm 8/13
22/11/13 Curso Básico de UNIX - Programación del Shell

Usando until, el script anterior se escribiría

# crear2.sh
# crea archivos arch1....arch9, los lista y luego borra
VAL=1
until [ $VAL -eq 10 ] # hasta que $VAL = 10
do
echo creando archivo arch$VAL
touch arch$VAL
VAL=`expr $VAL + 1`
done
ls -l arch[0-9]
rm arch[0-9]
# fin crear2.sh

exit

Este comando se utiliza en programación de shell para terminar inmediatamente un script y volver al shell
original.

exit
en un script, termina inmediatamente el script; en la línea de comando, termina la ejecución del shell actual,
y por lo tanto la sesión de UNIX.
exit 6
termina el script devolviendo el número indicado, lo que puede usarse para determinar condiciones de error.
exit 0
termina el script devolviendo 0, para indicar la finalización exitosa de tareas. Escribir sólo exittambién
devuelve código de error 0.
El siguiente script ofrece un ejemplo de uso.

#!/bin/bash
# exitar.sh: prueba valores de retorno de exit
#
clear
echo "Prueba de valores de retorno"
echo " Invocar con parámetros "
echo " bien, error1, error2, cualquier cosa o nada"
echo " Verificar valor de retorno con"
echo ' echo $?'
echo
VALOR=$1
case $VALOR in
bien)
echo " -> Terminación sin error."
exit 0;;
error1)
echo " -> Terminación con error 1." ; exit 1;;
error2)
echo " -> Terminación con error 2." ; exit 2;;
*)
echo " -> Terminación con error 3."
echo " (invocado con parámetro no previsto o sin parámetro."

iie.fing.edu.uy/~vagonbar/unixbas/shprog.htm 9/13
22/11/13 Curso Básico de UNIX - Programación del Shell

exit 3;;
esac

expr

Este comando recibe números y operadores aritméticos como argumentos, efectúa los cálculos indicados y
devuelve el resultado. Cada argumento debe estar separado por blancos. Opera sólo con números enteros y
realiza las operaciones suma (+), resta (­), multiplicación (*), división entera (/), resto de división entera
(%). Los símbolos * y / deben ser escapados escribiendo \* y \/, al igual que los paréntesis, que deben
escribirse \( y \).

El comando exprusa la convención de C para cierto y falso: 0 es falso, y distinto de 0 es cierto. No

confundir con la convención que toma el shell en sus valores true y false, que es la contraria.
expr 4 + 5
devuelve 9 ( 4 + 5 = 9 ).
expr 3 \* 4 + 6 \/2
devuelve 15 ( 3 * 4 + 6 /2 = 15 ).
expr 3 \* \( 4 + 3 \) \/2
devuelve 10 ( 3 * (4 + 3) / 2 = 10 ).

exprtambién realiza operaciones lógicas de comparación, aceptando los operadores =, !=, >, <, >= y
<=. El operador !=es "no igual"; el !se usa para negar. Estos caracteres también requieren ser escapados.
echo `expr 6 \< 10`
devuelve 1, cierto para expr.
echo `expr 6 \> 10`
devuelve 0, falso para expr.
echo `expr abc \< abd`
devuelve 1, cierto para expr.

test

Este comando prueba condiciones y devuelve valor cierto (0) o falso (distinto de 0) según el criterio de
cierto y falso del shell; esto lo hace apto para usar en la condición de if. Tiene dos formas equivalentes
test expresión
[ expresión ]

Los blancos entre la expresión y los paréntesis rectos son necesarios.

testdevuelve cierto ante una cadena no vacía, y falso ante una cadena vacía:
if test "cadena" ; then echo Cierto ; else echo Falso; fi
if test "" ; then echo Cierto ; else echo Falso ; fi
if [ cadena ] ; then echo Cierto ; else echo Falso; fi
if [ ] ; then echo Cierto ; else echo Falso ; fi

testprueba una cantidad de condiciones y situaciones:

if [ -f archivo ]; then echo "Existe archivo"; \

else echo "No existe archivo"; fi

iie.fing.edu.uy/~vagonbar/unixbas/shprog.htm 10/13
22/11/13 Curso Básico de UNIX - Programación del Shell

La condición [ -f archivo ]es cierta si archivo existe y es un archivo normal; análogamente, ­r

comprueba si es legible, ­w si puede escribirse, ­x si es ejecutable, ­d si es un directorio, ­s si tiene tamaño
mayor que 0.

Las condiciones
[ $DIR = $HOME ]
[ $LOGNAME = "usuario1" ]
[ $RESULTADO != "error" ]
comparan cadenas de caracteres; = para igualdad y != para desigualdad.
La condición
[ "$VAR1" ]
devuelve falso si la variable no está definida. Las comillas dan la cadena nula cuando VAR1no está
definida; sin comillas no habría cadena y daría error de sintaxis.
La condición
[ expnum1 -eq expnum2 ]
compara igualdad de expresiones que resultan en un número. Pueden ser expresiones numéricas o lógicas,
ya que éstas también resultan en números. Los operadores numéricos derivan sus letras del inglés, y son ­eq
(igualdad), ­neq (no igual, desigualdad), ­lt (menor), ­gt (mayor), ­le (menor o igual), ­ge (mayor o igual).

El comando testse usa mucho para determinar si un comando se completó con éxito, en cuyo caso el
valor de retorno es 0. El siguiente script crea un archivo si no existe.

# nvoarch.sh
# recibe un nombre y crea un archivo de ese nombre;
# si ya existe emite un mensaje
if [ -f $1 ]
then
echo El archivo $1 ya existe
else
touch $1
echo Fue creado el archivo $1
fi
echo
# fin nvoarch.sh

Para comprobar su acción,

bash nvoarch.sh nuevo1
ls -l nuevo1
crea el archivo; lscomprueba que existe;
bash nvoarch.sh nuevo1
da mensaje indicando que el archivo ya existe.

Otros operadores aceptados por test son -a(AND) y -o(OR).

# rwsi.sh
# indica si un archivo tiene permiso de lectura y escritura
ARCH=$1
if [ -r $ARCH -a -w $ARCH ]
then
echo El archivo $ARCH se puede leer y escribir
else
echo Al archivo $ARCH le falta algún permiso

iie.fing.edu.uy/~vagonbar/unixbas/shprog.htm 11/13
22/11/13 Curso Básico de UNIX - Programación del Shell

fi
ls -l $ARCH
# fin rwsi.sh

read

Este comando tiene como propósito solicitar información al usuario. Su ejecución captura las digitaciones
del usuario, hasta obtener un caracter nueva línea (techa Enter). El ejemplo siguiente obtiene datos del
usuario, los repite en pantalla, solicita confirmación y emite un mensaje en consecuencia.

# yo.sh: captura datos del usuario

#
clear
echo "Datos del usuario."
echo -n "Nombre y apellido: "; read NOMBRE
echo -n "Cédula de identidad: "; read CEDULA
echo
echo "Ha ingresado los siguientes datos:"
echo " Nombre y apellido: $NOMBRE"
echo " Cédula de Identidad: $CEDULA"
echo -n "¿Es correcto?(sN):"; read RESP
if [ "$RESP" = "s" -o $RESP = "S" ]
then
echo "Fin de ingreso."
else
echo "Debe ingresar sus datos nuevamente."
fi

Parámetros.

El siguiente programa muestra los parámetros que recibe al ser invocado:

# ecopars.sh
# muestra los parámetros recibidos
echo Cantidad de parámetros: $#
for VAR in $*
do
echo $VAR
done
# fin ecopars.sh

ecopars.sh Enero Febrero Marzo

muestra la cantidad y los parámetros recibidos. La variable $* contiene la lista de parámetros, y $# la
cantidad.

Dentro del script, los parámetros recibidos pueden referenciarse con $1, $2, $3, ..., $9, siendo $0 el nombre
del propio programa. Debido a que se los reconoce por su ubicación, se llaman parámetros posicionales. El
siguiente programa se invoca con tres parámetros y muestra sus valores:

# mostrar3.sh
# se invoca con 3 parámetros y los muestra
echo nombre del programa: $0

iie.fing.edu.uy/~vagonbar/unixbas/shprog.htm 12/13
22/11/13 Curso Básico de UNIX - Programación del Shell

echo parámetros recibidos:

echo $1; echo $2; echo $3
echo
# fin mostrar3.sh

¿Cómo se podría verificar la invocación con 3 parámetros, y emitir un mensaje de error en caso contrario
(cuando el usuario ingresa menos de 3 parámetros)?

Depuración.

Se llama depuración ("debug") de un programa al proceso de verificar su funcionamiento en todos los

casos posibles y corregir sus errores ("bugs", "pulgas"; del inglés, literalmente, "chinche"; por extensión,
insecto pequeño).

Cuando se está escribiendo un script, puede convenir invocarlo de forma especial para generar información
de comandos ejecutados y errores, para ayudar en la depuración. Las salidas se imprimen en el error
estándar, por lo que pueden direccionarse a un archivo sin mezclarse con la salida del comando.
bash -x ecopars.sh
imprime cada comando en la salida;
bash -v ecopars.sh
invoca el script obteniendo una salida verbosa con información sobre cada comando ejecutado.
bash -xv ecopars.sh 2>ecopars.err
reúne las dos fuentes de información y direcciona el error estándar a un archivo.

Preguntas y Ejercicios
Bibliografía y Referencias.
Comandos: true false if for case while until exit expr test
Referencias: Coffin[1989], Kernighan­Pike[1984]; páginas man de Linux "bash" ("Bourne­Again shell").

Víctor A. González Barbone vagonbar en fing edu uy

Instituto de Ingeniería Eléctrica ­ Facultad de Ingeniería ­ Montevideo, Uruguay.

iie.fing.edu.uy/~vagonbar/unixbas/shprog.htm 13/13