ShellCheck Wiki Sitemap
The wiki is maintained on GitHub. This page is primarily for the benefit of search engines.
- Azure-Pipelines –
- Buildkite –
- CentOS6 –
- Checks – Finding documentation for a check
- CircleCI –
- Contrib –
- DevGuide – ShellCheck Dev Guide
- Directive – ShellCheck directives
- GitHub-Actions – Differential ShellCheck
- GitLab-CI –
- Home – Welcome to the ShellCheck wiki!
- Ignore – Ignoring errors
- Integration – Integrating with ShellCheck
- JUnit – Getting JUnit XML from ShellCheck
- JUnit2text –
- More-Installation-Guides – Installing ShellCheck on CentOS 6 / RHEL6
- Optional – Optional checks
- Parser-error –
- Phabricator – Installation
- Recursiveness –
- SC1000 – `$` is not used specially and should therefore be escaped.
- SC1001 – This `\o` will be a regular 'o' in this context.
- SC1003 – Want to escape a single quote? `echo 'This is how it'\''s done'`.
- SC1004 – This backslash+linefeed is literal. Break outside single quotes if you just want to break the line.
- SC1007 – Remove space after `=` if trying to assign a value (or for empty string, use `var=''` ... ).
- SC1008 – This shebang was unrecognized. ShellCheck only supports sh/bash/dash/ksh. Add a 'shell' directive to specify.
- SC1009 – The mentioned parser error was in ...
- SC1010 – Use semicolon or linefeed before `done` (or quote to make it literal).
- SC1011 – This apostrophe terminated the single quoted string!
- SC1012 – `\t` is just literal `t` here. For tab, use `"$(printf '\t')"` instead.
- SC1014 – Use `if cmd; then ..` to check exit code, or `if [ "$(cmd)" = .. ]` to check output.
- SC1015 – This is a Unicode double quote. Delete and retype it.
- SC1016 – This is a Unicode single quote. Delete and retype it.
- SC1017 – Literal carriage return. Run script through `tr -d '\r'` .
- SC1018 – This is a Unicode non-breaking space. Delete it and retype as space.
- SC1019 – Expected this to be an argument to the unary condition.
- SC1020 – You need a space before the `]` or `]]`
- SC1026 – If grouping expressions inside `[[..]]`, use `( .. )`.
- SC1027 – Expected another argument for this operator.
- SC1028 – In `[..]` you have to escape `\( \)` or preferably combine `[..]` expressions.
- SC1029 – In `[[..]]` you shouldn't escape `(` or `)`.
- SC1033 – Test expression was opened with double `[[` but closed with single `]`. Make sure they match.
- SC1034 – Test expression was opened with double `[` but closed with single `]]`. Make sure they match.
- SC1035 – You need a space here
- SC1036 – `(` is invalid here. Did you forget to escape it?
- SC1037 – Braces are required for positionals over 9, e.g. `${10}`.
- SC1038 – Shells are space sensitive. Use `< <(cmd)`, not `<<(cmd)`.
- SC1039 – Remove indentation before end token (or use `<<-` and indent with tabs).
- SC1040 – When using `<<-`, you can only indent with tabs.
- SC1041 – Found `eof` further down, but not on a separate line.
- SC1043 – Found EOF further down, but with wrong casing.
- SC1044 – Couldn't find end token `EOF` in the here document.
- SC1045 – It's not `foo &; bar`, just `foo & bar`.
- SC1046 – Couldn't find `fi` for this `if`.
- SC1047 – Expected `fi` matching previously mentioned `if`.
- SC1048 – Can't have empty then clauses (use `true` as a no-op).
- SC1049 – Did you forget the `then` for this `if`?
- SC1050 – Expected `then`.
- SC1051 – Semicolons directly after `then` are not allowed. Just remove it.
- SC1052 – Semicolons directly after `then` are not allowed. Just remove it.
- SC1053 – Semicolons directly after `else` are not allowed. Just remove it.
- SC1054 – You need a space after the `{`.
- SC1055 – You need at least one command here. Use `true;` as a no-op.
- SC1056 – Expected a `}`. If you have one, try a `;` or `\n` in front of it.
- SC1057 – Did you forget the `do` for this loop?
- SC1058 – Expected `do`.
- SC1059 – Semicolon is not allowed directly after `do`. You can just delete it.
- SC1060 – Can't have empty do clauses (use `true` as a no-op)
- SC1061 – Couldn't find `done` for this `do`.
- SC1062 – Expected `done` matching previously mentioned `do`.
- SC1063 – You need a line feed or semicolon before the `do`.
- SC1064 – Expected a `{` to open the function definition.
- SC1065 – Trying to declare parameters? Don't. Use `()` and refer to params as `$1`, `$2`, …
- SC1066 – Don't use `$` on the left side of assignments.
- SC1067 – For indirection, use arrays, `declare "var$n=value"`, or (for sh) `read`/`eval`
- SC1068 – Don't put spaces around the `=` in assignments.
- SC1069 – You need a space before the `[`.
- SC1070 – Parsing stopped here. Mismatched keywords or invalid parentheses?
- SC1071 – ShellCheck only supports sh/bash/dash/ksh scripts. Sorry!
- SC1072 – Unexpected ..
- SC1073 – Couldn't parse this (thing). Fix to allow more checks.
- SC1074 – Did you forget the `;;` after the previous case item?
- SC1075 – Use `elif` instead of `else if`.
- SC1076 – Trying to do math? Use e.g. `[ $((i/2+7)) -ge 18 ]`.
- SC1077 – For command expansion, the tick should slant left (`` ` `` vs `´`).
- SC1078 – Did you forget to close this double-quoted string?
- SC1079 – This is actually an end quote, but due to next char it looks suspect.
- SC1080 – You need `\` before line feeds to break lines in `[ ]`.
- SC1081 – Scripts are case-sensitive. Use `if`, not `If`.
- SC1082 – This file has a UTF-8 BOM. Remove it with: `LC_CTYPE=C sed '1s/^...//' < yourscript`.
- SC1083 – This `{`/`}` is literal. Check if `;` is missing or quote the expression.
- SC1084 – Use `#!`, not `!#`, for the shebang.
- SC1086 – Don't use `$` on the iterator name in for loops.
- SC1087 – Use braces when expanding arrays, e.g. `${array[idx]}` (or `${var}[..` to quiet).
- SC1088 – Parsing stopped here. Invalid use of parentheses?
- SC1089 – Parsing stopped here. Is this keyword correctly matched up?
- SC1090 – Can't follow non-constant source. Use a directive to specify location
- SC1091 – Not following: (error message here)
- SC1092 – Stopping at 100 `source` frames :O
- SC1094 – Parsing of sourced file failed. Ignoring it.
- SC1095 – You need a space or linefeed between the function name and body.
- SC1097 – Unexpected `==`. For assignment, use `=`. For comparison, use `[`/`[[`.
- SC1098 – Quote/escape special characters when using `eval`, e.g. `eval "a=(b)"`.
- SC1099 – You need a space before the `#`.
- SC1100 – This is a Unicode dash. Delete and retype as ASCII minus.
- SC1101 – Delete trailing spaces after `\` to break line (or use quotes for literal space).
- SC1102 – Shells disambiguate `$((` differently or not at all. For `$(command substitution)`, add space after `$(` . For `$((arithmetics))`, fix parsing errors.
- SC1103 – This shell type is unknown. Use e.g. `sh` or `bash`.
- SC1104 – Use `#!`, not just `!`, for the shebang.
- SC1105 – Shells disambiguate `((` differently or not at all. If the first `(` should start a subshell, add a space after it.
- SC1106 – In arithmetic contexts, use `<` instead of `-lt`
- SC1107 – This directive is unknown. It will be ignored.
- SC1108 – You need a space before and after the `=` .
- SC1109 – This is an unquoted HTML entity. Replace with corresponding character.
- SC1110 – This is a Unicode quote. Delete and retype it (or quote to make literal).
- SC1111 – This is a Unicode quote. Delete and retype it (or ignore/singlequote for literal).
- SC1112 – This is a Unicode quote. Delete and retype it (or ignore/doublequote for literal).
- SC1113 – Use `#!`, not just `#`, for the shebang.
- SC1114 – Remove leading spaces before the shebang.
- SC1115 – Remove spaces between `#` and `!` in the shebang.
- SC1116 – Missing `$` on a `$((..))` expression? (or use `( (` for arrays).
- SC1117 – Backslash is literal in `"\n"`. Prefer explicit escaping: `"\\n"`.
- SC1118 – Delete whitespace after the here-doc end token.
- SC1119 – Add a linefeed between end token and terminating `)`.
- SC1120 – No comments allowed after here-doc token. Comment the next line instead.
- SC1121 – Add `;`/`&` terminators (and other syntax) on the line with the `<<`, not here.
- SC1122 – Nothing allowed after end token. To continue a command, put it on the line with the `<<`.
- SC1123 – ShellCheck directives are only valid in front of complete compound commands, like `if`, not e.g. individual `elif` branches.
- SC1124 – ShellCheck directives are only valid in front of complete commands like `case` statements, not individual case branches.
- SC1125 – Invalid `key=value` pair in directive
- SC1126 – Place shellcheck directives before commands, not after.
- SC1127 – Was this intended as a comment? Use `#` in sh.
- SC1128 – The shebang must be on the first line. Delete blanks and move comments.
- SC1129 – You need a space before the `!`.
- SC1130 – You need a space before the :.
- SC1131 – Use `elif` to start another branch.
- SC1132 – This `&` terminates the command. Escape it or add space after `&` to silence.
- SC1133 – Unexpected start of line. If breaking lines, `|`/`||`/`&&` should be at the end of the previous one.
- SC1134 –
- SC1135 – Prefer escape over ending quote to make `$` literal. Instead of `"It costs $"5`, use `"It costs \$5"`
- SC1136 – Unexpected characters after terminating `]`. Missing semicolon/linefeed?
- SC1137 – Missing second `(` to start arithmetic for ((;;)) loop
- SC1138 – Remove spaces between (( in arithmetic for loop.
- SC1139 – Use `||` instead of `-o` between test commands.
- SC1140 – Unexpected parameters after condition. Missing `&&`/`||`, or bad expression?
- SC1141 – Unexpected tokens after compound command. Bad redirection or missing `;`/`&&`/`||`/`|`?
- SC1142 – Use `done < <(cmd)` to redirect from process substitution (currently missing one `<`).
- SC1143 – This backslash is part of a comment and does not continue the line.
- SC1144 – `external-sources` can only be enabled in .shellcheckrc, not in individual files.
- SC1145 – Unknown `external-sources` value. Expected `true`/`false`.
- SC2000 – See if you can use `${#variable}` instead
- SC2001 – See if you can use `${variable//search/replace}` instead.
- SC2002 – Useless cat. Consider `cmd < file | ..` or `cmd file | ..` instead.
- SC2003 – expr is antiquated. Consider rewriting this using `$((..))`, `${}` or `[[ ]]`.
- SC2004 – `$`/`${}` is unnecessary on arithmetic variables.
- SC2005 –
- SC2006 – Use `$(...)` notation instead of legacy backticked `` `...` ``.
- SC2007 – Use `$((..))` instead of deprecated `$[..]`.
- SC2008 – `echo` doesn't read from stdin, are you sure you should be piping to it?
- SC2009 – Consider using `pgrep` instead of grepping `ps` output.
- SC2010 – Don't use `ls | grep`. Use a glob or a for loop with a condition to allow non-alphanumeric filenames.
- SC2011 – Use `find -print0` or `find -exec` to better handle non-alphanumeric filenames.
- SC2012 – Use `find` instead of `ls` to better handle non-alphanumeric filenames.
- SC2013 – To read lines rather than words, pipe/redirect to a `while read` loop.
- SC2014 – This will expand once before find runs, not per file found.
- SC2015 – Note that `A && B || C` is not if-then-else. C may run when A is true.
- SC2016 – Expressions don't expand in single quotes, use double quotes for that.
- SC2017 – Increase precision by replacing `a/b*c` with `a*c/b`.
- SC2018 – Use `[:lower:]` to support accents and foreign alphabets.
- SC2019 – Use `[:upper:]` to support accents and foreign alphabets.
- SC2020 – `tr` replaces sets of chars, not words (mentioned due to duplicates).
- SC2021 – Don't use `[]` around ranges in `tr`, it replaces literal square brackets.
- SC2022 – Note that unlike globs, `o*` here matches `ooo` but not `oscar`.
- SC2023 – The shell may override `time` as seen in man time(1). Use `command time ..` for that one.
- SC2024 – `sudo` doesn't affect redirects. Use `..| sudo tee file`
- SC2025 – Make sure all escape sequences are enclosed in `\[..\]` to prevent line wrapping issues.
- SC2026 – This word is outside of quotes. Did you intend to `'nest '"'single quotes'"'` instead?
- SC2027 – The surrounding quotes actually unquote this. Remove or escape them.
- SC2028 – `echo` won't expand escape sequences. Consider `printf`.
- SC2029 – Note that, unescaped, this expands on the client side.
- SC2030 – Modification of var is local (to subshell caused by pipeline).
- SC2031 – var was modified in a subshell. That change might be lost.
- SC2032 – This function can't be invoked via su on line 42.
- SC2033 – Shell functions can't be passed to external commands. Use separate script or sh -c.
- SC2034 – foo appears unused. Verify it or export it.
- SC2035 – Use `./*glob*` or `-- *glob*` so names with dashes won't become options.
- SC2036 – If you wanted to assign the output of the pipeline, use `a=$(b | c)` .
- SC2037 – To assign the output of a command, use `var=$(cmd)` .
- SC2038 – Use `-print0`/`-0` or `find -exec +` to allow for non-alphanumeric filenames.
- SC2039 – In POSIX sh, *something* is undefined.
- SC2040 – `#!/bin/sh` was specified, so ____ is not supported, even when sh is actually bash.
- SC2041 – This is a literal string. To run as a command, use `$(..)` instead of `'..'` .
- SC2042 – Use spaces, not commas, to separate loop elements.
- SC2043 – This loop will only ever run once for a constant value. Did you perhaps mean to loop over `dir/*`, `$var` or `$(cmd)`?
- SC2044 – For loops over find output are fragile. Use `find -exec` or a `while read` loop.
- SC2045 – Iterating over ls output is fragile. Use globs.
- SC2046 – Quote this to prevent word splitting.
- SC2048 – Use `"$@"` (with quotes) to prevent whitespace problems.
- SC2049 – `=~` is for regex, but this looks like a glob. Use `=` instead.
- SC2050 – This expression is constant. Did you forget the `$` on a variable?
- SC2051 – Bash doesn't support variables in brace range expansions.
- SC2053 – Quote the rhs of `=` in `[[ ]]` to prevent glob matching.
- SC2054 – Use spaces, not commas, to separate array elements.
- SC2055 – You probably wanted `&&` here, otherwise it's always true.
- SC2056 – You probably wanted `&&` here
- SC2057 – Unknown binary operator.
- SC2058 – Unknown unary operator.
- SC2059 – Don't use variables in the `printf` format string. Use `printf "..%s.." "$foo"`.
- SC2060 – Quote parameters to `tr` to prevent glob expansion.
- SC2061 – Quote the parameter to `-name` so the shell won't interpret it.
- SC2062 – Quote the grep pattern so the shell won't interpret it.
- SC2063 – Grep uses regex, but this looks like a glob.
- SC2064 – Use single quotes, otherwise this expands now rather than when signalled.
- SC2065 – This is interpreted as a shell file redirection, not a comparison.
- SC2066 – Since you double-quoted this, it will not word split, and the loop will only run once.
- SC2067 – Missing `;` or `+` terminating `-exec`. You can't use `|`/`||`/`&&`, and `;` has to be a separate, quoted argument.
- SC2068 – Double quote array expansions to avoid re-splitting elements.
- SC2069 – To redirect stdout+stderr, `2>&1` must be last (or use `{ cmd > file; } 2>&1` to clarify).
- SC2070 – `-n` doesn't work with unquoted arguments. Quote or use `[[ ]]`.
- SC2071 – `>` is for string comparisons. Use `-gt` instead.
- SC2072 – Decimals are not supported. Either use integers only, or use `bc` or `awk` to compare.
- SC2073 – Escape `\<` to prevent it redirecting (or switch to `[[ .. ]]`).
- SC2074 – Can't use `=~` in `[ ]`. Use `[[..]]` instead.
- SC2075 – Escaping `\<` is required in `[..]`, but invalid in `[[..]]`
- SC2076 – Don't quote rhs of `=~`, it'll match literally rather than as a regex.
- SC2077 – You need spaces around the comparison operator.
- SC2078 – This expression is constant. Did you forget a `$` somewhere?
- SC2079 – `(( ))` doesn't support decimals. Use `bc` or `awk`.
- SC2080 – Numbers with leading 0 are considered octal.
- SC2081 – `[ .. ]` can't match globs. Use `[[ .. ]]` or grep.
- SC2082 – To expand via indirection, use `name="foo$n"; echo "${!name}"`.
- SC2083 – Don't add spaces after the slash in `./file`.
- SC2084 – Remove `$` or use `_=$((expr))` to avoid executing output.
- SC2086 – Double quote to prevent globbing and word splitting.
- SC2087 – Quote `EOF` to make here document expansions happen on the server side rather than on the client.
- SC2088 – Tilde does not expand in quotes. Use `$HOME`.
- SC2089 – Quotes/backslashes will be treated literally. Use an array.
- SC2090 – Quotes/backslashes in this variable will not be respected.
- SC2091 – Remove surrounding `$()` to avoid executing output (or use `eval` if intentional).
- SC2092 – Remove backticks to avoid executing output.
- SC2093 – Remove `exec ` if script should continue after this command.
- SC2094 – Make sure not to read and write the same file in the same pipeline.
- SC2095 – Use `ssh -n` to prevent ssh from swallowing stdin.
- SC2096 – On most OS, shebangs can only specify a single parameter.
- SC2097 – This assignment is only seen by the forked process.
- SC2098 – This expansion will not see the mentioned assignment.
- SC2099 – Use `$((..))` for arithmetics, e.g. `i=$((i + 2))`
- SC2100 – Use `$((..))` for arithmetics, e.g. `i=$((i + 2))`
- SC2101 – Named class needs outer `[]`, e.g. `[[:digit:]]`.
- SC2102 – Ranges can only match single chars (mentioned due to duplicates).
- SC2103 – Use a `( subshell )` to avoid having to `cd` back.
- SC2104 – In functions, use `return` instead of `break`.
- SC2105 – `break` is only valid in loops
- SC2106 – This only exits the subshell caused by the pipeline.
- SC2107 – Instead of `[ a && b ]`, use `[ a ] && [ b ]`.
- SC2108 – In `[[..]]`, use `&&` instead of `-a`.
- SC2109 – Instead of `[ a || b ]`, use `[ a ] || [ b ]`.
- SC2110 – In `[[..]]`, use `||` instead of `-o`.
- SC2111 – ksh does not allow `function` keyword and `()` at the same time.
- SC2112 – `function` keyword is non-standard. Delete it.
- SC2113 – `function` keyword is non-standard. Use `foo()` instead of `function foo`.
- SC2114 – Warning: deletes a system directory.
- SC2115 – Use `"${var:?}"` to ensure this never expands to `/*` .
- SC2116 – Useless echo? Instead of `cmd $(echo foo)`, just use `cmd foo`.
- SC2117 – To run commands as another user, use `su -c` or `sudo`.
- SC2118 – Ksh does not support `|&`. Use `2>&1 |`
- SC2119 – Use `foo "$@"` if function's `$1` should mean script's `$1`.
- SC2120 – foo references arguments, but none are ever passed.
- SC2121 – To assign a variable, use just `var=value`, not `set ..`.
- SC2122 – `>=` is not a valid operator. Use `! a < b` instead.
- SC2123 – `PATH` is the shell search path. Use another name.
- SC2124 – Assigning an array to a string! Assign as array, or use `*` instead of `@` to concatenate.
- SC2125 – Brace expansions and globs are literal in assignments. Quote it or use an array.
- SC2126 – Consider using `grep -c` instead of `grep | wc`
- SC2127 – To use `${ ..; }`, specify `#!/usr/bin/env ksh`.
- SC2128 – Expanding an array without an index only gives the element in the index 0.
- SC2129 – Consider using `{ cmd1; cmd2; } >> file` instead of individual redirects.
- SC2130 – `-eq` is for integer comparisons. Use `=` instead.
- SC2139 – This expands when defined, not when used. Consider escaping.
- SC2140 – Word is of the form `"A"B"C"` (B indicated). Did you mean `"ABC"` or `"A\\"B\\"C"`?
- SC2141 – Did you mean `IFS=$'\t'` ?
- SC2142 – Aliases can't use positional parameters. Use a function.
- SC2143 – Use `grep -q` instead of comparing output with `[ -n .. ]`.
- SC2144 – `-e` doesn't work with globs. Use a `for` loop.
- SC2145 – Argument mixes string and array. Use `*` or separate argument.
- SC2146 – This action ignores everything before the `-o`. Use `\( \)` to group.
- SC2147 – Literal tilde in PATH works poorly across programs.
- SC2148 – Tips depend on target shell and yours is unknown. Add a shebang.
- SC2149 – Remove `$`/`${}` for numeric index, or escape it for string.
- SC2150 – `-exec` does not automatically invoke a shell. Use `-exec sh -c ..` for that.
- SC2151 – Only one integer 0-255 can be returned. Use stdout for other data.
- SC2152 – Can only return 0-255. Other data should be written to stdout.
- SC2153 – Possible Misspelling: MYVARIABLE may not be assigned. Did you mean MY_VARIABLE?
- SC2154 – var is referenced but not assigned.
- SC2155 – Declare and assign separately to avoid masking return values.
- SC2156 – Injecting filenames is fragile and insecure. Use parameters.
- SC2157 – Argument to implicit `-n` is always true due to literal strings.
- SC2158 – `[ false ]` is true. Remove the brackets
- SC2159 – `[ 0 ]` is true. Use `false` instead.
- SC2160 – Instead of `[ true ]`, just use `true`.
- SC2161 – Instead of `[ 1 ]`, use `true`.
- SC2162 – `read` without `-r` will mangle backslashes.
- SC2163 – This does not export `FOO`. Remove `$`/`${}` for that, or use `${var?}` to quiet.
- SC2164 – Use `cd ... || exit` in case `cd` fails.
- SC2165 – This nested loop overrides the index variable of its parent.
- SC2166 – Prefer `[ p ] && [ q ]` as `[ p -a q ]` is not well-defined.
- SC2167 – This parent loop has its index variable overridden.
- SC2168 – `local` is only valid in functions.
- SC2169 – In dash, *something* is not supported.
- SC2170 – Invalid number for `-eq`. Use `=` to compare as string (or use `$var` to expand as a variable).
- SC2171 – Found trailing `]` outside test. Add missing `[` or quote if intentional.
- SC2172 – Trapping signals by number is not well-defined. Prefer signal names.
- SC2173 – SIGKILL/SIGSTOP can not be trapped.
- SC2174 – When used with `-p`, `-m` only applies to the deepest directory.
- SC2175 – Quote this invalid brace expansion since it should be passed literally to eval
- SC2176 – `time` is undefined for pipelines. time single stage or `bash -c` instead.
- SC2177 – `time` is undefined for compound commands, use `time sh -c` instead.
- SC2178 – Variable was used as an array but is now assigned a string.
- SC2179 – Use `array+=("item")` to append items to an array.
- SC2180 – Bash does not support multidimensional arrays. Use 1D or associative arrays.
- SC2181 – Check exit code directly with e.g. `if mycmd;`, not indirectly with `$?`.
- SC2182 – This printf format string has no variables. Other arguments are ignored.
- SC2183 – This format string has 2 variables, but is passed 1 argument.
- SC2184 – Quote arguments to unset so they're not glob expanded.
- SC2185 – Some finds don't have a default path. Specify `.` explicitly.
- SC2186 – tempfile is deprecated. Use mktemp instead.
- SC2187 – Ash scripts will be checked as Dash. Add `# shellcheck shell=dash` to silence.
- SC2188 – This redirection doesn't have a command. Move to its command (or use `true` as no-op).
- SC2189 – You can't have `|` between this redirection and the command it should apply to.
- SC2190 – Elements in associative arrays need index, e.g. `array=( [index]=value )` .
- SC2191 – The `=` here is literal. To assign by index, use `( [index]=value )` with no spaces. To keep as literal, quote it.
- SC2192 – This array element has no value. Remove spaces after `=` or use `""` for empty string.
- SC2193 – The arguments to this comparison can never be equal. Make sure your syntax is correct.
- SC2194 – This word is constant. Did you forget the `$` on a variable?
- SC2195 – This pattern will never match the case statement's word. Double check them.
- SC2196 – `egrep` is non-standard and deprecated. Use `grep -E` instead.
- SC2197 – `fgrep` is non-standard and deprecated. Use `grep -F` instead.
- SC2198 – Arrays don't work as operands in `[ ]`. Use a loop (or concatenate with `*` instead of `@`).
- SC2199 – Arrays implicitly concatenate in `[[ ]]`. Use a loop (or explicit `*` instead of `@`).
- SC2200 – Brace expansions don't work as operands in `[ ]`. Use a loop.
- SC2201 – Brace expansion doesn't happen in `[[ ]]`. Use a loop.
- SC2202 – Globs don't work as operands in `[ ]`. Use a loop.
- SC2203 – Globs are ignored in `[[ ]]` except right of `=`/`!=`. Use a loop.
- SC2204 – `(..)` is a subshell. Did you mean `[ .. ]`, a test expression?
- SC2205 – `(..)` is a subshell. Did you mean `[ .. ]`, a test expression?
- SC2206 – Quote to prevent word splitting/globbing, or split robustly with mapfile or `read -a`.
- SC2207 – Prefer `mapfile` or `read -a` to split command output (or quote to avoid splitting).
- SC2208 – Use `[[ ]]` or quote arguments to `-v` to avoid glob expansion.
- SC2209 – Use `var=$(command)` to assign output (or quote to assign string).
- SC2210 – This is a file redirection. Was it supposed to be a comparison or fd operation?
- SC2211 – This is a glob used as a command name. Was it supposed to be in `${..}`, array, or is it missing quoting?
- SC2212 – Use `false` instead of empty `[`/`[[` conditionals.
- SC2213 – getopts specified `-n`, but it's not handled by this `case`.
- SC2214 – This case is not specified by getopts.
- SC2215 – This flag is used as a command name. Bad line break or missing `[ .. ]`?
- SC2216 – Piping to `rm`, a command that doesn't read stdin. Wrong command or missing `xargs`?
- SC2217 – Redirecting to `echo`, a command that doesn't read stdin. Bad quoting or missing `xargs`?
- SC2218 – This function is only defined later. Move the definition up.
- SC2219 – Instead of `let expr`, prefer `(( expr ))` .
- SC2220 – Invalid flags are not handled. Add a `*)` case.
- SC2221 – This pattern always overrides a later one.
- SC2222 – This pattern never matches because of a previous pattern.
- SC2223 – This default assignment may cause DoS due to globbing. Quote it.
- SC2224 – This `mv` has no destination. Check the arguments.
- SC2225 – This `cp` has no destination. Check the arguments.
- SC2226 – This `ln` has no destination. Check the arguments, or specify `.` explicitly.
- SC2227 – Redirection applies to the find command itself. Rewrite to work per action (or move to end).
- SC2229 – This does not read `foo`. Remove `$`/`${}` for that, or use `${var?}` to quiet.
- SC2230 – `which` is non-standard. Use builtin `command -v` instead.
- SC2231 – Quote expansions in this `for` loop glob to prevent wordsplitting, e.g. `"$dir"/*.txt` .
- SC2232 – Can't use `sudo` with builtins like `cd`. Did you want `sudo sh -c ..` instead?
- SC2233 – Remove superfluous `(..)` around condition to avoid subshell overhead.
- SC2234 – Remove superfluous `(..)` around test command to avoid subshell overhead.
- SC2235 – Use `{ ..; }` instead of `(..)` to avoid subshell overhead.
- SC2236 – Use `-n` instead of `! -z`.
- SC2237 – Use `[ -n .. ]` instead of `! [ -z .. ]`.
- SC2238 – Redirecting to/from command name instead of file. Did you want pipes/xargs (or quote to ignore)?
- SC2239 – Ensure the shebang uses the absolute path to the interpreter.
- SC2240 – The dot command does not support arguments in sh/dash. Set them as variables.
- SC2241 – The exit status can only be one integer 0-255. Use stdout for other data.
- SC2242 – Can only exit with status 0-255. Other data should be written to stdout/stderr.
- SC2243 – Prefer explicit `-n` to check for output (or run command without `[`/`[[` to check for success)
- SC2244 – Prefer explicit `-n` to check non-empty string (or use `=`/`-ne` to check boolean/integer).
- SC2245 – -d only applies to the first expansion of this glob. Use a loop to check any/all.
- SC2246 – This shebang specifies a directory. Ensure the interpreter is a file.
- SC2247 – Flip leading `$` and `"` if this should be a quoted substitution.
- SC2248 – Prefer double quoting even when variables don't contain special characters.
- SC2249 – Consider adding a default `*)` case, even if it just exits with error.
- SC2250 – Prefer putting braces around variable references even when not strictly required.
- SC2251 – This `!` is not on a condition and skips errexit. Use `&& exit 1` instead, or make sure `$?` is checked.
- SC2252 – You probably wanted `&&` here, otherwise it's always true.
- SC2253 – Use `-R` to recurse, or explicitly `a-r` to remove read permissions.
- SC2254 – Quote expansions in case patterns to match literally rather than as a glob.
- SC2255 – `[ ]` does not apply arithmetic evaluation. Evaluate with `$((..))` for numbers, or use string comparator for strings.
- SC2256 – This translated string is the name of a variable. Flip leading `$` and `"` if this should be a quoted substitution.
- SC2257 – Arithmetic modifications in command redirections may be discarded. Do them separately.
- SC2258 – The trailing comma is part of the value, not a separator. Delete or quote it.
- SC2259 – This redirection overrides piped input. To use both, merge or pass filenames.
- SC2260 – This redirection overrides the output pipe. Use `tee` to output to both.
- SC2261 – Multiple redirections compete for stdout. Use `cat`, `tee`, or pass filenames instead.
- SC2262 – This alias can't be defined and used in the same parsing unit. Use a function instead.
- SC2263 – Since they're in the same parsing unit, this command will not refer to the previously mentioned alias.
- SC2264 – This function unconditionally re-invokes itself. Missing `command`?
- SC2265 – Use && for logical AND. Single & will background and return true.
- SC2266 – Use && for logical AND. Single & will background and return true.
- SC2267 – GNU `xargs -i` is deprecated in favor of `-I{}`
- SC2268 – Avoid x-prefix in comparisons as it no longer serves a purpose.
- SC2269 – This variable is assigned to itself, so the assignment does nothing.
- SC2270 – To assign positional parameters, use `set -- first second ..` (or use `[ ]` to compare).
- SC2271 – For indirection, use arrays, `declare "var$n=value"`, or (for sh) read/eval
- SC2272 – Command name contains `==`. For comparison, use `[ "$var" = value ]`.
- SC2273 – Sequence of `===`s found. Merge conflict or intended as a commented border?
- SC2274 – Command name starts with `===`. Intended as a commented border?
- SC2275 – Command name starts with `=`. Bad line break?
- SC2276 – This is interpreted as a command name containing `=`. Bad assignment or comparison?
- SC2277 – Use `BASH_ARGV0` to assign to `$0` in bash (or use `[ ]` to compare).
- SC2278 – `$0` can't be assigned in Ksh (but it does reflect the current function).
- SC2279 – `$0` can't be assigned in Dash. This becomes a command name.
- SC2280 – `$0` can't be assigned this way, and there is no portable alternative.
- SC2281 – Don't use `$`/`${}` on the left side of assignments.
- SC2282 – Variable names can't start with numbers, so this is interpreted as a command.
- SC2283 – Use `[ ]` to compare values, or remove spaces around `=` to assign (or quote `'='` if literal).
- SC2284 – Use `[ x = y ]` to compare values (or quote `'=='` if literal).
- SC2285 – Remove spaces around `+=` to assign (or quote `'+='` if literal).
- SC2286 – This empty string is interpreted as a command name. Double check syntax (or use 'true' as a no-op).
- SC2287 – This is interpreted as a command name ending with '/'. Double check syntax.
- SC2288 – This is interpreted as a command name ending with apostrophe. Double check syntax.
- SC2289 – This is interpreted as a command name containing a linefeed. Double check syntax.
- SC2290 – Remove spaces around = to assign.
- SC2291 – Quote repeated spaces to avoid them collapsing into one.
- SC2292 – Prefer `[[ ]]` over `[ ]` for tests in Bash/Ksh.
- SC2293 – When eval'ing @Q-quoted words, use * rather than @ as the index.
- SC2294 – eval negates the benefit of arrays. Drop eval to preserve whitespace/symbols (or eval as string).
- SC2295 – Expansions inside `${..}` need to be quoted separately, otherwise they will match as a pattern.
- SC2296 – Parameter expansions can't start with `{`. Double check syntax.
- SC2297 – Double quotes must be outside `${}`: `${"invalid"}` vs `"${valid}"`.
- SC2298 – `${$x}` is invalid. For expansion, use ${x}. For indirection, use arrays, ${!x} or (for sh) eval.
- SC2299 – Parameter expansions can't be nested. Use temporary variables.
- SC2300 – Parameter expansion can't be applied to command substitutions. Use temporary variables.
- SC2301 – Parameter expansion starts with unexpected quotes. Double check syntax.
- SC2302 – This loops over values. To loop over keys, use `"${!array[@]}"`.
- SC2303 – `i` is an array value, not a key. Use directly or loop over keys instead.
- SC2304 – `*` must be escaped to multiply: `\*`. Modern `$((x * y))` avoids this issue.
- SC2305 – Quote regex argument to expr to avoid it expanding as a glob.
- SC2306 – Escape glob characters in arguments to expr to avoid pathname expansion.
- SC2307 – 'expr' expects 3+ arguments but sees 1. Make sure each operator/operand is a separate argument, and escape <>&|.
- SC2308 – `expr length` has unspecified results. Prefer `${#var}`.
- SC2309 – -eq treats this as a variable. Use = to compare as string (or expand explicitly with $var)
- SC2310 – This function is invoked in an 'if' condition so set -e will be disabled. Invoke separately if failures should cause the script to exit.
- SC2311 – Bash implicitly disabled set -e for this function invocation because it's inside a command substitution. Add set -e; before it or enable inherit_errexit.
- SC2312 – Consider invoking this command separately to avoid masking its return value (or use '|| true' to ignore).
- SC2313 – Quote array indices to avoid them expanding as globs.
- SC2314 – In bats, `!` does not cause a test failure.
- SC2315 – In bats, `!` does not cause a test failure. Fold the `!` into the conditional!
- SC2316 – This applies local to the variable named readonly, which is probably not what you want. Use a separate command or the appropriate `declare` options instead.
- SC2317 – Command appears to be unreachable. Check usage (or ignore if invoked indirectly).
- SC2318 – This assignment is used again in this `declare`, but won't have taken effect. Use two `declare`s.
- SC2319 – This `$?` refers to a condition, not a command. Assign to a variable to avoid it being overwritten.
- SC2320 – This `$?` refers to echo/printf, not a previous command. Assign to variable to avoid it being overwritten.
- SC2321 – Array indices are already arithmetic contexts. Prefer removing the `$((` and `))`.
- SC2322 – In arithmetic contexts, `((x))` is the same as `(x)`. Prefer only one layer of parentheses.
- SC2323 – `a[(x)]` is the same as `a[x]`. Prefer not wrapping in additional parentheses.
- SC2324 – var+=1 will append, not increment. Use (( var += 1 )), declare -i var, or quote number to silence.
- SC2325 – Multiple ! in front of pipelines are a bash/ksh extension. Use only 0 or 1.
- SC2326 – ! is not allowed in the middle of pipelines. Use command group as in `cmd | { ! cmd; }` if necessary.
- SC2327 – This command substitution will be empty because the command's output gets redirected away.
- SC2328 – This redirection takes output away from the command substitution.
- SC2329 – This function is never invoked. Check usage (or ignored if invoked indirectly).
- SC2330 – BusyBox `[[ .. ]]` does not support glob matching. Use a case statement.
- SC3001 – In POSIX sh, process substitution is undefined.
- SC3002 – In POSIX sh, extglob is undefined.
- SC3003 – In POSIX sh, `$'..'` is undefined.
- SC3004 – In POSIX sh, $".." is undefined
- SC3005 – In POSIX sh, arithmetic for loops are undefined.
- SC3006 – In POSIX sh, standalone `((..))` is undefined.
- SC3007 – In POSIX sh, `$[..]` in place of `$((..))` is undefined.
- SC3008 – In POSIX sh, select loops are undefined.
- SC3009 – In POSIX `sh`, brace expansion is undefined.
- SC3010 – In POSIX sh, `[[ ]]` is undefined.
- SC3011 – In POSIX sh, here-strings are undefined.
- SC3012 – In POSIX sh, lexicographical `\<` is undefined.
- SC3013 – In POSIX sh, `-nt` is undefined.
- SC3014 – In POSIX sh, `==` in place of `=` is undefined.
- SC3015 – In POSIX sh, `=~` regex matching is undefined.
- SC3016 – In POSIX sh, unary `-v` (in place of `[ -n "${var+x}" ]`) is undefined.
- SC3017 – In POSIX sh, unary `-a` in place of `-e` is undefined.
- SC3018 – In POSIX sh, `++` is undefined.
- SC3019 – In POSIX sh, exponentials are undefined.
- SC3020 – In POSIX sh, `&>` is undefined.
- SC3021 – In POSIX sh, `>& filename` (as opposed to `>& fd`) is undefined.
- SC3022 – In POSIX sh, named file descriptors is undefined.
- SC3023 – In POSIX sh, FDs outside 0-9 are undefined.
- SC3024 – In POSIX sh, `+=` is undefined.
- SC3025 – In POSIX sh, `/dev/{tcp,udp}` is undefined.
- SC3026 – In POSIX sh, `^` in place of `!` in glob bracket expressions is undefined.
- SC3028 – In POSIX sh, VARIABLE is undefined.
- SC3029 – In POSIX sh, `|&` in place of `2>&1 |` is undefined.
- SC3030 – In POSIX sh, arrays are undefined.
- SC3031 – In POSIX sh, redirecting from/to globs is undefined.
- SC3032 – In POSIX sh, coproc is undefined.
- SC3033 – In POSIX sh, naming functions outside [a-zA-Z_][a-zA-Z0-9_]* is undefined.
- SC3034 – In POSIX sh, `$(
- SC3035 – In POSIX sh, `` `
- SC3036 – In Dash, echo flags besides -n are not supported.
- SC3037 – In POSIX sh, echo flags are undefined.
- SC3038 – In POSIX sh, exec flags are undefined.
- SC3039 – In POSIX sh, `let` is undefined.
- SC3040 – In POSIX sh, set option *[name]* is undefined.
- SC3041 – In POSIX sh, set flag `-E` is undefined
- SC3042 – In POSIX sh, set flag `--default` is undefined
- SC3043 – In POSIX sh, `local` is undefined.
- SC3044 – In POSIX sh, `declare` is undefined.
- SC3045 – In POSIX sh, some-command-with-flag is undefined.
- SC3046 – In POSIX sh, `source` in place of `.` is undefined.
- SC3047 – In POSIX sh, trapping ERR is undefined.
- SC3048 – In POSIX sh, prefixing signal names with 'SIG' is undefined.
- SC3049 – In POSIX sh, using lower/mixed case for signal names is undefined.
- SC3050 – In POSIX sh, `printf %q` is undefined.
- SC3051 – In POSIX sh, `source` in place of `.` is undefined
- SC3052 – In POSIX sh, arithmetic base conversion is undefined
- SC3053 – In POSIX sh, indirect expansion is undefined.
- SC3054 – In POSIX sh, array references are undefined.
- SC3055 – In POSIX sh, array key expansion is undefined.
- SC3056 – In POSIX sh, name matching prefixes are undefined.
- SC3057 – In POSIX sh, string indexing is undefined.
- SC3059 –
- SC3060 – In POSIX sh, string replacement is undefined.
- SCXXXX –
- Skype –
- Template – (Message goes here, use `code` and *foo* wisely)
- TravisCI –
- checkstyle2text –
- severity – Severity