Linux if file options

3 ways to check if file exists in bash

In this blog post, we will discuss 3 different ways to check if a file exists in Bash. This is an important skill to have when you are working with files in a Linux environment. Each of these methods has its own benefits and drawbacks, so it is important to understand them all before deciding which one to use. Let’s get started!

The following Linux commands can be used to check if a file exists in bash.

• test -f /path/to/file && echo “FILE exists.” || echo “File does not exist”
• [ -e /path/to/file ] && echo “FILE exists.” || echo “File does not exist”
• [ -f /path/to/file ] && echo “FILE exists.” || echo “File does not exist”

Check if a File Exists Using the test Command in bash

The first method we will discuss is using the test command. This is a built-in command in Bash that can be used to test various things. In this case, we are interested in using it to check if a file exists. The syntax for this command is as follows:

If the file exists, this command will return a 0 exit code. If the file does not exist, it will return a non-zero exit code. So, we can use this command to check if a file exists like so:

if test -e /path/to/file; then
echo “File exists”
else
echo “File does not exist”
fi

We can do this in one command like this.
test -e /path/to/file && echo “FILE exists.” || echo “File does not exist”

Check if a File Exists Using if statement -e option in bash

The best Linux command to check if a file Exists in bash is using the if statement -e option. The -e option is a built-in operator in Bash to check file exists. If the file exists, this command will return a 0 exit code. If the file does not exist, it will return a non-zero exit code.

The syntax for this operator is as follows:

if [ -e /path/to/file ] ; then
echo “File exists”
else
echo “File does not exist”
fi

We can do this in one command.

[ -e /path/to/file ] && echo “FILE exists.” || echo “File does not exist”

Check if a File Exists Using -f option in bash if statement

The third method we will discuss is using the -f option in if statement. The -e option checks if the file path exists, while the -f option checks if the file path exists and if it is a regular file. The syntax for these operators are as follows:

if [-f /path/to/file ] ; then
echo “File exists”
else
echo “File does not exist”
fi

we can do this in one command line.
[ -f /path/to/file ] && echo “FILE exists.” || echo “File does not exist”

File test operators in bash

The test command includes the following FILE operators that allow you to test for particular types of files:

• -d FILE FILE exists and is a directory.
• -e FILE FILE exists.
• -r FILE FILE exists and the read permission is granted.
• -s FILE FILE exists and it’s size is greater than zero (ie. it is not empty).
• -w FILE FILE exists and the write permission is granted.
• -x FILE FILE exists and the execute permission is granted.

As you can see, there are many different ways to check if a file exists in Bash. Each of these methods has its own benefits and drawbacks, so it is important to understand them all before deciding which one to use. In general, the “test” command is the simplest and most reliable way to check if a file exists. However, the other methods can be useful in certain situations. Thanks for reading!

David is a Cloud & DevOps Enthusiast. He has years of experience as a Linux engineer. He had working experience in AMD, EMC. He likes Linux, Python, bash, and more. He is a technical blogger and a Software Engineer. He enjoys sharing his learning and contributing to open-source.

howtouselinux.com is dedicated to providing comprehensive information on using Linux.

We hope you find our site helpful and informative.

Источник

Bash if –e and –s and other File Test Operators

In Linux files, test operators are used for checking the attributes associated with a file like: the author of the file, administrative rights, and ownership of the file, and to check whether they are symlink or not. When we are dealing with files, it becomes necessary to check their existence and whether they contain any content or not for this purpose; or if a statement is used along with the test operators.

File test operators in bash are also used to test the files as the name explains. With the help of these operators, we can test different aspects of a file like if that file is writable or readable only. There are many file test operators and each one has a different role and use. File test operators help us to prevent errors while scripting in Bash. To perform that task, we use an if-else statement. The if-else statement acts as a very useful tool for error handling in Bash scripting.

The purpose of the “-e” operator is to tell us whether a file exists in the specified directory or not. The “-s” operator tells us that the file is not a zero size which means that this operator tells us whether the file in the specified directory contains any data or not. Other operators are used to dealing with files but the “-e” and “-s” are the most important ones and are frequently used.

How to Use Test Operators:

In this illustration, we will try to use all of the test operators to perform various tasks on the files.

Example no. 1: Using the if –e Text Operator

In this example, we will try to use the if –e test operator which is mainly used to verify whether the file exists in a directory or not. Now, we will first create a new file.

When we run the command above, it will open the empty file now we will write the code in which we will create a condition that the file “employee.txt” exist it will display the echo command which contains the message “File exists”. Else, it will execute the message “File does not exist”. The file testoperator will contain the content mentioned below.

#!/bin/sh
file = «employee.txt»
if [ -e $file ]
then
echo «File exists»
else
echo «The file does not exist»
fi

After saving the file using the bash command, we will run the below-mentioned command which will execute the testoperator.sh file.

When we run the above command, it will read the code of the testoperator file which executes and check for the file in the home directory. In this case, we do not have any file in the directory, so it executed the output below.

Now, we will first create a new file named “employee.txt”. Then, again run the command to check whether it will detect the file or not. As shown below, this time the file exists in the home directory.

Now, let us run the above command again. This time, it displays the output that is shown below in which the message “File exists”.

Example no. 2: Using the if –d Text Operator

In this example, we will try another test operator that is the “-d” operator which is used to verify whether the file we are checking is a directory or not. This time, we will create a new directory which we named “employee”, as can be seen in the snippet below.

Now, we will modify the “testoperator.sh” file in which we will change the file name “employee.txt” to just “employee”. Then, passing the “-d” operator in the if statement along with the “$file” which will be fetched out. And changing the message, that will be displayed as output, we will save the file. Now, the “testoperator.sh” file contains the following content.

#!/bin/sh
file = «employee”
if [ -d $file ]
then
echo » The employee is a directory »
else
echo » The employee is not a directory »
fi

After modifying the “testoperator.sh”, we will run the bash command along with the file name :

When the command above executes, it will display the output shown below in which it prints the message that is:

Example no. 3: Using the if –s Text Operator

In this example, we will try to use the “-s” operator which is used to check whether the file contains any content or not. For that, we will be using the already created file that we used in example 1 named “employee.txt”. Let us first modify the file testoperator.sh in which we will pass the “-s” option along with the file name to our if statement and assign the file “employee.txt”. Also, it will change the message that will be displayed as an output.

#!/bin/sh
file = «employee.txt”
if [ -d $file ]
then
echo » employee.txt is empty »
else
echo » employee.txt is not empty »
fi

Now, we will save and close the file “testoperator.sh” and run the command mentioned below in the terminal.

When the command above runs, it will execute the else statement because the employee.txt contains the content. So, it ignores the then statement echo command.

Now, we will remove the content from the “employee.txt” and then run the command again. When the command above is executed once again, it displays the then statements message because it does not contain any content in it. The example below is the output of the command that we executed after deleting the content of the file.

Example no. 4: Using the if –r Text Operator

In this example, we will implement another test operator that is “-r”. This operator is used to check whether the file is readable to the user or not. For this, we will modify the testoperator.txt file by replacing the “-d” operator with “-r”. It will also change the output message which is if the file is readable. It will display the message “employee.txt is readable and if the file is not readable it will display the else statement. Now, the “testoperator.txt” contains the following content:

#!/bin/sh
file =”employee.txt”
if [ -r $file ]
then
echo “employee.txt is readable”
else
echo “ employee.txt is readable “
fi

Now, we will run the command below to execute the code written inside it.

After running the above command, the displayed output below will be printed on the terminal.

Conclusion

We have discussed the most important part of the filing system, the test operators. While working with files, the test operators are the most essential utility provided by Linux packages. After introducing the purpose of the test operators, we explained them by implementing these operators in various examples.

About the author

Omar Farooq

Hello Readers, I am Omar and I have been writing technical articles from last decade. You can check out my writing pieces.

Источник

bash if -a vs -e option

-a is deprecated, thus isn’t listed in the manpage for /usr/bin/test anymore, but still in the one for bash. Use -e . For single ‘[‘, the bash builtin behaves the same as the test bash builtin, which behaves the same as /usr/bin/[ and /usr/bin/test (the one is a symlink to the other). Note the effect of -a depends on its position: If it’s at the start, it means file exists . If it’s in the middle of two expressions, it means logical and .

[ ! -a /path ] && echo exists doesn’t work, as the bash manual points out that -a is considered a binary operator there, and so the above isn’t parsed as a negate -a .. but as a if ‘!’ and ‘/path’ is true (non-empty). Thus, your script always outputs «-a» (which actually tests for files), and «! -a» which actually is a binary and here.

For [[ , -a isn’t used as a binary and anymore ( && is used there), so its unique purpose is to check for a file there (although being deprecated). So, negation actually does what you expect.

The bash builtin uses -a as -e in unary mode and -a as AND in binary mode. Using [[ ]] invokes the bashs builtin, thats why you got reasonable output with it. The single [ bracket invokes as mentioned the test binary which accepts the unary but does not treat it right (should be used as binary)

Very few shells actually invoke /bin/test (or /bin/[) when you write ‘if [ . ]’. Once upon a long time ago — yes; nowadays, no. Not even vanilla Bourne shell.

Источник