Command Line Fundamentals Cheat Sheet

Table 1: Directory Navigation

Navigating the filesystem fluently is the first skill any CLI user must internalize. pwd, cd, and ls form the absolute core; pushd/popd add a directory stack so you can jump between multiple locations without retyping paths — essential in long sessions involving many directories.

Table 2: File Operations

These commands create, copy, move, rename, delete, and inspect files — the basic CRUD of the filesystem. The -r flag (recursive), -i (interactive confirmation), and -p (preserve attributes or create parents) recur throughout; understanding them reduces the need to memorise each command separately.

Table 3: Viewing File Contents

Quickly reading files without opening an editor is one of the most frequent CLI tasks. cat dumps everything at once; less provides a scrollable pager; head/tail show the edges — choose based on file size and which part you need.

Table 4: Wildcards and Globbing

Shell globbing lets the shell expand patterns to matching filenames before the command even runs — it is the shell, not the command, doing the matching. This distinction explains why ls *.txt and ls '*.txt' behave completely differently.

Table 5: Redirection Operators

Every Linux command has three standard streams: stdin (0), stdout (1), and stderr (2). Redirection operators route these streams to files, other commands, or each other — mastering them turns output into data you can store, compare, and feed back into pipelines.

Table 6: Pipes and Command Chaining

Pipes connect the stdout of one command to the stdin of the next, enabling the Unix philosophy of composing small tools into powerful workflows. The logical operators (&&, ||, ;) control whether subsequent commands run based on exit status — this is how scripts implement error-aware flows.

Table 7: Text Processing

These stream-editing tools are the heart of shell text manipulation. Each does one thing: grep filters lines, sed transforms them, awk processes structured fields, sort/uniq deduplicate. Chaining them with pipes builds data-processing pipelines that rival dedicated ETL tools.

Table 8: File Searching

Finding files by name, content, size, type, or age is a daily task. find is the most powerful and flexible tool — combine it with -exec or xargs to act on results. type is the most reliable way to discover which version of a command the shell will actually run.

Table 9: File Permissions

Every file has an owner, a group, and permission bits for owner, group, and others (read=4, write=2, execute=1). Understanding chmod notation (both octal and symbolic), umask, and chown is essential for both security and scripting. Run ls -l to see the resulting permission string.

Table 10: Process Management

Understanding how processes start, stop, pause, and run in the background is essential for system administration and scripting. Job control (bg, fg, jobs) manages processes within your terminal session; nice/renice control CPU priority; nohup detaches processes from the terminal so they survive disconnect.

Table 11: Environment Variables

Environment variables pass configuration into processes and scripts. export makes a variable available to child processes; source executes a script in the current shell so its variables and functions become part of your session. PATH is the most critical variable — it determines which commands the shell finds.

Table 12: Special Variables

Bash sets several automatic variables that capture process state after every command. $? after every command tells you whether it succeeded. $@ and $* both expand all positional parameters but behave differently under double-quotes — $@ preserves individual arguments, $* joins them with IFS.

Table 13: Command Substitution and Expansion

Parameter expansion is one of the most powerful Bash features for manipulating strings, applying defaults, and extracting substrings — all without spawning a subprocess. Learning the full set of ${var...} forms eliminates many cases where people reach for sed or awk to do simple string work.

Table 14: Quoting and Escaping

Quoting determines which characters the shell interprets literally versus specially. Single quotes are the most aggressive: nothing inside expands. Double quotes allow variable and command substitution. Getting quoting wrong is the single most common source of subtle bugs in shell scripts — always quote variables unless you deliberately want word-splitting.

Table 15: Conditionals

Shell conditionals test file attributes, string values, and numeric relationships. Prefer [[ ... ]] over [ ... ] in Bash scripts — it avoids word-splitting pitfalls and supports pattern matching and &&/|| directly. The case statement is cleaner than chained elif when matching a single value against multiple patterns.

Table 16: Loops

Loops automate repetition. for iterates over a list or a C-style range; while runs until a condition is false; until is the inverse. The while IFS= read -r line pattern is the canonical way to process file lines safely — preserving whitespace and backslashes that naive loops would mangle.

Table 17: Networking Commands

Network tools handle the full stack from raw connectivity checks (ping) through file transfer (curl, rsync, scp) to port inspection (ss, nc). The modern ip command has replaced ifconfig and route on most Linux distributions; ss has replaced netstat.

Table 18: Archiving and Compression

tar bundles files into archives; compression algorithms (gzip, bzip2, xz, zstd) shrink them. These are two separate concerns: tar flags -z, -j, -J, --zstd each invoke a different compressor. Cross-platform portability often dictates using zip.

Table 19: Command History and Shortcuts

Readline keyboard shortcuts and Bash history expansion dramatically reduce keystrokes. Ctrl+R reverse-incremental-search is the single most useful shortcut to memorise. History expansion (!!, !$, !:n) lets you reuse and modify previous commands without retyping.

Table 20: Subshells and Command Grouping

Parentheses create a subshell — commands run in an isolated copy of the environment, so directory changes and variable assignments don't leak back to the parent. Curly braces group commands in the current shell. Process substitution creates anonymous pipe endpoints that look like files, enabling powerful comparisons and multi-source reads.

Table 21: Arrays (Bash 4.0+)

Bash arrays store ordered (indexed) or key-value (associative) collections. mapfile / readarray is the canonical way to read command output or file lines into an indexed array — it avoids the pitfalls of parsing with a while loop and is faster for large inputs. Arrays do not survive export.

Table 22: Input and Output Builtins

The read builtin reads a line from stdin and assigns words to variables — it is the standard way to accept user input and to safely iterate over file lines. printf formats output with far more precision and reliability than echo, especially when output must be consistent across different systems.

Table 23: Shell Script Safety Options

set options harden scripts against common failure modes that Bash otherwise silently ignores. Running with set -euo pipefail catches errors immediately, treats unset variables as errors, and propagates non-zero exit codes through pipelines — these three options together are the standard guard for production scripts.

Table 24: Signal Handling

Signals are asynchronous notifications sent to a process by the OS or another process. The trap command intercepts them and runs a handler — most commonly used with EXIT to guarantee cleanup code runs regardless of how the script exits. SIGKILL (9) cannot be trapped or ignored; SIGTERM and SIGINT can.

Table 25: Disk and System Monitoring

df shows free space at the filesystem level; du drills into directory and file sizes. Together they answer where disk space went. free, uname, and uptime give a quick system health snapshot without needing a full monitoring tool.

Table 26: Declaring and Typing Variables

declare (synonym: typeset) gives variables attributes that control their behavior: integer arithmetic, case conversion, export, and read-only status. Using local inside functions prevents variable leakage. readonly creates a constant that cannot be reassigned or unset.