Use triple backticks rather than indenting for code.

SC1000.md

@@ -2,11 +2,15 @@
 
 ### Problematic code:
 
+```sh
 echo "$"
+```
 
 ### Correct code:
 
+```sh
 echo "\$"
+```
 
 ### Rationale:
 `$` is special in double quotes, but there are some cases where it's interpreted literally:

SC1001.md

@@ -2,19 +2,27 @@
 
 ### Problematic code:
 
+```sh
 echo Yay \o/
+```
 
 or
 
+```sh
 \git status
+```
 
 ### Correct code:
 
+```sh
 echo 'Yay \o/'
+```
 
 or
 
+```sh
 command git status
+```
 
 ### Rationale:
 

SC1007.md

@@ -2,19 +2,27 @@
 
 ### Problematic code:
 
+```sh
 # I want programs to show text in dutch!
 LANGUAGE= nl
+```
 
+```sh
 # I want to run the nl command with English error messages!
 LANGUAGE= nl
+```
 
 ### Correct code:
 
+```sh
 # I want programs to show text in dutch!
 LANGUAGE=nl
+```
 
+```sh
 # I want to run the nl command with English error messages!
 LANGUAGE='' nl
+```
 
 ### Rationale:
 

SC1015.md

@@ -2,11 +2,15 @@
 
 ### Problematic code:
 
+```sh
 echo “hello world”
+```
 
 ### Correct code:
 
+```sh
 echo "hello world"
+```
 
 ### Rationale:
 

SC1016.md

@@ -2,11 +2,15 @@
 
 ### Problematic code:
 
+```sh
 echo ‘hello world’
+```
 
 ### Correct code:
 
+```sh
 echo 'hello world'
+```
 
 ### Rationale:
 

SC1037.md

@@ -2,13 +2,17 @@
 
 ### Problematic code:
 
+```sh
 echo "Ninth parameter: $9"
 echo "Tenth parameter: $10"
+```
 
 ### Correct code:
 
+```sh
 echo "Ninth parameter: $9"
 echo "Tenth parameter: ${10}"
+```
 
 ### Rationale:
 

SC1038.md

@@ -2,17 +2,21 @@
 
 ### Problematic code:
 
+```sh
 while IFS= read -r line
 do
   printf "%q\n" "$line"
 done <<(curl -s http://example.com)
+```
 
 ### Correct code:
 
+```sh
 while IFS= read -r line
 do
   printf "%q\n" "$line"
 done <  <(curl -s http://example.com)
+```
 
 ### Rationale:
 

SC1040.md

@@ -4,23 +4,29 @@
 
 Any code using `<<-` that is indented with spaces. `cat -T script` shows
 
+```sh
     cat <<- foo
         Hello world
     foo
+```
 
 ### Correct code:
 
 Code using `<<-` must be indented with tabs. `cat -T script` shows
 
+```sh
 ^Icat <<- foo
 ^I^IHello world
 ^Ifoo
+```
 
 Or simply don't indent the end token:
 
+```sh
     cat <<- foo
       Hello World
 foo
+```
 
 ### Rationale:
 

SC1045.md

@@ -2,11 +2,15 @@
 
 ### Problematic code:
 
+```sh
 foo &; bar
+```
 
 ### Correct code:
 
+```sh
 foo & bar
+```
 
 ### Rationale:
 

SC1065.md

@@ -2,17 +2,21 @@
 
 ### Problematic code:
 
+```sh
 foo(input) {
   echo "$input"
 }
 foo("hello world");
+```
 
 ### Correct code:
 
+```sh
 foo() {
   echo "$1"
 }
 foo "hello world"
+```
 
 ### Rationale:
 

SC1066.md

@@ -2,17 +2,23 @@
 
 ### Problematic code:
 
+```sh
 $greeting="Hello World"
+```
 
 ### Correct code:
 
+```sh
 greeting="Hello World"
+```
 
 Alternatively, if the goal was to assign to a variable whose name is in another variable (indirection), use `declare`:
 
+```sh
 name=foo
 declare "$name=hello world"
 echo "$foo"
+```
 
 ### Rationale:
 

SC1068.md

@@ -2,11 +2,15 @@
 
 ### Problematic code:
 
+```sh
 foo = 42
+```
 
 ### Correct code:
 
+```sh
 foo=42
+```
 
 ### Rationale:
 

SC1077.md

@@ -3,12 +3,16 @@
 
 ### Problematic code:
 
+```sh
 echo "Your username is ´whoami´"
+```
 
 ### Correct code:
 
+```sh
 echo "Your username is $(whoami)" # Preferred
 echo "Your username is `whoami`"  # Deprecated, will give [SC2006]
+```
 
 ### Rationale:
 
@@ -20,10 +24,14 @@ Backticks start command expansions, while forward ticks are literal. To help spo
 
 If you want to write out literal forward ticks, such as fancyful ascii quotation marks:
 
+```sh
 echo "``Proprietary software is an injustice.´´  - Richard Stallman"
+```
 
 use single quotes instead:
 
+```sh
 echo '``Proprietary software is an injustice.´´  - Richard Stallman'
+```
 
 To nest forward ticks in command expansion, use `$(..)` instead of `` `..` ``.

SC1078.md

@@ -2,13 +2,17 @@
 
 ### Problematic code:
 
+```sh
 greeting="hello
 target="world"
+```
 
 ### Correct code:
 
+```sh
 greeting="hello"
 target="world"
+```
 
 ### Rationale:
 
@@ -20,12 +24,16 @@ ShellCheck warns when it detects multi-line double quoted, single quoted or back
 
 If you do want a multiline variable, just make sure the character after it is a quote, space or line feed.
 
+```sh
 var='multiline
 'value
+```
 
 can be rewritten for readability and to remove the warning:
 
+```sh
 var='multiline
 value'
+```
 
 As always `` `..` `` should be rewritten to ``$(..)``.

SC1081.md

@@ -2,17 +2,21 @@
 
 ### Problematic code:
 
+```sh
 If true
 Then
   echo "hello"
 Fi
+```
 
 ### Correct code:
 
+```sh
 if true
 then
   echo "hello"
 fi
+```
 
 ### Rationale:
 

SC1083.md

@@ -2,18 +2,25 @@
 
 ### Problematic code:
 
+```sh
 rmf() { rm -f "$@" }
+```
 
 or
 
+```sh
 eval echo \${foo}
+```
 
 ### Correct code:
 
+```sh
 rmf() { rm -f "$@"; }
+```
 
 and
 
+```sh
 eval "echo \${foo}"
 ### Rationale:
 
@@ -30,3 +37,4 @@ ShellCheck does not warn about `{}`, since this is frequently used with `find` a
 ### Exceptions
 
 This error is harmless when the curly brackets are supposed to be literal, in e.g. `awk {'print $1'}`. However, it's cleaner and less error prone to simply include them inside the quotes: `awk '{print $1}'`.
+```

SC1084.md

@@ -2,13 +2,17 @@
 
 ### Problematic code:
 
+```sh
 !#/bin/sh
 echo "Hello World"
+```
 
 ### Correct code:
 
+```sh
 #!/bin/sh
 echo "Hello World"
+```
 
 ### Rationale:
 

SC1086.md

@@ -2,17 +2,21 @@
 
 ### Problematic code:
 
+```sh
 for $var in *
 do
   echo "$var"
 done
+```
 
 ### Correct code:
 
+```sh
 for var in *
 do
   echo "$var"
 done
+```
 
 ### Rationale:
 

SC1087.md

@@ -2,11 +2,15 @@
 
 ### Problematic code:
 
+```sh
 echo "$array[@]"
+```
 
 ### Correct code:
 
+```sh
 echo "${array[@]}"
+```
 
 ### Rationale:
 

SC1088.md

@@ -2,19 +2,27 @@
 
 ### Problematic code:
 
+```sh
 grep ^(.*)\1$ file
+```
 
 or
 
+```sh
 var = myfunction(value)
+```
 
 ### Correct code:
 
+```sh
 grep '^(.*)\1$' file
+```
 
 or
 
+```sh
 var=$(myfunction value)
+```
 
 ### Rationale:
 

SC1089.md

@@ -2,18 +2,22 @@
 
 ### Problematic code:
 
+```sh
 if true
 then
   echo hello
 fi
 fi
+```
 
 ### Correct code:
 
+```sh
 if true
 then
   echo hello
 fi
+```
 
 ### Rationale:
 
@@ -21,11 +25,13 @@ This error is typically seen when there are too many `fi`, `done` or `esac`s, or
 
 In some cases, it can even be caused by bad quoting:
 
+```sh
 var="foo
 if [[ $var = "bar ]
 then
   echo true
 fi
+```
 
 In this case, the `if` ends up inside the double quotes, leaving the `then` dangling.
 

SC1090.md

@@ -2,12 +2,16 @@
 
 ### Problematic code:
 
+```sh
 . "$(find_install_dir)/lib.sh"
+```
 
 ### Correct code:
 
+```sh
 # shellcheck source=src/lib.sh
 . "$(find_install_dir)/lib.sh"
+```
 
 ### Rationale:
 

SC1091.md

@@ -4,12 +4,16 @@ Reasons include: file not found, no permissions, not included on the command lin
 
 ### Problematic code:
 
+```sh
 source somefile
+```
 
 ### Correct code:
 
+```sh
 # shellcheck disable=SC1091
 source somefile
+```
 
 ### Rationale:
 

SC1094.md

@@ -2,12 +2,16 @@
 
 ### Problematic code:
 
+```sh
 source mylib
+```
 
 ### Correct code:
 
+```sh
 # shellcheck disable=SC1094
 source mylib
+```
 
 (or fix `mylib`)
 

SC1097.md

@@ -2,17 +2,23 @@
 
 ### Problematic code:
 
+```sh
 var==value
+```
 
 ### Correct code:
 
 Assignment:
 
+```sh
 var=value
+```
 
 Comparison:
 
+```sh
 [ "$var" = value ]
+```
 
 ### Rationale:
 
@@ -26,4 +32,6 @@ ShellCheck has noticed that you're using `==` in an unexpected way. The two most
 
 If you wanted to assign a literal equals sign, use quotes to make this clear:
 
+```sh
 var="=sum(A1:A10)"
+```

SC1098.md

@@ -2,11 +2,15 @@
 
 ### Problematic code:
 
+```sh
 eval $var=(a b)
+```
 
 ### Correct code:
 
+```sh
 eval "$var=(a b)"
+```
 
 ### Rationale:
 

SC1099.md

@@ -2,17 +2,21 @@
 
 ### Problematic code:
 
+```sh
 while sleep 1
 do# show time
   date
 done
+```
 
 ### Correct code:
 
+```sh
 while sleep 1
 do # show time
   date
 done
+```
 
 ### Rationale:
 

SC2001.md

@@ -2,11 +2,15 @@
 
 ### Problematic code:
 
+```sh
 string="stirng" ; echo "$string" | sed -e "s/ir/ri/"
+```
 
 ### Correct code:
 
+```sh
 string="stirng" ; echo "${string//ir/ri}"
+```
 
 ### Rationale:
 
@@ -16,6 +20,8 @@ Let's assume somewhere earlier in your code you have put data into a variable (E
 
 Occasionally a more complex sed substitution is required. For example, getting the last character of a string.
 
+```sh
 string="stirng" ; echo "$string" | sed -e "s/^.*\(.\)$/\1/"
+```
 
 This is a bit simple for the example and there are alternative ways of doing this in the shell, but this SC2001 flags on several of my crazy complex sed commands which are beyond the scope of this example. Utilizing some of the more complex capabilities of sed is required occasionally and it is safe to ignore SC2001.

SC2003.md

@@ -2,13 +2,17 @@
 
 ### Problematic code:
 
+```sh
 i=$(expr 1 + 2)
 l=$(expr length "$var")
+```
 
 ### Correct code:
 
+```sh
 i=$((1+2))
 l=${#var}
+```
 
 ### Rationale:
 

SC2004.md

@@ -2,20 +2,26 @@
 
 ### Problematic code:
 
+```sh
 echo $(($n+1))
+```
 
 ### Correct code:
 
+```sh
 echo $((n+1))
+```
 
 ### Rationale:
 
 The `$` on regular variables in arithmetic contexts is unnecessary, and can even lead to subtle bugs. This is because the contents of `$((..))` is first expanded into a string, and then evaluated as an expression:
 
+```sh
 $ a='1+1'
 $ echo $(($a * 5))    # becomes 1+1*5
 6
 $ echo $((a * 5))     # evaluates as (1+1)*5
 10
+```
 
 The `$` is unavoidable for special variables like `$1` vs `1`, `$#` vs `#`. ShellCheck does not warn about these cases.

SC2006.md

@@ -2,11 +2,15 @@
 
 ### Problematic code
 
+```sh
 echo "Current time: `date`"
+```
 
 ### Correct code
 
+```sh
 echo "Current time: $(date)"
+```
 
 ### Rationale
 

SC2008.md

@@ -2,11 +2,15 @@
 
 ### Problematic code:
 
+```sh
 find . | echo
+```
 
 ### Correct code:
 
+```sh
 find .
+```
 
 ### Rationale:
 

SC2009.md

@@ -2,11 +2,15 @@
 
 ### Problematic Code:
 
+```sh
 ps ax | grep -v grep | grep "$service" > /dev/null
+```
 
 ### Correct Code:
 
+```sh
 pgrep -f "$service" > /dev/null
+```
 
 ### Rationale:
 
@@ -16,11 +20,15 @@ If you are just after a pid from a running program, then pgrep is a much safer a
 
 What if you have the pid and you are looking for the matching program name?
 
+```sh
 pid=123; ps ax | grep "$pid"
+```
 
 What if you want a range of the ps field, like from the 16th space to the end of the line?
 
+```sh
 ps ax | grep "$pid" | cut -d" " -f16-
+```
 
 Both are valid cases where SC2009 is not valid.
 

SC2012.md

@@ -2,11 +2,15 @@
 
 ### Problematic code:
 
+```sh
 ls -l | grep " $USER " | grep '\.txt$'
+```
 
 ### Correct code:
 
+```sh
 find . -maxdepth 1 -name '*.txt' -user "$USER"
+```
 
 ### Rationale:
 
@@ -14,11 +18,13 @@
 
 Here's an example:
 
+```sh
 $ ls -l
 total 0
 -rw-r----- 1 me me 0 Feb  5 20:11 foo?bar
 -rw-r----- 1 me me 0 Feb  5  2011 foo?bar
 -rw-r----- 1 me me 0 Feb  5 20:11 foo?bar
+```
 
 It shows three seemingly identical filenames, and did you spot the time format change? How it formats and what it redacts can differ between locale settings, `ls` version, and whether output is a tty.
 

SC2013.md

@@ -2,24 +2,30 @@
 
 ### Problematic code:
 
+```sh
 for line in $(cat file | grep -v '^ *#')
 do
   echo "Line: $line"
 done
+```
 
 ### Correct code:
 
+```sh
 grep -v '^ *#' < file | while IFS= read -r line
 do
   echo "Line: $line"
 done
+```
 
 or without a subshell (bash, zsh, ksh):
 
+```sh
 while IFS= read -r line
 do
   echo "Line: $line"
 done < <(grep -v '^ *#' < file)
+```
 
 ### Rationale:
 
@@ -27,20 +33,26 @@ For loops by default (subject to `$IFS`) read word by word. Additionally, glob e
 
 Given this text file:
 
+```sh
 foo *
 bar
+```
 
 The for loop will print:
 
+```sh
 Line: foo
 Line: aardwark.jpg
 Line: bullfrog.jpg
 ...
+```
 
 The while loop will print:
 
+```sh
 Line: foo *
 Line: bar
+```
 
 
 ### Exceptions

SC2014.md

@@ -2,11 +2,15 @@
 
 ### Problematic code:
 
+```sh
 find . -name '*.tar' -exec tar xf {} -C "$(dirname {})" \;
+```
 
 ### Correct code:
 
+```sh
 find . -name '*.tar' -exec sh -c 'tar xf "$1" -C "$(dirname "$1")"' _ {} \;
+```
 
 ### Rationale:
 
@@ -14,8 +18,10 @@ Bash evaluates any command substitutions before the command they feature in is e
 
 To run shell code for each file, we can write a tiny script and inline it with `sh -c`. We add `_` as a dummy argument that becomes `$0`, and a filename argument that becomes `$1` in the inlined script:
 
+```sh
 $ sh -c 'echo "$1 is in $(dirname "$1")"' _ "mydir/myfile"
 mydir/myfile is in mydir
+```
 
 This command can be executed by `find -exec`, with `{}` as the filename argument. It executes shell which interprets the inlined script once for each file. Note that the inlined script is single quoted, again to ensure that the expansion does not happen prematurely .
 

SC2015.md

@@ -2,16 +2,20 @@
 
 ### Problematic code:
 
+```sh
 [[ $dryrun ]] && echo "Would delete file" || rm file
+```
 
 ### Correct code:
 
+```sh
 if [[ $dryrun ]]
 then
   echo "Would delete file"
 else
   rm file
 fi
+```
 
 ### Rationale:
 

SC2016.md

@@ -2,13 +2,17 @@
 
 ### Problematic code:
 
+```sh
 name=World
 echo 'Hello $name'
+```
 
 ### Correct code:
 
+```sh
 name=World
 echo "Hello $name"
+```
 
 ### Rationale:
 
@@ -18,7 +22,9 @@ If you want to use the values of variables and such, use double quotes instead.
 
 Note that if you have other items that needs single quoting, you can use both in a single word:
 
+```sh
 echo '$1 USD is '"$rate GBP"
+```
 
 ### Exceptions
 

SC2017.md

@@ -2,11 +2,15 @@
 
 ### Problematic code:
 
+```sh
 percent=$((count/total*100))
+```
 
 ### Correct code:
 
+```sh
 percent=$((count*100/total))
+```
 
 ### Rationale:
 

SC2020.md

@@ -2,11 +2,15 @@
 
 ### Problematic code:
 
+```sh
 echo 'hello world' | tr 'hello' 'goodbye'
+```
 
 ### Correct code:
 
+```sh
 echo 'hello world' | sed -e 's/hello/goodbye/g'
+```
 
 ### Rationale:
 

SC2022.md

@@ -1,13 +1,17 @@
 # Note that unlike globs, o* here matches 'ooo' but not 'oscar'
 ### Problematic code:
 
+```sh
 grep 'foo*'
+```
 
 when wanting to match `food` and `foosball`, but not `mofo` or `keyfob`.
 
 ### Correct code:
 
+```sh
 grep '^foo'
+```
 
 ### Rationale:
 

SC2025.md

@@ -2,11 +2,15 @@
 
 ### Problematic code:
 
+```sh
 PS1='\e[36m\$ \e(B\e[m'
+```
 
 ### Correct code:
 
+```sh
 PS1='\[\e[36m\]\$ \[\e(B\e[m\]'
+```
 
 ### Rationale:
 

SC2026.md

@@ -2,33 +2,43 @@
 
 ### Problematic code:
 
+```sh
 alias server_uptime='ssh $host 'uptime -p''
+```
 
 ### Correct code:
 
+```sh
 alias server_uptime='ssh $host '"'uptime -p'"
+```
 
 ### Rationale:
 
 In the first case, the user has four single quotes on a line, wishfully hoping that the shell will match them up as outer quotes around a string with literal single quotes:
 
+```sh
 #                   v--------match--------v
 alias server_uptime='ssh $host 'uptime -p''
 #                              ^--match--^
+```
 
 The shell, meanwhile, always terminates single quoted strings at the first possible single quote:
 
+```sh
 #                   v---match--v
 alias server_uptime='ssh $host 'uptime -p''
 #                                        ^^
+```
 
 Which is the same thing as `alias server_uptime='ssh $host uptime' -p`.
 
 There is no way to nest single quotes. However, single quotes can be placed literally in double quotes, so we can instead concatenate a single quoted string and a double quoted string:
 
+```sh
 #                   v--match---v
 alias server_uptime='ssh $host '"'uptime -p'"
 #                               ^---match---^
+```
 
 This results in an alias with embedded single quotes.
 

SC2027.md

@@ -2,11 +2,15 @@
 
 ### Problematic code:
 
+```sh
 echo "You enter "$HOSTNAME". You can smell the wumpus." >> /etc/issue
+```
 
 ### Correct code:
 
+```sh
 echo "You enter $HOSTNAME. You can smell the wumpus." >> /etc/issue
+```
 
 ### Rationale:
 
@@ -14,9 +18,11 @@ Always quoting variables and command expansions is good practice, but blindly pu
 
 In this case, ShellCheck has noticed that the quotes around the expansion are unquoting it, because the left quote is terminating an existing double quoted string, while the right quote starts a new one:
 
+```sh
 echo "You enter "$HOSTNAME". You can smell the wumpus."
      |----------|         |---------------------------|
         Quoted   No quotes           Quoted
+```
 
 If the quotes were supposed to be literal, they should be escaped. If the quotes were supposed to quote an expansion (as in the example), they should be removed because this is already a double quoted string.
 

SC2028.md

@@ -2,11 +2,15 @@
 
 ### Problematic code:
 
+```sh
 echo "Name:\t$value"
+```
 
 ### Correct code:
 
+```sh
 printf "Name:\t%s\n" "$value"
+```
 
 ### Rationale:
 
@@ -18,7 +22,9 @@ Other, non-portable methods include `echo -e '\t'` and `echo $'\t'`. ShellCheck
 
 If you actually wanted a literal backslash-t, use
 
+```sh
 echo "\\t"
+```
 
 ### Exceptions
 

SC2029.md

@@ -2,21 +2,29 @@
 
 ### Problematic code:
 
+```sh
 ssh host "echo $HOSTNAME"
+```
 
 ### Correct code:
 
+```sh
 ssh host "echo \$HOSTNAME"
+```
 
 or
 
+```sh
 ssh host 'echo $HOSTNAME'
+```
 
 ### Rationale:
 
 Bash expands all arguments that are not escaped/singlequoted. This means that the problematic code is identical to
 
+```sh
 ssh host "echo clienthostname"
+```
 
 and will print out the client's hostname, not the server's hostname.
 

SC2031.md

@@ -29,33 +29,45 @@ Here are some constructs that cause subshells (shellcheck may not warn about all
 
 Pipelines:
 
+```sh
 subshell1 | subshell2 | subshell3    # Bash, Dash, Ash
 subshell1 | subshell2 | regular      # Ksh, Zsh
+```
 
 Command substitution:
 
+```sh
 regular "$(subshell1)" "`subshell2`"
+```
 
 Process substitution:
 
+```sh
 regular <(subshell1) >(subshell2)
+```
 
 Some forms of grouping:
 
+```sh
 ( subshell )
 { regular; }
+```
 
 Backgrounding:
 
+```sh
 subshell1 &
 subshell2 &
+```
 
 Anything executed by external processes:
 
+```sh
 find . -exec subshell1 {} \;
 find . -print0 | xargs -0 subshell2
 sudo subshell3
 su -c subshell4
+```
 
 This applies not only to setting variables, but also setting shell options and changing directories.
 

SC2033.md

@@ -2,12 +2,16 @@
 
 ### Problematic code:
 
+```sh
 foo() { bar --baz "$@"; frob --baz "$@"; };
 find . -exec foo {} +
+```
 
 ### Correct code:
 
+```sh
 find . -exec sh -c 'bar --baz "$@"; frob --baz "$@";' -- {} +
+```
 
 ### Rationale:
 
@@ -19,7 +23,9 @@ Instead, the function contents can be executed in a shell, either through `sh -c
 
 If you're intentionally passing a word that happens to have the same name as a declared function, you can quote it to make shellcheck ignore it, e.g.
 
+```sh
 nobody() {
   sudo -u "nobody" "$@"
 }
 
+```

SC2034.md

@@ -2,13 +2,17 @@
 
 ### Problematic code:
 
+```sh
 foo=42
 echo "$FOO"
+```
 
 ### Correct code:
 
+```sh
 foo=42
 echo "$foo"
+```
 
 ### Rationale:
 
@@ -22,20 +26,26 @@ ShellCheck may not always realize that the variable is in use (especially with i
 
 For throwaway variables, consider using `_` as a dummy:
 
+```sh
 read _ last _ zip _ _ <<< "$str"
 echo "$last, $zip"
+```
 
 or use a directive to disable the warning:
 
+```sh
 # shellcheck disable=SC2034
 read first last email zip lat lng <<< "$str"
 echo "$last, $zip"
+```
 
 For indirection, there's not much you can do without rewriting to use arrays or similar:
 
+```sh
 bar=42  # will always appear unused
 foo=bar
 echo "${!foo}"
+```
 
 This is expected behavior, and not a bug. There is no good way to statically analyze indirection in shell scripts, just like static C analyzers have a hard time preventing segfaults.
 

SC2036.md

@@ -2,11 +2,15 @@
 
 ### Problematic code:
 
+```sh
 sum=find | wc -l
+```
 
 ### Correct code:
 
+```sh
 sum=$(find | wc -l)
+```
 
 ### Rationale:
 

SC2038.md

@@ -2,11 +2,15 @@
 
 ### Problematic code:
 
+```sh
 find . -type f | xargs md5sum
+```
 
 ### Correct code:
 
+```sh
 find . -type f -print0 | xargs -0 md5sum
+```
 
 ### Rationale:
 

SC2041.md

@@ -2,17 +2,21 @@
 
 ### Problematic code:
 
+```sh
 for i in 'seq 1 10'
 do
   echo "$i"
 done
+```
 
 ### Correct code:
 
+```sh
 for i in $(seq 1 10)
 do
   echo "$i"
 done
+```
 
 ### Rationale:
 

SC2043.md

@@ -2,10 +2,12 @@
 
 ### Problematic code:
 
+```sh
 for var in value
 do
   echo "$var"
 done
+```
 
 ### Correct code:
 
@@ -13,19 +15,27 @@ Correct code depends on what you want to do.
 
 To iterate over files in a directory, instead of `for var in /my/dir` use:
 
+```sh
 for var in /my/dir/* ; do echo "$var"; done
+```
 
 To iterate over lines in a file or command output, use a while read loop instead:
 
+```sh
 mycommand | while IFS= read -r line; do echo "$line"; done
+```
 
 To iterate over *words* written to a command or function's stdout, instead of `for var in myfunction`, use
 
+```sh
 for var in $(myfunction); do echo "$var"; done
+```
 
 To iterate over *words* in a variable, instead of  `for var in myvariable`, use
 
+```sh
 for var in $myvariable; do echo "$var"; done
+```
 
 
 

SC2044.md

@@ -2,6 +2,7 @@
 
 ### Problematic code:
 
+```sh
 for file in $(find mydir -mtime -7 -name '*.mp3')
 do
   let count++
@@ -9,6 +10,7 @@
   play "$file"
 done
 echo "Played $count files"
+```
 
 This will fail for filenames containing spaces and similar, such as `My File.mp3`, and has a series of potential globbing issues depending on other filenames in the directory like (if you have `MyFile2.mp3` and `MyFile[2014].mp3`, the former file will play twice and the latter will not play at all).
 
@@ -18,6 +20,7 @@ There are many possible fixes, each with its pros and cons.
 
 The most general fix (that requires the least amount of thinking to apply) is having `find` output a `\0` separated list of files and consuming them in a `while read` loop:
 
+```sh
 while IFS= read -r -d '' file
 do
   let count++
@@ -25,6 +28,7 @@ The most general fix (that requires the least amount of thinking to apply) is ha
   play "$file"
 done <   <(find mydir -mtime -7 -name '*.mp3' -print0)
 echo "Played $count files"
+```
 
 In usage it's very similar to the `for` loop: it gets its output from a `find` statement, it executes a shell script body, it allows updating/aggregating variables, and the variables are available when the loop ends.
 
@@ -34,6 +38,7 @@ It requires Bash, and works with GNU, Busybox, OS X, FreeBSD and OpenBSD find, b
 
 If you don't need `find` logic like `-mtime -7` and just use it to match globs recursively (all `*.mp3` files under a directory), you can instead use `globstar` and `nullglob` instead of `find`, and still use a `for` loop:
 
+```sh
 shopt -s globstar nullglob
 for file in mydir/**/*.mp3
 do
@@ -42,6 +47,7 @@ If you don't need `find` logic like `-mtime -7` and just use it to match globs r
   play "$file"
 done
 echo "Played $count files"
+```
 
 This is bash specific.
 
@@ -50,6 +56,7 @@ This is bash specific.
 
 If you need POSIX compliance, this is a fair approach:
 
+```sh
 find mydir ! -name "$(printf "*\n*")" -name '*.mp3' > tmp
 while IFS= read -r file
 do
@@ -59,6 +66,7 @@ If you need POSIX compliance, this is a fair approach:
 done < tmp
 rm tmp
 echo "Played $count files"
+```
 
 The only problem is for filenames containing line feeds. A `! -name "$(printf "*\n*")"` has been added to simply skip these files, just in case there are any.
 
@@ -68,8 +76,10 @@ If you don't need variables to be available after the loop (here, if you don't n
 
 If you don't need a shell script loop body or any form of variable  like if we only wanted to play the file, we can dramatically simplify while maintaining POSIX compatibility:
 
+```sh
 # Simple and POSIX
 find mydir -name '*.mp3' -exec play {} \;
+```
 
 This does not allow things like `let counter++` because `let` is a shell builtin, not an external command.
 
@@ -77,10 +87,12 @@ This does not allow things like `let counter++` because `let` is a shell builtin
 
 If we do need a shell script body but no aggregation, you can do the above but invoking `sh` (this is still POSIX):
 
+```sh
 find mydir -name '*.mp3' -exec sh -c '
     echo "Playing ${1%.mp3}"
     play "$1"
   ' sh {} \;
+```
 
 This would not be possible without `sh`, because `${1%.mp3}` is a shell construct that `find` can't evaluate by itself. If we had tried to `let counter++` in this loop, we would have found that the value never changes.
 

SC2048.md

@@ -2,11 +2,15 @@
 
 ### Problematic code:
 
+```sh
 cp $* ~/dir
+```
 
 ### Correct code:
 
+```sh
 cp "$@" ~/dir
+```
 
 ### Rationale:
 

SC2055.md

@@ -2,17 +2,21 @@
 
 ### Problematic code:
 
+```sh
 if [[ $1 != foo || $1 != bar ]]
 then
   echo "$1 is not foo or bar"
 fi
+```
 
 ### Correct code:
 
+```sh
 if [[ $1 != foo && $1 != bar ]]
 then
   echo "$1 is not foo or bar"
 fi
+```
 
 ### Rationale:
 

SC2059.md

@@ -2,19 +2,25 @@
 
 ### Problematic code:
 
+```sh
 printf "Hello, $NAME\n"
+```
 
 ### Correct code:
 
+```sh
 printf "Hello, %s\n" "$NAME"
+```
 
 ### Rationale:
 
 `printf` interprets escape sequences and format specifiers in the format string. If variables are included, any escape sequences or format specifiers in the data will be interpreted too, when you most likely wanted to treat it as data. Example:
 
+```sh
 coverage='96%'
 printf "Unit test coverage: %s\n" "$coverage"
 printf "Unit test coverage: $coverage\n"
+```
 
 The first printf writes `Unit test coverage: 96%`.
 
@@ -24,7 +30,9 @@ The second writes ``bash: printf: `\': invalid format character``
 
 Sometimes you may actually want to interpret data as a format string, like in:
 
+```sh
 hexToAscii() { printf "\x$1"; }
 hexToAscii 21
+```
 
 Like all warnings, you can selectively silence this warning with a [directive](Directive).

SC2060.md

@@ -2,11 +2,15 @@
 
 ### Problematic code:
 
+```sh
 tr -cd [:digit:]
+```
 
 ### Correct code:
 
+```sh
 tr -cd '[:digit:]'
+```
 
 ### Rationale:
 

SC2063.md

@@ -2,11 +2,15 @@
 
 ### Problematic code:
 
+```sh
 grep '*foo*'
+```
 
 ### Correct code:
 
+```sh
 grep 'foo'   # or more explicitly,  grep '.*foo.*'
+```
 
 ### Rationale:
 

SC2064.md

@@ -2,11 +2,15 @@
 
 ### Problematic code:
 
+```sh
 trap "echo \"Finished on $(date)\"" EXIT
+```
 
 ### Correct code:
 
+```sh
 trap 'echo "Finished on $(date)"' EXIT
+```
 
 ### Rationale:
 

SC2066.md

@@ -2,30 +2,40 @@
 
 ### Problematic code:
 
+```sh
 for s in "$(mycommand)"; do echo "$s"; done
+```
 
 ### Correct code:
 
 The correct code depends on your intention. Let's say you're in a directory with the files `file.png` and `My cat.png`, and you want to loop over a command that outputs (or variable that contains):
 
+```sh
 hello world
 My *.png
+```
 
 #### Loop over each line without globbing (`hello world`, `My *.png`)
 
+```sh
 mycommand | while IFS= read -r s; do echo "$s"; done
+```
 
 #### Loop over each word with globbing (`hello`, `world`, `My`, `file.png`, `My cat.png`):
 
+```sh
 # relies on the fact that IFS by default contains space-tab-linefeed
 for s in $(mycommand); do echo "$s"; done
+```
 
 #### Loop over each line with globbing (`hello world`, `My cat.png`)
 
+```sh
 # explicitly set IFS to contain only a line feed
 IFS='
 '
 for s in $(mycommand); do echo "$s"; done
+```
 
 ### Rationale:
 

SC2067.md

@@ -2,13 +2,17 @@
 
 ### Problematic code:
 
+```sh
 find . -type f -exec shellcheck {} | wc -l \;
 find . -exec echo {} ;
+```
 
 ### Correct code:
 
+```sh
 find . -type f -exec sh -c 'shellcheck "$1" | wc -l' -- {} \;
 find . -exec echo {} \;
+```
 
 ### Rationale:
 
@@ -18,11 +22,15 @@
 
 To instead go through each file and run `foo file && bar file` on it, invoke a shell that can interpret `&&`:
 
+```sh
 find . -exec sh 'foo "$1" && bar "$1"' -- {} \;
+```
 
 You can also use find `-a` instead of shell `&&`:
 
+```sh
 find . -exec foo {} \; -a -exec bar {} \;
+```
 
 This will have the same effect (`-a` is also the default when two commands are specified, and can therefore be omitted).
 

SC2068.md

@@ -2,11 +2,15 @@
 
 ### Problematic code:
 
+```sh
 cp $@ ~/dir
+```
 
 ### Correct code:
 
+```sh
 cp "$@" ~/dir
+```
 
 ### Rationale:
 

SC2069.md

@@ -2,11 +2,15 @@
 
 ### Problematic code:
 
+```sh
 firefox 2>&1 > /dev/null
+```
 
 ### Correct code:
 
+```sh
 firefox > /dev/null 2>&1
+```
 
 ### Rationale:
 

SC2070.md

@@ -2,40 +2,48 @@
 
 ### Problematic code:
 
+```sh
 if [ -n $var ]
 then
   echo "var has a value"
 else
   echo "var is empty"
 fi
+```
 
 ### Correct code:
 
 In bash/ksh:
 
+```sh
 if [[ -n $var ]]
 then
   echo "var has a value"
 else
   echo "var is empty"
 fi
+```
 
 In POSIX:
 
+```sh
 if [ -n "$var" ]
 then
   echo "var has a value"
 else
   echo "var is empty"
 fi
+```
 
 
 ### Rationale:
 
 When `$var` is unquoted, a blank value will cause it to wordsplit and disappear. If `$var` is empty, these two statements are identical:
 
+```sh
 [ -n $var ]
 [ -n ]
+```
 
 `[ string ]` is shorthand for testing if a string is empty. This is still true if `string` happens to be `-n`. `[ -n ]` is therefore true, and by extension so is `[ -n $var ]`.
 

SC2072.md

@@ -2,12 +2,16 @@
 
 ### Problematic code:
 
+```sh
 [[ 2 -lt 3.14 ]]
+```
 
 ### Correct code:
 
+```sh
 [[ 200 -lt 314 ]]                   # Use fixed point math
 [[ $(echo "2 < 3.14" | bc) == 1 ]]  # Use bc
+```
 
 ### Rationale:
 

SC2076.md

@@ -2,11 +2,15 @@
 
 ### Problematic code:
 
+```sh
 [[ $foo =~ "^fo+bar$" ]]
+```
 
 ### Correct code:
 
+```sh
 [[ $foo =~ ^fo+bar$ ]]
+```
 
 ### Rationale:
 

SC2077.md

@@ -2,11 +2,15 @@
 
 ### Problematic code:
 
+```sh
 [[ 0=1 ]]
+```
 
 ### Correct code:
 
+```sh
 [[ 0 = 1 ]]
+```
 
 ### Rationale:
 

SC2082.md

@@ -2,35 +2,43 @@
 
 ### Problematic code:
 
+```sh
 var_1="hello world"
 n=1
 echo "${var_$n}"
+```
 
 ### Correct code:
 
 Bash/ksh:
 
+```sh
 # Use arrays instead of dynamic names
 declare -a var
 var[1]="hello world"
 n=1
 echo "${var[n]}"
+```
 
 or
 
+```sh
 # Expand variable names dynamically
 var_1="hello world"
 n=1
 name="var_$n"
 echo "${!name}"
+```
 
 POSIX sh:
 
+```sh
 # Expand dynamically with eval
 var_1="hello world"
 n=1
 eval "tmp=\$var_$n"
 echo "${tmp}"
+```
 
 ### Rationale:
 

SC2084.md

@@ -2,41 +2,53 @@
 
 ### Problematic code:
 
+```sh
 i=4
 $(( i++ ))
+```
 
 ### Correct code:
 
 Bash, Ksh:
 
+```sh
 i=4
 (( i++ ))
+```
 
 POSIX (assuming `++` is supported):
 
+```sh
 i=4
 _=$(( i++ ))
+```
 
 Alternative POSIX version that does not preserve the exit code:
 
+```sh
 : $(( i++ ))
+```
 
 ### Rationale:
 
 `$((..))` expands to a number. If it's the only word on the line, the shell will try to execute this number as a command name:
 
+```sh
 $ i=4
 $ $(( i++ ))
 4: command not found
 $ echo $i
 5
+```
 
 To avoid trying to execute the number as a command name, use one of the methods mentioned:
 
+```sh
 $ i=4
 $ _=$(( i++ ))
 $ echo $i
 5
+```
 
 ### Exceptions:
 

SC2087.md

@@ -2,15 +2,18 @@
 
 ### Problematic code:
 
+```sh
 ssh host.example.com << EOF
   echo "Logged in on $HOSTNAME"
 EOF
 
 ### Correct code:
 
+```sh
 ssh host.example.com << "EOF"
   echo "Logged in on $HOSTNAME"
 EOF
+```
 
 ### Rationale:
 
@@ -20,15 +23,19 @@ This means that before sending the commands to the server, the client replaces `
 
 Scripts with any kind of variable use are especially problematic because all references will be expanded before the script run. For example,
 
+```sh
 ssh host << EOF
   x="$(uname -a)"
   echo "$x"
 EOF
+```
 
 will never print anything, neither client nor server details, since before evaluation, it will be expanded to:
 
+```sh
   x="Linux localhost ... x86_64 GNU/Linux"
   echo ""
+```
 
 By quoting the here token, local expansion will not take place, so the server sees `echo "Logged in on $HOSTNAME"` which is expanded and printed with the server's hostname, which is usually the intention.
 
@@ -38,6 +45,8 @@ If the client should expand some or all variables, this message can and should b
 
 To expand a mix of local and remote variables, the here doc end token should be unquoted, and the remote variables should be escaped, e.g.
 
+```sh
 ssh host.example.com << EOF
   echo "Logged in on \$HOSTNAME from $HOSTNAME"
 EOF
+```

SC2088.md

@@ -2,11 +2,15 @@
 
 ### Problematic code:
 
+```sh
 rm "~/Desktop/$filename"
+```
 
 ### Correct code:
 
+```sh
 rm "$HOME/Desktop/$filename"
+```
 
 ### Rationale:
 

SC2089.md

@@ -2,21 +2,27 @@
 
 ### Problematic code:
 
+```sh
 args='-lh "My File.txt"'
 ls $args
+```
 
 ### Correct code:
 
+```sh
 args=(-lh "My File.txt")
 ls "${args[@]}"
+```
 
 ### Rationale:
 
 Bash does not interpret data as code. Consider almost any other languages, such as Python:
 
+```sh
 print 1+1   # prints 2
 a="1+1"
 print a     # prints 1+1, not 2
+```
 
 Here, `1+1` is Python syntax for adding numbers. However, passing a literal string containing this expression does not cause Python to interpret it, see the `+` and produce the calculated result.
 
@@ -26,16 +32,20 @@ The solution is to use an array instead, whenever possible.
 
 If you due to `sh` compatibility can't use arrays, you can use `eval` instead. However, this is very insecure and easy to get wrong, leading to various forms of security vulnerabilities and breakage:
 
+```sh
 quote() { local q=${1//\'/\'\\\'\'}; echo "'$q'"; }
 args="-lh $(quote "My File.txt")"
 eval ls "$args" # Do not use unless you understand implications
+```
 
 If you ever accidentally forget to use proper quotes, such as with:
 
+```sh
 for f in *.txt; do
   args="-lh '$1'" # Example security exploit
   eval ls "$args" # Do not copy and use
 done
+```
 
 Then you can use `touch "'; rm -rf \$'\x2F'; '.txt"`  (or someone can trick you into downloading a file with this name, or create a zip file or git repo containing it, or changing their nick and have your chat client create the file for a chat log, or...), and running the script to list your files will run the command `rm -rf /`.
 

SC2091.md

@@ -2,17 +2,21 @@
 
 ### Problematic code:
 
+```sh
 if $(which epstopdf)
 then
   echo "Found epstopdf"
 fi
+```
 
 ### Correct code:
 
+```sh
 if which epstopdf
 then
   echo "Found epstopdf"
 fi
+```
 
 ### Rationale:
 

SC2094.md

@@ -2,11 +2,15 @@
 
 ### Problematic code:
 
+```sh
 grep foo file.txt | sed -e 's/foo/bar/g' > file.txt
+```
 
 ### Correct code:
 
+```sh
 grep foo file.txt  | sed -e 's/foo/bar/g' > tmpfile && mv tmpfile file.txt
+```
 
 ### Rationale:
 

SC2096.md

@@ -2,12 +2,16 @@
 
 ### Problematic code:
 
+```sh
 #!/usr/bin/env bash -x
+```
 
 ### Correct code:
 
+```sh
 #!/usr/bin/env bash
 set -x
+```
 
 ### Rationale:
 

SC2097.md

@@ -2,19 +2,25 @@
 
 ### Problematic code:
 
+```sh
 name=World cmd -m "Hello $name"
+```
 
 ### Correct code:
 
+```sh
 export name=World
 cmd -m "Hello $name"
+```
 
 To prevent setting the variable, this can also be done in a subshell:
 
+```sh
 (
    export name=World
    cmd -m "Hello $name"
 ) # 'name' does not leave this subshell
+```
 
 ### Rationale:
 

SC2101.md

@@ -2,11 +2,15 @@
 
 ### Problematic code:
 
+```sh
 gzip file[:digit:]*.txt
+```
 
 ### Correct code:
 
+```sh
 gzip file[[:digit:]]*.txt
+```
 
 ### Rationale:
 

SC2103.md

@@ -2,16 +2,19 @@
 
 ### Problematic code:
 
+```sh
 for dir in */
 do
   cd "$dir"
   convert index.png index.jpg
   cd ..
 done
+```
 
 
 ### Correct code:
 
+```sh
 for dir in */
 do
   (
@@ -19,15 +22,18 @@
   convert index.png index.jpg
   )
 done
+```
 
 or
 
+```sh
 for dir in */
 do
   cd "$dir" || exit
   convert index.png index.jpg
   cd ..
 done
+```
 
 ### Rationale:
 

SC2107.md

@@ -2,11 +2,15 @@
 
 ### Problematic code:
 
+```sh
 [ "$1" = "-v" && -z "$2" ]
+```
 
 ### Correct code:
 
+```sh
 [ "$1" = "-v" ] && [ -z "$2" ]
+```
 
 ### Rationale:
 

SC2108.md

@@ -2,11 +2,15 @@
 
 ### Problematic code:
 
+```sh
 [[ "$1" = "-v" -a -z "$2" ]]
+```
 
 ### Correct code:
 
+```sh
 [[ "$1" = "-v" && -z "$2" ]]
+```
 
 ### Rationale:
 

SC2109.md

@@ -2,11 +2,15 @@
 
 ### Problematic code:
 
+```sh
 [ "$1" = "-v" || "$1" = "-help" ]
+```
 
 ### Correct code:
 
+```sh
 [ "$1" = "-v" ] || [ "$1" = "-help" ]
+```
 
 ### Rationale:
 

SC2110.md

@@ -2,11 +2,15 @@
 
 ### Problematic code:
 
+```sh
 [[ "$1" = "-v" -o "$1" = "-help" ]]
+```
 
 ### Correct code:
 
+```sh
 [[ "$1" = "-v" || "$1" = "-help" ]]
+```
 
 ### Rationale:
 

SC2114.md

@@ -2,11 +2,15 @@
 
 ### Problematic code:
 
+```sh
 rm -rf /usr /lib/nvidia-current/xorg/xorg
+```
 
 ### Correct code:
 
+```sh
 rm -rf /usr/lib/nvidia-current/xorg/xorg
+```
 
 ### Rationale:
 
@@ -18,6 +22,8 @@ Due to an accidental space, it deleted `/usr` instead of just the particular dir
 
 In cases of chroot, initramfs and similar, it's reasonable to delete otherwise important directories. Due to this, Shellcheck will not warn if the command contains `--`:
 
+```sh
 rm -rf -- /usr
+```
 
 This is an arbitrary convention to allow deleting such directories without having to use a [[directive]] to silence the warning.

SC2115.md

@@ -2,11 +2,15 @@
 
 ### Problematic code:
 
+```sh
 rm -rf "$STEAMROOT/"*
+```
 
 ### Correct code:
 
+```sh
 rm -rf "${STEAMROOT:?}/"*
+```
 
 ### Rationale:
 

SC2116.md

@@ -2,11 +2,15 @@
 
 ### Problematic code:
 
+```sh
 a=$(echo $?)
+```
 
 ### Correct code:
 
+```sh
 a="$?"
+```
 
 ### Rationale:
 

SC2117.md

@@ -2,14 +2,18 @@
 
 ### Problematic code:
 
+```sh
 whoami
 su
 whoami
+```
 
 ### Correct code:
 
+```sh
 whoami
 sudo whoami
+```
 
 ### Rationale:
 

SC2120.md

@@ -2,19 +2,23 @@
 
 ### Problematic code:
 
+```sh
 sayhello() {
   echo "Hello $1"
 }
 sayhello
+```
 
 `./myscript World` just prints "Hello " instead of "Hello World".
 
 ### Correct code:
 
+```sh
 sayhello() {
   echo "Hello $1"
 }
 sayhello "$@"
+```
 
 `./myscript World` now prints "Hello World".
 
@@ -26,9 +30,11 @@ If you want to process your script's parameters in a function, you have to expli
 
 Note that `"$@"` refers to the current context's positional parameters, so if you call a function from a function, you have to pass in `"$@"` to both of them:
 
+```sh
 first() { second "$@"; }
 second() { echo "The first script parameter is: $1"; }
 first "$@"
+```
 
 ### Exceptions
 

SC2121.md

@@ -2,12 +2,16 @@
 
 ### Problematic code:
 
+```sh
 set var=42
 set var 42
+```
 
 ### Correct code:
 
+```sh
 var=42
+```
 
 ### Rationale:
 

SC2122.md

@@ -2,11 +2,15 @@
 
 ### Problematic code:
 
+```sh
 [[ a <= b ]]
+```
 
 ### Correct code:
 
+```sh
 [[ ! a > b ]]
+```
 
 ### Rationale:
 

SC2123.md

@@ -2,20 +2,26 @@
 
 ### Problematic code:
 
+```sh
 PATH=/my/dir
 cat "$PATH/myfile"
+```
 
 ### Correct code:
 
 Good practice: always use lowercase for unexported variables.
 
+```sh
 path=/my/dir
 cat "$path/myfile"
+```
 
 Bad practice: use another uppercase name.
 
+```sh
 MYPATH=/my/dir
 cat "$MYPATH/myfile"
+```
 
 ### Rationale:
 

SC2124.md

@@ -2,25 +2,33 @@
 
 ### Problematic code:
 
+```sh
 var=$@
 for i in $var; do ..; done
+```
 
 or
 
+```sh
 set -- Hello World
 msg=$@
 echo "You said $msg"
+```
 
 ### Correct code:
 
+```sh
 var=( "$@" )
 for i in "${var[@]}"; do ..; done
+```
 
 or
 
+```sh
 set -- Hello World
 msg=$*
 echo "You said $msg"
+```
 
 ### Rationale:
 

SC2125.md

@@ -2,13 +2,17 @@
 
 ### Problematic code:
 
+```sh
 foo={1..9}
 echo $foo
+```
 
 ### Correct code:
 
+```sh
 foo=( {1..9} )
 echo "${foo[@]}"
+```
 
 ### Rationale:
 

SC2126.md

@@ -2,11 +2,15 @@
 
 ### Problematic code:
 
+```sh
 grep foo | wc -l
+```
 
 ### Correct code:
 
+```sh
 grep -c foo
+```
 
 ### Rationale:
 
@@ -14,10 +18,12 @@ This is purely a stylistic issue. `grep` can count lines without piping to `wc`.
 
 Note that in many cases, this number is only used to see whether there are matches (i.e. `> 0`). In these cases, it's better and more efficient to use `grep -q` and check its exit status:
 
+```sh
 if grep -q pattern file
 then
   echo "The file contains the pattern"
 fi
+```
 
 ### Exceptions
 

SC2128.md

@@ -2,19 +2,23 @@
 
 ### Problematic code:
 
+```sh
 myarray=(foo bar)
 for f in $myarray
 do
   cat "$f"
 done
+```
 
 ### Correct code:
 
+```sh
 myarray=(foo bar)
 for f in "${myarray[@]}"
 do
   cat "$f"
 done
+```
 
 ### Rationale:
 

SC2129.md

@@ -2,18 +2,22 @@
 
 ### Problematic code:
 
+```sh
 echo foo >> file
 date >> file
 cat stuff  >> file
 
+```
 
 ### Correct code:
 
+```sh
 {
   echo foo
   date
   cat stuff
 } >> file
+```
 
 ### Rationale:
 

SC2130.md

@@ -2,11 +2,15 @@
 
 ### Problematic code:
 
+```sh
 [[ $foo -eq "Y" ]]
+```
 
 ### Correct code:
 
+```sh
 [[ $foo = "Y" ]]
+```
 
 ### Rationale:
 

SC2139.md

@@ -2,11 +2,15 @@
 
 ### Problematic code:
 
+```sh
 alias whereami="echo $PWD"
+```
 
 ### Correct code:
 
+```sh
 alias whereami='echo $PWD'
+```
 
 ### Rationale:
 

SC2140.md

@@ -2,19 +2,27 @@
 
 ### Problematic code:
 
+```sh
 echo "<img src="foo.png" />" > file.html
+```
 
 or
 
+```sh
 export "var"="42"
+```
 
 ### Correct code:
 
+```sh
 echo "<img src=\"foo.png\" />" > file.html
+```
 
 or
 
+```sh
 export "var=42"
+```
 
 
 ### Rationale:
@@ -28,13 +36,17 @@ This usually indicates one of:
 
 Without escaping, the inner two quotes of the sandwich (the end quote of the first section and the start quote of the second section) are no-ops. The following two statements are identical, so the quotes that were intended to be part of the html output are instead removed:
 
+```sh
 echo "<img src="foo.png" />" > file.html
 echo "<img src=foo.png />" > file.html
+```
 
 Similarly, these statements are identical, but work as intended:
 
+```sh
 export "var"="42"
 export "var=42"
+```
 
 ### Exceptions
 
@@ -42,7 +54,9 @@ If you know that the quotes are ineffectual but you prefer it stylistically, you
 
 It's common not to realize that double quotes can span multiple elements, or to stylistically prefer to quote individual variables. For example, these statements are identical, but the first is laboriously and redundantly quoted:
 
+```sh
 http://"$user":"$password"@"$host"/"$path"
 "http://$user:$password@$host/$path"
+```
 
 When ShellCheck detects the first style (i.e. the double quotes include only a single element each), it will suppress the warning.

SC2141.md

@@ -2,11 +2,15 @@
 
 ### Problematic code:
 
+```sh
 IFS="\t"
+```
 
 ### Correct code:
 
+```sh
 IFS=$'\t'
+```
 
 ### Rationale: