$ is not used specially and should therefore be escaped.

This `\o` will be a regular 'o' in this context.

Want to escape a single quote? echo 'This is how it'\\''s done'.

This backslash+linefeed is literal. Break outside single quotes if you just want to break the line.

Remove space after = if trying to assign a value (or for empty string, use var='' ... ).

The mentioned parser error was in ...

Use semicolon or linefeed before 'done' (or quote to make it literal).

This apostrophe terminated the single quoted string!

Use 'if cmd; then ..' to check exit code, or 'if [\[ $(cmd) == .. ]]' to check output.

This is a unicode double quote. Delete and retype it.

This is a Unicode single quote. Delete and retype it.

This is a unicode non-breaking space. Delete it and retype as space.

You need a space before the if single then "]" else "]]"

In [..] you have to escape \\( \\) or preferably combine [..] expressions.

In `[[..]]` you shouldn't escape `(` or `)`.

You need a space here

Braces are required for positionals over 9, e.g. ${10}.

Shells are space sensitive. Use '< <(cmd)', not '<<(cmd)'.

When using <<-, you can only indent with tabs.

Found 'eof' further down, but not on a separate line.

It's not 'foo &; bar', just 'foo & bar'.

Couldn't find 'fi' for this 'if'

Can't have empty then clauses (use 'true' as a no-op).

Did you forget the 'then' for this 'if'?

Semicolons directly after 'then' are not allowed. Just remove it.

Semicolons directly after 'then' are not allowed. Just remove it.

Semicolons directly after 'else' are not allowed. Just remove it.

You need a space after the '{'.

Expected a { to open the function definition.

Trying to declare parameters? Don't. Use () and refer to params as $1, $2..

Don't use $ on the left side of assignments.

Don't put spaces around the = in assignments.

ShellCheck only supports sh/bash/dash/ksh scripts. Sorry!

Unexpected ..

Couldn't parse this ...

Use 'elif' instead of 'else if'.

For command expansion, the tick should slant left (` vs ´).

Did you forget to close this double quoted string?

This is actually an end quote, but due to next char it looks suspect.

Scripts are case sensitive. Use 'if', not 'If'.

This file has a UTF-8 BOM. Remove it with: LC_CTYPE=C sed '1s/^...//' < yourscript .

This `{`/`}` is literal. Check expression (missing `;/\n?`) or quote it.

Use #!, not !#, for the shebang.

Don't use $ on the iterator name in for loops.

Braces are required when expanding arrays, as in ${array[idx]}.

Parsing stopped here. Invalid use of parentheses?

Parsing stopped here. Is this keyword correctly matched up?

Can't follow non-constant source. Use a directive to specify location.

Not following: (error message here)

Parsing of sourced file failed. Ignoring it.

You need a space or linefeed between the function name and body.

Unexpected ==. For assignment, use =. For comparison, use [/[[.

Quote/escape special characters when using eval, e.g. eval "a=(b)".

You need a space before the #.

This is a unicode dash. Delete and retype as ASCII minus.

Delete trailing spaces after \ to break line (or use quotes for literal space).

Shells disambiguate $(( differently or not at all. If the first $( should start command substitution, add a space after it.

Use #!, not just !, for the shebang.

Shells disambiguate (( differently or not at all. If the first ( should start a subshell, add a space after it.

This directive is unknown. It will be ignored.

You need a space before and after the = .

This is an unquoted HTML entity. Replace with corresponding character.

This is a unicode quote. Delete and retype it (or quote to make literal).

This is a unicode quote. Delete and retype it (or ignore/singlequote for literal).

This is a unicode quote. Delete and retype it (or ignore/doublequote for literal).

Use #!, not just #, for the shebang.

Remove leading spaces before the shebang.

Remove spaces between # and ! in the shebang.

Missing $ on a $((..)) expression? (or use ( ( for arrays).

Backslash is literal in `"\n"`. Prefer explicit escaping: `"\\n"`.

Delete whitespace after the here-doc end token.

Add a linefeed between end token and terminating ')'.

No comments allowed after here-doc token. Comment the next line instead.

Add ;/& terminators (and other syntax) on the line with the <<, not here.

Nothing allowed after end token. To continue a command, put it on the line with the `<<`.

SC2001: See if you can use ${variable//search/replace} instead.

Useless cat. Consider 'cmd < file | ..' or 'cmd file | ..' instead.

expr is antiquated. Consider rewriting this using $((..)), ${} or [[ ]].

$/${} is unnecessary on arithmetic variables.

Problematic code:

Use $(STATEMENT) instead of legacy \`STATEMENT\`

Use $((..)) instead of deprecated $[..]

echo doesn't read from stdin, are you sure you should be piping to it?

SC2009 Consider using pgrep instead of grepping ps output.

Don't use ls | grep. Use a glob or a for loop with a condition to allow non-alphanumeric filenames.

Use find instead of ls to better handle non-alphanumeric filenames.

To read lines rather than words, pipe/redirect to a 'while read' loop.

This will expand once before find runs, not per file found.

Note that A && B || C is not if-then-else. C may run when A is true.

Expressions don't expand in single quotes, use double quotes for that.

Increase precision by replacing a/b\*c with a\*c/b.

Use '[:lower:]' to support accents and foreign alphabets.

Use '[:upper:]' to support accents and foreign alphabets.

tr replaces sets of chars, not words (mentioned due to duplicates).

Don't use [] around ranges in tr, it replaces literal square brackets.

Note that unlike globs, o* here matches 'ooo' but not 'oscar'

sudo doesn't affect redirects. Use ..| sudo tee file

Make sure all escape sequences are enclosed in \[..\] to prevent line wrapping issues

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

The surrounding quotes actually unquote this. Remove or escape them.

echo won't expand escape sequences. Consider printf.

Note that, unescaped, this expands on the client side.

Modification of var is local (to subshell caused by pipeline).

var was modified in a subshell. That change might be lost.

Use own script or sh -c '..' to run this from su.

Shell functions can't be passed to external commands.

foo appears unused. Verify it or export it.

Use ./\*glob* or -- \*glob* so names with dashes won't become options.

If you wanted to assign the output of the pipeline, use a=$(b | c) .

To assign the output of a command, use var=$(cmd) .

Use -print0/-0 or find -exec + to allow for non-alphanumeric filenames.

In POSIX sh, *something* is undefined.

#!/bin/sh was specified, so ____ is not supported, even when sh is actually bash.

This is a literal string. To run as a command, use $(..) instead of '..' .

This loop will only ever run once for a constant value. Did you perhaps mean to loop over dir/*, $var or $(cmd)?"

For loops over find output are fragile. Use find -exec or a while read loop.

Iterating over ls output is fragile. Use globs.

Quote this to prevent word splitting

Use "$@" (with quotes) to prevent whitespace problems.

Bash doesn't support variables in brace range expansions.

Quote the rhs of = in [[ ]] to prevent glob matching.

Use spaces, not commas, to separate array elements.

You probably wanted && here

You probably wanted && here

Don't use variables in the printf format string. Use printf "..%s.." "$foo".

Quote parameters to tr to prevent glob expansion.

Quote the parameter to -name so the shell won't interpret it.

Quote the grep pattern so the shell won't interpret it.

Grep uses regex, but this looks like a glob.

Use single quotes, otherwise this expands now rather than when signalled.

This is interpreted as a shell file redirection, not a comparison.

Since you double quoted this, it will not word split, and the loop will only run once.

Missing ';' or + terminating -exec. You can't use |/||/&&, and ';' has to be a separate, quoted argument.

Double quote array expansions to avoid re-splitting elements.

The order of the 2>&1 and the redirect matters. The 2>&1 has to be last.

-n doesn't work with unquoted arguments. Quote or use [\[ ]].

> is for string comparisons. Use -gt instead.

Decimals are not supported. Either use integers only, or use bc or awk to compare.

Can't use `=~` in `[ ]`. Use `[[..]]` instead.

Don't quote rhs of =~, it'll match literally rather than as a regex.

You need spaces around the comparison operator.

This expression is constant. Did you forget a `$` somewhere?

`[ .. ]` can't match globs. Use `[[ .. ]]` or grep.

To expand via indirection, use name="foo$n"; echo "${!name}".

Remove '$' or use '_=$((expr))' to avoid executing output.

Double quote to prevent globbing and word splitting.

Quote 'EOF' to make here document expansions happen on the server side rather than on the client.

Tilde does not expand in quotes. Use $HOME.

Quotes/backslashes will be treated literally. Use an array.

Quotes/backslashes in this variable will not be respected.

Remove surrounding $() to avoid executing output.

Remove backticks to avoid executing output.

SC2094 Make sure not to read and write the same file in the same pipeline.

Add < /dev/null to prevent ssh from swallowing stdin.

On most OS, shebangs can only specify a single parameter.

This assignment is only seen by the forked process.

This expansion will not see the mentioned assignment.

Named class needs outer [], e.g. [[:digit:]\].

Use a ( subshell ) to avoid having to cd back.

`break` is only valid in loops

Instead of [ a && b ], use [ a ] && [ b ].

In [\[..]], use && instead of -a.

Instead of [ a || b ], use [ a ] || [ b ].

In [\[..]], use || instead of -o.

'function' keyword is non-standard. Delete it.

Warning: deletes a system directory.

Use "${var:?}" to ensure this never expands to /* .

SC2116 Useless echo? Instead of 'cmd $(echo foo)', just use 'cmd foo'.

To run commands as another user, use su -c or sudo.

Use foo "$@" if function's $1 should mean script's $1.

foo references arguments, but none are ever passed.

To assign a variable, use just 'var=value', no 'set ..'.

>= is not a valid operator. Use '! a < b' instead.

PATH is the shell search path. Use another name.

Assigning an array to a string! Assign as array, or use * instead of @ to concatenate.

Brace expansions and globs are literal in assignments. Quote it or use an array.

Consider using grep -c instead of grep|wc.

Expanding an array without an index only gives the first element.

Consider using { cmd1; cmd2; } >> file instead of individual redirects.

-eq is for integer comparisons. Use = instead.

This expands when defined, not when used. Consider escaping.

Word is on the form "A"B"C" (B indicated). Did you mean "ABC" or "A\"B\"C"?

Did you mean IFS=$'\t' ?

Aliases can't use positional parameters. Use a function.

Use grep -q instead of comparing output with [ -n .. ].

-e doesn't work with globs. Use a for loop.

Argument mixes string and array. Use * or separate argument.

This action ignores everything before the -o. Use \\( \\) to group.

Literal tilde in PATH works poorly across programs.

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

Remove $/${} for numeric index, or escape it for string.

-exec does not automatically invoke a shell. Use -exec sh -c .. for that.

Only one integer 0-255 can be returned. Use stdout for other data.

Can only return 0-255. Other data should be written to stdout.

Possible Misspelling: MYVARIABLE may not be assigned, but MY_VARIABLE is.

var is referenced but not assigned.

Declare and assign separately to avoid masking return values.

Injecting filenames is fragile and insecure. Use parameters.

Argument to implicit -n is always true due to literal strings.

[ false ] is true. Remove the brackets

[ 0 ] is true. Use 'false' instead

Instead of '[ true ]', just use 'true'.

Instead of '[ 1 ]', use 'true'.

read without -r mangle backslashes

Exporting an expansion rather than a variable.

Use cd ... || exit in case cd fails.

This nested loop overrides the index variable of its parent.

Prefer [ p ] && [ q ] as [ p -a q ] is not well defined.

This parent loop has its index variable overridden.

'local' is only valid in functions.

In dash, [\[ ]] is not supported.

Numerical -eq does not dereference in [..]. Expand or use string operator.

Trapping signals by number is not well defined. Prefer signal names.

SIGKILL/SIGSTOP can not be trapped.

When used with -p, -m only applies to the deepest directory.

Quote this invalid brace expansion since it should be passed literally to eval

'time' is undefined for pipelines. time single stage or bash -c instead.

'time' is undefined for compound commands, time sh -c instead.

Variable was used as an array but is now assigned a string.

Use array+=("item") to append items to an array.

Bash does not support multidimensional arrays. Use 1D or associative arrays.

Check exit code directly with e.g. 'if mycmd;', not indirectly with $?.

This printf format string has no variables. Other arguments are ignored.

This format string has 2 variables, but is passed 1 arguments.

Quote arguments to unset so they're not glob expanded.

Some finds don't have a default path. Specify '.' explicitly.

tempfile is deprecated. Use mktemp instead.

Ash scripts will be checked as Dash. Add '# shellcheck shell=dash' to silence.

This redirection doesn't have a command. Move to its command (or use 'true' as no-op).

You can't have | between this redirection and the command it should apply to.

Elements in associative arrays need index, e.g. array=( [index]=value ) .

The = here is literal. To assign by index, use ( [index]=value ) with no spaces. To keep as literal, quote it.

This array element has no value. Remove spaces after = or use "" for empty string.

The arguments to this comparison can never be equal. Make sure your syntax is correct.

This word is constant. Did you forget the $ on a variable?

This pattern will never match the case statement's word. Double check them.

egrep is non-standard and deprecated. Use grep -E instead.

fgrep is non-standard and deprecated. Use grep -F instead.

Arrays don't work as operands in [ ]. Use a loop (or concatenate with * instead of @).

Arrays implicitly concatenate in `[[ ]]`. Use a loop (or explicit * instead of @).

Brace expansions don't work as operands in [ ]. Use a loop.

Brace expansion doesn't happen in `[[ ]]`. Use a loop.

Globs don't work as operands in [ ]. Use a loop.

Globs are ignored in `[[ ]]` except right of =/!=. Use a loop.

(..) is a subshell. Did you mean [ .. ], a test expression?

(..) is a subshell. Did you mean [ .. ], a test expression?

Quote to prevent word splitting, or split robustly with mapfile or read -a.

Prefer mapfile or read -a to split command output (or quote to avoid splitting).

Use `[[ ]]` or quote arguments to -v to avoid glob expansion.

Use var=$(command) to assign output (or quote to assign string).

This is a file redirection. Was it supposed to be a comparison or fd operation?

This is a glob used as a command name. Was it supposed to be in ${..}, array, or is it missing quoting?

Use 'false' instead of empty [/[[ conditionals.

getopts specified -n, but it's not handled by this 'case'.

This case is not specified by getopts.

This flag is used as a command name. Bad line break or missing `[ .. ]`?

Piping to 'rm', a command that doesn't read stdin. Wrong command or missing xargs?

Redirecting to 'echo', a command that doesn't read stdin. Bad quoting or missing xargs?