Differences between revisions 23 and 87 (spanning 64 versions)
Revision 23 as of 2010-01-09 21:12:15
Size: 8196
Editor: s5591aacb
Comment:
Revision 87 as of 2021-10-24 02:43:01
Size: 12767
Comment: FUNCNAME -> `FUNCNAME`
Deletions are marked like this. Additions are marked like this.
Line 2: Line 2:

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
of these extensions work in other shells like ksh or zsh.
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.
Line 9: Line 5:
|| ||'''Works in bash''' ||'''Change to for dash''' ||'''Comment''' ||
||defining functions ||`function f { echo hello world; }` ||`f() { echo hello world; }` ||"function" is not defined by POSIX, only "name ()" is. The `function f {...}` syntax originated in `ksh` (and predates the Bourne syntax). In ksh both forms are present, but in the AT&T implementations, functions defined with "function" work slightly differently. `zsh` also supports both syntax without distinction. ||
||case ||`;;&` `;&` etc ||None. Duplicate the case (use a function to avoid code duplication, or an alias to let the shell expand the whole segment as it parses the script) ||`;;&` `;&` in bash4 is not defined by POSIX. AT&T ksh (since [[http://www.in-ulm.de/~mascheck/various/shells/ksh_versions.html|ksh88e]], where it originated), MirBSD ksh (since [[http://www.mirbsd.org/cvs.cgi/src/bin/mksh/syn.c.diff?r1=1.64;r2=1.65;f=h|R40]]) and zsh (since 3.1.2) have `;&` but not `;;&` ||
||numeric C-like for loop ||`for ((i=0; i<3; i++)); do`<<BR>>` echo "$i"`<<BR>>`done` ||`i=0 ; while [ "$i" -lt 3 ]; do`<<BR>>` echo "$i" ; i=$((i+1))`<<BR>>`done` ||This syntax is not defined by POSIX. Originated in ksh93; present in zsh. ||
||expand sequences ||`echo $'hello\tworld'` ||`printf "hello\tworld\n"` ||Historically `$' '` was not defined by POSIX through 2008, but has been accepted for the next version. http://austingroupbugs.net/view.php?id=249. Originated in ksh93, also supported by zsh, mksh, FreeBSD and Busybox sh though with variations ||
||extended glob ||`+( )` `@( )` `!( )` `*( )` ||not always possible, sometimes you can use several globs, sometimes you can use find(1) ||Not defined by POSIX. Originated in ksh; supported by zsh with an option like bash. ||
||select ||`select` ||some ideas: implement the menu yourself, use a command like dialog ||Not defined by POSIX. Originated in ksh; present in zsh. ||
||file slurp ||`$(< file)` ||`$(cat file)` ||Or read the file [[BashFAQ/001|line by line]]. ||
Line 10: Line 14:
|| || '''Works in bash''' || '''Change to for dash''' || '''Comment''' ||
|| defining functions || function f { echo hello world; } || f() { echo hello world; } || "function" is not defined by posix, only "name ()" is. In ksh both forms are present, but functions defined with "function" work slightly differently. ||
|| case || `;;&` `;&` etc || none. duplicate the case (use a funnction to avoid code duplication) || `;;&` `;&` in bash4 is not defined by posix. ksh93 has `;&` but not ``;;&` ||
|| numeric C-like for loop || `for ((i=0; i<3; i++)); do echo $i ; done` || `i=0 ; while test $i -lt 3 ; do echo $i ; i=$(($i+1)) ; done` || this syntax is not defined by posix. Present in ksh93. ||
|| expand sequences || `echo $'hello\tworld'` || `printf "hello\tworld"` || `$' '` is not defined by posix and is bash-specific ||
|| extended glob || `+( ) @( ) !( ) *( )` || not always possible, some times you can use several globs, sometimes you can use find(1) || not defined by posix. Present in ksh. ||
|| select || select || some ideas: implement the menu yourself, use a command like dialog || not defined by posix. Present in ksh. ||
Line 19: Line 16:
 * 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.
Line 20: Line 18:
 * Brace Expansion, eg {a,b,c} or {1..10} is not defined by posix. Both forms are present in ksh93, and the first form in older ksh.
 *
<( ) >( ) process substitution is not defined by posix, but can be simulated with FIFOs: instead of `foo <(bar)`, write `mkfifo fifo; bar > fifo & 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).  It is present in ksh93.
 * 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.
Line 24: Line 21:
List of expansions not defined by POSIX:
Line 25: Line 23:
List of expansions not defined by posix:  * `${name:n:l}` -- You can use `$(expr "x$name" : "x.\{0,$n\}\(.\{0,$l\}\)")`. This originated in ksh93 and is also present in zsh, mksh and busybox sh.
Line 27: Line 25:
 * ${name:n:l} -- if the variable contains no newlines, you can use `$(printf '%s\n' "$name" | cut -c $n-$((n+l-1)))`. If there are newlines, you can use `$(printf %s "$name" | dd bs=1 skip=$n count=$l 2>/dev/null)`, but printf may report a (harmless) broken pipe if the variable contents are large enough. This form is present in ksh93.
 * ${name/ } -- you can use `$(printf '%s\n' "$name" | sed 's/foo/bar/')`, after changing shell patterns to regular expressions. This form is prent in ksh93.
 * ${!name} -- bash-specific; it is possible, but dangerous, to use eval to achieve similar effects; see [[BashFAQ/006]].
 * `${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 variation in behaviour and glob pattern syntax between the three.
Line 31: Line 27:
Note that using `$( )` has the side-effect of removing trailing newlines from the results. Furthermore, since many standard Posix utilities, such as `sed`, require text files as input, you should ensure their input ends in a newline.  * `${!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.
Line 34: Line 34:

[[BashFAQ/005 | Arrays]] are not defined by posix (but are present in ksh); there is no easy general workaround for arrays. Here are some hints:
[[BashFAQ/005|Arrays]] are not defined by POSIX (but are present in ksh); there is no easy general workaround for arrays. Here are some hints:
Line 40: Line 39:
#build a command dynamically see [[BashFAQ/050]] # Build a command dynamically. See BashFAQ/050
Line 46: Line 45:
eval var=\$$i #take care if i comes from some user input see below
echo "$var"
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"
Line 49: Line 48:
 * use `IFS` and `set -f`
Line 50: Line 50:
 * use IFS and set -f  * `eval` is powerful but easy to misuse in dangerous ways. See [[BashFAQ/048|Eval command and security issues]].
Line 52: Line 52:
 * eval, is powerful but dangerous so use it wisely. See [[BashFAQ/048 | Eval command and security issues]].

 
Line 56: Line 53:
|| ||'''Works in bash''' ||'''Change to for dash''' ||'''Comment''' ||
||simple test ||`[[` ||use [ and use double quotes around the expansions `[ "$var" = "" ]` ||[[ is not defined by POSIX, originated in ksh and is also present in zsh ||
||pattern matching ||`[[ foo = *glov ]]` ||use `case` or `expr` or `grep` ||see [[BashFAQ/041]] ||
||equality with test ||`==` ||use `=` instead ||only `=` is defined by POSIX ||
||compare lexicographically. ||`<` `>` ||no change ||present in dash, ksh, yash and zsh, but not defined by POSIX. See note below for possible workarounds. ||
||compare modification times ||`[[ file1 -nt file2 ]]` or `-ot` ||`[ "$(find 'file1' -prune -newer 'file2')" ]` or `[ "file1" -nt "file2" ]` ||`-prune` is required to avoid recursion; present in dash, ksh, yash and zsh. `-nt` and `-ot` aren't specified by POSIX but are considered for addition in a future release. ||
||check if 2 files are the same hardlink ||`[[ file1 -ef file2 ]]` ||`[ "file1" -ef "file2" ]` ||`-ef` is not defined by POSIX (yet, same as above), but is present in ksh, yash, zsh and Dash. ||
||`(( ))` ||`(( ))` (without the `$`) acts like a command on its own ||For simple comparison: `[ -lt ] (and -ne -gt -ge)`. To assign a variable `var=$((3+1))`. For full functionality, use `[ "$(( (i+=2) < 5 && a > 3))" -ne 0 ]`. ||present in ksh (where it originated) and zsh ||
Line 58: Line 63:
|| || '''Works in bash''' || '''Change to for dash''' || '''Comment''' ||
|| simple test || `[[` || use [ and use double quotes around the expansions `[ "$var" = "" ]` || [[ is not defined by posix, but is present in ksh ||
|| pattern matching || `[[ foo = *glov ]]` || use case or grep || see [[BashFAQ/041]] ||
|| equality with test || `==` || use = instead || only = is defined by posix, = works also in bash ||
|| compare lexicographically. || `< >` || no change || present in dash and ksh, but not defined by posix. A possible workaround with awk: `awk -v v1="1" -v v2="fcd" 'BEGIN{exit !(v1 "" < "" v2)}'` ||
|| compare modification times || `[[ file1 -nt file2 ]]`` or `-ot` || [ "$(find 'file1' -prune -newer 'file2')" ] || -prune is required to avoid recursion; present in ksh ||
|| check if 2 files are the same hardlink || `[[ file1 -ef file2 ]]` || ? || -et is not defined by posix, but is present in ksh ||
|| `(( ))` || `(( ))` (without the $) acts like a command on its own || For simple comparison: `[ -lt ] (and -ne -gt -ge)` or `[ "$(( 3+1 < 5))" -eq 0 ]`. || present in ksh ||
|| || || To assign a variable var=$((3+1)) || ||
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.
Line 69: Line 74:
See [[http://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap01.html#tag_17_01_02_01|Arithmetic Precision and Operators]] and [[http://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_06_04|Arithmetic expansion]] for supported and required math expression features.
|| ||'''Works in bash''' ||'''Change to for dash''' ||'''Comment''' ||
||pre/post increment/decrement ||`++` `--` ||`i=$((i+1))` or `: "$((i+=1))"` || ||
||comma operator ||`,` ||`: "$((...))"; cmd "$((...))"` ||The comma operator is ''widely'' supported by almost everything except dash and yash -- even posh and Busybox. In ksh93 however, it conflicts with the decimal radix in locales where it's used in floating points instead of period ||
||exponentiation ||`**` || ||`**` is the only bash arithmetic operator that is not a standard C or C++ operator. ksh93 can use `pow(x, y)`. The `**` operator is supported by at least bash, zsh, ksh93, and busybox, but not by dash or mksh. ||
|| ||`let` or `((...))` ||`[ "$((...))" -ne 0 ]` ||Because of the above comma restriction, `let` can't be simulated exactly without a loop. ||
Line 70: Line 81:
|| || '''Works in bash''' || '''Change to for dash''' || '''Comment''' ||
|| pre/pos increment/decrement || `++ --` || `i=$((i+1))` || - ||
|| - || `let` || `: $((i=i+1))` || The `:` command can be used to peform side effects with an expansion ||

Line 75: Line 85:
|| || '''Works in bash''' || '''Change to for dash''' || '''Comment''' ||
|| redirect both stdout and stderr || `>&` and `&>`|| command > file 2>&1 or commnd 2>&1 | othercommand || - ||
||                                  || `|&` (bash4)|| command 2>&1 | othercommand || - ||
|| duplicate and close|| `m>
&n- m<&n-` || `m>&n n>&-` ||not defined by posix ||
 
|| ||'''Works in bash''' ||'''Change to for dash''' ||'''Comment''' ||
||redirect both stdout and stderr ||`>&` and `&>` ||`command > file 2>&1 or command 2>&1 | othercommand` ||- ||
|| ||`|&` (bash4) ||`command 2>&1 | othercommand` ||Conflicts with ksh. Not recommended, even in Bash. Just use `2>&1`. ||
||duplicate and close ||`m>&n
- m<&n-` ||`m>&n n>&-` ||not defined by POSIX ||
||herestring ||`<<<"string"` ||`echo | command`, or a here document to avoid a subshell (`<<EOF`) ||- ||

Line 81: Line 93:
 * `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`.
Line 82: Line 95:
 * `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. Also the `%q` format is not defined by posix.
 * `read` -- the only option defined by posix is `-r`; ksh has a different set of options that only partially overlaps 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`.
 * `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 [[https://github.com/stephane-chazelas/misc-scripts/blob/master/locvar.sh|there]].
Line 89: Line 104:
|| ||'''Works in bash''' ||'''Change to for dash''' ||'''Comment''' ||
||keep track of the times ||`SECONDS` ||`before=$(date +%s) ....seconds=$(( $(date +%s) - before))` ||`date +%s` is not POSIX; see [[BashFAQ/070|this faq for more info]]. Present in ksh and zsh ||
||Generate a random number ||`RANDOM` ||{{{random=$(awk 'BEGIN{srand(); printf "%d\n",(rand()*256)}')}}} gives a number between 0 and 256<<BR>> {{{random=$(hexdump -n 1 -e '/1 "%u"' /dev/urandom)}}} and {{{random=$(od -A n -N 1 -t u1 /dev/urandom)}}} give a timer-independent number between 0 and 256<<BR>> {{{random=$(hexdump -n 2 -e '/2 "%u"' /dev/urandom)}}} and {{{random=$(od -A n -N 2 -t u2 /dev/urandom)}}} give a timer-independent number between 0 and 65535 ||Be sure to learn what `srand()` and `rand()` do, ie this method fails if you call `awk` several times rapidly. Instead generate all the numbers you need inside `awk`. Some systems also provide /dev/random and /dev/urandom , but this is not specified by the POSIX standard. ksh and zsh have `RANDOM` ||
||Get the status of all the commands in a pipeline ||`PIPESTATUS` ||Simplest solution:<<BR>> {{{mkfifo fifo; command2 <fifo & command1 >fifo; echo "$?"}}}<<BR>> see NamedPipes ||bash-specific; see [[http://shell.cfajohnson.com/cus-faq-2.html#Q11|this faq]] ||
||Get the name of all / the current function name(s) ||`FUNCNAME` ||?? ||bash-specific see [[http://stackoverflow.com/questions/2630812/get-a-list-of-function-names-in-a-shell-script|stackoverflow question]] ||
Line 90: Line 110:
|| || '''Works in bash''' || '''Change to for dash''' || '''Comment''' ||
|| keep track of the times|| SECONDS || before=$(date +%s) ....seconds=$(( $(date +%s) - $before)) || date +%s is not posix; see [[BashFAQ/070|this faq for more info]]. Present in ksh||
|| Generate a random number|| RANDOM || {{{random=$(awk 'BEGIN{srand(); printf "%d\n",(rand*256)}'}}}) gives a number between 0 and 256 || Be sure to learn what srand() and rand() do, ie this method fails if you call awk several times rapidly. Instead generate all the numbers you need inside awk. Some systems also provides /dev/random and /dev/urandom. ksh has RANDOM ||
|| Get the status of all the commands in a pipeline|| PIPESTATUS || Simplest solution {{{mkfifo fifo; command2 <fifo & command1 >fifo; echo $?}}} see NamedPipes || bash-specific; see [[ http://shell.cfajohnson.com/cus-faq-2.html#Q11 | this faq ]] and this script [[http://pipestatus.sourceforge.net/ | pipe status for posix shell]] ||
Line 95: Line 111:
 
Line 97: Line 112:
 * [[http://www.gnu.org/software/bash/manual/html_node/Bash-POSIX-Mode.html#Bash-POSIX-Mode|The bash manual]] has a list of the differences between bash running in POSIX mode and a normal bash.<<BR>> '''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
 * [[http://www.etalabs.net/sh_tricks.html|Rich's sh tricks]] has some clever yet surprisingly powerful hacks for dealing with the limitations of the POSIX shell.
Line 98: Line 117:
 * [[ http://www.gnu.org/software/bash/manual/html_node/Bash-POSIX-Mode.html#Bash-POSIX-Mode | The bash manual]] has a list of the differences between bash running in posix mode and a normal bash.

Note that 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.

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

Works in bash

Change to for dash

Comment

defining functions

function f { echo hello world; }

f() { echo hello world; }

"function" is not defined by POSIX, only "name ()" is. The function f {...} syntax originated in ksh (and predates the Bourne syntax). In ksh both forms are present, but in the AT&T implementations, functions defined with "function" work slightly differently. zsh also supports both syntax without distinction.

case

;;& ;& etc

None. Duplicate the case (use a function to avoid code duplication, or an alias to let the shell expand the whole segment as it parses the script)

;;& ;& in bash4 is not defined by POSIX. AT&T ksh (since ksh88e, where it originated), MirBSD ksh (since R40) and zsh (since 3.1.2) have ;& but not ;;&

numeric C-like for loop

for ((i=0; i<3; i++)); do
 echo "$i"
done

i=0 ; while [ "$i" -lt 3 ]; do
 echo "$i" ; i=$((i+1))
done

This syntax is not defined by POSIX. Originated in ksh93; present in zsh.

expand sequences

echo $'hello\tworld'

printf "hello\tworld\n"

Historically $' ' was not defined by POSIX through 2008, but has been accepted for the next version. http://austingroupbugs.net/view.php?id=249. Originated in ksh93, also supported by zsh, mksh, FreeBSD and Busybox sh though with variations

extended glob

+( ) @( ) !( ) *( )

not always possible, sometimes you can use several globs, sometimes you can use find(1)

Not defined by POSIX. Originated in ksh; supported by zsh with an option like bash.

select

select

some ideas: implement the menu yourself, use a command like dialog

Not defined by POSIX. Originated in ksh; present in zsh.

file slurp

$(< file)

$(cat file)

Or read the file line by line.

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.\{0,$n\}\(.\{0,$l\}\)"). This originated in ksh93 and is also present in zsh, mksh and busybox sh.

  • ${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 variation in behaviour and glob pattern syntax between the three.

  • ${!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"

Conditionals

Works in bash

Change to for dash

Comment

simple test

[[

use [ and use double quotes around the expansions [ "$var" = "" ]

[[ is not defined by POSIX, originated in ksh and is also present in zsh

pattern matching

[[ foo = *glov ]]

use case or expr or grep

see BashFAQ/041

equality with test

==

use = instead

only = is defined by POSIX

compare lexicographically.

< >

no change

present in dash, ksh, yash and zsh, but not defined by POSIX. See note below for possible workarounds.

compare modification times

[[ file1 -nt file2 ]] or -ot

[ "$(find 'file1' -prune -newer 'file2')" ] or [ "file1" -nt "file2" ]

-prune is required to avoid recursion; present in dash, ksh, yash and zsh. -nt and -ot aren't specified by POSIX but are considered for addition in a future release.

check if 2 files are the same hardlink

[[ file1 -ef file2 ]]

[ "file1" -ef "file2" ]

-ef is not defined by POSIX (yet, same as above), but is present in ksh, yash, zsh and Dash.

(( ))

(( )) (without the $) acts like a command on its own

For simple comparison: [ -lt ] (and -ne -gt -ge). To assign a variable var=$((3+1)). For full functionality, use [ "$(( (i+=2) < 5 && a > 3))" -ne 0 ].

present in ksh (where it originated) and zsh

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.

Works in bash

Change to for dash

Comment

pre/post increment/decrement

++ --

i=$((i+1)) or : "$((i+=1))"

comma operator

,

: "$((...))"; cmd "$((...))"

The comma operator is widely supported by almost everything except dash and yash -- even posh and Busybox. In ksh93 however, it conflicts with the decimal radix in locales where it's used in floating points instead of period

exponentiation

**

** is the only bash arithmetic operator that is not a standard C or C++ operator. ksh93 can use pow(x, y). The ** operator is supported by at least bash, zsh, ksh93, and busybox, but not by dash or mksh.

let or ((...))

[ "$((...))" -ne 0 ]

Because of the above comma restriction, let can't be simulated exactly without a loop.

Redirections

Works in bash

Change to for dash

Comment

redirect both stdout and stderr

>& and &>

command > file 2>&1 or command 2>&1 | othercommand

-

|& (bash4)

command 2>&1 | othercommand

Conflicts with ksh. Not recommended, even in Bash. Just use 2>&1.

duplicate and close

m>&n- m<&n-

m>&n n>&-

not defined by POSIX

herestring

<<<"string"

echo | command, or a here document to avoid a subshell (<<EOF)

-

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

Works in bash

Change to for dash

Comment

keep track of the times

SECONDS

before=$(date +%s) ....seconds=$(( $(date +%s) - before))

date +%s is not POSIX; see this faq for more info. Present in ksh and zsh

Generate a random number

RANDOM

random=$(awk 'BEGIN{srand(); printf "%d\n",(rand()*256)}') gives a number between 0 and 256
random=$(hexdump -n 1 -e '/1 "%u"' /dev/urandom) and random=$(od -A n -N 1 -t u1 /dev/urandom) give a timer-independent number between 0 and 256
random=$(hexdump -n 2 -e '/2 "%u"' /dev/urandom) and random=$(od -A n -N 2 -t u2 /dev/urandom) give a timer-independent number between 0 and 65535

Be sure to learn what srand() and rand() do, ie this method fails if you call awk several times rapidly. Instead generate all the numbers you need inside awk. Some systems also provide /dev/random and /dev/urandom , but this is not specified by the POSIX standard. ksh and zsh have RANDOM

Get the status of all the commands in a pipeline

PIPESTATUS

Simplest solution:
mkfifo fifo; command2 <fifo & command1 >fifo; echo "$?"
see NamedPipes

bash-specific; see this faq

Get the name of all / the current function name(s)

FUNCNAME

??

bash-specific see stackoverflow question

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

Bashism (last edited 2022-10-20 23:13:29 by larryv)