Control Flow and Loops

Bash compares the word against each pattern using shell glob rules, not regular expressions, and a pattern must match the whole word. Clauses are tested top to bottom and the first match wins; every later clause is skipped.

In bash, $? holds the exit status of the most recently completed foreground command: 0 means success and 1-255 mean some kind of failure. Every command resets it, including echo, so an intervening command overwrites the status you meant to test.

In bash, -e means the path exists at all, -f means it is a regular file, -d means it is a directory, -s means it exists with a size above zero, and -r means the current user can read it. A directory exists, so -e is true and -f is false.

$(( )) is arithmetic expansion: it substitutes the computed integer into the command line. (( )) is an arithmetic command: it evaluates the same expression, prints nothing, and returns exit status 0 when the result is non-zero and 1 when it is zero.

Bash's if runs a command and branches on its exit status: status 0 takes the then branch, anything else takes elif/else. There is no boolean expression type. A leading ! inverts that status, so the then branch runs when the command fails.

Each stage of a bash pipeline runs in its own process, so the loop increments count inside a child shell that exits when the pipeline ends. Feed the loop from a redirection or a process substitution instead of a pipe.

IFS= stops read stripping leading and trailing whitespace from the line, -r stops it treating backslashes as escapes, and the redirection after done feeds the whole loop from the file so it stays in the current shell.

In bash, [ is an ordinary command, not syntax: the shell word-splits and globs its arguments first, so an empty or multi-word $answer changes the argument count and test reports a usage error. [[ is a shell keyword, so the expansion stays one word and needs no quotes.

Command substitution output is split on whitespace, so a filename containing a space becomes two loop items. Drop ls entirely and let the glob supply the list: for f in *.log, which yields one item per file no matter what the names contain.

declare -i marks a variable as integer, so every later assignment to it is evaluated as an arithmetic expression rather than stored as text. Non-numeric input silently becomes 0, and += means addition instead of string concatenation. A plain assignment with $(( )) makes that evaluation visible at each use site.

Bash applies tilde, parameter, arithmetic and command-substitution expansion plus quote removal to the case word, but never word splitting or pathname expansion — so an unquoted word is safe even with spaces. Quoting a pattern makes its wildcards literal.

In bash, && and || have equal precedence and associate left to right, so cmd1 && cmd2 || cmd3 means (cmd1 && cmd2) || cmd3. If cmd1 succeeds but cmd2 returns non-zero, cmd3 still runs — an if/then/else can never do that.

Brace expansion runs before parameter expansion, so bash sees {1..$n}, does not recognise it as a numeric range, and leaves it as text that later becomes {1..5}. Use a C-style loop, for ((i=1; i<=n; i++)), or iterate over seq output.

-gt compares integers, so it is false. Inside [ ], > is not an operator: the shell reads it as output redirection, creates a file named 10, and tests the single argument 5, which is true. Inside [[ ]], > compares strings, so 5 beats 10.

The post-increment count++ evaluates to the value before the increment, which is 0. A zero result makes the (( )) command exit with status 1, and a non-zero status on a bare command aborts the script. The variable was incremented; only the status looked like failure.

A bash case whose word matches no pattern runs nothing and returns exit status 0, so an unrecognised subcommand is indistinguishable from success. Harden it with a final catch-all clause that prints usage to stderr and exits non-zero.

In bash, 127 means the command was not found, 126 means it was found but could not be executed, and 137 is 128+9 — the process was terminated by signal 9, typically an out-of-memory or forced kill. All three come from the shell, not from the program's own error codes.

The loop body inherits the loop's standard input, and ssh reads standard input to forward it to the remote command — so the first ssh drains hosts.txt. Run ssh with -n, or redirect its input from /dev/null.

[[ ]] stops word splitting and globbing of its operands, so unquoted file and string tests really are safe. It does not make the right side of ==, != or =~ literal, does not validate the operands of -eq, and the unquoted habit breaks the moment you leave the brackets.

break 2 exits two levels of enclosing loop, so both the for and the while; continue 2 abandons the current inner iteration and starts the next iteration of the outer loop. A break inside case affects the enclosing loop, because case is not a loop.

A number with a leading zero is octal in bash arithmetic, so 08 is invalid — octal has no digit 8. Force base 10 with the base#number syntax, writing $(( 10#$month + 1 )), or strip the leading zero before doing the math.

In bash, ;; ends the case as soon as a clause runs. ;& falls through and runs the next clause's body without testing its pattern. ;;& keeps testing the remaining patterns and runs every later clause that also matches.

In bash's [[ ]], == matches the left value against the right side as a shell pattern, while =~ matches it against an extended regular expression and fills the BASH_REMATCH array. Quoting the right side makes it a literal string, so neither kind of matching happens.

A bash script's exit status is the status of the last command it ran, and here that is the successful echo, which masks the migration failure. Capture the status immediately with rc=$? and end with exit "$rc", or fail early on the migration itself.