Scott Robinson

Uchechukwu Azubuko

Guide to Building Rest APIs with Strapi

<h2 id="introduction">Introduction</h2>
The command line is a powerful tool for developers and system administrators. It allows them to perform tasks quickly and efficiently, without having to rely on graphical user interfaces. Understanding the basic concepts of the command line, such as redirections, is essential for unlocking its full potential. One of these redirections is the <code>2&gt;&amp;1</code> operator, which is the focus of this article.
<blockquote>
In this article, we will discuss what <code>2&gt;&amp;1</code> is, how it works, and its various use cases. With a deeper understanding of <code>2&gt;&amp;1</code>, developers and system administrators can use it to streamline their workflow and troubleshoot issues more effectively.
</blockquote>
<h2 id="whatis21">What is 2&gt;&amp;1</h2>
<code>2&gt;&amp;1</code> is a Shell operator that is used in the command line to redirect <code>stderr</code> (file descriptor <code>2</code>) to <code>stdout</code> (file descriptor <code>1</code>). In other words, it allows any error messages generated by a command to be combined with its standard output and sent to the same destination, such as the terminal or a file.

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 File descriptors are a fundamental concept in Unix-based operating systems and are used to identify the source and destination of input and output data. They are assigned integer values, with <code>0</code> representing <code>stdin</code>, <code>1</code> representing <code>stdout</code>, and <code>2</code> representing <code>stderr</code>.

 </div>
 </div>
 </div>
 The <code>2&gt;&amp;1</code> operator has a long history and has evolved over time to become a widely used tool in the command line. Its versatility and efficiency have made it a staple for developers and system administrators looking to streamline their workflow and simplify troubleshooting. In the next section, we will dive deeper into how <code>2&gt;&amp;1</code> works and its various use cases.
<h2 id="howdoes21work">How Does 2&gt;&amp;1 Work?</h2>
<code>stderr</code> and <code>stdout</code> are two separate data streams in the command line that are used to display the results of a command. <code>stdout</code> (standard output) is used to display normal output from a command, while <code>stderr</code> (standard error) is used to display error messages.
The difference between <code>stderr</code> and <code>stdout</code> is that <code>stderr</code> is meant to display error messages, while <code>stdout</code> is meant to display normal output. By default, <code>stderr</code> messages are displayed in a different color or are displayed differently in the terminal, making them easier to distinguish from normal output.
With <code>2&gt;&amp;1</code>, the <code>stderr</code> stream is redirected to <code>stdout</code>, effectively combining the two streams into a single stream of output. This can be useful in several scenarios, such as debugging scripts, capturing error messages, saving output to a file, or combining output from multiple commands. In the next section, we will explore some of the most common use cases for <code>2&gt;&amp;1</code>.
<h2 id="usecases">Use Cases</h2>
<code>2&gt;&amp;1</code> has several useful applications in the command line. Some of the most common use cases are:
<ul>
<li>
Debugging scripts - When writing scripts, it can be difficult to identify errors without having access to stderr messages. By using <code>2&gt;&amp;1</code>, developers can redirect <code>stderr</code> to <code>stdout</code>, making it easier to identify and fix errors.
</li>
<li>
Capturing error messages - When running a command, it is important to capture any error messages that are generated. By using <code>2&gt;&amp;1</code>, error messages can be redirected to the same destination as the normal output, making them easier to find and analyze.
</li>
<li>
Saving output to a file - By using <code>2&gt;&amp;1</code> in combination with the <code>&gt;</code> operator, it is possible to save the combined output of a command to a file. This can be useful for keeping a record of the output or for analyzing it later.
</li>
<li>
Combining output from multiple commands - When running multiple commands, it can be useful to combine their output into a single stream. By using <code>2&gt;&amp;1</code>, the error messages from one command can be redirected to the <code>stdout</code> of the next command, resulting in a single stream of output.
</li>
</ul>
These are just a few of the many use cases for <code>2&gt;&amp;1</code>. By understanding how it works and its various applications, developers and system administrators can use it to streamline their workflow and simplify troubleshooting.
<h2 id="conclusion">Conclusion</h2>
In conclusion, <code>2&gt;&amp;1</code> is a handy shell operator that is widely used in the command line. It makes it easy for developers and system administrators to redirect <code>stderr</code> (file descriptor <code>2</code>) to <code>stdout</code> (file descriptor <code>1</code>), combining error messages with normal output into a single stream.
Understanding <code>2&gt;&amp;1</code> is key to unlocking the full potential of the command line and making work a breeze. With its many uses, such as debugging scripts, capturing error messages, saving output to a file, and combining output from multiple commands, <code>2&gt;&amp;1</code> is a great tool to have in your toolbox. By using it effectively, you can simplify troubleshooting and get things done faster and more efficiently.

David Landup

Dimitrije Stamenic

In this short tutorial, learn what "2>&1" does in the Command Line on Linux.

What Does "2>&1" do on the Command Line?

<h2 id="introduction">Introduction</h2>
Grep is a powerful tool in the Unix world that allows you to search for specific text within files or even directories. It is widely used for log analysis, code review, and many other tasks that require searching for text. In Bash, you can use <code>grep</code> to search for specific text in a single file, but what if you want to search for text in multiple files in a directory and its subdirectories?
<blockquote>
This is where recursive <code>grep</code> comes in.
</blockquote>
Recursive <code>grep</code> is a feature in Bash that enables you to search for text within all files in a directory and its subdirectories. This is particularly useful when you have a large number of files or when you want to search for text in all files under a specific directory. With recursive <code>grep</code>, you can easily search for specific text in all files, without having to open each file individually.
<blockquote>
In this article, we will cover the basic syntax for recursive <code>grep</code>, practical use cases, and advanced options to help you become more proficient in using this powerful tool. This article will provide you with the knowledge you need to effectively use recursive <code>grep</code> in Bash.
</blockquote>
<h2 id="basicsyntaxforrecursivegrep">Basic Syntax for Recursive Grep</h2>
Let's take a quick look at the basic syntax for using <code>grep</code> to search for text recursively in Bash:
<pre><code class="hljs">grep -r &lt;pattern&gt; &lt;directory&gt;
</code></pre>
Now, we can break down the components of this command:
<ul>
<li><code>grep</code> - This is the command that you use to search for text</li>
<li><code>-r</code> - This is the option that tells <code>grep</code> to search recursively. It searches through all the files in the target directory, including subdirectories.</li>
<li><code>&lt;pattern&gt;</code> - This is the text or pattern that you want to search for. You can use regular expressions to specify the pattern.</li>
<li><code>&lt;directory&gt;</code> - This is the target directory that you want to search in. You can specify a relative or absolute path to the directory.</li>
</ul>
Here's an example of how you might use this syntax in a real-world scenario:
<pre><code class="hljs">grep -r &quot;error&quot; /var/log
</code></pre>
This command will search for the word <code>&quot;error&quot;</code> in all files within the <code>/var/log</code> directory, including subdirectories. The result of this command will display the name of the file and the line of text that contains the word <code>&quot;error&quot;</code>.

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: The basic syntax for recursive <code>grep</code> is the same for most Unix-based systems. However, some systems may have different options or variations of the command. It's always a good idea to consult the documentation for your specific system to make sure you are using the correct syntax.

 </div>
 </div>
 </div>
 <h2 id="practicalusecasesofthegrepcommand">Practical Use Cases of the grep Command</h2>
Recursive <code>grep</code> is a versatile tool that can be used in a variety of situations. Here are some practical use cases for recursive <code>grep</code>:
<ul>
<li>
Searching for specific text in all files under a directory
<ul>
<li>If you have a directory with multiple files and you want to search for a specific piece of text, you can use recursive grep to search through all the files in the directory and its subdirectories</li>
<li>This can be useful for tasks such as log analysis or code review</li>
</ul>
</li>
<li>
Searching for specific text in files with a specific extension
<ul>
<li>If you want to search for text in only specific types of files, you can use the <code>--include</code> option in combination with a file extension</li>
<li>For example, you might use <code>--include=*.log</code> to search only in files with a <code>.log</code> extension</li>
</ul>
</li>
<li>
Searching for specific text in hidden files
<ul>
<li>If you need to search for text in hidden files, you can use the <code>-a</code> option to include hidden files in the search</li>
</ul>
</li>
</ul>
For example, the following command will search for the word <code>&quot;error&quot;</code> in all <code>.log</code> files, including hidden files, in the <code>/var/log</code> directory and its subdirectories:
<pre><code class="hljs">grep -r -a &quot;error&quot; /var/log --include=*.log
</code></pre>
<h2 id="advancedoptions">Advanced Options</h2>
While the basic syntax for recursive <code>grep</code> is simple, there are many advanced options that you can use to further customize your search. Here are some of the most commonly used advanced options for recursive grep:
<ul>
<li>
<code>-i</code> - This option makes <code>grep</code> case-insensitive, meaning that it will match the search pattern regardless of the case
<ul>
<li>For example, <code>grep -ri &quot;error&quot; /var/log</code> will match both <code>&quot;error&quot;</code> and <code>&quot;Error&quot;</code></li>
</ul>
</li>
<li>
<code>-l</code> - This option tells <code>grep</code> to only display the names of the files that contain the search pattern, rather than the actual lines of text
<ul>
<li>For example, <code>grep -rl &quot;error&quot; /var/log</code> will display a list of all files in the <code>&quot;/var/log&quot;</code> directory that contain the word <code>&quot;error&quot;</code></li>
</ul>
</li>
<li>
<code>-v</code>: This option inverts the search, meaning that it will display all lines of text that do not match the search pattern
<ul>
<li>For example, <code>grep -rv &quot;error&quot; /var/log</code> will display all lines of text in the <code>/var/log</code> directory that do not contain the word <code>&quot;error&quot;</code></li>
</ul>
</li>
<li>
<code>-n</code>: This option displays the line number of each match in the file
<ul>
<li>For example, <code>grep -rn &quot;error&quot; /var/log</code> will display the line number for each line that contains the word <code>&quot;error&quot;</code>.</li>
</ul>
</li>
<li>
<code>--exclude</code>: This option allows you to exclude specific files or directories from the search
<ul>
<li>For example, <code>grep -r --exclude=*.log &quot;error&quot; /var/log</code> will search for the word <code>&quot;error&quot;</code> in all files in the <code>/var/log</code> directory, excluding files with a <code>.log</code> extension</li>
</ul>
</li>
</ul>
These are just a few examples of the many advanced options that you can use with recursive <code>grep</code>. By combining these options, you can create complex searches that match your specific needs. Whether you are searching for text in logs, code, or other types of files, the advanced options for recursive <code>grep</code> can help you get the results you need.
<h2 id="conclusion">Conclusion</h2>
All-in-all, recursive <code>grep</code> is a powerful tool in the bash shell that allows you to search for text in multiple files, including files in subdirectories. With its simple syntax and numerous advanced options, recursive <code>grep</code> can be used in a variety of situations, from searching for specific text in logs to searching for code in your project's source files. Whether you are a beginner or an advanced user, recursive <code>grep</code> is an important tool to have in your toolbox for any task that requires searching for text in multiple files.

In this short tutorial, learn how to search for text recursively, in a given directory, using the grep command, starting with the basic syntax, and going through advanced flags and practical use cases.

How to Grep Recursively in Bash

<h2 id="introduction">Introduction</h2>
Getting the source directory of a Bash script is an important topic for anyone who is looking to develop robust and reliable Bash scripts. Understanding how to retrieve the source directory of a script can make it easier to manage and organize your code. Whether you're a beginner or an experienced shell script programmer, it's essential to understand this concept.
<blockquote>
The article will cover the basics of the <code>$0</code> parameter in Bash, which holds the name of the script. We will then discuss the <code>dirname</code> command, which is used to extract the directory portion of a file path. Finally, we will put everything together to demonstrate how to get the source directory of a script using these tools.
</blockquote>
So, let's dive in and learn how to get the source directory of a Bash script.
<h2 id="understandingthe0parameter">Understanding the $0 Parameter</h2>
The <code>$0</code> parameter in Bash holds the name of the script that is currently running. It is a special parameter that can be used to retrieve the name of the script at runtime. This information can be useful for various purposes, such as printing the name of the script or using it to determine the source directory.
Here is an example of using the <code>$0</code> parameter to print the name of the script. Say the following is the content of the Bash script called <code>test.sh</code> and that it is located in the <code>/home/username/Desktop/scripts</code> folder:
<pre><code class="hljs">echo &quot;The name of the script is: $0&quot;
</code></pre>
When run, this script will output the following:
<pre><code class="hljs">The name of the script is: /home/username/Desktop/scripts/test.sh
</code></pre>
As you can see, the <code>$0</code> parameter holds the full path to the script, including the script name itself. This information can be used in combination with the <code>dirname</code> command to retrieve the source directory of the script, as we will see in the next section.
<h2 id="usingthedirnamecommand">Using the dirname Command</h2>
The <code>dirname</code> command in Bash is used to extract the directory portion of a file path. It takes a file path as an argument and returns the directory portion of that path.
Here is an example of using the <code>dirname</code> command to extract the directory portion of a file path:
<pre><code class="hljs">$ dirname /home/username/Desktop/scripts/test.sh
# Output: /home/username/Desktop/scripts
</code></pre>
As you can see, the <code>dirname</code> command returns the directory portion of the file path, excluding the file name itself. This information can be used in combination with the <code>$0</code> parameter to retrieve the source directory of a script.
<h2 id="puttingitalltogether">Putting It All Together</h2>
Now that we have a basic understanding of the <code>$0</code> parameter and the <code>dirname</code> command, let's put everything together to demonstrate how to get the source directory of a script.
Here is a complete example that uses both the <code>$0</code> parameter and the <code>dirname</code> command to retrieve the source directory of a script (which is called <code>example.sh</code>):
<pre><code class="hljs">src_dir=$(dirname &quot;$0&quot;)
echo &quot;The name of the script is: $0&quot;
echo &quot;Source directory of the script: $src_dir&quot;
</code></pre>
When run, this script will output the following:
<pre><code class="hljs">The name of the script is: /home/username/Desktop/scripts/example.sh
Source directory of the script: /home/username/Desktop/scripts
</code></pre>
As you can see, this script uses the <code>$0</code> parameter to retrieve the full path to the script and then uses the <code>dirname</code> command to extract the directory portion of that path. This information is stored in the <code>src_dir</code> variable, which can then be used in your script as needed.
<h2 id="conclusion">Conclusion</h2>
In conclusion, getting the source directory of a Bash script is a straightforward process that involves the use of the <code>$0</code> parameter and the <code>dirname</code> command. By understanding these two concepts, you have the ability to retrieve the source directory of any script and use it in your code as needed. Whether you're building simple scripts or complex applications, this information is essential for creating reliable and efficient Bash scripts.

In this short tutorial, learn how to get the source directory of a bash script, using the $0 parameter, and the dirname command.

How to Get the Source Directory of a Bash Script

<h2 id="introduction">Introduction</h2>
In Bash scripting, it's often necessary to check if a string contains a specific substring. This can be useful for validating user input, processing text data, or executing certain actions based on the presence or absence of a certain pattern.
The process of checking if a string contains a substring in bash can be done in several ways, including using the <code>if</code> statement alongside the <code>[[</code> operator, or using the <code>grep</code> command.
<blockquote>
In this article, we will be exploring both methods in detail, along with examples of how to implement them in your scripts. Whether you're a beginner or an experienced bash programmer, this guide will provide a comprehensive overview of how to check if a string contains a substring in bash.
</blockquote>
<h2 id="method1usingtheifstatementandtheoperator">Method 1: Using the if Statement and the [[ Operator</h2>
The <code>if</code> statement in Bash is used to perform conditional execution of commands based on the exit status of a <code>test</code> command. In this case, we can use the <code>[[</code> operator to perform a string comparison between the target string and the substring.
Let's take a quick look at the syntax for using the <code>if</code> statement and the <code>[[</code> operator to check if a string contains a substring:
<pre><code class="hljs">if [[ &quot;$string&quot; == *&quot;substring&quot;* ]]
then
 echo &quot;Substring found.&quot;
else
 echo &quot;Substring not found.&quot;
fi
</code></pre>
Here, <code>$string</code> is the target string that you want to check for the presence of a substring, and <code>&quot;substring&quot;</code> is the substring you're searching for. The <code>*</code> wildcard before and after the substring acts as a placeholder for any characters that may come before or after the substring.
Now, we can take a look at the actual example that checks if the string <code>&quot;This is a test string&quot;</code> contains a string <code>&quot;test&quot;</code> as its substring:
<pre><code class="hljs"># Define the target string
string=&quot;This is a test string.&quot;

# Check if the string contains the substring &quot;test&quot;
if [[ &quot;$string&quot; == *&quot;test&quot;* ]]
then
 echo &quot;Substring found.&quot;
else
 echo &quot;Substring not found.&quot;
fi
</code></pre>
As expected, the <code>if</code> statement will return <code>&quot;Substring found.&quot;</code> as the target string <code>$string</code> contains the substring <code>&quot;test&quot;</code>.
Now, let's take a look at the pros and cons of this method for checking if a string contains a substring in Bash.
<h3 id="pros">Pros</h3>
<ul>
<li>Syntax is simple and easy to understand</li>
<li>Doesn't require an external tool or command</li>
<li>Processing time is faster than using the <code>grep</code> command</li>
</ul>
<h3 id="cons">Cons</h3>
<ul>
<li>Limited in functionality, as it only checks for the presence of a substring and cannot be used for more advanced pattern matching</li>
</ul>
<h2 id="method2usingthegrepcommand">Method 2: Using the grep Command</h2>
The <code>grep</code> command is a powerful tool for searching for patterns in text data. It can be used to check if a string contains a substring by using the <code>-q</code> option to perform a quiet search, which returns an exit status based on whether or not the substring was found.
Take a look at the syntax for using the <code>grep</code> command to check if a string contains a substring:
<pre><code class="hljs">if echo &quot;$string&quot; | grep -q &quot;$substring&quot;
then
 echo &quot;Substring found.&quot;
else
 echo &quot;Substring not found.&quot;
fi
</code></pre>
As in the previous method, <code>$string</code> is the target string that you want to check for the presence of a substring, and <code>$substring</code> is the substring you're searching for. The <code>echo</code> command is used to pipe the target string to the <code>grep</code> command, which performs a quiet search for the specified substring.
Now, we can implement the previous example of checking the existence of the <code>&quot;test&quot;</code> substring inside of the <code>&quot;This is a test string.&quot;</code> string:
<pre><code class="hljs">Define the target string
string=&quot;This is a test string.&quot;

# Define the substring
substring=&quot;test&quot;

# Check if the string contains the substring
if echo &quot;$string&quot; | grep -q &quot;$substring&quot;
then
 echo &quot;Substring found.&quot;
else
 echo &quot;Substring not found.&quot;
fi
</code></pre>
As we expected, the <code>if</code> statement will return <code>&quot;Substring found.&quot;</code> as the target string <code>$string</code> definitely contains the substring <code>&quot;test&quot;</code>.
<h3 id="pros">Pros</h3>
<ul>
<li>More powerful and flexible than the <code>if</code> statement and <code>[[</code> operator</li>
<li>Can be used for more advanced pattern matching and text processing tasks</li>
<li>Widely used and well-documented</li>
</ul>
<h3 id="cons">Cons</h3>
<ul>
<li>Slower processing time compared to the <code>if</code> statement and <code>[[</code> operator</li>
<li>Requires the use of an external command, which can add complexity to your script</li>
</ul>
<h2 id="whentouseeachmethod">When to Use Each Method</h2>
Use the <code>if</code> statement and <code>[[</code> operator if you need to perform a simple check for the presence of a substring and don't require any advanced pattern matching capabilities. This method is suitable for simple use cases and is easy to understand and implement.
Use the <code>grep</code> command if you need to perform more advanced pattern matching and text processing tasks, or if you prefer a more flexible and powerful tool. This method is suitable for more complex use cases and is a good choice if you're familiar with the grep command.
All-in-all, the choice between the two methods depends on the specific needs of your script and your personal preference. Both methods have their own advantages and disadvantages, and it's up to you to choose the one that best fits your requirements.
<h2 id="conclusion">Conclusion</h2>
In this article, we covered two methods for checking if a string contains a substring in Bash: using the <code>if</code> statement and the <code>[[</code> operator, and using the <code>grep</code> command.
In conclusion, both methods have their advantages and disadvantages, and it's up to you to choose the one that best fits your requirements. If you're performing a simple check for the presence of a substring, the <code>if</code> statement and the <code>[[</code> operator is a good choice. If you require more advanced pattern matching capabilities, the <code>grep</code> command is a better option.
In general, it's always a good idea to choose the simplest and most straightforward solution that meets your needs, as it will make your code easier to understand and maintain in the long run. Remember to consider your specific needs and choose the method that best fits your requirements.

In this short tutorial, learn how to check if a string contains another string (substring) in Bash, using the if statement, [[ operator and the grep command.

How to Check if String Contains Substring in Bash

<h2 id="introduction">Introduction</h2>
When developing a large application, it is always a good idea to break it down into smaller components to make the code easier to read, structure, and maintain. Most Vue beginners understand what components are at least conceptually, but they might not understand what they can and cannot do fully.
<blockquote>
In this guide, we'll take a look at what a component in Vue is, how it works, how to pass data and events through them and lots more.
</blockquote>
<h2 id="whatisavuecomponent">What is a Vue Component?</h2>
Components are reusable instances of Vue elements that include templates, styles, and JavaScript elements. Each component is &quot;its own thing&quot;, similar to how each HTML element is &quot;its own thing&quot;, and both Vue components and HTML elements allow us to use them as building blocks for web pages.
<blockquote>
You can think of Vue components as JavaScript-imbued HTML elements, that you can define and manipulate yourself.
</blockquote>
A typical Vue application is made up of numerous components that can be reused as many times as needed.
For example, a usual website has sections that appear on all pages - navbar, header, footer, and so on. Therefore, it's considered a good practice to make each of them a separate component. That way, we are creating well-structured, readable, reusable, and easily maintainable code:
<img src="https://s3.stackabuse.com/media/articles/introduction-to-vue-components-1.png" alt="">
<h2 id="howtocreateavuecomponent">How to Create a Vue Component</h2>
There are two basic ways to create a Vue component, depending on how our project was created - with or without a build setup. In the first case, every component is stored in a separate file. In the second case, there can be multiple components in a single file.

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: Explaining what is a build setup and how to perform it is far beyond the scope of this guide. If you want to learn more about Vue basics, the good place to start is the <a rel="nofollow noopener noreferrer" target="_blank" href="https://vuejs.org/guide/quick-start.html">&quot;Quick Start&quot;</a> article from the official Vue documentation.

 </div>
 </div>
 </div>
 <h3 id="createvuecomponentswithabuildsetup">Create Vue Components With a Build Setup</h3>
Most projects are created using the build setup, which enables us to create Single-File Components (SFCs) - dedicated component files with the <code>.vue</code> extension. This allows us to encapsulate a Vue component's template, logic, and styling in a single file:
<pre><code class="hljs">&lt;!-- Vue-specific JavaScript --&gt;
&lt;script&gt;
 export default {
 data() {
 return {
 title: &#x27;Hello World!&#x27;
 }
 }
 }
&lt;/script&gt;

&lt;!-- HTML Template --&gt;
&lt;template&gt;
 &lt;div&gt;
 &lt;p class=&quot;title&quot;&gt;{{ title }}&lt;/p&gt;
 &lt;/div&gt;
&lt;/template&gt;

&lt;!-- CSS Styling --&gt;
&lt;style&gt;
.title {
 color: red;
}
&lt;/style&gt;
</code></pre>

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: To avoid conflicts with existing and future HTML elements, it's always best to use multi-word names rather than single-word names when naming our components. This does not apply to built-in components such as the root component (<code>App</code>, <code>Transition</code>, and so on).

 </div>
 </div>
 </div>
 <h3 id="createvuecomponentswithoutabuildsetup">Create Vue Components Without a Build Setup</h3>
If you, for whatever reason, cannot use a package manager such as <code>npm</code> to install Vue on your machine, you can still use Vue in your app. An alternative to building Vue using <code>npm</code> is to install Vue via a CDN (Content Delivery Network) directly in your app. Let's just quickly go over this way of creating a Vue component.
Installing Vue without build will enable us to use Vue-specific functionalities as we do with plain JavaScript. The syntax is somewhat similar to what we've seen in the usual SFCs:
<pre><code class="hljs">export default {
 data() {
 return {
 title: &#x27;Hello World!&#x27;
 }
 },
 template: `
 &lt;div&gt;
 &lt;p class=&quot;title&quot;&gt;{{ title }}&lt;/p&gt;.
 &lt;/div&gt;`
}
</code></pre>
In this guide, we will be using the SFC syntax, as that is the most commonly used method of creating components.
<h2 id="howtoregistercomponentsinvue">How to Register Components in Vue</h2>
So far, we've seen how to create components in Vue. The next step will be to use these components within another component (parent-child hierarchy).
To do so, we must first register components we want to use. This registration entails importing and then registering components. There are two options for doing so - global and local registration.
<h3 id="vuecomponentsglobalregistration">Vue Components - Global Registration</h3>
Globally registered components, as the name implies, are available globally, which means they can be used in any component of our application without us having to import them again. This is accomplished by registering a component using the <code>app.component()</code> method:
<pre><code class="hljs">import ChildComponent from &#x27;./App.vue&#x27;

app.component(&#x27;ChildComponent&#x27;, ChildComponent)
</code></pre>
In a situation where we have many components, we can chain them this way:
<pre><code class="hljs">app
 .component(&#x27;ChildComponent&#x27;, ChildComponent)
 .component(&#x27;ProfileComponent&#x27;, ProfileComponent)
</code></pre>
After we've registered our components, we can use them in the template of any component within this application using the following syntax:
<pre><code class="hljs">&lt;ChildComponent/&gt;
&lt;ProfileComponent/&gt;
</code></pre>
<h3 id="vuecomponentslocalregistration">Vue Components - Local Registration</h3>
We will use local registration in most cases because it allows us to scope the availability of our registered components. Importing these components and then adding them to the <code>components</code> option accomplishes this:
<pre><code class="hljs">&lt;script&gt;
import ChildComponent from &#x27;./ChildComponent.vue&#x27;

export default {
 components: {
 ChildComponent
 }
}
&lt;/script&gt;

&lt;template&gt;
 &lt;ChildComponent /&gt;
&lt;/template&gt;
</code></pre>
When naming components, use CamelCase to make it clear that this is a Vue component rather than a native HTML element in templates. This also makes it easier to import and register components in JavaScript.

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: For referencing our registered component within the template, we typically use CamelCase or kebab-case tags - <code>&lt;MyComponent /&gt;</code> or <code>&lt;my-component /&gt;</code>, respectively.

 </div>
 </div>
 </div>
 <h2 id="howtopassdatathroughvuecomponents">How to Pass Data Through Vue Components</h2>
One of the benefits of creating components is the ability to reuse code by making it modular.
Assume we are creating a user's profile component that needs to receive each student's data from the profile page; in this case, we must pass this data down from the profile component (parent component) to the user-profile component (child component), and we will use props.
<h3 id="props">Props</h3>
Props are custom attributes we can register on a component, so we can pass data from the parent component to the child component using the <code>props</code> option within the script tag:
<pre><code class="hljs">&lt;script&gt;
export default {
 props: {
 title: String,
 }
}
&lt;/script&gt;

&lt;template&gt;
 &lt;h4&gt;{{ title }}&lt;/h4&gt;
&lt;/template&gt;
</code></pre>

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: You can learn more about props and how to pass different types of data from the parent component to the child component in <a target="_blank" href="https://stackabuse.com/guide-to-vue-props/">&quot;Guide to Vue Props&quot;</a>.

 </div>
 </div>
 </div>
 <h3 id="slots">Slots</h3>
Vue slots are reserved spaces that allow us to pass any type of content from one component to another. This gives more centralized control than props because, unlike props, the parent component controls the content inside the child component. For example, we could make the following button:
<pre><code class="hljs">&lt;!-- my-button.vue --&gt;
&lt;template&gt;
 &lt;button class=&quot;btn btn-style&quot;&gt;
 &lt;slot&gt;Click Me&lt;/slot&gt;
 &lt;/button&gt;
&lt;/template&gt;
</code></pre>
Then we can use this component anywhere we want and give it the content we desire. Failure to give it a content means it will make use of the default value we gave it (Click Me):
<pre><code class="hljs">&lt;!-- my-form.vue --&gt;
&lt;template&gt;
 &lt;my-button&gt;
 Submit Form &lt;img src=&quot;/img/icons/arrow-icon.jpg&quot;&gt;
 &lt;/my-button&gt;
&lt;/template&gt;
</code></pre>
<h2 id="howtoemiteventsfromvuecomponents">How to Emit Events from Vue Components</h2>
We learned that props are used to send data from the parent component down to the child component. But we might wonder if there was a way to send something from the child component to the parent component. And the answer is yes, events can be sent from the child component to the parent component too.
Assume we have a parent component (<code>App.vue</code>) that contains a single child component (<code>MyBlogPost.vue</code>). Furthermore, the child component contains a button which is supposed to change the title.
Assume we want to change the title of our page when a button is clicked, so that a function is triggered:
<pre><code class="hljs">&lt;!-- App.vue --&gt;
&lt;script&gt;
import MyBlogPost from &#x27;./BlogPost.vue&#x27;
 
export default {
 components: {
 MyBlogPost
 },
 data() {
 return {
 title: &quot;Hello World&quot;
 }
 },
 methods:{
 changeText: function(){
 this.title = &quot;New Title&quot;
 }
 }
}
&lt;/script&gt;

&lt;template&gt;
 &lt;div&gt;
 &lt;MyBlogPost :title=&quot;title&quot; @change-text=changeText&gt;&lt;/MyBlogPost&gt;
 &lt;/div&gt;
&lt;/template&gt;
</code></pre>
And the child component will look like this:
<pre><code class="hljs">&lt;!-- MyBlogPost.vue --&gt;
&lt;script&gt;
export default {
 props: [&#x27;title&#x27;],
 emits: [&#x27;change-text&#x27;]
}
&lt;/script&gt;

&lt;template&gt;
 &lt;div class=&quot;blog-post&quot;&gt;
 &lt;h4&gt;{{ title }}&lt;/h4&gt;
 &lt;button @click=&quot;$emit(&#x27;change-text&#x27;)&quot;&gt;Change Title&lt;/button&gt;
 &lt;/div&gt;
&lt;/template&gt;
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this guide, we've learned how to work with components in Vue, which is essential for anyone using Vue. We also learned how to send and receive data, as well as how to emit events.

Guest Contributor

In this short introduction - get up to speed on the basics of Vue components, how they work, what they are, how to pass props and emit events.

Introduction to Vue Components

<h2 id="introduction">Introduction</h2>
When creating a website or web application, especially if they feature a lot of templated content (such as a grid or list of items belonging to a category) - it's generally a good idea to divide it into pages to reduce the number of items that appear on the screen at once.
<blockquote>
In this article, we will learn how to implement pagination in our web projects using vanilla JavaScript from the ground up.
</blockquote>
For the purpose of this article, we will fetch the content from <a rel="nofollow noopener noreferrer" target="_blank" href="https://jsonplaceholder.typicode.com/posts">this</a> example API response. It contains 100 data points, but we'll only use 30 and display 6 posts on our screen at a time.
<img src="https://s3.stackabuse.com/media/articles/pagination-in-javascript-1.gif" alt="pagination-in-javascript-animation">
<h2 id="gettingstarted">Getting Started</h2>
Before fetching all required posts from the API using the browsers built-in Fetch API, we first need to create a basic HTML markup that will be dynamically filled via our script later:
<pre><code class="hljs">&lt;div class=&quot;container&quot;&gt;
 &lt;div class=&quot;title-section&quot;&gt;
 &lt;h1 class=&quot;title&quot;&gt;Posts&lt;/h1&gt;
 &lt;/div&gt;
 &lt;div class=&quot;posts-section&quot;&gt;&lt;/div&gt;
 &lt;div class=&quot;pagination-section&quot;&gt;
 &lt;ul class=&quot;pagination&quot;&gt;
 &lt;li class=&quot;page-item prev&quot;&gt;&lt;a class=&quot;page-link&quot; href=&quot;#&quot;&gt;Previous&lt;/a&gt;&lt;/li&gt;
 &lt;li class=&quot;page-item next&quot;&gt;&lt;a class=&quot;page-link&quot; href=&quot;#&quot;&gt;Next&lt;/a&gt;&lt;/li&gt;
 &lt;/ul&gt;
 &lt;/div&gt;
&lt;/div&gt;
</code></pre>
<h2 id="fetchingrestapiposts">Fetching REST API Posts</h2>
As mentioned before, pagination is all about splitting up content into smaller chunks. It requires you to fetch the data, decide when and how to split, calculate the number of pages, and then show a portion of it to the user. Thankfully - back-end functionality usually takes care of the first few tasks, and return the relevant page, total number of pages, and the content per page.

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: Depending on the specific API you're working with - you may or may not be able to lazy load results. Whenever possible - prefer lazy loading results instead of loading them all upfront. Most modern APIs follow practices that let you set a <code>limit</code> or <code>page</code> count, and return the total number of pages that you can display to the user.

 </div>
 </div>
 </div>
 Let's get started by first fetching all our posts and then later we will amend this to query only a few data points per page:
<pre><code class="hljs">const postsSection = document.querySelector(&quot;.posts-section&quot;);

const fetchPosts = async () =&gt; {
 const response = await fetch(
 &quot;https://jsonplaceholder.typicode.com/posts&quot;
 );
 const posts = await response.json();
 postsSection.innerHTML = &quot;&quot;;
 posts.forEach((post) =&gt; {
 postsSection.innerHTML += `
 &lt;div class=&quot;posts-card&quot;&gt;
 &lt;div class=&quot;post-title&quot;&gt;
 &lt;h2 class=&quot;post-title-text&quot;&gt;${post.title}&lt;/h2&gt;
 &lt;/div&gt;
 &lt;div class=&quot;post-body&quot;&gt;
 &lt;p class=&quot;post-body-text&quot;&gt;
 ${post.body}
 &lt;/p&gt;
 &lt;/div&gt;
 &lt;/div&gt; 
 `;
 });
};

fetchPosts();
</code></pre>
Let's quickly examine the code above. First of all, we began by obtaining the <code>div</code> element where we would be displaying all of our content via the <code>class</code> name we assigned to the <code>div</code>. Finally, we wrote a function to handle the fetch operation.
In the <code>fetchPosts()</code> function, we used the Fetch API to retrieve posts from the JSON Placeholder posts API, then store the JSON data referenced by the <code>posts</code> variable and used the <code>innerHTML</code> property to add each piece of content to the <code>posts-section</code> by looping through them.
At this point, we have successfully fetched all of our content.

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: You can also fetch the content using a different method, but make sure that all of your content is loaded on that page before we dive into creating the pagination.

 </div>
 </div>
 </div>
 <h2 id="howtoimplementpaginationinjavascript">How to Implement Pagination in JavaScript</h2>
Let's begin by declaring three variables that are critical for implementing pagination within our web page. The first one is the number of posts we want to declare per page, then the current page number (<code>1</code> by default), and the total number of pages.

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: When consuming data from a standard API and database, the total count of the pages or the data points is usually returned. If we don't receive a total page count, it can be calculated via the total object count and the page size.

 </div>
 </div>
 </div>
 For this guide we will give the total number of pages a fixed number of <code>30</code>:
<pre><code class="hljs">const numberPerPage = 6;
var pageNumber = 1;
var numberOfPages = 30;
</code></pre>
In the previous section, we've displayed all posts on a single page, but we want to show only six at a time. Therefore, we've set the <code>numberPerPage</code> to <code>6</code> which we will now use to adjust the fetch operation so it only displays <code>6</code> posts.
It depends on the specific implementation, but it's wide-spread practice to allow query parameters to be used when fetching results from APIs, that allow you to fetch a certain page of the results. For example the mock REST API that we're using allows for the <code>page</code> and <code>limit</code> parameters that let you only load batches that you'll show at a given time.
<blockquote>
This way, we only load the data we want to show to the user! We can then either pre-fetch the next page for faster loading time, or revel in the computational speedup achieved by only loading the data to be shown.
</blockquote>
We'll be making use of these parameters by amending our fetch request:
<pre><code class="hljs">const fetchPosts = async (pageNumber) =&gt; {
 const response = await fetch(
 `https://jsonplaceholder.typicode.com/posts?_page=${pageNumber}&amp;_limit=${numberPerPage}`
 );
 const posts = await response.json();
 postsSection.innerHTML = &quot;&quot;;
 posts.forEach((post) =&gt; {
 postsSection.innerHTML += `
 &lt;div class=&quot;posts-card&quot;&gt;
 &lt;div class=&quot;post-title&quot;&gt;
 &lt;h2 class=&quot;post-title-text&quot;&gt;${post.title}&lt;/h2&gt;
 &lt;/div&gt;
 &lt;div class=&quot;post-body&quot;&gt;
 &lt;p class=&quot;post-body-text&quot;&gt;
 ${post.body}
 &lt;/p&gt;
 &lt;/div&gt;
 &lt;/div&gt; 
 `;
 });
};

fetchPosts();
</code></pre>
In the above code, we added the two parameters to the API endpoint which are the <code>pageNumber</code> and the number of posts per page which would help us break our posts into several pages and then these posts can now be displayed based on the page number.
Additionally, we also passed in the <code>pageNumber</code> to the <code>fetchPosts()</code> function so we can call this function whenever the page changes:
<img src="https://s3.stackabuse.com/media/articles/pagination-in-javascript-2.png" alt="javascript-pagination-no-navigation">
<blockquote>
Let's now add functionality to the page navigation buttons at the bottom of our page and have them display appropriate content based on the page number.
</blockquote>
<h3 id="implementingpaginationlogic">Implementing Pagination Logic</h3>
We will notice that in the markup we had a section that showing the pagination buttons:
<pre><code class="hljs">&lt;div class=&quot;pagination-section&quot;&gt;
 &lt;ul class=&quot;pagination&quot;&gt;
 &lt;li class=&quot;page-item prev&quot;&gt;&lt;a class=&quot;page-link&quot; href=&quot;#&quot;&gt;Previous&lt;/a&gt;&lt;/li&gt;
 &lt;li class=&quot;page-item next&quot;&gt;&lt;a class=&quot;page-link&quot; href=&quot;#&quot;&gt;Next&lt;/a&gt;&lt;/li&gt;
 &lt;/ul&gt;
&lt;/div&gt;
</code></pre>
We are now going to add <code>click</code> events to each button so that when they are clicked, the content intended for that page appears.
<h4 id="implementingthepreviousbutton">Implementing the Previous Button</h4>
The logic here is pretty simple. All we have to do is to retrieve the element representing the previous button, add the <code>click</code> event listener to it and show the appropriate content when the button is clicked:
<pre><code class="hljs">// Add event listeners to the prev button
const prev = document.querySelector(&#x27;.prev&#x27;);
prev.addEventListener(&#x27;click&#x27;, (e) =&gt; {
 e.preventDefault();
 if (pageNumber &gt; 1) {
 pageNumber--;
 fetchPosts(pageNumber);
 }
});
</code></pre>
After adding a <code>click</code> event listener, we've checked if the current page number is greater than <code>1</code> in the call back function. If the number is equal to or less than <code>1</code>, we'll just keep showing the current content. But if the current page number is greater than <code>1</code> we can freely decrement its value and call the <code>fetchPosts(pageNumber)</code> function with the new page number passed in it as an argument, therefore showing the content of the previous page.
<h4 id="implementingthenextbutton">Implementing the Next Button</h4>
The logic here is completely the same as for the previous button, with just a few minor changes. Of course, we'll retrieve the list element with the class <code>next</code> instead of <code>prev</code>. Also, we'll check whether the current page number is less than the number of pages which we set to <code>30</code> manually earlier. In the end, we'll increment the current page number instead of decrementing it:
<pre><code class="hljs">// Add event listeners to the next button
const next = document.querySelector(&quot;.next&quot;);
next.addEventListener(&quot;click&quot;, (e) =&gt; {
 e.preventDefault();
 if (pageNumber &lt; numberOfPages) {
 pageNumber++;
 fetchPosts(pageNumber);
 }
});
</code></pre>
<h2 id="conclusion">Conclusion</h2>
Splitting content into smaller, more manageable chunks that are displayed individually is crucial whenever you try to display a database or any other data source on your web application.
In this article, we took a look at how to implement pagination with JavaScript from scratch, without any external libraries and tools.

In this comprehensive tutorial, we'll take a look at how to split the content up into individual pages in Vanilla JavaScript. We'll learn how to create pagination and how to navigate through the individual pages without the use of any external libraries.

Pagination in Vanilla JavaScript

<h2 id="introduction">Introduction</h2>
It is important to check for the existence of directories and files in Bash scripts for several reasons. Firstly, it allows the script to handle situations where the expected directories or files do not exist. This can prevent errors and unexpected behavior in the script - if a script expects a certain file to be present in a certain directory, and that file does not exist, the script will fail if it does not check for the file's existence first.
Secondly, checking for the existence of directories and files can help to ensure that the script is running in the correct environment. Some scripts are intended to run on a system with a specific directory structure or set of files. By checking for the existence of these directories and files, the script can ensure that it is running in the correct environment before attempting to execute its tasks.
Finally, checking for the existence of directories and files can help to make Bash scripts more efficient by avoiding unnecessary tasks. If a script does not need to create a new directory if it already exists, the script can check for the directory's existence first and only create it if necessary. This can save time and resources compared to blindly creating the directory every time the script is run.
<blockquote>
In this article, we'll take a look at several most common methods you can use to check if a file or directory exists in Bash.
</blockquote>
<h2 id="howtocheckifadirectoryexistsinbash">How to Check if a Directory Exists in Bash</h2>
There are several methods for checking for the existence of directories in Bash, and all of them are pretty similar to methods for checking for file existence. In this section, we'll take a look at several methods to do so. Each of the covered methods can be easily altered to check for the existence of files in Bash, too. But we'll go over that in the latter sections. For now, let's just focus on checking for the existence of a directory.
<h3 id="method1theifddirectorycommandoperator">Method 1: The if [ -d $directory ] Command ([ Operator)</h3>
The <code>if [ -d $directory ]</code> command can be used to check for the existence of a directory. If the specified directory exists, the command will return an exit status of <code>0</code> (<code>true</code>). If the directory does not exist, the command will return a non-zero exit status (<code>false</code>).
Let's take a look at the general syntax of the <code>[ -d $directory ]</code> command:
<pre><code class="hljs">if [ -d &quot;$directory&quot; ]
then
 # code to execute if $directory exists
else
 # code to execute if $directory does not exist
fi
</code></pre>

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: In this example, the <code>$directory</code> represents the name of the directory you want to check for.

 </div>
 </div>
 </div>
 As you probably guessed, if the directory exists, the code within the <code>then</code> block will be executed. If the directory does not exist, the code within the <code>else</code> block will be executed.
Now we can take a look at the practical example of how you might use this command in a Bash script:
<pre><code class="hljs"># Check if the /my-dir directory exists
directory=&quot;/my-dir&quot;
if [ -d &quot;$directory&quot; ]
then
 # The /my-dir directory exists, so print a message
 echo &quot;The /my-dir directory exists.&quot;
else
 # The /my-dir directory does not exist, so print a message and create it
 echo &quot;The /my-dir directory does not exist. Creating it now...&quot;
 mkdir $directory
fi
</code></pre>
The script first checks if the <code>/my-dir</code> directory exists. If it does, a message is printed to the console. If the <code>/my-dir</code> directory does not exist, a message is printed and the <code>/my-dir</code> directory is created using the <code>mkdir</code> command.

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: If you need to check if a directory/file does not exist you can just add the not logical operator (<code>!</code>) inside the <code>[</code> operator. For example: <code>if [ ! -d &quot;$directory&quot; ]</code>.

 </div>
 </div>
 </div>
 <h3 id="method2thetestcommand">Method 2: The test Command</h3>
To use the <code>test</code> command to check if a directory exists in Bash, you can use the following syntax:
<pre><code class="hljs">if test -d $directory
then
 # code to execute if $directory exists
else
 # code to execute if $directory does not exist
fi
</code></pre>
As in the previous example, the <code>$directory</code> represents the name of the directory you want to check for. If the directory exists, the code within the <code>then</code> block will be executed. If the directory does not exist, the code within the <code>else</code> block will be executed.
Here is an example of how you might use this command in a Bash script:
<pre><code class="hljs"># Check if the /my-dir directory exists
directory=&quot;/my-dir&quot;
if test -d $directory
then
 # The /my-dir directory exists, so print a message
 echo &quot;The /my-dir directory exists.&quot;
else
 # The /my-dir directory does not exist, so print a message and create it
 echo &quot;The /my-dir directory does not exist. Creating it now...&quot;
 mkdir $directory
fi
</code></pre>
Here, the script first checks if the <code>/my-dir</code> directory exists using the <code>test -d</code> command. If it does, a message is printed to the console. If the <code>/my-dir</code> directory does not exist, a message is printed and the <code>/my-dir</code> directory is created using the <code>mkdir</code> command.

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: The <code>[</code> operator is an alias for the <code>test</code> command in Bash, so you could also use the <code>[ -d $directory ]</code> syntax to achieve the same result.

 </div>
 </div>
 </div>
 <h3 id="method3theoperator">Method 3: The [[ Operator</h3>
To use the <code>[[</code> operator to check if a directory exists in Bash, you can use the syntax similar to one seen in previous methods:
<pre><code class="hljs">if [[ -d $directory ]]
then
 # code to execute if $directory exists
else
 # code to execute if $directory does not exist
fi
</code></pre>
You guessed it, the <code>$directory</code> represents the name of the directory you want to check for. As we've seen in previous sections, if the directory exists, the code within the <code>then</code> block will be executed. If the directory does not exist, the code within the <code>else</code> block will be executed.
Here is an example of how you might use <code>[[</code> operator in a Bash script:
<pre><code class="hljs"># Check if the /my-dir directory exists
directory=&quot;/my-dir&quot;
if [[ -d $directory ]]
then
 # The /my-dir directory exists, so print a message
 echo &quot;The /my-dir directory exists.&quot;
else
 # The /my-dir directory does not exist, so print a message and create it
 echo &quot;The /my-dir directory does not exist. Creating it now...&quot;
 mkdir $directory
fi
</code></pre>

 <div class="alert alert-reference">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-link-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: The <code>[[</code> operator is a more powerful version of the <code>[</code> operator, and is generally preferred in Bash scripts due to its additional features and improved syntax. However, the <code>[</code> and <code>[[</code> operators can generally be used interchangeably. If you are interested in a more in-depth overview of the differences between those two operators, you should read our <a target="_blank" href="https://stackabuse.com/bash-difference-between-and-operators/">&quot;Bash: Difference Between [ and [[ Operators&quot;</a>.

 </div>
 </div>
 </div>
 <h2 id="howtocheckifafileexistsinbash">How to Check if a File Exists in Bash</h2>
All of the above is pretty much applicable in the case you want to check if a file exists - there are only a few trivial changes that you need to perform in order to make previous scripts compatible with the new use case. Therefore, in this section, we won't dig deep into each method, we'll just go over code snippets that show exactly how to check for the file existence in Bash. Let's start with the <code>if [ -f $file ]</code> command.
<h3 id="method1theifffilecommand">Method 1: The if [-f $file] Command</h3>
The <code>if [ -f $file ]</code> command is the equivalent of the <code>if [ -d $directory ]</code> command. They are pretty much the same, apart from the <code>-f</code> and <code>-d</code> arguments:
<pre><code class="hljs"># Check if the &#x27;my-file.txt&#x27; exists
file=&quot;/my-file.txt&quot;
if [ -f &quot;$file&quot; ]
then
 # The &#x27;my-file.txt&#x27; exists, so print a message
 echo &quot;The &#x27;my-file.txt exists.&quot;
else
 # The &#x27;my-file.txt&#x27; does not exist, so print a message and create it
 echo &quot;The &#x27;my-file.txt&#x27; does not exist. Creating it now...&quot;
 mkdir $file
fi
</code></pre>
<h3 id="method2thetestcommand">Method 2: The test Command</h3>
Also, the <code>test</code> command used to check for the existence of directories can be used to verify the (non)existence of a file:
<pre><code class="hljs"># Check if the &#x27;my-file.txt&#x27; directory exists
file=&quot;my-file.txt&quot;
if test -f $file
then
 # The &#x27;my-file.txt&#x27; file exists, so print a message
 echo &quot;The &#x27;my-file.txt&#x27; file exists.&quot;
else
 # The &#x27;my-file.txt&#x27; file does not exist, so print a message and create it
 echo &quot;The &#x27;my-file.txt&#x27; file does not exist. Creating it now...&quot;
 mkdir $file
fi
</code></pre>
<h3 id="method3theoperator">Method 3: The [[ Operator</h3>
And, finally, the <code>[[</code> can also be used for the purpose of checking if a file exists in Bash:
<pre><code class="hljs"># Check if the &#x27;my-file.txt&#x27; file exists
file=&quot;my-file.txt&quot;
if [[ -d $file ]]
then
 # The &#x27;my-file.txt&#x27; file exists, so print a message
 echo &quot;The &#x27;my-file.txt&#x27; file exists.&quot;
else
 # The &#x27;my-file.txt&#x27; file does not exist, so print a message and create it
 echo &quot;The &#x27;my-file.txt&#x27; file does not exist. Creating it now...&quot;
 mkdir $file
fi
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In conclusion, being able to check if a file or directory exists in Bash is a crucial skill for any Linux administrator or developer. The main methods we've discussed in this article are <code>[</code> and <code>[[</code> operators, as well as the <code>test</code> command in Bash. Additionally, the <code>ls</code> command can also be used to check for file or directory existence, although it is less efficient and less versatile. By understanding and utilizing these methods, you will be able to easily check for file or directory existence in Bash and take appropriate actions based on the outcome.

In this tutorial, learn how to check whether a file or directory exists in Bash, with practical examples, best practices and comparisons of methods.

Bash: Check if Directory or File Exists

<h2 id="introduction">Introduction</h2>
In bash, the <code>[</code> and <code>[[</code> operators are used for comparison and testing. The <code>[</code> operator is an alias for the <code>test</code> command, which is used to check the properties of files or to compare strings or integers. The <code>[[</code> operator is a more advanced version of the test command. It allows you to perform more powerful comparisons and tests, such as regular expression matching and string manipulation.
<blockquote>
In this article, we'll take a look at the difference between those very similar operators in Bash. We'll assume you already know the basics of both operators, and you just want to make an educated decision on when to use which one.
</blockquote>
<h2 id="operatorbacktobasics">[ Operator - Back to Basics</h2>
The <code>[</code> operator, also known as the test command, is a built-in command in bash that is used to perform various tests on files and strings. It can be used to check for the existence of files, compare values, and test the properties of strings. The operator must be enclosed in a whitespace or be escaped with a backslash.
Let's quickly take a look at the basic syntax for the <code>[</code> operator:
<pre><code class="hljs">if [ expression ]
then
 # commands to execute if expression is true
else
 # commands to execute if expression is false
fi
</code></pre>
Here, <code>expression</code> is a combination of options and arguments that are used to perform the test. Some common options used with the <code>[</code> operator include:
<ul>
<li><code>-e file</code> to check if a file exists</li>
<li><code>-f file</code> to check if a file is a regular file</li>
<li><code>-d file</code> to check if a file is a directory</li>
<li><code>-z string</code> to check if a string has a length of 0</li>
<li><code>-n string</code> to check if a string has a non-zero length</li>
</ul>
<h2 id="operatorbacktobasics">[[ Operator - Back to Basics</h2>
The <code>[[</code> operator is an extended version of the <code>[</code> operator in Bash. It is used to perform various tests and arithmetic operations, and has a more flexible syntax. It is not as strictly dependent on whitespace or backslashes around it, as the <code>[</code> operator.
The basic syntax for the <code>[[</code> operator is almost identical to the <code>[</code> operator syntax we've discussed above:
<pre><code class="hljs">if [[ expression ]]
then
 # commands to execute if expression is true
else
 # commands to execute if expression is false
fi
</code></pre>
The <code>expression</code> is a combination of options and arguments that are used to perform the test. The basic options are the same as the ones we've listed in the previous section when talking about the <code>[</code> operator.
In addition to these options, the <code>[[</code> operator supports additional string and arithmetic operations such as regular expressions matching, logical and/or operators, and comparison operators without the need for <code>-eq</code>, <code>-lt</code>, etc:
<pre><code class="hljs">if [[ $string =~ &quot;regex&quot; ]]
then
 echo &quot;string matches the regex&quot;
fi
</code></pre>
<pre><code class="hljs">if [[ $x &gt; 5 &amp;&amp; $y &lt; 10 ]]
then
 echo &quot; x is greater than 5 and y is less than 10&quot;
fi
</code></pre>
The <code>[[</code> operator also supports the assignment and arithmetic operations, this makes it more versatile than the <code>[</code> operator:
<pre><code class="hljs">if [[ ( x+=5) -lt 10 ]]
then
 echo &quot;x is now less than 10&quot;
fi
</code></pre>
Overall, the <code>[[</code> operator is a more recent addition to Bash and is more powerful than <code>[</code> operator in terms of functionality and flexibility, it offers improved readability, better performance, and additional functionality to perform various tests and operations.

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: Be aware that the behavior of <code>[[</code> might be slightly different than <code>[</code> operator, so it's important to check the documentation if you are not sure which to use!

 </div>
 </div>
 </div>
 <h2 id="andoperatorsheadtoheadcomparison">[ and [[ Operators - Head to Head Comparison</h2>
Now, after we recapped the basics of both operators, we can compare them head-to-head. Let's take a look at several use cases of <code>[</code> and <code>[[</code> operators and compare the syntax.
First of all, take a look at the example where we want to check for the existence of the <code>file.txt</code>:
<pre><code class="hljs"># Using the &quot;[&quot; operator
if [ -e &quot;file.txt&quot; ]
then
 echo &quot;file.txt exists&quot;
fi

# Using the &quot;[[&quot; operator
if [[ -e &quot;file.txt&quot; ]]
then
 echo &quot;file.txt exists&quot;
fi
</code></pre>
Pretty much the same! Both of the above code samples check if the file <code>file.txt</code> exists and print a message if it does. However, while the <code>[</code> operator requires whitespace or a backslash around it, the <code>[[</code> operator does not.

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: The <code>[</code> operator is the alias for the <code>test</code> built-in function in Bash, and all of the built-in functions accept arguments as an array of whitespace-separated strings. That's why the <code>[</code> operator requires whitespaces around each of its arguments!

 </div>
 </div>
 </div>
 The previous example wasn't sufficient at illustrating the need for whitespaces when using the <code>[</code> operator, so, let's choose another, more illustrative example. We'll compare two strings that are the same, and expect the script to return <code>&quot;Equal&quot;</code>:
<pre><code class="hljs">str1=&quot;My String&quot;

# Using the &quot;[&quot; operator WITHOUT whitespaces
# This will return &quot;Not equal&quot; even though two strings are the same
if [ &quot;$str1&quot;=&quot;$str1&quot; ] 
then 
 echo &quot;Equal&quot; 
else 
 echo &quot;Not equal&quot;
fi

# Using the &quot;[&quot; operator WITH whitespaces
# This will return &quot;Equal&quot;, as expected
if [ &quot;$str1&quot; = &quot;$str1&quot; ] 
then 
 echo &quot;Equal&quot; 
else 
 echo &quot;Not equal&quot;
fi

# Using the &quot;[[&quot; operator WITHOUT whitespaces
# This will return &quot;Equal&quot;, as expected
# Even without whitespaces
if [ &quot;$str1&quot;=&quot;$str1&quot; ] 
then 
 echo &quot;Equal&quot; 
else 
 echo &quot;Not equal&quot;
fi
</code></pre>
Another interesting difference between <code>[</code> and <code>[[</code> is that the <code>[[</code> operator supports more operators than <code>[</code>. For example, it can use the <code>==</code> comparison operator rather than the <code>-eq</code> operator used with <code>[</code>:
<pre><code class="hljs"># Using the &quot;[&quot; operator
if [ $x -eq 5 ]
then
 echo &quot;x is equal to 5&quot;
fi

# Using the &quot;[[&quot; operator
if [[ $x == 5 ]]
then
 echo &quot;x is equal to 5&quot;
fi
</code></pre>
Both of the above code samples check if the variable <code>x</code> is equal to <code>5</code> and print a message if it does. The first code sample uses the <code>-eq</code> operator with the <code>[</code> operator and the second code sample uses the <code>==</code> operator with the <code>[[</code> operator to check for equality.

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: The same can be applied to <code>-lt</code> and <code>&lt;</code>, <code>-gt</code> and <code>&gt;</code>, and other operators mentioned in the sections above.

 </div>
 </div>
 </div>
 Another handy feature of the <code>[[</code> operator is that we don't need to wrap strings with quotes when using <code>[[</code>:
<pre><code class="hljs"># Using the &quot;[&quot; operator
if [ -z &quot;$string&quot; ]
then
 echo &quot;string is empty&quot;
fi

# Using the &quot;[[&quot; operator
if [[ -z $string ]]
then
 echo &quot;string is empty&quot;
fi
</code></pre>
Both of the above code samples check if the variable <code>string</code> has a length of <code>0</code> and print a message if it does. However, while the <code>[</code> operator requires that <code>string</code> be enclosed in quotes(<code>&quot;&quot;</code>), the <code>[[</code> operator doesn't.
In general, the <code>[[</code> operator offers more functionality, improved readability, and better performance than the <code>[</code> operator. The <code>[[</code> operator supports additional string and arithmetic operations, regular expressions, logical and/or operators, and comparison operators without the need for <code>-eq</code>, <code>-lt</code>, etc, assignment and arithmetic operation, allowing for more complex and powerful tests in Bash scripts.

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: It is important to note that the behavior of <code>[[</code> might be slightly different than <code>[</code> operator and in certain scenarios <code>[</code> is more appropriate to use - most notably when you need to run your scripts on old systems.

 </div>
 </div>
 </div>
 <h3 id="comparisonrecap">Comparison Recap</h3>
Finally, let's recap several key differences in functionality and performance between the <code>[</code> and <code>[[</code> operators in bash.
Functionality
<ul>
<li>
The <code>[</code> operator is a synonym for the <code>test</code> command and is used to perform tests on files and strings. It supports a limited set of options and has a more restrictive syntax.
</li>
<li>
The <code>[[</code> operator is an extended version of the <code>[</code> operator, and is more powerful in terms of functionality. It supports additional string and arithmetic operations, regular expressions, logical and/or operators, and comparison operators without the need for <code>-eq</code>, <code>-lt</code>, etc, assignment and arithmetic operations, allowing for more complex and powerful tests in Bash scripts. It also allows more flexible syntax.
</li>
</ul>
Performance
<ul>
<li>
The <code>[</code> operator is generally considered to be slower than the <code>[[</code> operator as it requires more parsing, and also requires whitespace or backslashes around it, which can lead to additional overhead.
</li>
<li>
The <code>[[</code> operator, on the other hand, is faster and more efficient, as it has a more flexible syntax and does not require additional characters for parsing.
</li>
</ul>
Compatibility
<ul>
<li>
The <code>[[</code> operator is a more recent addition to Bash, and as such, it is not always guaranteed to be available on older systems. It is mostly used in more recent versions of Bash.
</li>
<li>
The <code>[</code> operator, on the other hand, has been around for a longer time and is widely supported across different systems.
</li>
</ul>
<h2 id="conclusion">Conclusion</h2>
All-in-all, after reading this article you'll be able to make an educated decision on what operator suits your needs the best.
Both operators are used to perform tests and make decisions in Bash scripts. In general, it's recommended to use <code>[[</code> operator for improved functionality, readability, and performance. However, in the case of scripts that need to be run on older systems or cross-platform, it is better to stick with the <code>[</code> operator, as it is more widely supported.

In this in-depth guide - learn about the difference between the [ and [[ operators in Bash, and how to use the nuanced differences to your advantage.