The Linux Command Line

A shell reads commands and starts the work they request. A terminal is the window through which you type and see output. Opening another terminal normally starts another shell session. A console provides a directly attached text screen; an SSH login can provide a shell on another computer.

Read the prompt

In the example prompt sam@laptop:~$, sam is the user, laptop is the host, and ~ means the home directory. The final $ commonly marks an ordinary user. Prompt layouts can change, so use commands to confirm details when needed. whoami prints the account name, and pwd prints the current directory.

A # prompt conventionally marks root, the administrator account. Work as an ordinary user and use administrator rights only when a task needs them. A prompt symbol printed before an example command is not part of the command you type.

Run a first session

Type each line separately and press Enter:

whoami
pwd
date
echo Hello

For the example account, the first two results are sam and /home/sam. date shows the current date and time; echo Hello prints Hello. A command's output appears below its input, followed by a fresh prompt. Some successful commands print nothing: mkdir reports creates a directory silently. Inspect the result with ls when you need confirmation.

Bash, the Bourne Again Shell, is widely used on Linux. Other shells include zsh and fish. echo $0 shows how the current shell was invoked; echo $SHELL shows the account's configured login shell. Starting another shell can make those answers differ. A terminal window does not itself determine which shell runs inside it.

Edit and recover

Suppose you type ls Doc and press Tab. If Documents is the only matching name, completion fills it in. If several names begin with Doc, Bash needs more characters or a choice. Completion helps with spelling and case: Documents and documents are different names.

A full-screen program may be waiting for its own key instead of showing the shell prompt. Press q to leave man or less. A plain cat command without a file waits for typed input; Ctrl+C returns you to the shell. Ctrl+C is therefore not the usual terminal copy shortcut. Many terminal emulators use Ctrl+Shift+C and Ctrl+Shift+V for copy and paste.

Keyboard layouts also affect how you enter symbols such as ~, [, and {. Some layouts use AltGr, and a dead-key ~ may need Space before it appears. Type commands with their exact case: LS and ls are different command names.

A command line is made of words. The first word names what to run, options change its behavior, and arguments supply the objects or values it works on. Spaces separate those words.

Identify the parts

In ls -l /etc, ls is the command, -l requests a long listing, and /etc is the directory argument. The usage form command [options] [arguments] describes this arrangement; you do not type those square brackets.

Short options use one dash and a letter. ls -a -l, ls -al, and ls -la request the same listing. Long options use two dashes, as in ls --all. Keep long options separate; joining words behind one dash does not create a long option. For example, ls -all is read as the short options -a -l -l.

An option can also need a value. In touch -d 2025-01-31 old.txt, the date belongs to -d; old.txt is the file argument. The long form is touch --date=2025-01-31 old.txt. Read the usage description to see whether an option needs a value and how to supply it.

Keep each name together

The shell treats unquoted spaces as word boundaries. These three lines each name one file:

ls "Annual Report.pdf"
ls 'Annual Report.pdf'
ls Annual\ Report.pdf

The quotes or backslash protect the space; they are not part of the file name. Without that protection, ls Annual Report.pdf requests two files. A similar effect appears with echo: echo Hello world receives two words and prints one separating space, while echo "Hello world" preserves all three spaces inside one argument.

Make options unambiguous

Put options before file arguments. GNU commands often accept them later too, but options first makes a line easier to read and works more widely. For commands supporting it, -- ends option processing. rm -- -draft.txt therefore treats -draft.txt as a file name. The path ./-draft.txt also starts with a dot, so rm ./-draft.txt avoids an option-like first character.

Option letters belong to their command. cp -r copies directories recursively, but ls -r reverses sorting; ls -R lists directories recursively. ls -h changes size display and does not request help. A copied en dash, –, is also different from the ordinary - that options require.

Find out what a name runs

A command may be a program file, a shell built-in, or an alias that expands to another command line. cd is built into Bash because it changes that shell's directory. ls is normally a program, often with an alias adding color. type cd and type ls report the active meaning.

If ls-l fails with command not found, Bash searched for that whole name. Insert the missing space: ls -l. If a command complains about an unrecognized option, check the option's spelling and its documentation; changing the file path will not fix an option error.

A manual page is a detailed reference for a named command or system feature. Open one with man ls. The page normally appears in less, a pager that shows one screen at a time and lets you search without leaving the terminal.

Read the page's structure

The NAME heading identifies the command and its purpose. SYNOPSIS gives its calling pattern. DESCRIPTION and OPTIONS explain behavior and switches. EXAMPLES can show actual uses, while FILES and ENVIRONMENT describe related files and variables. SEE ALSO names related pages. Headings vary because some commands need information that others do not.

A usage line such as ls [OPTION]... [FILE]... is compact notation:

• Literal text, often bold, is typed as printed.
• Placeholder text, often italic or underlined, is replaced with your value.
• Square brackets enclose optional parts.
• ... means the preceding part can repeat.
• A vertical bar separates alternatives.

Both option and file groups in this ls form are optional, so ls alone is valid. In mkdir [OPTION]... DIRECTORY..., the directory group has no square brackets: at least one directory name is required. Do not type DIRECTORY merely because it appears in the manual.

Search while reading

Space or Page Down moves forward a screen; b moves back. Arrow keys move by lines. Lowercase g goes to the beginning, and uppercase G goes to the end. Type /human and press Enter to search for "human". Use n for the next result and N for the previous one. Press q to leave the page; h opens the pager's help.

For a practical search, open man ls, search for /human, and read the entry for -h, --human-readable. It works with a listing that shows sizes, such as -l. Quit the manual and run ls -lh. A file of 2048 bytes appears as 2.0K. Using ls -h alone still gives a plain name listing because no size column was requested.

Choose the right manual section

The reference passwd(5) names section 5's explanation of the password file format. Run man 5 passwd to select it. Plain man passwd normally opens the command page from section 1.

If you know the purpose but not the command, run apropos directory or man -k directory. They search indexed names and short descriptions. If you already know a name and want its one-line purpose, use whatis ls or man -f ls. A new system may have an empty index, so a failed keyword search does not establish that the command is absent.

Some minimal installations omit manuals. A missing man cd page also commonly reflects that cd is a shell built-in. Use help cd for Bash's own description.

You do not always need a full manual page. A quick option list, a built-in's own help, or an error message may answer the immediate question. Choose a source that describes the command you are actually running.

Match help to the command

type cp normally identifies a program file, so cp --help gives its usage and options. type cd identifies a shell built-in, so help cd describes Bash's version. help alone lists Bash built-ins; it does not provide a help page for the external program ls.

Most GNU commands support --help, but short option meanings differ. For ls, -h means readable sizes, not help. Reading ls --help is the reliable way to check ls options without guessing from another program.

Suppose you want to create reports/2026/q1, but the parent directories do not exist. Work through the question:

1. apropos directory suggests mkdir for making directories.
2. mkdir --help shows -p, --parents and explains creating missing parents.
3. mkdir -p reports/2026/q1 creates the whole route.

The help lookup provides the missing behavior, not just the command name. This matters when you already know mkdir but its ordinary form reports that a parent is missing.

Look beyond the option list

GNU Info manuals are longer linked documents. info coreutils opens documentation for the basic file utilities. Inside Info, n goes to the next node, p to the previous node, u up a level, Enter follows a selected link, and q quits. A node is one part of the linked manual.

Installed packages can also provide documentation under /usr/share/doc/. For example, ls /usr/share/doc/bash lists the Bash package's documentation. These directories may contain README files, change logs, license text, and examples. A .gz suffix marks a compressed file; zless can display compressed text.

Read an error as a clue

An error usually names the command, the object, and the reason. In ls: cannot access 'note.txt': No such file or directory, ls ran, but it could not find that path. Check pwd, the spelling and case, and the directory containing the file. Retyping ls in uppercase would create a separate command-name problem.

rmdir: failed to remove 'photos': Directory not empty means the target exists but still has entries. Listing it, including hidden entries, explains why removal failed. An unknown option is different: a message about --bogus directs you to ls --help because the option itself is invalid.

Local help matches the installed program more closely than an arbitrary web example. ls --version identifies the GNU version when you need to compare documentation. Before using an unfamiliar copied command, identify each option in its own help, especially for commands that remove files or run with administrator rights.

Linux arranges files and directories in one tree. A file holds data; a directory, called a folder in a graphical file manager, holds named entries for files and other directories. The tree starts at the root directory, /.

Follow the tree

A forward slash separates path components: /home/sam/photos leads from / into home, then sam, then photos. Other disks appear within the same tree, often below /media or /mnt; they do not need drive letters. A backslash is not a Linux path separator. Bash uses it to protect a following character, as in Annual\ Report.pdf.

Important locations have different jobs:

Many current distributions link /bin to /usr/bin and /sbin to /usr/sbin. You may therefore see two directory names leading to the same installed programs. The root directory / and the directory /root still mean different places: one starts the tree, and the other is one account's home.

Recognize your own files

For the example user sam, the home directory is /home/sam, abbreviated by the shell as ~. /home is its parent, not sam's personal directory. Personal documents and settings normally live in the home directory; /tmp is unsuitable for something you need to keep because temporary data may be removed automatically.

Consider this layout:

/home/sam/
  .bashrc
  Documents/
    cv.pdf
    letter.txt
  photos/
  projects/
    notes.txt
    website/
      index.html
      style.css

The full route to the style sheet is /home/sam/projects/website/style.css. The file notes.txt is beside website, not inside it. Each directory's entries determine the next possible step down the tree.

Read names exactly

Names are case-sensitive: notes.txt, Notes.txt, and NOTES.TXT can name three files. Names cannot contain / or a null byte. Simple letters, digits, dots, dashes, and underscores keep everyday names easy to type; common Linux file systems limit a single name to 255 bytes.

A suffix such as .txt is part of a name, not proof of its contents. file report examines the data and might identify a PDF even when the name lacks .pdf.

A leading dot makes an entry hidden from ordinary ls output. .bashrc, .profile, and .config commonly hold settings. Hidden means omitted by the default listing, not protected from access; ls -a reveals these names. The special entry . means the directory itself, and .. means its parent. At the root, .. still leads to /.

A path tells a command where to find an object. To read a path correctly, first decide where it begins. An absolute path begins at /; a relative path begins at the shell's current working directory.

Establish your starting point

pwd prints your current directory. From /home/sam, the path projects/website reaches /home/sam/projects/website. From /etc, that same relative path would mean /etc/projects/website. The absolute path /home/sam/projects/website identifies the same location from either starting point.

cd changes the current directory. It does not list the destination's contents or open a file. cd projects moves into a child named projects; cd /etc moves to the absolute location /etc. With no argument, cd returns home. cd - returns to the previous working directory and prints that location.

Work a route one part at a time

Start in /home/sam/projects/website and consider cd ../../photos:

1. The first .. reaches /home/sam/projects.
2. The second .. reaches /home/sam.
3. photos goes down into /home/sam/photos.

The whole command makes one change to the final destination. From the website directory, cd .. stops at projects, while cd ../.. stops at home. The starting directory matters each time: after you have moved, a second relative command starts from your new location.

A leading ./ explicitly names the current directory. ./notes.txt and notes.txt refer to the same local file. ls ../photos lists a nearby directory without moving your shell there; only a command that changes the working directory, such as cd, changes the base for later relative paths.

Use the home shortcut

At the start of an unquoted word, Bash expands ~ to your home directory. cd ~/Documents therefore works from anywhere for sam. ~alex refers to alex's home directory.

Quoting the tilde stops that expansion: cd "~/Documents" asks for a literal ~ directory below the current directory. If the later part contains a space, leave the tilde outside the quotes:

cd ~/"My Files"

You can also write cd "$HOME/My Files"; double quotes preserve the space while allowing the variable's value to expand.

Diagnose a route that fails

cd /projects asks for projects immediately below /, not below your home. cd.. is a single command name; write cd ... A lowercase documents fails when the real name is Documents. Check the start, each component, and its exact case. Tab completion can fill in an existing name and avoid a typing error.

Absolute paths suit instructions that must work from different locations. Relative paths are convenient for nearby work. Both forms also work as file arguments to cp, mv, ls, and other commands; a path's interpretation does not depend on using it with cd.

ls shows the contents of the current directory, or the files and directories you name. A listing can answer more than "What is here?": options reveal hidden entries, details, sizes, ordering, and subdirectories.

Choose what to show

Plain ls and ls -l omit hidden entries. -a includes them along with . and ..; -A includes hidden entries without those two special names. -F adds a slash after directory names. Output colors are another visual aid, but exact colors depend on the system.

ls projects lists what is inside projects. ls -ld projects instead shows a long listing of the directory entry itself. The -d option changes the object being displayed, not the amount of detail.

Read a long listing

Consider this line from ls -l:

-rw-r--r-- 1 sam sam 2048 Mar  3 14:20 notes.txt

Read from left to right:

1. - marks a regular file; d would mark a directory and l a symbolic link.
2. The next nine characters describe permissions for the owner, group, and others.
3. 1 is the link count.
4. The two sam fields identify owner and group.
5. 2048 is the file size in bytes.
6. The date and time describe the last content modification.
7. notes.txt is the name.

ls -lh displays that size as 2.0K. The -h option changes size formatting, while -l supplies the size column. ls -h alone still shows names without sizes.

A directory's own size is space used for its entries; it is not the sum of all data inside. The heading total 12 describes disk blocks for the listed entries, not twelve files. Use the file-name lines to see the entries themselves.

Order the result

For example, ls -lt puts newest changes first, while ls -ltr puts them last. ls -lhS shows readable sizes with the largest first. Case and punctuation can sort differently with different locale settings, so do not infer a missing file merely from where you expected its name to appear.

Inspect below the first level

ls -R projects lists the contents of projects, then its subdirectories. With notes.txt beside a directory website, the first heading is projects: and its entries include those two names. A later heading, projects/website:, identifies the listing containing index.html and style.css.

Uppercase -R is recursive. Lowercase -r only reverses sorting. Combining -a with a recursive listing also exposes hidden entries, which can make a result much longer. For one directory's metadata, ls -ld is usually the clearer inspection.

mkdir creates directories, and touch creates empty files or updates existing timestamps. These are separate actions: a directory provides a place for entries, while an empty file is already a file even though it contains no data.

Create the directory first

mkdir drafts creates one directory below your current location. mkdir drafts final creates two sibling directories. If a requested name already exists, ordinary mkdir reports File exists.

A path's parents normally need to exist. If reports is missing, mkdir reports/2026/q1 cannot reach the requested location. Add -p to create missing parent directories:

mkdir -p reports/2026/q1

This creates each missing level, and accepts levels already present as directories. Repeating the command is useful when preparing a structure whose existing parts should stay in place. It does not turn an existing regular file into a directory.

Add empty files

touch todo.txt creates a zero-byte file if that name is absent. If the file exists, touch keeps its contents and updates its access and modification times. It is not a command for clearing a file. You can name several files, as in touch a.txt b.txt, or choose a timestamp with touch -d 2025-01-31 old.txt.

Files with content normally come from a program that saves data, such as an editor. Creating a file with touch gives it a name and an empty body; it does not add text for you.

Build a small project

Starting in your home directory, run:

mkdir -p website/css website/images
touch website/index.html website/css/style.css
ls -R website

The first line creates website and its two child directories. The second puts index.html inside website and style.css inside website/css. It does not put either file in images. In the recursive listing, website: has css, images, and index.html; website/css: has style.css; website/images: has no ordinary entries.

Notice that the touch command relies on the parent directories created by mkdir. Reversing those two steps would fail if website did not yet exist.

Remove an empty directory

rmdir website/images removes that empty directory. rmdir website/css fails while style.css remains inside it. A hidden entry also makes a directory nonempty, so inspect it with ls -A if the ordinary listing looks blank.

rmdir -p reports/2026/q1 removes q1, then tries 2026, then reports. It stops when a parent is not empty. That option works upward, while mkdir -p builds missing parents downward.

Spaces still separate arguments. mkdir My Project requests two directories; mkdir "My Project" requests one. A simple name such as my-project avoids the space. The names Reports and reports are distinct, so use the same case in the creation command and in later paths.

A copy leaves a source in place. A move changes its name or location. To predict the result of either action, read the source path, the destination path, and whether the destination already exists.

Predict a copy's destination

cp notes.txt notes-backup.txt creates a second file named notes-backup.txt. If Documents is an existing directory, cp notes.txt Documents/ instead creates Documents/notes.txt. The final slash expresses the intention to copy into a directory.

When there are multiple sources, the last argument must be an existing directory. cp cv.pdf letter.txt backup/ puts both named files in backup. A missing destination directory is not created automatically by this command.

Directories require recursive copying. cp website website-old omits the directory because no recursive option was supplied. cp -r website website-old copies the tree, but the result depends on the destination:

An existing destination directory receives the source directory by name. It is not automatically replaced with the source's contents.

Move or rename

mv draft.txt final.txt renames a file. mv final.txt Documents/ moves it into an existing directory. mv website site renames a directory when site is absent, and needs no recursive option.

Within one file system, a move normally changes directory entries without copying all the data. Moving across file systems can require copying and removing data, so a large move need not finish instantly.

If archive does not exist, mv notes.txt archive renames the file to archive. mv notes.txt archive/ instead requires a directory and fails when that directory is absent. Use the slash when a new file name would be the wrong result.

Control replacement and metadata

Plain cp and mv can overwrite an existing destination file without asking. -i asks before replacement; -n skips existing destinations; -v prints actions. Aliases may add options, so use type cp or type mv if the observed behavior differs.

A newly created ordinary copy gets a new modification time. cp -p preserves timestamps and permissions, while cp -a recursively preserves a directory tree's attributes and is useful for backups. Do not assume a plain copy preserves its source's time merely because the contents match.

Trace a complete operation

From /home/sam, first create backup. cp projects/notes.txt backup/ creates backup/notes.txt. Next, mv backup/notes.txt backup/notes-2026.txt changes only the copy's name. Finally, cp -r projects/website backup/ creates backup/website, including its files. The original projects/notes.txt and projects/website remain where they were because neither was a source of a move.

rm removes files named by its arguments. Unlike a graphical file manager's trash action, it does not put them in a recycle bin. A backup is normally the route to recovery after a removal.

Select the right removal command

rm old.txt removes a file, and rm a.txt b.txt removes several named files. Plain rm old refuses if old is a directory. rmdir old or GNU rm -d old removes a directory only when empty. rm -r old recursively removes its contents and then the directory itself.

The distinction is useful when you expect an empty directory. rmdir failing with Directory not empty gives you a chance to inspect unexpected contents. Recursive removal would remove those contents too.

Control questions deliberately

For ordinary interactive input, rm may also ask about a write-protected file. -f suppresses that question. It does not turn the action into a recoverable deletion or remove every possible reason a command might fail.

Check the exact targets

Use this routine before a removal that could affect several names:

1. Run pwd to confirm your location.
2. List the exact names or pattern you intend to remove.
3. Inspect the list, including whether any directories are selected.
4. Use the same target expression with rm, adding -i when confirmation helps.

Suppose the directory contains draft1.tmp, draft2.tmp, final.txt, and notes.tmp. ls *.tmp shows the three temporary files. rm -i *.tmp asks about those three names; final.txt does not match. Answering n skips a file, while y confirms removal.

Keep path spelling intact

A space is a word boundary even in a dangerous command. Adding a space between ~/ and a child name changes one home-relative path into two separate targets. Check the whole line before Enter. Avoid forceful recursive removal for routine cleanup when a narrower command serves the task. GNU rm protects / itself by default; that protection does not protect every path below / from a mistaken pattern.

A leading dash can be mistaken for an option. rm -- -draft.txt ends option parsing before the file name. rm ./-draft.txt also names it unambiguously. For a space inside a name, use rm "old notes.txt"; the unquoted version names old and notes.txt separately.

An error needs diagnosis, not stronger privileges by default. If a removal fails, check whether the target is a directory, whether its path is correct, and what the actual message says. Repeating a mistyped command with administrator rights enlarges what the mistake can affect.

A glob is a file-name pattern. Bash replaces an unquoted pattern with matching existing names before it starts the command. You can use the same pattern with ls, cp, mv, or another command that accepts those names.

Match a name one part at a time

A pattern matches the whole name. report* matches report because the star may match no characters. beach?.jpg matches beach1.jpg, but not beach10.jpg: two digits cannot fit one question mark. beach[12].jpg restricts that one place to 1 or 2.

For a worked selection, let photos contain beach1.jpg, beach2.jpg, beach10.jpg, city1.jpg, city2.png, IMG_01.JPG, notes.txt, and .index. The pattern *.jpg matches the three beach photos and city1.jpg. city* also matches city2.png because it constrains the beginning, not the suffix. [!b]* matches names whose first character is not b, leaving out both the beach names and the hidden .index.

Account for case and leading dots

Matching is case-sensitive by default. *.jpg does not select IMG_01.JPG. The pattern *.[jJ][pP][gG] accepts either case at each suffix position, so it includes both styles.

A leading dot needs an explicit dot at the start of that path component in ordinary Bash matching. * skips .index; .i* selects it. This rule also applies inside a directory: photos/* skips hidden names in photos. The pattern does not acquire hidden files merely because ls -a is the command receiving it; expansion already happened before ls starts.

A wildcard does not cross /. photos/*.jpg selects matches directly inside photos. */notes.txt selects a matching file exactly one directory level below the current directory. It does not search every deeper directory.

Read character sets carefully

[abc] offers one character position, not a choice among whole file names. A leading ! or ^ negates the set. A range such as [a-f] follows locale rules, which can affect ordering and matching. Named classes use another pair of brackets: [[:digit:]], [[:upper:]], and [[:lower:]]. Their character classifications follow the locale; lowercase characters are not restricted to the ASCII letters a through z.

Globs and regular expressions use different rules. In a glob, a dot is a literal dot and * is already a complete "any sequence" instruction. Do not borrow the meaning of . or * from a text-search pattern when predicting file-name matches.

A program receives the names Bash produces, not the wildcard expression that selected them. That makes previewing useful: you can inspect the selected arguments before a command changes files.

Expand, then run

If notes.txt and todo.txt are the only .txt names, ls *.txt receives those two names. The shell performs the matching; ls is then free to list each argument according to its own rules. Matching directories count as names too, so a pattern is not a guarantee that every target is a regular file.

echo *.tmp prints the expanded words without changing files. ls -d -- *.tmp lists the matching entries themselves, including any directory entries, instead of showing their contents. For uncomplicated file names, these previews make it easy to check the selection before copying, moving, or removing.

In default Bash, a pattern with no match remains unchanged. If no .pdf name exists, echo *.pdf prints *.pdf; ls *.pdf tries to access that literal name and reports that it does not exist. A printed star therefore can be evidence of no match, not a real list of selected files.

Decide who should see the pattern

Quotes stop wildcard expansion. echo '*.txt', echo "*.txt", and echo \*.txt all print the literal pattern. In contrast, echo *.txt asks Bash to select existing matching names. Quoting is appropriate when the program itself should receive special characters, or when a real file has a star in its name.

Keep that choice separate from quoting spaces. A file name selected by glob expansion remains one argument even if the selected name contains a space. But a variable holding a path should normally be double-quoted when used, because its unquoted expansion can split into words.

Check the command's destination

cp *.jpg ~/backup/ copies matching names into an existing backup directory. mv draft* archive/ moves matching names into an existing archive directory. A final slash requires a directory destination, helping expose a missing destination instead of silently renaming a single source.

A broad * includes directories. cp * backup/ copies ordinary files but omits directories without recursive copying. Adding -r includes directories, including backup itself when it is inside the current directory; cp then refuses to copy that directory into itself. Put a backup outside the selected source set or choose a narrower pattern.

Spacing changes selection. *.tmp is one pattern; * .tmp is a broad pattern plus a separate dot-name argument. Preview the actual expression you will use.

Generate new names with braces

Brace expansion writes out words whether or not they exist:

mkdir -p project/{src,docs,tests}
touch file{1..3}.txt
cp notes.txt{,.bak}

The first line creates three named children. The second produces file1.txt, file2.txt, and file3.txt. The last expands to cp notes.txt notes.txt.bak; its first brace choice is empty. Use braces to generate names and globs to select existing ones.

Bash keeps a history list of commands entered in the shell. You can recall a line, inspect it, change one part, and run the edited version. This is especially useful for a long path or an option combination you used recently.

Recall a line before running it

The Up and Down arrows move through earlier commands. The recalled line becomes editable input; it is not executed until you press Enter. history prints the numbered list, and history 5 limits the output to recent entries.

Ctrl+R searches backward. Type part of a command, such as mkdir, to find the latest matching line. Press Ctrl+R again for an older match. Enter runs the shown command, while Ctrl+G cancels the search. Read the whole result, since the matched fragment may appear in several commands with different paths.

Understand exclamation-mark shortcuts

History expansion rewrites expressions before execution:

For example, immediately after mkdir -p reports/2026, cd !$ expands to cd reports/2026. The shortcut refers to the preceding command, so another command entered between those lines would change what !$ selects. To repeat a numbered command, use its event number; to reuse its last argument, use a word shortcut in the proper context.

Expansion normally prints the expanded command and runs it straight away. The display is not a confirmation prompt. A :p modifier, such as !rm:p, prints the expansion without running it. Arrow recall or Ctrl+R is often easier when you want to inspect and edit a potentially destructive line. You may see sudo !! used to repeat the last command with administrator rights; inspect the intended action before deciding that additional rights are appropriate.

Know what is saved

The active shell holds history in memory. On exit, it normally writes to the file named by HISTFILE, usually ~/.bash_history. Each terminal has its own in-memory list, so two open terminals need not show the same history at that moment.

HISTSIZE limits the number of commands kept in memory. Bash's built-in default is 500, though distributions often change it. HISTFILESIZE limits lines in the saved history file. These settings control different places, so changing one does not mean you changed both limits.

HISTCONTROL=ignorespace omits lines beginning with a space; ignoredups omits a line identical to the preceding one; ignoreboth combines them. These are configuration choices, not reasons to assume an arbitrary terminal leaves a command unrecorded. history -d 42 removes an entry, and history -c clears the current in-memory list.

Passwords placed in command arguments can be stored in history. Let a program request a password through its own prompt instead of putting it in the command line.

A variable gives a value a name. Bash can substitute that value into later command lines. An environment variable is also passed to programs started from that shell, letting those programs read settings such as language or home location.

Assign and read a value

Write an assignment without spaces around =:

city=Lisbon
echo "$city"
echo "${city}_trip"

The first line stores Lisbon; the next lines print Lisbon and Lisbon_trip. Braces mark where the variable name ends. Without them, $city_trip means a different variable named city_trip.

city = Lisbon is not an assignment: Bash tries to run a command named city with two arguments. Names are case-sensitive and may contain letters, digits, and underscores, but cannot start with a digit. Reading an unset variable gives an empty value in ordinary Bash use. unset city removes the value.

Choose quotes for the job

After greeting="Good morning", echo "$greeting, $USER" prints the greeting and account name as one argument. Double-quote a variable used as a path when its value may contain spaces. Single quotes protect everything inside them, including the dollar sign, so they cannot serve the same purpose as double quotes when you want a variable expanded.

Pass settings to child programs

A plain assignment creates a shell variable. export city marks it for the environment; export city=Lisbon combines both actions. Compare:

city=Lisbon
bash -c 'echo $city'
export city
bash -c 'echo $city'

If city was not previously exported, the first child shell prints an empty line. After the export, a newly started child receives Lisbon. Export passes a copy at launch; it does not update programs that are already running.

env and printenv list environment entries, while printenv HOME shows one. set lists shell variables and functions too. Common settings include HOME for home, USER for the user, PWD for the working directory, SHELL for the login shell, LANG for language and regional formats, and PATH for program lookup. Lowercase names for your own values avoid collisions with these conventional uppercase names.

Control lifetime and startup

An assignment before one command supplies a setting just to that command: TZ=Asia/Tokyo date prints Tokyo time without replacing the shell's time-zone setting. LC_ALL=C ls --help requests untranslated messages.

An unsaved prompt setting belongs to that shell; opening a separate terminal does not make it persistent. Put a repeated setting such as export EDITOR=nano in ~/.bashrc for interactive non-login Bash shells. Login shells read profile files, which often load that file. A new non-login shell reads the saved setting; source ~/.bashrc applies the file in the current shell.

When you enter a command name, Bash needs to decide what that name means. It can be an alias, function, built-in, or program file. PATH controls the program-file search for a name that has no slash.

Read the search list

PATH holds directory names separated by colons, for example /usr/local/bin:/usr/bin:/bin. echo "$PATH" prints the list. Bash considers shell-defined meanings first; for an external program name, it searches the listed directories from left to right and uses the first executable match.

The directory names matter, not the fact that a program is installed somewhere. A file outside the search list is not found by a bare name. Everyday programs are commonly under /usr/bin or /bin; administration programs use /usr/sbin or /sbin; local installations often use /usr/local/bin. Personal programs can live under ~/bin or ~/.local/bin.

If two PATH directories contain a program with the same name, the earlier directory wins for a fresh lookup.

Inspect the active command

type cd identifies a shell built-in. type ls may identify /usr/bin/ls or report a color alias. type -a echo lists the built-in and external matches. which ls normally reports a program path from PATH, but it can miss shell features that type knows about. Use type when you want to understand what Bash will actually do.

Run an explicit path

The usual PATH omits the current directory. An executable file named backup beside your prompt therefore needs ./backup unless its directory is in PATH. A command name containing / names a location directly:

./backup
/home/sam/bin/backup

Both forms bypass the PATH search. The first is relative to your working directory; the second starts from /. The file must still be executable. Merely being able to list or read it does not make it runnable.

Extend without replacing

To add a personal directory at the end, retain the existing value:

export PATH="$PATH:$HOME/bin"

The colon separates the old list from the added directory. With an executable backup in /home/sam/bin, a later backup command can now find it. Appending keeps any earlier matching program ahead of your new directory. Placing the new directory first would change which duplicate name wins.

PATH=$HOME/bin instead discards every existing directory in the value. External commands such as ls may stop working by bare name. Opening a fresh terminal with the normal startup configuration restores its normal PATH; for the current shell, export PATH=/usr/local/bin:/usr/bin:/bin supplies a basic repair list. Built-ins can still work because they are not found through PATH.

To retain an intended addition for new interactive non-login shells, save its export line in ~/.bashrc.