Basics

#!/usr/bin/env bash        # preferred: uses PATH to find bash
#!/bin/bash                # absolute path (common but less portable)

bash script.sh             # run with bash explicitly
./script.sh                # run directly (must be +x)
chmod +x script.sh         # make executable
bash -x script.sh          # trace execution (debug mode)
bash -n script.sh          # syntax check only (no execution)
bash -e script.sh          # exit on first error
bash -u script.sh          # error on unset variables
bash -o pipefail script.sh # propagate pipe errors

set -e                     # exit immediately on error
set -u                     # treat unset variables as errors
set -x                     # print each command before executing
set -o pipefail            # pipe fails if any command fails
set -euo pipefail          # common "safe mode" combination

set +e                     # disable exit-on-error
set +x                     # disable trace

# In a script header:
set -euo pipefail

echo "Script: $0, Args: $#"
echo "All args: $@"
echo "Last exit: $?"
echo "PID: $$"

# This is a single-line comment

: '
This is a
multi-line comment block
(uses the no-op colon command)
'

echo "code"  # inline comment

'literal string'           # single quotes: no expansion at all
"double quoted $var"       # double quotes: expands variables and $()
$'escape sequences'        # ANSI-C quoting: \n \t \\ etc.
\\                         # escape next character
echo "Tab:\tNewline:\n"    # \t \n NOT interpreted inside ""
echo $'Tab:\tNewline:\n'   # \t \n ARE interpreted here
printf "A\tB\n"            # printf always interprets \n \t

echo "hello"               # print to stdout (adds newline)
echo -n "no newline"       # suppress trailing newline
echo -e "line1\nline2"     # interpret escape sequences
printf "%-10s %d\n" name 42  # formatted output (preferred over echo)
printf '%s\n' "$var"       # safely print variable

read var                   # read line from stdin into var
read -p "Enter: " var      # display prompt before reading
read -s var                # silent (no echo, for passwords)
read -t 5 var              # timeout after 5 seconds
read -a arr                # read words into array
read -r line               # raw: don't interpret backslashes
read -d $'\0' var          # read until NUL byte

exit 0                     # exit with success
exit 1                     # exit with failure
exit $?                    # exit with last command's status

true                       # always exits 0
false                      # always exits 1
echo $?                    # print last exit status (0 = success)

command && echo "ok"       # run echo only if command succeeds
command || echo "failed"   # run echo only if command fails
command && echo "ok" || echo "failed"   # if/else one-liner

! command                  # negate exit status

cmd1; cmd2                 # run sequentially (ignore exit status)
cmd1 && cmd2               # run cmd2 only if cmd1 succeeds
cmd1 || cmd2               # run cmd2 only if cmd1 fails
cmd1 | cmd2                # pipe stdout of cmd1 to stdin of cmd2
cmd1 |& cmd2               # pipe both stdout and stderr (bash 4+)

(cd /tmp && ls)            # subshell: changes don't affect parent
{ cd /tmp; ls; }           # current shell: changes DO affect parent
                           # note: space after { and semicolon before }

cmd &                      # run in background
wait                       # wait for all background jobs
wait $!                    # wait for last background job
wait $pid                  # wait for specific PID
jobs                       # list background jobs
fg %1                      # bring job 1 to foreground
bg %1                      # send job 1 to background
kill %1                    # kill job 1
kill -9 $pid               # force kill by PID
disown %1                  # remove job from job table (won't get HUP)
nohup cmd &                # run immune to hangup signal

:                          # no-op, always returns 0
.  file                    # source (same as source)
source file                # execute file in current shell
alias ll='ls -la'          # create alias
unalias ll                 # remove alias
type cmd                   # show how cmd would be interpreted
which cmd                  # show path of cmd (external)
command -v cmd             # portable check if cmd exists
builtin cd                 # force use of builtin, not a function
help builtin               # show help for a builtin

!!                         # repeat last command
!n                         # repeat command number n
!string                    # repeat last command starting with string
!$                         # last argument of previous command
!^                         # first argument of previous command
^old^new                   # replace old with new in last command
history                    # show command history
history 20                 # show last 20 commands
history -c                 # clear history
Ctrl+R                     # reverse search history (interactive)