ShellCheck

https://www.shellcheck.net/wiki
Admin
ShellCheck is a static analysis tool for shell scripts that identifies and helps fix common errors,...
Tokens:249,498
Snippets:2,258
Trust Score:9.6
Update:1 day ago
Show doc for...
Tokens:
Raw
### Correct code using 'command -v' and 'hash'

Source: https://www.shellcheck.net/wiki/SC2230

This example shows the recommended replacements for 'which'. Use 'command -v' to get the path of a single command or check if it will run, and 'hash' to check if commands exist without obtaining a path.

```shell
# For the path of a single, unaliased, external command,
# or to check whether this will just "run" in this shell:
command -v grep
# To check whether commands exist, without obtaining a reusable path:
hash grep
```

--------------------------------

### Output of while loop on example file

Source: https://www.shellcheck.net/wiki/SC2013

This shows the output of the correct while loop on the example file, preserving lines as-is.

```text
Line: foo *
Line: bar
```

--------------------------------

### Code walkthrough for simple pattern example

Source: https://www.shellcheck.net/wiki/SC3057

Annotated version of the previous example with comments explaining each step of the pattern-based substring extraction.

```sh
#!/usr/bin/env sh

part="zyxwvutsrqponmlkjihgfedcba"
#echo "${part:5:3}"

part="${part%${part#????????}}"
## Removed smallest prefix from text where prefix matches pattern ????????
## in this case : "rqponmlkjihgfedcba"
## "${part%${part#????????}}" = "${part%"rqponmlkjihgfedcba"}" = "zyxwvuts"
## Removed smallest suffix from part of text where suffix matches pattern ${part#????????} (i.e. "rqponmlkjihgfedcba")

part="${part#?????}"
## Removed smallest prefix from text where prefix matches ????? (i.e. "zyxwv")

printf '%s\n' "${part?}"

```

--------------------------------

### Expanded result of the problematic example

Source: https://www.shellcheck.net/wiki/SC2087

This shows what the previous example becomes after local expansion, illustrating why the output is empty.

```bash
  x="Linux localhost ... x86_64 GNU/Linux"
  echo ""
```

--------------------------------

### Example output of mycommand

Source: https://www.shellcheck.net/wiki/SC2066

This is the sample output used in the documentation to illustrate the different splitting behaviors.

```text
hello world
My *.png
```

--------------------------------

### SC2000 example: Compare wc -c, wc -m, and ${#1}

Source: https://www.shellcheck.net/wiki/SC2000

Example script showing three methods to count characters in the first argument: using `wc -c`, `wc -m`, and the recommended `${#1}`. The `${#1}` approach is preferred as it avoids spawning a subshell and is more efficient.

```bash
#!/usr/bin/env  bash

if [ "$( echo "$1" | wc -c )" -gt 1 ]; then
  echo "greater than 1"
fi

if [ "$( echo "$1" | wc -m )" -gt 1 ]; then
  echo "greater than 1"
fi

if [ "${#1}" -gt 1 ]; then
  echo "greater than 1"
fi

```

--------------------------------

### Rationale examples: literal vs variable and command substitution

Source: https://www.shellcheck.net/wiki/SC2050

Four one-line examples contrasting always-false literal comparisons with correct variable and command substitution usage, illustrating the cause of SC2050.

```bash
if [[ "myvar" = "test" ]]             # always false because myvar is a literal string
```

```bash
if [[ "$myvar" = "test" ]]            # correctly compares a variable
```

```bash
if [ 'grep -c foo bar' -ge 10 ]       # always false because grep doesn't run
```

```bash
if [ "$(grep -c foo bar)" -ge 10 ]    # correctly checks grep output
```

--------------------------------

### Output of for loop on example file

Source: https://www.shellcheck.net/wiki/SC2013

This shows the output of the problematic for loop on the example file, where glob expansion occurs and words are split.

```text
Line: foo
Line: aardwark.jpg
Line: bullfrog.jpg
...
```

--------------------------------

### POSIX example: test "$1" -a "$2"

Source: https://www.shellcheck.net/wiki/SC2166

An example from the POSIX rationale showing an ambiguous invocation using -a.

```shell
test "$1" -a "$2"
```

--------------------------------

### ShellCheck SC1041: Companion SC1042 error output

Source: https://www.shellcheck.net/wiki/SC1041

Example output showing the companion SC1042 errors that point to the start of the here document. This output is shown when the here document is not properly terminated.

```text
In foo line 4:
Hello
^-- SC1041: Found 'eof' further down, but not on a separate line.
^-- SC1042: Close matches include '-eof' (!= 'eof').

```

--------------------------------

### Loop with pgrep and ps to get user

Source: https://www.shellcheck.net/wiki/SC2009

Demonstrates using pgrep to get PIDs and ps to get a non-PID field (user) in a loop, which is more robust than grepping ps output.

```bash
for pid in $(pgrep '^python$')
do
  user=$(ps -o user= -p "$pid")
  echo "The process $pid is run by $user"
done
```

--------------------------------

### Example of removing line numbers with redirection

Source: https://www.shellcheck.net/wiki/SC2189

This example shows a common scenario: starting with `nl < foo.txt | grep bar`, then an incorrect attempt to remove line numbers leaves `grep` with no input, and finally the correct version uses `grep bar < foo.txt`.

```shell
# Match lines with line numbers
nl < foo.txt | grep bar

# Incorrect attempt at removing line numbers. grep now has no input:
< foo.txt | grep bar

# Line numbers correctly removed. grep now reads foo.txt as intended.
grep bar < foo.txt
```

--------------------------------

### ls -l output example

Source: https://www.shellcheck.net/wiki/SC2012

Example output of ls -l showing three seemingly identical filenames and a time format change, illustrating why ls output is unreliable.

```bash
$ 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
```

--------------------------------

### Exponentiation with bc: overflow example

Source: https://www.shellcheck.net/wiki/SC2039

Demonstrates that bash overflows on 2^63 while bc does not, and bc can handle arbitrarily large exponents.

```bash
# Note the overflow that gives a negative number
$ echo "$(( 2**63 ))"
-9223372036854775808

# No such problem
$ echo 2^63 | bc
9223372036854775808

# 'bc' just keeps on going
$ echo 2^1280 | bc
20815864389328798163850480654728171077230524494533409610638224700807\
21611934672059602447888346464836968484322790856201558276713249664692\
98162798132113546415258482590187784406915463666993231671009459188410\
95379622423387354295096957733925002768876520583464697770622321657076\
83317005651120933244966378183760369413644440628104205339687097746591\
6057756101739472373801429441421111406337458176
```

--------------------------------

### Semantic problems example with getopts

Source: https://www.shellcheck.net/

Example demonstrating ShellCheck's detection of higher-level semantic problems, such as using 'v' instead of 'f' in getopts and unquoted variables.

```bash
#!/bin/bash
## Example: ShellCheck can detect some higher level semantic problems
while getopts "nf:" param
do
  case "$param" in
    f) file="$OPTARG" ;;
    v) set -x ;;
  esac
done
case "$file" in
  *.gz) gzip -d "$file" ;;
  *.zip) unzip "$file" ;;
  *.tar.gz) tar xzf "$file" ;;
  *) echo "Unknown filetype" ;;
esac
if [[ "$(uname)" == "Linux" ]]
then
  echo "Using Linux"
fi
```

--------------------------------

### Base specification example with $

Source: https://www.shellcheck.net/wiki/SC2004

Shows that $ is required when specifying a base for a variable value, as in 10#$a, and demonstrates the error when base is not specified.

```bash
$ a=09
$ echo $((a + 1))          # leading zero forces octal interpretation
bash: 09: value too great for base (error token is "09")
$ echo $((10#a + 1))
bash: 10#a: value too great for base (error token is "10#a")
$ echo $((10#$a + 1))
10
```

--------------------------------

### Examples of flipped $ and " in echo commands

Source: https://www.shellcheck.net/wiki/SC2247

Two examples demonstrating the flipped syntax in echo commands, with comments indicating the intended substitutions. These are interpreted as localized string resources containing literal parentheses or braces.

```bash
echo $"(cmd)"  # Supposed to be "$(cmd)"

```

```bash
echo $"{var}"  # Supposed to be "${var}"

```

--------------------------------

### Exception example: decompress all gz files except tar.gz

Source: https://www.shellcheck.net/wiki/SC2146

This example shows an intentional use of -o with grouping to decompress all .gz files except .tar.gz. The command uses \( \) to group the -name '*.gz' and -exec gzip -d, so that the -o applies to the whole group.

```shell
find . -name '*.tar.gz' -o \( -name '*.gz' -exec gzip -d {} + \)
```

--------------------------------

### Correct code: _411toppm=true

Source: https://www.shellcheck.net/wiki/SC2282

This corrected example uses an underscore prefix to make the variable name valid, avoiding SC2282.

```shell
_411toppm=true
```

--------------------------------

### Problematic code: command starting with `===`

Source: https://www.shellcheck.net/wiki/SC2274

This example triggers SC2274 because the line starts with `===` and is interpreted as a command. It is likely intended as a visual border but lacks the `#` comment prefix.

```bash
===================== MAIN SECTION =======================

```

--------------------------------

### Problematic code for SC2275: command name starts with '='

Source: https://www.shellcheck.net/wiki/SC2275

This example triggers SC2275 because the '=' at the start of the second line is interpreted as a command name. It likely results from a bad line break in a variable assignment.

```shell
my_variable
  =value
```

--------------------------------

### Example: sh -c with dummy argument and filename

Source: https://www.shellcheck.net/wiki/SC2014

This command demonstrates how sh -c works with a dummy argument _ as $0 and a filename as $1. It shows the output of the command.

```shell
$ sh -c 'echo "$1 is in $(dirname "$1")"' _ "mydir/myfile"
mydir/myfile is in mydir
```

--------------------------------

### Problematic code: 411toppm=true

Source: https://www.shellcheck.net/wiki/SC2282

This example triggers SC2282 because the variable name starts with a digit. ShellCheck interprets it as a command, not an assignment.

```shell
411toppm=true
```

--------------------------------

### Correct code: three alternatives for handling output

Source: https://www.shellcheck.net/wiki/SC2328

These examples show three correct approaches: capturing output instead of writing to file, capturing and writing using tee, or not capturing at all.

```shell
# If the output should be captured INSTEAD OF being written to file
var=$(tr -d ':' < input.txt)
```

```shell
# If the output should be captured IN ADDITION to being written to file
var=$(tr -d ':' < input.txt | tee output.txt)
```

```shell
# If the output should NOT BE captured at all
tr -d ':' < input.txt > output.txt
```

--------------------------------

### Correct code: fix misspelled variable name

Source: https://www.shellcheck.net/wiki/SC2154

Correct version of the second problematic example, fixing the misspelling to $target.

```shell
target="world"
echo "hello $target"
```

--------------------------------

### Correct code: using mktemp

Source: https://www.shellcheck.net/wiki/SC2186

Shows the recommended replacement using `mktemp`, which is more portable across GNU, OSX, BusyBox, *BSD, and Solaris.

```bash
tmp=$(mktemp)
```

--------------------------------

### Correct code: space after `{`

Source: https://www.shellcheck.net/wiki/SC1054

This corrected example places a space after `{`, making it a separate token and recognized as the start of a command group.

```shell
foo() { echo "hello world"; }

```

--------------------------------

### Problematic code: echo "Hello ${{name}"

Source: https://www.shellcheck.net/wiki/SC2296

This example triggers SC2296 because the parameter expansion starts with an invalid character (duplicated '{').

```shell
echo "Hello ${{name}"
```

--------------------------------

### Problematic code: for loop with `do` on same line

Source: https://www.shellcheck.net/wiki/SC1063

This example triggers SC1063 because `do` appears on the same line as the loop header without a semicolon or line feed before it. ShellCheck expects `do` to start a new statement.

```bash
for file in * do
  echo "$file"
done
```

--------------------------------

### Correct code: using `run !` in bats test

Source: https://www.shellcheck.net/wiki/SC2314

This example shows the corrected bats test using `run ! test_file_exists` to properly cause a test failure. This works starting with bats 1.5.0.

```bash
#!/usr/bin/env bats

@test "test" {
    # ... code
    run ! test_file_exists
    # ... more code
}
```

--------------------------------

### Correct code: if [ foo -eq bar ]; then true; fi

Source: https://www.shellcheck.net/wiki/SC2171

Shows the corrected code for the test expression example: adding the missing `[`.

```shell
if [ foo -eq bar ]; then true; fi
```

--------------------------------

### Alternative: hash command

Source: https://www.shellcheck.net/wiki/SC2230

This example shows the 'hash' command as an alternative that observes standard failure behavior. It fails if any of the given commands do not exist.

```shell
$ hash <file1> <file2>
```

--------------------------------

### Visual breakdown of SC2027 quoting issue

Source: https://www.shellcheck.net/wiki/SC2027

Annotated example showing how the quotes around $HOSTNAME unquote it: the left quote terminates the double-quoted string, and the right quote starts a new one. The labels indicate which parts are quoted and which are not.

```bash
echo "You enter "$HOSTNAME". You can smell the wumpus."
     |----------|         |---------------------------|
        Quoted   No quotes           Quoted
```

--------------------------------

### Exception: background command with &

Source: https://www.shellcheck.net/wiki/SC1132

Shows an acceptable use of `&` for backgrounding, with a space after it for clarity.

```shell
sleep 10& wait
```

--------------------------------

### POSIX example: test "$1" && test "$2"

Source: https://www.shellcheck.net/wiki/SC2166

The recommended POSIX form using separate test commands with &&.

```shell
test "$1" && test "$2"
```

--------------------------------

### Merge conflict example with markers

Source: https://www.shellcheck.net/wiki/SC2273

Example of a merge conflict block with markers that should be resolved and removed.

```shell
<<<<<<< HEAD
echo "Goodbye World"
=======
echo "Hello World!"
>>>>>>> mybranch

```

--------------------------------

### Exception solution: using an array for command options

Source: https://www.shellcheck.net/wiki/SC2086

Shows the recommended array-based approach for bash, ksh, and zsh to handle optional arguments without word splitting issues. Includes a comment for ksh88 syntax.

```bash
options=(-j 5 -B) # ksh88: set -A options -- -j 5 -B
[[ $debug == "yes" ]] && options=("${options[@]}" -d)
make "${options[@]}" file
```

--------------------------------

### Correct: use pgrep

Source: https://www.shellcheck.net/wiki/SC2009

Shows the recommended alternative using pgrep to find a process by name.

```bash
pgrep -f "$service" > /dev/null
```

--------------------------------

### Debugging anti-strategy: adding quotes until it works

Source: https://www.shellcheck.net/wiki/SC2294

This snippet illustrates the anti-strategy of adding quotes to make the problematic example work, but it fails with the correct example. It shows that the correct example requires the function invocation to be tweaked as well.

```bash
# Works with problematic example because of double-escaping, fails with correct example
check ls -l "'My File.txt'" 

# Works with correct example the way it was always intended:
check ls -l "My File.txt" 
```

--------------------------------

### Dash quoting problem examples

Source: https://www.shellcheck.net/wiki/SC2155

Two examples that fail in dash due to word splitting and quoting issues.

```bash
f(){ local e=$1; }
f "1 2"

export g=$(printf '%s' "foo 2")
```

--------------------------------

### Correct code: cd with error handling

Source: https://www.shellcheck.net/wiki/SC2164

Shows corrected versions of the problematic examples. The first uses `|| exit` to abort on failure, the second uses `|| return` inside a function to return on failure.

```shell
cd generated_files || exit
rm -r *.c

```

```shell
# For functions, you may want to use return:
func(){
  cd foo || return
  do_something
}

```

--------------------------------

### Correct code: echo "Hello ${name}"

Source: https://www.shellcheck.net/wiki/SC2296

This corrected example uses the proper syntax for parameter expansion, avoiding the warning.

```shell
echo "Hello ${name}"
```

--------------------------------

### Correct code: use $HOME in PATH

Source: https://www.shellcheck.net/wiki/SC2147

Shows the correct way to add a directory to PATH using $HOME instead of a literal tilde, ensuring compatibility across all programs.

```bash
PATH="$PATH:$HOME/bin"
```

--------------------------------

### Problematic code: trying to execute commands with ${}

Source: https://www.shellcheck.net/wiki/SC2154

Example of SC2154 where command substitution is incorrectly attempted with ${} instead of $(). This is the third problematic example.

```shell
echo "Result: ${mycmd -a myfile}"  # trying to execute commands
```

--------------------------------

### Demonstration of sed vs Bash parameter expansion

Source: https://www.shellcheck.net/wiki/SC2001

Compares sed and Bash parameter expansion for the same substitution, showing that the two echo commands are equivalent.

```bash
var="foo foo"
# the following two echo's should be equivalent:
echo "$var" | sed 's/^foo/bar/g'
echo ${var/#foo/bar}
```

--------------------------------

### Problematic code: misspelled variable name

Source: https://www.shellcheck.net/wiki/SC2154

Example of SC2154 where a variable is misspelled: $tagret instead of $target. This is the second problematic example.

```shell
target="world"
echo "hello $tagret"  # misspelled
```

--------------------------------

### Demonstration of collapsing spaces

Source: https://www.shellcheck.net/wiki/SC2291

Shows the actual output of the problematic command, where multiple spaces collapse into one.

```shell
$ echo Hello        World
Hello World
```

--------------------------------

### Correct code: switch to bash

Source: https://www.shellcheck.net/wiki/SC3044

Suggests switching to bash if 'declare' functionality is required.

```shell
#!/bin/bash
declare ...

```

--------------------------------

### Correct code: gcc -o myfile file.c and ./myfile

Source: https://www.shellcheck.net/wiki/SC2083

Shows the correct way to run a file in the current directory: './myfile' without a space. The compilation command is the same, but the execution command uses the proper path.

```shell
gcc -o myfile file.c
./myfile
```

--------------------------------

### Security exploit example with eval

Source: https://www.shellcheck.net/wiki/SC2089

Shows a dangerous example where improper quoting in eval can lead to command injection, with a warning not to copy or use.

```bash
for f in *.txt; do
  args="-lh '$1'" # Example security exploit
  eval ls "$args" # Do not copy and use
done
```

--------------------------------

### Literal forward ticks: problematic example

Source: https://www.shellcheck.net/wiki/SC1077

Shows an example of using forward ticks as literal characters, which is problematic because ShellCheck parses them as backticks.

```bash
echo "``Proprietary software is an injustice.´´  - Richard Stallman"
```

--------------------------------

### Correct code: `true`

Source: https://www.shellcheck.net/wiki/SC2160

This example shows the recommended replacement using `true` directly, which makes the intent clear and avoids the misleading bracket syntax.

```shell
if true
then
  echo "always triggers"
fi
```

--------------------------------

### Problematic code: line starts with pipe

Source: https://www.shellcheck.net/wiki/SC1133

Shows the incorrect style that triggers SC1133: the pipe is placed at the start of the second line, which the shell does not recognize as a continuation.

```shell
dmesg
  | grep "error"

```

--------------------------------

### Correct code: if which epstopdf

Source: https://www.shellcheck.net/wiki/SC2091

Shows the corrected version of the first example: simply run the command directly without command substitution.

```bash
if which epstopdf
then
  echo "Found epstopdf"
fi
```

--------------------------------

### Problematic code: overextended variable name

Source: https://www.shellcheck.net/wiki/SC2154

Example of SC2154 where a variable name is overextended: $var_ is interpreted as a variable name, causing the warning. This is the first problematic example.

```shell
var=name
n=42
echo "$var_$n.jpg"   # overextended
```

--------------------------------

### Alternatives using extglob and brace expansion

Source: https://www.shellcheck.net/wiki/SC2102

Three alternative patterns for matching multiple alternatives in Bash. The first is incorrect, the second uses brace expansion, and the third uses extglob (requires shopt -s extglob).

```shell
cat *.[dev,prod,test].conf   # Doesn't work
```

```shell
cat *.{dev,prod,test}.conf   # Works in bash
```

```shell
cat *.@(dev|prod|test).conf  # Works in bash with `shopt -s extglob`
```

--------------------------------

### Quoting issues example

Source: https://www.shellcheck.net/

Example showing ShellCheck's detection of various quoting issues, such as quoting in grep patterns, unquoted variables, and incorrect quoting in find arguments.

```bash
#!/bin/bash
## Example: ShellCheck can detect many different kinds of quoting issues
if ! grep -q backup=true.* "~/.myconfig"
then
  echo 'Backup not enabled in $HOME/.myconfig, exiting'
  exit 1
fi
if [[ $1 =~ "-v(erbose)?" ]]
then
  verbose='-printf "Copying %f\n"'
fi
find backups/ \
  -iname *.tar.gz \
  $verbose \
  -exec scp {} “myhost:backups” +
```

--------------------------------

### Function wrapper for ffmpeg with extra arguments

Source: https://www.shellcheck.net/wiki/SC2089

Shows how to use a function to add fixed arguments to a command while still accepting additional arguments via "$@".

```bash
ffmpeg_with_args() {
  ffmpeg -filter_complex '[#0x2ef] setpts=PTS+1/TB [sub] ; [#0x2d0] [sub] overlay' "$@"
}
ffmpeg_with_args -i "My File.avi" "Output.avi"
```

--------------------------------

### Bash 1.14 bug example with x-prefix

Source: https://www.shellcheck.net/wiki/SC2268

Example showing a test that incorrectly fails in Bash 1.14 from 1992, fixed in Bash 2.0 in 1996. This illustrates why the x-prefix was historically used.

```shell
var='!'
[ "$var" = "!" ]
```

--------------------------------

### Example showing expansion issue with variables

Source: https://www.shellcheck.net/wiki/SC2087

This example demonstrates the problem: unquoted EOF causes local expansion, so the command substitution and variable are expanded before sending, resulting in an empty echo.

```bash
ssh host << EOF
  x="$(uname -a)"
  echo "$x"
EOF
```

--------------------------------

### Handling process substitution failures with file descriptor duplication

Source: https://www.shellcheck.net/wiki/SC2312

Example showing how to use exec with process substitution and file descriptor duplication to retain exit codes of background processes, using wait. It defines generate_data and consume_data functions and demonstrates reading output while preserving exit statuses.

```bash
generate_data() {
    declare i
    for (( i = 0 ; i < 5 ; ++i ))
    do
        date -d "$RANDOM hours"
    done
}

consume_data() {
    declare line
    while IFS= read -r line
    do
        echo Consuming line: "$line"
    done
}

declare \
    input_file_descriptor \
    process

# The following statement
#
# - uses process substitution to allow us to read the output of `generate_data`
#   via a filename and
# - duplicates the file descriptor for that file so that it is not
#   immediately closed
#
# Note that process substitution uses either `pipe(2)` or named pipes (FIFOs)
# with `O_RDONLY` or `O_WRONLY`, and so the file descriptor that is duplicated
# via `[N]<&WORD` is only opened for reads
exec {input_file_descriptor}< <(
    generate_data
)
process=$!

# Returns non-zero if `consume_data` does
consume_data <&"$input_file_descriptor"

# Returns non-zero if `generate_data` does
wait "$process"
```

--------------------------------

### Example input file with glob characters

Source: https://www.shellcheck.net/wiki/SC2013

This text file is used to demonstrate the difference between for and while loops. It contains a line with a glob pattern.

```text
foo *
bar
```

--------------------------------

### ShellCheck SC1041: Example error message

Source: https://www.shellcheck.net/wiki/SC1041

Example output from ShellCheck showing the SC1041 warning and the close match suggestion. This is the error message that appears when the here document terminator is not on a separate line.

```text
Close matches include '-eof' (!= 'eof').

```

--------------------------------

### Correct code: use tee to output to both

Source: https://www.shellcheck.net/wiki/SC2260

This example shows the correct pattern using `tee` to write to a file and pipe to grep simultaneously. Use this when you need both redirection and piping.

```shell
env | tee environment.txt | grep '^ANDROID'
```

--------------------------------

### Portability warning example with shebang 'sh'

Source: https://www.shellcheck.net/

Example showing ShellCheck's portability warnings when the shebang is 'sh' but the script uses bashisms like brace expansion and arithmetic evaluation.

```sh
#!/bin/sh
## Example: The shebang says 'sh' so shellcheck warns about portability
## Change it to '#!/bin/bash' to allow bashisms
for n in {1..$RANDOM}
do
  str=""
  if (( n % 3 == 0 ))
  then
    str="fizz"
  fi
  if [ $[n%5] == 0 ]
  then
    str="$strbuzz"
  fi
  if [[ ! $str ]]
  then
    str="$n"
  fi
  echo "$str"
done
```

--------------------------------

### Conditional function definition example

Source: https://www.shellcheck.net/wiki/SC2218

Demonstrates defining a function conditionally based on the operating system, then calling it. The definition must be executed before the call.

```shell
case "$(uname -s)" in
  Linux) hi() { echo "Hello from Linux"; } ;;
  Darwin) hi() { echo "Hello from macOS"; } ;;
  *) hi() { echo "Hello from something else"; } ;;
esac

hi

```

--------------------------------

### Typical script with several problems

Source: https://www.shellcheck.net/

Example script demonstrating common issues ShellCheck detects, such as using ls parsing, missing semicolons, and unquoted variables.

```sh
#!/bin/sh
## Example: a typical script with several problems
for f in $(ls *.m3u)
do
  grep -qi hq.*mp3 $f \
    && echo -e 'Playlist $f contains a HQ file in mp3 format'
done
```

--------------------------------

### Problematic code: find -exec with shell command string

Source: https://www.shellcheck.net/wiki/SC2150

This example triggers SC2150 because find -exec does not invoke a shell, so the command string is not parsed. Use sh -c as shown in the correct examples.

```bash
find . -type f -exec 'cat {} | wc -l' \;
```

--------------------------------

### Correct code using redirection

Source: https://www.shellcheck.net/wiki/SC2002

Shows the corrected versions of the problematic examples, using input redirection instead of cat. This avoids the useless use of cat and is more efficient.

```shell
< file tr ' ' _ | nl  
while IFS= read -r i; do echo "${i%?}"; done < file
```

--------------------------------

### Dash 0.5.4 bug example with x-prefix

Source: https://www.shellcheck.net/wiki/SC2268

Example showing a test that incorrectly passes in Dash 0.5.4 from 2007, fixed in Dash 0.5.5 in 2008. This is another historical case where the x-prefix was used to avoid such bugs.

```shell
x='(' y=')'
[ "$x" = "$y" ]
```

--------------------------------

### Correct code: use command substitution with $()

Source: https://www.shellcheck.net/wiki/SC2154

Correct version of the third problematic example, using $(mycmd -a myfile) for command substitution.

```shell
echo "Result: $(mycmd -a myfile)"
```

--------------------------------

### Equivalent alternatives for appending

Source: https://www.shellcheck.net/wiki/SC2024

Provides alternative commands to `tee -a` for appending to a file with sudo: `awk` and `sh -c`.

```bash
echo 'data' | sudo awk '{ print $0 >> "file" }'
echo 'data' | sudo sh -c 'cat >> file'
```

--------------------------------

### Correct code: double quotes allow expansion

Source: https://www.shellcheck.net/wiki/SC2016

Shows the fix: using double quotes allows $name to expand, outputting 'Hello World'.

```shell
name=World
echo "Hello $name"   # Outputs Hello World
```

--------------------------------

### Correct code: using tee and cat

Source: https://www.shellcheck.net/wiki/SC2024

Shows the recommended fixes: use `tee` for writing and appending, and `cat` for reading. The redirection is performed by the elevated command, not the shell.

```bash
# Write to a file
echo 3 | sudo tee /proc/sys/vm/drop_caches > /dev/null

# Append to a file
echo 'export FOO=bar' | sudo tee -a /etc/profile > /dev/null

# Read from a file
sudo cat /etc/shadow | wc -l
```

--------------------------------

### Dash error messages

Source: https://www.shellcheck.net/wiki/SC2155

Error messages produced by dash for the problematic examples.

```bash
local: 2: bad variable name
export: 2: bad variable name
```

--------------------------------

### Correct code: retries=${RETRIES:-3}

Source: https://www.shellcheck.net/wiki/SC2298

Corrects the first example by removing the extra `$`.

```shell
retries=${RETRIES:-3}
```

--------------------------------

### Correct code: gzip file[:digit:](:digit:)*.txt

Source: https://www.shellcheck.net/wiki/SC2101

This corrected example wraps the named class in outer brackets, so [:digit:] matches a digit as intended.

```shell
gzip file[:digit:](:digit:)*.txt
```

--------------------------------

### Problematic code: fgrep usage

Source: https://www.shellcheck.net/wiki/SC2197

Example of code that triggers SC2197. fgrep is non-standard and deprecated.

```shell
fgrep '*.*' file
```

--------------------------------

### Correct code: Set variables before sourcing

Source: https://www.shellcheck.net/wiki/SC2240

Shows the correct approach: assign arguments to variables before sourcing the script, as sh/dash do not support arguments to the dot command.

```shell
#!/bin/sh
host=example.com port=80 . include/myscript 

```

--------------------------------

### Correct code: use temporary file

Source: https://www.shellcheck.net/wiki/SC3001

Alternative fix: replace process substitution with a temporary file created by mktemp, then read from it and remove it.

```sh
#!/bin/sh
tmp="$(mktemp)"
program > "$tmp"
while IFS= read -r n
do
  sum=$((sum+n))
done < "$tmp"
rm "$tmp"
```

--------------------------------

### Correct while loop with 'do'

Source: https://www.shellcheck.net/wiki/SC1057

This corrected example adds the 'do' keyword after the while condition, resolving SC1057.

```shell
while read -r line
do
  echo $line
done
```
Tokens:
Raw