PDF de programación - Administración de sistemas Linux RedHat - Programación avanzada en Shell

SEMINARIO 06053
PROGRAMACIÓN AVANZADA EN
SHELL (shellscripts)

Ramón M. Gómez Labrador
([email protected])
Abril de 2.005

Nota importante: El presente seminario se oferta dentro del plan de
formación para personal informático de la Universidad de Sevilla para el
año 2006 y toda su documentación asociada está bajo licencia Creative
Commons con reconocimiento
(http://creativecommons.org/licenses/by/2.5/deed.es).

1ª edición: Curso 03-55 Programación Avanzada en Shell, octubre 2.003.
2ª edición: Curso 05-08 Programación Avanzada en Shell, abril 2.005.
Esta 3ª edición divide el curso en 2 seminarios:

1. Seminario 06013 Programación Avanzada en Shell (línea de
2. Seminario 06053 Programación Avanzada en Shell (shellscripts),

comandos), septiembre 2.006.
septiembre 2.006.

2

06013 Programación Avanzada en Shell

(shellscripts)

ÍNDICE
1. Introducción.................................................................................4
1.1. La línea de mandatos........................................................................4
1.2. Edición y ejecución de un guión........................................................4
1.3. Recomendaciones de programación.................................................5
2. Expansiones.................................................................................7
2.1. Expansión de llaves...........................................................................7
2.2. Expansión de tilde.............................................................................8
2.3. Expansión de parámetro o de variable..............................................9
2.4. Sustitución de mandato...................................................................10
2.5. Expansión aritmética.......................................................................11
2.6. Sustitución de proceso....................................................................11
2.7. División en palabras........................................................................12
2.8. Expansión de fichero.......................................................................12
3. Programación estructurada.......................................................14
3.1. Listas de mandatos..........................................................................14
3.1.1. Listas condicionales..................................................................15
3.2. Estructuras condicionales y selectivas...........................................15
3.2.1. Estructuras condicionales.........................................................15
3.2.2. Estructura selectiva..................................................................17
3.3. Bucles..............................................................................................18
3.3.1. Bucles genéricos.......................................................................19
7.3.2. Bucles condicionales “mientras” y “hasta”...............................20
3.3.3. Bucle de selección interactiva..................................................21
4. Funciones...................................................................................22
5. Características especiales..........................................................25
5.1. Programas interactivos...................................................................25
5.2. Control de trabajos..........................................................................26
5.3. Intérprete de uso restringido..........................................................28
6. Referencias................................................................................29

3

1. Introducción

1.1. La línea de mandatos.

La línea de mandatos es el interfaz del usuario con el sistema, que
permite personalizar el entorno de operación y ejecutar programas y
guiones.
El formato típico de una línea consta de una orden y unos modificadores y
parámetros opcionales, aunque puede incluir algunos caracteres
especiales, que modifican el comportamiento típico.

Mandato [Modificador ...][Parámetro ...]

Un caso especial es el de las líneas que comienzan por la almohadilla (#),
que se consideran comentarios. También puede insertarse un comentario
en mitad de una línea, a la derecha de una orden.

# Esto es un comentario
ls -al # lista el contenido del directorio actual

Pueden agruparse varias órdenes en la misma línea separadas por el
punto y coma (;), que se ejecutan siempre en secuencia. Asimismo, si un
mandato es muy largo o engorroso, puede usarse el carácter de escape
(\) para continuar escribiéndolo en la línea siguiente.

cd /var/log; grep –i error *
find /tmp /var/tmp ! –user root –type f \
-perm +2 –print

1.2. Edición y ejecución de un guión.

Un guión interpretado por BASH es un fichero de texto normal que
consta de una serie de bloques de código formados por líneas de
mandatos que se ejecutan en secuencia. El usuario debe tener los
permisos de modificación (escritura) en el directorio –para crear un
nuevo programa– o sobre el propio fichero, para modificar uno existente.
Como un programa binario, el usuario debe tener permiso de ejecución
en el fichero del guión, y se lanza tecleando su camino completo junto con
sus opciones y parámetros. Asimismo, como veremos en el Capítulo 4, si
el programa se encuentra en un directorio incluido en la variable de
entorno PATH, sólo se necesita teclear el nombre, sin necesidad de
especificar el camino.

4

El proceso completo de edición y ejecución de un guión es el siguiente:

vi prueba.sh
chmod u+x prueba.sh
./prueba.sh
prueba.sh

# o cualquier otro editor de textos
# activa el permiso de ejecución
# ejecuta el guión
# si está en un directorio de $PATH

Existe una manera especial para ejecutar un guión, precediéndolo por el
signo punto, que se utiliza para exportar todas las variables del programa
al entorno de ejecución del usuario (para más información sobre las
variables de entorno revisar el Capítulo 4). El siguiente ejemplo ilustra el
modo de ejecutar
apachectl start
. miprofile
source miprofile

# Ejecución normal de un guión.
# Ejecución exportando las variables.
# Equivalente a la línea anterior.

Un “script” puede –y debe– comenzar con la marca #! para especificar el
camino completo y los parámetros del intérprete de mandatos que
ejecutará el programa. Esta marca puede usarse para ejecutar cualquier
intérprete instalado en la máquina (BASH, BSH, PERL, AWK, etc.).
El siguiente cuadro muestra un pequeño ejemplo de guión BASH.

#!/bin/bash
# ejemplo1: informe de la capacidad de la cuenta

echo "Usuario: $USER"
echo "Capacidad de la cuenta:"
du –hs $HOME # suma total del directorio del usuario

1.3. Recomendaciones de programación.

Como cualquier otro programa, un guión BASH puede requerir un cierto
mantenimiento, que incluya modificaciones, actualizaciones o mejoras del
código. Por lo tanto, el programador debe ser precavido y desarrollarlo
teniendo en cuenta las recomendaciones de desarrollo típicas para
cualquier programa.
Una práctica ordenada permite una verificación y comprensión más
cómoda y rápida, para realizar las modificaciones de forma más segura y
ayudar al usuario a ejecutar el programa correctamente. Pare ello, seguir
las siguientes recomendaciones.

• El código debe ser fácilmente legible, incluyendo espacios y

sangrías que separen claramente los bloques de código

• Deben añadirse comentarios claros sobre el funcionamiento general
del programa principal y de las funciones, que contengan: autor,
descripción, modo de uso del programa, versión y fechas de
modificaciones.

5

•

Incluir comentarios para los bloques o mandatos importantes, que
requieran cierta aclaración.

• Agregar comentarios y ayudas sobre la ejecución del programa.
• Depurar el código para evitar errores, procesando correctamente

los parámetros de ejecución.

• No desarrollar un código excesivamente enrevesado, ni complicado

de leer, aunque ésto haga ahorrar líneas de programa.

• Utilizar funciones y las estructuras de programación más

adecuadas para evitar repetir código reiterativo.

• Los nombres de variables, funciones y programas deben ser
descriptivos, pero sin confundirse con otros de ellos, ni con los
mandatos internos o externos; no deben ser ni muy largos ni muy
cortos.

• Todos los nombres de funciones y de programas suelen escribirse
en letras minúsculas, mientras que las variables acostumbran a
definirse en mayúsculas.

6

2. Expansiones.

Como se ha observando en el seminario anterior, la línea de comandos se
divide en una serie de elementos que representan cierto significado en la
semántica del intérprete. La expansión es un procedimiento especial que
se realiza sobre dichos elementos individuales.
BASH dispone de 8 topos de expansiones, que según su orden de
procesado son [2]:

• Expansión de llaves: modifica la expresión para crear cadenas

arbitrarias.

• Expansión de tilde: realiza sustituciones de directorios.
• Expansión de parámetro y variable: tratamiento general de
variables y parámetros, incluyendo la sustitución de prefijos,
sufijos, valores por defecto y otros operaciones con cadenas.

• Sustitución de mandato: procesa el mandato y devuelve su salida

normal.

• Expansión aritmética: sustituye la expresión por su valor

numérico.

• Sustitución de proceso: comunicación de procesos mediante

tuberías con nombre de tipo cola (FIFO).

• División en palabras: separa la línea de mandatos resultante en
palabras usando los caracteres de división incluidos en la variable
IFS.

• Expansión de fichero: permite buscar patrones con comodines en

los nombres de ficheros.

El re