Variables and Arguments

A shell variable is a name bound to a string. The shell has no integers, floats, or arrays-of-numbers in the way a programming language does — everything is text until a command or an arithmetic context interprets it otherwise. You assign with name=value and absolutely no spaces around the =, because name = value is parsed as the command name with arguments = and value. You read the value back by prefixing the name with $, and the shell performs the substitution before the command ever runs.

Arguments are how the outside world reaches the script: the positional parameters $1, $2, and onward hold what the caller typed after the script name, $# holds the count, and "$@" holds the whole list. The single operational fact that governs nearly everything on this page is that the shell splits unquoted variable expansions on whitespace and then expands glob characters. Forget to quote, and a filename with a space becomes two arguments, an empty variable vanishes entirely, and a value containing * silently turns into a directory listing.

Assignment and Scope

An assignment with no export creates a shell variable that lives only inside the current shell and is invisible to any command the shell launches. export name (or export name=value) promotes it to an environment variable, which is copied into the environment of every child process. This is why VAR=hello; bash -c 'echo $VAR' prints a blank line, while export VAR=hello; bash -c 'echo $VAR' prints hello — the child only sees what was exported.

A variable assignment placed in front of a command, with no semicolon, sets that variable for that one command only and does not touch the current shell. This is the idiom behind LC_ALL=C sort file or DEBIAN_FRONTEND=noninteractive apt-get install -y nginx: the override applies to the single invocation and is gone afterward. Names are conventionally uppercase for exported and environment variables, lowercase for script-local ones, which keeps your own variables from colliding with the dozens the system already defines.

greeting="hello world"          # no spaces around =
echo "$greeting"                # hello world
export PATH="$PATH:/opt/bin"    # now visible to child processes

# per-command override, does not persist:
LC_ALL=C sort names.txt

Quoting and Expansion

Double quotes preserve whitespace and stop word-splitting and globbing while still allowing variable and command substitution — "$var" expands but stays a single argument. Single quotes are literal: '$var' is the four characters dollar-v-a-r, with no substitution at all. The default discipline for any value that came from outside the script is to wrap every expansion in double quotes, including "$@", which is the only form that preserves each argument exactly as the caller passed it.

Curly braces, as in ${name}, disambiguate where the variable name ends — ${file}_backup is the value of file followed by _backup, whereas $file_backup looks up a variable literally named file_backup that probably does not exist and expands to nothing. Brace syntax also unlocks parameter expansion: defaults, length, substring, and pattern removal, all without spawning an external process.

Expansion	Result
${var:-default}	value of var, or default if unset or empty
${var:=default}	same, but also assigns default to var
${var:?message}	expand var, or exit with message on stderr if unset or empty
${#var}	length of the value in characters
${var#prefix} / ${var%suffix}	remove shortest matching prefix / suffix
${var/old/new}	replace first occurrence of old with new

Positional Parameters

When a script runs, $0 is the path it was invoked as, $1 through $9 are the first nine arguments, and beyond nine you must brace them — ${10}, not $10, which the shell reads as $1 followed by a literal 0. $# is the argument count, useful for a guard like [ "$#" -lt 2 ] && { echo "need 2 args" >&2; exit 1; }. The pair $@ and $* both list all arguments, but they differ exactly once: quoted. "$@" expands to one word per argument, preserving spaces inside each; "$*" joins them into a single string separated by the first character of IFS. For passing arguments through to another command, "$@" is the only correct choice.

shift drops $1 and renumbers the rest down by one, which is how you walk a variable-length argument list or consume flags one at a time. For anything more than a couple of flags, getopts parses single-letter options in the POSIX style and is built into the shell, so it costs nothing and behaves identically on Debian, Ubuntu, and Red Hat. The external getopt from util-linux handles long options like --verbose but is a separate program with its own quoting rules.

#!/usr/bin/env bash
set -euo pipefail

verbose=0
while getopts ":vo:" opt; do
  case "$opt" in
    v) verbose=1 ;;
    o) outfile="$OPTARG" ;;
    *) echo "usage: $0 [-v] [-o file] target" >&2; exit 2 ;;
  esac
done
shift "$((OPTIND - 1))"      # drop parsed options, leaving "$@" as operands

echo "verbose=$verbose target=${1:?target required}"

Command Substitution and Arithmetic

Command substitution runs a command and replaces the expression with its output, trailing newlines stripped. Use $(command), not the backtick form — $() nests cleanly and does not require escaping inner quotes. A common assignment is count=$(wc -l < access.log), and because the result is captured before word-splitting decisions are made, you still quote it on use: echo "$count". The pattern now=$(date +%s) captures a Unix timestamp; files=$(find /var/log -name '*.gz') captures a newline-separated list that you should iterate with care, not by leaving it unquoted.

Arithmetic lives in $(( )), which treats its contents as integers and supports the usual C operators. Inside it you do not prefix variables with $ — $((count + 1)) works. The shell has no floating point; $((7 / 2)) is 3, and for decimals you reach for bc or awk. Unset variables evaluate to 0 in arithmetic, which is convenient for counters but masks typos, so under set -u an unset name in $(( )) still triggers the error and saves you.