**Bash** é un shell de Unix (**intérprete de comandos de Unix**) escrito para o Proxecto GNU. O nome é o acrónimo de  ***B**ourne-**a**gain **sh**ell*  (**Consola Bourne Renacida**) — un xogo de palabras sobor o Bourne shell (sh), que foi unha das primeiras consolas importantes de Unix. Cara 1978 o shell Bourne era o shell distribuído co Unix Version 7. O shell Bourne orixinal foi escrito por Stephen Bourne, por entón investigador dos Bell Labs. O shell Bash foi escrito en 1987 por Brian Fox. En 1990, Chet Ramey converteuse no seu principal mantedor. Bash é o shell por defecto na maioría de sistemas Linux ademais de Mac OS X Tiger, e pode executarse na maioría dos sistemas operativos tipo Unix. Tamén foi portado a Microsoft Windows polo proxecto Cygwin.

Sintaxe do Bash
---------------

A sintaxe de comandos do Bash é un superconxunto da sintaxe do shell Bourne. A especificación definitiva da sintaxe de comandos do Bash pódese atopar no Bash Reference Manual distribuído polo proxecto GNU. Esta sección destaca algunhas das características únicas do Bash.

A gran maioría dos shell scripts (**guións de comandos**) Bourne poden ser executados por Bash sen ningún cambio, coa excepción daqueles guións de shell Bourne que fan referencia a variables especiais de Bourne ou que utilizan un comando interno de Bourne. A sintaxe de comandos de Bash inclúe ideas tomadas do Korn shell (ksh) e o C shell (csh), como a edición da liña de comandos, o historial de comandos, a pila de directorios, as variables `$RANDOM` e `$PPID`, e a sintaxe de substitución de comandos POSIX: `$(...)`. Cando se utiliza coma un intérprete de comandos interactivo, Bash proporciona autocompletado de nomes de programas, nomes de ficheiros, nomes de variables etc, cando o usuario preme a tecla TAB.

A sintaxe de Bash ten moitas extensións que non proporciona o shell Bourne. Enuméranse a continuación varias das extensións mencionadas.

### Matemáticas con enteiros

Unha gran limitación do shell Bourne é que non pode realizar cálculos con enteiros sen lanzar un proceso externo. Un proceso Bash pode realizar cálculos con enteiros utilizando o comando `((...))` e a sintaxe de variables `$[...]` da seguinte maneira:

```
VAR=55             # Asigna o valor enteiro 55 á variable VAR.
((VAR = VAR + 1))  # Suma un á variable VAR.  Olle a ausencia do carácter '$'.
((++VAR))          # Outra maneira de sumar un a VAR.  Preincremento estilo C.
((VAR++))          # Outra maneira de sumar un a VAR.  Postincremento estilo C.
echo $[VAR * 22]   # Multiplica a variable VAR por 22 e substitúe o comando polo resultado.
echo $((VAR * 22)) # Outra maneira de realizalo mesmo.
```

O comando `((...))` tamén se pode utilizar en sentenzas condicionais, xa que seu código de retorno é 0 ou 1 dependendo de se a condición é certa ou falsa:

```
if ((VAR == Y * 3 + X * 2))
then
        echo Si
fi

((Z > 23)) && echo Si
```

O comando `((...))` soporta os seguintes operadores relacionais: '`==`', '`!=`', '`>`', '`<`', '`>=`', e '`<=`'.

Un proceso Bash non pode realizar cálculos en coma flotante. Os únicos shell Unix capaces disto son o Korn Shell (versión de 1993) e o zsh (a partir da versión 4.0).

### Redireccións de Entrada/Saída

A sintaxe do Bash permite diferentes maneiras de redirección de entrada/saída das que o Shell Bourne tradicional carece. Bash pode redirixir a saída estándar e os fluxos de saída de erro á vez utilizando a sintaxe:

```
comando &> ficheiro
```

que é máis simple que teclear o comando Bourne equivalente, "`comando > ficheiro 2>&1`". Desde a versión 2.05b, Bash pode redirixir a entrada estándar desde unha cadea utilizando a seguinte sintaxe (denominada "**here strings**"):

```
comando <<< "cadea a ler como entrada estándar"
```

Se a cadea contén espazos en branco, débense utilizar aspas.

**Exemplo**:
Redirixe a saída estándar a un ficheiro, escribe datos, cerra o ficheiro e reinicia stdout

```
# Fai que o descritor de ficheiro 6 sexa unha copia de stdout (descritor ficheiro 1)
exec 6>&1
# abre o ficheiro "test.data" para escritura
exec 1>test.data
# xera algún contido
echo "data:data:data"
# pecha o ficheiro "test.data"
exec 1>&-
# Reinicia stdout o facer que sexa unha copia do descritor de ficheiro 6
exec 1>&6
# pecha o descritor de ficheiro 6
exec 6>&-
```

Abre e pecha ficheiros

```
# abre o ficheiro test.data para letura
exec 6<test.data
# le ata o final do ficheiro
while read -u 6 dta
do
  echo "$dta" 
done
# pecha o ficheiro test.data
exec 6<&-
```

Captura a saída de comandos externos

```
 # executa 'find' e garda os resultados en VAR
 # busca nomes de ficheiros que rematan coa letra "h"
 VAR=$(find. -name "*h")
```

### Expresións regulares

Os procesos Bash 3.0 soportan emparellamento de expresións regulares utilizando a seguinte sintaxe, reminiscente do Perl:

```
[[ string =~ regex ]]
```

A sintaxe de expresións regulares é a mesma que documenta a páxina do manual regex(3). O estado de saída do comando anterior é 0 se a cadea concorda coa expresión regular, 1 se non casan.

Nas expresións regulares, as partes delimitadas por parénteses, poden ser accedidas utilizando a variable shell `BASH\_REMATCH`, da seguinte maneira:

```
if [[ abcfoobarbletch =~ 'foo(bar)bl(.\*)' ]]
then
        echo A expresión regular coincide!
        echo $BASH_REMATCH—produce: foobarbletch
        echo ${BASH_REMATCH[1]} -- produce: bar
        echo ${BASH_REMATCH[2]} -- produce: etch
fi
```

Esta sintaxe proporciona un rendemento superior a lanzar un proceso separado para executar un comando `grep`, porque o emparellamento das expresións regulares ten lugar no propio proceso Bash. Se a expresión regular ou a cadea conteñen un espazo en branco, ou un metacarácter do shell (coma '`\*`' ou '`?`'), debe estar entre aspas.

### Escape con contrabarra

As palabras coa forma `$'string'` trátanse dun modo especial. Estas verbas expándense a `string`, cos caracteres escapados pola contrabarra substituídos segundo especifica a linguaxe de programación C. As secuencias de escape con contrabarra, descodifícanse do seguinte modo:

Backslash Escapes| BackslashEscape | Expands To ... |
| --- | --- |
| `\a` | Carácter de aviso (campaíña) |
| `\b` | Carácter para tras |
| `\e` | Carácter de escape |
| `\f` | Carácter de expulsión de papel |
| `\n` | Carácter de liña nova |
| `\r` | Carácter de retorno de carro |
| `\t` | Carácter de tabulador horizontal |
| `\v` | Carácter de tabulador vertical |
| `\\` | Carácter de barra invertida |
| `\'` | Carácter de aspa simple |
| `\nnn` | O carácter de oito bits cuxo valor é o valor octal nnn (un a tres díxitos) |
| `\xHH` | O carácter de oito bits cuxo valor é o valor hexadecimal HH (un ou dous díxitos hexadecimais) |
| `\cx` | Carácter control-X |

O resultado expandido atópase entrecomillado entre aspas simples, coma se o signo dólar non estivese presente.

Unha cadea entrecomillada con aspas dobres precedida por un signo dólar (`$"..."`) será **traducida** de acordo ó LOCALE actual. Se fose C ou POSIX, ignórase o símbolo $. Se a cadea é **traducida** e substituída, a substitución estará entrecomillada por aspas dobre.

Guións de inicio do Bash
------------------------

Cando Bash arranca, executa os comandos que se atopan en diferentes scripts.

Cando se invoca a Bash como shell interactivo para o inicio dunha sesión (**login shell**), ou como shell non interactivo coa opción `--login`, en primeiro lugar le e executa comandos desde o ficheiro `/etc/profile`, se existe. Despois, busca `~/.bash\_profile`, `~/.bash\_login`, e `~/.profile`, nesa orde, e le e executa os comandos desde o primeiro que existe e é lexible. A opción `--noprofile` pode utilizarse ó comezar un novo shell para inhibir este comportamento.

Cando un **login shell** termina, Bash le e executa os comandos de `~/.bash\_logout`, se existe.

Cando un shell interactivo que non é un login shell arranca, Bash lee e executa comandos desde `~/.bashrc`, s existise. Isto pode evitarse utilizando a opción `--norc`. A opción `--rcfile ficheiro` forzará a Bash a ler e executar comandos desde `ficheiro` na vez de `~/.bashrc`.

Cando Bash arranca dun modo non interactivo, por exemplo para executar un shell script diferente, busca a variable de contorno `BASH\_ENV`, se existe expande o seu valor, e utilízao coma o nome do ficheiro para ler e executar. Bash comportase coma se se executase o seguinte comando:

```
if [ -n "$BASH_ENV" ]; then. "$BASH_ENV"; fi
```

mais o valor da variable `PATH` non se utiliza para buscar o ficheiro.

Se se invoca a Bash co nome `sh`, tenta replicar o comportamento das versións antigas de `sh`, á vez que se mantén a conformidade co estándar POSIX. Cando se invoca como login shell interactivo, ou shell non interactivo coa opción `--login`, primeiro tenta ler e executar comandos desde `/etc/profile` e `~/.profile`, nesta orde. A opción `--noprofile` pode utilizarse para evitar este comportamento. Cando se invoca como un shell interactivo co nome `sh`, Bash busca a variable `ENV`, se está definida expande o seu valor, e utiliza o valor expandido coma o nome dun ficheiro para ler e executar. Coma un shell invocado coma `sh` non tenta ler e executar comandos desde ningún outro ficheiro de arranque, e a opción `--rcfile` non ten efecto. Un shell non interactivo invocado co nome `sh` non intenta ler ningún outro ficheiro de arranque. Cando se invoca coma `sh`, Bash entra no modo *posix* despois de ler os ficheiros de inicio.

Cando se inicia Bash no modo posix, por exemplo coa opción `--posix`, segue o estándar POSIX para os ficheiros de inicio. Neste modo, os shells interactivos expanden a variable `ENV` e lense, e execútanse, os comandos desde o ficheiro do cal o nome é o valor da variable expandida. Non se le ningún outro ficheiro de arranque.

Bash tenta determinar cando está sendo executado por un demo (daemon) do shell remoto, normalmente `rshd`. Se Bash determina que está sendo executado por `rshd`, le e executa comandos desde `~/.bashrc`, se este ficheiro existe e é lexible. Non fará isto se se invoca como `sh`. A opción `--norc` pode utilizarse para evitar este comportamento, e a opción `--rcfile` pode utilizarse para forzar a ler outro ficheiro, pero `rshd` normalmente non invoca o shell con estas opcións ou permite que sexan especificadas.

Notas
-----

1. ↑  "Páxina de descargas de GNU Bash patch list". 29 de maio de 2023.

Véxase tamén
------------

|  |  |
| --- | --- |
|  | Wikimedia Commons ten máis contidos multimedia na categoría:  ***Bash Modificar a ligazón no Wikidata*** |

### Ligazóns externas

* Bash home page
* Bash FAQ
* The GNU Bash Reference Manual, (HTML version) por Chet Ramey e Brian Fox, ISBN 0-9541617-7-7
* Programación bash (en español)Arquivado 19 de febreiro de 2006 en Wayback Machine.
* Bash Guide for Beginners
* BASH Programming - Introduction HOW-TO
* Advanced Bash-Scripting Guide
* Linux Shell Scripting Tutorial - A Beginner's handbook*(en inglés)*
* Beginners Bash Tutorial
* Linux Know-How including the Bash Guide for Beginners

|  |  |
| --- | --- |
| Control de autoridades | 
* Wd: Q189248
* BNF: 125416570
* GND: 4492523-2
* SUDOC: 034688234

 |