Traducción del       Manual de Referencia para Bash (version 4.1)                                  Edicion 0.9            ...
Esta es una traducción no autorizada de la Documentación de Referencia de Bash. Está basada en laEdición 4.1, para Bash ve...
Datos de la Edición original:    Bash Reference Manual -    Reference Documentation for Bash    Edition 4.1, for Bash Vers...
Presentacion de la version originalThis text is a brief description of the features that are present in the Bash shell (ve...
Índice de ContenidoÍndice de contenido1.-Introducción........................................................................
Índice de Contenido      3.6.3.-Anexando la salida redirigida................................................................
Índice de Contenido   7.1.-Fundamentos del Control de Tareas.................................................................
Índice de ContenidoApéndice A: Informando de errores.........................................................................
Capítulo 1: Introducción1.- Introducción1.1.- ¿Qué es Bash?Bash es la shell, o interprete de comandos, para el sistema ope...
Capítulo 1: Introducciónshell se debe a los lenguajes de programación embebidos en ella. Como cualquier lenguaje de altoni...
Capítulo 2: Definiciones2.- DefinicionesEstas definiciones son usadas a lo largo de este manual    POSIX            Una fa...
Capítulo 2: Definiciones             metacaracter sin entrecomillar.     grupo de procesos           Una colección o proce...
Capitulo 3: Características Básicas del Shell3.- Características Básicas de la ShellBash es un acrónimo para Bourne-Again ...
Capitulo 3: Características Básicas del Shell3.1.2.- EntrecomilladoEl entrecomillado es usado para eliminar el significado...
Capitulo 3: Características Básicas del Shellsigue:               a            alerta(campana)               b            ...
Capitulo 3: Características Básicas del Shellinteractive_comments activada no permite comentarios. La opción interactive_c...
Capitulo 3: Características Básicas del Shellcomando en la tubería, a menos que la opción pipefail esté activada (vea la S...
Capitulo 3: Características Básicas del Shell3.2.4.1.- Construcciones CíclicasBash soporta las siguientes construcciones c...
Capitulo 3: Características Básicas del Shell                      if comandos-test; then                             coma...
Capitulo 3: Características Básicas del Shell               El estado de retorno es cero si no se ajusta a ningún patrón. ...
Capitulo 3: Características Básicas del Shell              desentrecomillados para que sean reconocidos como primarios. Cu...
Capitulo 3: Características Básicas del Shellun único flujo.     ()                    ( lista )              Encerrar una...
Capitulo 3: Características Básicas del Shell3.3.- Funciones de ShellLas funciones de shell son una manera de agrupar coma...
Capitulo 3: Características Básicas del Shelllos valores de los parámetros posicionales y el parámetro especial  # son res...
Capitulo 3: Características Básicas del ShellSección 6.7 [Arrays]), el valor de la variable no es eliminado (como sí lo es...
Capitulo 3: Características Básicas del Shell      $        Se expande al id de proceso de la shell. En una subshell dada ...
Capitulo 3: Características Básicas del Shell3.5.1.- Expansión de LlavesLa expansión de llaves es un mecanismo por el cual...
Capitulo 3: Características Básicas del Shellconsiderados como un prefijo-tilde. Si ninguno de los caracteres en el prefij...
Capitulo 3: Características Básicas del Shellun dígito o cuando el parámetro es seguido por un carácter que no debe ser in...
Capitulo 3: Características Básicas del Shell              parámetros posicionales comenzando en desplazamiento. Si el par...
Capitulo 3: Características Básicas del Shell              que concuerde con el patrón (en el caso de %) o el ajuste más l...
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
manual de Bash 4.1
Upcoming SlideShare
Loading in …5
×

manual de Bash 4.1

1,489 views
1,373 views

Published on

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 edición original en inglés está fechada en Diciembre de 2009, mientras que esta traducción es de Noviembre de 2010.

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.

0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total views
1,489
On SlideShare
0
From Embeds
0
Number of Embeds
2
Actions
Shares
0
Downloads
48
Comments
0
Likes
0
Embeds 0
No embeds

No notes for slide

manual de Bash 4.1

  1. 1. Traducción del Manual de Referencia para Bash (version 4.1) Edicion 0.9 Noviembre de 2010Chet Ramey, Case Western Reserve UniversityBrian Fox, Free Software FoundationMario Piñar Ramírez (Traducción)
  2. 2. Esta es una traducción no autorizada de la Documentación de Referencia de Bash. Está basada en laEdició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 enel 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 FreeDocumentation License, Versión 1.3 o cualquier versión posterior publicada por la Free SoftwareFoundation; 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 elApéndice C, seguida por una traducción de la misma (Apéndice D) obtenida de:http://docs.danexlandia.com.mx/gfdl/gfdl_es.f.htmlPuede comunicar sugerencias o errores en la dirección traduccionbash41@gmail.com Página ii
  3. 3. Datos de la Edición original: Bash Reference Manual - Reference Documentation for Bash Edition 4.1, for Bash Version 4.1. December 2009 Chet Ramey, Case Western Reserve University Brian Fox, Free Software Foundation Bash - Manual de Referencia Documentación de Referencia para Bash Edición 4.1, para Bash versión 4.1 Diciembre de 2009 Chet Ramey, Case Western Reserve University Brian Fox, Free Software Foundation Página iii
  4. 4. Presentacion de la version originalThis text is a brief description of the features that are present in the Bash shell (version 4.1, 23December 2009). This is Edition 4.1, last updated 23 December 2009, of The GNU Bash Reference Manual, forBash, Version 4.1. Copyright © 1988–2009 Free Software Foundation, Inc. Permission is granted to make and distribute verbatim copies of this manual provided thecopyright 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 theGNU Free Documentation License, Version 1.3 or any later version published by the Free SoftwareFoundation; with no Invariant Sections, with the Front-Cover texts being “A GNU Manual”, andwith 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. Buyingcopies 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 USAPresentacion 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 deReferencia 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 avisode 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 FreeDocumentation License, Versión 1.3 o cualquier versión posterior publicada por la Free SoftwareFoundation; 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 lasecció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 ypromoviendo la libertad de software. Publicado por la Free Software Foundation 59 Temple Place, Suite 330 Boston, MA 02111-1307 USA Página iv
  5. 5. Índice de ContenidoÍndice de contenido1.-Introducción.....................................................................................................................................9 1.1.-¿Qué es Bash?...........................................................................................................................9 1.2.-¿Qué es una shell?....................................................................................................................92.-Definiciones...................................................................................................................................113.-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
  6. 6. Índice de Contenido 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.....................................................................................................................434.-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...............................................................................................715.-Variables de Shell..........................................................................................................................73 5.1.-Variables de la Shell Bourne..................................................................................................73 5.2.-Variables de Bash...................................................................................................................746.-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......................................................................................................997.-Control de Tareas.........................................................................................................................103 Página vi
  7. 7. Índice de Contenido 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.....................................................................................1068.-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.........................................................1329.-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...............................................................................................................14110.-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
  8. 8. Índice de ContenidoApéndice A: Informando de errores................................................................................................150C.2.-Diferencias Principales con la Shell de Bourne........................................................................151 B.1.-Diferencias de Implementación con la Shell SVR4.2.........................................................156Apé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...........................................163Apé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:.......................................................................................................................171Apé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
  9. 9. Capítulo 1: Introducción1.- Introducción1.1.- ¿Qué es Bash?Bash es la shell, o interprete de comandos, para el sistema operativo GNU. El nombre es unacró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 delos Bell Labs Research (Laboratorios de Investigación de Bell). Bash es ampliamente compatible con sh e incorpora características muy útiles de la Korn shellksh y la C shell csh. Busca ser una implementación conforme al IEEE POSIX Shell y Herramientasparte de la especificación POSIX del IEEE (estándar IEEE 1003.1). Ofrece mejoras funcionalesfrente a sh tanto para uso interactivo como de programación. Aunque el sistema operativo GNU proporciona otras shells, incluida una versión de csh, lashell Bash es la shell por defecto. Al igual que el resto del software GNU, Bash es bastanteportable. Actualmente corre en casi todas las versiones de Unix y en algunos sistemas operativosmá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érminoprocesador de macros indica una funcionalidad donde texto y símbolos son expandidos para crearexpresiones más largas. Una shell de Unix es a la vez un interprete de comandos y un lenguaje de programación. Comointerprete 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. Sepueden crear archivos que contengan comandos, y que lleguen a ser comandos por si mismos. Estosnuevos comandos tienen la misma categoría que los comandos del sistema situados en directorioscomo /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 aceptanentradas desde el teclado. Cuando se ejecutan en modo no-interactivo, las shells ejecutan comandosleídos desde un fichero. Una shell permite la ejecución de comandos GNU tanto de forma síncrona como asíncrona. Lashell espera hasta que se completan los comandos síncronos antes de aceptar más entradas; loscomandos asíncronos continúan ejecutándose paralelamente a la shell mientras que esta lee yejecuta otros comandos. La redirección permite un control detallado de la entrada y la salida deestos 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 deforma poco apropiada. Por ejemplo, no se puede implementar a cd, break, continue y exec fuerade 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 sonmás convenientes usados como comandos internos. Todos los comandos internos de la shell serándescritos en las secciones siguientes. Mientras que la ejecución de comandos es esencial, gran parte del poder (y complejidad) de la Página 9
  10. 10. Capítulo 1: Introducciónshell se debe a los lenguajes de programación embebidos en ella. Como cualquier lenguaje de altonivel, la shell proporciona variables, construcciones de control del flujo, entrecomillado yfunciones. Las shells ofrecen características orientadas específicamente para el uso interactivo más quepara aumentar el lenguaje de programación. Estas características interactivas incluyen control detareas, 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
  11. 11. Capítulo 2: Definiciones2.- DefinicionesEstas 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
  12. 12. 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
  13. 13. Capitulo 3: Características Básicas del Shell3.- Características Básicas de la ShellBash es un acrónimo para Bourne-Again Shell. La shell Bourne es la shell Unix tradicional escritaoriginalmente por Stephen Bourne. Todos los comandos internos de la shell Bourne estándisponibles en Bash. Las reglas para evaluación y entrecomillado están tomadas de la especificaciónPOSIX 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 enla que la shell ejecuta comandos.3.1.- Sintaxis de la shellCuando la shell lee una entrada, procede a realizar una secuencia de operaciones. Si la entradaindica el principio de un comentario, la shell ignora el signo de comentario (#) y el resto de esalínea. En caso contrario, hablando de forma aproximada, la shell lee su entrada y divide esta enpalabras y operadores, empleando las reglas de entrecomillado para seleccionar qué significadodebe asignar a las palabras y caracteres. La shell luego analiza esos tokens en comandos y otras construcciones, elimina el significadoespecial de ciertas palabras o caracteres, expande otras, redirecciona la entrada y la salida según seanecesario, ejecuta los comandos especificados, espera por el estado de salida de los comandos, ypone disponible ese estado de salida para favorecer su inspección o procesamiento.3.1.1.- Modo de operación de la shellLo que sigue es una breve descripción del modo en que trabaja la shell cuando esta lee y ejecuta uncomando. 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
  14. 14. Capitulo 3: Características Básicas del Shell3.1.2.- EntrecomilladoEl entrecomillado es usado para eliminar el significado especial a ciertos caracteres o palabras parala shell. El entrecomillado puede ser usado para eliminar el tratamiento especial para los caracteresespeciales, o para prevenir a las palabras reservadas de ser reconocidas como tales, y para prevenirla expansión de parámetros. Cada uno de los metacaracteres de shell (vea el Capítulo 2 [Definiciones]) tiene un significadoespecial para el shell y debe ser entrecomillado si se representa a sí mismo. Cuando se está usandolas habilidades de expansión de la historia de comandos (vea la Sección 9.3 [Interacciones con laHistoria]), el carácter de expansión de la historia, normalmente !, debe ser entrecomillado paraprevenir la expansión de la historia. Vea la Sección 9.1 [Características de Historial de Bash], paramás detalles concernientes a la expansión de la historia. Hay tres mecanismos de entrecomillado: El carácter de escape, las comillas simples y lascomillas dobles.3.1.2.1.- Carácter de EscapeEl carácter de escape consiste en una barra invertida sin entrecomillar . Esta mantiene el valorliteral del carácter que le sigue, con la excepción de la nueva línea. Si aparece una parejanueva_linea esta es tratada como una continuación de línea (esto es, esta es eliminada del flujo deentrada e ignorada completamente).3.1.2.2.- Comillas simplesEncerrar caracteres en comillas simples () mantiene el valor literal de cualquier carácter situadoentre las comillas. Una comilla simple no puede aparecer encerrada entre comillas simples, inclusocuando es precedida por una barra invertida.3.1.2.3.- Comillas DoblesEncerrar caracteres entre comillas dobles (”) mantiene el valor literal de todos los caracteresdentro 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 especialsólo cuando es seguida por uno de los siguientes caracteres: $, , , o nueva linea. Dentrode comillas dobles, las barras invertidas que son seguidas por uno de estos caracteres soneliminadas. Las barras invertidas que preceden caracteres sin un significado especial permanecencomo tales. Una comilla doble puede ser entrecomillada dentro de dobles comillas precediéndolacon una barra invertida. Si está habilitada la expansión de la historia de comandos esta se realizará amenos que el signo ! que aparece entre las comillas dobles sea escapado usando una barrainvertida. La barra invertida precediendo al ! no es eliminada. Los parámetros especiales * y @ tienen un significado especial cuando aparecen encerradosentre comillas dobles (vea la sección 3.5.3 [Expansión de parámetros de la Shell]).3.1.2.4.- Entrecomillado ANSI-CLas 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ándarANSI C. Las secuencias de escape con barra invertida, si están presentes, son decodificadas como Página 14
  15. 15. Capitulo 3: Características Básicas del Shellsigue: 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 $ noestuviese presente.3.1.2.5.- Traducciones Específicas de la LocalizaciónUna cadena entrecomillada con comillas dobles precedida por un signo ($) causará que la cadenasea traducida de acuerdo a la localización actual. Si la localización actual es C o POSIX, el signodólar es ignorado. Si la cadena es traducida y reemplazada, el sustituto es entrecomillado concomillas dobles. Algunos sistemas usan el catálogo de mensajes seleccionado por la variable de shellLC_MESSAGES . Otros crean el nombre del catálogo de mensajes a partir del valor de la variabledel shell TEXTDOMAIN , posiblemente añadiendo un sufijo o .mo. Si usa la variableTEXTDOMAIN , puede necesitar ajustar la variable TEXTDOMAINDIR a la localización de losarchivos del catálogo de mensajes. Otros incluso usan ambas variables de la forma: TEXTDOMAINDIR/LC_MESSAGES/TEXTDOMAIN.mo.3.1.3.- ComentariosEn una shell no-interactiva, o en una shell interactiva en la que la opcióninteractive_comments para el comando interno shopt está activada (vea la sección 4.3.2 [ ElComando Interno Shopt]), una palabra comenzando con # provoca que la palabra y todos loscaracteres que le siguen en esa línea sean ignorados. Una shell interactiva sin la opción Página 15
  16. 16. Capitulo 3: Características Básicas del Shellinteractive_comments activada no permite comentarios. La opción interactive_comentsestá establecida por defecto en las shells interactivas. Vea la sección 6.3 [Shells Interactiva], parauna descripción de qué hace una shell interactiva.3.2.- Comandos de ShellUn 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 devarias formas; en una tubería en la cual la salida de un comando se convierte en la entrada delsegundo, en una construcción tipo bucle o condicional, o en algunas otras agrupaciones.3.2.1.- Comandos simplesUn comando simple es el tipo de comando que se encuentra con más frecuencia. Este es sólo unasecuencia de palabras separadas por blancos, terminada por uno de los operadores de control de lashell (vea el Capítulo 2 [Definiciones]). La primera palabra generalmente especifica un comandopara 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 suestado de salida como viene especificado por la función POSIX 1003.1 waitpid, o 128+n si elcomando fue terminado por la señal n.3.2.2.- TuberíasUna 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 delsiguiente comando. Esto es, cada comando lee la salida del comando previo. Esta conexión seestablece 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 delcomando2 a través del cauce; es una forma corta para 2>&1. Esta redirección implícita de la salidade 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 unavez que esta finaliza. Las estadísticas actualmente consisten en el tiempo transcurrido y tiempo deusuario y de sistema consumidos por la ejecución del comando. La opción -p cambia el formato desalida por el especificado por POSIX. La variable TIMEFORMAT puede ser ajustada a una cadenade 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 comopalabra reservada permite el cronometrado de los comandos internos de la shell, las funciones deshell 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 esperahasta 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 [Entornode Ejecución de Comandos]). El estado de salida de una tubería es el estado de salida de el último Página 16
  17. 17. Capitulo 3: Características Básicas del Shellcomando en la tubería, a menos que la opción pipefail esté activada (vea la Sección 4.3.1 [ElComando 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 loscomandos salen satisfactoriamente. Si la palabra reservada ! precede a la tubería, el estado desalida es la negación lógica del estado de salida como se describió más arriba. El shell espera hastaque todos los comandos en la tubería terminen antes de retornar un valor.3.2.3.- Listas de ComandosUna 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 nuevalínea. De estos operadores de lista && y || tienen igual precedencia, seguidos por ; y &, quetienen igual precedencia. Una secuencia de una o más nuevas líneas pueden aparecer en una lista para delimitarcomandos, esto equivale a un punto y coma. Si un comando termina con el operador de control & la shell ejecuta el comando de formaasíncrona en una subshell. Esto es conocido como ejecutar el comando en segundo plano. La shellno espera a que el comando finalice, y el estado de retorno es 0 (verdadero). Cuando el control detareas no está activado (vea el Capítulo 7 [Control de Tareas]), la entrada estándar para loscomandos 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 cadacomando finalice turnándose con el siguiente. El estado de retorno es el estado de retorno del últimocomando 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 asociatividada 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 comandoejecutado en la lista.3.2.4.- Comandos CompuestosLos comandos compuestos son las construcciones de programación de la shell. Cada construccióncomienza con una palabra reservada o un operador de control y termina con otra correspondientepalabra reservada u operador. Cualquier redirección (vea la Sección 3.6 [Redirecciones]) asociadacon un comando compuesto se aplica a todos los comandos dentro de ese comando compuesto, amenos que sea sobreescrito explícitamente. Bash proporciona construcciones cíclicas, comandos condicionales y mecanismos para agruparcomandos y ejecutarlos como una unidad. Página 17
  18. 18. Capitulo 3: Características Básicas del Shell3.2.4.1.- Construcciones CíclicasBash 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 uncomando 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 ShellBourne]) 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
  19. 19. Capitulo 3: Características Básicas del Shell 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
  20. 20. Capitulo 3: Características Básicas del Shell 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
  21. 21. Capitulo 3: Características Básicas del Shell 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 ComandosBash proporciona dos maneras de agrupar una lista de comandos para ser ejecutada como unaunidad. Cuando los comandos se agrupan, las redirecciones pueden ser aplicadas a la lista decomandos completa. Por ejemplo, la salida de todos los comandos en la lista puede ser redirigida a Página 21
  22. 22. Capitulo 3: Características Básicas del Shellun ú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 separadasde 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 decomandos por espacios en blanco. El estado de salida de ambas construcciones es el estado de salida de la lista de comandos.3.2.5.- CoprocesosUn coproceso es un comando de shell precedido por la palabra reservada coproc. Un coproceso esejecutado asíncronamente en un subshell, como si el comando hubiese terminado con el operador decontrol &, 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 esCOPROC. No se debe proporcionar NOMBRE si el comando es un comando simple (vea la Sección3.2.1 [Comandos Simples]); de otro modo, se interpretará este como la primera palabra delcomando 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 delcomando se conecta a través de un cauce a un descriptor de fichero en la shell en ejecución, y estedescriptor de fichero se asigna a NOMBRE[0] . La entrada estándar del comando se conecta a travésde un cauce a un descriptor de fichero en la shell en ejecución, y ese descriptor de fichero se asignaa NOMBRE[1] . Este cauce es establecido antes de cualquier redirección especificada por elcomando (vea la Sección 3.6 [Redirecciones]). El descriptor de fichero se puede utilizar comoargumento 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 enel valor de la variable NAME_PID . Se puede utilizar el comando interno wait para esperar hasta queel coproceso termine. El valor devuelto por un coproceso es el estado de salida del comando. Página 22
  23. 23. Capitulo 3: Características Básicas del Shell3.3.- Funciones de ShellLas 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”. Cuandose utiliza el nombre de una función de shell como un simple nombre de comando, se ejecuta la listade comandos asociados con ese nombre de función. Las funciones de shell son ejecutadas en elcontexto 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 lafunción es el comando compuesto comando-compuesto (vea la Sección 3.2.4 [ComandosCompuestos]). Este comando es normalmente una lista encerrada entre { y }, pero puede sercualquier comando compuesto listado más arriba. El comando-compuesto se ejecuta en cualquierlugar donde se especifique nombre como nombre de un comando. Cualquier redirección (vea laSección 3.6 [Redirecciones]) asociada con la función de shell se lleva a cabo cuando se ejecuta lafunción. Una definición de función se puede eliminar usando la opción -f con el comando internounset (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 sintaxiso 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 últimocomando 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 lafunción deben estar separadas del cuerpo mediante caracteres blancos o nuevas lineas. Este esdebido a que las llaves son palabras reservadas y son sólo reconocidas como tales cuando estánseparadas 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 &, ouna nueva línea. Cuando se ejecuta una función, los argumentos pasados a la función se convierten enparámetros posicionales durante su ejecución (vea la Sección 3.4.1 [Parámetros Posicionales]). Elparámetro especial # que se expande al número de parámetros posicionales, es actualizado parareflejar el cambio. El parámetro especial 0 permanece sin cambios. El primer elemento de lavariable 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 ysu llamador con estas excepciones: las trampas DEBUG y RETURN no son heredades a menos quese le haya dado a la función el atributo trace usando el comando interno declare o se haya activadola opción -o functrace con el comando interno set (en cuyo caso todas las funciones heredanlas 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], parauna descripción del comando interno trap. Si se ejecuta el comando interno return en una función, la función termina y la ejecucióncontinua con el siguiente comando después de la llamada a la función. Cuando una función termina, Página 23
  24. 24. Capitulo 3: Características Básicas del Shelllos valores de los parámetros posicionales y el parámetro especial # son restaurados a los valoresque 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 estadode salida del último comando ejecutado antes del return; Se pueden declarar variables locales a la función utilizando el comando interno local. Estasvariables 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 loscomandos 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 (yopcionalmente 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 (veala Sección 4.1 [Comandos Internos de la Shell]), de forma que los subshells las tengan definidasautomáticamente. Advierta que tener funciones y variables de shell con el mismo nombre puedellevar a tener múltiples entradas con el mismo nombre en el entorno pasado a las shells hijas. Debetenerse 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 recursivasposibles.3.4.- Parámetros de ShellUn parámetro es una entidad que almacena valores. Este puede ser un nombre, un número o uno delos caracteres especiales listados más abajo. Una variable es un parámetro identificado por unnombre. Una variable tiene un valor y cero o más atributos. Los atributos son asignados usando elcomando 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 valorválido. Una vez que una variable está establecida puede ser eliminada únicamente usando elcomando 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ónde tilde, expansión de parámetros y variables, sustitución de comandos, expansión aritmética yeliminación de entrecomillado (detallado más abajo). Si la variable tiene establecido su atributointeger, entonces su valor se evalúa como una expresión aritmética incluso si no se ha usado laexpansión $(( … )) (vea la Sección 3.5.5 [Expansión Aritmética]. La división de palabras no serealiza, con la excepción de “$@” como se explica más abajo. No se realiza la expansión denombres de fichero. Las sentencias de asignación pueden aparecer también como argumentos en loscomandos 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 lashell o un índice de un array (vea la Sección 6.7 [Arrays]), el operador += puede ser usado paraagregar o añadir el valor dado al valor previo de la variable. Cuando se aplica el operador += a unavariable para la cual se ha establecido el atributo integer (entero), el valor se evalúa como unaexpresión aritmética y se añade al valor actual de la variable, la cual también se evalúa. Cuando seaplica el operador += a una variable de tipo array usando una asignación compuesta (vea la Página 24
  25. 25. Capitulo 3: Características Básicas del ShellSección 6.7 [Arrays]), el valor de la variable no es eliminado (como sí lo es cuando se usa =), y seagregan nuevos valores al array comenzando por el inmediatamente mayor al máximo índice delarray (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 lavariable.3.4.1.- Parámetros posicionalesUn parámetro posicional es un parámetro denotado por uno o más dígitos, distintos al dígito 0. Losparámetros posicionales se asignan desde los argumentos de la shell cuando esta es invocada, ypueden ser reasignados usando el comando interno set. El parámetro posicional N puede serreferenciado 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 yshift para establecer y eliminar estos parámetros (vea el Capítulo 4 [Comandos Internos de laShell]). Los parámetros posicionales son reemplazados temporalmente cuando se ejecuta unafunció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 debeser encerrado entre llaves.3.4.2.- Parámetros EspecialesLa 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
  26. 26. Capitulo 3: Características Básicas del Shell $ 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 shellLa 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 aderecha), 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 deprocesos. Esta se realiza al mismo tiempo que la expansión de parámetros y variables, la expansiónaritmé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 ficheropueden cambiar el número de palabras de la expansión; otras expansiones expanden de palabra apalabra. La única excepción a esto son las expansiones de “$@” (vea la Sección 3.4.2 [ParámetrosEspeciales]) y “${nombre[@]} ” (vea la Sección 6.7 [Array]) Después de realizar todas las expansiones se realiza la eliminación del entrecomillado (vea laSección 3.5.9 [Eliminación del Entrecomillado]). Página 26
  27. 27. Capitulo 3: Características Básicas del Shell3.5.1.- Expansión de LlavesLa expansión de llaves es un mecanismo por el cual se pueden generar cadenas arbitrarias. Estemecanismo es similar a la expansión de nombres de fichero (vea la Sección 3.5.8 [Expansión deNombres de Fichero]), pero los nombres de archivo generados no existen. Los patrones para laexpansión de llaves tienen la forma de un preámbulo opcional, seguido por o bien una serie decadenas separadas por comas o bien una expresión secuencia encerrada entre llaves, seguido por unepílogo opcional. El preámbulo se usa como prefijo para cada una de las cadenas contenidas entrelas llaves, y el epílogo se añade al final de cada cadena resultante, expandiendo de derecha aizquierda. Las expansiones de llaves pueden ser anidadas. No se ordena el resultado de cada cadenaexpandida; 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 ocaracteres únicos, e incr, es un incremento opcional, dado como un valor entero. Cuando sesuministran enteros, la expresión expande a cada número entre x e y, ambos inclusive. Los enterossuministrados 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 acontener el mismo número de dígitos, añadiendo ceros a la izquierda cuando sea necesario. Cuandose 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 elincremento este se usa como la diferencia entre cada uno de los términos. El incremento por defectoes 1 o -1 según corresponda. La expansión de llaves se realiza antes de cualquier otra expansión, y cualquier carácterespecial para otras expansiones se mantiene en el resultado. Esto es estrictamente textual. Bash noaplica 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 laexpansión de llaves. Una expansión de llaves formada correctamente debe contener las llaves de apertura y de cierresin 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 lacadena 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 TildesSi una palabra comienza con un carácter tilde (~ ) sin entrecomillar todos los caracteres anterioresa la primera barra no entrecomillada (o todos los caracteres si no hay barras sin entrecomillar) son Página 27
  28. 28. Capitulo 3: Características Básicas del Shellconsiderados 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 deinicio de sesión. Si este nombre de inicio de sesión es la cadena nula, la tilde es reemplazada por elvalor de la variable de shell HOME. Si HOME no está establecida, en su lugar se utiliza el directoriohome del usuario que está ejecutando la shell. De otro modo, el prefijo-tilde es reemplazado con eldirectorio 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 pilade directorios, como si fuera mostrado por el comando interno dirs invocado con los caracteres quesiguen 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 vaacompañado del signo +. Si el nombre de inicio de sesión es inválido, o la expansión de tilde falla, la palabra semantiene sin cambios. Cada asignación de variables se comprueba inmediatamente en busca de prefijos-tilde sinentrecomillar siguiendo al : o al primer =. En estos casos, la expansión tilde es inmediata. Porconsiguiente, uno pude usar los nombres de fichero con tildes en asignaciones a PATH, MAILPATHy 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 +N3.5.3.- Expansión de Parámetros de ShellEl 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 esopcional, pero sirve para proteger la variable a ser expandida de que los caracteres inmediatamentesiguientes 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 escapadamediante una barra invertida o encerrada en una cadena entrecomillada, y no encerrada en unaexpansió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 deparámetro. Las llaves son obligatorias cuando el parámetro es un parámetro posicional con más de Página 28
  29. 29. Capitulo 3: Características Básicas del Shellun dígito o cuando el parámetro es seguido por un carácter que no debe ser interpretado como partede su nombre. Si el primer carácter del parámetro es una exclamación de cierre (!), se realiza una indirecciónde variables de un nivel. Bash utiliza el valor de la variable formada con el resto del parámetrocomo el nombre de la variable; esta variable entonces se expande y ese valor se utiliza en el resto dela sustitución, en vez del valor del parámetro por sí mismo. Esto se conoce como expansiónindirecta. Las excepciones a esto son las expansiones ${!prefijo*} y ${!nombre[@]} descritas másabajo. La exclamación de cierre debe ir inmediatamente a continuación de la llave izquierda paraque indique la indirección. En todos los casos que se dan más abajo, palabra se somete a expansión de tildes, expansión depará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, Bashanaliza en busca de un parámetro que no esté establecido o sea nulo. Omitir el dos puntos resulta enque el chequeo se realiza sólo en busca de un parámetro que no esté establecido. Dicho de otromodo, si se incluye el dos puntos, el operador chequea tanto la existencia del parámetro como quesu 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
  30. 30. Capitulo 3: Características Básicas del Shell 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
  31. 31. Capitulo 3: Características Básicas del Shell 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. Lasustitución de comandos ocurre cuando un comando es encerrado de la siguiente manera: $(comando) o Página 31

×