Common Linux Commands Notes

1. Quick Reference Table for Linux Paths

Syntax	Meaning	Example	Description
`<span><span>/</span></span>`	🟥 Root Directory	`<span><span>/etc/hosts</span></span>`	Starting point for all paths
`<span><span>.</span></span>`	🟩 Current Directory	`<span><span>./script.sh</span></span>`	Indicates “in the current directory”
`<span><span>..</span></span>`	🟨 Parent Directory	`<span><span>../file.txt</span></span>`	Parent directory of the current directory
`<span><span>~</span></span>`	🟦 Current User’s Home Directory	`<span><span>~/docs</span></span>`	Equivalent to `<span><span>/home/username</span></span>`
`<span><span>~user</span></span>`	🟪 Specified User’s Home Directory	`<span><span>~root</span></span>`	Indicates `<span><span>/root</span></span>`
Absolute Path	🟧 Complete path starting from `<span><span>/</span></span>`	`<span><span>/home/user/file.txt</span></span>`	Uniquely identifiable by the system
Relative Path	🟩 Path relative to the current directory	`<span><span>docs/file.txt</span></span>`	Depends on the current location
`<span><span>-</span></span>`	🟦 Last Directory	`<span><span>cd -</span></span>`	Switch between two directories

2. File and Directory Operations

- Parameters start with this symbol
Writing name "*.py" → The system treats it as a regular filename parameter, not a condition
Writing as -name "*.py" → Represents “conditional option” that tells find to match by name

In other words, - Parameters start with this symbol are similar to ls -l and rm -r commands.

2.1 ls – List Directory Contents

ls                    # List files in the current directory
ls -l                 # Detailed information (permissions, size, time, etc.)
ls -a                 # Show hidden files
ls -la                # Combined usage
ls -lh                # Human-readable file sizes

“l for detailed, a for all, h for human-readable, t for time, r for reverse”

2.2 cd – Change Directory

cd /path/to/directory  # Change to specified directory
cd ..                  # Go back to the parent directory
cd ~                   # Return to home directory, just typing cd works too
cd -                   # Return to the last directory

2.3 pwd – Display Current Directory Path

pwd                    # Display full path

2.4 mkdir – Create Directory

mkdir is for creating directories, not files

mkdir Name Origin

mk → make (create)
dir → directory (directory)
Combined, it means make directory → Create a directory.

-p Meaning

-p = parents (parent directory)
Meaning:If the parent directory does not exist, create it as well; and if the directory already exists, no error will be reported.

mkdir dirname          # Create a single directory
mkdir -p path/to/dir   # Recursively create multi-level directories
mkdir dir1 dir2 dir3   # Create multiple directories at once

2.5 rm – Remove Files/Directories

rm = remove
Function: Remove files or directory links.
-r → recursive (recursively) → Deletes everything down the line, including files and subdirectories in the directory.

-f → force (force) → Force delete, will not ask for confirmation, nor will it prompt for non-existent files.

In the Unix/Linux world, most commands are abbreviations of English words, rm is short for remove (to remove, delete).

rm filename            # Remove file
rm -r dirname          # Recursively remove directory
rm -f filename         # Force delete (no prompt)
rm -rf dirname         # Forcefully recursively delete directory
rm *.txt               # Remove all .txt files

2.6 cp – Copy Files/Directories

cp = copy (to copy)

This is the abbreviation style of early Unix system commands: take the first two letters of the word, short and easy to type.

-p = preserve (to keep/preserve)

Purpose: When copying files, preserve the original file’s attributes, including:

Modification time (mtime)
Access time (atime)
Permissions (rwx)
Owner and group

cp file1 file2         # Copy file.
cp test.txt backup.txt   # Copy and name the new file backup.txt
cp file /path/to/dest  # Copy to specified directory
cp -r dir1 dir2        # Recursively copy directory
cp -p file1 file2      # Preserve original file attributes

2.7 mv – Move/Rename Files

mv = move (to move)

Function:

Move files/directories to a new location
Rename files/directories

mv oldname newname     # Rename file, works for directories too
mv file /path/to/dest  # Move file, directories can also be moved
mv dir1 dir2           # Move or rename directory

2.8 find – Find Files

1. Find by Name

find . -name "*.txt"         # Find .txt files in the current directory
find /path -name "*.py"      # Find .py files in the specified path

Find by Type

Without adding -type, find will only match based on name, size, etc., possibly including directories, symbolic links, etc.

find . -type f -name "*.py"  # Find Python files in the current directory
find /path -type d -name "test"  # Find directory named test in the specified path

📖 Common -type Types**

-type f → Regular file (file)
-type d → Directory (directory)
-type l → Symbolic link (symlink)
-type s → Socket (socket)
-type b → Block device (block device)
-type c → Character device (character device)

Find by Size

find . -size +100M           # Find files larger than 100MB in the current directory
find /path -size -10M        # Find files smaller than 10MB in the specified path

Starting from the current directory, find files that are larger than 100MB.

+100M → Greater than 100MB
-100M → Less than 100MB
100M → Exactly 100MB

4. Find by Time

find . -mtime -7             # Find files modified within the last 7 days in the current directory
find /path -mtime +7         # Find files modified more than 7 days ago in the specified path

Starting from the current directory, find files that are larger than 100MB .

+100M → Greater than 100MB
-100M → Less than 100MB
100M → Exactly 100MB

3. File Viewing and Editing

Command	Function	Features
`<span><span>cat</span></span>`	Display entire file	Prints all at once, suitable for small files
`<span><span>more</span></span>`	Paginated display	Can only scroll down, limited functionality
`<span><span>less</span></span>`	Paginated display	Can scroll up and down, search, most powerful functionality

3.1 cat – Display File Content

Full name:concatenate (verb, to connect, to concatenate).

In Unix/Linux, cat was originally used to concatenate the contents of multiple files and output them to the terminal.

Later, because using cat file.txt can directly display content, many people began to use it as the command to “view files”.

cat filename           # Display entire content of the file, not applicable for directories
cat file1 file2        # Display multiple files at once
cat -n filename        # Display line numbers and show entire content of the file

3.2 less/more – Paginated Viewing

1 less

The name comes from the English proverb “less is more” (less is more).
It is named as an improved version of more:

more → Can only scroll down, limited functionality
less → More powerful, can scroll up and down, search, jump

So the author humorously named it less, meaning “less is stronger than more”.

less filename          # Paginated viewing (recommended)

The file will not be printed all at once to the screen, but displayed page by page.

You can use shortcut keys to scroll, search:

space → Next page
b → Previous page
/keyword → Search
q → Exit

2 more means “show more content”.

(1) Compared to less, it can show the reading progress

more filename          # Paginated viewing
# In less: q to exit, / to search, n for next, N for previous

(2) Can query keywords

After entering more, you can operate like this:

/keyword → Search down for “keyword”

Example:
```
/hello
```
Will find the first “hello” in the remaining content and stop there, just type and press enter to query.

n → Find the next match (abbreviation for next)
q → Exit

3.3 head/tail – View File Start/End

📌head

English:head = head
Meaning: Display the “first few lines” of the file
Defaults to 10 lines, can use -n to specify the number of lines.

📌 tail

English:tail = tail
Meaning: Display the “last few lines” of the file
Defaults to 10 lines, can use -n to specify the number of lines.

📌 tail -f

-f = follow (to follow)
Meaning: Continuously “follow” changes at the end of the file, commonly used for log files.

head filename          # Display first 10 lines, file with extension
head /tmp/demo.txt     # File without extension
head /tmp/demo
head -n20 filename    # Display first 20 lines
tail filename          # Display last 10 lines
tail -n50 filename    # Display last 50 lines
tail -f filename       # Real-time monitor file changes

3.4 grep – Text Search

grep is used to search for text within file contents.

📌 grep name origin

grep comes from a command in the ed editor:
```
g/re/p
```
Meaning:globally search for a regular expression and print 👉 Globally search for a regular expression and print.
Later it was simplified to the command name grep.

📖 Common parameters’ English origins

-r = recursive👉 Recursively search all files in the directory.
-i = ignore case👉 Ignore case.
-n = number👉 Display line numbers of matching lines.
-v = invert match👉 Invert match → Display lines that do “not match”.

grep "pattern" filename        # Search in file, e.g.: grep "Linux" /tmp/demo.txt  Of course, some files have no extension /tmp/demo directly is this
grep -r "pattern" directory    # Recursively search directory, e.g.: grep -r "Linux" /tmp/mydocs
grep -i "pattern" filename     # Ignore case
grep -n "pattern" filename     # Display line numbers
grep -v "pattern" filename     # Display non-matching lines "Display non-matching lines" = Exclude lines containing keywords, only show the remaining lines.

4. File Permissions and Attributes

4.1 chmod – Change File Permissions

1 chmod name origin

chmod = change mode
In Linux/Unix, file permissions are called mode, such as read r, write w, execute x.
chmod is the command to change file permission mode.

2 Usage of chmod

r = 4 (read), w = 2 (write), x = 1 (execute), 0 = — (no permission)

Numbers = r+w+x summed to get permissions, for example 7=rwx, 6=rw-, 5=r-x, 4=r– …

Three digits represent:u = user/owner (file owner), g = group (file group), o = others (other people)

chmod 755 filename     # Set permissions in numeric format
chmod +x filename      # Add execute permission
chmod -w filename      # Remove write permission
chmod u+x filename     # Add execute permission for user

Permission Explanation:

4=read(r), 2=write(w), 1=execute(x)
755 = rwxr-xr-x (user can read, write, execute; group and others can read, execute)

4.2 chown – Change File Owner

chown user filename           # Change owner
chown user:group filename     # Change owner and group
chown -R user:group dirname   # Recursively change directory

5. Process Management

`ps aux` and `ps -ef` and top differences

ps aux and ps -ef = Full list, lists all

top = Dynamic monitoring, prioritizes showing processes with high resource usage, remaining processes are also there but need to scroll to see.

5.1 ps – View Processes (Static)

ps defaults to showing processes in the current terminal (shell) → So you can only see 1~2, such as bash and the command you just entered ps itself.

Programs running in the current terminal can only be seen with ps in that terminal; in a new terminal, ps will not show those processes by default.

ps aux and ps will list all processes in the system → So there will be a lot.

ps → process status displays process status.

aux → BSD style options:

a = all (all user processes)
u = user (show user information)
x = include processes without a terminal

-ef → System V style options:

-e = every (all processes)
-f = full (complete format, parent-child relationships, etc.)

grep → global regular expression print, filters specific processes in the output.

ps                     # Display current user processes
ps aux | grep process  # Find specific process
ps aux | grep keyword, usually the program's filename

ps aux                 # Display detailed information of all processes

Typical BSD style output, common columns include:

USER   PID  %CPU  %MEM  VSZ  RSS  TTY  STAT  START  TIME  COMMAND

%CPU → CPU usage percentage
%MEM → Memory usage percentage
STAT → Process status (e.g., R=running, S=sleeping, I=idling)
START → Start time
TIME → Cumulative CPU time

👉 Focus on resource monitoring (CPU, memory, status).

ps -ef                 # Another way to display all processes

Typical System V style output, common columns include:

UID   PID   PPID   C   STIME   TTY   TIME   CMD

UID → User of the process
PID → Process ID
PPID → Parent Process ID (shows parent-child relationships)
C → CPU usage rate
STIME → Start time
TIME → Cumulative CPU time

👉 Focus on process relationships (parent-child structure, start time).

5.2 top – Real-time View of System Processes (Dynamic, Tabular Display)

top this name is commonly interpreted as:

Table Of Processes (process table)

top                    # Real-time display of process information
# In top: q to exit, k to kill process, M to sort by memory, P to sort by CPU

Can display all, needs scrolling to see

Scroll left/right (to see more information columns)

👉 Some fields (like the complete command CMD of the process) are too long, so you need this to see the full.

Press → (right arrow) → Move right to display more fields
Press ← (left arrow) → Move left

Scroll up/down (to see more processes)By default, top only displays one screen of processes (e.g., 40 lines), if there are many processes, you can:

Shift + PgDn (Page Down) → Next page
Shift + PgUp (Page Up) → Previous page

👉 This way you can see more than one screen of processes.

Expand display line count

In the top interface, press z to switch to color mode, more intuitive.
Use E / e to switch units (KB, MB, GB).
You can also specify when starting top:
```
top -n 1 -b | less
```
👉 Here, less can scroll up and down to browse all process output.

5.3 kill – Terminate Process

kill PID               # Gracefully terminate process, equivalent to kill -15 PID   # Graceful exit (recommended to use first)
kill -9 PID            # Forcefully terminate process
killall process_name   # Kill all related processes by name
kill -1 PID    # Let the process reload configuration
kill -STOP PID # Suspend process
kill -CONT PID # Let the process continue

Suspend Process Function (Stop/Suspend):

Main purpose:

Temporarily reduce server load:

When a program suddenly consumes full CPU, and you do not want to kill it directly.

Cross-terminal / Cross-user process management

You started a program (like a training script) in terminal A.
You or an operations personnel can directly kill -STOP PID to pause it without running to terminal A.

Debugging / Troubleshooting

If you want to analyze the state of a process, you can first STOP it → Stabilize at a certain moment without running.
After checking, you can then CONT to resume running.

Temporarily release terminal (using in the same terminal)

You are running a long task in the terminal (like python train.py or tail -f), suddenly want to execute another command.
👉 Press Ctrl+Z to suspend → The program pauses, and the terminal is released.

Prevent the process from continuing to run (a program started in one terminal, even if you use kill to stop or resume it in another terminal, this process still belongs to the terminal that originally started it; if you close that starting terminal, the process will also end.)

When a program occupies a lot of CPU, you do not want to kill it (for fear of losing data), but want to pause it first.
👉 kill -STOP PIDThis will directly send the specified PID process a SIGSTOP, regardless of which terminal it was started in, it can be suspended.

5.4 nohup – Run in Background

nohup = no hang up → Allows the process to “survive independently”, even if the terminal is closed, the program will continue to run.

nohup command &        # Run command in background, unaffected by terminal closure

Long-running tasks

For example: model training, data import, log analysis, etc., which may take hours or even days.
If run directly in the terminal, SSH disconnection / computer sleep will cause the task to be interrupted.

👉 Common usage:

nohup python3 train.py > train.log 2>&1 & tail -f train.log   # Real-time view of logs

> train.log → Redirects standard output (stdout) to train.log file.

2>&1 → Redirects standard error (stderr) also to standard output (i.e., also written into train.log).

1 = stdout, 2 = stderr
2>&1 = Merges the output of 2 into 1 (merges error output and normal output.)

& → Places the entire task in the background, allowing the terminal to immediately accept more commands.

Logs = Content output to the terminal (stdout + stderr), saved to a file.

The benefit is: even if the program runs for several days, if the terminal is closed, the content will not be lost, and can be traced back at any time.

nohup → One-time tasks (throw in to run, collect logs). The downside is: cannot “re-enter” the program’s interactive interface like tmux /screen can, only automatically ends and checks terminal output in logs.

tmux/screen → Long-term interactive tasks (disconnection and reconnection, multi-window collaboration).

Big company habits: Operations/backend prefer tmux/screen, algorithms/data science prefernohup`.

screen: An old tool (appeared in 1987), functional enough, suitable for simple scenarios.

tmux: A modern alternative (2007), strong split-screen + management capabilities, more commonly used in big companies.

6. System Information

6.1 df – View Disk Usage

df origin

Full name:disk free
Function : Displays disk usage of the file system (remaining space, total space, used space, etc.).
Literally means “disk free amount”.
df -h → Check if “disk space” is sufficient.
df -i → Check if “can create more files”.

Disk is like a big warehouse:

Not enough space → Warehouse has no place to store goods.
Not enough inodes → Warehouse still has space, but the shelves (numbering) are used up, cannot register new goods.

The value of inodes is: providing each file with an independent “ID card”, separating file metadata from content, facilitating efficient management and locating files by the file system.

df                     # Display disk usage
df -h                  # Human-readable display (GB, MB, etc.)
df -i                  # Display inode usage information, showing inode usage (i.e., related to file count, not disk capacity).

6.2 du – View Directory Size

du full name is disk usage.

disk = disk
usage = usage

du                     # Display current directory size
du -h                  # Human-readable display
du -s                  # Only display total

du -sh *               # Display size of each folder in the current directory

6.3 free – View Memory Usage

free in English means free, available.

free                   # Display memory usage
free -h                # Human-readable display
free -m                # Display in MB

6.4 Other System Information Commands

uname -a               # System information
whoami                 # Current username
who                    # Current logged-in users
date                   # Display date and time
uptime                 # System uptime and load

7. Network Related

7.1 ping – Test Network Connectivity

ping google.com        # Test network connectivity
ping -c 4 google.com   # Ping 4 times only

7.2 wget/curl – Download Files

wget http://example.com/file    # Download file
curl -O http://example.com/file # curl download file
curl -L url                     # Follow redirects

7.3 ssh – Remote Login

ssh user@hostname      # Remote login
ssh -p port user@host  # Specify port

7.4 scp – Remote Copy Files

scp file user@host:/path/       # Copy file to remote
scp user@host:/path/file ./     # Copy file from remote
scp -r dir user@host:/path/     # Copy directory

8. Compression and Decompression

8.1 tar – Pack and Compress

tar -czf archive.tar.gz dir/    # Create gzip compressed package
tar -xzf archive.tar.gz         # Unzip gzip compressed package
tar -tf archive.tar.gz          # View contents of compressed package
tar -czf backup.tar.gz --exclude='*.log' dir/  # Exclude specific files

8.2 zip/unzip

zip -r archive.zip dir/         # Create zip compressed package
unzip archive.zip               # Unzip zip file
unzip -l archive.zip            # View zip contents

9. Piping and Redirection

9.1 Piping

ls -l | grep ".txt"             # Filter .txt files
ps aux | grep python            # Find python processes
cat file | sort | uniq          # Sort and remove duplicates

9.2 Redirection

command > file                  # Output redirection to file (overwrite)
command >> file                 # Append output to file
command < file                  # Input from file
command 2> error.log            # Error output redirection
command &> all.log              # Redirect all output

10. Common Combination Techniques

10.1 Find Large Files

find . -type f -size +100M | head -10
du -ah . | sort -rh | head -20

10.2 View Port Usage

netstat -tulpn | grep :8080
lsof -i :8080

10.3 Batch Processing

for file in *.txt; do mv "$file" "${file%.txt}.bak"; done  # Batch rename
find . -name "*.log" -exec rm {} \;  # Batch delete log files

10.4 System Monitoring

watch -n 1 "ps aux | grep python"   # Refresh process information every second
iostat 1                            # Monitor IO status

11. Shortcuts

Ctrl + C – Terminate current command
Ctrl + Z – Suspend current command
Ctrl + L – Clear screen
Ctrl + A – Move cursor to the beginning of the line
Ctrl + E – Move cursor to the end of the line
Ctrl + R – Search command history
!! – Execute the last command
!grep – Execute the most recent grep command

Tips

Use man command to view detailed help documentation for commands
Use command --help to view basic usage of commands
Make good use of the Tab key for auto-completion of filenames and commands
Use history to view command history