>($prefilter_progress_function)\

Close

var is referenced but not assigned.

Problematic code:

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

or

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

or

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

Correct code:

var=name
n=42
echo "${var}_$n.jpg"

or

target="world"
echo "hello $target"

or

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

Rationale:

ShellCheck has noticed that you reference a variable that is not assigned. Double check that the variable is indeed assigned, and that the name is not misspelled.

Note: This message only triggers for variables with lowercase characters in their name (foo and kFOO but not FOO) due to the standard convention of using lowercase variable names for unexported, local variables.

Exceptions:

ShellCheck does not attempt to figure out runtime or dynamic assignments like with source "$(date +%F).sh" or eval var=value.

If you know for a fact that the variable is set, you can use ${var:?} to fail if the variable is unset (or empty), or explicitly initialize/declare it with var="" or declare var. You can also disable the message with a [[directive]].

Notice

Original content from the ShellCheck https://github.com/koalaman/shellcheck/wiki.

        $cmd_part_parallelism\

Close

Double quote to prevent globbing and word splitting.

Problematic code:

echo $1
for i in $*; do :; done # this done and the next one also applies to expanding arrays.
for i in $@; do :; done

Correct code:

echo "$1"
for i in "$@"; do :; done # or, 'for i; do'

Rationale

The first code looks like "print the first argument". It's actually "Split the first argument by IFS (spaces, tabs and line feeds). Expand each of them as if it was a glob. Join all the resulting strings and filenames with spaces. Print the result."

The second one looks like "iterate through all arguments". It's actually "join all the arguments by the first character of IFS (space), split them by IFS and expand each of them as globs, and iterate on the resulting list". The third one skips the joining part.

Quoting variables prevents word splitting and glob expansion, and prevents the script from breaking when input contains spaces, line feeds, glob characters and such.

Strictly speaking, only expansions themselves need to be quoted, but for stylistic reasons, entire arguments with multiple variable and literal parts are often quoted as one:

$HOME/$dir/dist/bin/$file        # Unquoted (bad)
"$HOME"/"$dir"/dist/bin/"$file"  # Minimal quoting (good)
"$HOME/$dir/dist/bin/$file"      # Canonical quoting (good)

When quoting composite arguments, make sure to exclude globs and brace expansions, which lose their special meaning in double quotes: "$HOME/$dir/src/*.c" will not expand, but "$HOME/$dir/src"/*.c will.

Note that $( ) starts a new context, and variables in it have to be quoted independently:

echo "This $variable is quoted $(but this $variable is not)"
echo "This $variable is quoted $(and now this "$variable" is too)"

Exceptions

Sometimes you want to split on spaces, like when building a command line:

options="-j 5 -B"
make $options file

Just quoting this doesn't work. Instead, you should have used an array (bash, ksh, zsh):

options=(-j 5 -B) # ksh: set -A options -- -j 5 -B
make "${options[@]}" file

or a function (POSIX):

make_with_flags() { make -j 5 -B "$@"; }
make_with_flags file

To split on spaces but not perform glob expansion, Posix has a set -f to disable globbing. You can disable word splitting by setting IFS=''.

Similarly, you might want an optional argument:

debug=""
[[ $1 == "--trace-commands" ]] && debug="-x"
bash $debug script

Quoting this doesn't work, since in the default case, "$debug" would expand to one empty argument while $debug would expand into zero arguments. In this case, you can use an array with zero or one elements as outlined above, or you can use an unquoted expansion with an alternate value:

debug=""
[[ $1 == "--trace-commands" ]] && debug="yes"
bash ${debug:+"-x"} script

This is better than an unquoted value because the alternative value can be properly quoted, e.g. wget ${output:+ -o "$output"}.

---

As always, this warning can be [[ignore]]d on a case-by-case basis.

this is especially relevant when BASH many not be available for the array work around. For example, use in eval or in command options where script has total control of the variables...

FLAGS="-av -e 'ssh -x' --delete --delete-excluded"
...
# shellcheck disable=SC2086
eval rsync $FLAGS ~/dir remote_host:dir

Notice

Original content from the ShellCheck https://github.com/koalaman/shellcheck/wiki.

                $cmd_part_parallelism\

Close

Double quote to prevent globbing and word splitting.

Problematic code:

echo $1
for i in $*; do :; done # this done and the next one also applies to expanding arrays.
for i in $@; do :; done

Correct code:

echo "$1"
for i in "$@"; do :; done # or, 'for i; do'

Rationale

The first code looks like "print the first argument". It's actually "Split the first argument by IFS (spaces, tabs and line feeds). Expand each of them as if it was a glob. Join all the resulting strings and filenames with spaces. Print the result."

The second one looks like "iterate through all arguments". It's actually "join all the arguments by the first character of IFS (space), split them by IFS and expand each of them as globs, and iterate on the resulting list". The third one skips the joining part.

Quoting variables prevents word splitting and glob expansion, and prevents the script from breaking when input contains spaces, line feeds, glob characters and such.

Strictly speaking, only expansions themselves need to be quoted, but for stylistic reasons, entire arguments with multiple variable and literal parts are often quoted as one:

$HOME/$dir/dist/bin/$file        # Unquoted (bad)
"$HOME"/"$dir"/dist/bin/"$file"  # Minimal quoting (good)
"$HOME/$dir/dist/bin/$file"      # Canonical quoting (good)

When quoting composite arguments, make sure to exclude globs and brace expansions, which lose their special meaning in double quotes: "$HOME/$dir/src/*.c" will not expand, but "$HOME/$dir/src"/*.c will.

Note that $( ) starts a new context, and variables in it have to be quoted independently:

echo "This $variable is quoted $(but this $variable is not)"
echo "This $variable is quoted $(and now this "$variable" is too)"

Exceptions

Sometimes you want to split on spaces, like when building a command line:

options="-j 5 -B"
make $options file

Just quoting this doesn't work. Instead, you should have used an array (bash, ksh, zsh):

options=(-j 5 -B) # ksh: set -A options -- -j 5 -B
make "${options[@]}" file

or a function (POSIX):

make_with_flags() { make -j 5 -B "$@"; }
make_with_flags file

To split on spaces but not perform glob expansion, Posix has a set -f to disable globbing. You can disable word splitting by setting IFS=''.

Similarly, you might want an optional argument:

debug=""
[[ $1 == "--trace-commands" ]] && debug="-x"
bash $debug script

Quoting this doesn't work, since in the default case, "$debug" would expand to one empty argument while $debug would expand into zero arguments. In this case, you can use an array with zero or one elements as outlined above, or you can use an unquoted expansion with an alternate value:

debug=""
[[ $1 == "--trace-commands" ]] && debug="yes"
bash ${debug:+"-x"} script

This is better than an unquoted value because the alternative value can be properly quoted, e.g. wget ${output:+ -o "$output"}.

---

As always, this warning can be [[ignore]]d on a case-by-case basis.

this is especially relevant when BASH many not be available for the array work around. For example, use in eval or in command options where script has total control of the variables...

FLAGS="-av -e 'ssh -x' --delete --delete-excluded"
...
# shellcheck disable=SC2086
eval rsync $FLAGS ~/dir remote_host:dir

Notice

Original content from the ShellCheck https://github.com/koalaman/shellcheck/wiki.

        $cmd_size\

Close

Double quote to prevent globbing and word splitting.

Problematic code:

echo $1
for i in $*; do :; done # this done and the next one also applies to expanding arrays.
for i in $@; do :; done

Correct code:

echo "$1"
for i in "$@"; do :; done # or, 'for i; do'

Rationale

The first code looks like "print the first argument". It's actually "Split the first argument by IFS (spaces, tabs and line feeds). Expand each of them as if it was a glob. Join all the resulting strings and filenames with spaces. Print the result."

The second one looks like "iterate through all arguments". It's actually "join all the arguments by the first character of IFS (space), split them by IFS and expand each of them as globs, and iterate on the resulting list". The third one skips the joining part.

Quoting variables prevents word splitting and glob expansion, and prevents the script from breaking when input contains spaces, line feeds, glob characters and such.

Strictly speaking, only expansions themselves need to be quoted, but for stylistic reasons, entire arguments with multiple variable and literal parts are often quoted as one:

$HOME/$dir/dist/bin/$file        # Unquoted (bad)
"$HOME"/"$dir"/dist/bin/"$file"  # Minimal quoting (good)
"$HOME/$dir/dist/bin/$file"      # Canonical quoting (good)

When quoting composite arguments, make sure to exclude globs and brace expansions, which lose their special meaning in double quotes: "$HOME/$dir/src/*.c" will not expand, but "$HOME/$dir/src"/*.c will.

Note that $( ) starts a new context, and variables in it have to be quoted independently:

echo "This $variable is quoted $(but this $variable is not)"
echo "This $variable is quoted $(and now this "$variable" is too)"

Exceptions

Sometimes you want to split on spaces, like when building a command line:

options="-j 5 -B"
make $options file

Just quoting this doesn't work. Instead, you should have used an array (bash, ksh, zsh):

options=(-j 5 -B) # ksh: set -A options -- -j 5 -B
make "${options[@]}" file

or a function (POSIX):

make_with_flags() { make -j 5 -B "$@"; }
make_with_flags file

To split on spaces but not perform glob expansion, Posix has a set -f to disable globbing. You can disable word splitting by setting IFS=''.

Similarly, you might want an optional argument:

debug=""
[[ $1 == "--trace-commands" ]] && debug="-x"
bash $debug script

Quoting this doesn't work, since in the default case, "$debug" would expand to one empty argument while $debug would expand into zero arguments. In this case, you can use an array with zero or one elements as outlined above, or you can use an unquoted expansion with an alternate value:

debug=""
[[ $1 == "--trace-commands" ]] && debug="yes"
bash ${debug:+"-x"} script

This is better than an unquoted value because the alternative value can be properly quoted, e.g. wget ${output:+ -o "$output"}.

---

As always, this warning can be [[ignore]]d on a case-by-case basis.

this is especially relevant when BASH many not be available for the array work around. For example, use in eval or in command options where script has total control of the variables...

FLAGS="-av -e 'ssh -x' --delete --delete-excluded"
...
# shellcheck disable=SC2086
eval rsync $FLAGS ~/dir remote_host:dir

Notice

Original content from the ShellCheck https://github.com/koalaman/shellcheck/wiki.

        if [[ $opt_show_diff = 1 ]]; then

Close

var is referenced but not assigned.

Problematic code:

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

or

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

or

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

Correct code:

var=name
n=42
echo "${var}_$n.jpg"

or

target="world"
echo "hello $target"

or

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

Rationale:

ShellCheck has noticed that you reference a variable that is not assigned. Double check that the variable is indeed assigned, and that the name is not misspelled.

Note: This message only triggers for variables with lowercase characters in their name (foo and kFOO but not FOO) due to the standard convention of using lowercase variable names for unexported, local variables.

Exceptions:

ShellCheck does not attempt to figure out runtime or dynamic assignments like with source "$(date +%F).sh" or eval var=value.

If you know for a fact that the variable is set, you can use ${var:?} to fail if the variable is unset (or empty), or explicitly initialize/declare it with var="" or declare var. You can also disable the message with a [[directive]].

Notice

Original content from the ShellCheck https://github.com/koalaman/shellcheck/wiki.

            -e 's/\/.*g//g'\

Close

This word is outside of quotes. Did you intend to 'nest '"'single quotes'"' instead'?

Problematic code:

alias server_uptime='ssh $host 'uptime -p''

Correct code:

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:

#                   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:

#                   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:

#                   v--match---v
alias server_uptime='ssh $host '"'uptime -p'"
#                               ^---match---^

This results in an alias with embedded single quotes.

Exceptions

None.

Notice

Original content from the ShellCheck https://github.com/koalaman/shellcheck/wiki.

            -e 's/\/.*g//g'\

Close

This word is outside of quotes. Did you intend to 'nest '"'single quotes'"' instead'?

Problematic code:

alias server_uptime='ssh $host 'uptime -p''

Correct code:

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:

#                   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:

#                   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:

#                   v--match---v
alias server_uptime='ssh $host '"'uptime -p'"
#                               ^---match---^

This results in an alias with embedded single quotes.

Exceptions

None.

Notice

Original content from the ShellCheck https://github.com/koalaman/shellcheck/wiki.

                $cmd_part_parallelism\

Close

var is referenced but not assigned.

Problematic code:

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

or

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

or

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

Correct code:

var=name
n=42
echo "${var}_$n.jpg"

or

target="world"
echo "hello $target"

or

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

Rationale:

ShellCheck has noticed that you reference a variable that is not assigned. Double check that the variable is indeed assigned, and that the name is not misspelled.

Note: This message only triggers for variables with lowercase characters in their name (foo and kFOO but not FOO) due to the standard convention of using lowercase variable names for unexported, local variables.

Exceptions:

ShellCheck does not attempt to figure out runtime or dynamic assignments like with source "$(date +%F).sh" or eval var=value.

If you know for a fact that the variable is set, you can use ${var:?} to fail if the variable is unset (or empty), or explicitly initialize/declare it with var="" or declare var. You can also disable the message with a [[directive]].

Notice

Original content from the ShellCheck https://github.com/koalaman/shellcheck/wiki.

    if [[ -s "$opt_whitelist_filename" ]]; then

Close

var is referenced but not assigned.

Problematic code:

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

or

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

or

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

Correct code:

var=name
n=42
echo "${var}_$n.jpg"

or

target="world"
echo "hello $target"

or

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

Rationale:

ShellCheck has noticed that you reference a variable that is not assigned. Double check that the variable is indeed assigned, and that the name is not misspelled.

Note: This message only triggers for variables with lowercase characters in their name (foo and kFOO but not FOO) due to the standard convention of using lowercase variable names for unexported, local variables.

Exceptions:

ShellCheck does not attempt to figure out runtime or dynamic assignments like with source "$(date +%F).sh" or eval var=value.

If you know for a fact that the variable is set, you can use ${var:?} to fail if the variable is unset (or empty), or explicitly initialize/declare it with var="" or declare var. You can also disable the message with a [[directive]].

Notice

Original content from the ShellCheck https://github.com/koalaman/shellcheck/wiki.

            -e 's/\\b//g'\

Close

This word is outside of quotes. Did you intend to 'nest '"'single quotes'"' instead'?

Problematic code:

alias server_uptime='ssh $host 'uptime -p''

Correct code:

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:

#                   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:

#                   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:

#                   v--match---v
alias server_uptime='ssh $host '"'uptime -p'"
#                               ^---match---^

This results in an alias with embedded single quotes.

Exceptions

None.

Notice

Original content from the ShellCheck https://github.com/koalaman/shellcheck/wiki.

            -e 's/^s\///g'\

Close

This word is outside of quotes. Did you intend to 'nest '"'single quotes'"' instead'?

Problematic code:

alias server_uptime='ssh $host 'uptime -p''

Correct code:

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:

#                   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:

#                   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:

#                   v--match---v
alias server_uptime='ssh $host '"'uptime -p'"
#                               ^---match---^

This results in an alias with embedded single quotes.

Exceptions

None.

Notice

Original content from the ShellCheck https://github.com/koalaman/shellcheck/wiki.

        ${directories[*]}\

Close

Double quote to prevent globbing and word splitting.

Problematic code:

echo $1
for i in $*; do :; done # this done and the next one also applies to expanding arrays.
for i in $@; do :; done

Correct code:

echo "$1"
for i in "$@"; do :; done # or, 'for i; do'

Rationale

The first code looks like "print the first argument". It's actually "Split the first argument by IFS (spaces, tabs and line feeds). Expand each of them as if it was a glob. Join all the resulting strings and filenames with spaces. Print the result."

The second one looks like "iterate through all arguments". It's actually "join all the arguments by the first character of IFS (space), split them by IFS and expand each of them as globs, and iterate on the resulting list". The third one skips the joining part.

Quoting variables prevents word splitting and glob expansion, and prevents the script from breaking when input contains spaces, line feeds, glob characters and such.

Strictly speaking, only expansions themselves need to be quoted, but for stylistic reasons, entire arguments with multiple variable and literal parts are often quoted as one:

$HOME/$dir/dist/bin/$file        # Unquoted (bad)
"$HOME"/"$dir"/dist/bin/"$file"  # Minimal quoting (good)
"$HOME/$dir/dist/bin/$file"      # Canonical quoting (good)

When quoting composite arguments, make sure to exclude globs and brace expansions, which lose their special meaning in double quotes: "$HOME/$dir/src/*.c" will not expand, but "$HOME/$dir/src"/*.c will.

Note that $( ) starts a new context, and variables in it have to be quoted independently:

echo "This $variable is quoted $(but this $variable is not)"
echo "This $variable is quoted $(and now this "$variable" is too)"

Exceptions

Sometimes you want to split on spaces, like when building a command line:

options="-j 5 -B"
make $options file

Just quoting this doesn't work. Instead, you should have used an array (bash, ksh, zsh):

options=(-j 5 -B) # ksh: set -A options -- -j 5 -B
make "${options[@]}" file

or a function (POSIX):

make_with_flags() { make -j 5 -B "$@"; }
make_with_flags file

To split on spaces but not perform glob expansion, Posix has a set -f to disable globbing. You can disable word splitting by setting IFS=''.

Similarly, you might want an optional argument:

debug=""
[[ $1 == "--trace-commands" ]] && debug="-x"
bash $debug script

Quoting this doesn't work, since in the default case, "$debug" would expand to one empty argument while $debug would expand into zero arguments. In this case, you can use an array with zero or one elements as outlined above, or you can use an unquoted expansion with an alternate value:

debug=""
[[ $1 == "--trace-commands" ]] && debug="yes"
bash ${debug:+"-x"} script

This is better than an unquoted value because the alternative value can be properly quoted, e.g. wget ${output:+ -o "$output"}.

---

As always, this warning can be [[ignore]]d on a case-by-case basis.

this is especially relevant when BASH many not be available for the array work around. For example, use in eval or in command options where script has total control of the variables...

FLAGS="-av -e 'ssh -x' --delete --delete-excluded"
...
# shellcheck disable=SC2086
eval rsync $FLAGS ~/dir remote_host:dir

Notice

Original content from the ShellCheck https://github.com/koalaman/shellcheck/wiki.

        $COVERAGE_WRAPPER\

Close

Double quote to prevent globbing and word splitting.

Problematic code:

echo $1
for i in $*; do :; done # this done and the next one also applies to expanding arrays.
for i in $@; do :; done

Correct code:

echo "$1"
for i in "$@"; do :; done # or, 'for i; do'

Rationale

The first code looks like "print the first argument". It's actually "Split the first argument by IFS (spaces, tabs and line feeds). Expand each of them as if it was a glob. Join all the resulting strings and filenames with spaces. Print the result."

The second one looks like "iterate through all arguments". It's actually "join all the arguments by the first character of IFS (space), split them by IFS and expand each of them as globs, and iterate on the resulting list". The third one skips the joining part.

Quoting variables prevents word splitting and glob expansion, and prevents the script from breaking when input contains spaces, line feeds, glob characters and such.

Strictly speaking, only expansions themselves need to be quoted, but for stylistic reasons, entire arguments with multiple variable and literal parts are often quoted as one:

$HOME/$dir/dist/bin/$file        # Unquoted (bad)
"$HOME"/"$dir"/dist/bin/"$file"  # Minimal quoting (good)
"$HOME/$dir/dist/bin/$file"      # Canonical quoting (good)

When quoting composite arguments, make sure to exclude globs and brace expansions, which lose their special meaning in double quotes: "$HOME/$dir/src/*.c" will not expand, but "$HOME/$dir/src"/*.c will.

Note that $( ) starts a new context, and variables in it have to be quoted independently:

echo "This $variable is quoted $(but this $variable is not)"
echo "This $variable is quoted $(and now this "$variable" is too)"

Exceptions

Sometimes you want to split on spaces, like when building a command line:

options="-j 5 -B"
make $options file

Just quoting this doesn't work. Instead, you should have used an array (bash, ksh, zsh):

options=(-j 5 -B) # ksh: set -A options -- -j 5 -B
make "${options[@]}" file

or a function (POSIX):

make_with_flags() { make -j 5 -B "$@"; }
make_with_flags file

To split on spaces but not perform glob expansion, Posix has a set -f to disable globbing. You can disable word splitting by setting IFS=''.

Similarly, you might want an optional argument:

debug=""
[[ $1 == "--trace-commands" ]] && debug="-x"
bash $debug script

Quoting this doesn't work, since in the default case, "$debug" would expand to one empty argument while $debug would expand into zero arguments. In this case, you can use an array with zero or one elements as outlined above, or you can use an unquoted expansion with an alternate value:

debug=""
[[ $1 == "--trace-commands" ]] && debug="yes"
bash ${debug:+"-x"} script

This is better than an unquoted value because the alternative value can be properly quoted, e.g. wget ${output:+ -o "$output"}.

---

As always, this warning can be [[ignore]]d on a case-by-case basis.

this is especially relevant when BASH many not be available for the array work around. For example, use in eval or in command options where script has total control of the variables...

FLAGS="-av -e 'ssh -x' --delete --delete-excluded"
...
# shellcheck disable=SC2086
eval rsync $FLAGS ~/dir remote_host:dir

Notice

Original content from the ShellCheck https://github.com/koalaman/shellcheck/wiki.

        $cmd_part_ignore\

Close

var is referenced but not assigned.

Problematic code:

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

or

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

or

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

Correct code:

var=name
n=42
echo "${var}_$n.jpg"

or

target="world"
echo "hello $target"

or

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

Rationale:

ShellCheck has noticed that you reference a variable that is not assigned. Double check that the variable is indeed assigned, and that the name is not misspelled.

Note: This message only triggers for variables with lowercase characters in their name (foo and kFOO but not FOO) due to the standard convention of using lowercase variable names for unexported, local variables.

Exceptions:

ShellCheck does not attempt to figure out runtime or dynamic assignments like with source "$(date +%F).sh" or eval var=value.

If you know for a fact that the variable is set, you can use ${var:?} to fail if the variable is unset (or empty), or explicitly initialize/declare it with var="" or declare var. You can also disable the message with a [[directive]].

Notice

Original content from the ShellCheck https://github.com/koalaman/shellcheck/wiki.

        -and \( $opt_name_filter \)\

Close

var is referenced but not assigned.

Problematic code:

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

or

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

or

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

Correct code:

var=name
n=42
echo "${var}_$n.jpg"

or

target="world"
echo "hello $target"

or

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

Rationale:

ShellCheck has noticed that you reference a variable that is not assigned. Double check that the variable is indeed assigned, and that the name is not misspelled.

Note: This message only triggers for variables with lowercase characters in their name (foo and kFOO but not FOO) due to the standard convention of using lowercase variable names for unexported, local variables.

Exceptions:

ShellCheck does not attempt to figure out runtime or dynamic assignments like with source "$(date +%F).sh" or eval var=value.

If you know for a fact that the variable is set, you can use ${var:?} to fail if the variable is unset (or empty), or explicitly initialize/declare it with var="" or declare var. You can also disable the message with a [[directive]].

Notice

Original content from the ShellCheck https://github.com/koalaman/shellcheck/wiki.

            -c$bash_arg\

Close

Double quote to prevent globbing and word splitting.

Problematic code:

echo $1
for i in $*; do :; done # this done and the next one also applies to expanding arrays.
for i in $@; do :; done

Correct code:

echo "$1"
for i in "$@"; do :; done # or, 'for i; do'

Rationale

The first code looks like "print the first argument". It's actually "Split the first argument by IFS (spaces, tabs and line feeds). Expand each of them as if it was a glob. Join all the resulting strings and filenames with spaces. Print the result."

The second one looks like "iterate through all arguments". It's actually "join all the arguments by the first character of IFS (space), split them by IFS and expand each of them as globs, and iterate on the resulting list". The third one skips the joining part.

Quoting variables prevents word splitting and glob expansion, and prevents the script from breaking when input contains spaces, line feeds, glob characters and such.

Strictly speaking, only expansions themselves need to be quoted, but for stylistic reasons, entire arguments with multiple variable and literal parts are often quoted as one:

$HOME/$dir/dist/bin/$file        # Unquoted (bad)
"$HOME"/"$dir"/dist/bin/"$file"  # Minimal quoting (good)
"$HOME/$dir/dist/bin/$file"      # Canonical quoting (good)

When quoting composite arguments, make sure to exclude globs and brace expansions, which lose their special meaning in double quotes: "$HOME/$dir/src/*.c" will not expand, but "$HOME/$dir/src"/*.c will.

Note that $( ) starts a new context, and variables in it have to be quoted independently:

echo "This $variable is quoted $(but this $variable is not)"
echo "This $variable is quoted $(and now this "$variable" is too)"

Exceptions

Sometimes you want to split on spaces, like when building a command line:

options="-j 5 -B"
make $options file

Just quoting this doesn't work. Instead, you should have used an array (bash, ksh, zsh):

options=(-j 5 -B) # ksh: set -A options -- -j 5 -B
make "${options[@]}" file

or a function (POSIX):

make_with_flags() { make -j 5 -B "$@"; }
make_with_flags file

To split on spaces but not perform glob expansion, Posix has a set -f to disable globbing. You can disable word splitting by setting IFS=''.

Similarly, you might want an optional argument:

debug=""
[[ $1 == "--trace-commands" ]] && debug="-x"
bash $debug script

Quoting this doesn't work, since in the default case, "$debug" would expand to one empty argument while $debug would expand into zero arguments. In this case, you can use an array with zero or one elements as outlined above, or you can use an unquoted expansion with an alternate value:

debug=""
[[ $1 == "--trace-commands" ]] && debug="yes"
bash ${debug:+"-x"} script

This is better than an unquoted value because the alternative value can be properly quoted, e.g. wget ${output:+ -o "$output"}.

---

As always, this warning can be [[ignore]]d on a case-by-case basis.

this is especially relevant when BASH many not be available for the array work around. For example, use in eval or in command options where script has total control of the variables...

FLAGS="-av -e 'ssh -x' --delete --delete-excluded"
...
# shellcheck disable=SC2086
eval rsync $FLAGS ~/dir remote_host:dir

Notice

Original content from the ShellCheck https://github.com/koalaman/shellcheck/wiki.

        'bin/sed'\

Close

This word is outside of quotes. Did you intend to 'nest '"'single quotes'"' instead'?

Problematic code:

alias server_uptime='ssh $host 'uptime -p''

Correct code:

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:

#                   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:

#                   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:

#                   v--match---v
alias server_uptime='ssh $host '"'uptime -p'"
#                               ^---match---^

This results in an alias with embedded single quotes.

Exceptions

None.

Notice

Original content from the ShellCheck https://github.com/koalaman/shellcheck/wiki.

        $enabled_rules\

Close

Double quote to prevent globbing and word splitting.

Problematic code:

echo $1
for i in $*; do :; done # this done and the next one also applies to expanding arrays.
for i in $@; do :; done

Correct code:

echo "$1"
for i in "$@"; do :; done # or, 'for i; do'

Rationale

The first code looks like "print the first argument". It's actually "Split the first argument by IFS (spaces, tabs and line feeds). Expand each of them as if it was a glob. Join all the resulting strings and filenames with spaces. Print the result."

The second one looks like "iterate through all arguments". It's actually "join all the arguments by the first character of IFS (space), split them by IFS and expand each of them as globs, and iterate on the resulting list". The third one skips the joining part.

Quoting variables prevents word splitting and glob expansion, and prevents the script from breaking when input contains spaces, line feeds, glob characters and such.

Strictly speaking, only expansions themselves need to be quoted, but for stylistic reasons, entire arguments with multiple variable and literal parts are often quoted as one:

$HOME/$dir/dist/bin/$file        # Unquoted (bad)
"$HOME"/"$dir"/dist/bin/"$file"  # Minimal quoting (good)
"$HOME/$dir/dist/bin/$file"      # Canonical quoting (good)

When quoting composite arguments, make sure to exclude globs and brace expansions, which lose their special meaning in double quotes: "$HOME/$dir/src/*.c" will not expand, but "$HOME/$dir/src"/*.c will.

Note that $( ) starts a new context, and variables in it have to be quoted independently:

echo "This $variable is quoted $(but this $variable is not)"
echo "This $variable is quoted $(and now this "$variable" is too)"

Exceptions

Sometimes you want to split on spaces, like when building a command line:

options="-j 5 -B"
make $options file

Just quoting this doesn't work. Instead, you should have used an array (bash, ksh, zsh):

options=(-j 5 -B) # ksh: set -A options -- -j 5 -B
make "${options[@]}" file

or a function (POSIX):

make_with_flags() { make -j 5 -B "$@"; }
make_with_flags file

To split on spaces but not perform glob expansion, Posix has a set -f to disable globbing. You can disable word splitting by setting IFS=''.

Similarly, you might want an optional argument:

debug=""
[[ $1 == "--trace-commands" ]] && debug="-x"
bash $debug script

Quoting this doesn't work, since in the default case, "$debug" would expand to one empty argument while $debug would expand into zero arguments. In this case, you can use an array with zero or one elements as outlined above, or you can use an unquoted expansion with an alternate value:

debug=""
[[ $1 == "--trace-commands" ]] && debug="yes"
bash ${debug:+"-x"} script

This is better than an unquoted value because the alternative value can be properly quoted, e.g. wget ${output:+ -o "$output"}.

---

As always, this warning can be [[ignore]]d on a case-by-case basis.

this is especially relevant when BASH many not be available for the array work around. For example, use in eval or in command options where script has total control of the variables...

FLAGS="-av -e 'ssh -x' --delete --delete-excluded"
...
# shellcheck disable=SC2086
eval rsync $FLAGS ~/dir remote_host:dir

Notice

Original content from the ShellCheck https://github.com/koalaman/shellcheck/wiki.

        -v '\\b'\

Close

This word is outside of quotes. Did you intend to 'nest '"'single quotes'"' instead'?

Problematic code:

alias server_uptime='ssh $host 'uptime -p''

Correct code:

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:

#                   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:

#                   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:

#                   v--match---v
alias server_uptime='ssh $host '"'uptime -p'"
#                               ^---match---^

This results in an alias with embedded single quotes.

Exceptions

None.

Notice

Original content from the ShellCheck https://github.com/koalaman/shellcheck/wiki.

        -and \( $opt_name_filter \)\

Close

Double quote to prevent globbing and word splitting.

Problematic code:

echo $1
for i in $*; do :; done # this done and the next one also applies to expanding arrays.
for i in $@; do :; done

Correct code:

echo "$1"
for i in "$@"; do :; done # or, 'for i; do'

Rationale

The first code looks like "print the first argument". It's actually "Split the first argument by IFS (spaces, tabs and line feeds). Expand each of them as if it was a glob. Join all the resulting strings and filenames with spaces. Print the result."

The second one looks like "iterate through all arguments". It's actually "join all the arguments by the first character of IFS (space), split them by IFS and expand each of them as globs, and iterate on the resulting list". The third one skips the joining part.

Quoting variables prevents word splitting and glob expansion, and prevents the script from breaking when input contains spaces, line feeds, glob characters and such.

Strictly speaking, only expansions themselves need to be quoted, but for stylistic reasons, entire arguments with multiple variable and literal parts are often quoted as one:

$HOME/$dir/dist/bin/$file        # Unquoted (bad)
"$HOME"/"$dir"/dist/bin/"$file"  # Minimal quoting (good)
"$HOME/$dir/dist/bin/$file"      # Canonical quoting (good)

When quoting composite arguments, make sure to exclude globs and brace expansions, which lose their special meaning in double quotes: "$HOME/$dir/src/*.c" will not expand, but "$HOME/$dir/src"/*.c will.

Note that $( ) starts a new context, and variables in it have to be quoted independently:

echo "This $variable is quoted $(but this $variable is not)"
echo "This $variable is quoted $(and now this "$variable" is too)"

Exceptions

Sometimes you want to split on spaces, like when building a command line:

options="-j 5 -B"
make $options file

Just quoting this doesn't work. Instead, you should have used an array (bash, ksh, zsh):

options=(-j 5 -B) # ksh: set -A options -- -j 5 -B
make "${options[@]}" file

or a function (POSIX):

make_with_flags() { make -j 5 -B "$@"; }
make_with_flags file

To split on spaces but not perform glob expansion, Posix has a set -f to disable globbing. You can disable word splitting by setting IFS=''.

Similarly, you might want an optional argument:

debug=""
[[ $1 == "--trace-commands" ]] && debug="-x"
bash $debug script

Quoting this doesn't work, since in the default case, "$debug" would expand to one empty argument while $debug would expand into zero arguments. In this case, you can use an array with zero or one elements as outlined above, or you can use an unquoted expansion with an alternate value:

debug=""
[[ $1 == "--trace-commands" ]] && debug="yes"
bash ${debug:+"-x"} script

This is better than an unquoted value because the alternative value can be properly quoted, e.g. wget ${output:+ -o "$output"}.

---

As always, this warning can be [[ignore]]d on a case-by-case basis.

this is especially relevant when BASH many not be available for the array work around. For example, use in eval or in command options where script has total control of the variables...

FLAGS="-av -e 'ssh -x' --delete --delete-excluded"
...
# shellcheck disable=SC2086
eval rsync $FLAGS ~/dir remote_host:dir

Notice

Original content from the ShellCheck https://github.com/koalaman/shellcheck/wiki.

                $cmd_part_parallelism\

Close

Double quote to prevent globbing and word splitting.

Problematic code:

echo $1
for i in $*; do :; done # this done and the next one also applies to expanding arrays.
for i in $@; do :; done

Correct code:

echo "$1"
for i in "$@"; do :; done # or, 'for i; do'

Rationale

The first code looks like "print the first argument". It's actually "Split the first argument by IFS (spaces, tabs and line feeds). Expand each of them as if it was a glob. Join all the resulting strings and filenames with spaces. Print the result."

The second one looks like "iterate through all arguments". It's actually "join all the arguments by the first character of IFS (space), split them by IFS and expand each of them as globs, and iterate on the resulting list". The third one skips the joining part.

Quoting variables prevents word splitting and glob expansion, and prevents the script from breaking when input contains spaces, line feeds, glob characters and such.

Strictly speaking, only expansions themselves need to be quoted, but for stylistic reasons, entire arguments with multiple variable and literal parts are often quoted as one:

$HOME/$dir/dist/bin/$file        # Unquoted (bad)
"$HOME"/"$dir"/dist/bin/"$file"  # Minimal quoting (good)
"$HOME/$dir/dist/bin/$file"      # Canonical quoting (good)

When quoting composite arguments, make sure to exclude globs and brace expansions, which lose their special meaning in double quotes: "$HOME/$dir/src/*.c" will not expand, but "$HOME/$dir/src"/*.c will.

Note that $( ) starts a new context, and variables in it have to be quoted independently:

echo "This $variable is quoted $(but this $variable is not)"
echo "This $variable is quoted $(and now this "$variable" is too)"

Exceptions

Sometimes you want to split on spaces, like when building a command line:

options="-j 5 -B"
make $options file

Just quoting this doesn't work. Instead, you should have used an array (bash, ksh, zsh):

options=(-j 5 -B) # ksh: set -A options -- -j 5 -B
make "${options[@]}" file

or a function (POSIX):

make_with_flags() { make -j 5 -B "$@"; }
make_with_flags file

To split on spaces but not perform glob expansion, Posix has a set -f to disable globbing. You can disable word splitting by setting IFS=''.

Similarly, you might want an optional argument:

debug=""
[[ $1 == "--trace-commands" ]] && debug="-x"
bash $debug script

Quoting this doesn't work, since in the default case, "$debug" would expand to one empty argument while $debug would expand into zero arguments. In this case, you can use an array with zero or one elements as outlined above, or you can use an unquoted expansion with an alternate value:

debug=""
[[ $1 == "--trace-commands" ]] && debug="yes"
bash ${debug:+"-x"} script

This is better than an unquoted value because the alternative value can be properly quoted, e.g. wget ${output:+ -o "$output"}.

---

As always, this warning can be [[ignore]]d on a case-by-case basis.

this is especially relevant when BASH many not be available for the array work around. For example, use in eval or in command options where script has total control of the variables...

FLAGS="-av -e 'ssh -x' --delete --delete-excluded"
...
# shellcheck disable=SC2086
eval rsync $FLAGS ~/dir remote_host:dir

Notice

Original content from the ShellCheck https://github.com/koalaman/shellcheck/wiki.

function prepare_rules_for_prefiltering {

Close

Tips depend on target shell and yours is unknown. Add a shebang.

Problematic code:

echo "$RANDOM"   # Does this work?

Correct code:

#!/bin/sh
echo "$RANDOM"  # Unsupported in sh. Produces warning.

or

#!/bin/bash
echo "$RANDOM"  # Supported in bash. No warnings.

Rationale:

Different shells support different features. To give effective advice, ShellCheck needs to know which shell your script is going to run on. You will get a different numbers of warnings about different things depending on your target shell.

ShellCheck normally determines your target shell from the shebang (having e.g. #!/bin/sh as the first line). The shell can also be specified from the CLI with -s, e.g. shellcheck -s sh file.

If you don't specify shebang nor -s, ShellCheck gives this message and proceeds with some default (bash).

Note that this error can not be ignored with a [[directive]]. It is not a suggestion to improve your script, but a warning that ShellCheck lacks information it needs to be helpful.

Exceptions

None. Please either add a shebang or use -s.

Notice

Original content from the ShellCheck https://github.com/koalaman/shellcheck/wiki.

            -e 's/^s\///g'\

Close

This word is outside of quotes. Did you intend to 'nest '"'single quotes'"' instead'?

Problematic code:

alias server_uptime='ssh $host 'uptime -p''

Correct code:

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:

#                   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:

#                   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:

#                   v--match---v
alias server_uptime='ssh $host '"'uptime -p'"
#                               ^---match---^

This results in an alias with embedded single quotes.

Exceptions

None.

Notice

Original content from the ShellCheck https://github.com/koalaman/shellcheck/wiki.

        >"$tmpfile.prepared.sed.all_rules"

Close

var is referenced but not assigned.

Problematic code:

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

or

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

or

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

Correct code:

var=name
n=42
echo "${var}_$n.jpg"

or

target="world"
echo "hello $target"

or

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

Rationale:

ShellCheck has noticed that you reference a variable that is not assigned. Double check that the variable is indeed assigned, and that the name is not misspelled.

Note: This message only triggers for variables with lowercase characters in their name (foo and kFOO but not FOO) due to the standard convention of using lowercase variable names for unexported, local variables.

Exceptions:

ShellCheck does not attempt to figure out runtime or dynamic assignments like with source "$(date +%F).sh" or eval var=value.

If you know for a fact that the variable is set, you can use ${var:?} to fail if the variable is unset (or empty), or explicitly initialize/declare it with var="" or declare var. You can also disable the message with a [[directive]].

Notice

Original content from the ShellCheck https://github.com/koalaman/shellcheck/wiki.

        '\\b'\

Close

This word is outside of quotes. Did you intend to 'nest '"'single quotes'"' instead'?

Problematic code:

alias server_uptime='ssh $host 'uptime -p''

Correct code:

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:

#                   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:

#                   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:

#                   v--match---v
alias server_uptime='ssh $host '"'uptime -p'"
#                               ^---match---^

This results in an alias with embedded single quotes.

Exceptions

None.

Notice

Original content from the ShellCheck https://github.com/koalaman/shellcheck/wiki.

        ${directories[*]}\

Close

var is referenced but not assigned.

Problematic code:

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

or

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

or

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

Correct code:

var=name
n=42
echo "${var}_$n.jpg"

or

target="world"
echo "hello $target"

or

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

Rationale:

ShellCheck has noticed that you reference a variable that is not assigned. Double check that the variable is indeed assigned, and that the name is not misspelled.

Note: This message only triggers for variables with lowercase characters in their name (foo and kFOO but not FOO) due to the standard convention of using lowercase variable names for unexported, local variables.

Exceptions:

ShellCheck does not attempt to figure out runtime or dynamic assignments like with source "$(date +%F).sh" or eval var=value.

If you know for a fact that the variable is set, you can use ${var:?} to fail if the variable is unset (or empty), or explicitly initialize/declare it with var="" or declare var. You can also disable the message with a [[directive]].

Notice

Original content from the ShellCheck https://github.com/koalaman/shellcheck/wiki.

        if [[ $opt_whitelist_save = 1 ]]; then

Close

var is referenced but not assigned.

Problematic code:

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

or

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

or

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

Correct code:

var=name
n=42
echo "${var}_$n.jpg"

or

target="world"
echo "hello $target"

or

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

Rationale:

ShellCheck has noticed that you reference a variable that is not assigned. Double check that the variable is indeed assigned, and that the name is not misspelled.

Note: This message only triggers for variables with lowercase characters in their name (foo and kFOO but not FOO) due to the standard convention of using lowercase variable names for unexported, local variables.

Exceptions:

ShellCheck does not attempt to figure out runtime or dynamic assignments like with source "$(date +%F).sh" or eval var=value.

If you know for a fact that the variable is set, you can use ${var:?} to fail if the variable is unset (or empty), or explicitly initialize/declare it with var="" or declare var. You can also disable the message with a [[directive]].

Notice

Original content from the ShellCheck https://github.com/koalaman/shellcheck/wiki.

    if [[ $opt_dots = 1 ]]; then

Close

var is referenced but not assigned.

Problematic code:

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

or

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

or

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

Correct code:

var=name
n=42
echo "${var}_$n.jpg"

or

target="world"
echo "hello $target"

or

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

Rationale:

ShellCheck has noticed that you reference a variable that is not assigned. Double check that the variable is indeed assigned, and that the name is not misspelled.

Note: This message only triggers for variables with lowercase characters in their name (foo and kFOO but not FOO) due to the standard convention of using lowercase variable names for unexported, local variables.

Exceptions:

ShellCheck does not attempt to figure out runtime or dynamic assignments like with source "$(date +%F).sh" or eval var=value.

If you know for a fact that the variable is set, you can use ${var:?} to fail if the variable is unset (or empty), or explicitly initialize/declare it with var="" or declare var. You can also disable the message with a [[directive]].

Notice

Original content from the ShellCheck https://github.com/koalaman/shellcheck/wiki.

    if [[ $opt_verbose = 1 ]]; then

Close

var is referenced but not assigned.

Problematic code:

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

or

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

or

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

Correct code:

var=name
n=42
echo "${var}_$n.jpg"

or

target="world"
echo "hello $target"

or

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

Rationale:

ShellCheck has noticed that you reference a variable that is not assigned. Double check that the variable is indeed assigned, and that the name is not misspelled.

Note: This message only triggers for variables with lowercase characters in their name (foo and kFOO but not FOO) due to the standard convention of using lowercase variable names for unexported, local variables.

Exceptions:

ShellCheck does not attempt to figure out runtime or dynamic assignments like with source "$(date +%F).sh" or eval var=value.

If you know for a fact that the variable is set, you can use ${var:?} to fail if the variable is unset (or empty), or explicitly initialize/declare it with var="" or declare var. You can also disable the message with a [[directive]].

Notice

Original content from the ShellCheck https://github.com/koalaman/shellcheck/wiki.

        $opt_real_run = 1 ]]

Close

var is referenced but not assigned.

Problematic code:

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

or

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

or

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

Correct code:

var=name
n=42
echo "${var}_$n.jpg"

or

target="world"
echo "hello $target"

or

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

Rationale:

ShellCheck has noticed that you reference a variable that is not assigned. Double check that the variable is indeed assigned, and that the name is not misspelled.

Note: This message only triggers for variables with lowercase characters in their name (foo and kFOO but not FOO) due to the standard convention of using lowercase variable names for unexported, local variables.

Exceptions:

ShellCheck does not attempt to figure out runtime or dynamic assignments like with source "$(date +%F).sh" or eval var=value.

If you know for a fact that the variable is set, you can use ${var:?} to fail if the variable is unset (or empty), or explicitly initialize/declare it with var="" or declare var. You can also disable the message with a [[directive]].

Notice

Original content from the ShellCheck https://github.com/koalaman/shellcheck/wiki.

        $cmd_part_ignore\

Close

Double quote to prevent globbing and word splitting.

Problematic code:

echo $1
for i in $*; do :; done # this done and the next one also applies to expanding arrays.
for i in $@; do :; done

Correct code:

echo "$1"
for i in "$@"; do :; done # or, 'for i; do'

Rationale

The first code looks like "print the first argument". It's actually "Split the first argument by IFS (spaces, tabs and line feeds). Expand each of them as if it was a glob. Join all the resulting strings and filenames with spaces. Print the result."

The second one looks like "iterate through all arguments". It's actually "join all the arguments by the first character of IFS (space), split them by IFS and expand each of them as globs, and iterate on the resulting list". The third one skips the joining part.

Quoting variables prevents word splitting and glob expansion, and prevents the script from breaking when input contains spaces, line feeds, glob characters and such.

Strictly speaking, only expansions themselves need to be quoted, but for stylistic reasons, entire arguments with multiple variable and literal parts are often quoted as one:

$HOME/$dir/dist/bin/$file        # Unquoted (bad)
"$HOME"/"$dir"/dist/bin/"$file"  # Minimal quoting (good)
"$HOME/$dir/dist/bin/$file"      # Canonical quoting (good)

When quoting composite arguments, make sure to exclude globs and brace expansions, which lose their special meaning in double quotes: "$HOME/$dir/src/*.c" will not expand, but "$HOME/$dir/src"/*.c will.

Note that $( ) starts a new context, and variables in it have to be quoted independently:

echo "This $variable is quoted $(but this $variable is not)"
echo "This $variable is quoted $(and now this "$variable" is too)"

Exceptions

Sometimes you want to split on spaces, like when building a command line:

options="-j 5 -B"
make $options file

Just quoting this doesn't work. Instead, you should have used an array (bash, ksh, zsh):

options=(-j 5 -B) # ksh: set -A options -- -j 5 -B
make "${options[@]}" file

or a function (POSIX):

make_with_flags() { make -j 5 -B "$@"; }
make_with_flags file

To split on spaces but not perform glob expansion, Posix has a set -f to disable globbing. You can disable word splitting by setting IFS=''.

Similarly, you might want an optional argument:

debug=""
[[ $1 == "--trace-commands" ]] && debug="-x"
bash $debug script

Quoting this doesn't work, since in the default case, "$debug" would expand to one empty argument while $debug would expand into zero arguments. In this case, you can use an array with zero or one elements as outlined above, or you can use an unquoted expansion with an alternate value:

debug=""
[[ $1 == "--trace-commands" ]] && debug="yes"
bash ${debug:+"-x"} script

This is better than an unquoted value because the alternative value can be properly quoted, e.g. wget ${output:+ -o "$output"}.

---

As always, this warning can be [[ignore]]d on a case-by-case basis.

this is especially relevant when BASH many not be available for the array work around. For example, use in eval or in command options where script has total control of the variables...

FLAGS="-av -e 'ssh -x' --delete --delete-excluded"
...
# shellcheck disable=SC2086
eval rsync $FLAGS ~/dir remote_host:dir

Notice

Original content from the ShellCheck https://github.com/koalaman/shellcheck/wiki.

        -d ':'\

Close

This word is outside of quotes. Did you intend to 'nest '"'single quotes'"' instead'?

Problematic code:

alias server_uptime='ssh $host 'uptime -p''

Correct code:

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:

#                   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:

#                   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:

#                   v--match---v
alias server_uptime='ssh $host '"'uptime -p'"
#                               ^---match---^

This results in an alias with embedded single quotes.

Exceptions

None.

Notice

Original content from the ShellCheck https://github.com/koalaman/shellcheck/wiki.

        $enabled_rules\

Close

var is referenced but not assigned.

Problematic code:

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

or

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

or

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

Correct code:

var=name
n=42
echo "${var}_$n.jpg"

or

target="world"
echo "hello $target"

or

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

Rationale:

ShellCheck has noticed that you reference a variable that is not assigned. Double check that the variable is indeed assigned, and that the name is not misspelled.

Note: This message only triggers for variables with lowercase characters in their name (foo and kFOO but not FOO) due to the standard convention of using lowercase variable names for unexported, local variables.

Exceptions:

ShellCheck does not attempt to figure out runtime or dynamic assignments like with source "$(date +%F).sh" or eval var=value.

If you know for a fact that the variable is set, you can use ${var:?} to fail if the variable is unset (or empty), or explicitly initialize/declare it with var="" or declare var. You can also disable the message with a [[directive]].

Notice

Original content from the ShellCheck https://github.com/koalaman/shellcheck/wiki.

        $cmd_size\

Close

var is referenced but not assigned.

Problematic code:

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

or

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

or

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

Correct code:

var=name
n=42
echo "${var}_$n.jpg"

or

target="world"
echo "hello $target"

or

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

Rationale:

ShellCheck has noticed that you reference a variable that is not assigned. Double check that the variable is indeed assigned, and that the name is not misspelled.

Note: This message only triggers for variables with lowercase characters in their name (foo and kFOO but not FOO) due to the standard convention of using lowercase variable names for unexported, local variables.

Exceptions:

ShellCheck does not attempt to figure out runtime or dynamic assignments like with source "$(date +%F).sh" or eval var=value.

If you know for a fact that the variable is set, you can use ${var:?} to fail if the variable is unset (or empty), or explicitly initialize/declare it with var="" or declare var. You can also disable the message with a [[directive]].

Notice

Original content from the ShellCheck https://github.com/koalaman/shellcheck/wiki.

            -d ':'\

Close

This word is outside of quotes. Did you intend to 'nest '"'single quotes'"' instead'?

Problematic code:

alias server_uptime='ssh $host 'uptime -p''

Correct code:

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:

#                   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:

#                   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:

#                   v--match---v
alias server_uptime='ssh $host '"'uptime -p'"
#                               ^---match---^

This results in an alias with embedded single quotes.

Exceptions

None.

Notice

Original content from the ShellCheck https://github.com/koalaman/shellcheck/wiki.

        -I '{}'\

Close

This word is outside of quotes. Did you intend to 'nest '"'single quotes'"' instead'?

Problematic code:

alias server_uptime='ssh $host 'uptime -p''

Correct code:

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:

#                   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:

#                   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:

#                   v--match---v
alias server_uptime='ssh $host '"'uptime -p'"
#                               ^---match---^

This results in an alias with embedded single quotes.

Exceptions

None.

Notice

Original content from the ShellCheck https://github.com/koalaman/shellcheck/wiki.

            -c$bash_arg\

Close

var is referenced but not assigned.

Problematic code:

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

or

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

or

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

Correct code:

var=name
n=42
echo "${var}_$n.jpg"

or

target="world"
echo "hello $target"

or

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

Rationale:

ShellCheck has noticed that you reference a variable that is not assigned. Double check that the variable is indeed assigned, and that the name is not misspelled.

Note: This message only triggers for variables with lowercase characters in their name (foo and kFOO but not FOO) due to the standard convention of using lowercase variable names for unexported, local variables.

Exceptions:

ShellCheck does not attempt to figure out runtime or dynamic assignments like with source "$(date +%F).sh" or eval var=value.

If you know for a fact that the variable is set, you can use ${var:?} to fail if the variable is unset (or empty), or explicitly initialize/declare it with var="" or declare var. You can also disable the message with a [[directive]].

Notice

Original content from the ShellCheck https://github.com/koalaman/shellcheck/wiki.

            "$loop_function\

Close

var is referenced but not assigned.

Problematic code:

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

or

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

or

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

Correct code:

var=name
n=42
echo "${var}_$n.jpg"

or

target="world"
echo "hello $target"

or

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

Rationale:

ShellCheck has noticed that you reference a variable that is not assigned. Double check that the variable is indeed assigned, and that the name is not misspelled.

Note: This message only triggers for variables with lowercase characters in their name (foo and kFOO but not FOO) due to the standard convention of using lowercase variable names for unexported, local variables.

Exceptions:

ShellCheck does not attempt to figure out runtime or dynamic assignments like with source "$(date +%F).sh" or eval var=value.

If you know for a fact that the variable is set, you can use ${var:?} to fail if the variable is unset (or empty), or explicitly initialize/declare it with var="" or declare var. You can also disable the message with a [[directive]].

Notice

Original content from the ShellCheck https://github.com/koalaman/shellcheck/wiki.

                -e 's/^/^/'\

Close

This word is outside of quotes. Did you intend to 'nest '"'single quotes'"' instead'?

Problematic code:

alias server_uptime='ssh $host 'uptime -p''

Correct code:

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:

#                   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:

#                   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:

#                   v--match---v
alias server_uptime='ssh $host '"'uptime -p'"
#                               ^---match---^

This results in an alias with embedded single quotes.

Exceptions

None.

Notice

Original content from the ShellCheck https://github.com/koalaman/shellcheck/wiki.

    if [[ $smart_sed = 1 ]]; then

Close

var is referenced but not assigned.

Problematic code:

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

or

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

or

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

Correct code:

var=name
n=42
echo "${var}_$n.jpg"

or

target="world"
echo "hello $target"

or

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

Rationale:

ShellCheck has noticed that you reference a variable that is not assigned. Double check that the variable is indeed assigned, and that the name is not misspelled.

Note: This message only triggers for variables with lowercase characters in their name (foo and kFOO but not FOO) due to the standard convention of using lowercase variable names for unexported, local variables.

Exceptions:

ShellCheck does not attempt to figure out runtime or dynamic assignments like with source "$(date +%F).sh" or eval var=value.

If you know for a fact that the variable is set, you can use ${var:?} to fail if the variable is unset (or empty), or explicitly initialize/declare it with var="" or declare var. You can also disable the message with a [[directive]].

Notice

Original content from the ShellCheck https://github.com/koalaman/shellcheck/wiki.

            if [[ $opt_backup = 1 ]]; then

Close

var is referenced but not assigned.

Problematic code:

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

or

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

or

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

Correct code:

var=name
n=42
echo "${var}_$n.jpg"

or

target="world"
echo "hello $target"

or

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

Rationale:

ShellCheck has noticed that you reference a variable that is not assigned. Double check that the variable is indeed assigned, and that the name is not misspelled.

Note: This message only triggers for variables with lowercase characters in their name (foo and kFOO but not FOO) due to the standard convention of using lowercase variable names for unexported, local variables.

Exceptions:

ShellCheck does not attempt to figure out runtime or dynamic assignments like with source "$(date +%F).sh" or eval var=value.

If you know for a fact that the variable is set, you can use ${var:?} to fail if the variable is unset (or empty), or explicitly initialize/declare it with var="" or declare var. You can also disable the message with a [[directive]].

Notice

Original content from the ShellCheck https://github.com/koalaman/shellcheck/wiki.