Bash

Acceso a los parámetros

Los scripts 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 script 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 script 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 operadores relacionales.

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: orden y archivo que es más simple que teclear la orden Bourne equivalente, orden y archivo. 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 Expresión regular utilizando la siguiente sintaxis, reminiscente de Perl:

La sintaxis de expresiones regulares es la misma que documenta la Man (Unix)|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 debe ser entrecomillada).

Escape con contrabarra

Las palabras con la forma se tratan de un modo especial. Estas palabras se expanden a , 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:

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.