David Landup

Dimitrije Stamenic

Uchechukwu Azubuko

In this in-depth guide, we will create a React app and cover a complete guide to how we can perform unit tests on the React application using _Jest_ and _React Testing Library_ so that you can hone your testing skills and learn how to create a tame React application.

Definitive Guide to Unit Testing in React Applications with Jest and React-Testing

<h2 id="introduction">Introduction</h2>
The security of users and their personal data while using a web application is paramount. While this guiding principle has been acknowledged even from the early stages of web development - bad actors find loopholes in applications, and may exploit your users.
<blockquote>
Many &quot;standard&quot; attacks are well-known and documented, and protection from them isn't hard. To unburden the developer from implementing security practices themselves, frameworks like Spring Boot have abstracted away various security measures and allow you to simply apply security filters in your applications to prevent well-known attacks.
</blockquote>
In this short guide, we'll take a look at what Cross-Site Scripting (XSS) is, how someone could perform this attack on your own application, and how you can prevent it easily with Spring Boot.
<h2 id="whatiscrosssitescriptingxss">What is Cross-Site Scripting (XSS)?</h2>
Cross-Site Scripting is a well-known, widely spread exploit, in which a bad actor injects a script into a web application.
Typically, a same-origin policy is applied to web applications, which restricts scripts in a web page to access data from sources if their origins don't match. Under the same-origin policy - if a page from a trusted website may access data interfacing with the user (such as cookies, for example), other pages from the same origin may do so as well. This form of access-control seemed sufficient to protect the integrity of data on web applications at the time.
Cross-Site Scripting circumvents the same-origin policy, by injecting a malicious script into a trusted website's page. Since the script is run from a trusted website, it's executed as a trusted script. There was no clear-cut way to differentiate between malicious scripts and non-malicious scripts - so arbitrary code execution was possible with Cross-Site Scripting. This ranges anywhere from inserting annoying alerts, to social engineering attacks, silently collecting user information, or redirecting users to phishing pages that appear to be parts of trusted websites.
Many websites are susceptible to Cross-Site Scripting attacks, and it remains a common attack today, even though this type of exploit has been known since the 90s.
<h2 id="preventingxssinaspringbootapplicationwithcontentsecuritypolicycsp">Preventing XSS in a Spring Boot Application with Content-Security Policy (CSP)</h2>
Spring Boot takes security seriously, and Spring's Security module implements flexible and powerful security practices that allows developers to minimize their worry when it comes to security, which oftentimes requires a low-level understanding of the principles of the way messages are being exchanged in a web application.
By default, Spring Boot implements several security headers:
<pre><code class="hljs">Cache-Control: no-cache, no-store, max-age=0, must-revalidate
Pragma: no-cache
Expires: 0
X-Content-Type-Options: nosniff
Strict-Transport-Security: max-age=31536000 ; includeSubDomains
X-Frame-Options: DENY
X-XSS-Protection: 1; mode=block
</code></pre>
X-XSS-Protection is included by default! This security header attempts to detect XSS attempts, and blocks them. This isn't a fail-proof process though, and browsers have different implementations of detectors. Some browsers, like Chrome, have even removed their XSS Auditor. Additionally, the automated detection works for Reflected XSS Attacks, while other types of attacks also exist.
A more modern alternative to X-XSS-Protection is the Content-Security Policy (CSP), which primarily deal with policies on which resources can be loaded, from which origins, and at which endpoints. As of 2022, CSP is the best prevention measure against XSS, Clickjacking and other types of attacks. Not all browsers implement CSP, which is why it's not included in the security headers by default.

 <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: Even with CSP in place, it's always the best course of action to validate any user input and make sure that it's safe to process using your system, to prevent code injection.

 </div>
 </div>
 </div>
 In Spring Boot - to configure custom web security measures, you'll typically extend the <code>WebSecurityConfigurerAdapter</code> class, and override the <code>configure()</code> method:
<pre><code class="hljs">@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

@Override
protected void configure(HttpSecurity http) throws Exception {
 http
 .headers()
 .contentSecurityPolicy(&quot;csp-directives&quot;);
 }
}
</code></pre>
Where the content security policy directives (supplied as a <code>;</code>-separated string) depend on your use-case and which sources you wish to trust:
<pre><code class="hljs">Content-Security Policy: directive1; directive2; directive3; ... directiveN;
</code></pre>
For example, a web application can list trusted websites from which scripts can be loaded with:
<pre><code class="hljs">script-src https://trusted.com;
</code></pre>
Or you can skip trusting any third-party website:
<pre><code class="hljs">script-src self;
</code></pre>
Similarly, an application can trust plugins:
<pre><code class="hljs">object-src https://trusted.com
</code></pre>
There's a wide variety of directives you can supply, including:
<ul>
<li><code>default-src</code> - Default fallback</li>
<li><code>child-src</code> - Valid web worker sources</li>
<li><code>frame-src</code> - Valid sources for <code>&lt;frame&gt;</code>s and <code>&lt;iframe&gt;</code>s</li>
<li><code>img-src</code> - Valid sources for images</li>
<li><code>media-src</code> - Valid sources for <code>&lt;audio&gt;</code>, <code>&lt;video&gt;</code> and <code>&lt;track&gt;</code> tags</li>
<li><code>script-src</code> - Valid script sources (helps prevent XSS)</li>
<li><code>style-src</code> - Valid sources for <code>&lt;style&gt;</code> elements</li>
<li><code>base-uri</code> - Restricts resources accessible from the <code>&lt;base&gt;</code> element</li>
<li><code>frame-ancestors</code> - Valid parents of <code>&lt;frame&gt;</code> <code>&lt;iframe&gt;</code>, <code>&lt;embed&gt;</code>, <code>&lt;applet&gt;</code>, etc. elements</li>
<li>etc.</li>
</ul>

 <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 the full list of accepted CSP directives, take a look at <a target="_blank" rel="nofollow noopener noreferrer" href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy">MDN's Documentation</a>.

 </div>
 </div>
 </div>
 For example, here's a safe set of policy directives:
<pre><code class="hljs">script-src &#x27;strict-dynamic&#x27; &#x27;nonce-rAnd0m123&#x27; &#x27;unsafe-inline&#x27; http: https:;
object-src &#x27;none&#x27;;
base-uri &#x27;none&#x27;;
require-trusted-types-for &#x27;script&#x27;;
report-uri https://csp.example.com;
</code></pre>
Let's add these to our Spring Boot application:
<pre><code class="hljs">@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

@Override
protected void configure(HttpSecurity http) throws Exception {
 http
 .headers()
 .contentSecurityPolicy(&quot;script-src &#x27;strict-dynamic&#x27; &#x27;nonce-rAnd0m123&#x27; &#x27;unsafe-inline&#x27; http: https:; object-src &#x27;none&#x27;; base-uri &#x27;none&#x27;; require-trusted-types-for &#x27;script&#x27;; report-uri https://csp.example.com;&quot;);
 }
}
</code></pre>
You can use the <a rel="nofollow noopener noreferrer" target="_blank" href="https://csp-evaluator.withgoogle.com/">CSP-Evaluator</a> to evaluate whether your CSP directives are valid and safe, and it'll point out which directives are easily exploitable. Here's a CSP-directive that allows for Google APIs:
<pre><code class="hljs">default-src &#x27;self&#x27;;
object-src &#x27;none&#x27;;
frame-src &#x27;self&#x27; data:; 
script-src &#x27;self&#x27; &#x27;strict-dynamic&#x27; &#x27;nonce-rAnd0m123&#x27; &#x27;unsafe-inline&#x27; https://storage.googleapis.com; 
style-src &#x27;self&#x27; &#x27;unsafe-inline&#x27;; 
img-src &#x27;self&#x27; data:; 
font-src &#x27;self&#x27; data:;
base-uri &#x27;self&#x27;
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this short guide, we've taken a look at what Cross-Site Scripting (XSS) is, and how it works at a holistic level. Then, we've explored some XSS prevention measures that can easily be implemented with Spring Boot to make your applications safe, and set a Content-Security Policy (CSP).
Finally, we've explored CSP directives and took a look at a couple of different safe policies.

In this short guide, learn how to make your Java-based Spring Boot application safe against cross-site scripting (XSS) attacks, using CSP (Content-Safety Policy) and learn about CSP directives.

Prevent Cross-Site Scripting (XSS) in Spring Boot with Content-Security Policies (CSPs)

Cássia Sampaio

In this practical, hands-on, in-depth guide - learn everything you need to know about decision trees, ensembling them into random forests and going through an end-to-end mini project using Python and Scikit-Learn.

Definitive Guide to the Random Forest Algorithm with Python and Scikit-Learn

Guest Contributor

In this guide - learn how to check whether a string contains a digit, number, numeric representation or decimal using various methods, map(), any(), RegEx and lambda functions in Python, with performance benchmarks!

Check if String Contains a Number in Python

Scott Robinson

In this tutorial, you'll learn how to parse, read, and write JSON to files in Python through examples, using load(), loads(), dump() and dumps() methods. We'll also cover pretty-printing and sorting, enabling or disabling NaN checks, circular references, etc.

Reading and Writing JSON to a File in Python

Arpendu Kumar Garai

In this in-depth guide, learn all you need to know about setting up and using AWS Simple Email Service (SES) in Java with Spring Boot and Spring Cloud.

Guide to Simple Email Service (AWS SES) with Spring Boot and Spring Cloud

In this guide - learn how to properly handle exceptions and errors in Express/Node in JavaScript, with practical code samples and best practices.

Guide to Exception Handling in Express

<h2 id="introduction">Introduction</h2>
The Random Forest algorithm is a tree-based supervised learning algorithm that uses an ensemble of predictions of many decision trees, either to classify a data point or determine its approximate value. This means it can either be used for classification or regression.
When applied for classification, the class of the data point is chosen based on the class that was most voted by the trees; and when applied for regression, the value of the data point is the average of all the values output by the trees.
<blockquote>
An important thing to remember when using Random Forests is that the number of trees is a hyperparameter and it will be defined before running the model.
</blockquote>
When working in data science, one of the reasons why a Random Forest model was chosen for a specific project might have to do with the ability to look at ensembled trees and understand why a classification was made, or why a value was given - this is called explainability.
Considering tree based algorithms, attempting to explain a model can done in several ways, by displaying and looking at each tree (can be hard if the model has 200 trees or more), using <a target="_blank" rel="nofollow noopener noreferrer" href="https://shap.readthedocs.io/en/latest/index.html">Shapley (or SHAP) values</a>, looking at the features that were most taken into consideration by the model, using <a target="_blank" rel="nofollow noopener noreferrer" href="https://github.com/marcotcr/lime">LIME</a> to investigate the relationships between model input and output, etc. Usually, a combination of all methods is employed.
<blockquote>
In this quick guide, we will focus on creating a chart of the features that were considered important for the model to make a decision when classifying penguins. This is known as investigating the feature importance, and can be conveyed to other members of the team (technical and non-technical) to offer a glimpse into how decisions are made.
</blockquote>

 <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">
 Advice: If you'd like to read an in-depth guide to Random Forest, read our <a target="_blank" href="https://stackabuse.com/random-forest-algorithm-with-python-and-scikit-learn/">&quot;Guide to Random Forest Algorithm with Python and Scikit-Learn&quot;</a>!

 </div>
 </div>
 </div>
 To do this, let's import the necessary libraries, load the Palmer Penguins dataset, split the data, create the model, obtain the feature importances, and use Seaborn to plot them! We won't delve much on the data, EDA, or the model itself - those are the topic of the dedicated guide.

 <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 download the dataset from <a target="_blank" href="https://gist.github.com/cassiasamp/197b4e070f5f4da890ca4d226d088d1f">GitHub</a> or directly from the code.

 </div>
 </div>
 </div>
 <h2 id="importinglibraries">Importing Libraries</h2>
Let's start by importing a few libraries that we'll be using:
<pre><code class="hljs"># Importing libraries
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier

# Loading the dataset
raw_data_url = &quot;https://gist.githubusercontent.com/cassiasamp/197b4e070f5f4da890ca4d226d088d1f/raw/38c9d4906ed121481b4dc201fa2004f2b3d0065f/penguins.csv&quot;
df = pd.read_csv(raw_data_url)
</code></pre>
<h2 id="splittingthedata">Splitting the Data</h2>
Let's split the data for training and testing:
<pre><code class="hljs"># Removing NaN values, and duplicated index column `rowid`
df = df.dropna().drop(&quot;rowid&quot;, axis=1)

# Splitting data into X (features) and y (target)
y = df[&quot;species&quot;]
X = df[[&quot;bill_length_mm&quot;, &quot;bill_depth_mm&quot;, &quot;flipper_length_mm&quot;]]

# Splitting data into train and test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)
</code></pre>
<h2 id="obtainingfeatureimportances">Obtaining Feature Importances</h2>
Finally - we can train a model and export the feature importances with:
<pre><code class="hljs"># Creating Random Forest (rf) model with default values
rf = RandomForestClassifier()

# Fitting model to train data
rf.fit(X_train, y_train)

# Obtaining feature importances
rf.feature_importances_
</code></pre>
This outputs:
<pre><code class="hljs">array([0.41267633, 0.30107056, 0.28625311])
</code></pre>
Those are the feature values, to see feature names, run:
<pre><code class="hljs"># Obtaining feature names
rf.feature_names_in_
</code></pre>
This results in the corresponding name of each feature:
<pre><code class="hljs">array([&#x27;bill_length_mm&#x27;, &#x27;bill_depth_mm&#x27;, &#x27;flipper_length_mm&#x27;],
 dtype=object)
</code></pre>
This means that the most important feature for deciding penguin classes for this particular model was the <code>bill_length_mm</code>!
The importance is relative to the measure of how well the data is being separated in each node split - in this case, the measure is given by the Gini Index - the Gini value is then weighted by how many rows have been split when using the <code>bill_length_mm</code> feature and averaged over the 100 trees in the ensemble. The result of those steps account for <code>0.41267633</code>, or more than 40% in this case.
<h2 id="visualizingfeatureimportance">Visualizing Feature Importance</h2>
A common way of representing importance values is by using bar charts. Let's first create a dataframe with the feature names and their corresponding importances, and then visualize them using Seaborn's <code>barplot()</code>:
<pre><code class="hljs"># Creating importances_df dataframe
importances_df = pd.DataFrame({&quot;feature_names&quot; : rf.feature_names_in_, 
 &quot;importances&quot; : rf.feature_importances_})
 
# Plotting bar chart, g is from graph
g = sns.barplot(x=importances_df[&quot;feature_names&quot;], 
 y=importances_df[&quot;importances&quot;])
g.set_title(&quot;Feature importances&quot;, fontsize=14); 
</code></pre>
<img src="https://s3.stackabuse.com/media/articles/feature-importances-chart-1.png" alt="">

 <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">
 Advice: A good practice when presenting information is to order values either in ascending or descending order. In this case, the data is already ordered, with the first value being the first we want to know. When this isn't the case, you can order the dataframe with <code>sort_values</code>. This can be done on any column in ascending or descending order: <code>importances_df.sort_values(by=&quot;importances&quot;, ascending=False)</code>.

 </div>
 </div>
 </div>
 When looking at this first plot, it's harder to interpret the value of each feature's importance. It is obvious that the bill length is larger than the other two bars, but not exactly that the <code>bill_depth_mm</code> is equivalent to <code>0.30107056</code>, and that the <code>flipper_length_mm</code> is 0.28625311. So, this first chart can be improved by displaying the value of each bar. This can be done by accessing Seaborn's <code>containers</code> object. It stores each bar information and passing the values as bar labels:
<pre><code class="hljs">g = sns.barplot(data=importances_df, 
 x=&quot;importances&quot;, 
 y=&quot;feature_names&quot;)
g.set_title(&quot;Feature importances&quot;, fontsize=14)
for value in g.containers:
 g.bar_label(value)
</code></pre>
<img src="https://s3.stackabuse.com/media/articles/feature-importances-chart-2.png" alt="">
Now, we can see each importance value clearly, or almost clearly, because the <code>bill_length_mm</code> value is being cut by a vertical line that is part of the chart's outer border. Borders are used to enclose an area as a means of focusing more attention on it, but in this case, we don't need to enclose, because there is only one graph. Let's remove the border and improve the numbers' readability:
<pre><code class="hljs">g = sns.barplot(data=importances_df, 
 x=&quot;importances&quot;, 
 y=&quot;feature_names&quot;)
 
# removing the borders with despine
sns.despine(bottom=True, left=True)
g.set_title(&quot;Feature importances&quot;, fontsize=14)
for value in g.containers:
 g.bar_label(value)
</code></pre>
<img src="https://s3.stackabuse.com/media/articles/feature-importances-chart-3.png" alt="">
The chart seems easier to read, but the ticks on the X-axis seem to be floating and we already have the values along with the bars, so we can remove the <code>xticks</code>:
<pre><code class="hljs">g = sns.barplot(data=importances_df, 
 x=&quot;importances&quot;, 
 y=&quot;feature_names&quot;)
sns.despine(bottom=True, left=True)

# setting x ticks as empty
g.set(xticks=[])
g.set_title(&quot;Feature importances&quot;, fontsize=14)
for value in g.containers:
 g.bar_label(value)
</code></pre>
<img src="https://s3.stackabuse.com/media/articles/feature-importances-chart-4.png" alt="">
Notice how after removing the ticks, the Y and X labels are a bit hard to read. The Y-label, <code>feature_names</code>, is vertical and in the X-axis, there are only <code>importances</code>. Since the title already states that the chart is of Feature importances, we can also remove the axis labels:
<pre><code class="hljs">g = sns.barplot(data=importances_df, 
 x=&quot;importances&quot;, 
 y=&quot;feature_names&quot;)
sns.despine(bottom=True, left=True)
g.set_title(&quot;Feature importances&quot;, fontsize=14)
g.set(xticks=[])

# removing x and y axis labels by setting them to None
g.set(xlabel=None)
g.set(ylabel=None)
for value in g.containers:
 g.bar_label(value)
</code></pre>
<img src="https://s3.stackabuse.com/media/articles/feature-importances-chart-5.png" alt="">
You can see how this chart is cleaner, easier to read and understand when compared with the first one. There are still some things we can do. Observe that the numbers are really close to the bars, it would be easier to read if there was a little more space between them.
Another element in this plot are the colors, when contrasting colors are used, it transmits an idea of separation, on the other way around, when similar colors are used, they communicate an idea of unity, or parts of a whole. Since the features are all part of penguins, we can use a colors that makes each bar distinct while maintaining unity:
<pre><code class="hljs">g = sns.barplot(data=importances_df, 
 x=&quot;importances&quot;, 
 y=&quot;feature_names&quot;,
 
 # adding mako palette
 palette=&quot;mako&quot;)
sns.despine(bottom=True, left=True)
g.set_title(&quot;Feature importances&quot;, fontsize=14)
g.set(xticks=[])
g.set(xlabel=None)
g.set(ylabel=None)
for value in g.containers:
 g.bar_label(value, 
 padding=2) # adding space (padding) between bars and values
</code></pre>
<img src="https://s3.stackabuse.com/media/articles/feature-importances-chart-6.png" alt="">
If you want to make the results even more direct, you can change the title and add the conclusion. What is known is that the bill length was considered the most important feature according to the criteria we have previously discussed. This can be the first information for someone that looks at the plot, we could say that the penguin's bill length was the most important feature for species classification in the Random Forest (RF) base model :
<pre><code class="hljs">g = sns.barplot(data=importances_df, 
 x=&quot;importances&quot;, 
 y=&quot;feature_names&quot;, 
 palette=&quot;mako&quot;)
sns.despine(bottom=True, left=True)
g.set_title(&quot;The penguin&#x27;s bill length was the most important feature for species classification (RF base model)&quot;, fontsize=14)
g.set(xticks=[])
g.set(xlabel=None)
g.set(ylabel=None)
for value in g.containers:
 g.bar_label(value, padding=2)
</code></pre>
This is the final result of the feature importances chart:
<img src="https://s3.stackabuse.com/media/articles/feature-importances-chart-7.png" alt="">
<h2 id="conclusion">Conclusion</h2>
In this guide - we've built a Random Forest Classifier - and inspected the feature importances that were used to train the model in an attempt to explain what a model has learned, and what affects its reasoning.

In this guide - learn how to get feature importance from a Python's Scikit-Learn RandomForestRegressor or RandomForestClassifier, and how to plot and communicate the importance of features from the training set after fitting the model.

Get Feature Importances for Random Forest with Python and Scikit-Learn

<h2 id="introduction">Introduction</h2>
In bash scripts, assigning the output of a command to variables can be convenient by storing the outputs of the commands and using them later.
<blockquote>
In this short guide, we will take a look at how you can store the output of a command as a variable in Bash.
</blockquote>
<h2 id="thebasicstosetupvariables">The Basics To Set Up Variables</h2>
Saving the output of a command as a variable is achieved through command substitution. Command substitution is a wrapper that executes the command in a subshell environment, and replaces the wrapped command with the standard output of the environment in which the command was run. This output can then be referenced later, if connected to a reference variable!
Command substitution can be achieved through back ticks or the dollar sign with parentheses:
<pre><code class="hljs">`command`

$(command)
</code></pre>
There's debate as to whether `command` (backticks) or $(command) (dollar sign and parentheses) should be used as the &quot;best practice&quot;. <code>$(command)</code> works well in nesting, and improves readability in some cases, but you can go with either syntax in the preceding examples.
That being said - assigning the output of a command to a variable in Bash is as easy as:
<pre><code class="hljs">VARIABLE=$(command)
echo &quot;${VARIABLE}&quot;
</code></pre>
Running <code>${variable}</code> is known as parameter expansion, and is used to evaluate and fetch the value associated with a reference variable.
Let's now take a look at the simple example of setup a variable for a command to change the output color:
<pre><code class="hljs">#!/bin/bash
GREEN=$(tput setaf 2)
echo &quot;${GREEN}Please&quot;

ORANGE=$(tput setaf 9)
echo &quot;${ORANGE}Visit&quot;

echo &quot;${GREEN}Paris&quot;
</code></pre>
In the snippet, we've used the <code>tput</code> command and assigned the returned value of those commands to print colorful text. The <code>setaf</code> changes the foreground color, and 3 (green) and 9 (orange) are color codes.
Now we'll move on to another example that contains multiple conditions to set up variables for different commands:
<pre><code class="hljs">#!/bin/bash
PERSON=$(whoami)
echo -e &quot;Hey ${PERSON}! I am Charlie\n&quot;

DETAILS=$(uname -a)
echo -e &quot;You&#x27;re running this script on:\n${DETAILS}\n&quot;

DATES=$(date)
echo -e &quot;The script is being run on:\n${DATES}\n&quot;

CREATE=$(touch $(date +&quot;%d%m%Y&quot;).txt)
echo -e &quot;A text file logging this run is created.${CREATE}\n&quot;

LOCATION=$(ls \
 -l *txt)
echo -e &quot;Saved text file at: ${LOCATION}&quot;
</code></pre>
In the above script, the <code>whoami</code> command returns the current user's username. The <code>uname -a</code> returns the system information, and the <code>date</code> returns the current time and date.

 <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: We can chain variable assignment by adding multiple commands in a single nested call. The <code>CREATE</code> variable contains the output of the <code>touch</code> command, which in turn creates a file and sets the filename to the output of the <code>date +&quot;%d%m%Y</code> command.

 </div>
 </div>
 </div>
 Finally, we add a <code>multiline</code> command variable assignment concept by adding a backslash <code>(\)</code> between the <code>ls</code> command <code>-l</code> flag to display only text files using <code>*.txt</code>. The backslash is an escape character that informs the shell not to interpret the next character.
In the <code>echo</code> command, we added the <code>-e</code> flag to use the special character, i.e., <code>\n</code> (newline), to print the output in the new line.
We get the following result after executing the script:
<pre><code class="hljs">$ ./variable.sh
</code></pre>
<img src="https://s3.stackabuse.com/media/articles/how-to-save-command-output-as-variable-in-bash.jpg" alt="">
<h2 id="conclusion">Conclusion</h2>
In this short guide, we've taken a look at how you can set the output of a command to a variable in Bash. We've taken a look at the difference between the syntaxes for command substitution, noting the readability improvements of <code>$(command)</code> over backtick based substitution. Then, we've taken a look at several examples of both simple assignment and chained/nested output assignment.

In this short guide - learn how to save the output of a Bash command as a variable, that you can call later.