manual de Bash 4.1

Traducción del
Manual de Referencia para Bash (version 4.1)
Edicion 0.9
Noviembre de 2010

Chet Ramey, Case Western Reserve University
Brian Fox, Free Software Foundation
Mario Piñar Ramírez (Traducción)

Esta es una traducción no autorizada de la Documentación de Referencia de Bash. Está basada en la
Edición 4.1, para Bash versión 4.1, de Diciembre de 2009.

La última versión original (en inglés) del Manual de Referencia de Bash se puede encontrar en
el sitio oficial del programa GNU Bash: http://www.gnu.org/software/bash/bash.html

Copyright © 1988–2009 Free Software Foundation, Inc.

Se autoriza a copiar, distribuir y/o modificar este documento bajo los términos de la GNU Free
Documentation License, Versión 1.3 o cualquier versión posterior publicada por la Free Software
Foundation; sin Secciones Invariantes, sin los textos de Portada y sin los textos de Contraportada.
Se incluye una copia de la licencia en la sección titulada “GNU Free Documentation License” en el
Apéndice C, seguida por una traducción de la misma (Apéndice D) obtenida de:

http://docs.danexlandia.com.mx/gfdl/gfdl_es.f.html

Puede comunicar sugerencias o errores en la dirección traduccionbash41@gmail.com

Página ii

Datos de la Edición original:

Bash Reference Manual -
Reference Documentation for Bash
Edition 4.1, for Bash Version 4.1.
December 2009


Bash - Manual de Referencia
Documentación de Referencia para Bash
Edición 4.1, para Bash versión 4.1
Diciembre de 2009


Página iii

Presentacion de la version original
This text is a brief description of the features that are present in the Bash shell (version 4.1, 23
December 2009).
This is Edition 4.1, last updated 23 December 2009, of The GNU Bash Reference Manual, for
Bash, Version 4.1.
Copyright © 1988–2009 Free Software Foundation, Inc.
Permission is granted to make and distribute verbatim copies of this manual provided the
copyright notice and this permission notice are preserved on all copies.
Permission is granted to copy, distribute and/or modify this document under the terms of the
GNU Free Documentation License, Version 1.3 or any later version published by the Free Software
Foundation; with no Invariant Sections, with the Front-Cover texts being “A GNU Manual”, and
with the Back-Cover Texts as in (a) below. A copy of the license is included in the section entitled
“GNU Free Documentation License”.
(a) The FSF’s Back-Cover Text is: You are free to copy and modify this GNU manual. Buying
copies from GNU Press supports the FSF in developing GNU and promoting software freedom.”
Published by the Free Software Foundation
59 Temple Place, Suite 330,
Boston, MA 02111-1307
USA

Presentacion de la version original (traducida)
Este texto es una breve descripción de las características que están presentes en la shell Bash
(versión 4.1 de 23 de diciembre de 2009)
Esta es la edición 4.1, actualizada por última vez el 23 de diciembre de 2009, del Manual de
Referencia de GNU Bash para Bash Versión 4.1
Copyright © 1988-2009 Free Software Foundation, Inc.
Se concede permiso para hacer y distribuir copias literales de este manual manteniendo el aviso
de copyright y este aviso de autorización en todas las copias.
Se autoriza a copiar, distribuir y/o modificar este documento bajo los términos de la GNU Free
Documentation License, Versión 1.3 o cualquier versión posterior publicada por la Free Software
Foundation; sin Secciones Invariantes, con la portada “A GNU Manual”, y con los textos de contra-
portada como en el apartado (a) mostrado más abajo. Se incluye una copia de la licencia en la
sección titulada “GNU Free Documentation License”.
(a) El texto de contraportada de la FSF es: Eres libre de copiar y modificar este manual GNU.
Comprar copias en la GNU Press da soporte a la FSF para continuar desarrollando GNU y
promoviendo la libertad de software.

Publicado por la Free Software Foundation
59 Temple Place, Suite 330
Boston, MA 02111-1307
USA

Página iv

Índice de Contenido

Índice de contenido
1.-Introducción.....................................................................................................................................9
1.1.-¿Qué es Bash?...........................................................................................................................9
1.2.-¿Qué es una shell?....................................................................................................................9
2.-Definiciones...................................................................................................................................11
3.-Características Básicas de la Shell.................................................................................................13
3.1.-Sintaxis de la shell..................................................................................................................13
3.1.1.-Modo de operación de la shell........................................................................................13
3.1.2.-Entrecomillado................................................................................................................14
3.1.2.1.-Carácter de Escape..................................................................................................14
3.1.2.2.-Comillas simples.....................................................................................................14
3.1.2.3.-Comillas Dobles......................................................................................................14
3.1.2.4.-Entrecomillado ANSI-C..........................................................................................14
3.1.2.5.-Traducciones Específicas de la Localización..........................................................15
3.1.3.-Comentarios....................................................................................................................15
3.2.-Comandos de Shell.................................................................................................................16
3.2.1.-Comandos simples..........................................................................................................16
3.2.2.-Tuberías..........................................................................................................................16
3.2.3.-Listas de Comandos........................................................................................................17
3.2.4.-Comandos Compuestos..................................................................................................17
3.2.4.1.-Construcciones Cíclicas..........................................................................................18
3.2.4.2.-Construcciones Condicionales................................................................................18
3.2.4.3.-Agrupando Comandos.............................................................................................21
3.2.5.-Coprocesos......................................................................................................................22
3.3.-Funciones de Shell..................................................................................................................23
3.4.-Parámetros de Shell................................................................................................................24
3.4.1.-Parámetros posicionales..................................................................................................25
3.4.2.-Parámetros Especiales.....................................................................................................25
3.5.-Expansiones de la shell...........................................................................................................26
3.5.1.-Expansión de Llaves.......................................................................................................27
3.5.2.-Expansión de Tildes........................................................................................................27
3.5.3.-Expansión de Parámetros de Shell..................................................................................28
3.5.4.-Sustitución de Comandos...............................................................................................31
3.5.5.-Expansión Aritmética.....................................................................................................32
3.5.6.-Sustitución de Procesos..................................................................................................32
3.5.7.-Separación de palabras....................................................................................................33
3.5.8.-Expansión de Nombres de Fichero.................................................................................33
3.5.8.1.-Concordancia de Patrones.......................................................................................34
3.5.9.-Eliminación del entrecomillado......................................................................................35
3.6.-Redirecciones.........................................................................................................................35
3.6.1.-Redireccionando la entrada.............................................................................................36
3.6.2.-Redireccionando la salida...............................................................................................36

Página v


3.6.3.-Anexando la salida redirigida.........................................................................................37
3.6.4.-Redirigiendo la Salida Estándar y la Salida de Error Estándar.......................................37
3.6.5.-Anexando la Salida Estándar y la Salida de Error Estándar...........................................37
3.6.6.-Documentos Internos (Here Documents).......................................................................37
3.6.7.-Cadenas Internas (Here strings)......................................................................................38
3.6.8.-Duplicando Descriptores de Fichero...............................................................................38
3.6.9.-Moviendo Descriptores de Fichero.................................................................................38
3.6.10.-Abriendo descriptores de fichero para lectura y escritura............................................38
3.7.-Ejecutando comandos.............................................................................................................39
3.7.1.-Expansión de un comando simple..................................................................................39
3.7.2.-Búsqueda y Ejecución de Comandos..............................................................................39
3.7.3.-Entorno de Ejecución de Comandos...............................................................................40
3.7.4.-Entorno...........................................................................................................................41
3.7.5.-Estados de Salida............................................................................................................42
3.7.6.-Señales............................................................................................................................42
3.8.-Guiones de Shell.....................................................................................................................43
4.-Comandos Internos de la Shell.......................................................................................................44
4.1.-Comandos Internos de la Shell Bourne..................................................................................44
4.2.-Comandos Internos de Bash...................................................................................................51
4.3.-Modificando el Comportamiento de la Shell..........................................................................61
4.3.1.-El comando Interno Set..................................................................................................61
4.3.2.-El Comando Interno Shopt.............................................................................................66
4.4.-Comandos Internos Especiales...............................................................................................71
5.-Variables de Shell..........................................................................................................................73
5.1.-Variables de la Shell Bourne..................................................................................................73
5.2.-Variables de Bash...................................................................................................................74
6.-Características de Bash..................................................................................................................85
6.1.-Invocando a Bash...................................................................................................................85
6.2.-Ficheros de Inicio de Bash.....................................................................................................87
6.3.-Shells Interactivas...................................................................................................................89
6.3.1.-¿Qué es una Shell Interactiva?........................................................................................89
6.3.2.-¿Es esta una shell Interactiva?........................................................................................89
6.3.3.-Comportamiento de la Shell Interactiva.........................................................................89
6.4.-Expresiones Condicionales de Bash.......................................................................................91
6.5.-Aritmética de la Shell.............................................................................................................93
6.6.-Alias........................................................................................................................................94
6.7.-Arrays.....................................................................................................................................95
6.8.-La Pila de Directorios.............................................................................................................96
6.8.1.-Comandos Internos de la Pila de Directorios..................................................................96
6.9.-Controlando el Prompt...........................................................................................................97
6.10.-La Shell Restringida.............................................................................................................99
6.11.-El Modo POSIX de Bash......................................................................................................99
7.-Control de Tareas.........................................................................................................................103

Página vi


7.1.-Fundamentos del Control de Tareas.....................................................................................103
7.2.-Comandos Internos para el Control de Tareas.....................................................................104
7.3.-Variables para el Control de Tareas.....................................................................................106
8.-Edición de la Línea de Comandos................................................................................................107
8.1.-Introducción a la Edición de la Línea de Comandos............................................................107
8.2.-Interacción con Readline......................................................................................................107
8.2.1.-Los Fundamentos de Readline al Desnudo...................................................................108
8.2.2.-Comandos de Movimiento de Readline........................................................................108
8.2.3.-Comandos para cortar texto de Readline......................................................................109
8.2.4.-Argumentos de Readline...............................................................................................109
8.2.5.-Buscando Comandos en la Historia..............................................................................110
8.3.-El Fichero de Inicialización de Readline..............................................................................110
8.3.1.-La Sintaxis del Fichero de Inicialización de Readline..................................................111
8.3.2.-Construcciones de inicialización condicionales...........................................................117
8.3.3.-Ejemplo de Fichero de Inicialización...........................................................................118
8.4.-Comandos enlazables de Readline.......................................................................................120
8.4.1.-Comandos de Movimiento............................................................................................120
8.4.2.-Comandos para Manipular la Historia..........................................................................121
8.4.3.-Comandos para Modificar el Texto..............................................................................122
8.4.4.-Cortando y Pegando......................................................................................................123
8.4.5.-Especificando Argumentos Numéricos........................................................................125
8.4.6.-Permitiendo que Readline introduzca caracteres por tí................................................125
8.4.7.-Macros de Teclado........................................................................................................127
8.4.8.-Algunos comandos variados.........................................................................................127
8.5.-Modo vi de Readline............................................................................................................130
8.6.-Completado Programable.....................................................................................................130
8.7.-Comandos Internos para el Completado Programable.........................................................132
9.-Usando la Historia Interactivamente............................................................................................137
9.1.-Características de Historia de Bash......................................................................................137
9.2.-Comandos Internos para la Historia de Bash.......................................................................138
9.3.-Expansión de la Historia.......................................................................................................139
9.3.1.-Designadores de Evento...............................................................................................140
9.3.2.-Designadores de Palabra...............................................................................................140
9.3.3.-Modificadores...............................................................................................................141
10.-Instalando Bash..........................................................................................................................143
10.1.-Instalación Básica...............................................................................................................143
10.2.-Compiladores y Opciones...................................................................................................144
10.3.-Compilando para Múltiples Arquitecturas.........................................................................144
10.4.-Nombres de Instalación......................................................................................................144
10.5.-Especificando el Tipo de Sistema.......................................................................................145
10.6.-Compartiendo Valores por Defecto....................................................................................145
10.7.-Controles de Operación......................................................................................................145
10.8.-Características Opcionales..................................................................................................145

Página vii


Apéndice A: Informando de errores................................................................................................150
C.2.-Diferencias Principales con la Shell de Bourne........................................................................151
B.1.-Diferencias de Implementación con la Shell SVR4.2.........................................................156
Apéndice C: GNU Free Documentation License............................................................................157
C.0.-PREAMBLE........................................................................................................................157
C.1.-APPLICABILITY AND DEFINITIONS............................................................................157
C.2.-VERBATIM COPYING......................................................................................................158
C.3.-COPYING IN QUANTITY.................................................................................................159
C.4.-MODIFICATIONS..............................................................................................................159
C.5.-COMBINING DOCUMENTS............................................................................................161
C.6.-COLLECTIONS OF DOCUMENTS..................................................................................161
C.7.-AGGREGATION WITH INDEPENDENT WORKS.........................................................161
C.8.-TRANSLATION.................................................................................................................162
D.0.1.-TERMINATION..............................................................................................................162
C.9.-FUTURE REVISIONS OF THIS LICENSE.......................................................................162
C.10.-RELICENSING.................................................................................................................163
C.11.-ADDENDUM: How to use this License for your documents...........................................163
Apéndice D: Licencia de Documentación Libre de GNU (Traducción).........................................164
D.0.-PREÁMBULO.....................................................................................................................164
D.1.-APLICABILIDAD Y DEFINICIONES..............................................................................164
D.2.-COPIA LITERAL................................................................................................................166
D.3.-COPIADO EN CANTIDAD...............................................................................................166
D.4.-MODIFICACIONES...........................................................................................................167
D.5.-COMBINACIÓN DE DOCUMENTOS.............................................................................168
D.6.-COLECCIONES DE DOCUMENTOS...............................................................................169
D.7.-AGREGACIÓN CON TRABAJOS INDEPENDIENTES.................................................169
D.8.-TRADUCCIÓN...................................................................................................................169
D.9.-TERMINACIÓN.................................................................................................................169
D.9.1.-REVISIONES FUTURAS DE ESTA LICENCIA...........................................................170
D.10.-RE-LICENCIAMIENTO...................................................................................................170
D.11.-ADDENDUM: Cómo usar esta Licencia en sus documentos...........................................171
D.12.-Notas:.................................................................................................................................171
D.13.-Referencias:.......................................................................................................................171
Apéndice E: Índices.........................................................................................................................172
E.1.-Índice de Comandos Internos de la Shell............................................................................172
E.2.-Índice de Palabras Reservadas de la Shell..........................................................................173
E.3.-Índice de Parámetros y Variables........................................................................................173
E.4.-Índice de Funciones............................................................................................................175

Página viii

Capítulo 1: Introducción

1.- Introducción

1.1.- ¿Qué es Bash?
Bash es la shell, o interprete de comandos, para el sistema operativo GNU. El nombre es un
acrónimo para el 'Bourne-Again Shell', un juego de palabras de Stephen Bourne, el autor del prede-
cesor directo del actual shell Unix sh, que apareció en la Séptima Edición de la versión de Unix de
los Bell Labs Research (Laboratorios de Investigación de Bell).
Bash es ampliamente compatible con sh e incorpora características muy útiles de la Korn shell
ksh y la C shell csh. Busca ser una implementación conforme al IEEE POSIX Shell y Herramientas
parte de la especificación POSIX del IEEE (estándar IEEE 1003.1). Ofrece mejoras funcionales
frente a sh tanto para uso interactivo como de programación.
Aunque el sistema operativo GNU proporciona otras shells, incluida una versión de csh, la
shell Bash es la shell por defecto. Al igual que el resto del software GNU, Bash es bastante
portable. Actualmente corre en casi todas las versiones de Unix y en algunos sistemas operativos
más – existen implementaciones independientes para las plataformas MS-DOS, OS/2, y Windows.

1.2.- ¿Qué es una shell?
En esencia una shell es simplemente un procesador de macros que ejecuta comandos. El término
procesador de macros indica una funcionalidad donde texto y símbolos son expandidos para crear
expresiones más largas.
Una shell de Unix es a la vez un interprete de comandos y un lenguaje de programación. Como
interprete de comandos, la shell proporciona una interfaz de usuario para el amplio juego de utili-
dades GNU. Las capacidades de lenguaje de programación permiten combinar estas utilidades. Se
pueden crear archivos que contengan comandos, y que lleguen a ser comandos por si mismos. Estos
nuevos comandos tienen la misma categoría que los comandos del sistema situados en directorios
como '/bin', permitiendo a los usuarios o grupos establecer entornos personalizados para automa-
tizar sus tareas comunes.
Las shells se pueden utilizar de modo interactivo o no-interactivo. En modo interactivo aceptan
entradas desde el teclado. Cuando se ejecutan en modo no-interactivo, las shells ejecutan comandos
leídos desde un fichero.
Una shell permite la ejecución de comandos GNU tanto de forma síncrona como asíncrona. La
shell espera hasta que se completan los comandos síncronos antes de aceptar más entradas; los
comandos asíncronos continúan ejecutándose paralelamente a la shell mientras que esta lee y
ejecuta otros comandos. La redirección permite un control detallado de la entrada y la salida de
estos comandos. Más aún, la shell permite controlar el contenido de los entornos de los comandos.
Las shells también proporcionan un pequeño juego de comandos internos (builtins) implemen-
tando funcionalidades que mediante utilidades separadas serían imposibles de obtener o lo harían de
forma poco apropiada. Por ejemplo, no se puede implementar a cd, break, continue y exec fuera
de la shell porque estas manipulan directamente la propia shell. Los comandos internos history,
getopts, kill o pwd, a parte de otros, pueden ser implementados en utilidades separadas, pero son
más convenientes usados como comandos internos. Todos los comandos internos de la shell serán
descritos en las secciones siguientes.
Mientras que la ejecución de comandos es esencial, gran parte del poder (y complejidad) de la

Página 9

Capítulo 1: Introducción

shell se debe a los lenguajes de programación embebidos en ella. Como cualquier lenguaje de alto
nivel, la shell proporciona variables, construcciones de control del flujo, entrecomillado y
funciones.
Las shells ofrecen características orientadas específicamente para el uso interactivo más que
para aumentar el lenguaje de programación. Estas características interactivas incluyen control de
tareas, edición de la linea de comandos, historia de comandos y alias. Cada una de estas caracterís-
ticas son descritas en este manual.

Página 10

Capítulo 2: Definiciones

2.- Definiciones
Estas definiciones son usadas a lo largo de este manual
POSIX
Una familia de estándares libres basados en Unix. Bash se ve afectado principalmente
por la parte Shell y Utilidades del estándar POSIX 1003.1.
blanco (blank)
Un carácter espacio o tabulador
comando interno o builtin
Un comando que es implementado internamente por la shell, en vez de por un programa
ejecutable en algún lugar del sistema de ficheros.
operadores de control
Un token que realiza una función de control. Es una nueva linea o alguno de los
siguientes: ‘||’, ‘&&’, ‘&’, ‘;’, ‘;;’, ‘|’, ‘|&’, ‘(’, o ‘)’.
estado de salida
El valor retornado por un comando a su llamador. Este valor está restringido a ocho bits,
así que el valor máximo es 255.
campo
Una unidad de texto que es el resultado de una de las expansiones de la shell. Tras la
expansión, cuando se ejecuta un comando, los campos resultantes son usados como
nombre de comando y argumentos
nombre de archivo
Una cadena de caracteres usados para identificar un archivo.
tarea
Un juego de procesos que componen una tubería, y los procesos que descienden de
estos, que están todos en el mismo grupo de procesos.
control de tareas
Un mecanismo por el cual los usuarios pueden parar (suspender) y reiniciar (reanudar)
selectivamente la ejecución de procesos.
metacaracter
Un carácter que, cuando se encuentra sin entrecomillar, separa palabras. Un metaca-
racter es un blanco o uno de los siguientes caracteres: ‘|’, ‘&’, ‘;’, ‘(’, ‘)’, ‘<’, o ‘>’.
nombre
Una palabra consistente únicamente en letras, números y caracteres de subrayado, y que
comienza con una letra o un carácter de subrayado. Los nombres se usan como nombres
de variables de shell y de funciones. También se le llama identificador.
operador
Un operador de control o un operador de redirección. Vea en la sección 3.6 [Redirec-
ciones], una lista de operadores de redirección. Los operadores contienen al menos un

Página 11

Capítulo 2: Definiciones

metacaracter sin entrecomillar.
grupo de procesos
Una colección o procesos relacionados cada uno de los cuales tiene el mismo
identificador de grupo de procesos.
identificador (o ID) de grupo de procesos
Un identificador único que representa un grupo de procesos durante su tiempo de vida.
palabra reservada
Una palabra que tiene un significado especial para la shell. La mayoría de las palabras
reservadas introducen en la shell construcciones de control de flujo, como for y while.
estado de retorno
Un sinónimo para el estado de salida.
señal
Un mecanismo por el que cualquier proceso puede ser notificado por el kernel de un
evento ocurrido en el sistema.
comandos internos especiales
Un comando interno de la shell que ha sido clasificado como especial por el estándar
POSIX
token (o componente léxico)
Una secuencia de caracteres considerados una unidad única por el shell. Puede ser bien
una palabra o un operador.
palabra
Una secuencia de caracteres tratados como una unidad por el shell. Las palabras no
pueden incluir metacaracteres sin entrecomillar.

Página 12

Capitulo 3: Características Básicas del Shell

3.- Características Básicas de la Shell
Bash es un acrónimo para 'Bourne-Again Shell'. La shell Bourne es la shell Unix tradicional escrita
originalmente por Stephen Bourne. Todos los comandos internos de la shell Bourne están
disponibles en Bash. Las reglas para evaluación y entrecomillado están tomadas de la especificación
POSIX para la shell Unix 'estándar'.
Este capítulo resume brevemente los 'bloques de construcción' de la shell: comandos,
estructuras de control, funciones de shell, parámetros de shell, expansiones de shell, redirecciones,
que son un modo de dirigir la entrada y la salida desde y hacia un nombre de archivo, y la forma en
la que la shell ejecuta comandos.

3.1.- Sintaxis de la shell
Cuando la shell lee una entrada, procede a realizar una secuencia de operaciones. Si la entrada
indica el principio de un comentario, la shell ignora el signo de comentario ('#') y el resto de esa
línea.
En caso contrario, hablando de forma aproximada, la shell lee su entrada y divide esta en
palabras y operadores, empleando las reglas de entrecomillado para seleccionar qué significado
debe asignar a las palabras y caracteres.
La shell luego analiza esos tokens en comandos y otras construcciones, elimina el significado
especial de ciertas palabras o caracteres, expande otras, redirecciona la entrada y la salida según sea
necesario, ejecuta los comandos especificados, espera por el estado de salida de los comandos, y
pone disponible ese estado de salida para favorecer su inspección o procesamiento.

3.1.1.- Modo de operación de la shell
Lo que sigue es una breve descripción del modo en que trabaja la shell cuando esta lee y ejecuta un
comando. Básicamente, la shell hace lo siguiente:
1. Lee su entrada desde un archivo (vea la Sección 3.8 [Guiones de shell]), desde una cadena
suministrada como un argumento a la opción de invocación ' -c' (vea la Sección 6.1
[Invocando a Bash], o desde la terminal del usuario.
2. Rompe la entrada en palabras y operadores, obedeciendo las reglas de entrecomillado des-
critas en la Sección 3.1.2 [Entrecomillado]. Estos tokens están separados por metacaracteres.
La expansión de Alias se realiza en este paso (vea Sección 6.6 [Alias]
3. Analiza sintácticamente los tokens en comandos simples y compuestos (vea Sección 3.2
[Comandos de Shell])
4. Realiza varias expansiones de shell (vea la Sección 3.5 [Expansiones de la Shell], rompe los
tokens expandidos en listas de nombres de ficheros (vea Sección 3.5.8 [Expansión de
Nombres de Fichero]) y comandos y argumentos.
5. Realiza cualquier redirección que sea necesaria (vea la Sección 3.6 [Redirecciones]) y
elimina los operadores de redirección y sus operandos de la lista de argumentos.
6. Ejecuta el comando (vea la Sección 3.7 [Ejecutando Comandos]).
7. Opcionalmente espera hasta que se complete la ejecución del comando y recolecta su estado
de salida (vea la Sección 3.7.5 [Estados de salida]).

Página 13


3.1.2.- Entrecomillado
El entrecomillado es usado para eliminar el significado especial a ciertos caracteres o palabras para
la shell. El entrecomillado puede ser usado para eliminar el tratamiento especial para los caracteres
especiales, o para prevenir a las palabras reservadas de ser reconocidas como tales, y para prevenir
la expansión de parámetros.
Cada uno de los metacaracteres de shell (vea el Capítulo 2 [Definiciones]) tiene un significado
especial para el shell y debe ser entrecomillado si se representa a sí mismo. Cuando se está usando
las habilidades de expansión de la historia de comandos (vea la Sección 9.3 [Interacciones con la
Historia]), el carácter de expansión de la historia, normalmente '!', debe ser entrecomillado para
prevenir la expansión de la historia. Vea la Sección 9.1 [Características de Historial de Bash], para
más detalles concernientes a la expansión de la historia.
Hay tres mecanismos de entrecomillado: El carácter de escape, las comillas simples y las
comillas dobles.
3.1.2.1.- Carácter de Escape
El carácter de escape consiste en una barra invertida sin entrecomillar ''. Esta mantiene el valor
literal del carácter que le sigue, con la excepción de la nueva línea. Si aparece una pareja
nueva_linea esta es tratada como una continuación de línea (esto es, esta es eliminada del flujo de
entrada e ignorada completamente).
3.1.2.2.- Comillas simples
Encerrar caracteres en comillas simples (''') mantiene el valor literal de cualquier carácter situado
entre las comillas. Una comilla simple no puede aparecer encerrada entre comillas simples, incluso
cuando es precedida por una barra invertida.
3.1.2.3.- Comillas Dobles
Encerrar caracteres entre comillas dobles ('”') mantiene el valor literal de todos los caracteres
dentro de las comillas, con la excepción de '$', ''', '' y, cuando la expansión de la historia está
habilitada, '!'. Los caracteres '$' y ''' mantienen su significado especial dentro de comillas dobles
(Vea la Sección 3.5 [Expansiones de Shell]). La barra invertida mantiene su significado especial
sólo cuando es seguida por uno de los siguientes caracteres: '$', ''', '', o nueva linea. Dentro
de comillas dobles, las barras invertidas que son seguidas por uno de estos caracteres son
eliminadas. Las barras invertidas que preceden caracteres sin un significado especial permanecen
como tales. Una comilla doble puede ser entrecomillada dentro de dobles comillas precediéndola
con una barra invertida. Si está habilitada la expansión de la historia de comandos esta se realizará a
menos que el signo '!' que aparece entre las comillas dobles sea escapado usando una barra
invertida. La barra invertida precediendo al '!' no es eliminada.
Los parámetros especiales '*' y '@' tienen un significado especial cuando aparecen encerrados
entre comillas dobles (vea la sección 3.5.3 [Expansión de parámetros de la Shell]).
3.1.2.4.- Entrecomillado ANSI-C
Las palabras de la forma $'cadena' son tratadas de forma especial. La palabra se expande a cadena,
con los caracteres escapados por barras invertidas reemplazados como se especifica por el estándar
ANSI C. Las secuencias de escape con barra invertida, si están presentes, son decodificadas como

Página 14


sigue:
a alerta(campana)
b retroceso (elimina el carácter anterior)
e
E un carácter de escape (no ANSI C)
f carácter de alimentación de línea (form feed)
n carácter de nueva línea
r carácter de retorno de carro
t tabulador horizontal
v tabulador vertical
carácter barra invertida
' carácter comilla simple
” carácter comilla doble
nnn el carácter de 8 bits cuyo valor es el número octal nnn (de uno a tres
dígitos).
xHH el carácter de 8 bits cuyo valor es el número hexadecimal HH (uno o dos
dígitos hexadecimales)
cx un carácter control-x
El resultado expandido se encuentra entrecomillado con comilla simple, como si el signo '$' no
estuviese presente.
3.1.2.5.- Traducciones Específicas de la Localización
Una cadena entrecomillada con comillas dobles precedida por un signo ('$') causará que la cadena
sea traducida de acuerdo a la localización actual. Si la localización actual es C o POSIX, el signo
dólar es ignorado. Si la cadena es traducida y reemplazada, el sustituto es entrecomillado con
comillas dobles.
Algunos sistemas usan el catálogo de mensajes seleccionado por la variable de shell
LC_MESSAGES . Otros crean el nombre del catálogo de mensajes a partir del valor de la variable
del shell TEXTDOMAIN , posiblemente añadiendo un sufijo o '.mo'. Si usa la variable
TEXTDOMAIN , puede necesitar ajustar la variable TEXTDOMAINDIR a la localización de los
archivos del catálogo de mensajes. Otros incluso usan ambas variables de la forma:
TEXTDOMAINDIR/LC_MESSAGES/TEXTDOMAIN.mo.

3.1.3.- Comentarios
En una shell
no-interactiva, o en una shell interactiva en la que la opción
interactive_comments para el comando interno shopt está activada (vea la sección 4.3.2 [ El
Comando Interno Shopt]), una palabra comenzando con '#' provoca que la palabra y todos los
caracteres que le siguen en esa línea sean ignorados. Una shell interactiva sin la opción

Página 15


interactive_comments activada no permite comentarios. La opción interactive_coments
está establecida por defecto en las shells interactivas. Vea la sección 6.3 [Shells Interactiva], para
una descripción de qué hace una shell interactiva.

3.2.- Comandos de Shell
Un comando de shell simple como echo a b c consiste en el propio comando seguido por argu-
mentos separados por espacios.
Comandos de shell más complejos están compuestos de comandos simples situados juntos de
varias formas; en una tubería en la cual la salida de un comando se convierte en la entrada del
segundo, en una construcción tipo bucle o condicional, o en algunas otras agrupaciones.

3.2.1.- Comandos simples
Un comando simple es el tipo de comando que se encuentra con más frecuencia. Este es sólo una
secuencia de palabras separadas por blancos, terminada por uno de los operadores de control de la
shell (vea el Capítulo 2 [Definiciones]). La primera palabra generalmente especifica un comando
para ser ejecutado, con el resto de las palabras como argumentos del comando.
El estado de retorno (vea la Sección 3.7.5 [Estado de salida]) de un comando simple es su
estado de salida como viene especificado por la función POSIX 1003.1 waitpid, o 128+n si el
comando fue terminado por la señal n.

3.2.2.- Tuberías
Una tubería es una secuencia de comandos simples separados por uno de los operadores de control
'|' o '|&'.
El formato de uso de una tubería es:
[time [-p]] [!] comando1 [ [| ir |&] comando2 … ]
La salida de cada comando en la tubería es conectado a través del cauce a la entrada del
siguiente comando. Esto es, cada comando lee la salida del comando previo. Esta conexión se
establece antes de realizar cualquier redirección especificada por el comando.
Si se usa '|&' la salida de error estándar del comando1 es conectada a la entrada estándar del
comando2 a través del cauce; es una forma corta para 2>&1. Esta redirección implícita de la salida
de error estándar es realizada después de cualquier redirección especificada en el comando.
La palabra reservada time produce que se impriman estadísticas de tiempo para la tubería una
vez que esta finaliza. Las estadísticas actualmente consisten en el tiempo transcurrido y tiempo de
usuario y de sistema consumidos por la ejecución del comando. La opción '-p' cambia el formato de
salida por el especificado por POSIX. La variable TIMEFORMAT puede ser ajustada a una cadena
de formato que especifique como se debe mostrar la información de los tiempos. Vea la Sección 5.2
[Variables de Bash] para obtener una descripción de los formatos disponibles. El uso de time como
palabra reservada permite el cronometrado de los comandos internos de la shell, las funciones de
shell y las tuberías. Un comando externo time no podría hacer esto fácilmente.
Si la tubería no es ejecutada de forma asíncrona (vea la Sección 3.2.3 [Listas]) la shell espera
hasta que se completen todos los comandos de la tubería.
Cada comando en una tubería es ejecutado en su propia subshell (vea la Sección 3.7.3 [Entorno
de Ejecución de Comandos]). El estado de salida de una tubería es el estado de salida de el último

Página 16


comando en la tubería, a menos que la opción pipefail esté activada (vea la Sección 4.3.1 [El
Comando Interno Set]) Si pipefail está activado, el estado de retorno de la tubería es el valor del
último comando (el más a la derecha) en salir con un estado distinto de cero, o cero si todos los
comandos salen satisfactoriamente. Si la palabra reservada '!' precede a la tubería, el estado de
salida es la negación lógica del estado de salida como se describió más arriba. El shell espera hasta
que todos los comandos en la tubería terminen antes de retornar un valor.

3.2.3.- Listas de Comandos
Una lista es una secuencia de una o más tuberías separadas por uno de los siguientes operadores:
';', '&', '&&', o '||', y opcionalmente terminada por uno de los siguientes: ';', '&', o una nueva
línea.
De estos operadores de lista '&&' y '||' tienen igual precedencia, seguidos por ';' y '&', que
tienen igual precedencia.
Una secuencia de una o más nuevas líneas pueden aparecer en una lista para delimitar
comandos, esto equivale a un punto y coma.
Si un comando termina con el operador de control '&' la shell ejecuta el comando de forma
asíncrona en una subshell. Esto es conocido como ejecutar el comando en segundo plano. La shell
no espera a que el comando finalice, y el estado de retorno es 0 (verdadero). Cuando el control de
tareas no está activado (vea el Capítulo 7 [Control de Tareas]), la entrada estándar para los
comandos asíncronos, en ausencia de alguna redirección explícita, es redirigida desde /dev/null.
Los comandos separados por un ';' se ejecutan secuencialmente; la shell espera para que cada
comando finalice turnándose con el siguiente. El estado de retorno es el estado de retorno del último
comando ejecutado.
Las listas Y (AND) y O (OR) son secuencias de una o más tuberías separadas por los opera-
dores de control '&&' y '||' respectivamente. Las listas AND y OR son ejecutadas con asociatividad
a la izquierda
Una lista AND tiene la forma
comando1 && comando2
comando2 se ejecuta sí y sólo sí el comando1 retorna un estado de salida de cero.
Una lista OR tiene la forma
comando1 || comando2
comando2 se ejecuta sí y sólo sí, el comando1 retorna un valor de salida distinto de cero.
El estado de retorno de las listas AND y OR es el estado de salida del último comando
ejecutado en la lista.

3.2.4.- Comandos Compuestos
Los comandos compuestos son las construcciones de programación de la shell. Cada construcción
comienza con una palabra reservada o un operador de control y termina con otra correspondiente
palabra reservada u operador. Cualquier redirección (vea la Sección 3.6 [Redirecciones]) asociada
con un comando compuesto se aplica a todos los comandos dentro de ese comando compuesto, a
menos que sea sobreescrito explícitamente.
Bash proporciona construcciones cíclicas, comandos condicionales y mecanismos para agrupar
comandos y ejecutarlos como una unidad.

Página 17


3.2.4.1.- Construcciones Cíclicas
Bash soporta las siguientes construcciones cíclicas (en forma de bucle).
Note que en cualquier lugar en el que aparezca un ';' en la descripción de la sintaxis de un
comando este puede ser reemplazado por una o más nuevas líneas.
until
La sintaxis del comando until es:
until comandos-test; do comandos-consiguientes; done
Ejecuta los comandos-consiguientes mientras que los comandos-test tengan un estado de
salida distinto de cero. El estado de retorno es el estado de salida del último comando
ejecutado en comandos-consiguientes, o cero si no se ejecutó ninguno.
while
La sintaxis del comando while es:
while comandos-test; do comandos-consiguientes; done
Ejecuta los comandos-consiguientes mientas que los comandos-test tengan un estado de
salida igual a cero. El estado de retorno es el estado de salida del último comando
ejecutado en comandos-consiguientes, o cero si no se ejecutó ninguno.
for
La sintaxis del comando for es:
for nombre [ [in [palabras …] ] ; ] do comandos; done
Expande las palabras y ejecuta los comandos uno por cada miembro en la lista resul-
tante, con nombre asignado al miembro actual. Si 'in palabras' no está presente, el
comando for ejecuta los comandos uno por cada parámetro posicional que se le pase,
como si se hubiera especificado ' in $@' (vea la Sección 3.4.2 [Parámetros Especiales]).
El estado de retorno es el estado de salida del último comando que ejecuta. Si no hay
miembros en la expansión de palabras, no se ejecuta ningún comando y el estado de
retorno es cero.
Bash también soporta una forma alternativa para el comando for:
for (( expr1 ; expr2 ; expr3 )) ; do comandos ; done
Primero se evalúa la expresión aritmética expr1 de acuerdo con las reglas descritas más
abajo (vea la Sección 6.5 [Aritmética de la Shell]). La expresión aritmética expr2 se
evalúa a continuación repetidamente hasta que se evalúa como distinta de cero. Cada
vez que expr2 se evalúa con un valor distinto de cero, se ejecutan los comandos y se
evalúa la expresión expr3 .Si se omite alguna expresión se toma como si esta se evaluara
a 1. El valor devuelto es el estado de salida del último comando en la lista que es
ejecutado, o false si alguna de las expresiones es inválida.
Los comandos internos break y continue (vea la Sección 4.1 [Comandos internos de la Shell
Bourne]) pueden ser usados para controlar la ejecución del bucle.
3.2.4.2.- Construcciones Condicionales

if
La sintáxis del comando if es:

Página 18


if comandos-test; then
comandos-consiguientes
[elif mas-comandos-test; then
más-siguientes;]
[else alternativas-consiguientes; ]
fi
La lista de comandos-test se ejecuta y si esta retorna un estado igual a cero se ejecuta la
lista de comandos-consiguientes. Si los comandos-test retornan un estado distinto de
cero, se ejecuta cada lista elif en turnos, y si su estado de salida es igual a cero, se
ejecutan los correspondientes mas-consiguientes y el comando finaliza. Si la
construcción 'else alternativas-consiguientes' está presente y el comando final en la
última clausula if o elif tiene un estado de salida distinto de cero, entonces se ejecutan
las alternativas-consiguientes. El estado de retorno es el estado de salida del último
comando ejecutado o cero si ninguna condición fue evaluada como true.
case
La sintaxis del comando case es:
case palabra in [ [(] patrón [| patrón] ….) lista-
comandos ;;]... esac
case ejecutará selectivamente la lista-comandos correspondiente al primer patrón que se
ajusta con palabra. Si la opción de shell nocasematch (vea la descripción de shopt en
la Sección 4.3.2 [El Comando Interno Shopt]) está activada, el ajuste se realiza sin
diferenciar entre mayúsculas y minúsculas para los caracteres alfabéticos. El '|' se usa
para separar patrones múltiples, y el operador ')' termina una lista de patrones. Una lista
de patrones y su lista de comandos asociada se conoce como una clausula.
Cada clausula debe terminar con ';;', ';&' o ';;&'. La palabra sufre expansión de tildes,
expansión de parámetros, sustitución de comandos, expansión aritmética y eliminación
de entrecomillado antes de intentar el ajuste. Cada patrón sufre expansión del tildes,
expansión de parámetros, sustitución de comandos y expansión aritmética.
Puede haber un número arbitrario de clausulas case, cada una terminada con un ';;',
';&' o ';;&'. El primer patrón que ajusta determina la lista-comandos que será ejecutada.
Aquí hay un ejemplo usando case en un guión que puede ser usado para describir una
interesante característica de un animal:
echo -n "Introduzca el nombre de un animal: "
read ANIMAL
echo -n "El $ANIMAL tiene "
case $ANIMAL in
caballo | perro | gato) echo -n "cuatro";;
hombre | canguro ) echo -n "dos";;
*) echo -n "un número desconocido de";;
esac
echo " patas."
Si se utiliza el operador ';;' no se intenta ningún ajuste adicional tras el primer patrón
encontrado. Usar ';&' en vez de ';;' produce que la ejecución continúe con la
lista- comandos asociada con la siguiente clausula, si hay alguna. Usar ';;&' en vez de
';;' produce que la shell pruebe a ajustar los patrones en la siguiente clausula, si hay
alguna, y ejecuta cualquier lista-comandos asociada a los ajustes conseguidos.

Página 19


El estado de retorno es cero si no se ajusta a ningún patrón. De otro modo, el estado de
retorno es la salida del estado de la lista-comandos ejecutada.
select
La construcción select permite generar menús fácilmente. Esta tiene casi la misma
sintaxis que el comando for:
select nombre [ in palabras …]; do comandos; done
Se expande la lista de palabras que siguen a in, generando una lista de items. El juego
de palabras expandidas se imprime en el flujo de la salida de error estándar, cada una
precedida por un número. Si se omite la construcción ' in palabras' se imprimen los
parámetros posicionales, como si se hubiese especificado ' in “$@”'. A continuación se
muestra el prompt PS3 y se lee una línea desde la entrada estándar. Si la linea consiste
en un número correspondiente a una de las palabras mostradas, entonces el valor de
nombre es ajustado a esa palabra. Si la linea está vacía, las palabras y el prompt se
muestran de nuevo. Si se lee EOF (fin de fichero), el comando select finaliza. Cualquier
otro valor leído produce que nombre se establezca a null. La linea leída es salvada en la
variable REPLY.
Los comandos son ejecutados en cada selección hasta que se ejecuta un comando break,
punto en el que el comando select finaliza.
A continuación tenemos un ejemplo que permite al usuario elegir un nombre de fichero
del directorio actual y mostrar el nombre y el índice del archivo seleccionado:
select fname in *;
do
echo usted seleccionó $fname ($REPLY)
break;
done
(( … ))
(( expresión ))
La expresión aritmética se evalúa de acuerdo a las reglas descritas más abajo (vea la
sección 6.5 [Aritmética del Shell]). Si el valor de la expresión es distinta de cero, el
estado de retorno es 0; de otro modo el estado de retorno es 1. Esto es exactamente
equivalente a
let “expresión”
Vea la Sección 4.2 [Comandos Internos de Bash] para una descripción completa del
comando interno let.
[[ … ]]
[[ expresión ]]
Devuelve un estado de 0 ó 1 dependiendo de la evaluación de la expresión condicional
expresión. Las expresiones se componen de expresiones fundamentales descritas más
abajo en la Sección 6.4 [Expresiones Condicionales de Bash]. La división de palabras y
la expansión de nombres de archivo no se realiza en las palabras encerradas entre '[[' y
']]'; se realizan la expansión de tildes, la expansión de parámetros y variables, la
expansión aritmética, la sustitución de comandos, la sustitución de procesos y la
eliminación del entrecomillado. Los operadores condicionales como '-f' deben ser

Página 20


desentrecomillados para que sean reconocidos como primarios. Cuando se usan con ' [[',
los operadores '<' y '>' ordenan lexicográficamente usando la localización actual.
Cuando se usan los operadores '==' y '!=' la cadena a la derecha del operador se
considera como un patrón y ajusta conforme a las reglas descritas más abajo, en la
Sección 3.5.8.1 [Ajuste a Patrones]. Si la opción de shell nocasematch (vea la
descripción de shopt en la Sección 4.3.2 [El Comando Interno Shopt]) está activada, el
ajuste se realiza sin diferenciar entre minúsculas y mayúsculas en el caso de caracteres
alfabéticos. El valor devuelto es 0 si las cadenas ajustan ('==') o no ajustan ('!=') al
patrón, y 1 de otro modo. Cualquier parte del patrón puede ser entrecomillada para
forzar a que sea ajustada como una cadena.
Hay un operador binario adicional '=~ ', con la misma precedencia que '==' y '!=' .
Cuando se utiliza este la cadena a la derecha del operador es considerada como una
expresión regular extendida y ajustada en consecuencia (como en regex3). El valor
devuelto es 0 si la cadena ajusta al patrón, y 1 en otro caso. Si la expresión regular es
incorrecta sintácticamente el valor devuelto de la expresión condicional es 2. Si la
opción de la shell nocasematch (vea la descripción de shopt en la Sección 4.3.2 [El
Comando Interno Shopt]) está activada, el ajuste se realiza sin diferenciar entre
mayúsculas y minúsculas para los caracteres alfabéticos. Cualquier parte del patrón
puede ser entrecomillado para forzar a que este ajuste como una cadena. Las subcadenas
ajustadas por subexpresiones parentizadas dentro de la expresión regular son guardadas
en la variable de tipo array BASH_REMATCH . Los elementos de BASH_REMATCH con
índice 0 será la porción de la cadena que ajusta con la expresión regular completa. El
elemento de BASH_REMATCH con el índice n es la porción de la cadena que encaja
con la n-ésima subexpresión parentizada.
Las expresiones se pueden combinar usando los siguientes operadores, listados en orden
de precedencia decreciente:
( expresión )
Devuelve el valor de expresión. Este puede ser usado para sobrescribir la
precedencia normal de los operadores.
! expresión
Devuelve true si la expresión es false
expresión1 && expresión2
Devuelve true si tanto expresión1 como expresión2 son true.
expresión1 || expresión2
Devuelve true si expresión1 o expresión2 son true.
Los operadores && y || no evalúan expresión2 si el valor de expresión1 es suficiente
para determinar el valor devuelto por la expresión condicional completa.
3.2.4.3.- Agrupando Comandos
Bash proporciona dos maneras de agrupar una lista de comandos para ser ejecutada como una
unidad. Cuando los comandos se agrupan, las redirecciones pueden ser aplicadas a la lista de
comandos completa. Por ejemplo, la salida de todos los comandos en la lista puede ser redirigida a

Página 21


un único flujo.
()
( lista )
Encerrar una lista de comandos entre paréntesis produce que se cree un entorno de
subshell (vea la Sección 3.7.3 [Entorno de Ejecución de Comandos]), y cada uno de los
comandos en lista será ejecutado en ese subshell. Puesto que la lista es ejecutada en un
subshell, el efecto de la asignación de variables no permanece tras la finalización de la
subshell.
{}
{ lista; }
Encerrar una lista de comandos entre llaves produce que lista sea ejecutada en el
contexto de shell actual. No se crea ningún subshell. El punto y coma (o nueva línea)
que sigue a lista es obligatorio.
A parte de la creación de la subshell hay una sutil diferencia entre el uso de estas dos construc-
ciones debido a razones históricas. Las llaves son palabras reservadas, así que deben ser separadas
de la lista de comandos por blancos u otros metacaracteres de shell. Los paréntesis son operadores,
y son reconocidos como tokens separados por la shell incluso si no están separados de la lista de
comandos por espacios en blanco.
El estado de salida de ambas construcciones es el estado de salida de la lista de comandos.

3.2.5.- Coprocesos
Un coproceso es un comando de shell precedido por la palabra reservada coproc. Un coproceso es
ejecutado asíncronamente en un subshell, como si el comando hubiese terminado con el operador de
control '&', con un cauce de dos sentidos establecido entre el shell en ejecución y el coproceso.
El formato de ejecución de un coproceso es:
coproc [NOMBRE] comando [redirecciones]
Esto crea un coproceso llamado NOMBRE. Si no se proporciona NOMBRE, el nombre por defecto es
COPROC. No se debe proporcionar NOMBRE si el comando es un comando simple (vea la Sección
3.2.1 [Comandos Simples]); de otro modo, se interpretará este como la primera palabra del
comando simple.
Cuando se ejecuta el coproceso, la shell crea una variable de tipo array (vea la Sección 6.7
[Arrays]), llamada NOMBRE en el contexto de la shell en ejecución. La salida estándar del
comando se conecta a través de un cauce a un descriptor de fichero en la shell en ejecución, y este
descriptor de fichero se asigna a NOMBRE[0] . La entrada estándar del comando se conecta a través
de un cauce a un descriptor de fichero en la shell en ejecución, y ese descriptor de fichero se asigna
a NOMBRE[1] . Este cauce es establecido antes de cualquier redirección especificada por el
comando (vea la Sección 3.6 [Redirecciones]). El descriptor de fichero se puede utilizar como
argumento para los comandos de shell y las redirecciones usando expansiones de palabra estándar.
El identificador de proceso de la shell engendrada para ejecutar el coproceso está disponible en
el valor de la variable NAME_PID . Se puede utilizar el comando interno wait para esperar hasta que
el coproceso termine.
El valor devuelto por un coproceso es el estado de salida del comando.

Página 22


3.3.- Funciones de Shell
Las funciones de shell son una manera de agrupar comandos para ejecutarlos más tarde usando un
único nombre para todo el grupo. Estas se ejecutan justo igual que un comando “regular”. Cuando
se utiliza el nombre de una función de shell como un simple nombre de comando, se ejecuta la lista
de comandos asociados con ese nombre de función. Las funciones de shell son ejecutadas en el
contexto actual de la shell; no se crea ningún nuevo proceso para interpretarlas.
Las funciones se declaran usando la siguiente sintaxis:
[ function ] nombre () comando-compuesto [ redirecciones ]
Esto define una función de shell llamada nombre. La palabra reservada function es opcional.
Si se suministra la palabra reservada function, los paréntesis son opcionales. El cuerpo de la
función es el comando compuesto comando-compuesto (vea la Sección 3.2.4 [Comandos
Compuestos]). Este comando es normalmente una lista encerrada entre { y }, pero puede ser
cualquier comando compuesto listado más arriba. El comando-compuesto se ejecuta en cualquier
lugar donde se especifique nombre como nombre de un comando. Cualquier redirección (vea la
Sección 3.6 [Redirecciones]) asociada con la función de shell se lleva a cabo cuando se ejecuta la
función.
Una definición de función se puede eliminar usando la opción '-f' con el comando interno
unset (vea la Sección 4.1 [Comandos Internos de la Shell Bourne]).
El estado de salida de una definición de función es cero a menos que ocurra un error de sintaxis
o que previamente exista una función de sólo lectura con el mismo nombre.
Cuando se ejecuta la función, el estado de salida de esta es el estado de salida del último
comando ejecutado en el cuerpo de su definición.
Advierta que por razones históricas, en su uso más común las llaves que rodean el cuerpo de la
función deben estar separadas del cuerpo mediante caracteres blancos o nuevas lineas. Este es
debido a que las llaves son palabras reservadas y son sólo reconocidas como tales cuando están
separadas de la lista de comandos por espacios en blanco o cualquier otro metacaracter de shell.
También, cuando usamos llaves, la lista de comandos debe terminar en un punto y coma, un '&', o
una nueva línea.
Cuando se ejecuta una función, los argumentos pasados a la función se convierten en
parámetros posicionales durante su ejecución (vea la Sección 3.4.1 [Parámetros Posicionales]). El
parámetro especial '#' que se expande al número de parámetros posicionales, es actualizado para
reflejar el cambio. El parámetro especial 0 permanece sin cambios. El primer elemento de la
variable FUNCNAME se asigna al nombre de la función mientras que la función está en ejecución.
Todos los demás aspectos del entorno de ejecución de la shell son los mismos para la función y
su llamador con estas excepciones: las trampas DEBUG y RETURN no son heredades a menos que
se le haya dado a la función el atributo trace usando el comando interno declare o se haya activado
la opción '-o functrace' con el comando interno set (en cuyo caso todas las funciones heredan
las trampas DEBUG y RETURN), y la trampa ERR no es heredada a menos que la opción de shell '-
o errtrace' haya sido activada. Vea la Sección 4.1 [Comandos Internos de la Shell Bourne], para
una descripción del comando interno trap.
Si se ejecuta el comando interno return en una función, la función termina y la ejecución
continua con el siguiente comando después de la llamada a la función. Cuando una función termina,

Página 23


los valores de los parámetros posicionales y el parámetro especial ' #' son restaurados a los valores
que tenían antes de la ejecución de la función. Si se proporciona a return un argumento numérico,
este es el estado devuelto por la función; de otro modo el estado devuelto por la función es el estado
de salida del último comando ejecutado antes del return;
Se pueden declarar variables locales a la función utilizando el comando interno local. Estas
variables son visibles sólo para la función y los comandos que esta invoca.
Los nombres de función y sus definiciones pueden ser listadas con la opción ' -f' de los
comandos internos declare o typeset (vea la Sección 4.2 [Comandos Internos de Bash]). La opción
'-F' de los comandos internos declare o typeset listará únicamente los nombres de las funciones (y
opcionalmente el archivo fuente y el número de línea, si la opción de shell extdebug está
activada). Las funciones pueden ser exportadas con la opción ' -f' del comando interno export (vea
la Sección 4.1 [Comandos Internos de la Shell]), de forma que los subshells las tengan definidas
automáticamente. Advierta que tener funciones y variables de shell con el mismo nombre puede
llevar a tener múltiples entradas con el mismo nombre en el entorno pasado a las shells hijas. Debe
tenerse especial cuidado en aquellos casos donde esto puede causar problemas.
Las funciones pueden ser recursivas. No existe límite en el número de llamadas recursivas
posibles.

3.4.- Parámetros de Shell
Un parámetro es una entidad que almacena valores. Este puede ser un nombre, un número o uno de
los caracteres especiales listados más abajo. Una variable es un parámetro identificado por un
nombre. Una variable tiene un valor y cero o más atributos. Los atributos son asignados usando el
comando interno declare. (vea la descripción del comando interno declare en la Sección 4.2
[Comandos Internos de Bash]).
Un parámetro está establecido si le ha sido asignado un valor. La cadena nula es un valor
válido. Una vez que una variable está establecida puede ser eliminada únicamente usando el
comando interno unset.
Una variable puede ser asignada mediante una sentencia de la forma:
nombre=[valor]
Si no se da el valor, se asigna a la variable la cadena nula. Todos los valores sufren expansión
de tilde, expansión de parámetros y variables, sustitución de comandos, expansión aritmética y
eliminación de entrecomillado (detallado más abajo). Si la variable tiene establecido su atributo
integer, entonces su valor se evalúa como una expresión aritmética incluso si no se ha usado la
expansión $(( … )) (vea la Sección 3.5.5 [Expansión Aritmética]. La división de palabras no se
realiza, con la excepción de “$@” como se explica más abajo. No se realiza la expansión de
nombres de fichero. Las sentencias de asignación pueden aparecer también como argumentos en los
comandos internos alias, declare, typeset, export, readonly y local.
En el contexto donde una sentencia de asignación está asignando un valor a una variable de la
shell o un índice de un array (vea la Sección 6.7 [Arrays]), el operador '+=' puede ser usado para
agregar o añadir el valor dado al valor previo de la variable. Cuando se aplica el operador '+=' a una
variable para la cual se ha establecido el atributo integer (entero), el valor se evalúa como una
expresión aritmética y se añade al valor actual de la variable, la cual también se evalúa. Cuando se
aplica el operador '+=' a una variable de tipo array usando una asignación compuesta (vea la

Página 24


Sección 6.7 [Arrays]), el valor de la variable no es eliminado (como sí lo es cuando se usa '='), y se
agregan nuevos valores al array comenzando por el inmediatamente mayor al máximo índice del
array (para arrays indexados), o añadido como pares llave-valor adicionales en un array asociativo.
Cuando se aplica sobre una variable de tipo cadena, el valor se expande y se agrega al valor de la
variable.

3.4.1.- Parámetros posicionales
Un parámetro posicional es un parámetro denotado por uno o más dígitos, distintos al dígito 0. Los
parámetros posicionales se asignan desde los argumentos de la shell cuando esta es invocada, y
pueden ser reasignados usando el comando interno set. El parámetro posicional N puede ser
referenciado como ${N}, o como $N cuando N consiste en un único dígito. Los parámetros posicio-
nales no pueden ser asignados con sentencias de asignación. Se utilizan los comandos internos set y
shift para establecer y eliminar estos parámetros (vea el Capítulo 4 [Comandos Internos de la
Shell]). Los parámetros posicionales son reemplazados temporalmente cuando se ejecuta una
función de shell (vea la Sección 3.3 [Funciones de la Shell]).
Cuando se expande un parámetro posicional consistente en más de un único dígito, este debe
ser encerrado entre llaves.

3.4.2.- Parámetros Especiales
La shell trata a varios parámetros de forma especial. Estos parámetros únicamente pueden ser refe-
renciados; la asignación a ellos no está permitida.

* Se expande a los parámetros posicionales, comenzando por el uno. Cuando la
expansión ocurre entre dobles comillas se expande a una única palabra con el valor de
cada uno de los parámetros separados por el primer carácter de la variable especial
IFS . Esto es, “$* ” es equivalente a “$1c$2c... ”, donde c es el primer carácter del valor
de la variable IFS. Si la variable IFS no está establecida, los parámetros son separados
por espacios. Si IFS es nulo, los parámetros se unen sin utilizar ningún tipo de
separador.
@ Se expande a los parámetros posicionales, empezando por el uno. Cuando la expansión
ocurre entre comillas dobles cada parámetro es expandido a una palabra separada del
resto. Esto es, “$@” es equivalente a “$1 ” “$2 ” ….Si la expansión con comillas dobles
ocurre dentro de una palabra, la expansión del primer parámetro se une con la parte
inicial de la palabra original, y la expansión del último parámetro se une con la última
parte de la palabra original. Cuando no hay parámetros posicionales “$@” y $@ se
expanden a nada (es decir, son eliminados).
# Se expande al número de parámetros posicionales en el sistema decimal

? Se expande al estado de salida de la tubería ejecutada en primer plano más reciente-
mente.
- (Un guión). Se expande a las banderas de opción actuales como se especificó en la
invocación, mediante el comando interno set, o aquellas especificadas por la propia
shell (como la opción '-i').

Página 25


$ Se expande al id de proceso de la shell. En una subshell dada por ( ), esta variable se
expande a la id del proceso de la shell padre, no de la subshell.
! Se expande al id del proceso del comando ejecutado en segundo plano más reciente-
mente (de forma asíncrona).
0 Se expande al nombre de la shell o del guión de shell. Este se establece en el inicio de
la shell. Si Bash es invocado con un archivo de comandos (vea la Sección 3.8 [Guiones
de Shell]), $0 se asigna al nombre de ese archivo. Si Bash se inicia con la opción ' -c'
(vea la Sección 6.1 [Invocando a Bash]), entonces $0 se asigna al primer argumento
tras la cadena a ser ejecutada, si hay alguna presente. De otro modo, se asigna al
nombre de archivo usado para invocar Bash, dado por el argumento cero.
_ (Un carácter de subrayado). Al inicio de la shell, contiene la ruta absoluta usada para
invocar la shell o el guión de shell que está siendo ejecutado tal cómo se pasó en el
entorno o en la lista de argumentos. Posteriormente, expande al último argumento del
comando previo, tras la expansión. También contiene la ruta completa usada para
invocar cada comando ejecutado y situado en el entorno que se ha exportado para ese
comando. Cuando comprobamos el correo, este parámetro mantiene el nombre del
archivo de correo.

3.5.- Expansiones de la shell
La expansión se realiza en la línea de comandos después de que esta haya sido dividida en tokens.
Se realizan siete tipos de expansiones:
• expansión de llaves
• expansión de tildes
• expansión de parámetros y variables
• sustitución de comandos
• expansión aritmética
• división de palabras
• expansión de nombres de archivo.
El orden de las expansiones es: expansión de llaves, expansión de tildes, expansión de pará-
metros y variables, expansión aritmética y sustitución de comandos (realizada de izquierda a
derecha), división de palabras y expansión de nombres de archivo.
En sistemas que lo soporten hay disponible un tipo adicional de expansión: la sustitución de
procesos. Esta se realiza al mismo tiempo que la expansión de parámetros y variables, la expansión
aritmética y la sustitución de comandos.
Sólo la expansión de llaves, la división de palabras y la expansión de nombres de fichero
pueden cambiar el número de palabras de la expansión; otras expansiones expanden de palabra a
palabra. La única excepción a esto son las expansiones de “$@” (vea la Sección 3.4.2 [Parámetros
Especiales]) y “${nombre[@]} ” (vea la Sección 6.7 [Array])
Después de realizar todas las expansiones se realiza la eliminación del entrecomillado (vea la
Sección 3.5.9 [Eliminación del Entrecomillado]).

Página 26


3.5.1.- Expansión de Llaves
La expansión de llaves es un mecanismo por el cual se pueden generar cadenas arbitrarias. Este
mecanismo es similar a la expansión de nombres de fichero (vea la Sección 3.5.8 [Expansión de
Nombres de Fichero]), pero los nombres de archivo generados no existen. Los patrones para la
expansión de llaves tienen la forma de un preámbulo opcional, seguido por o bien una serie de
cadenas separadas por comas o bien una expresión secuencia encerrada entre llaves, seguido por un
epílogo opcional. El preámbulo se usa como prefijo para cada una de las cadenas contenidas entre
las llaves, y el epílogo se añade al final de cada cadena resultante, expandiendo de derecha a
izquierda.
Las expansiones de llaves pueden ser anidadas. No se ordena el resultado de cada cadena
expandida; se mantiene el orden de izquierda a derecha. Por ejemplo:
bash$ echo a{d,c,b}e
ade ace abe
Una expresión secuencia tiene la forma {x..y[..incr]}, donde x e y son enteros o
caracteres únicos, e incr, es un incremento opcional, dado como un valor entero. Cuando se
suministran enteros, la expresión expande a cada número entre x e y, ambos inclusive. Los enteros
suministrados pueden ir precedidos de '0' para forzar a que cada término tenga la misma longitud.
Cuando x o y comienzan con un cero, la shell intenta forzar a todos los términos generados a
contener el mismo número de dígitos, añadiendo ceros a la izquierda cuando sea necesario. Cuando
se suministran caracteres, la expresión se expande lexicográficamente a cada carácter entre x e y,
ambos inclusive. Advierta que tanto x como y deben ser del mismo tipo. Cuando se utiliza el
incremento este se usa como la diferencia entre cada uno de los términos. El incremento por defecto
es 1 o -1 según corresponda.
La expansión de llaves se realiza antes de cualquier otra expansión, y cualquier carácter
especial para otras expansiones se mantiene en el resultado. Esto es estrictamente textual. Bash no
aplica ninguna interpretación sintáctica al contexto de la expansión o al texto entre los corchetes.
Para evitar conflictos con la expansión de parámetros, la cadena '${' no se considera apta para la
expansión de llaves.
Una expansión de llaves formada correctamente debe contener las llaves de apertura y de cierre
sin entrecomillar, y al menos una coma o una expresión secuencia sin entrecomillar en ambos casos.
Cualquier expansión de llaves formada incorrectamente permanecerá sin cambios.
Un '{' o una ',' pueden ser entrecomilladas con una barra invertida para prevenir que sea consi-
derada como parte de una expresión de llaves.
Esta construcción es frecuentemente usada como una abreviatura cuando el prefijo común de la
cadena a generar es mayor que en el ejemplo siguiente:
mkdir /usr/local/src/bash/{old, new, dist, bugs}
o
chown root /usr/{ucb/{ex,edit},lib/{ex?.?*, how_ex}}

3.5.2.- Expansión de Tildes
Si una palabra comienza con un carácter tilde ('~ ') sin entrecomillar todos los caracteres anteriores
a la primera barra no entrecomillada (o todos los caracteres si no hay barras sin entrecomillar) son

Página 27


considerados como un prefijo-tilde. Si ninguno de los caracteres en el prefijo-tilde están entrecomi-
llados, los caracteres en el prefijo-tilde que siguen a la tilde son tratados como un posible nombre de
inicio de sesión. Si este nombre de inicio de sesión es la cadena nula, la tilde es reemplazada por el
valor de la variable de shell HOME. Si HOME no está establecida, en su lugar se utiliza el directorio
home del usuario que está ejecutando la shell. De otro modo, el prefijo-tilde es reemplazado con el
directorio home asociado con el nombre de inicio de sesión especificado.
Si el prefijo-tilde es '~+', el valor de la variable PWD reemplaza al prefijo-tilde. Si el prefijo-
tilde es '~-' se sustituye por el valor de la variable OLDPWD , si esta está establecida.
Si los caracteres que siguen a la tilde en el prefijo-tilde consisten en un número N, opcional-
mente precedido por '+' o '-', el prefijo-tilde se sustituye por el correspondiente elemento de la pila
de directorios, como si fuera mostrado por el comando interno dirs invocado con los caracteres que
siguen al prefijo-tilde como argumento (vea la Sección 6.8 [La Pila de Directorios]). Si el prefijo-
tilde, sin la tilde, consiste en un número sin que vaya acompañado de '+' o '-', se asume que va
acompañado del signo '+'.
Si el nombre de inicio de sesión es inválido, o la expansión de tilde falla, la palabra se
mantiene sin cambios.
Cada asignación de variables se comprueba inmediatamente en busca de prefijos-tilde sin
entrecomillar siguiendo al ':' o al primer '='. En estos casos, la expansión tilde es inmediata. Por
consiguiente, uno pude usar los nombres de fichero con tildes en asignaciones a PATH, MAILPATH
y CDPATH , y la shell asigna el valor expandido.
La siguiente tabla muestra como Bash trata los prefijos-tilde sin entrecomillar:

~ El valor de $HOME
~/foo '$HOME/foo'
~fred/foo El subdirectorio foo del directorio home del usuario fred
~+foo '$PWD/foo'
~-/foo '${OLDPWD-'~-'} /foo'
~N La cadena que sería mostrada por 'dirs +N'
~+N La cadena que sería mostrada por 'dirs +N'
~-N La cadena que sería mostrada por 'dirs +N'

3.5.3.- Expansión de Parámetros de Shell
El carácter '$' inicia la expansión de parámetros, la sustitución de comandos o la expansión aritmé-
tica. El nombre del parámetro o el símbolo a expandir puede ser encerrado entre llaves, lo que es
opcional, pero sirve para proteger la variable a ser expandida de que los caracteres inmediatamente
siguientes a ella puedan ser interpretados como parte del nombre.
Cuando se usan las llaves, la llave de cierre que se utiliza es la primera '}' no escapada
mediante una barra invertida o encerrada en una cadena entrecomillada, y no encerrada en una
expansión aritmética, sustitución de comandos o expansión de parámetros embebidas.
La forma básica de la expansión de parámetros es ${parámetro} . Se sustituye el valor de
parámetro. Las llaves son obligatorias cuando el parámetro es un parámetro posicional con más de

Página 28


un dígito o cuando el parámetro es seguido por un carácter que no debe ser interpretado como parte
de su nombre.
Si el primer carácter del parámetro es una exclamación de cierre (!), se realiza una indirección
de variables de un nivel. Bash utiliza el valor de la variable formada con el resto del parámetro
como el nombre de la variable; esta variable entonces se expande y ese valor se utiliza en el resto de
la sustitución, en vez del valor del parámetro por sí mismo. Esto se conoce como expansión
indirecta. Las excepciones a esto son las expansiones ${!prefijo*} y ${!nombre[@]} descritas más
abajo. La exclamación de cierre debe ir inmediatamente a continuación de la llave izquierda para
que indique la indirección.
En todos los casos que se dan más abajo, palabra se somete a expansión de tildes, expansión de
parámetros, sustitución de comandos y expansión aritmética.
Cuando no se realiza la expansión de subcadenas, usando la forma descrita más abajo, Bash
analiza en busca de un parámetro que no esté establecido o sea nulo. Omitir el dos puntos resulta en
que el chequeo se realiza sólo en busca de un parámetro que no esté establecido. Dicho de otro
modo, si se incluye el dos puntos, el operador chequea tanto la existencia del parámetro como que
su valor no sea nulo; si el dos puntos se omite, el operador chequea únicamente la existencia.
${parámetro:-palabra}
Si el parámetro no está establecido o es nulo, se sustituye la expansión de palabra. De
otro modo, se sustituye el valor de parámetro.
${parámetro:=palabra}
Si el parámetro no está establecido o es nulo se asigna a parámetro la expansión de
palabra. Luego se sustituye el valor de parámetro. Los parámetros posicionales y los
parámetros especiales no pueden ser asignados de este modo.
${parámetro:?palabra}
Si el parámetro es nulo o no está establecido, se escribe en la salida de error estándar la
expansión de palabra (o un mensaje a tal efecto si palabra no está presente) y la shell, si
no es interactiva, termina. De otro modo, se sustituye el valor de parámetro.
${parámetro:+palabra}
Si el parámetro es nulo o no está establecido, no realiza ninguna sustitución, de otro
modo se sustituye la expansión de palabra
${parámetro:desplazamiento}
${parámetro:desplazamiento:longitud}
Expande hasta longitud caracteres del parámetro comenzando por el carácter especi-
ficado por desplazamiento. Si se omite longitud, expande a la subcadena de parámetro
que comienza en el carácter especificado por desplazamiento. longitud y desplazamiento
son expresiones aritméticas (vea la Sección 6.5 [Aritmética de la Shell]). Esto es
conocido como Expansión de Subcadenas.
longitud debe evaluarse a un número mayor o igual que cero. Si el desplazamiento se
evalúa como un número menor que cero, entonces el valor del desplazamiento se cuenta
desde el final del valor de parámetro. Si el parámetro es '@', el resultado es longitud

Página 29


parámetros posicionales comenzando en desplazamiento. Si el parámetro es el nombre
de un array indexado seguido por '@' o '*', el resultado es de longitud miembros del array
comenzando con ${parámetro[desplazamiento]} . Un desplazamiento negativo se toma
como relativo al índice inmediatamente superior al mayor índice del array especificado.
La expansión de subcadenas aplicada a un array asociativo produce resultados no
definidos.
${!prefijo*}
${!prefijo@}
Expande a nombres de variables cuyos nombres comiencen con prefijo, separados por el
primer carácter de la variable especial IFS . Cuando se usa '@' y la expansión aparece
encerrada entre dobles comillas, cada nombre de variable se expande a una palabra
separada del resto.
${!nombre[@]}
${!nombre[*]}
Si nombre es una variable de tipo array, expande a la lista de índices del array (claves)
asignada en nombre. Si nombre no es un array, expande a 0 si nombre está establecido y
a nulo en caso contrario. Cuando se usa ' @' y la expansión aparece encerrada entre
comillas dobles, cada clave se expande en una palabra separada.
${#parámetro}
Se sustituye por la longitud en caracteres del valor expandido de parámetro. Si el
parámetro es '*' o '@', el valor sustituido es el número de parámetros posicionales. Si
parámetro es un nombre de array seguido de '* ' o '@', el valor sustituido es el número de
elementos del array.
${parámetro#palabra}
${parámetro##palabra}
La palabra se expande para producir un patrón al igual que en la expansión de nombres
de fichero (vea la Sección 3.5.8 [Expansión de Nombres de Fichero]). Si el patrón
encaja con el principio del valor expandido de parámetro, entonces el resultado de la
expansión es el valor expandido de parámetro en el que se elimina el ajuste más corto al
patrón (en el caso de usar '#') o el ajuste más largo al patrón (en el caso de '##'). Si el
parámetro es '@' o '*' la operación de eliminación del patrón se aplica a cada parámetro
posicional sucesivamente, y la expansión es la lista resultante. Si el parámetro es una
variable de tipo array indexada por '@' o '*' la operación de eliminación del patrón se
aplica a cada miembro del array en turnos, y la expansión es la lista resultante.
${parámetro%palabra}
${parámetro%%palabra}
La palabra es expandida para producir un patrón como en la expansión de nombres de
fichero. Si el patrón encaja en una porción marginal del valor expandido de parámetro,
entonces el resultado de la expansión es el valor de parámetro con el ajuste más corto

Página 30


que concuerde con el patrón (en el caso de '%') o el ajuste más largo (en el caso de '%%')
eliminados. Si el parámetro es '@' o '*' la operación de eliminación del patrón se aplica a
cada parámetro posicional en turnos y la expansión es la lista resultante. Si el parámetro
es una variable de tipo array indexada por ' @' o '*', la operación de eliminación del
patrón se aplica a cada miembro del array secuencialmente, y la expansión es la lista
resultante.
${parámetro/patrón/cadena}
patrón se expande para producir un patrón como en la expansión de nombres de archivo.
parámetro se expande y el ajuste más largo al patrón de este valor es sustituido por
cadena. Si el patrón comienza con '/', todos los ajustes al patrón son reemplazados por
cadena. Normalmente sólo se reemplaza el primer ajuste. Si el patrón comienza con '#',
este debe encajar al principio del valor expandido de parámetro. Si el patrón comienza
con '%' este debe ajustar al final del valor expandido de parámetro. Si la cadena es nula
los ajustes al patrón serán eliminados y se puede omitir la '/' posterior al patrón. Si el
parámetro es '@' o '* ', la operación de sustitución se aplica a cada parámetro posicional
por turnos, y la expansión es la lista resultante. Si parámetro es una variable de tipo
array indexada con '@' o '*', la operación de sustitución se aplica a cada uno de los
miembros del array en turnos, y la expansión es la lista resultante.
${parámetro^patrón}
${parámetro^^patrón}
${parámetro,patrón}
${parámetro,,patrón}
Esta expansión modifica las mayúsculas-minúsculas en los caracteres alfabéticos de
parámetro. patrón se expande para producir un patrón como en la expansión de nombres
de fichero. El operador '^' convierte las letras minúsculas que encajen con el patrón a
letras mayúsculas; el operador ';' convierte las letras mayúsculas que ajusten con el
patrón a letras minúsculas. Las expansiones con '^^' y ',,' convierten cada carácter que
encaje en el valor expandido; Las expansiones con '^' y ',' encajan y convierten
únicamente el primer carácter en el valor expandido. Si se omite el patrón se considera
que este es igual a '?', con el que encaja cualquier carácter. Si el parámetro es '@' o '*'
las modificaciones de mayúsculas y minúsculas se aplican a cada carácter posicional en
turnos y la expansión es la lista resultante. Si parámetro es una variable de tipo array
indexada con '@' o '*', las modificaciones se aplican a cada miembro del array en turnos,
y la expansión es la lista resultante.

3.5.4.- Sustitución de Comandos.
La sustitución de comandos permite que la salida de un comando sustituya al propio comando. La
sustitución de comandos ocurre cuando un comando es encerrado de la siguiente manera:
$(comando)
o

Página 31

manual de Bash 4.1

Recomendados

Recomendados

Más contenido relacionado

Similar a manual de Bash 4.1

Similar a manual de Bash 4.1 (20)

manual de Bash 4.1