Bash (consola de shell de Unix)

El idioma de entrada al intérprete de comandos se reconocerá primero a nivel de caracteres. ^{[ b ]}

$ printf '<newline>: <%b>\n' $'\n' <newline>: < > $ printf '<tab>: <%b>\n' $'\t' <tab>: < > $ printf '<space>: <%s>\n' " " <space>: < > $ printf '<NUL>: <%b>\n' $'\0' <NUL>: <>

Cualquier serie de caracteres se denomina "cadena" o, a veces, " literal de cadena ". En los sistemas operativos tipo Unix, todos los caracteres, tanto imprimibles como no imprimibles, excepto algunos como el carácter nulo y la barra inclinada / , pueden utilizarse en los nombres de archivo . Además, todas las cadenas distinguen entre mayúsculas y minúsculas. ^{[ c ]}

Bash, al igual que muchos otros lenguajes de programación, utiliza una numeración basada en cero .

La funcionalidad Control+tecla la proporciona GNU Readline y solo está disponible en modo interactivo. Ciertas combinaciones de teclas permiten al usuario operar Bash para usar la función de autocompletado y buscar en el historial de comandos.

• Tab ↹– Activar la función de autocompletar pestañas
• ↑– Desplácese hacia arriba (es decir, hacia atrás) en el historial de comandos.
• ↓– Desplácese hacia abajo (es decir, hacia adelante) en el historial de comandos.
• Ctrl+r – Buscar en el historial de comandos

Algunas combinaciones de teclas también permiten al usuario operar el emulador de terminal para mover el cursor dentro de la ventana del terminal y controlar el programa emulador. ^{[ 10 ]} Por defecto, estas combinaciones de teclas en Bash reflejan las de Emacs . ^{[ d ]}

Las combinaciones de teclas predeterminadas para los códigos de control incluyen:

• Ctrl+f – Mueve el cursor un carácter a la derecha
• Ctrl+b – Mueve el cursor un carácter a la izquierda
• Alt+f – Mueve el cursor una palabra a la derecha
• Alt+b – Mueve el cursor una palabra a la izquierda
• Ctrl+a – Mueve el cursor al principio de la línea de comandos actual.
• Ctrl+c – Cancela el comando actual y muestra un nuevo mensaje.
• Ctrl+d – Cierra la instancia actual de Bash, posiblemente también cerrando el emulador de terminal.
• Ctrl+e – Mueve el cursor al final de la línea de comandos actual.
• Ctrl+q – Activa la terminal; las pulsaciones de teclas almacenadas en búfer se procesan a continuación.
• Ctrl+s – Poner la terminal en modo de suspensión
• Ctrl+w – Elimina una palabra a la izquierda del cursor
• Ctrl+z – Detener un proceso en primer plano

También están disponibles las combinaciones de teclas de Vi y se pueden habilitar ejecutando . ^{[ e ]}set-ovi

Cuando Bash lee una línea de comandos completa, la cadena completa se divide en tokens. Los "tokens" se identifican mediante y se separan entre sí mediante metacaracteres .

A partir de Bash 5.3, los 10 metacaracteres son el espacio, la tabulación y el salto de línea, así como los siguientes caracteres:|&;()<>

Los "espacios en blanco" están compuestos enteramente de metacaracteres sin comillas, los "operadores" contienen al menos un metacaracter sin comillas cada uno y las "palabras" no pueden incluir ningún metacaracter sin comillas.

En la práctica, Bash divide las cadenas de comandos completas en tokens o grupos de tokens que contienen metacaracteres y tokens o grupos de tokens que no los contienen, denominados "palabras" . A partir de ahí, subdivide las palabras en partes más específicas y significativas, como nombres de comandos, instrucciones de asignación de variables, etc.

Los dos espacios en blanco son un espacio y una tabulación.

'!' '[[' '{' ']]' '}' caso en esac para hacer hecho si entonces si no fi ... 

$ #, , , ,, , ,, , $ if echo foo ; then bar = abc ; fi $ # ^^ ```` ``` ^^^^ ``````` ^^

Un "subproceso" es una instancia adicional del intérprete de comandos que ha sido inicializada por una instancia actual del mismo. Cuando un intérprete de comandos "padre" crea un subproceso, o un intérprete de comandos "hijo", se recrea una copia exacta de la información del entorno del padre, que se convierte en el entorno del subproceso.

En Bash, en contextos no aritméticos, se puede forzar el uso de un subproceso encerrando una cadena de comandos completa entre paréntesis simples .

$ echo foo ; ( echo foo ) foo foo

En este caso sencillo, los dos comandos anteriores son equivalentes; sin embargo, el uso de subprocesos puede tener ciertos efectos secundarios inesperados. Existen numerosas formas de sintaxis que pueden provocar la inicialización de un subproceso. A continuación, se presenta una lista no exhaustiva de operadores que provocan la inicialización de un subproceso:

• La sintaxis de subshells, ()por ejemplo, inicializaría un subshell:

  $ ( programa arga argb )

• La sintaxis de tuberías A | Binicializaría múltiples subprocesos, uno para cada comando separado en la tubería:

  $ programa1 abc definición | programa2 -abc 

Bash ofrece variables y arreglos como estructuras de datos, y aunque existen numerosos tipos de cada una, las estructuras de datos son relativamente simples en comparación con otros lenguajes como C o Java . Todos los datos se almacenan en memoria como cadenas de texto.

El signo de dólar al inicio de una palabra indica que se trata del nombre de una variable o matriz. Siempre se recomienda encerrar la sintaxis del signo de dólar/nombre de variable entre comillas dobles. Esta práctica protege los valores de los parámetros de posibles efectos secundarios no deseados.

Se recomienda encerrar el nombre de la variable entre llaves {}para mayor legibilidad y coherencia entre variables y arreglos. Al escribir variables, las llaves son opcionales y los corchetes constituirían un error de sintaxis. Los nombres de los parámetros siempre se colocan a la izquierda del signo igual y los valores siempre a la derecha.

La "ejecución" de un programa determinado se produce cuando un usuario (o algún otro programa) le pide al sistema operativo que actúe conforme a las instrucciones contenidas en dicho programa.

Por defecto, Bash lee el código del usuario línea por línea, interpreta cualquier salto de línea o punto y coma ;como el final del comando actual y ejecuta los comandos en secuencia. Si un comando interactivo se extiende más allá del ancho del emulador de terminal, normalmente es posible seguir escribiendo y el comando se ajustará automáticamente. Para extender un comando más allá de un salto de línea a una línea adicional, es necesario que el último carácter de la primera línea sea una barra invertida sin escape, \, que indica "continuación de línea". Bash siempre termina de analizar y ejecutar una línea de comandos completa antes de pasar a analizar la siguiente.

$ foo = aa bar = bb quux = cc zork = dd ; establecer -o xtrace $ : " ${ foo } " ; : " ${ bar } " + : aa + : bb $ : " ${ quux } " \ > : " ${ zork } " + : cc : dd

La primera palabra de una línea de comandos se conoce como la "posición del comando". Según la convención de UNIX, la primera palabra de la línea de comandos siempre es algún tipo de comando, y el resto de las palabras en la cadena de la línea de comandos son opciones para el comando, argumentos para las opciones o algún tipo de entrada sobre la cual operará el comando. Las "opciones" también se denominan "indicadores", "conmutadores" o, más formalmente, "operadores". Cuando Bash intenta localizar un comando para su ejecución, los directorios que busca son los que aparecen en la $PATHvariable y el directorio de trabajo actual. ^{[ 12 ]}

$ # [POSICIÓN DEL COMANDO] [OPCIÓN] [ARGUMENTOS] $ # ,--^ ,------------^ ,----^ $ declare -p USER BASH_VERSION declare -x USER="liveuser" declare -- BASH_VERSION="5.2.37(1)-release"

Se puede crear una cuenta de usuario tanto para una persona como para un programa. En los sistemas operativos tipo Unix, existen dos tipos de usuarios: "privilegiados" y "normales". Un usuario privilegiado, como el usuario root o el núcleo del sistema operativo, tiene permiso para realizar cualquier acción en la máquina. Los usuarios no privilegiados están sujetos a diversas limitaciones.

Cuando una sesión interactiva de shell espera la entrada del usuario, por defecto imprime una cadena de caracteres específica en la pantalla. En Bash, el valor de esta cadena de espera se almacena en la variable$PS1 de shell . Para los usuarios normales, un valor predeterminado común para $PS1es el carácter de dólar ( $ ). ^{[ j ]} Para el superusuario , un valor predeterminado común es el hash ( # ).

$ sudo --login --user root [sudo] contraseña para liveuser: # vim /home/liveuser/names.txt # salir $ grep -e bob ./names.txt grep: ./names.txt: Permiso denegado

Aunque la mayoría de los usuarios consideran la shell como un intérprete de comandos interactivo, en realidad es un lenguaje de programación en el que cada instrucción ejecuta un comando. Debido a que debe satisfacer tanto los aspectos interactivos como los de programación de la ejecución de comandos, es un lenguaje peculiar, moldeado tanto por la historia como por el diseño. ^{[ 13 ]}

Bash está escrito en C. Se puede lograr un estilo modular mediante un buen estilo y un diseño cuidadoso. ^{[ 14 ]} A menudo se utiliza en un estilo imperativo o procedimental .

Como procesador de comandos , Bash puede operar en dos modos: interactivo o no interactivo. En el modo interactivo , los comandos se leen generalmente desde un emulador de terminal . En el modo no interactivo, que facilita la automatización , los comandos se leen generalmente desde archivos con nombre, conocidos hoy como scripts de shell . Cuando se ejecuta como un comando independiente en la interfaz de línea de comandos (CLI), por defecto Bash abre una nueva shell en modo interactivo.

Los scripts de shell son archivos de texto que contienen código , a menudo comandos , destinados a ser leídos y ejecutados por un intérprete específico en un proceso por lotes, de forma no interactiva y sin interacción adicional del usuario. Los scripts interpretados son programas que no requieren la compilación de su código fuente : todo el código fuente relevante se encuentra dentro del propio script. Existen muchos programas que pueden funcionar como intérpretes de scripts: Perl , AWK , etc. Los scripts interpretados se escriben con mayor frecuencia para shells de Unix.

Los dos primeros caracteres de la primera línea de cualquier script de shell (ejecutable) comienzan con algo llamado shebang : literalmente los caracteres hash ( # ) y bang ( ! ) uno al lado del otro.

$ cat ./example.sh # ! /bin/env bash echo foo

Si un script está destinado a ser ejecutado por un usuario como un programa independiente en la línea de comandos, entonces se le denomina "ejecutable" . Por convención, los nombres de archivo de los scripts de shell de Unix ejecutables se identifican con el sufijo .sh. El bit "execute" se puede habilitar en un script de shell con la utilidad chmod:

$ ls -l ./example.sh -rw-r--r--.1 liveuser liveuser 32 Aug 3 22:33 example.sh $ ./example.sh bash: ./example.sh: Permiso denegado $ chmod 0744 ./example.sh $ ls -l ./example.sh -rwxr--r--.1 liveuser liveuser 32 Aug 3 22:33 example.sh $ ./example.sh foo

Con el comando source, o su sinónimo ., Bash lee y ejecuta comandos de shell desde cualquier archivo de texto por su nombre. ^{[ k ]}

Bash puede ejecutarse como intérprete de comandos de inicio de sesión , o " líder de sesión ", tanto en modo interactivo como no interactivo mediante la --loginopción correspondiente. El inicio de sesión requiere autenticación de usuario . Por este motivo, solo existe un intérprete de comandos de inicio de sesión por sesión de usuario. En GNU/Linux, el intérprete de comandos de inicio de sesión de un usuario se identifica en el archivo /etc/passwd.

$ awk -F ':' '$1 ~ /root/' /etc/passwd root:x:0:0:Super User:/root:/bin/bash

Cuando un usuario humano inicia sesión, este procedimiento suele realizarse en una interfaz gráfica de usuario (GUI). Al abrir un emulador de terminal , este ejecuta una instancia del intérprete de comandos del usuario que no es de inicio de sesión.

Cerrar sesión en una sesión de shell desde un emulador de terminal se puede lograr con el comando exit o, por defecto en Bash, presionando + . Ctrld

Cuando Bash se inicia, utiliza sourcepara ejecutar comandos en una variedad de dotfiles (ver listas a continuación). ^{[ 15 ]} Estos dotfiles, a diferencia de los scripts de shell, normalmente no tienen habilitado el permiso de ejecución ni un hash-bang . Por defecto, Bash cargará un conjunto de archivos algo diferente, y en una secuencia diferente, dependiendo de: ^{[ l ]}

• Cómo se llama a Bash: de forma interactiva, no interactiva, invocado con nombresh
• ¿Qué opciones se utilizan?: --login, --rcfile, --norc,--posix
• ¿Qué variables de entorno están definidas: BASH_ENV, ENV, y
• ¿Qué archivos existen?
  • /etc/profile
  • ~/.bash_profile
  • ~/.bash_login
  • ~/.profile
  • ~/.bash_logout, y
  • ~/.bashrcentre otros.

Por supuesto, cualquier archivo de inicio también puede ejecutar comandos de cualquier otro archivo. Los archivos de inicio pueden afectar el comportamiento del shell, los emuladores de terminal, el sistema de ventanas X y el gestor de ventanas .

El estándar POSIX IEEE 1003.1 especifica un conjunto común de definiciones al que puede ajustarse cualquier aplicación de sistema de shell (bash, dash , zsh , etc.). Cualquier script de usuario de shell ./myscript.shescrito de conformidad con las directrices POSIX debería ser ejecutable por cualquier aplicación de sistema de shell que haya implementado la especificación POSIX. En consecuencia, se puede esperar razonablemente que los scripts compatibles con POSIX se ejecuten correctamente en cualquier sistema operativo Unix o similar que implemente el estándar POSIX ( Linux , OpenBSD , Oracle Linux , HP-UX , etc.). Estos scripts se consideran " portátiles " tal como están y sin modificaciones adicionales. La parte de POSIX que se aplica a los shells y las utilidades de línea de comandos es un subconjunto de un grupo más amplio de estándares POSIX que especifican con mayor detalle cómo deben funcionar los terminales y los emuladores de terminal para que también se consideren portátiles.

Cuando Bash funciona en modo POSIX, dispone de menos funciones, pero el código resultante se puede ejecutar en una mayor variedad de sistemas operativos.

Para habilitar el modo POSIX al inicializar un shell interactivo, Bash se puede ejecutar como sh, bash --posixo bash -o posix. ^{[ m ]}

Para que un script se inicialice en modo POSIX, se usaría el hashbang #!/usr/bin/env sho el menos portable #!/bin/sh. Cuando una instancia de Bash está operando en modo POSIX, $POSIXLY_CORRECTse define la variable de entorno y el valor de la variable de entorno SHELLOPTSincluye la cadena posix .

$ declare -p POSIXLY_CORRECT SHLVL bash: declare: POSIXLY_CORRECT: no encontrado declare -x SHLVL="1" $ sh $ declare -p POSIXLY_CORRECT SHLVL declare -- POSIXLY_CORRECT="y" declare -x SHLVL="2"

La lista completa de características disponibles en Bash que no están especificadas por POSIX es considerable. ^{[ 17 ]} Aquí hay una lista parcial:

• Cualquier matriz que no sea la matriz de parámetros posicionales, $@, no es POSIX
• La construcción de prueba extendida de doble corchete, [[...]], no es POSIX
  • [...]y testson POSIX
• Una de las sintaxis de evaluación aritmética con paréntesis dobles, ((...)), no es POSIX
  • $((...))es POSIX
• La expansión de llaves kernel{,-headers}no es POSIX.
• El alcance dinámico de los parámetros y la localfunción integrada no son POSIX.
• La sustitución de procesos <(...)no es POSIX.
• Ciertas operaciones de manipulación de cadenas en expansiones de parámetros no son POSIX.
• La mayoría de los comandos integrados de Bash no son POSIX.
  • El comando imprime la lista de funciones integradas especiales de Bourne, que son POSIXenable-s

    $ enable -s | wc --lines 16 $ enable | wc --lines 61

  • El enablepropio sistema integrado no es POSIX.
  • En Bash, en modo no POSIX, los builtins .y sourceson sinónimos.
    • El .operador integrado (es decir, 'punto') es POSIX, sin embargo
    • El sourcesistema integrado no es POSIX.
• Las variables de shell $EPOCHSECONDSy $EPOCHREALTIMEno son POSIX

Los comandos del sistema disponibles en los sistemas operativos modernos tipo Unix, y que también están especificados por POSIX, pueden tener menos opciones o menos variables de entorno relevantes disponibles bajo POSIX. La mayoría (como ls) son programas independientes en los directorios /bin, /usr/bin, /sbino /usr/sbin(en Linux, generalmente proporcionados por GNU coreutils o BusyBox ) en lugar de funciones integradas de Bash.

Debido a estas y otras diferencias, los scripts de shell Bash modernos (versión 5) rara vez se pueden ejecutar "tal cual" con los intérpretes de shell Bourne o Korn (versión anterior). La creación de scripts pensando en la portabilidad es cada vez menos común a medida que GNU/Linux se generaliza.

El código que tiene sintaxis válida en Bash pero no está especificado por POSIX se denomina "bashismo". El programa checkbashismsse puede utilizar para asegurar que un script se pueda ejecutar en Debian Linux sin errores de portabilidad. ^{[ 18 ]}shellcheck El linter estático de Vidar Holen , escrito en Haskell , puede analizar la sintaxis de un script para comprobar su compatibilidad con bash, dash, ksh y Bourne sh. ^{[ 19 ]}

Los requisitos de sintaxis para cada shell son ligeramente diferentes. Por ejemplo, la política de Debian permite algunas extensiones en sus scripts (como en el shell dash ), ^{[ 20 ]} mientras que un script destinado a admitir shells Bourne pre-POSIX, como configure de autoconf , está aún más limitado en las características que puede usar. ^{[ 21 ]}

Cuando xtrace está habilitado, se imprime contenido de depuración simple en la terminal. Se puede habilitar con o , y deshabilitar con , o . Estas opciones también se aceptan en la línea de comandos y en hash-bangs: , etc.set -o xtraceset -xset +o xtraceset +xset -#!/bin/bash -x

$ bash -x $ echo $(( 2 + 2 )) + echo 4 4 $ set -- 1 2 3 $ printf '<%s>\n' " $@ " + printf '<%s>\n' 1 2 3 <1> <2> <3>

La configuración del shell xtrace está especificada por POSIX. Véase también § Depuración . 

La opción verbose imprime las cadenas en la terminal a medida que se leen, y antes de que se realicen expansiones. Se usa raramente. ^{[ q ]}

Los comentarios pueden ser una forma valiosa de aclarar información o explicar un script o archivo fuente a otra persona que tal vez no esté familiarizada con las intenciones o el contexto del programador.

Los comentarios estándar en Bash se indican con el carácter de almohadilla: # . Cualquier texto a la derecha de la almohadilla hasta el final de la línea será ignorado. Se permiten comentarios en línea, pero los comentarios con almohadilla no se imprimirán durante la depuración. Véase también: §  xtrace .

Los comentarios denotados con el carácter de dos puntos, : , se originaron en el intérprete de comandos Thompson . Cualquier argumento a la derecha de los dos puntos : builtin se ignora. No se permiten comentarios en línea, pero los comentarios con dos puntos se imprimirán durante la depuración y cualquier parámetro se habrá expandido. ^{[ r ]}

$ # Definir foo $ foo = bar # Un comentario hash en línea aparece en la misma línea que un comando $ set -x $ # Un comentario normal (sin salida) $ : " ${ foo } " + : bar

Cuando bash ejecuta comandos, se generan códigos de estado de salida$? , también llamados "códigos de retorno", que pueden ofrecer información sobre cómo finalizó la ejecución de un programa. El valor del código de salida capturado más recientemente se almacena en el parámetro de shell 'signo de interrogación:' . En contextos no aritméticos (es decir, la mayoría de las veces), el valor numérico o booleano de "verdadero" es cero (0) y el de "falso" es uno (1).

Cuando se ejecuta un comando del sistema, el significado previsto de su estado de salida se puede encontrar con mayor frecuencia en su página de manual; por lo general, un cero indica éxito y un estado de salida distinto de cero indica algún tipo de condición de fallo o éxito parcial. pinges un comando bien conocido con tres códigos de salida significativos: 0, 1 y 2.

En Bash, dentro de los contextos aritméticos, los valores numéricos de verdad se invierten: "verdadero" es uno y "falso" es cero. Un contexto aritmético generalmente se identifica mediante la sintaxis ((...))o $((...)). Si una instrucción aritmética se evalúa como cero, se considera "verdadera" y el código de salida es uno. Si la instrucción se evalúa como cualquier número distinto de cero, la instrucción aritmética es "falsa" y el código de salida es cero.

No todos los comandos de Linux/UNIX proporcionan códigos de salida significativos más allá de cero y uno, y no existe un sistema estándar para la definición de códigos de salida en Linux.

$ true ; echo " $? " # El código de salida significa "verdadero" 0 $ false ; echo " $? " ; echo # El código de salida significa "falso" 1 $ $ bash -c 'exit 99' ; printf 'código de salida: %d\n' " $? " código de salida: 99 $ (( 1 - 1 )) ; printf '%d\n' " $? " # Este código de salida significa "verdadero" 1 $ (( 1 + 1 )) ; printf '%d\n' " $? " # ...y este código de salida significa "falso" 0

El intérprete de comandos Bash tiene dos modos de ejecución: por lotes (asíncrono) y concurrente (síncrono). Para ejecutar comandos en modo por lotes (es decir, en secuencia), deben estar separados por el carácter ; o en líneas separadas:

$ comando1 ; comando2 $ comando3 

En este ejemplo, cuando el comando1 finaliza, se ejecuta el comando2 , y cuando el comando2 se completa, se ejecuta el comando3 . La ejecución en segundo plano del comando1 puede ocurrir usando el símbolo & al final de un comando de ejecución; el proceso se ejecutará en segundo plano, devolviendo inmediatamente el control al intérprete de comandos y permitiendo la ejecución continua de otros comandos.

$ comando1 y

O para tener una ejecución concurrente de command1 y command2 , deben ejecutarse en el intérprete de comandos Bash de la siguiente manera:

$ comando1 y comando2 

En este caso, el comando1 se ejecuta en segundo plano, y el símbolo & devuelve el control inmediato al intérprete de comandos que ejecuta el comando2 en primer plano. Un proceso puede detenerse y el control puede devolverse a bash escribiendo + mientras el proceso se está ejecutando en primer plano. ^{[ s ]} Se puede obtener una lista de todos los procesos, tanto en segundo plano como detenidos, ejecutando jobs :Ctrlz

$ trabajos [1]- Ejecutando comando1 y

En la salida, el número entre corchetes se refiere al ID del trabajo. El signo más indica el proceso predeterminado para bg y fg . Los textos "Running" y "Stopped" se refieren al estado del proceso . La última cadena es el comando que inició el proceso.

El estado de un proceso se puede cambiar mediante varios comandos. El comando `fg` trae un proceso al primer plano, mientras que `bg` ejecuta un proceso detenido en segundo plano. Tanto `bg` como `fg` pueden aceptar un ID de trabajo como primer argumento para especificar el proceso sobre el que actuar. Si no se especifica, utilizan el proceso predeterminado, identificado por un signo más en la salida de `jobs` . El comando `kill` se puede usar para finalizar un proceso prematuramente, enviándole una señal . El ID de trabajo debe especificarse después de un signo de porcentaje.

$ dormir 100 & [1] 4904 $ matar %1 $ trabajos [1]+ Terminados dormir 100

El control de trabajos, también conocido como "modo monitor", está habilitado de forma predeterminada en los shells interactivos y se puede deshabilitar con .set+m

La señalización es un medio de comunicación entre procesos (IPC). En ocasiones, un proceso de línea de comandos puede parecer que se congela a mitad de su ejecución. En estos casos, puede ser necesario identificar qué proceso está bloqueado y finalizarlo manualmente.

En una terminal interactiva, normalmente basta con pulsar para finalizar el proceso en primer plano y devolver el control al indicador de usuario, o pulsar para suspenderlo. En ocasiones, suspender un proceso tendrá éxito cuando los intentos de cancelarlo parezcan no responder. En otros casos, puede ser necesario usar el programa kill para enviar una señal IPC. En este ejemplo, usamos el comando kill desde una segunda pantalla de terminal para finalizar el proceso con PID 4331. Ctrl-c Ctrl-z

$ tty # Terminal uno /dev/pts/0 $ whoami liveuser $ sleep 1000 # El comando se queda colgado

$ tty # Terminal dos /dev/pts/1 $ whoami liveuser $ ps aux | grep -e sleep -e PID USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND liveuser 4331 0.0 0.0 230336 2312 pts/1 S+ 11:19 0:00 sleep 1000 liveuser 4333 0.0 0.0 231248 2516 pts/0 S+ 11:19 0:00 grep --color=auto -e sleep -e PID $ kill 4331 $ ps aux | grep -e sleep -e PID # El proceso sleep ha terminado USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND liveuser 4333 0.0 0.0 231248 2516 pts/0 S+ 11:19 0:00 grep --color=auto -e sleep -e PID

$ tty # Terminal una vez más /dev/pts/0 $ whoami liveuser $ sleep 1000 Terminado

En los sistemas operativos tipo Unix, un usuario puede indicarle al núcleo que envíe una señal a un proceso de su propiedad. Un usuario normal no puede enviar una señal a un proceso con privilegios. Las señales se pueden enviar a un proceso mediante el comando interno `kill` o mediante el binario del sistema del mismo nombre.

$ whoami liveuser $ ps aux | awk '$2 ~ /\<1\>/' # Veamos información sobre el proceso del kernel, proceso 1. root 1 0.0 0.2 37140 20440 ? Ss 04:44 0:18 /usr/lib/systemd/systemd --switched-root --system --deserialize=53 rhgb $ kill -s SIGKILL 1 bash: kill: (1) - Operación no permitida $ type -a kill kill es un comando integrado del shell kill es /usr/bin/kill $ /usr/bin/kill -s SIGKILL 1 kill: error al enviar la señal a 1: Operación no permitida

Las señales más utilizadas se pueden ver con kill -L | head -n 4. Cada señal IPC está asociada a un número de señal, pero los códigos de salida y los códigos de señal son dos cosas distintas. Si bien enviar a un proceso una señal IPC de 9 (una señal "KILL") casi con certeza terminará el proceso de inmediato, lo más probable es que no resulte en que el proceso devuelva un código de salida de 9.

Por defecto en Bash, el comando kill integrado envía una señal TERM ("terminar"). Es común que las utilidades de línea de comandos respondan a una SIGTERM cerrándose y saliendo limpiamente. (TERM y SIGTERM son lo mismo, el prefijo SIG- en todos los nombres de señales se puede omitir). La secuencia de teclas Ctrl-c en Bash envía una señal SIGINT, señal de interrupción, al proceso en primer plano. La secuencia de teclas Ctrl-z envía la señal SIGSTOP, señal de parada. ^{[ t ]} Cuando un proceso recibe una SIGKILL, el proceso termina inmediatamente y de forma desordenada. Se recomienda usar SIGKILL solo como último recurso. ^{[ 23 ]} La señal SIGKILL no se puede bloquear ni manejar.

Los procesos pueden "capturar" y "manejar" las señales IPC que reciben. Un usuario puede usar el comando interno kill para "enviar" una señal IPC a otro proceso. Ese proceso objetivo puede establecer un mecanismo, un plan previo, sobre cómo responder cuando reciba o "capture" una señal en particular. La forma en que un programa objetivo responde se denomina cómo el programa "maneja" la recepción de la señal. En las páginas man se puede ver cómo algunos comandos del sistema imprimen cierta información en la terminal cuando reciben una señal SIGHUP: por ejemplo, el ddcomando. ^{[ 24 ]}

Cuando bash es interactivo, en ausencia de cualquier interrupción, ignora SIGTERM (para que no termine un shell interactivo) y captura y maneja SIGINT (para que el comando interno wait sea interrumpible). Cuando bash recibe SIGINT , sale de cualquier bucle en ejecución. En todos los casos, bash ignora SIGQUIT . Si el control de trabajos está activo, bash ignora SIGTTIN , SIGTTOU y SIGTSTP . ^{[ 25 ]}kill0

Por defecto, los scripts de shell Bash reciben y responden a todas y cada una de las señales IPC que se les envían; sin embargo, los scripts Bash pueden utilizar la función integrada trap para capturar y manejar señales. ^{[ 26 ]}

$ cat ./trap-example.sh # ! /usr/bin/env bash trap umask EXIT echo bar exit 0 $ chmod 0700 trap-example.sh $ ./trap-example.sh bar 0077

Existen algunas señales que solo están disponibles dentro de Bash como extensiones de GNU: ERR , EXIT , RETURN y DEBUG . Estas señales pueden ser útiles para la depuración y solo pueden ser enviadas y manejadas por comandos integrados del shell. Véase también § Depuración . 

Hay muchas implementaciones diferentes de echo . Algunas tienen la opción y otras no. ^{[ u ]} La lista de opciones no es uniforme en todas las implementaciones, aunque tanto echo como printf están especificados por POSIX. Si un programador desea conocer el valor preciso de una cadena contenida en una variable, la forma más consistente de hacerlo es usar printf .-e

Para cualquier cadena que contenga cualquier carácter (¿aparte de nulo?), incluidos los dígitos, el especificador de formato es %s .

$ foo = abc bar = 123 $ printf '<%s>\n' " ${ foo } " " ${ bar } " <abc> <123>

Para dígitos únicamente, el especificador de formato es %d .

$ printf '<%d>\n' " ${ foo } " " ${ bar } " bash: printf: abc: número no válido <0> <123>

Con printf , nunca se incluye un salto de línea en la salida a menos que el programador lo incluya en la cadena de formato. En el ejemplo siguiente, donde se ha omitido un salto de línea en la cadena de formato, el valor de PS1 se imprime en la misma línea que la salida del comando anterior.

$ printf '<%s>' " ${ foo } " " ${ bar } " <abc><123>$

Otro método muy consistente es usar . La salida de se puede reutilizar como entrada. Sin embargo, no todas las variables y parámetros se pueden imprimir usando , por ejemplo, los valores de los Parámetros especiales. El hashtag de Parámetro especial, , informa cuántos Parámetros posicionales están definidos actualmente.declare-pdeclare-pdeclare-p"$#"

$ declare -p foo bar declare -- foo="abc" declare -- bar="123" $ declare -p " $# " bash: declare: 0: no encontrado

Para ver una cadena completa de entrada en una consola interactiva...

$ declarar -p #

...el hashtag sería interpretado por Bash como un comentario en línea. Con el comentario y todo el texto a su derecha eliminados, el comando que Bash ejecutaría sería . Este comando, según , "mostraría los valores y atributos de cada NOMBRE", es decir, cada variable, y, "si no se dan NOMBRES, mostraría los valores y atributos y valores de todas las variables", lo que puede ser más de 100 líneas de salida.declare-phelp declare

Por otro lado, printf no puede mostrar los atributos de las variables. Véase también § Depuración . 

$ readonly foo $ declare -p foo declare -r foo="abc" $ printf '<%s>' " ${ foo } " <abc>

Entorno(s) de ejecución configurable(s): ^{[ v ]}

• Archivos de inicio de sesión y de shell como ~/.bashrcy ~/.profile(es decir, archivos de puntos );
• Configuración ( set built-in ) y opciones de shell ( shopt built-in ) que alteran el comportamiento del shell;

Archivos de inicio de sesión y de shell (también conocidos como "archivos ocultos")

Cuando Bash se inicia, ejecuta los comandos en una variedad de archivos de punto . ^{[ 15 ]} A diferencia de los scripts de shell de Bash, los archivos de punto normalmente no tienen habilitado el permiso de ejecución ni una directiva de intérprete como #!/bin/bash.

• Ejemplo de inicio de Bash compatible con versiones anteriores

El siguiente ejemplo ~/.bash_profilees compatible con el shell Bourne y proporciona una semántica similar a la de csh para ~/.bashrcy ~/.bash_login. La es una evaluación de cortocircuito que comprueba si el nombre del archivo existe y es legible, omitiendo la parte posterior a si no lo es.[ -r filename ] && cmd&&

[ -r ~/.profile ] && ~/.profile # Configurar el entorno, una sola vez, solo sintaxis Bourne-sh if [ -n " ​​$PS1 " ] ; then # ¿Somos interactivos? [ -r ~/.bashrc ] && ~/.bashrc # Configuración de tty/prompt/función para shells interactivos [ -r ~/.bash_login ] && ~/.bash_login # Cualquier tarea de inicio de sesión solo para el shell de inicio de sesión fi # Fin del bloque "if"

• Problemas del sistema operativo al iniciar Bash

Algunas versiones de Unix y Linux contienen scripts de inicio del sistema Bash, generalmente en el /etcdirectorio. Bash ejecuta estos archivos como parte de su inicialización estándar, pero otros archivos de inicio pueden leerlos en un orden diferente a la secuencia de inicio de Bash documentada. El contenido predeterminado de los archivos del usuario root también puede tener problemas, así como los archivos esqueleto que el sistema proporciona a las nuevas cuentas de usuario al configurarse. Los scripts de inicio que inician el sistema de ventanas X también pueden hacer cosas inesperadas con los scripts de inicio de Bash del usuario en un intento de configurar las variables de entorno del usuario antes de iniciar el gestor de ventanas . Estos problemas a menudo se pueden solucionar usando un archivo ~/.xsessiono ~/.xprofilepara leer el ~/.profile— que proporciona las variables de entorno que necesitan las ventanas de shell Bash generadas desde el gestor de ventanas, como xterm o Gnome Terminal .

Flujos estándar : STDIN, STDOUT y STDERR

Los alias permiten sustituir una cadena por una palabra que se encuentra en una posición en la entrada donde puede ser la primera palabra de un comando simple. Los alias tienen nombres y valores correspondientes que se establecen y eliminan mediante los comandos integrados alias y unalias. ^{[ w ]}

• function
  • Las declaraciones de funciones de Bash que incluyen esta palabra clave en particular no son compatibles con los scripts Bourne/Korn/POSIX; sin embargo, Bash sí acepta la sintaxis de declaración de funciones utilizada por los shells compatibles con Bourne, Korn y POSIX.

Las funciones de shell son una forma de agrupar comandos para su posterior ejecución utilizando un único nombre para el grupo. Se ejecutan como un comando simple "normal". Cuando se utiliza el nombre de una función de shell como nombre de comando simple, el shell ejecuta la lista de comandos asociados con ese nombre de función. Las funciones de shell se ejecutan en el contexto actual del shell; no se crea ningún proceso nuevo para interpretarlas. ^{[ x ]}

• Varios comandos integrados:
  • Funciones integradas especiales POSIX: ^{[ y ]}
    • cd , pwd , etc.
  • conjunto ^{[ z ]}
    • Xtrace: [ | ]. El principal método de depuración del intérprete de comandos. Tanto xtrace como verbose se pueden desactivar simultáneamente con el comando .set-xset-oxtraceset-
    • Detallado: [ | ]. Imprime un comando en la terminal mientras Bash lo lee. Bash lee las construcciones de una sola vez, como los comandos compuestos que incluyen bloques if-fi y case-esac. Si se incluye un dentro de un comando compuesto, entonces "detallado" se habilitará la próxima vez que Bash lea código como entrada, es decir, después del final de la construcción que se está ejecutando actualmente. ^{[ 27 ]}set-vset-overboseset-v
    • Tanto xtrace como verbose se pueden desactivar al mismo tiempo con el comando .set-
  • tienda ^{[ 28 ]}
    • expand-aliases: Activado por defecto en shells interactivos. Algunos desarrolladores desaconsejan su uso en scripts.

Cuando el intérprete de comandos busca comandos externos, se basa en la variable de entorno Bourne $PATH. Esta variable $PATHcontiene una lista de directorios separados por dos puntos :. Comenzando por el directorio más a la izquierda y seleccionando directorios de izquierda a derecha, se busca en cada directorio hasta encontrar una coincidencia. En Linux, para que un usuario pueda localizar comandos adicionales, es práctica común que los administradores de distribución y los desarrolladores de paquetes modifiquen el valor de la variable del usuario final $PATHincluyendo archivos fuente en /etc/profile.dy otras ubicaciones.

Al buscar el comando, chmodpor ejemplo, después de considerar los comandos internos y no encontrar nada, Bash buscará en los directorios en $PATHy seleccionará la ruta absoluta del primer ejecutable encontrado que tenga un nombre base que coincida con la cadena de búsqueda. ^{[ 12 ]}

Si hay más de un comando echodisponible en los directorios listados en $PATH, durante el proceso de análisis y ejecución de una línea de comandos, por defecto solo se seleccionará el primer comando encontrado. $PATHLas búsquedas son lentas. El intérprete de comandos acelera el proceso de ejecución de la línea de comandos al recordar las ubicaciones de los comandos en una tabla hash. Para realizar una $PATHbúsqueda completa sin ninguna interferencia de la tabla hash, elimine la tabla actual con y busque todo tipo de comandos con .hash-rtype-a

$ # Forzar una búsqueda de ruta completa $ PATH = ${ PATH } : ${ HOME } $ printf 'echo script_file: "$@"\n' > ./echo $ chmod 0700 ./echo $ hash -r ; type -a echo echo es un comando integrado del shell echo es /usr/bin/echo echo es /home/liveuser/echo

Para ejecutar una línea de comandos con un comando que se encuentre más adelante en la $PATHcadena, puede especificar una ruta absoluta o puede establecer la resolución de la ruta en relación con el directorio de trabajo actual.

$ /home/liveuser/echo foo script_file: foo $ ./echo bar script_file: bar

Por motivos de seguridad, es recomendable asegurarse de que los directorios incluidos en PATH no sean modificables por todos los usuarios, o que solo sean modificables por el usuario root y los usuarios de confianza.

• Posición del comando: después de las expansiones, la primera palabra del texto completo de la línea de comandos.
• La búsqueda del nombre del comando se realiza en el siguiente orden:
  • Comandos internos del intérprete de comandos :
    • Alias ​​de shell ,
    • Palabras reservadas de Shell,
    • Funciones de shell y
    • Comandos integrados del shell ;
  • Comandos externos al intérprete de comandos, utilizando la variable de entorno PATH:
    • Separe los programas de estilo UNIX como ls o ln y
    • Scripts de shell , que son archivos que contienen comandos ejecutables. ^{[ aa ]}
• La cadena resultante se ejecuta como un comando.

Subcapas : (...);

Sin embargo, al utilizar una tubería, pueden realizar múltiples ciclos de computación al mismo tiempo, aumentando sustancialmente su velocidad. En una unidad de control con tubería, diferentes instrucciones pasan simultáneamente por el proceso, pero en diferentes puntos. Mientras se obtiene una instrucción, se decodifica una segunda, y así sucesivamente. Tuberías al estilo Unix : |.

• Y ( &&)
• O ( ||)
• NO ( !)

Bash proporciona separadores de comandos de "ejecución condicional" que hacen que la ejecución de un comando dependa del código de salida establecido por un comando precedente. Por ejemplo:

$ cd " $SOMEWHERE " && ./do_something || echo "Ocurrió un error" > & 2

Donde ./do_somethingsolo se ejecuta si el comando cd (cambiar directorio) fue "exitoso" (devolvió un estado de salida de cero) y el comando echo solo se ejecutaría si cd o el comando devuelven un "error" (estado de salida distinto de cero)../do_something

ITERACIÓN: A veces, los programas se repiten indefinidamente o hasta que se alcanza un resultado específico. Cada ejecución de las instrucciones es una "iteración". ^{[ 29 ]}

• mientras , hasta y seleccionar comandos compuestos de bucle;
• Comandos compuestos de bucle for con enumeración de listas y estilo aritmético C ; y
• comandos de control de flujo continue , break , return y exit ;

compuesto: algo formado por la unión de elementos o partes. ^{[ 30 ]}

Bash también admite formas de evaluación de comandos condicionales. ^{[ ab ]}if...ficase...esac

Comandos integrados para probar atributos de archivo, comparar valores de cadena y enteros, etc.:

• Comando de prueba tradicional ,
• Prueba tradicional de un solo soporte: [,
• Prueba moderna de doble soporte: , que incluye características avanzadas: [[...]]
  • Expresiones regulares extendidas y coincidencia de extglob
  • Comparaciones lexicográficas con <y >;
• ((...))evaluación y prueba numérica; esto incluye casi todos los operadores del lenguaje "C" para comparación aritmética y numérica;

Para todos los comandos, el estado de salida se almacena en la variable especial $?.

Bash 3.0 admite la coincidencia de expresiones regulares dentro del proceso utilizando una sintaxis que recuerda a Perl . ^{[ 32 ]} La coincidencia de expresiones regulares se limita a las cadenas en el lado derecho del =~operador en la [[..]]construcción de prueba extendida. ^{[ ac ]}

[[${line}=~[[:space:]]*(a)?b]]significa que los valores de línea como 'aab', 'aaaaaab', 'xaby' y 'ab' coincidirán, al igual que una línea que contenga una 'b' en cualquier parte de su valor.

Un coproceso es un comando de shell precedido por la palabra reservada `coproc`. Un coproceso se ejecuta de forma asíncrona en un subshell, como si el comando hubiera terminado con el operador de control `&`, estableciéndose una tubería bidireccional entre el shell ejecutor y el coproceso. ^{[ ad ]}

Dividir en palabras (es decir, dividir palabras )

En caso de duda, ¡cita! ^{[ 33 ]}

Bash tiene ciertas reglas de citación : usos de

• comillas simples'...'
• comillas dobles"..."
• barras invertidas \y
• Citas ANSI-C $'...'.

Véase también §  Localidades ,$"..."

Véase también las comillas invertidas `...`: §  Sintaxis obsoleta .

Compatibilidad con Unicode y con el uso de comillas ANSI-C.echo-e

$ echo kernel { ,-headers } kernel kernel-headers

La expansión de llaves, también llamada alternancia, es una característica copiada del intérprete de comandos C. Genera un conjunto de combinaciones alternativas. ^{[ ae ]} Los resultados generados no tienen por qué existir como archivos. Los resultados de cada cadena expandida no están ordenados y se conserva el orden de izquierda a derecha:

$ echo a { p,c,d,b } e ape ace ade abe $ echo { a,b,c }{ d,e,f } ad ae af bd be bf cd ce cf

Los usuarios no deben usar expansiones de llaves en scripts de shell portátiles, porque el intérprete de comandos Bourne no produce la misma salida.

$ # shell bash $ /bin/bash -c 'echo a{p,c,d,b}e' ape ace ade abe $ # Un shell tradicional no produce la misma salida $ /bin/sh -c 'echo a{p,c,d,b}e' a{p,c,d,b}e

Cuando la expansión de llaves se combina con comodines, primero se expanden las llaves y luego se sustituyen los comodines resultantes de forma normal. Por lo tanto, se podría obtener una lista de imágenes JPEG y PNG en el directorio actual utilizando:

ls *. { jpg,jpeg,png } # se expande a *.jpg *.jpeg *.png – después de lo cual, # se procesan los comodines echo *. { png,jp { e, } g } # echo solo muestra las expansiones – # y son posibles las llaves dentro de las llaves.

Además de la alternancia, la expansión de llaves se puede usar para rangos secuenciales entre dos enteros o caracteres separados por puntos dobles. Las versiones más recientes de Bash permiten usar un tercer entero para especificar el incremento.

$ echo { 1 ..10 } 1 2 3 4 5 6 7 8 9 10 $ echo { 01 ..10 } 01 02 03 04 05 06 07 08 09 10 $ echo file { 1 ..4 } .txt file1.txt file2.txt file3.txt file4.txt $ echo { a..e } abcde $ echo { 1 ..10..3 } 1 4 7 10 $ echo { a..j..3 } adgj

Cuando la expansión de llaves se combina con la expansión de variables (también conocida como expansión de parámetros y sustitución de parámetros ), la expansión de variables se realiza después de la expansión de llaves, lo que en algunos casos puede requerir el uso de la función integrada eval , por lo tanto:

$ inicio = 1 ; fin = 10 $ echo { $inicio .. $fin } # falla la expansión debido al orden de evaluación {1..10} $ eval echo { $inicio .. $fin } # ocurre la expansión de la variable y luego se evalúa la cadena resultante 1 2 3 4 5 6 7 8 9 10

• Tipo
• Parámetros de la carcasa
• Variables ambientales
• Variables de usuario
• Alcance
• Matrices
  • Matrices indexadas : el tamaño es ilimitado.
  • Matrices asociativas : vía . En febrero de 2009, Bash 4.0 introdujo soporte para matrices asociativas . Los índices de las matrices asociativas son cadenas, de manera similar a AWK o Tcl . Se pueden usar para emular matrices multidimensionales. ^{[ af ]}declare-A
• Expansión de parámetros

  Sintaxis de expansión que pueden realizar algunas tareas más rápidamente que las utilidades externas, incluyendo, entre otras:

  • Sustitución de patrones
    • ${foo//x/y}para ,sed 's/x/y/g'
  • Eliminar patrón de prefijo o sufijo coincidente
    • ${bar##[a-zA-Z0-9]*}para cut -c8-,
  • Enumerar las claves de la matriz
    • ${!array[@]}, y
  • Mostrar error si es nulo o no está configurado.
    • ${var:?error message},

Expansión de ruta de acceso, es decir, comodines y coincidencia de patrones al estilo shell usando *, ?, [...]. ^{[ ag ]}

Traducción específica del idioma mediante $"..."sintaxis de comillas. ^{[ ah ]}

Sustitución de comandos : ,$(...)

Sustitución de procesos , o , cuando un sistema lo admite:<()>()

Bash admite la sustitución de procesos mediante la sintaxis `and` , que sustituye la salida (o la entrada) de un comando donde normalmente se usa un nombre de archivo. (Esto se implementa a través de tuberías sin nombre `/proc/fd/` en sistemas que lo admiten, o mediante tuberías temporales con nombre cuando sea necesario).<(command)>(command)

Expansión aritmética, ((...))o , incluyendo$((...))

• Aritmética de enteros en cualquier base de dos a sesenta y cuatro, aunque
• La aritmética de punto flotante no está disponible dentro del propio shell (para esta funcionalidad, consulte las versiones actuales de bc y awk , entre otras).

Bash puede realizar cálculos con números enteros ("evaluación aritmética") sin necesidad de crear procesos externos. Para ello, utiliza el ((...))comando y la sintaxis de variables.$((...))

Se realizan redirecciones de los flujos de datos de entrada estándar, salida estándar y error estándar , incluyendo:

• Escritura de archivos >, y adición >>,
• Aquí documentos , <<,
• Aquí cadenas, <<<, que permiten que los parámetros se utilicen como entrada, y
• Un operador de redirección, >|que puede forzar la sobrescritura de un archivo cuando la configuración noclobber de un shell está habilitada;

Su sintaxis simplifica la redirección de E/S . Por ejemplo, puede redirigir la salida estándar (stdout) y el error estándar (stderr) al mismo tiempo usando el &>operador. Esto es más sencillo de escribir que el equivalente de Bourne shell ' '. Bash admite documentos aquí . Desde la versión 2.05b, Bash puede redirigir la entrada estándar (stdin) desde una "cadena aquí" usando el operador.command>file2>&1<<<

• (A) Los comentarios se ignoran, desde un #(hash) sin comillas hasta el final de la misma línea; ^{[ 34 ] [ 35 ]}

• (B) Los comandos se analizan línea por línea:
  • Las estructuras de control se respetan y
  • Las secuencias de escape con barra invertida \también se respetan al final de las líneas;
• (C) Dividir en palabras (es decir, división de palabras ) según las reglas de citación ,
  • Incluyendo la citación ANSI-C $'...';
• (D) Se realizan siete tipos de expansiones en el siguiente orden sobre la cadena resultante:
  1. (Tipo 1) Expansión de refuerzo kernel{-headers},
  2. (Tipo 2) Expansión de tilde ~,
  3. De izquierda a derecha:
     • (Tipo 3) Expansión de parámetros y variables$foo o , incluyendo${bar}
     • (Tipo 4) Sustitución de comandos : ,$(...)
     • (Tipo 5) Sustitución de procesos , o , cuando un sistema lo admite:<()>()
     • (Tipo 6) Expansión aritmética, ((...))o , incluyendo $((...))
       • Aritmética de enteros en cualquier base de dos a sesenta y cuatro, aunque
       • La aritmética de punto flotante no está disponible dentro del propio shell. ^{[ ai ]}
  4. División de palabras (de nuevo),
  5. (Tipo 7) Expansión de ruta de acceso, es decir, comodín y coincidencia de patrones al estilo shell usando *, ?, , ^{[ ag ]}[...]
  6. Eliminación de la cotización ;
• (E) Se realizan redirecciones de los flujos de datos de entrada estándar, salida estándar y error estándar , incluyendo:
  • Escritura de archivos >, y adición >>,
  • Aquí documentos , <<,
  • Aquí cadenas, <<<, que permiten que los parámetros se utilicen como entrada, y
  • Un operador de redirección, >|que puede forzar la sobrescritura de un archivo cuando noclobberla configuración de un shell está habilitada;
• (F) La búsqueda del nombre del comando se realiza en el siguiente orden:
  1. Comandos internos del intérprete de comandos :
     • Alias ​​de shell ,
     • Palabras reservadas de Shell,
     • Funciones de shell y
     • Comandos integrados del shell ;
  2. Comandos externos al intérprete de comandos:
     • Separe los programas de estilo UNIX como lso ln, y
     • Scripts de shell , que son archivos que contienen comandos ejecutables. ^{[ aa ]}
• (G) La cadena resultante se ejecuta como un comando.

Historial de comandos de tamaño ilimitado . Esta función solo está disponible en modo interactivo. ^{[ aj ]}

La función de pila de directorios ( pushdypopd funciones integradas) solo está disponible en modo interactivo.

También conocido como "autocompletado de tabulación" o " autocompletado de línea de comandos ", cuando un usuario presiona la tecla Tab dentro de una consola de comandos interactiva, Bash utiliza automáticamente cualquier script de autocompletado disponible para sugerir nombres de programas, nombres de archivos y nombres de variables parcialmente escritos. ^{[ ak ]} El sistema de autocompletado de línea de comandos de Bash es muy flexible y personalizable, y a menudo viene con funciones que completan argumentos y nombres de archivos para programas y tareas específicas.Tab ↹

Bash admite la finalización programable a través de los comandos integrados complete, compopt, y compgen. ^{[ 36 ]} Esta función está disponible desde la versión beta de 2.04 lanzada en 2000.

Estos comandos permiten la especificación de autocompletado compleja e inteligente para comandos (es decir, programas instalados), funciones, variables y nombres de archivo. ^{[ 37 ]}

Los comandos completey compoptespecifican cómo se mostrarán los argumentos de algunos comandos u opciones disponibles en la entrada de readline. A partir de la versión 5.1, la finalización del comando o la opción se activa normalmente mediante la pulsación de tecla después de escribir su nombre. ^{[ 37 ]} Esta función solo está disponible en modo interactivo. Tab

Mensajes configurables . Esta función solo está disponible en modo interactivo.

El Proyecto GNU proporciona un manual de usuario/usr/share/doc/bash para Bash. A veces se considera un documento más fácil de usar que la página man. "También puede encontrar información sobre Bash... consultando los directorios , /usr/local/share/doc/bash, o similares en su sistema." ^{[ 38 ]} En sistemas GNU/Linux, si el programa info está disponible, la versión del Manual GNU relevante para su instalación también debería estar disponible en . ^{[ 39 ] [ 40 ]}info bash

El manual técnico más reciente, o «página man» , pretende ser el documento técnico explicativo autorizado para comprender cómo funciona bash. En sistemas GNU/Linux, la versión relevante para su instalación suele estar disponible a través del programa man en . ^{[ 39 ] [ 25 ] [ 41 ]}manbash

Con las versiones recientes de Bash, se puede encontrar información sobre los comandos integrados del shell ejecutando help, o en un indicador de terminal donde esté instalado bash.help[nameofbuiltin]man builtins

El comando printf se puede invocar a través de env para asegurar que ejecute el programa encontrado a través de la ruta de búsqueda de su shell, y no un alias de shell o una función integrada: . ^{[ 42 ]}envprintf--help

Con el fin de permitir la interoperabilidad entre diferentes programas de shell que se ejecutan en distintos sistemas operativos, la "Especificación POSIX" ^{[ 8 ]} influye en cómo se escriben los shells modernos tipo UNIX. Bash "está diseñado para ser una implementación conforme a la parte "Shell y utilidades" de la especificación IEEE POSIX (Estándar IEEE 1003.1)" ^{[ 43 ]} . La publicación más reciente del estándar (2024) está disponible en línea.

El estándar POSIX, o IEEE Std 1003.1, que sirve de base para bash, resulta especialmente informativo.

"El mantenedor del proyecto también tiene una página de Bash que incluye preguntas frecuentes", ^{[ 38 ] [ 44 ] [ 45 ]} estas preguntas frecuentes están vigentes a partir de la versión 5.1 de bash y ya no se actualizan.

Se pueden encontrar vías informales de apoyo a través de IRC en libera.chat, en el canal #bash, y también hay listas de correo disponibles. ^{[ 7 ]}

Ejecutar scripts de shell como usuario root ha sido ampliamente criticado durante años por considerarse una mala práctica de seguridad. Una razón común es que, al ejecutar un script como root, los efectos negativos de cualquier error en el script se magnifican debido a los privilegios elevados de root.

Un ejemplo común: un script contiene el comando, pero la variable queda sin definir. En Linux, si el script fuera ejecutado por un usuario normal, el intérprete de comandos intentaría ejecutar el comando como tal, y este fallaría. Sin embargo, si el script fuera ejecutado por el usuario root, probablemente el comando se ejecutaría correctamente y el sistema de archivos se borraría.rm-rf${dir}/$dirrm -rf /

Se recomienda utilizar sudo para cada comando individualmente.

Los scripts CGI son una fuente importante de vulnerabilidad. ^{[ 46 ] [ 47 ] [ 48 ]}

"El comando eval es extremadamente potente y extremadamente fácil de usar indebidamente." ^{[ 49 ]}

" La validación de datos de entrada es el proceso de asegurar que los datos hayan sido sometidos a un proceso de limpieza para confirmar que tienen calidad, es decir, que son correctos y útiles."

La validación de entrada se realiza para garantizar que solo los datos con el formato correcto ingresen al flujo de trabajo de un sistema de información, evitando que los datos con formato incorrecto persistan en la base de datos y provoquen fallos en diversos componentes posteriores. La validación de entrada debe realizarse lo antes posible en el flujo de datos, preferiblemente tan pronto como se reciban los datos de la parte externa. ^{[ 50 ]}

En septiembre de 2014, se descubrió una vulnerabilidad de seguridad en el programa. Se la denominó " Shellshock ". Su divulgación pública provocó rápidamente una serie de ataques en Internet . ^{[ 51 ] [ 52 ] [ 53 ]}

La explotación de esta vulnerabilidad podría permitir la ejecución de código arbitrario en scripts CGI ejecutables por ciertas versiones de Bash. El error afectaba la forma en que Bash pasaba definiciones de funciones a subshells a través de variables de entorno . ^{[ 54 ]} El error había estado presente en el código fuente desde agosto de 1989 (versión 1.03) ^{[ 55 ]} y fue corregido en septiembre de 2014 (versión 4.3).

Las correcciones para solucionar los errores se publicaron poco después de su detección. Se recomienda encarecidamente actualizar a la versión más reciente.

Se le asignaron los identificadores de vulnerabilidades comunes CVE- 2014-6271 , CVE- 2014-6277 y CVE- 2014-7169 , entre otros. Según las métricas CVSS 2.x y 3.x, el fallo se considera de gravedad "alta" y "crítica", respectivamente.

• Características del shell especificadas por POSIX :
  • Expansión de parámetros de la capa ^{[ al ]}
  • Parámetros especiales: ^{[ 71 ] [ 72 ]}
  • Conjunto de utilidades integradas especiales : ^{[ 73 ] [ 74 ]}
  • Trampa de utilidad incorporada especial : ^{[ 74 ] [ 75 ]}
    • POSIX especifica ciertos usos de la función integrada trap : ...
  • Función de utilidad printf : un medio para imprimir de forma fiable el contenido de una variable:
• Funcionalidades de Bash no especificadas por POSIX:
  • Variables de Bash: ^{[ am ]}
  • Conjunto de funciones integradas del shell : ^{[ 73 ] [ 74 ]}
  • Tienda Shell Builtin : ^{[ un ] [ 74 ]}
  • Trampa integrada de Shell : ^{[ 75 ] [ 74 ]}
    • Si bien POSIX especifica ciertos usos de la función integrada trap , las siguientes especificaciones de señales son extensiones de Bash: ...
• Utilidades de depuración de terceros:
  • ShellCheck: Herramienta de análisis de scripts de shell; ^{[ 76 ] [ 19 ]}
  • devscripts-checkbashisms: Comprueba si un script /bin/sh contiene alguna construcción común específica de bash; ^{[ 77 ] [ 18 ]}
  • kcov: Herramienta de cobertura de código sin opciones de compilación especiales; ^{[ 78 ]}
  • Bashdb: El depurador simbólico de Bash. ^{[ 22 ] [ 79 ]}

Un comando externo llamado bashbug informa sobre errores del intérprete de comandos Bash. Al ejecutar el comando, se abre el editor predeterminado del usuario con un formulario para completar. El formulario se envía por correo electrónico a los responsables del mantenimiento de Bash (o, de forma opcional, a otras direcciones de correo electrónico). ^{[ 80 ]}

A continuación se enumeran eventos significativos en la historia de Bash: ^{[ 84 ]}

• Concha de Almquist (ceniza)
  • Shell de Debian-Almquist (dash)
• Concha de Bourne (sh)
• BusyBox
• shell de C (csh)
• Pez (Caparazón interactivo y amigable)
  • nsh – intérprete de línea de comandos como fish, pero compatible con POSIX ^{[ 122 ]}
• Google Shell (goosh): interfaz gráfica tipo UNIX para la Búsqueda de Google.
• KornShell (ksh) – tiene muchas variantes
• osh (Oil Shell) – Intérprete de línea de comandos UNIX compatible con Bash; disponible en Arch Linux.
• Interfaz PWB (Interfaz Mashey o Programmer's Workbench)
• Qshell – para IBM i
• rc – del Plan 9
• RUNCOM
• rush (Shell de usuario restringido) – disponible en Debian ^{[ 98 ]}
• Estructura independiente (de guillotina)
• scsh (El intérprete de comandos de Scheme)
• tcsh (shell C de TENEX)
• Caparazón Thompson (tsh)
• Caja de juguetes
• yash (Yet Another Shell) – aspira a ser "el intérprete de comandos más compatible con POSIX del mundo"; disponible en Arch Linux.
• Z shell (zsh)

Existen muchos programas que permiten crear una interfaz gráfica para scripts de shell.

• curses - curses es una biblioteca de control de terminal para sistemas tipo Unix, que permite la construcción de aplicaciones con interfaces de usuario de texto (TUI).
• dialog es una utilidad que permite crear cuadros de diálogo en la consola, utilizando las bibliotecas curses y ncurses .
• gtkdialog es la utilidad más funcional para crear aplicaciones gráficas en scripts bash. ^{[ 123 ]}

• kdialog: es el equivalente de KDE a zenity. ^{[ 124 ]}

• ncurses : una biblioteca de programación para crear interfaces de usuario textuales (TUI) que funcionan en una amplia variedad de terminales.
• whiptail - es un análogo de la utilidad de diálogo, utiliza la biblioteca newt . ^{[ 125 ]}

• xdialog es un sustituto de dialog diseñado para proporcionar a los programas ejecutados desde la terminal una interfaz del sistema X Window .
• yad - es una bifurcación de zenity, con más características. ^{[ 126 ]}

• Zenity es la aplicación más popular para crear una interfaz gráfica para scripts. ^{[ 127 ]}