Bash

The vast majority of important Bourne shell scripts can be run unchanged in bash, with the exception of those that refer to special Bourne variables or use the Bourne built-in commands. The Bash command syntax includes ideas borrowed from Korn shell ( ksh ) and C shell ( csh ), such as command line editing, command history, directory stack, $RANDOM and $PPID , $(…) command replacement syntax. When Bash is used as an interactive command processor, it supports the completion of program names, files, variables, etc. using the Tab ↹ key.

The bash interpreter has many built-in commands, some of which have similar executable files in the operating system. However, it should be noted that most often there are no man pages for built-in commands, and when you try to view help on a built-in command, the help on the executable file will actually be issued. The executable file and the built-in command may differ in parameters. Information on built-in commands is described in the bash man page:

man bash

In the simplest case, a script is a simple list of commands written to a file. The command processor should know that it should process this file, and not just read its contents. A special construct called shebang serves for this: #! . The # character specifies a comment, but in this case shebang means that after this special character there is a path to the interpreter for script execution.

Syntax

The syntax for bash commands is the extended syntax for Bourne shell commands. The final bash command syntax specification is in the Bash Reference Manual distributed by the GNU project. ^[four]

"Hello world"

  #! / usr / bin / env bash
 echo 'Hello World!'

This script contains only two lines. The first line tells the system which program is used to run the file. The second line is the only action that this script executes; it actually prints “Hello world!” In the terminal.

Run Script

In order for the script to become executable, the following commands can be used:

  chmod + rx scriptname # granting read / execute rights to any user
 chmod u + rx scriptname # granting rights to read / execute only to the "owner" of the script

For security reasons, the path to the current directory . not included in the $PATH environment variable. Therefore, to run the script, you must explicitly specify the path to the current directory in which the script is located:

  ./scriptname

In addition, you can pass such a file for execution to the Bash interpreter explicitly using the bash command:

  bash scriptname

In this case, neither setting the access rights nor using the sequence #! is required #! in code.

I / O Redirection

There are built-in file descriptors in bash: 0 (stdin), 1 (stdout), 2 (stderr).

• stdin - standard input - what the user types in the console;
• stdout - standard output of the program;
• stderr - standard error output.

There are special characters for operations with these and user descriptors: > (output redirection), < (input redirection). Symbols & , - can precede the descriptor number; for example, 2>&1 - redirecting handle 2 (stderr) to handle 1 (stdout).

Bash has an individual redirection syntax that is not supported in the Bourne shell. Example of simultaneously redirecting standard output and standard errors:

  command & > file

This is easier to type than the equivalent command in the Bourne shell syntax.

  command > file 2 > & 1

Redirect "from script code"

The heredoc syntax is supported:

• With the interpretation of variables and language constructs inside a block:

  $ a = 'multi-line'
 command << MYDOC123
 $ a
 text
 $ (<$ HOME / my_file.txt)
 MYDOC123

• Without interpretation of variables:

  command << 'PERLCODE'
 my $ first = 'Hello';
 my $ second = 'world';
 say join (',', $ first, $ second), '!';
 PERLCODE

• With removal of initial indents (only indents are supported by tabs):

  command << - 'TABSTRIP'
 for ((i = 0; i <10; i ++))
 do
 echo "$ i"
 done
 TABSTRIP

Starting with version 2.05b, bash can redirect standard input from a string using the following here strings syntax:

  command <<< "string to be read as standard input"

If a string contains spaces, it should be enclosed in quotation marks or apostrophes, or escape spaces with a backslash.

Be careful: the line you enter using here strings contains an implicit sequence to end the line: either 1 extra byte of line feed , or 2 extra bytes: carriage return and line feed.

  cat - <<< '123' |  wc -c
 # Result: 4
 cat < ( echo -n '123' ) |  wc -c
 # Result: 3
 wc -c <<< '123'
 # Result: 4
 echo -n 123 |  wc -c
 # Result: 3

Starting with version 4.1 ^[5], it became possible to indicate a terminating sequence of characters in one line and, immediately after it, a bracket. This may be useful for assigning a here-doc content variable:

  var = $ ( cat - << 'TERMSEQ'
 February.  Get ink and cry!
 Write about feverishly about February,
 While the rumbling slush
 In spring it burns black.
 TERMSEQ )

In this case, a BASH warning message will be generated.

Redirection for the whole process

Example (redirecting standard output to a file, writing data, closing a file, resetting stdout):

  # make Filedescriptor (FD) 6 a copy of stdout (FD 1)
 exec 6 > & 1
 # open file "test.data" for writing
 exec 1 > test.data
 # produce some content
 echo "data: data: data"
 # close file "test.data"
 exec 1 > & -
 # make stdout a copy of FD 6 (reset stdout)
 exec 1 > & 6
 # close FD6
 exec 6 > & -

Opening and closing files:

  # open file test.data for reading
 exec 6 <test.data
 # read until end of file
 while read -u 6 dta
 do
   echo " $ dta " 
 done
 # close file test.data
 exec 6 < & -

Command Substitution

Capturing the output of external commands:

  # execute 'date' and put the result in VAR
 VAR = " $ ( date ) "
 echo " $ VAR " # will display the date at the time the previous line was called

At the same time, null-character strings are not supported, the final line feeds disappear, unlike channels and other file I / O.

Conditional Operator

  #! / usr / bin / env bash
 T1 = 'foo'
 T2 = 'bar'
 if [[ $ T1 == " $ T2 " ]] 
 then
   echo 'condition is satisfied'
 else
   echo 'condition not fulfilled'
 fi

Note that quotation marks around the left side are optional. ^[6]

Cycles

  #! / usr / bin / env bash
 for i in "Number" { 1 ..10 }
 do
   echo " $ i "
 done

  1 #! / Usr / bin / env bash
 2 COUNTER = 0
 3 while [[ $ COUNTER -lt 10 ]] 
 4 do
 5 echo The counter is $ COUNTER
 6 let COUNTER = COUNTER + 1
 7 done

  #! / usr / bin / env bash
 i = 0
 until [[ $ i -eq 10 ]] 
 do
   echo " $ i "
   i = $ (( $ i + 1 ))
 done

  #! / usr / bin / env bash
 # inside double parentheses, variables can be written in C-style (without $ and separating operators and operands with a space)
 for (( i = 0 ; i < 10 ; i ++ ))
 do
	 echo -n " $ i ;"
 done

Arrays

In bash, only one-dimensional arrays are implemented. Indexes can be either integer values ​​(an "ordinary" array ) or strings ( an associative array , or a "hash").

Despite the unification of the syntax for working with regular and associative arrays, the former are not a variation of the latter either from the point of view of the end user or from the point of view of the internal logic of the interpreter itself.

As a natural consequence of the support of "associative" keys, in bash there is an extremely limited ability to emulate multidimensional arrays.

General Operations

Get a string consisting of all ^[7] elements of the array, separated by a space.

  values = " $ { arr [@] } "

Get a string with all ^[7] indexes or array keys, regardless of whether they are numeric or text:

  keys = " $ { ! arr [@] } "

Carry out mass replacement of the first occurrence of the substring “MAY” with “MARCH” in all ^[7] elements of the array and return a string composed of the resulting elements of the array, separated by a space:

  values = " $ { arr [@] / MAY / MARCH } "

The same, but in each ^[7] element of the array all occurrences of the substring “MAY” will be replaced:

  values = " $ { arr [@] // MAY / MARCH } "

Until now, not all the features declared in the documentation work correctly for arrays. For example:

  [ -v 'array_name' ]

fails for an empty array. ^[8]

Indexed Array Operations

Bash has support for one-dimensional arrays. The elements of the array can be initialized as: my_array[xx] . You can also explicitly declare an array in a script using the declare directive:

  declare -a my_array

You can access individual elements of the array using curly braces: "${my_array[xx]}" .

There are two ways to initialize an indexed array:

one)

  Array = ( element1 element2 element3 )

2)

  temp_array [ 0 ] = element1
 temp_array [ 5 ] = element
 temp_array [ 9 ] = elementN

Adding elements to the end of an indexed array:

  declare -a arrAnimals
 arrAnimals = ( dog elephant horse cow fox koala turtle )
 # Output the contents of the array:
 echo " $ { arrAnimals [@] } "
 # At the end of the arrAnimals array, add a new element: "pig"
 arrAnimals + = ( pig )
 # And again, show the contents of the array:
 echo " $ { arrAnimals [@] } "

Get the first element of the array:

  echo " $ { arrAnimals [0] } "

Both indexed and associative arrays support the so-called “slices”:

  # Another way to get the first element of an array
 echo " $ { arrAnimals [@]: 0 : 1 } "

 # Output 3 elements of the array, starting from the 2nd:
 echo " $ { arrAnimals [@]: 2 : 3 } "

Note: in the case of associative arrays, the sequence of values ​​in the general case will be random (determined by the hash function used), therefore, the operation of cutting on the associative array, although valid, has a very limited area of ​​practical application.

In arrays with numerical indices, “reverse” (“negative”) addressing is allowed, which allows access to elements starting from the end of the array:

  # The value of the last element of the array
 echo " $ { arrAnimals [-1] } "
 # The value of the penultimate element of the array
 echo " $ { arrAnimals [-2] } "
 # ... etc.

Using the built-in mapfile (synonym: readarray ), you can map the contents of a text file to an indexed array:

  declare -a fileWithLogins
 mapfile fileWithLogins </ etc / passwd
 for (( i = 0 ; i < $ {# fileWithLogins [@] } ; i ++ ))
 do
	 echo "Line # $ i : $ { fileWithLogins [ $ i ] } "
 done

Associative Array Operations

Starting with version 4.0, bash introduced support for associative arrays (the so-called hash arrays).

To declare associative arrays, use the -A switch of the declare built-in command:

  declare -A hshArray

As with indexed arrays, two different syntaxes can be used to populate associative arrays:

one)

  TheCapitalOf [ Georgia ] = 'Tbilisi'
 TheCapitalOf [ Australia ] = 'Canberra'
 TheCapitalOf [ Pakistan ] = 'Islamabad'

2)

  TheCapitalOf = ([ Georgia ] = 'Tbilisi' [ Australia ] = 'Canberra' [ Pakistan ] = 'Islamabad' )

Using associative arrays you can simulate support for multidimensional arrays:

  declare -A a # declares an associative array 'a'
 i = 1 ;  j = 2 # initialize multiple indexes
 a [ $ i , $ j ] = 5 # assigning the value “5” to the cell “$ i, $ j” (ie “1,2”)
 echo $ { a [ $ i , $ j ] } # output stored values ​​from "$ i, $ j"

Unfortunately, in current versions of bash, copying the contents of one associative array into another is not possible with a simple assignment. This problem can only be circumvented, for which there are two fundamentally different approaches:

1) Emulate the declaration of the second hash “from scratch” by copying the declaration of the first hash:

  declare -A hsh1
 hsh1 = ( ... )

 source < ( declare -p hsh1 | sed 's / ^ declare -A hsh1 / declare -A hsh2 /' )

2) Iterate over all ^[7] elements of the source hash and copy them to the target hash:

  declare -A hsh1 hsh2
 hsh1 = ( ... )

 for k in " $ { ! hsh1 [@] } "
 do
	 hsh2 [ " $ k " ] = " $ { hsh1 [ " $ k " ] } "
 done

Safe work with arrays

Arrays are a convenient way to pass dynamically generated arguments to functions or commands. In addition, each element of the array is a separate argument.

  args = ( -l -a / )
 ls " $ { args [@] } " # ls -l -a /
 ls $ { args [@] } # ls -l -a /
 ls $ { args [*] } # ls -l -a /

However, when using arrays in this way, you should be careful because of the features of expanding arrays when using the special characters @ and * as indices.

If the array is enclosed in quotation marks and expanded using the @ index, a string of words is formed, where each word is a separate element of the array. However, if you do not enclose the expansion of the array in double quotation marks, then you may get a completely different result: the spaces that make up the array elements become word delimiters.

  args = ( -l -a '/ home / user / Desktop' )
 ls " $ { args [@] } " # view the contents of the directory '/ home / user / Desktop'
 ls $ { args [@] } # error: the directories '/ home / user / Worker' and './table' do not exist

An array with index * enclosed in double quotation marks is expanded on one line, connecting all elements of the array through the delimiters stored in the IFS variable. If you do not specify double quotation marks, then the array is expanded similarly to expansion when using the @ index.

  args = ( '' usr local bin )
 IFS = '/' ls " $ { args [*] } " # view the contents of the directory '/ usr / local / bin'
 IFS = '/' ls $ { args [*] } # alternately viewing the contents of the directories '.', './Usr', './local' and './bin'

When creating an array from the contents of a text variable, you must consider the possible presence of spaces in the text. For example, as one of the ways to create an array from an enumerated string, you can consider replacing the separator character with a space. However, the presence of gaps in shared elements will lead to fragmentation of the elements themselves into parts.

  array = ( $ { text //, / } ) # wrong: the text in the variable 'text' could contain whitespace

 IFS = ',' array = ( $ text ) # right: the separator character is a comma.
 IFS = ',' read -r -a array <<< " $ text " # is correct (alternative with redirecting the contents of the variable 'text' to the command 'read')

Errors can be caused by creating an array from text received as a command output or from a file, since not only line breaks, but also spaces with tabs will be considered delimiters by default ^[9] .

  array = ( " $ ( ls ) " ) # wrong: spaces in the file name can split the file name into two array elements

 IFS = $ '\ n' array = ( " $ ( ls ) " ) # right: only line breaks will be a delimiter
 mapfile -t array << ( ls ) # correct: alternative via the built-in mapfile command

Conveyor

The conveyor transfers the output of the previous command to the input of the next or to the input of the shell. The method is often used to link a sequence of commands into a single chain. The conveyor is indicated by | .

Example (grep works like a filter for standard output):

  cat filename |  grep pattern

Logical operations

Logical OR is denoted as || . In condition checking operations, the operator || returns 0 (success) if one of the operands is true (TRUE).

Logical AND is denoted as && . In condition checking operations, the && operator returns 0 (success) if and only if both operands are true (TRUE).

Примечание: Возможная путаница в понимании возникает из-за того, что команда true (и успешное завершение любой команды) завершается с кодом возврата 0, success ( false , наоборот, не 0), в то время как логическое значение true/false — отлично от нуля/равно нулю.

Examples:

 if false ; then echo "successfully" ; else echo "unsuccessfully" ; fi
unsuccessfully

 let "a=(( 1 && 0 && 123))" ; echo $?  ; echo $a
1 # Код завершения команды
0 # Значение переменной "a", результат логической операции
if (( 1 && 0 && 123 )) ; then echo "true" ; else echo "false" ; fi
false
let "a=(( 1 && 123 && -345 ))" ; echo $?  ; echo $a
0 # Код завершения команды
1 # Значение переменной "a", результат логической операции
if (( 1 && 123 & -345 )) ; then echo "true" ; else echo "false" ; fi
true

 false && echo "Успешное завершение" || echo "Неуспешное завершение"
Неуспешное завершение

Целочисленная математика

Bash может выполнять целочисленные вычисления внутри процесса, используя команду ((…)) и синтаксис переменной $((…)) ^[10] , как показано ниже:

 VAR = 55 # Устанавливаем переменную VAR, равной 55
(( VAR = VAR + 1 )) # Добавляем единицу к переменной VAR. Обратите внимание на отсутствие знака '$'
(( VAR += 1 )) # Сокращённая форма записи инкремента
(( ++VAR )) # Другой способ увеличения VAR на единицу. Выполняет префиксный инкремент
(( VAR++ )) # Другой способ увеличения VAR на единицу. Выполняет постфиксный инкремент
echo $(( VAR * 22 )) # Умножаем VAR на 22 и передаем результат команде
echo $ [ VAR * 22 ] # Устаревший способ сделать то же
(( VAR <<3)) # Побитовый сдвиг влево (то же, что VAR*8)
((VAR>>3 )) # Побитовый сдвиг вправо (то же, что VAR/8)

Команда ((…)) также может использоваться в условных утверждениях, так как её исходный параметр — это 0 или 1, которые могут интерпретироваться как true или false:

 if (( VAR == Y * 3 + X * 2 ))
then
  echo Yes 
fi
(( Z > 23 )) && echo Yes

Команда ((…)) поддерживает следующие операторы ставнения: == != > < >= <= .

Bash не поддерживает вычисления внутри процесса с числами с плавающей точкой. Только командные процессоры Unix Korn shell (версия 1993 года ) и zsh (начиная с версии 4.0) поддерживают эту возможность.

Список математических операций: + , - , * , / , ** (возведение в степень), % (деление по модулю, остаток от деления), let — позволяет использовать сокращения арифметических команд (сокращая количество используемых переменных; например: a += b эквивалентно a = a + b и т. п.).

Аргументы:

Встроенные переменные:

Регулярные выражения внутри процесса

Bash 3.0 поддерживает встроенные регулярные выражения с синтаксисом, подобным синтаксису Perl :

 [[ string = ~ regex ]]

Синтаксис регулярных выражений задокументирован на страницах документации man 7 regex. Статус выхода устанавливается в 0, если регулярное выражение совпало со строкой, и 1, если нет. Значение подвыражения, заключённого в скобки, можно получить ^[7] через переменную ${BASH_REMATCH[@]} , например:

 REGEXP = 'foo(bar)bl(.*)'
if [[ "abcfoobarbletch" = ~ $REGEXP ]] 
then
  echo "Регулярное выражение совпало со строкой!" 
  echo " $BASH_REMATCH " # выводит: foobarbletch
  echo " ${ BASH_REMATCH [1] } " # выводит: bar
  echo " ${ BASH_REMATCH [2] } " # выводит: etch
fi

Встроенные регулярные выражения обычно работают быстрее, чем выполнение внешней команды grep, потому что соответствующее регулярное выражение выполняется в рамках процесса bash. Если регулярное выражение или строка содержат пробелы или метасимволы (такие как * или ? ), их следует взять в кавычки. Рекомендуется использовать переменную для хранения регулярного выражения, как в вышеприведённом примере, для избежания проблем с экранированием специальных символов. Можно использовать вывод bash с опцией -x для проверки, как именно bash воспринимает ваше регулярное выражение.

Возможность расширения скобок заимствована у csh . Она позволяет произвольной строке быть сформированной с использованием похожей техники, как это делается с названиями файлов. Однако в bash сгенерированные строки не обязаны быть именами файлов. Результат каждого расширения строки не сортируется, сохраняется порядок слева направо:

 # Это особенность присущая bash
echo a { p,c,d,b } e # ape ace ade abe

Не следует использовать эту особенность, если скрипт планируется портировать, потому что в традиционных скриптах расширение строки не будет действовать:

 # Традиционная оболочка не даёт тот же результат
echo a { p,c,d,b } e # a{p,c,d,b}e

Когда используется расширение скобок в сочетании с символами подстановки, скобки раскрываются первыми, а затем результат обрабатывается в обычном режиме. Таким образом, список JPEG- и PNG-изображений в текущем каталоге может быть получен так:

 ls *. { jpg,jpeg,png } # скобки раскрываются до *.jpg *.jpeg *.png, после чего выполняется поиск по маскам

• Tab ↹ : Автодополнение строки за курсором.
• Ctrl + ! Ctrl + ! : Повторить последнюю команду.
• Ctrl + a : Перемещает курсор в начало строки (эквивалентно клавише Home ).
• Ctrl + b : Перемещает курсор на один символ назад (эквивалентно клавише ← ).
• Ctrl + r : Поиск по набранным ранее командам.
• Ctrl + c : Посылает сигнал SIGINT текущему заданию, который обычно (но не всегда) прекращает и закрывает его.
• Ctrl + d : Посылает маркер EOF , который (если не отключено опцией и текущая строка не содержит текста) закрывает текущую оболочку (эквивалентно команде exit ), при вводе в исполняющуюся программу завершает ввод, если в строке нет текста, иначе завершает строку без символа завершения строки.
• Ctrl + d : Удаляет текущий символ (только если есть текст на текущей строке) (эквивалентно клавише Delete ).
• Ctrl + e : Перемещает курсор в конец строки (эквивалентно клавише End ).
• Ctrl + f : Перемещает курсор на один символ вперёд (эквивалентно клавише → ).
• Ctrl + h : Удаляет предыдущий символ (то же самое, что и клавиша ← Backspace ).
• Ctrl + i : Эквивалентно клавише Tab ↹ .
• Ctrl + j : Эквивалентно клавише ↵ Enter .
• Ctrl + k : Очищает содержимое строки после курсора и копирует это в буфер обмена экземпляра bash (kill ring).
• Ctrl + l : Очищает содержимое экрана (эквивалентно команде clear ).
• Ctrl + m : Эквивалентно клавише ↵ Enter .
• Ctrl + n : (следующее) перелистывает к следующей команде (эквивалентно клавише ↓ ).
• Ctrl + o : Выполняет найденную команду в истории, и выбирает следующую строку относительно текущей строки в истории для того, чтобы отредактировать.
• Ctrl + p : (предыдущее) перелистывает к предшествующей команде (эквивалентно клавише ↑ ).
• Ctrl + q : Возобновить вывод процесса.
• Ctrl + s : Приостановить вывод процесса (stop).
• Ctrl + t : Обмен местами соседних символов.
• Ctrl + u : Очищает содержание строки до курсора и копирует его в буфер обмена экземпляра bash (kill ring).
• Ctrl + w : Убирает слово до курсора и копирует его в буфер обмена экземпляра bash (kill ring).
• Ctrl + y : добавляет содержимое буфера обмена экземпляра bash от позиции курсора.
• Ctrl + z : Посылает сигнал SIGTSTP текущему заданию, который приостанавливает его выполнение, и возобновляет приём команд. Для возобновления его выполнения в фоновом режиме можно ввести команду bg. Для того, чтобы вернуть его из фонового режима или приостановки, можно выполнить fg.
• Ctrl + / : Прервать текущий процесс с дампом памяти (core dump), послав ему сигнал.
• Ctrl + _ ( Ctrl + ⇧ Shift + - ): Откат редактирования.
• Alt + > : переход к последней команде в истории.
• Alt + b : (назад) перемещает курсор назад на одно слово (эквивалентно клавише Ctrl + ← ).
• Alt + d : Сокращает слово после курсора.
• Alt + f : (вперёд) перемещает курсор вперёд на одно слово (эквивалентно клавише Ctrl + → ).
• Alt + t : Меняет два слова перед курсором местами.
• Alt + . : Добавляет последний аргумент предыдущей команды.
• Alt + c : Заменить букву под курсором на заглавную.
• Alt + l : Заменить букву под курсором на строчную.
• Ctrl + x Ctrl + x : Переносит курсор к началу строки от текущей позиции, и обратно.
• Ctrl + x Ctrl + e : Редактирует текущую строку в программе $EDITOR, или vi, если не предопределено.
• Ctrl + x Ctrl + v : Вывод на экран информации о версии текущего экземпляра bash.

Bash при запуске вызывает команды из множества различных скриптов.

Когда bash вызывается как интерактивная оболочка входа в систему, первым делом он читает и вызывает команды из файла /etc/profile , если этот файл существует. После чтения этого файла он смотрит следующие файлы в следующем порядке: ~/.bash_profile , ~/.bash_login и ~/.profile , читает и вызывает команды из первого, который существует и доступен для чтения. При выходе bash читает и выполняет команды из файла ~/.bash_logout .

Когда запускается интерактивная оболочка, но не для входа в систему, bash читает и исполняет команды из файлов /etc/bash.bashrc и ~/.bashrc , если они существуют. Это может быть отменено опцией -norc . Опция -rcfile file заставит bash использовать команды из файла file вместо /etc/bash.bashrc и ~/.bashrc .

Первой строкой скрипта должна быть запись #!/bin/bash , если известен абсолютный путь к исполняемому файлу, либо #!/usr/bin/env bash для автоматического определения пути к исполняемому файлу через команду env с помощью переменной окружения PATH ^[11] .

Скрипты оболочек, написанные со специфическими для bash особенностями, не будут работать на системах, где используется Bourne shell (sh) или один из его аналогов , если bash не был установлен в качестве дополнительной оболочки. Эта проблема стала особенно важной, когда Ubuntu начал с октября 2006 года поставлять Debian Almquist shell (dash) как скриптовую оболочку по умолчанию, что привело к неработоспособности многочисленных скриптов.

Существует множество программ, позволяющих создавать графический интерфейс к bash-скриптам.

• dialog — утилита, позволяющая создавать диалоговые окна в консоли, использует библиотеки curses и ncurses .
• whiptail — аналог утилиты dialog, использует библиотеку newt .
• zenity — наиболее популярное приложение для создания графического интерфейса к скриптам.
• kdialog — аналог zenity в среде KDE .
• yad — форк zenity, с большими возможностями.
• xdialog — замена dialog, предназначенная для придания запускаемым из терминала программам интерфейса X Window System .
• gtkdialog — наиболее функциональная утилита для создания графических приложений на bash-скриптах.

• Сравнение командных оболочек
• Пакетный файл
• GNU Readline

• Bash Reference Manual (англ.) . — Официальное руководство. Дата обращения 22 ноября 2010. Архивировано 23 августа 2011 года.
• Bash Reference Manual (неопр.) . — Перевод man -страницы от 2004 года. Архивировано 18 мая 2012 года.
• Advanced Bash-Scripting Guide (рус.) . — Расширенное руководство по написанию bash-скриптов. Дата обращения 6 августа 2011. Архивировано 23 августа 2011 года.
• Частые ошибки программирования на Bash (неопр.) . Дата обращения 22 ноября 2010. Архивировано 23 августа 2011 года.
• Введение в программирование на bash (неопр.) . Дата обращения 22 ноября 2010. Архивировано 23 августа 2011 года.
• Bash (рус.) . openSuse wiki. Дата обращения 22 ноября 2010. Архивировано 23 августа 2011 года.
• Описание команд bash (англ.) . Дата обращения 22 ноября 2010. Архивировано 23 августа 2011 года.
• Ян Шилдс (Ian Shields). Полезные советы Linux: Параметры bash и расширения параметров (рус.) . Архивировано 15 октября 2012 года.