Bash (Bourne again shell) es un
programa informático, cuya función consiste en
interpretar órdenes, y un
lenguaje de programación de consola. Está basado en la
shell de Unix y es compatible con
POSIX.
Fue escrito para el
proyecto GNU por
Brian Fox y es el intérprete de comandos por defecto en la mayoría de las distribuciones de
GNU con Linux. Es el sustituto
libre de
Bourne Shell1 2 Su nombre es un
acrónimo de
Bourne-Again Shell (otro shell bourne) — haciendo un juego de palabras (born-again significa renacimiento) sobre el
Bourne shell (
sh), que fue uno de los primeros intérpretes importantes de Unix.
Hacia 1978 Bourne era el intérprete distribuido con la versión del sistema operativo Unix
Versión 7.
Stephen Bourne, por entonces investigador de los
Laboratorios Bell, escribió la versión original de Bourne.
Brian Fox escribió Bash en 1987. En 1990,
Chet Ramey se convirtió en su principal desarrollador. Bash es el intérprete predeterminado en la mayoría de sistemas
GNU/Linux, además de
Mac OS X Tiger, y puede ejecutarse en la mayoría de los sistemas operativos
tipo Unix. También se ha llevado a
Microsoft Windows por el
proyecto Cygwin.
Sintaxis de Bash
La sintaxis de órdenes de Bash es un superconjunto de instrucciones
basadas en la sintaxis del intérprete Bourne. La especificación
definitiva de la sintaxis de órdenes de Bash, puede encontrarse en el
Bash Reference Manual distribuido por el proyecto GNU. Esta sección destaca algunas de sus únicas características.
La mayoría de los
shell scripts (
guiones de intérprete de órdenes)
Bourne pueden ejecutarse por Bash sin ningún cambio, con la excepción
de aquellos guiones del intérprete de órdenes, o consola, Bourne que
hacen referencia a variables especiales de Bourne o que utilizan una
orden interna de Bourne. La sintaxis de órdenes de Bash incluye ideas
tomadas desde el
Korn Shell (ksh) y el
C Shell (csh), como la edición de la línea de órdenes, el historial de órdenes, la pila de directorios, las variables
$RANDOM y
$PPID, y la sintaxis de substitución de órdenes
POSIX:
$(...).
Cuando se utiliza como un intérprete de órdenes interactivo, Bash
proporciona autocompletado de nombres de programas, nombres de archivos,
nombres de variables, etc, cuando el usuario pulsa la tecla TAB.
La sintaxis de Bash tiene muchas extensiones que no proporciona el
intérprete Bourne. Varias de las mencionadas extensiones se enumeran a
continuación.
Acceso a los parámetros
Los guiones de Bash reciben los parámetros que le pasa la shell como
$1, $2, ..., $n. Podemos saber cuantos hemos recibido con el símbolo $#.
Por ejemplo, si nuestro guion necesita dos parámetros pondremos:
if [ $# -lt 2 ]; then
echo "Necesitas pasar dos parámetros."
exit 1
fi
Además disponemos del array $@, el cual contiene todos los parámetros
pasados al guion y podemos iterar sobre estos de la siguiente manera:
for param in "$@"
do
echo "$param"
done
Matemáticas con enteros
Una gran limitación del intérprete Bourne es que no puede realizar
cálculos con enteros sin lanzar un proceso externo. En cambio, un
proceso Bash puede realizar cálculos con enteros utilizando la orden
((...)) y la sintaxis de variables
$[...] de la siguiente manera:
VAR=55 # Asigna el valor entero 55 a la variable VAR.
((VAR = VAR + 1)) # Suma uno a la variable VAR. Observe la ausencia del carácter '$'.
((++VAR)) # Otra forma de sumar uno a VAR. Preincremento estilo C.
((VAR++)) # Otra forma de sumar uno a VAR. Postincremento estilo C.
echo $[VAR * 22] # Multiplica la variable VAR por 22 y sustituye la orden por el resultado.
echo $((VAR * 22)) # Otra forma de realizar lo mismo.
La orden
((...)) también se puede utilizar en sentencias condicionales, ya que su
código de retorno es 0 o 1 dependiendo de si la condición es cierta o falsa:
if ((VAR == Y * 3 + X * 2))
then
echo Si
fi
((Z > 23)) && echo Si
La orden
((...)) soporta los siguientes
operadores relacionales: '
==', '
!=', '
>', '
<', '
>=', y '
<='.
Un proceso Bash no puede realizar cálculos en
coma flotante. Los únicos shell Unix capaces de esto son el
Korn Shell (versión de 1993) y el
zsh (a partir de la versión 4.0).
Redirecciones de entrada/salida
La sintaxis de Bash permite diferentes formas de
redirección de entrada/salida de las que el Shell Bourne tradicional carece. Bash puede redirigir la
salida estándar y los flujos de
error estándar a la vez utilizando la sintaxis:
que es más simple que teclear la orden Bourne equivalente, "
orden > archivo 2>&1".
Desde la versión 2.05b, Bash puede redirigir la entrada estándar desde
una cadena utilizando la siguiente sintaxis (denominada "
here strings"):
orden <<< "cadena a leer como entrada estándar"
Si la cadena contiene espacios en blanco, deben utilizarse comillas.
Ejemplo: Redirige la salida estándar a un archivo, escribe datos, cierra el archivo y reinicia
stdout
# hace que el descriptor de archivo 6 sea una copia de stdout (descriptor archivo 1)
exec 6>&1
# abre el archivo "test.data" para escritura
exec 1>test.data
# genera algún contenido
echo "data:data:data"
# recupera stdout original, al hacer que sea una copia del descriptor de archivo 6
exec 1>&6
# cierra el descriptor de archivo 6
exec 6>&-
Abre y cierra archivos
# abre el archivo test.data para lectura
exec 6<test.data
# lee hasta el final del archivo
while read -u 6 dta
do
echo "$dta"
done
# cierra el archivo test.data
exec 6<&-
Captura la salida de órdenes externas
# ejecuta 'find' y guarda los resultados en VAR
# busca nombres de archivos que terminan con la letra "h"
VAR=$(find . -name "*h")
Expresiones regulares
Los procesos Bash 3.0 soportan emparejamiento de
expresiones regulares utilizando la siguiente sintaxis, reminiscente de
Perl:
La sintaxis de expresiones regulares es la misma que documenta la
página de manual
regex(3). El estado de salida de la orden anterior es 0 si la cadena
concuerda con la expresión regular, y 1 si no casan. En las expresiones
regulares puede accederse a las partes delimitadas por paréntesis,
utilizando la variable shell
BASH_REMATCH, de la siguiente manera:
if [[ foobarbletch =~ 'foo(bar)bl(.*)']]
then
echo The regex matches!
echo $BASH_REMATCH -- outputs: foobarbletch
echo ${BASH_REMATCH[1]} -- outputs: bar
echo ${BASH_REMATCH[2]} -- outputs: etch
fi
Esta sintaxis proporciona un rendimiento superior a lanzar un proceso separado para ejecutar una orden
grep,
porque el emparejamiento de las expresiones regulares tiene lugar en el
propio proceso Bash. Si la expresión regular o la cadena contiene un
espacio en blanco o un
metacarácter del shell (como '
*' o '
?'), debe ser entrecomillada.
Escape con contrabarra
Las palabras con la forma
$'string' se tratan de un modo especial. Estas palabras se expanden a
string, con los caracteres escapados por la contrabarra reemplazados según especifica el
lenguaje de programación C. Las secuencias de escape con contrabarra, se decodifican del siguiente modo:
Escapes con contrabarra
Backslash
Escape |
Se expande a... |
| \b |
Un carácter de retroceso |
| \e |
Un carácter de escape |
| \f |
Un carácter de alimentación de línea (form feed) |
| \n |
Un carácter de nueva línea |
| \r |
Un carácter de retorno de carro |
| \t |
Un tabulador horizontal |
| \v |
Un tabulador vertical |
| \\ |
Un carácter contrabarra |
| \' |
Un carácter de comilla simple |
| \nnn |
El carácter de 8 bits cuyo valor es el número octal nnn (de uno a tres dígitos) |
| \xHH |
El carácter de 8 bits cuyo valor es el número hexadecimal HH (uno o dos dígitos hexadecimales) |
| \cx |
Un carácter control-X |
El resultado expandido se encuentra entrecomillado con comilla simple, como si el signo
$ no estuviese presente.
Una cadena entrecomillada con comillas dobles precedida por un signo $ (
$"...") será
traducida de acuerdo al LOCALE actual. Si fuese C o POSIX, se ignora el símbolo $. Si la cadena es
traducida y reemplazada, el reemplazo estará entrecomillado por comilla doble.
Guiones de inicio de Bash
Cuando Bash arranca, ejecuta las órdenes que se encuentran en diferentes guiones.
Cuando se invoca a Bash como un shell interactivo para el inicio de una sesión (
login shell), o como un shell no interactivo con la opción
--login, en primer lugar lee y ejecuta órdenes desde el archivo
/etc/profile, si existe. Después, busca
~/.bash_profile,
~/.bash_login, y
~/.profile, en este orden, y lee y ejecuta las órdenes desde el primero que existe y es legible. La opción
--noprofile puede utilizarse al comenzar un nuevo shell para inhibir este comportamiento.
Cuando un
login shell termina, Bash lee y ejecuta las órdenes de
~/.bash_logout, si existe.
Cuando un shell interactivo que no es un login shell arranca, Bash lee y ejecuta órdenes desde
~/.bashrc, si existiese. Esto puede evitarse utilizando la opción
--norc. La opción
--rcfile archivo forzará a Bash a leer y ejecutar órdenes desde
archivo en lugar de
~/.bashrc.
Cuando Bash arranca de un modo no interactivo, por ejemplo para
ejecutar un guion de consola diferente, busca la variable de entorno
BASH_ENV,
si existe expande su valor, y lo utiliza como el nombre del archivo
para leer y ejecutar. Bash se comporta como si se ejecutase la siguiente
orden:
if [ -n "$BASH_ENV" ]; then . "$BASH_ENV"; fi
pero el valor de la variable
PATH no se utiliza para buscar el archivo.
Si se invoca a Bash con el nombre
sh, intenta replicar el comportamiento de las versiones antiguas de
sh, a la vez que se mantiene la conformidad con el estándar
POSIX. Cuando se invoca como un login shell interactivo, o un shell no interactivo con la opción
--login, primero intenta leer y ejecutar órdenes desde
/etc/profile y
~/.profile, en este orden. La opción
--noprofile puede utilizarse para evitar este comportamiento.
Cuando se invoca como un shell interactivo con el nombre
sh, Bash busca la variable
ENV,
si está definida expande su valor, y utiliza el valor expandido como el
nombre de un archivo para leer y ejecutar. Como un shell invocado como
sh no intenta leer y ejecutar órdenes desde ningún otro archivo de arranque, y la opción
--rcfile no tiene efecto. Un shell no interactivo invocado con el nombre
sh no intenta leer ningún otro archivo de arranque. Cuando se invoca como
sh, Bash entra en el modo
posix después de leer los archivos de inicio.
Cuando se inicia Bash en el modo posix, por ejemplo con la opción
--posix, sigue el estándar POSIX para los archivos de inicio. En este modo, los shells interactivos expanden la variable
ENV
y se leen, y ejecutan, las órdenes desde el archivo cuyo nombre es el
valor de la variable expandida. No se lee ningún otro archivo de
arranque.
Bash intenta determinar cuando está siendo ejecutado por un dominio de shell remoto, normalmente
rshd. Si Bash determina que está siendo ejecutado por
rshd, lee y ejecuta órdenes desde
~/.bashrc, si este archivo existe y es legible. No hará esto si se invoca como
sh. La opción
--norc puede utilizarse para evitar este comportamiento, y la opción
--rcfile puede utilizarse para forzar a leer otro archivo, pero
rshd normalmente no invoca al shell con estas opciones o permite que sean especificadas.
Si quieres ver mas a fondo este articulo visita el link original
Link
RSS Feed
20:22
Carlos
En este bloque se asume que las variables suma y N han sido declaradas previamente y las inicializa en 0 para comenzar a el conteo y la suma de valores (
En éste paso se incrementa en 1 la variable N (N = N + 1). Por lo que, en la primera pasada esta N valdrá 1, ya que estaba inicializada en 0.
Pero en éste, ya se le agrega el valor de N a la variable que contendrá la suma (
