{"id":68155,"date":"2022-10-26T09:00:49","date_gmt":"2022-10-26T09:00:49","guid":{"rendered":"https:\/\/www.cryptocabaret.com\/?p=68155"},"modified":"2022-10-26T09:00:49","modified_gmt":"2022-10-26T09:00:49","slug":"tips-for-using-the-linux-test-command","status":"publish","type":"post","link":"https:\/\/www.cryptocabaret.com\/?p=68155","title":{"rendered":"Tips for using the Linux test command"},"content":{"rendered":"

Tips for using the Linux test command<\/span>
\nSeth Kenlon<\/a><\/span>
\nWed, 10\/26\/2022 – 03:00<\/span><\/p>\n

\n

The [<\/code> command, often called a “test,” is a command from the GNU Core Utils package, and initiates a conditional statement in Bash. Its function is exactly the same as the test<\/code> command. When you want to execute a command only when something is either true or false, use the [<\/code> or the test<\/code> command. However, there’s a significant difference between [<\/code> or test<\/code> and [[<\/code>, and there’s a technical difference between those commands and your shell’s versions of them.<\/p>\n

[ vs test commands in Linux<\/h2>\n

The [<\/code> and the test<\/code> commands, installed by the GNU Core Utils package, perform the same function using a slightly different syntax. (You might find it difficult to search for documentation using the single left-square bracket character, however, so many users find test<\/code> easier to reference.) Bash and similar shells happen to also<\/em> have the [<\/code> and the test<\/code> commands built-in, and the built-in versions supersede the ones installed in \/usr\/bin<\/code>. In other words, when you use [<\/code> or test<\/code>, you’re probably not executing \/usr\/bin\/[<\/code> or \/usr\/bin\/test<\/code>. Instead, you’re invoking what’s essentially a function of your Bash shell.<\/p>\n

You might wonder why [<\/code> or test<\/code> exist in \/usr\/bin<\/code> at all. Some shells, such as tcsh<\/a>, don’t have [<\/code> and test<\/code> built-in, so if you want to use those commands in that shell, you must have them installed as separate binaries.<\/p>\n

The bottom line is that as long as you don’t get an error when you type a command starting with [<\/code> or test<\/code>, then you’ve got everything you need. It almost never matters whether your shell or your bin<\/code> directory is providing the commands.<\/p>\n<\/p>\n

\n
More Linux resources<\/div>\n
\n
Linux commands cheat sheet<\/a><\/div>\n
Advanced Linux commands cheat sheet<\/a><\/div>\n
Free online course: RHEL technical overview<\/a><\/div>\n
Linux networking cheat sheet<\/a><\/div>\n
SELinux cheat sheet<\/a><\/div>\n
Linux common commands cheat sheet<\/a><\/div>\n
What are Linux containers?<\/a><\/div>\n
Our latest Linux articles<\/a><\/div>\n<\/p><\/div>\n<\/p><\/div>\n

Testing for a file<\/h2>\n

It’s common to want to know whether a file exists, often so you can confidently proceed with some action, or so you can avoid “clobbering” it with a file of the same name. In an interactive shell session, you can just look to see whether the file exists but in a shell script, you need the computer to determine that for itself. The -e<\/code> option tests whether a file exists, but its apparent response is the same either way.<\/p>\n

\n
$ touch<\/span> example
\n$ test<\/span> -e<\/span> example
\n$ test<\/span> -e<\/span> notafile
\n$<\/div><\/div><\/pre>\n
The [<\/code> and test<\/code> commands are essentially switches. They emit a true<\/code> or false<\/code> response, but considers both of them as success. You can put this to use by pairing the commands with logical operators, such as &&<\/code> and ||<\/code>. The &&<\/code> operator is executed when a response is true<\/code>:<\/p>\n
\n
$ touch<\/span> example
\n$ test<\/span> -e<\/span> example &&<\/span> echo<\/span> \"foo\"<\/span>
\nfoo
\n$ test<\/span> -e<\/span> notafile &&<\/span> echo<\/span> \"foo\"<\/span>
\n$<\/div><\/div><\/pre>\n
The ||<\/code> operator executes when a response is false<\/code>:<\/p>\n
\n
$ touch<\/span> example
\n$ test<\/span> -e<\/span> example ||<\/span> echo<\/span> \"foo\"<\/span>
\n$ test<\/span> -e<\/span> notafile ||<\/span> echo<\/span> \"foo\"<\/span>
\nfoo
\n$<\/div><\/div><\/pre>\n
If you prefer, you can use square brackets instead of test<\/code>. In all cases, the results are the same:<\/p>\n
\n
$ touch<\/span> example
\n$ [<\/span> -e<\/span> example &<\/span>#93; && echo \"foo\"<\/span>
\nfoo
\n$ [<\/span> -e<\/span> notafile &<\/span>#93; && echo \"foo\"<\/span>
\n$<\/div><\/div><\/pre>\n
Testing for file types<\/h2>\n
Everything in Linux is a file, so when you can test for the existence of a directory with the -e<\/code> option, the same way you test for a file. However, there are different kinds of files, and sometimes that matters. You can use [<\/code> or test<\/code> to detect a variety of different file types:<\/p>\n