Navigate the Linux Command Line

What you will be able to do

• Read a shell prompt without confusing displayed context with command input.
• Distinguish logical, physical, absolute, and relative locations.
• Navigate and inspect paths with commands that preserve exact names and boundaries.
• Produce a reproducible terminal record before and after a filesystem task.

01

Read the prompt as context, not as a command

A prompt shows that a shell is ready for input. It may include a username, host, directory, or privilege marker, but its format is configurable and therefore not proof of identity or location. In documentation, copy only the command after the prompt marker unless the prompt itself is evidence.

Before working on an unfamiliar host, run `id` to see the effective user and groups, `hostname` when host identity matters, and `pwd` to see the current directory. Those three observations prevent a correct command from being applied to the wrong account, machine, or path.

A `$` or `#` glyph in an example normally represents a prompt; it is not part of the command. A `#` prompt can suggest elevated privilege, but verify with `id` rather than trusting presentation.

$ id -un
ana
$ hostname
app-01
$ pwd
/srv/app

The commands establish that the shell is running as `ana` on `app-01` with `/srv/app` as its current directory. The prompt decoration was not used as evidence.

Confirm user, host, and working directory before a path-sensitive command so a correct command is not applied in the wrong execution context.

02

Confirm the current directory in logical and physical form

Every shell has a current working directory. Relative pathnames begin there, which makes `pwd` a required check before a command that creates, moves, or removes files. Record the printed path with the command that produced it.

Symbolic links can make the displayed logical path differ from the resolved physical path. In Bash, `pwd -L` preserves the logical view when valid, while `pwd -P` resolves symbolic-link components. Compare them when a deployment, mount, or recovery procedure depends on the actual directory.

$ cd /srv/current
$ pwd -L
/srv/current
$ pwd -P
/srv/releases/2026-09-25

The friendly path `current` resolves to a dated release directory, so both names reach the same files.

Record the physical result when validating a deployment target whose logical path is a symbolic link.

Changing directory does not prove that a later filename is correct. After `cd`, repeat `pwd`; before a write, inspect the intended target separately.

03

Choose absolute or relative paths deliberately

An absolute pathname begins with `/` and resolves from the process root. A relative pathname resolves from the current working directory. `reports/today.txt` can therefore name different files in different shells, while `/srv/reports/today.txt` names the same location within the same filesystem namespace.

The components `.` and `..` refer to the current and parent directories during resolution. They are useful interactively, but a handoff or automation should use an unambiguous target when the starting directory is not guaranteed.

Use `realpath -e -- path` when you need the canonical form of a path whose components must already exist. The `--` ends option parsing so a pathname beginning with a hyphen is treated as data.

04

Use cd without losing the path you came from

`cd directory` changes the current shell's working directory. `cd` without an argument uses the configured home directory, `cd -` returns to the directory recorded in `OLDPWD`, and `cd ..` resolves a parent component. Follow movement with `pwd` when the next action changes state.

Quote directory names that contain spaces: `cd -- "Quarterly Reports"`. The `--` is useful when a name begins with a hyphen. Tab completion can reduce typing errors, but the completed text still needs review before Enter.

Logical navigation can retain symbolic-link names, while physical navigation resolves the directory structure. Use `cd -P` only when the physical path is the question; changing modes casually can make a familiar `..` sequence land somewhere unexpected.

05

Inspect directory entries and target metadata

`ls` lists directory entries; `ls -la -- directory` includes names beginning with a dot and a long-format view. The listing helps locate a candidate, but it does not prove file contents or explain every permission boundary.

Use `stat -- path` for metadata about one exact target. Use `file -- path` when the content type matters more than the filename extension. When access can fail at a parent directory, `namei -l -- path` is more useful than repeatedly changing directories because it shows each component.

Hidden names are ordinary names beginning with a dot; they are not automatically secret or protected. Do not expose their contents merely because `ls -a` revealed them.

06

Make pathnames survive shell parsing

The shell parses a command line before the program receives its arguments. Unquoted spaces split words, and wildcard characters such as `*` can expand to several pathnames. That is why a visually correct variable can address the wrong number of files when used unquoted.

Quote expansions intended to remain one pathname, such as `stat -- "$target"`. Use `printf '<%s>\n' -- "$target"` to inspect a variable boundary without letting `echo` options or escapes obscure the value.

Preview a wildcard with a read-only listing before a modifying command. If the target set is empty, unexpectedly broad, or includes a name beginning with a hyphen, stop and correct the command rather than relying on confirmation prompts as the safety model.

$ target='Quarterly Reports'
$ printf '<%s>\n' -- "$target"
<Quarterly Reports>

Quoting preserved `Quarterly Reports` as one argument, and the angle brackets make its exact boundary visible. Without the quotes, the shell would split the value at the space.

Inspect a variable as the shell will pass it before using that value in a command that reads or changes a pathname.

07

Verify the command before relying on its options

A name typed at a prompt can resolve to an alias, function, shell builtin, or executable file. Use `type -a name` to see the available interpretations and `command -v name` for the selected command. This matters when local aliases change familiar options.

For Bash builtins such as `cd`, start with `help cd`. For external tools, use the installed manual page, `man command`, or the command's documented `--help` output. Documentation from another operating system or version may describe different options.

Do not paste a command from a search result directly into an administrative shell. Identify the resolved program, read the options that affect scope, substitute the exact target, and preview any expansion first.

08

Leave a reproducible navigation record

Suppose a service owner asks whether `/srv/app/current/config.yml` is the active configuration. Record `id`, `hostname`, `pwd`, `realpath -e -- /srv/app/current/config.yml`, and `stat --` for the resolved target. This establishes execution context, link resolution, ownership, timestamps, and the exact file under discussion.

Do not change directory merely to shorten every command. Absolute paths are often clearer in a ticket or runbook because another operator can reproduce them from any working directory. Remove secrets and unrelated directory contents from the record.

If a change is later approved, repeat the same target-specific observations afterward. The evidence should show that the intended object changed on the intended host while neighboring files and link targets stayed within scope.

09

Leave a navigation handoff another operator can verify

Treat the prompt as presentation. Verify the effective user, host, and current directory with commands when those facts affect the task.

Use `pwd -L` for the logical location and `pwd -P` for the physical location. Compare them when symbolic links change the operational meaning of a path.

Absolute paths begin at `/`; relative paths begin at the current directory. Resolve an existing target with `realpath -e` when a canonical path is required.

Use `ls` to discover names, then `stat`, `file`, or `namei` for the specific metadata question. Hidden entries are not automatically protected.

Quote pathname expansions, terminate options with `--` where supported, preview wildcards, and record the exact command and result another operator needs to reproduce the decision.