Bash

Create with arr=(a b c), append with arr+=(d), read one element as "${arr[0]}", count with "${#arr[@]}". A bare $arr is shorthand for ${arr[0]}, so it shows only the first element.

Bash parses count = 5 as the command count with the arguments = and 5. An assignment must have no spaces around =: write count=5, and quote the value when it contains spaces, as in msg="hello world".

In globbing, * matches any run of characters, ? exactly one character, and [abc] or [[:digit:]] one character from a set; the pattern must match a whole filename. In a regex, * instead repeats the preceding item.

They give archive.tar.gz, /var/log/app, /var/log/app/archive.tar and /var/log/app/archive. In bash, # strips a matching prefix and % strips a matching suffix; doubling the character strips the longest match instead of the shortest.

Double quotes still expand variables and command substitutions while suppressing word splitting and filename globbing; single quotes suppress all of that as well, so every character between them is literal, including the dollar sign and the backslash.

It prints 3. Bash arithmetic is integer-only, so division truncates toward zero and there is no fractional result. For decimals you call out to another tool — awk or bc — or scale the integers up before dividing and format the result with printf.

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.

A bash function receives its own positional parameters: $1, $2 … are the function's arguments and $# is their count, shadowing the script's for the duration of the call. $0 is the exception — it still names the script. Write ${10}, because $10 parses as $1 followed by 0.

Bash variables are global by default, so an assignment inside a function writes into the one shell-wide namespace and survives the return. Declaring the name with local (or declare) inside the function creates a temporary copy that disappears when the function returns.

In bash, return only sets the function's exit status — a number 0-255 the caller reads in $? — never a value. To hand back real data, print it with echo or printf and capture it with result=$(func).

source (and its POSIX synonym .) reads the file and runs its commands in the shell you are already in, so variables, functions and cd persist. ./setup.sh starts a separate shell that gets a copy of the environment and discards everything when it exits.

"$@" expands to one word per argument, preserving spaces and empty arguments — it is the only correct way to forward. "$*" joins everything into a single word separated by IFS's first character. Unquoted $@ re-splits each argument on whitespace and globs the pieces.

The >&2 is shorthand for 1>&2: it makes echo's stdout a duplicate of file descriptor 2, so the message is written to stderr instead of stdout. Diagnostics belong on stderr so a caller can capture, pipe or discard the script's real output without losing them.

By default a bash pipeline reports only the exit status of its last command; every earlier stage's status is discarded. So false | true returns 0, and a failing build piped into tee or grep looks successful to CI.

A bare > redirects only standard output, file descriptor 1. Error messages travel on standard error, descriptor 2, which stays on the terminal until you redirect it explicitly with 2> file, 2>> file, or 2>/dev/null.

Bash applies redirections left to right, and each one copies where the target points at that moment. cmd > out.log 2>&1 puts stdout in the file and then makes stderr a copy of it, so both are captured. cmd 2>&1 > out.log copies stderr to the terminal first, then moves only stdout.

Quoting the here-document delimiter (<<'EOF') sends the body through untouched; leaving it unquoted (<<EOF) makes the local shell expand $variables, $(...) and backticks in the body first. Use the quoted form for anything that must be evaluated on the remote host.

Appending & runs the command asynchronously in a background child process and returns immediately with status 0. $! then holds that child's PID. A bare wait blocks until every background child of the script has finished.

Both run a command and substitute its standard output, but $(...) nests and quotes cleanly because everything up to the matching ) is parsed as a fresh command, while backticks need a backslash escape for every nested level and mangle backslashes and inner quotes.

Only exported variables become part of a child process's environment. A plain assignment creates a shell variable that lives in the current shell alone; marking it with export copies it into every command the shell runs afterwards, including child.sh.

Bash runs an EXIT trap whenever the shell itself decides to exit: the end of the script, any explicit exit, an abort under set -e, and after a fatal signal such as SIGTERM. SIGKILL leaves it unrun.

Every stage of a bash pipeline runs in its own forked subshell, so the while loop increments a copy of count that dies when the pipeline finishes. Feed the loop by redirection instead of through a pipe.

set -x makes bash print every command to stderr just before running it, after expansion, prefixed by PS4 (default "+ "). Wrap a region in set -x and set +x to scope it, or run bash -x script.sh to trace one run without touching the file.

eval joins its arguments and hands the result back to the shell parser, so metacharacters inside the variable become syntax instead of data. Anyone who controls the value can run arbitrary commands as the script's user.

OPTIND is the index of the next argument getopts will examine, and getopts never alters the positional parameters itself. The missing line is shift $((OPTIND - 1)) after the loop, which drops the parsed options so operands start at $1.

cron mails any output a job produces to the crontab owner, or to MAILTO if set, and mails nothing when the job prints nothing. Appending > /dev/null 2>&1 discards errors too, which is why failures go unnoticed.

ShellCheck statically analyses shell scripts and flags quoting, expansion and exit-status mistakes that run without any error message yet behave wrongly. It grades findings as error, warning, info or style, and picks the dialect from the script's shebang.