How to make bash scripts work in dash

This page is an attempt to list some of the most common bashisms, i.e. features not defined by POSIX (won't work in dash, or general /bin/sh). It probably won't be exhaustive. Note also we talk about "bashism" because this wiki is largely bash-centric but a number (almost all) of these extensions work in at least some other shells like ksh or zsh with perhaps some differences in the details, as most of Bash's scripting features are derived from ksh. POSIX has simply required a much smaller number of them.

Syntax

Expansions

• Brace Expansion, eg {a,b,c} or {1..10} is not defined by POSIX. Both forms are present in zsh, ksh93, yash (with an option) and the first form in older ksh and mksh. The first one originated in csh, the second in zsh.

• The <( ) and >( ) process substitutions are not defined by POSIX, but can be simulated with FIFOs: instead of foo <(bar), write mkfifo /tmp/foo_fifo; bar > /tmp/foo_fifo & foo /tmp/foo_fifo (this is basically how process substitution is implemented on OSes that don't have a mechanism like /dev/fd/ to refer to unnamed pipes with filenames). Originated in ksh86, also present in zsh.

Parameter Expansions

List of expansions not defined by POSIX:

• ${name:n:l} -- You can use $(expr "x$name" : "x.\{,$n\}\(.\{,$l\}\)"). This originated in ksh93 and is also present in zsh.

• ${name/foo/bar} -- you can use $(printf '%s\n' "$name" | sed 's/foo/bar/'), after changing shell patterns to regular expressions. This originated in ksh93 and is also present in mksh, and zsh, but ksh93's substitution expansion differs from Bash's.

• ${!name} -- bash-specific; it is possible to use eval to achieve similar effects, but it requires great attention to detail; see BashFAQ/006.

• The behavior of the #, ##, %, and %% operators are unspecified by POSIX and the ksh88 manual when used together with the @ or * parameters. Dash applies the trimming to the flattened result. mksh/pdksh treats it as a bad expansion.

Note that using $( ) has the side-effect of removing trailing newlines from the results. See CommandSubstitution for workarounds.

Arrays

Arrays are not defined by POSIX (but are present in ksh); there is no easy general workaround for arrays. Here are some hints:

• The positional parameters are a kind of array (only one array):

# Build a command dynamically. See BashFAQ/050
set -- 'mycommand' 'needs some complex' 'args'
"$@"
#access the i'th param
set -- one two three
i=2
eval "var=\${$i}" # i should be controlled by the script at all times. If influenced by side-effects like user input, robust validation is required.
printf '%s\n' "$var"

• use IFS and set -f

• eval is powerful but easy to misuse in dangerous ways. See Eval command and security issues.

Conditionals

Note: several standard POSIX utilities can be used for lexical comparisons. The examples below return a true (zero) exit status if the content of $a sorts before $b.

• awk 'BEGIN { exit !(ARGV[1] "" < "" ARGV[2]) }' "$a" "$b"

• expr "x$a" "<" "x$b" >/dev/null

• If the variables don't contain newline characters: printf "%s\n" "x$a" "x$b" | sort -C (also returns true if $a and $b are equal)

See http://austingroupbugs.net/view.php?id=375 for current work on extending the standard test builtin operators.

Arithmetic

See Arithmetic Precision and Operators and Arithmetic expansion for supported and required math expression features.

Redirections

Builtins

• echo -n or -e -- POSIX doesn't define any options, and furthermore allows echo -e to be the default behavior. Instead use printf "%s\n" (for normal echo) or printf "%b\n" (for echo -e); leave off the \n to simulate echo -n.

• printf -v is not defined by POSIX, and only Bash and Zsh support it. The %q format is not defined by POSIX but supported by ksh93, zsh, GNU printf and Bash (though with variations). The a, A, e, E, f, F, g, and G formats are not required by POSIX for printf(1), but dash appears to support %f, %e, %E, %g, and %G. %()T is only supported by ksh93 and Bash though with variations.

• read -- the only option defined by POSIX is -r; ksh and zsh have different sets of options that only partially overlap with bash.

• shopt, and therefore all the options it provides (extglob, nullglob, dotglob, etc.) are not defined by POSIX and are bash-specific

• local -- there is no POSIX equivalent. You can use $funcname_varname to reduce the likelihood of conflicts, but even that is not enough for recursive functions. You can ensure that recursive calls occur in subshell environments (so there is a "local" copy of all variables), or pass all "local variables" as parameters (because the positional parameters $@, $1, $2, etc are truly local). dash explicitly supports local as a non-Posix extension; ksh uses typeset instead, which works like bash's declare. local is mandated by the LSB and Debian policy specifications, though only the local varname (not local var=value) syntax is specified. An implementation of a variable stack for POSIX shells can be found there.

Special Variables

More

• The bash manual has a list of the differences between bash running in POSIX mode and a normal bash.
  Note: invoking bash in POSIX mode is only guaranteed to run a shell written according to the POSIX specification. It doesn't mean that it will fail if you use bashisms in your scripts.

• There is a handy perl script checkbashisms which is part of the debian devscripts package which can help point out bashisms in a particular script.

• https://wiki.ubuntu.com/DashAsBinSh The Ubuntu wiki also has a page that describes the differences

• Rich's sh tricks has some clever yet surprisingly powerful hacks for dealing with the limitations of the POSIX shell.

CategoryShell