How to Remove Symbolic Links in Linux
Linux
23.09.2024
Reading time: 8 min
Share
Linux file systems are not complete without symbolic links, or "symlinks," which provide an adaptable means of referencing files and directories. As an alternative to a typical file copy, which makes a copy of the entire file, a symbolic link points to the location of another file or directory without taking up extra space on the disc. When files must be readily available from several locations or when users or system administrators want many references to a single file, this functionality becomes quite helpful. Symbolic connections are more versatile than hard links because they can span many file systems and partitions.
Linux users can improve system organization, streamline file management, and prevent needless file duplication by employing symbolic links. In-depth discussion of symbolic link generation, usage, and possible advantages in routine Linux activities will be provided in this article.
Difference Between Hard Links and Symbolic Links
Both hard links and symbolic links, or symlinks, offer methods for referencing files under Linux, however, they function differently and have different uses. Comprehending the distinctions between these two categories of connections is imperative for effective file administration and system arrangement.
In essence, a hard link is an explicit reference to a file's actual physical contents on the disc. The file system data structure known as the inode, which holds information about the location of the file, is the destination that a hard link links to when it is established. Eliminating one hard link to a file does not impact the others or the content of the original file because several hard links to the same file are indistinguishable from each other. Hard links cannot reference folders and must live on the same file system as the original file.
A symbolic link, on the other hand, stores the path to the destination and functions as a pointer or shortcut to the original file or directory. Because they can connect to files or directories on various file systems and even point to directories, symbolic links are more versatile than hard links. Symbolic links, however, require the target file to be present. The symbolic link gets "broken" and stops working if the target is removed or moved since it points to an invalid location.
The following are the primary key differences between Hard Links and Symbolic Links.
-
The files that are referenced by hard links can only be found within the same file system, whereas symbolic links can traverse several file systems and external discs.
-
As long as one hard link survives, all other links to the file will continue to work even if the original is removed. On the other hand, symbolic links require the original file or directory to be present.
-
Hard links are effectively duplicates of the file without consuming extra storage because they make direct references to its contents. Symbolic links take up less space because they just save the path to the source file; however, they run the risk of being invalid if the file structure changes.
-
Symbolic links can point to directories, but hard links cannot.
In summary, symbolic links allow flexibility, particularly when working with files or directories across various file systems, while hard links provide a more reliable approach to keep file references without having to worry about path dependencies. Based on the particular use case and file management requirements, users might choose between the two.
Identifying Symbolic Links in the File System
There are a number standard techniques, most involving terminal commands, that make it simple to identify symbolic connections.
-
Using the ls command with the
-loption is one of the easiest ways to discover a symlink. This will show comprehensive details, such as permissions and type, regarding files and directories. See below example:
SYNTAX:
ls –l <filename>EXAMPLE:
ls –l myfilename
An l (lowercase L) at the start of the permission string and the symlink's reference to the target file or directory is indicated by an arrow (->) indicates symbolic links in the output, as shown in the example above.
-
The
filecommand, which yields details about the content of each file, is an additional tool for identifying symbolic links. The output will clearly indicate that a link is symbolic and provide the target path when it is used on a symbolic link.
SYNTAX:
file <filename>EXAMPLE:
file target_path_name
By default, the file package is not installed. It can be readily installed using the system's package manager, depending on the distribution in use.
Debian/Ubuntu-Based Systems:
sudo apt install fileRed Hat/CentOS/Fedora-Based Systems:
sudo yum install file-
The
readlinkcommand is useful for users who want to confirm the actual target of a symbolic link. It returns the target path of the symbolic link without any additional information.
SYNTAX:
readlink <filename>EXAMPLE:
readlink target_path_name
Removing Symbolic Links with rm Command
The recommended way to remove symbolic links is to use the rm command. The fact that the symlink can be deleted without impacting the file or directory it points to is one of its main benefits. It's simple to remove a symbolic link using the command below.
SYNTAX:
rm <symbolic_file>EXAMPLE:
rm target_path_nameThe target file is unaffected by this command, just the symbolic link is deleted. The same procedure can be used to remove a symbolic link using the rm command if its target no longer exists, or if the symbolic link becomes broken.
Verifying Removal of Symbolic Links
The ls command can be used to list files and directories in the current directory, confirming that the symbolic link has been properly removed. It has been successfully deleted if the symbolic link removes.
SYNTAX:
ls –l <filename>EXAMPLE:
ls –l myfilename
Symbolic links are indicated in the output by an l (for "link") at the start of the permissions string. The symbolic link has been successfully deleted if it is no longer visible in the list.
Handling Errors When Removing Symbolic Links
Although the procedure of eliminating symbolic links in Linux is usually simple, users may sometimes run into problems. These mistakes may be the result of faulty or nonexistent links, permission problems, or improper syntax. File administration in a Linux system runs more smoothly when user know what common causes mistakes and how to fix them. Below are most common issue that may encounter.
-
"Permission denied" is one of the most frequent errors that occur while trying to erase a symbolic link. When a user lacks the necessary rights to remove a symlink or access the directory containing it, this happens. Users can use the
sudocommand to elevate their privileges and temporarily grant administrator rights in order to fix this problem. -
Links that point to nonexistent files or folders are known as broken symbolic links. Although fixing a damaged symlink should usually be the same as fixing any other symlink, users could run into problems if the path has changed. In these situations, the broken link itself can still be removed with the rm command, but it's crucial to make sure the link's name and location are entered correctly.
-
"No Such File or Directory" Error: This error usually arises when the user enters the incorrect file name or when the symbolic link intended for removal does not exist. Users should make sure that the symbolic link is being utilised with the correct name in order to resolve this issue. Users can verify the symlink's name by using the
ls -lcommand, which can be useful in identifying all files and symbolic links in the directory. -
When a user uses the
-r(recursive) flag to remove a symbolic link to a directory, users could experience an unexpected outcome where the directory contents are erased instead of simply the symbolic link. It's crucial to refrain from erasing symbolic links to folders with the-roption.
To sum up, resolving issues during the removal of symbolic links usually entails verifying the file name accuracy, assessing the present status of the file system, and examining permissions. Through the resolution of these possible problems, users can efficiently handle symbolic connections and prevent disturbances in their Linux environment.
Conclusion
Within the Linux file system, symbolic links are an incredibly useful and adaptable feature that let users establish shortcuts and references to files and directories. Whether they are used to handle broken files, generate cross-directory linkages, or simplify file administration, symlinks offer an effective means of streamlining processes without repeating data.
The primary features of symbolic links have been emphasized throughout this article, along with how they differ from hard links, how to build and maintain them, and how to fix typical removal issues. Users of Linux and system administrators can optimize system speed and file system organization by effectively utilizing symbolic connections.
Like any other Linux feature, using symbolic links correctly in both simple and complicated environments depends on your knowledge of their complexity. Users will be able to confidently add symbolic links into their daily activities with this knowledge, which will improve file handling and overall system organization.
You can try our reliable Linux VPS for your projects.
Linux
23.09.2024
Reading time: 8 min
Share
Similar
Linux
How to Compress Files in Linux Using tar Command
The tar command basically functions to put together all files and directories into one archive without altering their structure. The approach simplifies organization, creation of the backup, and the transfer of files. Once packaged, you can compress these archives by using multiple ways such as using gzip, bzip2, or xz, which help optimize storage and enhance transfer speeds.
Modern Linux distributions come with updated versions of tar, enabling seamless integration with compression tools like gzip for more efficient data handling. This makes tar a valuable asset for users managing large datasets, as it supports both file consolidation and compression in a single command.
Thanks to its flexibility, tar is widely used across different Linux environments. It not only facilitates backup creation but also streamlines software distribution and the management of the important data. With an array of choices available, all users can customize archives according to their requirements, whether by excluding particular directories or files, preserving permissions, or securing sensitive data.
For anyone dealing with extensive information or complex storage requirements, learning everything about the tar command is crucial. This all makes it an important utility to learn for Linux users.
Understand the Syntax of tar
The tar command is fundamentally divided into four distinct parts:
tar (keyword)
-flags (options), used to execute a specific action
name of the archive
path to the desired file or directory
It would be written as follows:
tar -flags (archive_name) (path)
Archiving Files and Directories
tar used with the flag -cvf has the power to essentially archive the files and also the directories.
For a File:
tar -cvf collectionX.tar snake.txt
For a Directory:
tar -cvf DRcollection.tar newDir/
This would essentially archive the file snake.txt to collectionX.tar and the directory newDir to DRcollection.tar respectively.
If desired outcome is to archive multiple files and directories, then use the following commands.For Multiple Files:
tar -cvf collectionX.tar snake.txt panther.txt Tiger.txt
For Multiple Directories:
tar -cvf DRcollection.tar newDir1/ newDir2/ newDir3/
Compressing Files and Directories
tar used with the flag -czvf has the power to compress the files as well as the directories:
For a File:
tar -czvf collectionX.tar.gz snake.txt
For a Directory:
tar -czvf DRcollection.tar.gz newDir/
-c archives the directories and files, -z pushes for gzip compression, -v is verbose which essentially shows what’s going on with compression, and -f allows to name the archive that is going to be compressed.
Add .gz after tar, if you want to compress the files and directories.
For Multiple Files:
tar -cvf collectionX.tar.gz snake.txt panther.txt Tiger.txt
For Multiple Directories:
tar -cvf DRcollection.tar.gz newDir1/ newDir2/ newDir3/
.bz2 used with tar and both used with -cjf allow to archive and compress files and directories. -j applies bzip2 compression.
For a File (with bz2):
tar -cjf collectionX.tar.bz2 snake.txt
For a Directory (with bz2):
tar -cjf DRcollection.tar.bz2 newDir/
.xz used with .tar and both used with -cJf allow you to archive and compress files and directories. In -cJf, -J means compress with xz.
For a File (with xz):
tar -cJf DRcollection.tar.xz file1.txt
For a Directory (with xz):
tar -cJf collectionX.tar.xz newDir/
Extracting Compressed .tar Files
arch1.tar.gz, arch1.tar.bz2 and arch1.tar.xz are three compressed files.
Extract tar.gz:
tar -xvzf arch1.tar.gz
-x stands for file extraction.
Extract tar.bz2:
tar -xvjf arch1.tar.bz2
Extract tar.xz:
tar -xvJf arch1.tar.xz
Extracting Specific Files Using Wildcards
If you need to extract only a specific type of file out of an archive, do this:
tar -xvf arch1.tar --wildcards '*.sh'
It will give you only the files with .sh extension.
--wildcards help search that specific type of file and enable pattern matching while *.sh ensures that you only extract the .sh type of files.
Extracting to a Specific Directory
If you need to extract the complete archive to a specific directory, do this:
tar -xvf arch1.tar -C ./destinationDir/pathDir/
-C changes to the specified directory path and -xvf helps extract the archive there.
Managing .tar Archives
Check Contents without Extracting
If you need to know what's inside an archive but don't want to uncompress files, use commands like this:
tar -tzf arch1.tar.gztar -tjf arch1.tar.bz2tar -tJf arch1.tar.xz
-t gives details about what’s inside the compressed archives without performing extraction on it.
Appending Files to an Existing Archive
To append a new file to an archive:
tar -rvf arch1.tar new.sh
new.sh will be added to arch1.tar. That’s how you append a file into an existing archive.
Removing a Specific File from an Archive
What if you need to delete a file from an archive without having to extract it, it can be done by using --delete.
tar --delete -f arch1.tar new.sh
This will remove the file new.sh from the archive arch1.tar without extracting it.
Note that --delete does not work on the compressed files, only on archives.
Comparing Archive Contents with Current Directory
If you have to examine the contents of your current working directory and compare them with the archive? use:
tar --diff -f arch1.tar
--diff will help compare the contents of arch1.tar with the content available in the present working directory.
Troubleshooting Common .tar Errors
"tar: Removing leading '/' from member names"
This warning appears when absolute paths are used in an archive:
tar -cvf arch1.tar /home/user/file.txt
Solution: Use -p to preserve absolute paths.
tar -cvpf arch1.tar /home/user/file.txt
"tar: Error opening archive: Unrecognized archive format"
This error occurs when the archive is corrupt or the wrong decompression command is used.
Solution: Verify the file type:
file arch1.tar.gz
Use the correct decompression command:
tar -xvzf arch1.tar.gz # For .tar.gztar -xvjf arch1.tar.bz2 # For .tar.bz2tar -xvJf arch1.tar.xz # For .tar.xz
If corruption is suspected, check integrity:
gzip -t arch1.tar.gzbzip2 -tv arch1.tar.bz2
Conclusion
The tar utility serves as an important tool for archiving, compression and extraction. It provides efficiency, making it a crucial component of Linux storage management. With a variety of configurations and settings, tar functions as an evergreen solution catering to diverse use scenarios. Options such as -czvf and -xvzf determine the way files are stored and retrieved, granting users complete control over data compression.
Furthermore, tar supports multiple compression tools like gzip, bzip2, and xz, allowing users to optimize both speed and compression ratio based on their specific needs.
For Information Technology professionals, developers, and Linux users, learning everything about tar is invaluable. Whether it’s for managing backups, distribution of data effectively, or optimizing storage, tar is by far one of the most influential archiving tools. By selecting the right configurations and commands, users can significantly enhance their workflow, automate tasks, and efficiently handle large datasets.
12 March 2025 · 6 min to read
Linux
How to Use the Screen Utility in Linux
The Screen utility is a Linux window manager that allows you to switch between multiple processes in a single physical terminal. Screen provides a scrollable history buffer and a mechanism for copying and pasting text between windows.
With Screen, you can create new windows with different programs, close the current windows, view a list of active windows, enable and disable output logging, and switch between windows. All windows work independently, and programs continue to run even when the session is disconnected from the user's terminal. This makes Screen a useful tool for efficiently managing multiple tasks in a single terminal.
Installing the Screen Utility
The Screen may be pre-installed in the operating system or require separate installation depending on the distribution. To install Screen, use the following command:
For Ubuntu and Debian:
apt install -y screen
For CentOS and Fedora:
yum install -y screen
Or:
dnf install -y screen
Basic Commands
Let's go over the basic commands for managing Linux Screen sessions.
Starting a Screen Session
To start Screen, simply enter the following command in your terminal:
screen
This will open a Screen session, create a new window, start a shell in it, and you will see a new window. Press Enter to proceed to enter commands.
Creating a Named Session
You can name your sessions, which is especially useful when working with multiple Screen sessions. To create a named session, use the following command:
screen -S session_name
It’s always helpful to choose a descriptive name for the session.
Detaching from a Screen Session in Linux
To detach from a Screen session at any time, type:
Ctrl+a d
The program running in the Screen session will continue to run in the background after you detach.
Reattaching to a Screen Session in Linux
To resume your Screen session, use the command:
screen -r
If you have multiple Screen sessions running, you need to specify the session ID or its name after the -r parameter.
To see the list of currently running sessions, use:
screen -ls
You will see a list of sessions like this:
There are screens on:
1468393.hostman (01/25/2025 02:07:34 PM) (Detached)
1466624.pts-3.1495851-user (01/25/2025 01:54:05 PM) (Detached)
2 Sockets in /run/screens/S-linuxize.
To resume the session with ID 1466624.pts-3.1495851-username, enter:
screen -r 1466624
To resume a session using its name, type:
screen -r session_name
Additional Options
Screen offers a variety of useful features for convenient session management in the terminal.
You can customize each window to suit your needs, such as adjusting its size according to display settings or configuring options using a custom configuration file.
You can also pause a session and resume it later or run Screen in daemon mode to keep it running in the background.
Additionally, you can customize command keys, manage data flow, and enable logging.
It's also possible to switch between windows, change their titles, and use UTF-8 encoding, making terminal work more comfortable and adaptable to different tasks.
Screen options:
-a: Enables all possible features for each window, maximizing functionality.
-A -[r|R]: Automatically adjusts all windows to fit the new screen width and height.
-c file: Specifies an alternate configuration file instead of the default .screenrc.
-d (-r): Detaches the current Screen session without terminating it so that you can reconnect later.
-D (-r): Terminates the active connection to a remote session, but the session itself remains running and can be resumed.
-D -RR: Takes all necessary actions to reconnect to an existing Screen session if one is available. If not, it starts a new one.
-e xy: Changes the default keybindings for Screen commands to custom ones, which is useful for avoiding conflicts with other programs.
-f: Enables data flow control; -fn disables it; -fa enables automatic flow control, which is helpful when working with large amounts of data.
-h lines: Sets the scrollback buffer size, allowing you to scroll through more command history.
-i: Interrupts data output on the screen when flow control is enabled, preventing terminal overload.
-l: Logs session information to the system log to keep track of active sessions; -ln disables this.
-ls [pattern]: Displays a list of all active Screen sessions currently connected.
-L: Enables logging of all terminal output to a log file.
-p window: Automatically selects the specified window on startup if it exists.
-q: Runs Screen in “quiet” mode, suppressing unnecessary error messages.
-V: Displays the version of Screen and then exits.
-r [session]: Reconnects to a previously started but detached Screen session.
-R: If an existing session is found, it reconnects to it; if not, it starts a new one.
-S session_name: Assigns a name to the new session, making it easier to reconnect to it later.
-t title: Sets a title for the window, which is displayed in the window list.
-U: Enables UTF-8 encoding support for text display.
-v: Displays the current version of the Screen program.
-x: Attaches to an active session, allowing it to be used simultaneously on multiple screens.
-X: Executes the specified command within an active Screen session.
Working with Screen Windows
You can work with multiple Screen sessions simultaneously, with several windows open for each session.
To create a new window with a shell, press:
Ctrl+a c
The window will be automatically assigned a number from 0 to 9.
Below are the common commands for managing windows in Screen:
Ctrl+a c — Create a new window (with a shell).
Ctrl+a " — Display a list of all windows.
Ctrl+a 0 — Switch to window 0 (by number).
Ctrl+a A — Rename the current window.
Ctrl+a S — Split the current region horizontally into two regions.
Ctrl+a | — Split the current region vertically into two regions.
Ctrl+a tab — Move the input focus to the next region.
Ctrl+a Ctrl+a — Toggle between the current and previous windows.
Ctrl+a Q — Close all regions except the current one.
Ctrl+a X — Close the current region.
To see all commands, enter:
Ctrl+a ?
When Screen starts, it reads its configuration settings from /etc/screenrc and ~/.screenrc, if they exist.
You can customize Screen's default settings to suit your preferences using the .screenrc file.
This example includes a custom status line and several additional options:
# Disable the startup message
startup_message off
# Automatically detach from the session when the connection is lost
autodetach on
# Set the scrollback buffer to 10,000 lines
defscrollback 10000
# Enable logging for the current session
logfile /path/to/screenlog
Additional recommendations for customizing Screen configuration:
Automatic Window Splitting on Startup
Useful if you frequently work with multiple windows and want them to open automatically when Screen starts.
screen -t shell1
split
focus
screen -t shell2
Logging All Sessions
Useful for keeping a record of work.
deflog on
logfile $HOME/.screen/screenlog.%t
Automatic Reconnection on Disconnection
Useful when working with unstable connections.
autodetach on
reattach on
Examples of Using Screen
Example 1: To monitor file changes in real-time, you can use two Screen windows: one for editing the file and another for displaying its content using the command:
tail -f filename
This allows you to instantly see all changes made without having to re-run the command.
Example 2: When working in a terminal over SSH using a Screen session, you won’t lose data if the connection is interrupted. Even if the connection drops, you can reconnect and resume work exactly where you left off by simply reattaching to the Screen session.
Example 3: For long-running tasks, such as compiling code or performing a backup, you can start the task in one Screen session and monitor its progress. You can safely disconnect anytime, knowing the task will continue running. Later, you can reconnect to the session to check the results.
Conclusion
In this guide, we covered how to use Linux Screen to manage terminal sessions effectively. You learned how to:
Create multiple windows within a single session.
Switch between windows.
Manage sessions, including detaching and resuming them.
We also discussed how to customize the terminal using the .screenrc configuration file to make your work environment more convenient and personalized.
You can now use Screen for a more comfortable and productive terminal experience by mastering these basic features.
For more information about Screen, check out the Screen user's manual.
20 February 2025 · 7 min to read
Linux
How to Use if-else in Bash
Many programming languages have conditional statements, such as if-else. These statements are also present in Bash, the default shell used in almost all modern Linux distributions. The if-else statements are used to check conditions — they allow the execution of specific commands depending on whether the condition is true or false. The if-else statements work exactly the same way as in any programming language.
In this article, we will discuss how to use if-else statements in the Bash shell through practical examples.
The if Statement in Bash
The if statement in Bash allows you to execute specific commands depending on the truth value of the given condition. Two logical statements are used to check for truth: True and False. The if statement is used when you need to check a condition. It controls the flow of script execution, allowing decisions to be made based on variable values, command results, and other conditions.
The if statement works as follows:
First, the program checks the condition (the condition can be a command or a mathematical expression) contained in the if statement.
If the condition is true, the program executes the commands listed after the then keyword.
If the condition is false, the program executes the commands listed after the else statement.
The syntax of the if statement in Bash is as follows:
if [condition]; then
# commands to execute if the condition is true
fi
Let's break down the operation of the if statement with a simple practical example. We will create a script that asks the user for a number, and if the number entered is greater than 10, the system will return the message "The number is greater than 10."
Create a new file with a .sh extension, for example, using the nano editor:
nano greater_than_10.sh
Insert the following code:
#!/bin/bash
read -p "Enter a number: " number
if [ $number -gt 10 ]; then
echo "The number is greater than 10."
fi
Provide the file with execute permissions:
chmod +x greater_than_10.sh
Now, run the script:
./greater_than_10.sh
Output:
Enter a number:
Enter any number, for example, 32, and press Enter. Since 32 is greater than 10, and this condition returns True, the program will execute the echo command.
Enter a number: 32The number is greater than 10
Let’s break down the script in more detail:
The conditions are written in square brackets. In this example, the -gt operator is used (greater than, equivalent to the > symbol).
Next, we check the condition. If it’s True, the program executes the command after the then keyword.
The script ends with the fi keyword, signaling the end of the if block.
However, this script has one major drawback: it does not handle the case when the entered number is less than 10. The script will not return anything because there is no condition for that case.
To address this issue, we will use the else statement, which we will discuss in the next chapter.
The if-else Statement in Bash
In the previous section, we ran a script with only one condition in the if statement — True. We didn’t specify any action for the False condition. As a result, if we entered a value leading to False, there was no response. If we want the script to perform specific actions for the false condition False, we need to use the else statement, which follows the if statement.
The if-else statement in Bash is used to perform conditional operations. It allows the execution of specific commands depending on whether the condition is true or false. The syntax for if-else is as follows:
if [condition]; then
# commands executed if the condition is true
else
# commands executed if the condition is false
fi
Remember that keywords, including if and else, in Bash shell scripts are case-sensitive. Be careful when using keywords in script files.
Let's consider using the if-else statements in a practical example. In this case, we will create a Bash script that asks the user for a number, and the system will display whether the number is greater than or less than 10.
Create a new file with a .sh extension:
nano check.sh
Insert the following code:
#!/bin/bash
read -p "Enter a number: " number
if [ $number -gt 10 ]; then
echo "The number is greater than 10."
else
echo "The number is less than or equal to 10."
fi
Grant the file execute permissions:
chmod +x check.sh
Now, run the script:
./check.sh
The algorithm for the script works as follows:
After the if keyword, we specify the condition in square brackets. In this example, we use the -gt operator (greater than, equivalent to the > symbol).
The condition is checked. If the condition is true, the program executes the command after the then keyword— in this case, it prints the message "The number is greater than 10". If the condition is false, the program executes the command after the else keyword, printing the message "The number is less than or equal to 10".
Once one of the conditions is met, the program will end, as indicated by the fi keyword at the end.
Output if the number is greater than 10:
Enter a number: 56The number is greater than 10.
Output if the number is less than 10:
Enter a number: 6The number is less than or equal to 10.
Practical Use of if-else in Bash
Let's look at the practical application of the if-else statement in Bash, which can be used when writing scripts.
Script Example 1. Checking if Run as root
First, we will create a script that checks whether the script file is run as the root user. This can be useful when writing scripts that require root privileges, such as installing packages as the root user.
Create a file named check-for-root.sh:
nano check-for-root.sh
Use the following code to check for root user:
#!/bin/bash
if [[ $EUID -ne 0 ]]; then
/usr/bin/printf "${R}>>>>${NC} Please run as root\n"
exit 1
fi
Grant the file execute permissions:
chmod +x check-for-root.sh
And run it:
./check-for-root.sh
If the script is run as a regular user, the console will print the message "Please run as root".
The check for the root user uses the condition $EUID -ne 0, where:
$EUID is an environment variable that holds the numeric user ID. In Linux systems, the root user always has the ID 0, while other user accounts start at 1000.
-ne is a comparison operator meaning "not equal". Instead of ne, you can also use !=.
Script Example 2. Checking the Linux distribution
Next, let's create another script that checks which Linux distribution is being used. If the script is run on Ubuntu, it will print the message "This is Ubuntu". If the script is run on any other Linux distribution, it will print "Not Ubuntu. You can run this script only on Ubuntu distributions".
Create a file named check-for-distribution.sh:
nano check-for-distribution.sh
Use the following code:
#!/bin/bash
dist=`grep DISTRIB_ID /etc/*-release | awk -F '=' '{print $2}'`
if [ "$dist" == "Ubuntu" ]; then
echo "This is Ubuntu"
else
echo "Not Ubuntu. You can run this script only on Ubuntu distributions"
fi
Make the file executable:
chmod +x check-for-distribution.sh
And run it:
./check-for-distribution.sh
If the script is run on an Ubuntu system, it will print "This is Ubuntu". On any other distribution, it will print "Not Ubuntu. You can run this script only on Ubuntu distributions".
Script Example 3. Checking if File Exists
Now, let’s look at another practical example. We will create a Bash script that checks if a file named file1.txt exists. If it doesn't exist, the script will create it. The script checks for the file in the same directory it is run. If the file already exists, the script will print a message without creating the file.
Create a file named check-file.sh:
nano check-file.sh
Use the following script code:
#!/bin/bash
FILE="file1.txt"
if [ ! -f "$FILE" ]; then
touch "$FILE"
echo "$FILE has been created."
else
echo "$FILE already exists."
fi
Grant execute permissions for the script:
chmod +x check-file.sh
Run the script:
./check-file.sh
If the file1.txt file already exists in the directory from which the script is run, you will see the message "file1.txt already exists.". The file will not be created.
Conclusion
In this article, we reviewed the principles of logical statements such as if-else in the Bash shell and provided practical examples of using these statements. These examples are useful when writing scripts to automate system tasks or checks.
18 February 2025 · 7 min to read
Do you have questions,
comments, or concerns?
Our professionals are available to assist you at any moment,
whether you need help or are just unsure of where to start.
whether you need help or are just unsure of where to start.
