Familiarization of basic Linux Commands- ls, mkdir, rmdir , rm, cat, cp, mv , chmod

ls - list files

The ls command in Linux is one of the most frequently used commands. It is used to list the contents of a directory. It shows files, directories, and symbolic links. Here’s a detailed explanation of the command, including its syntax, common options, and examples.

Syntax

ls [OPTION]... [FILE]...

OPTION: Flags to modify the behavior of the command.

FILE: The directory or file(s) whose contents you want to list. If omitted, ls lists the contents of the current directory.

Default Behavior

Without any options, ls lists the contents of the current directory in a simple format.
It does not show hidden files (files starting with a dot .) by default.

Common Options

Option	Description
`-l`	Displays contents in a detailed (long) format, including file permissions, size, and more.
`-a`	Lists all files, including hidden files (starting with `.`).
`-h`	Shows file sizes in a human-readable format (e.g., `1K`, `5M`, `3G`).
`-R`	Lists contents of directories recursively.
`-t`	Sorts files by modification time (newest first).
`-r`	Reverses the order of the listing.
`-S`	Sorts files by size (largest first).
`--color`	Adds colors to distinguish file types (e.g., directories in blue, files in white).
`-d`	Lists directories themselves, not their contents.
`-i`	Displays the inode number of each file.
`--help`	Displays a help message with usage information.

Understanding the -l Option Output

When you use the ls -l command, it provides detailed information about each file/directory. For example:

ls -l

Sample Output:

-rw-r--r-- 1 user group 1234 Nov 30 14:00 file.txt

drwxr-xr-x 2 user group 4096 Nov 30 14:00 mydir

Explanation:

File Permissions (-rw-r--r--):
- The first character: File type (- for files, d for directories, l for symbolic links).
- Next nine characters: Permissions for the owner, group, and others (r for read, w for write, x for execute).
Number of Links (1): Number of hard links to the file or directory.
Owner (user): The username of the file's owner.
Group (group): The group that owns the file.
Size (1234): File size in bytes.
Last Modified (Nov 30 14:00): Date and time of the last modification.
Name (file.txt): Name of the file or directory.

Examples

1. List Files in Current Directory

2. List All Files, Including Hidden Files

ls-a

3. Detailed(long) Listing

ls -l

4.Human-Readable File Sizes

ls -lh

5.Sort by File Size

ls -lS

6.Recursive Listing

ls-R

7.Combine Multiple Options

ls -lah

This will list all files (including hidden ones) in a detailed format with human-readable sizes.

Tips

Use ls --color or configure your terminal to enable colored output for better visualization.
Combine options for more tailored outputs, like ls -ltr to list files sorted by time in reverse order.
To explore all available options, use: man ls

Summary

The ls command is an essential tool for navigating and managing files in Linux. With its wide range of options, it offers flexibility and customization for displaying directory contents. It is highly recommended to practice using different combinations of options to get familiar with its usage.

mkdir - make directory

The mkdir command in Linux is used to create directories. It is one of the fundamental commands for managing the file system. Here's a detailed explanation of the mkdir command, including its syntax, options, and examples.

Syntax

mkdir [OPTION]... DIRECTORY...

OPTION: Flags to modify the behavior of the command.

DIRECTORY: Name(s) of the directory (or directories) to be created. Multiple directories can be specified at once.

Basic Functionality

Without any options, mkdir creates a new directory with the specified name in the current working directory.

The command will fail if:

The directory already exists (without the -p option).
The user lacks the necessary permissions to create directories in the specified location.

Common Options

Option	Description
`-p`	Creates parent directories as needed. Prevents errors if the directory already exists.
`-v`	Displays a message for each directory created (verbose mode).
`-m`	Sets permissions for the new directory in octal mode (e.g., `mkdir -m 755`).
`--help`	Displays help information about the command.

Details of Common Options

1. -p (Create Parent Directories)

If you try to create a nested directory (e.g., parent/child) without -p, it will fail if parent does not exist.
Using -p, mkdir will create all necessary parent directories.

mkdir -p parent/child

2. `-v` (Verbose Mode)

Prints a confirmation message for every directory created.

mkdir -v mydir

# Output: mkdir: created directory 'mydir'

3. `-m` (Set Permissions)

Specifies permissions for the new directory at creation time.
Permissions are provided in octal format (e.g., 755 for read/write/execute for the owner, and read/execute for group and others).

mkdir -m 700 mec

Examples

1. Create a Single Directory

mkdir mydir

2. Create Multiple Directories

mkdir dir1 dir2 dir3

3. Create Nested Directories

mkdir -p projects/python/scripts

4. Set Specific Permissions

mkdir -m 755 shared_folder

5. Verbose Output

mkdir -v newdir

6. Handle Existing Directories Gracefully

mkdir -p existing_dir

If existing_dir already exists, no error is thrown.

7.Use sudo to create directories in restricted locations:

sudo mkdir /restricted_dir

8.Combine Options:

Use mkdir -pv to create nested directories with confirmation messages.

mkdir -pv projects/java/src

9.Check Directory Creation:

Use ls to verify the new directory:

ls -ld newdir

10.Set Default Permissions:

If the -m option is not used, the directory permissions are determined by the user’s umask.

Summary

The mkdir command is a simple yet powerful tool for directory management. By using options like -p for nested directories or -m for permissions, it provides flexibility to suit various needs. Practicing with this command helps you manage directories efficiently in the Linux file system.

rmdir - Removing Directories

rmdir: A standard Linux command used to remove empty directories.

The rmdir command is used to remove empty directories. If a directory contains files or sub directories, rmdir will fail.

Syntax

rmdir [OPTION]... DIRECTORY...

DIRECTORY: Name of the empty directory to remove.

OPTION: Optional flags to modify the behavior of the command.

-p:Removes the specified directory and any parent directories if they are empty.

`rm -r` Command

If you need to remove non-empty directories or directories containing files, you use the rm command with the -r (recursive) option.

-r: Recursively removes directories and their contents.
-f: Forces deletion without prompting for confirmation.

Examples

1.Remove an Empty Directory

rmdir emptydir

2.Remove Multiple Directories

rmdir dir1 dir2

3.Remove Parent Directories

rmdir -p parent/child

4.Remove a Non-Empty Directory

rm -r dir

5.Force Deletion Without Confirmation

rm -rf dir

6.Remove Multiple Directories

rm -r dir1 dir2

Safety Tips for Recursive Deletion

Be Cautious: Using rm -rf can irreversibly delete important files.
Double-Check Path: Always verify the directory path before running the command.
Dry Run: Use ls or tree to preview the contents before deletion

tree dir

Summary

Use rmdir for safely removing empty directories.
Use rm -r for removing directories and their contents.
Always exercise caution with recursive deletion commands like rm -rf.

rm - remove files and directories

Syntax
rm [OPTION]... FILE...

OPTION: Flags that modify the behavior of the rm command.

FILE: Name(s) of the file(s) or directory(s) to be removed.

Basic Functionality

The rm command removes the specified files or directories.
By default, rm does not remove directories; you need to use specific options to remove directories or their contents.
Deleted files and directories cannot be recovered directly through the command.

Common Options

Option	Description
`-f`	Force deletion without prompting or showing error messages for non-existent files.
`-i`	Prompts for confirmation before each file or directory is removed.
`-I`	Prompts once before removing more than three files or recursively deleting.
`-r` or `-R`	Removes directories and their contents recursively.
`-d`	Removes empty directories.
`--preserve-root`	Prevents recursive deletion of the root directory `/` (default behavior).
`--help`	Displays help information about the command.

Examples

1. Remove a Single File

rm file.txt

2. Remove Multiple Files
rm file1.txt file2.txt

3.Remove Empty Directories

rm -d emptydir

4. Remove a Directory and Its Contents

rm -r dir

5.Force Deletion Without Confirmation

rm -f file.txt

6.Combine Recursive and Force Options

rm -rf dir

7. Interactive Deletion

rm -i file1.txt

8.Prompt for Large or Recursive Deletions

rm -I *

Summary

The rm command is a versatile tool for file and directory management. With options like -r for recursive deletion, -f for forced deletion, and -i for interactive mode, it offers flexibility for various scenarios. However, its power comes with responsibility — always double-check paths and options before executing potentially destructive commands.

cat command

The cat command in Linux is a fundamental tool used to concatenate and display file contents. It is frequently utilized to read, create, and combine files, making it a versatile and essential command in Linux and Unix-like systems.

Syntax

cat [OPTION]... [FILE]...

OPTION: Flags that modify the behavior of the cat command.

FILE: Name(s) of the file(s) to be read or processed.

Common Use Cases

Displaying the contents of a file.
Creating a new file.
Appending content to a file.
Combining multiple files into one.

Common Options

Option	Description
`-n`	Numbers all lines in the output.
`-b`	Numbers only non-empty lines in the output.
`-s`	Suppresses repeated empty lines in the output.
`-T`	Displays tab characters as `^I`.
`-v`	Shows non-printable characters (except for tabs and line endings).
`-A`	Combines `-vET` to show all non-printable characters, end-of-lines, and tabs.
`-e`	Equivalent to `-vE`; shows non-printable characters and end-of-line markers.
`-E`	Displays `$` at the end of each line.

Examples

1. Display the Contents of a File

cat file.txt

2.Display Multiple Files

cat file1.txt file2.txt

3.Number All Lines

cat -n file.txt

4. Number Only Non-Empty Lines

cat -b file.txt

5.Show End-of-Line Markers

cat -E file.txt

6.Create a File

You can use cat to create a file and input text directly from the terminal.Type the content, and press CTRL+D to save and exit:

cat > newfile.txt

7.Append to a File

cat >> existingfile.txt

8.Concatenate Files

cat file1.txt file2.txt > combined.txt

9.Show Non-Printable Characters

cat -v file.txt

10.Concatenate and View with Line Numbers

cat -n file1.txt file2.txt

11.Combine and Redirect Output

cat file1.txt file2.txt > mergedfile.txt

Tips and Best Practices

Avoid Overwriting by Mistake
- Be cautious when using > as it overwrites the target file.
- Use >> to append instead of overwriting.
Verify Commands
- Double-check file paths and options to prevent data loss, especially when overwriting or appending.
Combine with Other Commands

Pipe the output of cat to other utilities like grep, less, or wc

cat file.txt | grep "pattern"

Summary

The cat command is an indispensable utility in Linux for managing and viewing files. Its simplicity and flexibility make it a favorite for both basic and advanced text operations. With options like -n, -b, and -s, it provides detailed control over file output and manipulation. Always use it carefully, especially when overwriting or appending data.

cp - copy command

The cp command in Linux is used to copy files and directories from one location to another. It is one of the fundamental file management commands and supports a variety of options to handle permissions, symbolic links, and directory structures effectively.

Syntax

cp [OPTION]... SOURCE... DESTINATION

OPTION: Flags that modify the behavior of the cp command.

SOURCE: The file(s) or directory(s) to copy.

DESTINATION: The target location where the file(s) or directory(s) should be copied.

Common Use Cases

Copying a single file to a new location.
Copying multiple files to a directory.
Copying directories, including their contents, recursively.

Common Options

Option	Description
`-a`	Archive mode: Preserves file attributes (e.g., ownership, permissions, timestamps). Equivalent to `-dR --preserve=all`.
`-f`	Force overwriting existing files without prompting.
`-i`	Interactive mode: Prompts before overwriting files.
`-n`	No clobber: Prevents overwriting existing files.
`-r` or `-R`	Recursive: Copies directories and their contents recursively.
`-v`	Verbose: Displays detailed information about the copying process.
`-u`	Updates files only if the source file is newer than the destination file or if the destination file does not exist.
`--preserve`	Specifies which attributes to preserve (e.g., mode, ownership, timestamps).
`--no-preserve`	Specifies attributes not to preserve.
`--backup`	Creates a backup of files that are about to be overwritten.
`--help`	Displays help information about the command.

Examples

1. Copy a Single File

cp file1.txt /home/user/documents/

2. Copy and Rename a File

cp file1.txt file2.txt

3.Copy Multiple Files

cp file1.txt file2.txt /home/user/documents/

4. Copy Directories Recursively

cp -r /home/user/source_dir /home/user/backup_dir

5. Copy with Overwrite Confirmation

cp -i file1.txt /home/user/documents/

6. Preserve File Attributes

cp -a file1.txt /home/user/documents/

7. Verbose Mode

cp -v file1.txt file2.txt /home/user/documents/

Displays the files being copied:

8. Copy Files Only if Updated

cp -u file1.txt /home/user/documents/

9. Backup Before Overwriting

cp --backup file1.txt /home/user/documents/

Tips and Best Practices

Use -i for Safe Copying
- Always use -i when working with critical files to avoid accidental overwrites.
Preserve Attributes with -a
- When creating backups or migrating files, use -a to maintain file metadata.
Verify Files with ls
- After copying, list the contents of the destination directory to confirm the operation:
Use -u to Save Time

When copying large directories, -u ensures only updated files are copied, saving time and resources.

Summary

The cp command is a versatile and powerful tool for copying files and directories in Linux. With options like -r for recursive copying, -a for preserving attributes, and -i for interactive mode, it provides flexibility and control over the copying process. Always double-check source and destination paths to prevent accidental overwrites or data loss.

mv - move command

he mv command in Linux is used to move or rename files and directories. It is a versatile command for organizing and renaming files and directories in the filesystem.

Syntax

mv [OPTIONS] SOURCE DESTINATION

SOURCE: The file(s) or directory(s) you want to move or rename.

DESTINATION: The target location or new name for the file or directory.

Common Options

Option	Description
`-i`	Interactive: Prompts for confirmation before overwriting existing files.
`-f`	Force: Moves files without prompting, even if overwriting.
`-n`	No-clobber: Prevents overwriting existing files.
`-u`	Updates: Only moves files if the source is newer than the destination or missing.
`-v`	Verbose: Displays the details of the move process.

Usage

1. Move a File

mv file1.txt /home/user/documents/

2. Rename a File

mv file1.txt renamed_file.txt

3.Move Multiple Files

mv file1.txt file2.txt /home/user/documents/

4.Move a Directory

mv /source_directory /destination_directory/

5.Interactive Mode

mv -i file1.txt /home/user/documents/

6. No Overwrite

mv -n file1.txt /home/user/documents/

7. Verbose Mode

mv -v file1.txt /home/user/documents/

8.Conditional Move (Update Mode)

mv -u file1.txt /home/user/documents/

Differences Between `mv` and `cp`

Aspect	mv	cp
Operation	Moves the file (removes it from the source).	Copies the file (source remains intact).
Permissions	Requires write permissions at both locations.	Requires read permissions at source and write at destination.

Summary

The mv command is a straightforward yet powerful utility for file and directory management. Its ability to rename and move files or directories, coupled with options for interactive mode, verbose output, and safe handling, makes it essential for organizing and maintaining a Linux filesystem. Always use caution when moving files, especially across different directories, to avoid unintended data loss.

chmod- change mode

The chmod command in Linux is used to change the permissions of files or directories. Permissions control who can read, write, or execute a file or directory.

Syntax

chmod [OPTIONS] MODE FILE/DIRECTORY

MODE: Specifies the new permissions, either symbolically (letters) or numerically (octal).
FILE/DIRECTORY: The target file or directory to which permissions are applied.

File Permissions in Linux

Each file or directory has three types of permissions for three categories of users:

Permission Types

Permission	Symbol	Description
Read	`r`	Allows reading the file or listing the directory.
Write	`w`	Allows modifying the file or creating/deleting files in a directory.
Execute	`x`	Allows executing a file or accessing a directory.

User Categories

User	Symbol	Description
Owner	`u`	The file's creator or owner.
Group	`g`	Users in the file's group.
Others	`o`	All other users.
All	`a`	Represents `u`, `g`, and `o` combined.

Displaying Current Permissions

You can view permissions using the ls -l command:

ls -l file.txt

output:

-rw-r--r-- 1 user group 1234 date file.txt

Here:

-rw-r--r-- represents the permissions:
- r: Read
- w: Write
- x: Execute
The breakdown is:
- Owner: rw- (read, write)
- Group: r-- (read)
- Others: r-- (read)

Setting Permissions

1. Using Symbolic Mode

Symbolic mode modifies permissions by adding (+), removing (-), or setting explicitly (=) for specific categories.

Example 1: Grant Execute Permission to Owner

chmod u+x file.txt

Example 2: Remove Write Permission for Group

chmod g-w file.txt

Example 3: Set Read-Only Permission for All

chmod a=r file.txt

2. Using Numeric (Octal) Mode

Numeric mode uses a three-digit octal number to set permissions. Each digit represents the permissions for owner, group, and others:

Permission	Octal Value
`---`	0
`--x`	1
`-w-`	2
`-wx`	3
`r--`	4
`r-x`	5
`rw-`	6
`rwx`	7

Example 1: Set rwx for Owner, r-- for Group, and --- for Others

chmod 740 file.txt

Example 2: Make a File Executable by Everyone

chmod 777 script.sh

Options

Option	Description
`-R`	Recursive: Changes permissions for files and subdirectories.
`--verbose`	Displays a message for each file processed.
`--help`	Displays help for the command.

Examples

1. Change Permissions for Multiple Files

chmod 644 file1.txt file2.txt

2. Apply Permissions Recursively

chmod -R 755 /var/www/

3. Combine Permissions Symbolically

chmod u+x,g-w,o+r file.txt

4. Make a Directory Accessible to Everyone

chmod 777 /shared_directory/

Best Practices

Avoid Over-Permissive Settings
Avoid using 777 unless necessary, as it grants all users unrestricted access.
Use Recursive Option Cautiously
When using -R, double-check the target directory to prevent unintended permission changes.
Combine Symbolic and Numeric Modes
Use symbolic mode for flexibility and numeric mode for precision.

Summary

The chmod command is a fundamental tool for managing file and directory security in Linux. By understanding symbolic and numeric modes and their appropriate use cases, you can control access effectively and maintain system security.