What are the most important things to know about using Linux terminal commands safely and effectively?

Question

Accepted Answer

The big safety rule is this: the terminal usually does exactly what you typed, not what you meant. `rm` has no Trash, `>` overwrites files, `dd` can wipe disks silently, `sudo` turns small mistakes into system-wide damage, and `kill -9` stops a process without cleanup. Use preview steps first: `pwd`, `ls`, `ls -l`, `lsblk`, `find ... -print`, and interactive flags like `rm -i`, `cp -i`, and `mv -i`.

## 1. Treat deletion commands as loaded weapons

`rm` permanently removes files. It does not move them to a recycle bin.

```bash
rm file.txt
```

removes `file.txt`.

For directories:

```bash
rm -r old_dir
```

removes a directory recursively.

The dangerous version is:

```bash
rm -rf folder_name
```

That means recursive + force. No prompts. No undo. It removes the folder and everything inside it.

Never run:

```bash
rm -rf /
```

or:

```bash
sudo rm -rf /
```

That can delete the entire system.

Safer habits:

```bash
pwd
ls
rm -i file.txt
rm -ri old_folder/
```

Use `rm -i` when you want confirmation before each removal.

If you want Trash-like behavior instead of permanent deletion:

```bash
trash-put file.txt
```

## 2. Be careful with overwrites

The `>` operator overwrites the target file:

```bash
command > file
```

Example:

```bash
ls -l > file_list.txt
```

This replaces the previous contents of `file_list.txt`.

To append instead of overwrite:

```bash
command >> file
```

Example:

```bash
echo "again" >> file.txt
```

To redirect errors only:

```bash
command 2> errorfile
```

To redirect both normal output and errors:

```bash
cmd > file 2>&1
```

A brutal mistake is redirecting output to a disk device:

```bash
command >/dev/sda
```

That can overwrite the drive.

## 3. Use `sudo` only when needed

`sudo` runs a command with elevated privileges:

```bash
sudo command
```

That is useful for admin tasks, but dangerous if you do not understand the command. After `sudo su`, every command runs as root, which means even normally harmless mistakes can damage the system.

If you forgot `sudo`, use:

```bash
sudo !!
```

That reruns the previous command with superuser privileges. But remember: it repeats the last command exactly.

## 4. Preview destructive `find` commands before deleting

Before doing this:

```bash
find /path/to/search -name "temp*.txt" -delete
```

or this:

```bash
find /var/log -name "*.log" | xargs rm -f
```

preview first:

```bash
find /var/log -name "*.log" -mtime +30 -print
```

Only delete after the printed list is exactly what you expect.

When using `find` with `-exec rm -rf`, restrict the search to a specific directory and double-check the matches first.

## 5. Quote paths with spaces or special characters

This creates two directories:

```bash
mkdir another folder
```

It creates `another` and `folder`.

This creates one directory:

```bash
mkdir "another folder"
```

Use quotes around paths containing spaces or special characters:

```bash
mv "old file.txt" "new file.txt"
```

Single quotes preserve literal text. Double quotes still allow variable expansion.

## 6. Understand globs before using them with `rm` or `mv`

Globs like `*` and `?` expand to matching filenames.

```bash
rm *.log
```

removes every matching `.log` file in the current directory.

Before using a new glob destructively, test it:

```bash
ls *.log
```

Hidden dotfiles need care. To match hidden entries except `.` and `..`, use both:

```bash
.[!.]* ..?*
```

If you intend a wildcard character literally, escape it with a backslash.

## 7. Prefer graceful process termination before force-killing

The normal form:

```bash
kill 1234
```

sends SIGTERM, signal 15. It asks the process to shut down gracefully.

Equivalent:

```bash
kill -15 1234
```

Only if that fails, use:

```bash
kill -9 1234
```

`kill -9` sends SIGKILL. It cannot be caught or ignored, and the process gets no chance to clean up.

For process names:

```bash
pkill nginx
```

kills matching processes.

Forcefully:

```bash
pkill -9 unresponsive_app
```

But check matches first:

```bash
pgrep processname
```

For full command-line matching:

```bash
pkill -f 'python3 /opt/myapp/server.py'
```

Be careful: the wrong pattern can kill the wrong process.

## 8. Know that zombie processes cannot be killed directly

A zombie process is already dead. It remains only because its parent has not reaped its exit status.

Find zombies:

```bash
ps -eo pid,ppid,stat,comm | grep -w Z
```

You cannot fix one with `kill -9` against the zombie itself. Instead, nudge the parent:

```bash
kill -SIGCHLD <parent_pid>
```

If needed, fix or terminate the parent so PID 1 can reap the zombie.

## 9. Double-check disk devices before using `dd`, `mkfs`, or `wipefs`

`dd` does not ask for confirmation. If you reverse input and output, you can destroy data.

Example raw copy:

```bash
dd if=/dev/sda of=/dev/sdb bs=4M
```

Before running it:

```bash
lsblk
```

Confirm the exact source and target.

To monitor progress safely in a pipeline:

```bash
pv file.iso | dd of=/dev/sdb
```

Commands like these wipe data:

```bash
dd if=/dev/zero of=/dev/sda
mkfs.ext3 /dev/sda
wipefs -a /dev/sdx
```

Use the correct whole disk or partition path deliberately.

## 10. Use interactive overwrite protection with copy and move

By default, `cp` and `mv` can overwrite existing files.

Copy a file:

```bash
cp source dest
```

Copy with overwrite confirmation:

```bash
cp -i source dest
```

Never overwrite:

```bash
cp -n source dest
```

Copy a directory recursively:

```bash
cp -r source_directory destination_directory
```

Preserve permissions, ownership, and timestamps:

```bash
cp -p /source/file /destination/
```

Archive-style copy:

```bash
cp -a source destination
```

Move or rename:

```bash
mv old_name new_name
```

Prompt before overwrite:

```bash
mv -i source dest
```

Never overwrite:

```bash
mv -n old.txt new.txt
```

Force overwrite:

```bash
mv -f source target
```

Also: `mv` does not support `-R`.

## 11. Use the right permission tool

`chmod` changes permissions:

```bash
chmod u+x script.sh
```

or:

```bash
chmod 600 secret.key
```

`chown` changes owner:

```bash
sudo chown user:user file.txt
```

Recursively:

```bash
chown -R user:group dir
```

Be very careful with recursive permission changes. This is dangerous:

```bash
chmod -R 777 /
```

It grants read, write, and execute permissions to everyone across the system.

Also dangerous:

```bash
chown -R user:user /
```

Critical system files require specific ownership.

## 12. Make scripts executable correctly

Start a Bash script with:

```bash
#!/bin/bash
```

Make it executable:

```bash
chmod u+x myBashScript.sh
```

Run it as an executable:

```bash
./myBashScript.sh
```

Important nuance: the shebang is used when you run the script as an executable. If

The Most Useful Linux Terminal Commands and Their Key Details

À propos de cette capsule

Couvert dans cette capsule

IA générique vs cette capsule

1. Know where you are before running commands

2. Understand paths: absolute vs relative

1. Treat deletion commands as loaded weapons

Tags

Similaires dans Technologie

Ne confiez jamais votre réflexion à l'IA

La chaleur analogique est surtout une perception, pas une qualité sonore supérieure

Le boom de l'IA est-il une percée ou une bulle ?

La plupart des investissements en IA gaspillent énergie et argent sans bénéfices réels