1. Introduction to Linux and Shells
• Linux Overview: Linux is an open-source operating system known for its stability, security, and flexibility. It’s widely used in servers, desktops, and embedded systems.
• Shells: A shell is a command-line interface (CLI) that allows users to interact with the operating system. Common shells include Bash (Bourne Again Shell), Zsh, and Fish. Shells interpret user commands and execute them.
Example: Running a command in the Bash shell:
echo "Hello, Linux!"
Output:
Hello, Linux!
Explanation: This command uses the Bash shell to output the text "Hello, Linux!" to the terminal.
2. man Command
Purpose: The man (manual) command provides detailed documentation for Linux commands and programs.
Usage: To access a command’s manual, type man followed by the command name (e.g., man ls). Within the man pages, you can navigate using arrow keys, search using /, and exit with q.
Example: Viewing the manual page for the ls command:
man ls
Output:
LS(1) User Commands LS(1)
NAME
ls - list directory contents
SYNOPSIS
ls [OPTION]... [FILE]...
DESCRIPTION
List information about the FILEs (the current directory by default).
Explanation: This output shows the beginning of the manual page for ls. You can scroll through the content using the arrow keys and exit by pressing q.
3. ls Command
Purpose: The ls command lists the files and directories within the current directory.
Options:
• -l: Displays detailed information (permissions, owner, size, etc.).
• -a: Shows all files, including hidden ones (those starting with .).
• -h: Makes the file sizes human-readable (e.g., KB, MB).
Example: Listing files in the current directory:
ls
Output:
Documents Downloads Music Pictures Videos
Example: Listing all files, including hidden ones, with detailed information:
ls -la
Output:
drwxr-xr-x 5 user user 4096 Aug 16 10:00 .
drwxr-xr-x 3 user user 4096 Aug 16 09:00 ..
-rw-r--r-- 1 user user 220 Aug 15 20:00 .bash_logout
-rw-r--r-- 1 user user 3771 Aug 15 20:00 .bashrc
drwxr-xr-x 2 user user 4096 Aug 16 09:30 Documents
Explanation: The first command lists files in the current directory. The second command lists all files (including hidden ones) with details like permissions, owner, and modification date.
4. cd Command
Purpose: The cd (change directory) command allows you to navigate between directories.
Usage:
• cd /path/to/directory: Moves to the specified directory.
• cd ..: Moves up one directory level.
• cd ~: Moves to the user’s home directory.
Example: Navigating to the Documents directory:
cd Documents
Output:
(No output, but the prompt changes to show the current directory)
Example: Moving up one directory level:
cd ..
Output:
(No output, but the prompt changes to show the parent directory)
Explanation: The cd Documents command changes the current directory to Documents. The cd .. command moves you up one directory level.
5. pwd Command
Purpose: The pwd (print working directory) command displays the full path of the current directory.
Usage: Simply type pwd to see the directory you are currently in. It helps confirm your location in the filesystem.
Example: Displaying the current directory:
pwd
Output:
/home/user/Documents
Explanation: This command shows the full path of the current working directory, which in this case is /home/user/Documents.
6. mkdir Command
Purpose: The mkdir (make directory) command creates new directories.
Usage:
• mkdir directory_name: Creates a single directory.
• mkdir -p /path/to/directory: Creates nested directories, creating any parent directories as needed.
Example: Creating a new directory named new_folder:
mkdir new_folder
Output:
(No output, but a new directory is created)
Example: Creating a nested directory structure:
mkdir -p projects/java/app
Output:
(No output, but the directories `projects/java/app` are created)
Explanation: The first command creates a single directory named new_folder. The second command creates a nested directory structure, with projects, java, and app.
7. rmdir Command
Purpose: The rmdir (remove directory) command removes empty directories.
Usage:
• rmdir directory_name: Removes the specified empty directory.
• For directories with content, use rm -r to remove them recursively.
Example: Removing an empty directory named old_folder:
rmdir old_folder
Output:
(No output, but the directory is removed)
Explanation: The rmdir command removes an empty directory. If the directory contains files, it will not be removed.
8. mv Command
Purpose: The mv (move) command is used to move or rename files and directories.
Usage:
• mv source destination: Moves a file or directory to a new location.
• mv old_name new_name: Renames a file or directory.
Example: Renaming a file from old_name.txt to new_name.txt:
mv old_name.txt new_name.txt
Output:
(No output, but the file is renamed)
Example: Moving a file document.txt to the Documents directory:
mv document.txt Documents/
Output:
(No output, but the file is moved to the `Documents` directory)
Explanation: The mv command is used to move files or directories and to rename them. The first example renames a file, while the second example moves the file to a different directory.
9. cp Command
Purpose: The cp (copy) command copies files or directories.
Usage:
• cp source destination: Copies a file to a new location.
• cp -r source destination: Recursively copies directories and their contents.
Example: Copying a file file.txt to backup.txt:
cp file.txt backup.txt
Output:
(No output, but the file is copied)
Example: Copying a directory my_folder and its contents to backup_folder:
cp -r my_folder backup_folder
Output:
(No output, but the directory and its contents are copied)
Explanation: The cp command copies files or directories. The r option is used to copy directories recursively.
10. open Command
Purpose: The open command opens files and applications in the default application associated with the file type.
Usage:
• open file_name: Opens the specified file.
• On Linux systems, xdg-open is commonly used as an equivalent, especially in graphical environments.
Example: Opening a file example.txt using the default application:
open example.txt
Output:
(No output, but the file is opened in the default text editor)
Example: Opening a directory Documents in Finder (Mac) or File Explorer (Linux with a GUI):
open Documents/
Output:
(No output, but the directory is opened in the file manager)
Explanation: The open command is primarily used on macOS to open files or directories with their default applications. On Linux, a similar command would be xdg-open.
11. touch Command
Purpose: Creates an empty file or updates the timestamp of an existing file.
Example:
touch newfile.txt
Use Case: Quickly create a new file or update the modification time of a file without editing its content.
12. find Command
Purpose: Searches for files and directories within a specified directory and its subdirectories.
Example:
find . -name "file.txt"
Use Case: Locate files based on their name, type, size, or other attributes across the file system.
13. ln Command
Purpose: Creates links between files, either as hard links or symbolic (soft) links.
Example:
ln -s file.txt link_to_file.txt
Use Case: Link files for easy access or to avoid duplicating content, using symbolic links for flexible file referencing.
14. gzip Command
Purpose: Compresses files to reduce their size using the GNU zip algorithm.
Example:
gzip example.txt
Use Case: Compress files to save disk space or to prepare files for transfer over the network.
15. gunzip Command
Purpose: Decompresses files that were compressed using the gzip command.
Example:
gunzip example.txt.gz
Use Case: Restore compressed files to their original size and format for use or further processing.
16. tar Command
Purpose: Archives multiple files into a single file, often combined with compression.
Example:
tar -czvf archive.tar.gz folder/
Use Case: Create a compressed archive of a directory or group of files for easier storage or transfer.
17. alias Command
Purpose: Creates shortcuts for long or complex commands.
Example:
alias ll="ls -la"
Use Case: Simplify frequently used commands by creating an alias for quick access.
18. cat Command
Purpose: Concatenates and displays the content of files.
Example:
cat file.txt
Use Case: View the contents of a file or combine multiple files into one.
19. less Command
Purpose: Allows you to view the content of a file one screen at a time.
Example:
less file.txt
Use Case: Navigate through large text files without opening them entirely in memory, making it efficient for viewing logs or large documents.
20. tail Command
Purpose: Displays the last few lines of a file, with the option to monitor the file for new content.
Example:
tail -f logfile.txt
Use Case: Monitor real-time updates to a log file, useful for debugging or observing system behavior.
21. wc Command
Purpose: Counts lines, words, and characters in a file.
Example:
wc file.txt
Use Case: Quickly get statistical information about the content of a file, such as the number of lines, words, and characters.
22. grep Command
Purpose: Searches for patterns in files and outputs matching lines.
Example:
grep "search_term" file.txt
Use Case: Find specific lines within files that match a given pattern, useful for searching through text files or logs.
23. sort Command
Purpose: Sorts lines of text files in various orders.
Example:
sort file.txt
Use Case: Organize lines of text alphabetically or numerically, useful for data processing and organization.
24. uniq Command
Purpose: Removes duplicate lines from a sorted file.
Example:
sort file.txt | uniq
Use Case: Filter out duplicate lines from a sorted file, often used in conjunction with sort to process and clean data.
25. diff Command
Purpose: Compares files line by line and shows differences between them.
Example:
diff file1.txt file2.txt
Use Case: Identify differences between two files, useful for comparing versions of documents or source code changes.
26. echo Command
Purpose: Displays a line of text or variables to the standard output.
Example:
echo "Hello, World!"
Output:
Hello, World!
Use Case: Print messages or values of variables to the terminal, often used in scripts for feedback or debugging.
27. chown Command
Purpose: Changes the owner and/or group of a file or directory.
Example:
chown user:group file.txt
Use Case: Modify file ownership to ensure proper access permissions and control over files and directories.
28. chmod Command
Purpose: Changes the permissions of a file or directory.
Example:
chmod 755 file.txt
Use Case: Set read, write, and execute permissions for files and directories, controlling user access.
29. umask Command
Purpose: Sets default file creation permissions for the user.
Example:
umask 022
Use Case: Configure default permissions for newly created files and directories, typically set in shell initialization files.
30. du Command
Purpose: Estimates and displays disk usage of files and directories.
Example:
du -sh directory/
Output:
1.5G directory/
Use Case: Check the disk space usage of directories and files, helpful for managing storage and finding large files.
31. df Command
Purpose: Displays information about disk space usage for file systems.
Example:
df -h
Output:
Filesystem Size Used Avail Use% Mounted on
/dev/sda1 50G 20G 28G 42% /
/dev/sdb1 100G 50G 45G 55% /data
Use Case: Check the available and used disk space on mounted file systems, useful for monitoring and managing disk usage.
32. basename Command
Purpose: Strips directory and suffix from filenames, returning just the base name.
Example:
basename /path/to/file.txt
Output:
file.txt
Use Case: Extract the filename from a full path or remove a file extension, useful for script processing and filename manipulation.
33. dirname Command
Purpose: Strips the last component from the file path, returning the directory path.
Example:
dirname /path/to/file.txt
Output:
/path/to
Use Case: Extract the directory path from a full file path, useful for file manipulation and script automation.
34. ps Command
Purpose: Displays information about active processes.
Example:
ps aux
Output:
USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND
user 1234 0.0 0.1 12345 6789 ? Ss 10:00 0:00 bash
user 5678 1.2 0.5 23456 12345 ? R 10:01 0:01 top
Use Case: View details of running processes, including their resource usage and status, useful for system monitoring and management.
35. top Command
Purpose: Provides a real-time, dynamic view of system processes and their resource usage.
Example:
top
Output:
top - 10:05:01 up 10 days, 2:17, 2 users, load average: 0.20, 0.15, 0.10
Tasks: 57 total, 2 running, 55 sleeping, 0 stopped, 0 zombie
%Cpu(s): 1.5 us, 0.5 sy, 0.0 ni, 97.5 id, 0.0 wa, 0.0 hi, 0.5 si, 0.0 st
KiB Mem : 2048000 total, 1234567 free, 345678 used, 456789 buff/cache
KiB Swap: 1024000 total, 987654 free, 123456 used. 789012 avail Mem
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
1234 user 20 0 123456 67890 12345 S 1.0 0.5 0:01.23 bash
5678 user 20 0 234567 123456 23456 R 2.5 1.0 0:05.67 top
Use Case: Monitor real-time system performance, including CPU and memory usage, process states, and overall system load, useful for system diagnostics and performance tuning.
36. kill Command
Purpose: Sends a signal to terminate or modify the behavior of a process.
Example:
kill 1234
Output:
(No output if the signal is sent successfully; the process with PID 1234 is terminated)
Use Case: Terminate a process by its process ID (PID), useful for stopping unresponsive or unwanted processes.
37. killall Command
Purpose: Sends a signal to terminate all processes matching a specified name.
Example:
killall firefox
Output:
(No output if the signal is sent successfully; all instances of Firefox are terminated)
Use Case: Terminate all processes with a specific name, useful for stopping multiple instances of a program.
38. jobs Command
Purpose: Lists all jobs running in the background or stopped jobs in the current shell session.
Example:
jobs
Output:
[1]+ 1234 Running ./script.sh &
[2]- 5678 Stopped vim
Use Case: View the status of background or stopped jobs, useful for managing multiple tasks within a shell session.
39. bg Command
Purpose: Resumes a suspended job in the background.
Example:
bg %1
Output:
[1]+ ./script.sh &
Use Case: Continue running a previously suspended job in the background, freeing up the terminal for other tasks.
40. fg Command
Purpose: Brings a background job to the foreground.
Example:
fg %1
Output:
./script.sh
Use Case: Bring a background job to the foreground to interact with it directly, useful for resuming work on tasks that were previously running in the background.
40. fg Command
Purpose: Brings a background job to the foreground.
Example:
fg %1
Output:
./script.sh
Use Case: Resume a background job and interact with it directly in the current terminal session.
41. type Command
Purpose: Displays the type of command (e.g., whether it is a shell built-in, function, or external command).
Example:
type ls
Output:
ls is /bin/ls
Use Case: Determine the nature and location of a command or function, useful for debugging and understanding command types.
42. which Command
Purpose: Shows the path of the executable file associated with a command.
Example:
which python3
Output:
/usr/bin/python3
Use Case: Locate the path of a command or executable, useful for verifying the command's installation and location.
43. nohup Command
Purpose: Runs a command immune to hangups, with output redirected to a file.
Example:
nohup ./long-running-script.sh &
Output:
nohup: appending output to 'nohup.out'
Use Case: Execute commands that should continue running after logging out or closing the terminal, often used for long-running processes.
44. xargs Command
Purpose: Builds and executes command lines from standard input.
Example:
echo "file1.txt file2.txt" | xargs cat
Output:
(Content of file1.txt followed by content of file2.txt)
Use Case: Pass arguments from standard input to commands, useful for processing lists of files or data.
45. vim Editor Command
Purpose: Opens the Vim text editor for editing files.
Example:
vim file.txt
Output:
(Vim editor opens with file.txt for editing)
Use Case: Edit files with a powerful and configurable text editor, ideal for coding and text manipulation.
46. emacs Editor Command
Purpose: Opens the Emacs text editor for editing files.
Example:
emacs file.txt
Output:
(Emacs editor opens with file.txt for editing)
Use Case: Edit files using a highly extensible and customizable text editor, known for its advanced features and programmability.
47. nano Editor Command
Purpose: Opens the Nano text editor for editing files.
Example:
nano file.txt
Output:
(Nano editor opens with file.txt for editing)
Use Case: Edit files with a simple and user-friendly text editor, suitable for beginners and quick edits.
48. whoami Command
Purpose: Displays the username of the current user.
Example:
whoami
Output:
username
Use Case: Identify the current logged-in user, useful for confirming user context in scripts or terminal sessions.
49. who Command
Purpose: Shows who is currently logged into the system.
Example:
who
Output:
username tty7 2024-08-16 09:00 (:0)
username pts/0 2024-08-16 09:15 (:0)
Use Case: List all users currently logged into the system along with their terminal sessions and login times.
50. su Command
Purpose: Switches the current user to another user account, typically used to become the root user.
Example:
su - username
Output:
(Switches to the specified user's shell)
Use Case: Change to another user account or become the root user, useful for administrative tasks and user management.
50. su Command
Purpose: Switches the current user to another user account, typically used to become the root user.
Example:
su - username
Output:
(Switches to the specified user's shell)
Use Case: Change to another user account or become the root user, useful for administrative tasks and user management.
51. sudo Command
Purpose: Executes a command as another user, typically as the root user, with elevated privileges.
Example:
sudo apt update
Output:
(Command executed with root privileges; prompts for user password)
Use Case: Perform administrative tasks or run commands with elevated privileges, useful for system maintenance and configuration.
52. passwd Command
Purpose: Changes the user’s password.
Example:
passwd
Output:
Changing password for username
New password:
Retype new password:
Use Case: Update the user password, necessary for account security and management.
53. ping Command
Purpose: Sends ICMP echo requests to a network host to check connectivity and measure round-trip time.
Example:
ping google.com
Output:
PING google.com (142.250.67.206) 56(84) bytes of data.
64 bytes from 142.250.67.206: icmp_seq=1 ttl=117 time=12.3 ms
64 bytes from 142.250.67.206: icmp_seq=2 ttl=117 time=11.9 ms
Use Case: Test network connectivity and diagnose network issues by measuring response times to network hosts.
54. traceroute Command
Purpose: Traces the route packets take to a network host and displays the path with intermediate hops.
Example:
traceroute google.com
Output:
traceroute to google.com (142.250.67.206), 30 hops max, 60 byte packets
1 192.168.1.1 (192.168.1.1) 1.234 ms 0.987 ms 0.764 ms
2 10.0.0.1 (10.0.0.1) 2.345 ms 2.123 ms 2.012 ms
3 142.250.67.206 (142.250.67.206) 12.345 ms 11.987 ms 12.345 ms
Use Case: Diagnose network paths and identify routing issues by displaying the route and delays to a destination.
55. clear Command
Purpose: Clears the terminal screen of all previous output.
Example:
clear
Output:
(Clears the terminal screen)
Use Case: Refresh the terminal display by removing previous content, useful for improving readability during terminal sessions.
56. history Command
Purpose: Displays a list of previously executed commands in the current shell session.
Example:
history
Output:
1 ls -l
2 cd /home/user
3 mkdir new_directory
4 rm old_file.txt
Use Case: Review or reuse previously run commands, useful for quickly accessing or repeating recent commands.
57. export Command
Purpose: Sets environment variables or exports them to child processes.
Example:
export PATH=$PATH:/usr/local/bin
Output:
(No output; the environment variable is updated)
Use Case: Modify environment variables or make new variables available to all processes started from the current shell.
58. crontab Command
Purpose: Manages cron jobs, which are scheduled tasks to be run at specified intervals.
Example:
crontab -e
Output:
(Opens the cron table in an editor to add or edit scheduled tasks)
Use Case: Schedule and manage recurring tasks or scripts, useful for automating system maintenance and backups.
59. uname Command
Purpose: Displays system information, including kernel name, version, and other details.
Example:
uname -a
Output:
Linux hostname 5.8.0-44-generic #1 SMP Wed Oct 7 14:00:00 UTC 2020 x86_64 x86_64 x86_64 GNU/Linux
Use Case: Obtain detailed information about the system's kernel and architecture, useful for system diagnostics and compatibility checks.
60. env Command
Purpose: Displays or sets environment variables in the current session.
Example:
env
Output:
HOME=/home/user
PATH=/usr/local/bin:/usr/bin:/bin
SHELL=/bin/bash
Use Case: View current environment variables or modify them temporarily for the session, useful for troubleshooting and configuration.
61. printenv Command
Purpose: Prints all or specified environment variables.
Example:
printenv PATH
Output:
/usr/local/bin:/usr/bin:/bin
Use Case: Display the value of environment variables, useful for verifying and debugging environment settings.