bash-hackers-wiki/docs/index.md
2023-07-04 00:29:25 +02:00

26 KiB

~~DISCUSSION:off~~

The Bash Hackers Wiki

![](keywords>bash shell linux scripting)

Come visit us at ircs://irc.libera.chat:6697 #bash ! ~ormaaj

<WRAP center round box 90%> This wiki is intended to hold documentation of any kind about GNU Bash. The main motivation was to provide human-readable documentation and information so users aren't forced to read every bit of the Bash manpage - which can be difficult to understand. However, the docs here are not meant as a newbie tutorial.

This wiki and any programs found in this wiki are free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

This wiki and its programs are distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see <http://www.gnu.org/licenses/>.

What would YOU like to see here? (outdated and locked, please use the discussions)

Stranger! Feel free to register and comment or edit the contents. There is a Bash Hackers Wiki needs love page that lists some things to do. The registration is only there to prevent SPAM. </WRAP>

Scripting and general information

Code snippets

There is a section that holds small code snippets.

See also some Bash source code excerpts.

How to....

Doing specific tasks: concepts, methods, ideas:

Bash syntax and operations

<WRAP column 40%> [Compound commands]{.underline}

Compound commands overview


Grouping
{ ...; } command grouping ( ... ) command grouping in a subshell Conditionals
[[ ... ]] conditional expression if ...; then ...; fi conditional branching case ... esac pattern-based branching Loops
for word in ...; do ...; done classic for-loop for ((x=1; x<=10; x++)); do ...; done C-style for-loop while ...; do ...; done while loop until ...; do ...; done until loop Misc
(( ... )) arithmetic evaluation select word in ...; do ...; done user selections

</WRAP>

<WRAP column 40%> [Expansions and substitutions]{.underline}

Introduction to expansions and substitutions


{A,B,C} {A..C} Brace expansion ~/ ~root/ Tilde expansion $FOO ${BAR%.mp3} Parameter expansion `command` $(command) Command substitution <(command) >(command) Process substitution $((1 + 2 + 3)) $[4 + 5 + 6] Arithmetic expansion Hello <---> Word! Word splitting /data/*-av/*.mp? Pathname expansion

</WRAP> <WRAP clear></WRAP>

Builtin Commands

This is a selection of builtin commands and command-like keywords, loosely arranged by their common uses. These are provided directly by the shell, rather than invoked as standalone external commands.

<WRAP column 46%>


                                                       Declaration commands\                                                                                                                                                                      Alt             Type
 \<wrap center round lo todo box 80%\>Commands that set and query attributes/types, and manipulate simple datastructures.\</wrap\>                                                                                                                          

                                               [declare](/commands/builtin/declare)                                                   Display or set shell variables or functions along with attributes.                                       `typeset`         builtin

                                                [export](/commands/builtin/export)                                                    Display or set shell variables, also giving them the export attribute.                                  `typeset -x`   special builtin

                                                  [eval](/commands/builtin/eval)                                                      Evaluate arguments as shell code.                                                                            \-        special builtin

                                                 [local](/commands/builtin/local)                                                     Declare variables as having function local scope.                                                            \-            builtin

                                              [readonly](/commands/builtin/readonly)                                                  Mark variables or functions as read-only.                                                               `typeset -r`   special builtin

                                                 [unset](/commands/builtin/unset)                                                     Unset variables and functions.                                                                               \-        special builtin

                                                 [shift](/commands/builtin/shift)                                                     Shift positional parameters                                                                                  \-        special builtin

                                                               I/O\                                                                                                                                                                               Alt             Type

<wrap center round lo todo box 80%>Commands for reading/parsing input, or producing/formatting output of standard streams.</wrap>

                                                 [coproc](/syntax/keywords/coproc)                                                    Co-processes: Run a command in the background with pipes for reading / writing its standard streams.         \-            keyword

                                                  [echo](/commands/builtin/echo)                                                      Create output from arguments.                                                                                \-            builtin

                                               [mapfile](/commands/builtin/mapfile)                                                   Read lines of input into an array.                                                                      `readarray`        builtin

                                                [printf](/commands/builtin/printf)                                                    \"advanced `echo`.\"                                                                                         \-            builtin

                                                  [read](/commands/builtin/read)                                                      Read input into variables or arrays, or split strings into fields using delimiters.                          \-            builtin

                                                   Configuration and Debugging\                                                                                                                                                                   Alt             Type
  \<wrap center round lo todo box 80%\>Commands that modify shell behavior, change special options, assist in debugging.\</wrap\>                                                                                                                           

                                                [caller](/commands/builtin/caller)                                                    Identify/print execution frames.                                                                             \-            builtin

                                                   [set](/commands/builtin/set)                                                       Set the positional parameters and/or set options that affect shell behaviour.                                \-        special builtin

                                                 [shopt](/commands/builtin/shopt)                                                     set/get some bash-specific shell options.                                                                    \-            builtin

</WRAP>

<WRAP column 46%>


                                    Control flow and data processing\                                                                                                  Alt          Type
 \<wrap center round lo todo box 80%\>Commands that operate on data and/or affect control flow.\</wrap\>                                                                      

                                     [colon](/commands/builtin/true)                                        \"true\" null command.                                     true    special builtin

                                     [dot](/commands/builtin/source)                                        Source external files.                                    source   special builtin

                                    [false](/commands/builtin/false)                                        Fail at doing nothing.                                      \-         builtin

                           [continue / break](/commands/builtin/continueBreak)                              continue with or break out of loops.                        \-     special builtin

                                      [let](/commands/builtin/let)                                          Arithmetic evaluation simple command.                       \-         builtin

                                   [return](/commands/builtin/return)                                       Return from a function with a specified exit status.        \-     special builtin

                                       [\[](/commands/classictest)                                          The classic `test` simple command.                         test        builtin

                                        Process and Job control\                                                                                                       Alt          Type

<wrap center round lo todo box 80%>Commands related to jobs, signals, process groups, subshells.</wrap>

                                     [exec](/commands/builtin/exec)                                         Replace the current shell process or set redirections.      \-     special builtin

                                     [exit](/commands/builtin/exit)                                         Exit the shell.                                             \-     special builtin

                                     [kill](/commands/builtin/kill)                                         Send a signal to specified process(es)                      \-         builtin

                                     [trap](/commands/builtin/trap)                                         Set signal handlers or output the current handlers.         \-     special builtin

                                    [times](/commands/builtin/times)                                        Display process times.                                      \-     special builtin

                                     [wait](/commands/builtin/wait)                                         Wait for background jobs and asynchronous lists.            \-         builtin

                                                                                                                                                                       Alt          Type

</WRAP> <WRAP clear></WRAP> <WRAP hide> previous alphabetical version <WRAP column 40%>

A-G


caller identify/print execution frames (Bash builtin) coproc Co-processes (Bash keyword) declare display or set shell variables or functions along with attributes (Bash builtin, synonym: typeset) exec replace the shell, set redirections (Bash builtin) I-N
let arithmetic evaluation - an old fashioned way (Bash builtin) mapfile Mapping lines of input to an array, also named readarray (Bash builtin)

</WRAP>

<WRAP column 40%>

O-T


printf "advanced echo" (Bash builtin) read getting input from stdin (Bash builtin) readonly mark variables or functions as read-only (Bash builtin) set control positional parameters and shell behaviour (Bash builtin) shopt set/get shell options (Bash builtin) test the classic test command (Bash builtin) U-Z
unset unset variables and functions (Bash builtin)

</WRAP> <WRAP clear></WRAP> </WRAP>

Dictionary

<note tip>A list of expressions, words, and their meanings is here.</note>

Documentation / Reference

Bash Libraries (needs review)

<div hide>

Most wanted

Statistics for Month: April 2012


Rank Views Article 1 6833 getopts_tutorial (March: 11663) 2 4025 printf (March: 7079) 3 2861 quoting (March: 5730) 4 2854 classictest (March: 6145) 5 2222 pe (March: 4540) 6 1760 posparams (March: 3591) 7 1249 bash4 (March: --) 8 1212 edit-ed (March: 2727) 9 1205 read (March: --) 10 1182 mutex (March: --)

  • "Total visits": 35144
  • The overall "start" page is not counted

</div>

Contact

<WRAP column 40%> Visit us in ircs://irc.libera.chat:6697, channel #bash ;-)

If you have critiques or suggestions, please feel free to send a mail using the contact form on the right. Note that there is a simple discussion option below every article.

Please also see the imprint if you have problems with the site and its contents (legality, ...)!

It also would be nice to drop a line when

  • it helped you
  • it didn't help you (something missing / unclear)
  • you like it
  • you don't like it
  • you found mistakes / bugs

Simply: Reader's feedback </WRAP>

<WRAP column 40%> ![](contact>subj=Wiki reader feedback) </WRAP> <WRAP clear></WRAP>