PDF de programación - Administración de sistemas Linux RedHat - Programación avanzada en Shell (línea de comandos)

SEMINARIO 06013
PROGRAMACIÓN AVANZADA EN
SHELL (línea de comandos)

Ramón M. Gómez Labrador
([email protected])
Septiembre de 2.006

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

(línea de comandos)

ÍNDICE
1. Introducción.................................................................................4
1.1. Características principales de BASH................................................4
1.2. Cuándo utilizar el intérprete de mandatos.......................................5
2. Redirecciones...............................................................................6
2.1. Redirección de entrada.....................................................................6
2.2. Redirecciones de salida.....................................................................7
2.3. Combinación de redirecciones..........................................................7
2.4. Redirección de entrada/salida...........................................................8
2.5. Documento interno............................................................................9
2.6. Tuberías...........................................................................................10
3. Variables....................................................................................12
3.1. Tipos de variables...........................................................................12
3.1.1. Variables locales.......................................................................12
3.1.2. Variables de entorno.................................................................13
3.1.3. Parámetros de posición.............................................................15
3.1.4. Variables especiales..................................................................15
3.2. Matrices..........................................................................................17
3.3. Configuración del entorno...............................................................17
4. Expresiones................................................................................19
4.1. Expresiones aritméticas..................................................................20
4.2. Expresiones condicionales..............................................................22
4.2.1. Expresiones de ficheros............................................................22
4.3.2. Expresiones comparativas numéricas.......................................24
4.3.3. Expresiones comparativas de cadenas.....................................24
5. Entrecomillado...........................................................................26
6. Referencias................................................................................27

3

1. Introducción.

El intérprete de mandatos o "shell" es la interfaz principal entre el
usuario y el sistema, permitiéndole a aquél interactuar con los recursos
de éste. El usuario introduce sus órdenes, el intérprete las procesa y
genera la salida correspondiente.
Por lo tanto, un intérprete de mandatos de Unix es tanto una interfaz de
ejecución de órdenes y utilidades, como un lenguaje de programación,
guiones o
que admite crear nuevas órdenes –denominadas
“shellscripts”–, utilizando combinaciones de mandatos y estructuras
lógicas de control, que cuentan con características similares a las del
sistema y que permiten que los usuarios y grupos de la máquina cuenten
con un entorno personalizado [2].
En Unix existen 2 familias principales de intérpretes de mandatos: los
basados en el intérprete de Bourne (BSH, KSH o BASH) y los basados en
el intérprete C (CSH o TCSH).
Los 2 seminarios de formación sobre programación en shell pretenden
formar una guía para el usuario de Linux, que le permitirá comprender,
ejecutar y empezar a programar en la Shell, haciendo referencia
especialmente a BASH (Bourne Again Shell) –evolución de BSH, con
características de KSH y CSH–, ya que es el intérprete de mandatos más
utilizado en Linux e incluye un completo lenguaje para programación
estructurada y gran variedad de funciones internas.

1.1. Características principales de BASH.

Los principales características del intérprete BASH [i] son:

• Ejecución síncrona de órdenes (una tras otra) o asíncrona (en

paralelo).

• Distintos tipos de redirecciones de entradas y salidas para el

control y filtrado de la información.
• Control del entorno de los procesos.
• Ejecución de mandatos interactiva y desatendida, aceptando

entradas desde teclado o desde ficheros..

• Proporciona una serie de órdenes internas para la manipulación

directa del intérprete y su entrono de operación.

• Un lenguaje de programación de alto nivel, que incluye distinto
tipos de variables, operadores, matrices, estructuras de control de
flujo, entrecomillado, sustitución de valores y funciones.

• Control de trabajos en primer y segundo plano.

4

• Edición del histórico de mandatos ejecutados.
• Posibilidad de usar una "shell" para el uso de un entorno

controlado.

1.2. Cuándo utilizar el intérprete de mandatos.

Como se ha indicado anteriormente, una “shell” de Unix puede utilizarse
como interfaz para ejecutar órdenes en la línea de comandos o como
intérprete de un lenguaje de programación para la administración del
sistema.
El lenguaje de BASH incluye una sintaxis algo engorrosa, pero
relativamente fácil de aprender, con una serie de órdenes internas que
funcionan de forma similar a la línea de comandos. Un programa o guión
puede dividirse en secciones cortas, cómodas de depurar, permitiendo
realizar prototipos de aplicaciones más complejas.
Sin embargo, hay ciertas tareas que deben ser resueltas con otros
intérpretes más complejos o con lenguajes compilados de alto nivel, tales
como [4]:

• Procesos a tiempo real, o donde la velocidad es un factor

fundamental.

• Operaciones matemáticas de alta precisión, de lógica difusa o de

números complejos.

• Portabilidad de código entre distintas plataformas.
• Aplicaciones complejas que necesiten programación estructurada o

proceso multihilvanado.

• Aplicaciones críticas para el funcionamiento del sistema.
• Situaciones donde debe garantizarse la seguridad e integridad del

sistema, para protegerlo contra intrusión o vandalismo.

• Proyectos formados por componentes con dependencias de

bloqueos.

• Proceso intensivo de ficheros, que requieran accesos directos o

indexados.

• Uso de matrices multidimensionales o estructuras de datos (listas,

colas, pilas, etc.).

• Proceso de gráficos.
• Manipulación de dispositivos, puertos o “sockets”.
• Uso de bibliotecas de programación o de código propietario

.

5

2. Redirecciones.

Unix hereda 3 ficheros especiales del lenguaje de programación C, que
representan las funciones de entrada y salida de cada programa. Éstos
son:

• Entrada estándar: procede del teclado; abre el fichero descriptor

0 (stdin) para lectura.

• Salida estándar: se dirige a la pantalla; abre el fichero descriptor

1 (stdout) para escritura.

• Salida de error: se dirige a la pantalla; abre el fichero descriptor 2

(stderr) para escritura y control de mensajes de error.

El proceso de redirección permite hacer una copia de uno de estos
ficheros especiales hacia o desde otro fichero normal. También pueden
asignarse los descriptores de ficheros del 3 al 9 para abrir otros tantos
archivos, tanto de entrada como de salida.
El fichero especial /dev/null sirve para descartar alguna redirección e
ignorar sus datos.

2.1. Redirección de entrada.

La redirección de entrada sirve para abrir para lectura el archivo
especificado usando un determinado número descriptor de fichero. Se
usa la entrada estándar cuando el valor del descriptor es 0 o éste no se
especifica.
El siguiente cuadro muestra el formato genérico de la redirección de
entrada.

[N]<Fichero

La redirección de entrada se usa para indicar un fichero que contiene los
datos que serán procesados por el programa, en vez de teclearlos
directamente por teclado. Por ejemplo:

miproceso.sh < fichdatos

Sin embargo, conviene recordar que la mayoría de las utilidades y filtros
de Unix soportan los ficheros de entrada como parámetro del programa y
no es necesario redirigirlos.

6

2.2. Redirecciones de salida.

De igual forma a los descrito en el apartado anterior, la redirección de
salida se utiliza para abrir un fichero –asociado a un determinado
número de descriptor– para operaciones de escritura.
Se reservan 2 ficheros especiales para el control de salida de un
programa: la salida normal (con número de descriptor 1) y la salida de
error (con el descriptor 2).
En la siguiente tabla se muestran los formatos genéricos para las
redirecciones de salida.

Redirección

[N]> Fichero

[N]>| Fichero

[N]>> Fichero

&> Fichero

Descripción

Abre el fichero de descriptor N para escritura. Por
defecto se usa la salida estándar (N=1). Si el fichero
existe, se borra; en caso contrario, se crea.
Como en el caso anterior, pero el fichero debe existir
previamente.
Como en el primer caso, pero se abre el fichero