If you've been working with Git long enough, you've probably had times where you made changes to your codebase, but needed to switch branches or work with the latest working version of your code. However, you don't want to lose the changes you've made already, but they're not yet ready to commit the updates since they're not finished. What should you do?
<h2 id="gitstash">Git Stash</h2>
Luckily, Git provides a mechanism to handle cases like this through the command <code>git stash</code>. The <code>stash</code> command takes the uncommitted changes in your working directory, both the updated tracked files and staged changes, and saves them.
Let's say you're working on a new feature and you made some modifications to your code, and you now have one or more files with uncommitted modifications:
<pre><code class="hljs">$ git status
On branch master
Changes not staged for commit:
 (use &quot;git add &lt;file&gt;...&quot; to update what will be committed)
 (use &quot;git checkout -- &lt;file&gt;...&quot; to discard changes in working directory)

 modified: index.js

no changes added to commit (use &quot;git add&quot; and/or &quot;git commit -a&quot;)
</code></pre>
However, the changes aren't finished, and you need to switch to a different branch to quickly fix a bug before continuing on with the current feature. To avoid losing the current updates you've made, you can just stash the changes instead and get them back later without messing up your commit history.
<pre><code class="hljs">$ git stash
Saved working directory and index state WIP on master: bbf6ef9 Initial commit
HEAD is now at bbf6ef9 Initial commit
</code></pre>
As you can see, <code>HEAD</code> is now back to our last commit, which in this case is the initial commit. To verify, look for changes using <code>git status</code>:
<pre><code class="hljs">$ git status
On branch master
nothing to commit, working tree clean
</code></pre>
We're back to where we started as if we never made the changes at all! Now you can go off and fix that bug.
But what about restoring your changes? To get them back, we can simply use the <code>apply</code> sub-command, which takes the last-stashed changes and puts them back into your working directory.
<pre><code class="hljs">$ git stash apply
On branch master
Changes not staged for commit:
 (use &quot;git add &lt;file&gt;...&quot; to update what will be committed)
 (use &quot;git checkout -- &lt;file&gt;...&quot; to discard changes in working directory)

 modified: index.js

no changes added to commit (use &quot;git add&quot; and/or &quot;git commit -a&quot;)
</code></pre>
And just like that, you have your changes back.
<h2 id="advancedfeatures">Advanced Features</h2>
In the examples above, we used <code>stash</code> in the simplest context. As we tend to find out in our day-to-day programming, real-world use-cases aren't usually that simple. What if, for example, you end up needing to stash changes from your working directory multiple times? Luckily, <code>stash</code> allows you to do just that. Technically, when you stash changes, Git puts the changes on a stack, which can then be pulled off in a LIFO (last in, first out) order. You're able to view this stack using the <code>list</code> subcommand.
<pre><code class="hljs">$ git stash list
stash@{0}: WIP on master: 7513525 Fixed console output
stash@{1}: WIP on master: 91f33cc Fixed output punctuation
stash@{2}: WIP on master: bbf6ef9 Initial commit
stash@{3}: WIP on master: bbf6ef9 Initial commit
</code></pre>
The stashed work at the top of the list is what you'll get when using the <code>apply</code> command without any extra arguments. If there is a different stash you'd like to get instead, you can specify it using the identifier at the beginning of each line. For example, to get the second stash, you would use the following:
<pre><code class="hljs">$ git stash apply stash@{1}
On branch master
nothing to commit, working tree clean
</code></pre>
You may notice that after using the <code>apply</code> subcommand, the stash will still be on the stack. In order to apply it and remove it from the stack, use <code>pop</code> instead.
<pre><code class="hljs">$ git stash pop stash@{0}
On branch master
nothing to commit, working tree clean
Dropped stash@{0} (9079b4ffdf46574701cffcd68eb4feba80ebcf72)
</code></pre>
This stash is now no longer in our stack:
<pre><code class="hljs">$ git stash list
stash@{0}: WIP on master: 91f33cc Fixed output punctuation
stash@{1}: WIP on master: bbf6ef9 Initial commit
stash@{2}: WIP on master: bbf6ef9 Initial commit
</code></pre>
But what if you want to remove a stash without applying it to your current working directory? This can be achieved with <code>drop</code>, which works much like <code>apply</code> and <code>pop</code> syntactically:
<pre><code class="hljs">$ git stash drop stash@{2}
Dropped stash@{2} (5483fdec3496572c8b943504b6029d45a7999453)
</code></pre>
And, as expected, that stash was not applied and it is gone from the stash stack:
<pre><code class="hljs">$ git status
On branch master
nothing to commit, working tree clean
$ git stash list
stash@{0}: WIP on master: 91f33cc Fixed output punctuation
stash@{1}: WIP on master: bbf6ef9 Initial commit
</code></pre>
<h2 id="conclusion">Conclusion</h2>
Unsurprisingly, Git has a solution for most problems that arise in version control since it's been around for such a long time. Here we've seen how to handle the use-case where you have changes in your working directory, but you want to switch branches and not commit the unfinished changes. The <code>stash</code> command can be very powerful, and there are more features to it than what was covered here, like various flags that are available, which we'll save for another article.

Scott Robinson

Git: Stashing Uncommitted Changes

<h2 id="introduction">Introduction</h2>
Elasticsearch initially began as a custom search engine. These days, it has gone above and beyond that singular role as it's part of log aggregation stacks, security monitoring, and even as a datastore for performing exploratory analysis.
Indices in Elasticsearch are where the data is stored, and there are often times when these indices need to be transported from one cluster to another. Perhaps we just need a safe backup before moving data to another cluster or upgrading versions. Elasticdump is a tool that helps in facilitating this backup and restore operation.
<blockquote>
Elasticdump is a tool made to move and save Elasticsearch indices.
</blockquote>
In this guide, we'll take a look at how to use Elasticdump and how to create and move indices between clusters on your local computer.

 <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 follow this tutorial, you need to have <a href="/docker-a-high-level-introduction" target="_blank">docker installed</a>, as well as <a href="/how-to-install-node-js-on-ubuntu" target="_blank">NPM</a>.

 </div>
 </div>
 </div>
 <h2 id="whatiselasticdumpandwhyuseit">What Is Elasticdump, and Why Use It?</h2>
Those familiar with Elasticsearch would know of its &quot;Snapshot and Restore&quot; feature to facilitate these operations. Yes, it is indeed a smart feature that helps back up individual indices or an entire cluster. While exploring that option for a small number of indices or clusters, you may find that using the &quot;Snapshot and Restore&quot; feature could be an overkill. This is even more pronounced when there's no system to incrementally take snapshots.
This is where Elasticdump can help - it's a lightweight tool that can move and save indices with a remote repository required by Elasticsearch's &quot;Snapshot and Restore&quot;.
Here's what Elasticdump can do:
<ul>
<li>Copy the indices from one cluster to the other</li>
<li>Dump indices to flat files</li>
<li>Back up indices &amp; mappings</li>
<li>Restore indices across different versions of Elasticsearch</li>
<li>Multielasticdump that comes along with Elasticdump can export multiple indices in parallel</li>
</ul>
<h2 id="settingupelasticdump">Setting up Elasticdump</h2>
<h3 id="installation">Installation</h3>
Elasticdump is a Node package and it can be directly downloaded from <a href="https://www.npmjs.com/package/elasticdump" target="_blank" rel="noopener nofollow">NPM</a>. We'll need to have Node.js installed, alongside the Node Package Manager (NPM).
Let's go ahead and install them, before downloading Elasticdump:
<pre><code class="hljs">$ sudo apt install nodejs npm # Install Node.js + NPM
$ sudo npm install n -g # Install helper package to get latest Node.js + NPM versions
/usr/local/bin/n -&gt; /usr/local/lib/node_modules/n/bin/n
/usr/local/lib
└── n@7.2.2
$ sudo n latest # Get latest version of NPM

 installing : node-v16.2.0
 mkdir : /usr/local/n/versions/node/16.2.0
 fetch : https://nodejs.org/dist/v16.2.0/node-v16.2.0-linux-x64.tar.xz
 installed : v16.2.0 (with npm 7.13.0)

Note: the node command changed location and the old location may be remembered in your current shell.
 old : /usr/bin/node
 new : /usr/local/bin/node
To reset the command location hash either start a new shell or execute PATH=&quot;$PATH&quot;

$ sudo npm install elasticdump -g # Install Elasticdump globally on your local machine
</code></pre>
This installs Elasticdump globally and the installation can be verified using the following command:
<pre><code class="hljs">$ elasticdump --version
6.71.0
</code></pre>
<h3 id="settingupanelasticsearchclusteroptional">Setting Up an Elasticsearch Cluster (Optional)</h3>
To test Elasticdump out, you will have to have at least one Elasticsearch cluster with a single node setup. If you have an Elasticsearch cluster running already, <a href="#elasticdumpinaction">you may skip this step</a>.
For others, the following commands will spin up an Elasticsearch container for you. Make sure you have Docker or Docker Desktop installed and running on your machine. You can download your suitable installer from <a href="https://www.docker.com/products/docker-desktop" target="_blank" rel="noopener nofollow">here</a>.
Once your Docker server is up and running, let's create a directory, which will contain the volume to hold Elasticsearch's data. If this is not done, Elasticsearch volume would be ephemeral and your data will be lost if the container goes down:
<pre><code class="hljs">$ mkdir -p data/ES9200
$ mkdir -p data/ES9400
$ vol_location=`pwd`
</code></pre>
You can now spin up your Elasticsearch container by keying in the following command:
<pre><code class="hljs">$ docker run -p 9200:9200 -p 9300:9300 -e &quot;discovery.type=single-node&quot; -v ${vol_location}/data/es9200:/usr/share/elasticsearch/data --name=es_source -d docker.elastic.co/elasticsearch/elasticsearch:7.13.0
</code></pre>
Let's break this command down a bit.
We've commanded Docker to publish (<code>-p</code> flag) port <code>9200</code> on your host machine to the <code>9200</code> port on your container, and the same process is then run for <code>9300</code>. We have also assigned an environment variable (<code>-e</code> flag) stating that it is going to be a single node setup.
Then, we attach the volume (<code>-v</code> flag) to the directory created in the previous setup, mapped to the data directory inside the container, in which the data will be stored.
Finally, the <code>--name</code> flag is to give a nice name to the container while the <code>-d</code> flag is to make the container run in the background, and <code>docker.elastic.co/elasticsearch/elasticsearch:7.13.0</code> is the name of the image.
We'll copy data from this Elasticsearch cluster to another cluster, using Elasticdump. To make this happen, you can create another cluster known as <code>es_target</code> by issuing the following command:
<pre><code class="hljs">$ docker run -p 9400:9200 -p 9500:9300 -e &quot;discovery.type=single-node&quot; -v ${vol_location}/data/es9400:/usr/share/elasticsearch/data --name=es_target -d docker.elastic.co/elasticsearch/elasticsearch:7.13.0
</code></pre>
Note: The service won't run on a port that's already being used by another service.
You can check if your Elasticsearch cluster containers are running fine by issuing the following command:
<pre><code class="hljs">$ docker ps
CONTAINER ID IMAGE COMMAND CREATED
STATUS PORTS NAMES
c0aa983abb21 docker.elastic.co/elasticsearch/elasticsearch:7.13.0 &quot;/bin/tini -- /usr/l…&quot; 9 hours ago
Up 2 hours 0.0.0.0:9400-&gt;9200/tcp, :::9400-&gt;9200/tcp, 0.0.0.0:9500-&gt;9300/tcp, :::9500-&gt;9300/tcp es_target
eb30714b5302 docker.elastic.co/elasticsearch/elasticsearch:7.13.0 &quot;/bin/tini -- /usr/l…&quot; 10 hours ago Up 3 hours 0.0.0.0:9200-&gt;9200/tcp, :::9200-&gt;9200/tcp, 0.0.0.0:9300-&gt;9300/tcp, :::9300-&gt;9300/tcp es_source
</code></pre>
The containers that you have created look good! Let's dive into the usage of Elasticdump.
<h2 id="workingwithelasticdump">Working with Elasticdump</h2>
With a container ready, we can start working with Elasticdump.
<h3 id="restoringtheindex">Restoring the Index</h3>
The clusters are ready, but they look empty. Let's create an index and load data to one of the clusters. The <code>es_source</code> cluster runs on port <code>9200</code> and can be accessed via <code>http://localhost:9200</code>. Run the following commands to download the mapping and the data to be loaded:
<pre><code class="hljs">$ wget https://raw.githubusercontent.com/StackAbuse/moving-elasticsearch-indices-with-elasticdump/main/logs_mapping.json
$ wget https://raw.githubusercontent.com/StackAbuse/moving-elasticsearch-indices-with-elasticdump/main/logs_data.json
</code></pre>
Let's try loading these files to the <code>es_source</code> cluster under the index <code>log-2021-06-01</code> using Elasticdump:
<pre><code class="hljs">$ elasticdump --input=logs_mapping.json --output=http://localhost:9200/log-2021-06-01 --type=mapping
$ elasticdump --input=logs_data.json --output=http://localhost:9200/logindex --type=data
</code></pre>
There are three flags here: <code>--input</code> corresponds to the JSON file that we have downloaded, <code>--output</code> corresponds to the cluster endpoint, and <code>--type</code> corresponds to either mapping or data which defines what to export.
Elasticdump takes the input as these files and writes the output to the <code>log-2021-06-01</code> index as:
<pre><code class="hljs">$ elasticdump --input=logs_mapping.json --output=http://localhost:9200/log-2021-06-01 --type=mapping
Sat, 05 Jun 2021 12:30:52 GMT | starting dump
Sat, 05 Jun 2021 12:30:52 GMT | got 1 objects from source file (offset: 0)
Sat, 05 Jun 2021 12:30:59 GMT | sent 1 objects to destination elasticsearch, wrote 1
Sat, 05 Jun 2021 12:30:59 GMT | got 0 objects from source file (offset: 1)
Sat, 05 Jun 2021 12:30:59 GMT | Total Writes: 1
Sat, 05 Jun 2021 12:30:59 GMT | dump complete

$ elasticdump --input=logs_data.json --output=http://localhost:9200/log-2021-06-01 --type=data
Sat, 05 Jun 2021 12:31:23 GMT | starting dump
Sat, 05 Jun 2021 12:31:24 GMT | got 100 objects from source file (offset: 0)
Sat, 05 Jun 2021 12:31:26 GMT | sent 100 objects to destination elasticsearch, wrote 100
Sat, 05 Jun 2021 12:31:26 GMT | got 100 objects from source file (offset: 100)
Sat, 05 Jun 2021 12:31:27 GMT | sent 100 objects to destination elasticsearch, wrote 100
Sat, 05 Jun 2021 12:31:27 GMT | got 100 objects from source file (offset: 200)
Sat, 05 Jun 2021 12:31:28 GMT | sent 100 objects to destination elasticsearch, wrote 100
Sat, 05 Jun 2021 12:31:28 GMT | got 0 objects from source file (offset: 300)
Sat, 05 Jun 2021 12:31:28 GMT | got 0 objects from source file (offset: 300)
Sat, 05 Jun 2021 12:31:28 GMT | Total Writes: 300
Sat, 05 Jun 2021 12:31:28 GMT | dump complete
</code></pre>
Let's check if the restoration is completed successfully:
<pre><code class="hljs">$ curl localhost:9200/_cat/indices
yellow open log-2021-06-01 UD4SRzu-TjCNdVZatdOQsA 1 1 300 0 305.5kb 305.5kb
</code></pre>
There are 300 documents in Elasticsearch constituting a total size of <code>305.5kb</code>.
<h3 id="copyingtheindexacrossclusters">Copying the Index Across Clusters</h3>
The syntax seen above is similar across the usage of Elasticdump for different scenarios. Let's now copy the index created previously into a new index on another cluster:
<pre><code class="hljs">$ elasticdump --input=http://localhost:9200/log-2021-06-01 --output=http://localhost:9400/log-2021-06-01
Sat, 05 Jun 2021 10:05:24 GMT | starting dump
Sat, 05 Jun 2021 10:05:24 GMT | got 100 objects from source elasticsearch (offset: 0)
Sat, 05 Jun 2021 10:05:28 GMT | sent 100 objects to destination elasticsearch, wrote 100
Sat, 05 Jun 2021 10:05:28 GMT | got 100 objects from source elasticsearch (offset: 100)
Sat, 05 Jun 2021 10:05:28 GMT | sent 100 objects to destination elasticsearch, wrote 100
Sat, 05 Jun 2021 10:05:28 GMT | got 100 objects from source elasticsearch (offset: 200)
Sat, 05 Jun 2021 10:05:30 GMT | sent 100 objects to destination elasticsearch, wrote 100
Sat, 05 Jun 2021 10:05:30 GMT | got 0 objects from source elasticsearch (offset: 300)
Sat, 05 Jun 2021 10:05:30 GMT | Total Writes: 300
Sat, 05 Jun 2021 10:05:30 GMT | dump complete
</code></pre>
Elasticdump will create a new index for you if the output index doesn't exist. Let's again verify if the index has been created properly.
<pre><code class="hljs">$ curl localhost:9400/_cat/indices
yellow open log-2021-06-01 UD4SRzu-TjCNdVZatdOQsA 1 1 300 0 305.5kb 305.5kb
</code></pre>
<h2 id="conclusion">Conclusion</h2>
As simple as it sounds, the Elasticdump tool is a must-have tool for anyone dealing with Elasticsearch.

Marcus Sanatan

Sathiya Sarathi Gunasekaran

Elasticdump is a lightweight tool that copies data to and from Elasticsearch indices. In this guide, we'll take a look at how to install and use Elasticdump to make your work with Elasticsearch easier.

Guide to Elasticdump - Moving and Saving Elasticsearch Indices

<h2 id="introduction">Introduction</h2>
Measuring code execution time is a vital step in trying to write efficient applications. Temporal awareness of your code on a machine that might be serving a great deal of users lets you plan further, accounting for the execution time.
In multi-threaded systems, it's also useful to measure the execution time of individual <code>Thread</code>s or asynchronous tasks.
Since there's no built-in, convenient way to measure code execution in Java - for Spring-based solutions, we've been introduced to the <code>StopWatch</code> tool.
In this tutorial, we'll take a look at how to measure code execution time in Java with Spring's <code>StopWatch</code>.
<h2 id="springsstopwatchclass">Spring's StopWatch Class</h2>
The <code>StopWatch</code> is a utility class, residing in the <code>util</code> package. It has a very simple API and allows us to time named tasks, groups of tasks and the total running time of a program.
This class is normally used to check the performance of code during the development phase, rather than a part of production applications.
Note: It is worth noting that <code>StopWatch</code> is not thread-safe.
It tracks the time in nanoseconds, relying on <code>System.nanoTime()</code>, which is what people have been doing manually to time the execution of their code.
<h2 id="measuringcodeexecutiontimewithstopwatch">Measuring Code Execution Time with StopWatch</h2>
The <code>StopWatch</code> belongs to the core <code>util</code> package of Spring:
<pre><code class="hljs">&lt;dependency&gt;
 &lt;groupId&gt;org.springframework&lt;/groupId&gt;
 &lt;artifactId&gt;spring-core&lt;/artifactId&gt;
&lt;/dependency&gt;
</code></pre>
Naturally, it's also present in the <code>spring-boot-starter-web</code> dependency:
<pre><code class="hljs">&lt;dependency&gt;
 &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;
 &lt;artifactId&gt;spring-boot-starter-web&lt;/artifactId&gt;
&lt;/dependency&gt;
</code></pre>
The API of <code>StopWatch</code> boils down to creating an instance and calling <code>start()</code> and <code>stop()</code> - as if timing the code with an actual stopwatch. When starting the timing, you can also provide a <code>String</code> to be used as a name or annotation for the associated task. This helps differentiate them in the results.
<blockquote>
A task is simply the period between a <code>start()</code> and <code>stop()</code> call. For each task, created when a <code>StopWatch</code> starts - its name and execution time are saved in a <code>TaskInfo</code> instance, and added to the task list.
</blockquote>
Let's go ahead and create a task, with a name and measure a piece of code's execution time:
<pre><code class="hljs">StopWatch timeMeasure = new StopWatch();

timeMeasure.start(&quot;Task 1&quot;);
Thread.sleep(1000);
timeMeasure.stop();

System.out.println(&quot;Last task time in Millis: &quot; 
 + timeMeasure.getLastTaskMillis());
</code></pre>
This results in:
<pre><code class="hljs">Last task time in Millis: 1009
</code></pre>
You can access the sum of all tasks through <code>getTotalTimeSeconds()</code>, <code>getTotalTimeMillis()</code> and <code>getTotalTimeNanos()</code>.
You can also access the last task of the <code>StopWatch</code> through <code>getLastTaskInfo()</code>, which returns a <code>TaskInfo</code> instance. This instance contains information on the last task such as the name and how long it took in seconds, milliseconds and nanoseconds:
<pre><code class="hljs">StopWatch stopWatch = new StopWatch();

stopWatch.start(&quot;Task 1&quot;);
Thread.sleep(1000);
stopWatch.stop();

System.out.println(stopWatch.getLastTaskInfo().getTaskName());

System.out.println(stopWatch.getLastTaskInfo().getTimeMillis());
</code></pre>
This now results in:
<pre><code class="hljs">Task 1
1008
</code></pre>
When dealing with multiple tasks, a really handy method is the <code>prettyPrint()</code> method - which prints all of the records in a table-like fashion, with simple formatting:
<pre><code class="hljs">// Naming this StopWatch instance
StopWatch stopWatch = new StopWatch(&quot;Measure Code Execution&quot;);
 
stopWatch.start(&quot;1. Task&quot;);
Thread.sleep(2000);
stopWatch.stop();
 
stopWatch.start(&quot;2. Task&quot;);
Thread.sleep(5000);
stopWatch.stop();
 
stopWatch.start(&quot;3. Task&quot;);
Thread.sleep(3000);
stopWatch.stop();
 
System.out.println(stopWatch.prettyPrint());
</code></pre>
Output:
<pre><code class="hljs">StopWatch &#x27;Measure Code Execution&#x27;: running time = 10012348500 ns
---------------------------------------------
ns % Task name
---------------------------------------------
2002729600 020% 1. Task
5006985700 050% 2. Task
3002633200 030% 3. Task
</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: If we're using <code>StopWatch</code> to measure the code execution time for a large number of intervals (on the order of hundreds of thousands or millions) - the <code>TaskInfo</code> list will consume a significant portion of your working memory. You can turn it off via:
<pre><code class="hljs">stopWatch.setKeepTaskList(false);
</code></pre>

 </div>
 </div>
 </div>
 <h2 id="conclusion">Conclusion</h2>
In this tutorial, we took a look at the <code>StopWatch</code> utility class - Spring's answer to the inherent lack of time measurement tools in Java.

David Landup

Ognjen Jankovic

In this tutorial, we'll take a look at how to measure Java code execution time for Spring-based projects via StopWatch and its simple API.

Measuring Java Code Execution Time with Spring's StopWatch

<h2 id="introduction">Introduction</h2>
Python has a lot of built-in tools that allow us to iterate and transform data. A great example is the <code>itertools</code> module, which offers several convenient iteration functions. Each of these iterator-building functions (they generate iterators) can be used on their own, or combined.
The module was inspired by functional languages such as APL, Haskell, and SPL and the elements within <code>itertools</code> from Python's iterator algebra.
<h2 id="iterablevsiterator">Iterable vs Iterator</h2>
Before we dive into the iteration, let's first define the distinction between two important terms: iterable and iterator.
An iterable is an object which can be iterated over. When using the <code>iter()</code> function, an iterator is being generated. Generally speaking, most sequences are iterable, such as lists, tuples, strings, etc.
An iterator is also an object, which is used to iterate over an iterable and an iterator can also iterate over itself. This is done by using the <code>next()</code> method, passing in the iterator that we're trying to traverse.
The <code>next()</code> method returns the next element of an iterable object. An iterator can be generated from an iterable (using <code>iter()</code>):
<pre><code class="hljs">list = [1,2,3,4,5]
iterator = iter(list)

print(iterator)
</code></pre>
This results in:
<pre><code class="hljs">&lt;list_iterator object at 0x0000018E393A0F28&gt;
</code></pre>
Now, let's access the <code>next()</code> element (starting at the first one) using our <code>iterator</code>:
<pre><code class="hljs">print(next(iterator))
</code></pre>
This results in:
<pre><code class="hljs">1
</code></pre>
This is practically what happens under the hood of the <code>for</code> loop - it calls <code>iter()</code> on the collection you're iterating over, and after that, the <code>next()</code> element is accessed <code>n</code> times.
In this tutorial, we'll be taking a look at a few Python iteration tools:
<ul>
<li><a href="#methodcount">count()</a></li>
<li><a href="#methodcycle">cycle()</a></li>
<li><a href="#methodchain">chain()</a></li>
</ul>
<h2 id="thecountfunction">The count() Function</h2>
The <code>count(start, step)</code> function creates an iterator and is used to generate evenly-spaced values, where the space between them is defined by the <code>step</code> argument. The <code>start</code> argument defines the starting value of the iterator - and these are set to <code>start=0</code> and <code>step=1</code> by default.
Without a braking condition, the <code>count()</code> function will continue counting indefinitely (on a system with indefinite memory):
<pre><code class="hljs">from itertools import count

iterator_count = count(start=0, step=5)

for i in iterator_count:
 if(i == 25):
 break
 print(i)
</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: Using <code>count()</code> like this is unusual. You'd typically chain it with other methods, such as <code>zip()</code>, <code>map()</code>, or <code>imap()</code>.

 </div>
 </div>
 </div>
 The iterator iterates over itself here, printing values in steps of 5:
<pre><code class="hljs">0
5
10
15
20
</code></pre>
Given its generative nature, this function is most commonly used with other functions that expect new or generate sequences.
For example, when using <code>zip()</code> to zip together multiple items of a list, you might want to annotate them via a positional index. While zipping, we'd use <code>count()</code> to generate values for these indices:
<pre><code class="hljs">from itertools import count

list = [&#x27;John&#x27;, &#x27;Marie&#x27;, &#x27;Jack&#x27;, &#x27;Anna&#x27;]
for i in zip(count(), list):
 print(i)
</code></pre>
This results in:
<pre><code class="hljs">(0, &#x27;John&#x27;)
(1, &#x27;Marie&#x27;)
(2, &#x27;Jack&#x27;)
(3, &#x27;Anna&#x27;)
</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">
 Advice: If you'd like to read more about the <code>zip()</code> function, s well as some other commonly used functions alongside it - read our guide on <a rel="nofollow noopener" target="_blank" href="https://stackabuse.com/pythons-iteration-tools-filter-islice-map-and-zip">Python Iteration Tools - filter(), islice(), map() and zip()</a>.

 </div>
 </div>
 </div>
 <h2 id="thecyclefunction">The cycle() Function</h2>
The <code>cycle()</code> function accepts an iterable and generates an iterator, which contains all of the iterable's elements. In addition to these elements, it contains a copy of each element.
Once we iterate through to the end of the elements, we start iterating through the copies. While iterating through the copies, new copies are made. Once the first set of copies runs out - we iterate through the new set.
This process is repeated indefinitely.

 <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: Given this fact, using <code>cycle()</code>, especially for longer sequences is extremely memory-burdening.

 </div>
 </div>
 </div>
 Beware of infinite, recursive creation logic, since you'll easily run out of memory to house it all:
<pre><code class="hljs">from itertools import cycle

list = [1,2,3,4]
iterator = cycle(list)

for i in iterator:
 print(i)
</code></pre>
This results in:
<pre><code class="hljs">1
2
3
4
1
2
3
4
...
</code></pre>
Until we terminate the program or run out of memory. That being said - you should always have an exit/termination condition for the <code>cycle()</code> function.
Given the fact that <code>cycle()</code> can cycle through any iterable, we can easily apply it to strings and tuples as well:
<pre><code class="hljs">from itertools import cycle

string = &quot;This is a random string&quot;
iterator = cycle(string)

for i in iterator:
 print(i)
</code></pre>
This results in an endless sequence of:
<pre><code class="hljs">T
h
i
s
i
s
a
r
a
n
d
o
...
</code></pre>
<h2 id="thechainfunction">The chain() Function</h2>
The <code>chain()</code> function is used to chain multiple iterables together, by generating an iterator that traverses them sequentially, one after the other:
<pre><code class="hljs">result = list(chain([1, 2, 3], 
 [&quot;one&quot;, &quot;two&quot;, &quot;three&quot;], 
 &quot;String&quot;, 
 (&quot;this&quot;, &quot;is&quot;, &quot;a&quot;, &quot;tuple&quot;)))
 
print(result)
</code></pre>
The output will be:
<pre><code class="hljs">[1, 2, 3, &#x27;one&#x27;, &#x27;two&#x27;, &#x27;three&#x27;, &#x27;S&#x27;, &#x27;t&#x27;, &#x27;r&#x27;, &#x27;i&#x27;, &#x27;n&#x27;, &#x27;g&#x27;, &#x27;this&#x27;, &#x27;is&#x27;, &#x27;a&#x27;, &#x27;tuple&#x27;]
</code></pre>
Here, we've got four different types of iterables - each one being chained together.
Even though <code>[&quot;one&quot;, &quot;two&quot;, &quot;three&quot;]</code> is a list of strings, <code>chain()</code> treats this as a list and simply chains its elements without calling a subsequent <code>chain()</code> for each of the strings. On the other hand, <code>&quot;String&quot;</code> is broken down into its constituent characters.
The former can be achieved with another method, derived from the <code>chain()</code> function - <code>chain.from_iterable()</code>:
<pre><code class="hljs">result2 = list(chain([&quot;one&quot;, &quot;two&quot;, &quot;three&quot;]))
result3 = list(chain.from_iterable([&quot;one&quot;, &quot;two&quot;, &quot;three&quot;]))

print(result2)
print(result3)
</code></pre>
The <code>chain()</code> function behaves the same as we've previously observed - it chains the elements as they are. On the other hand, the <code>chain.from_iterable()</code> method treats each element as an iterable and returns its constituent elements alongside other elements broken down in the same fashion:
<pre><code class="hljs">[&#x27;one&#x27;, &#x27;two&#x27;, &#x27;three&#x27;]
[&#x27;o&#x27;, &#x27;n&#x27;, &#x27;e&#x27;, &#x27;t&#x27;, &#x27;w&#x27;, &#x27;o&#x27;, &#x27;t&#x27;, &#x27;h&#x27;, &#x27;r&#x27;, &#x27;e&#x27;, &#x27;e&#x27;]
</code></pre>
Commonly, you'd use <code>chain.from_iterable()</code> to calculate the sum of digits, contained within several collections that you first chain together, and then calculate the <code>sum()</code> for:
<pre><code class="hljs">from itertools import chain

number_list = [[1, 2, 3],[4, 5, 6],[7, 8, 9]]
result = list(chain.from_iterable(number_list))
print(sum(result))
</code></pre>
Each element of the <code>number_list</code> collection is another list. Since lists are iterable, the <code>chain.from_iterable()</code> call breaks these down into a single list containing elements from <code>[1..9]</code>, after which we calculate their <code>sum()</code> and print the result:
<pre><code class="hljs">45
</code></pre>
<h2 id="conclusion">Conclusion</h2>
The <code>itertools</code> module introduces us to several useful convenience functions for working with iterables and iteration.
Many of these can be used as standalone convenience functions, but they're most commonly chained with other functions to transform data.

Lazar Ristic

In this tutorial, we'll be taking a look at the `itertools` module in Python - and take a look at examples of count(), cycle() and eval().

Python's itertools – count(), cycle() and chain()

Dragan Bjekic

In this beginner-level guide, we'll get introduced to Jenkins, the CI/CD automation server, and run and automate the build process of a simple project.

Beginner's Introduction to Jenkins - CI/CD

<h2 id="introduction">Introduction</h2>
In this tutorial, we'll explain how to replace words in text sequences, with Python using the FlashText module, which provides one of the most efficient ways of replacing a large set of words in a textual document.
<h2 id="howdoestheflashtextalgorithmwork">How does the FlashText Algorithm Work?</h2>
The FlashText module is based on its proprietary algorithm, the FlashText algorithm. In essence, it is based on a Python implementation of the <a rel="nofollow noopener" target="_blank" href="https://en.wikipedia.org/wiki/Aho%E2%80%93Corasick_algorithm">Aho–Corasick algorithm</a>.
The fundamental takeaway of the algorithm is to reduce the time spent finding a large number of keywords in the text, by minimizing the number of times that the text is scanned.
<blockquote>
A naive algorithm consists of comparing each keyword to every single word in the whole text - akin to Linear Search. That approach is extremely inefficient, because it needs to scan the entire text document <code>n</code> times - where <code>n</code> is the number of keywords.
</blockquote>
<blockquote>
On the other hand, FlashText opts for a different approach, intending to scan the text only once.
</blockquote>
The key to the efficiency of the FlashText algorithm is that it stores all of the keywords, paired with corresponding replacement words in a dictionary. Then, instead of scanning text once for every keyword in the dictionary, it scans the text only once. In that one scan over the text, words are matched to the dictionary keys and if present - replaced with the key's value.
<h2 id="howtoinstallflashtext">How to Install FlashText</h2>
Installing FlashText is fairly straightforward, via <code>pip</code>:
<pre><code class="hljs">$ pip install flashtext
</code></pre>
<h2 id="howtouseflashtext">How to Use FlashText</h2>
Let's first take a look at the <code>FlashText</code> API and some of the key classes within it.
<h3 id="thekeywordprocessorclass">The KeywordProcessor Class</h3>
The main class we'll be working with, which takes care of the processing of keywords, is the <code>KeywordProcessor</code> class. Let's import it directly from <code>FlashText</code> and initialize it:
<pre><code class="hljs">from flashtext import KeywordProcessor
keyword_processor = KeywordProcessor()
</code></pre>
The previous line creates the <code>KeywordProcessor</code> object that will work in the case-insensitive mode.
<blockquote>
Case-insensitive mode will match <code>abc</code> with <code>ABC</code>, as well as with <code>aBc</code>, <code>ABc</code>, etc.
</blockquote>
<blockquote>
Case-sensitive mode will only match <code>aaa</code> with exactly the same string, <code>aaa</code>.
</blockquote>
Alternatively, we can create a <code>KeywordProcessor</code> instance in the case-sensitive mode:
<pre><code class="hljs">keyword_processor= KeywordProcessor(case_sensitive=True)
</code></pre>
<h3 id="definingthekeywordsdictionary">Defining the Keywords Dictionary</h3>
In the FlashText module, we use keywords to define words that need to be replaced. The <code>KeywordProcessor</code> object contains a dictionary containing all of the defined keywords.
There are two ways of adding keywords to the dictionary: in bulk or one-by-one.
Firstly, let's take a look at how to add keywords one-by-one:
<pre><code class="hljs">keyword_processor.add_keyword(&lt;keyword&gt;, &lt;replacementWord&gt;)
</code></pre>
<blockquote>
<code>&lt;replacementWord&gt;</code> is an optional argument. When not specified, just the <code>&lt;keyword&gt;</code> is added to the dictionary and there is no way of replacing it with another replacement word.
So, if you want to use FlashText to replace words in a text, we highly recommend you to specify the <code>&lt;replacementWord&gt;</code> argument.
</blockquote>
If we have more than a couple of keywords, adding them one-by-one can be a little time-consuming. An alternative, much more commonly used even for small lists of keywords is to add keywords in bulk:
<pre><code class="hljs">keyword_dictionary = {
 &#x27;replacementWord1&#x27;: [&#x27;list&#x27;, &#x27;of&#x27;, &#x27;keywords&#x27;, &#x27;for&#x27;, &#x27;replacementWord1&#x27;],
 &#x27;replacementWord2&#x27;: [&#x27;list&#x27;, &#x27;of&#x27;, &#x27;keywords&#x27;, &#x27;for&#x27;, &#x27;replacementWord2&#x27;],
 ...
 &#x27;replacementWordN&#x27;: [&#x27;list&#x27;, &#x27;of&#x27;, &#x27;keywords&#x27;, &#x27;for&#x27;, &#x27;replacementWordN&#x27;]
}

keyword_processor.add_keywords_from_dict(keyword_dictionary )
</code></pre>
Each <code>key</code> in the dictionary is a string keyword. Each <code>value</code> must be a list. Alternatively, you can provide keywords through a <code>List</code>:
<pre><code class="hljs">keyword_processor.add_keywords_from_list([&#x27;list&#x27;, &#x27;of&#x27;, &#x27;keywords&#x27;])
</code></pre>
Though, with this approach - you just add the keywords without replacement words. Or, if a text file contains key-value pairs following a <code>key=&gt;value</code> syntax:
<pre><code class="hljs">keyword1=&gt;value1
keyword2=&gt;value2
</code></pre>
We can import them through the <code>keywords_from_file()</code> function:
<pre><code class="hljs">keyword_processor.add_keywords_from_file(&#x27;keyword_list.txt&#x27;)
</code></pre>
A popular approach, which allows you for the most flexibility and great readability is using a dictionary. It's also the most natural match for the algorithm, given the fact that it all ultimately ends up in a dictionary.
Now, let's take a look at a quick example. Imagine we have a textual document and we want to minimize the usage of synonyms in order to standardize the vocabulary used. In essence, we want to replace all occurrences of words such as awful, terrible and horrible (list of keywords) with the word bad (replacement word), and all occurrences of words such as fine, excellent and great, with the word good.
We would add those <code>keywords</code> and <code>replacement_words</code> to the <code>keyword_dictionary</code>:
<pre><code class="hljs">keyword_dictionary = {
 &quot;bad&quot;: [&quot;awful&quot;, &quot;terrible&quot;, &quot;horrible&quot;],
 &quot;good&quot;: [&quot;fine&quot;, &quot;excellent&quot;, &quot;great&quot;]
}
</code></pre>
And, finally, add the <code>keyword_dictionary</code> to the <code>keyword_processor</code> object:
<pre><code class="hljs">keyword_processor.add_keywords_from_dict(keyword_dictionary)
</code></pre>
<h3 id="replacekeywordswithreplacementwords">Replace Keywords with Replacement Words</h3>
Once we've loaded the keywords and their respective replacement words into the <code>KeywordProcessor</code> instance, we can execute <code>replace_keywords()</code> function, which scans the provided text, and executes the replacement:
<pre><code class="hljs">new_text = keywordProcessor.replace_keywords(&quot;Passed String&quot;)
</code></pre>
It parses through the provided text, replacing all of the keywords within it with their matched values, and returns a new string.
Now, we typically don't work with string literals here - but rather with documents. We'll want to open a document, read the lines within it, and pass those in as a string to the <code>replace_keywords()</code> function.

 <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 really long files, that might not fit into your local machine's memory - you might want to consider <a target=”_blank” href=”/read-a-file-line-by-line-in-python”>reading a file line-by-line</a>.

 </div>
 </div>
 </div>
 In any case, let's load in a text file and execute the <code>replace_keywords()</code> function on the contents:
<pre><code class="hljs"># Open the long textual document `data.txt`
with open(&#x27;data.txt&#x27;, &#x27;r+&#x27;) as file:
 # Load the content from `data.txt` to a variable as a string
 content = file.read()
 # Replace all desired keywords from `data.txt` and store it in the new variable
 new_content = keyword_processor.replace_keywords(content)
 # Replace the old content
 file.seek(0)
 file.truncate()
 # Write the alternated content to the original file 
 file.write(new_content)
</code></pre>
So if we feed a text file such as, <code>text.txt</code>:
<pre><code class="hljs">The breakfast was terrific! I really loved the eggs, you&#x27;re a great cook.
</code></pre>
With the following keywords and replacement words:
<pre><code class="hljs">from flashtext import KeywordProcessor
keyword_processor = KeywordProcessor()

keyword_dictionary = {
 &quot;good&quot;: [&quot;terrific&quot;, &quot;great&quot;],
 &quot;eggs&quot;: [&quot;hash browns&quot;]
}

keyword_processor.add_keywords_from_dict(keyword_dictionary)

with open(&#x27;data.txt&#x27;, &#x27;r+&#x27;) as file:
 content = file.read()
 new_content = keyword_processor.replace_keywords(content)
 file.seek(0)
 file.truncate()
 file.write(new_content)
</code></pre>
It'd result in an altered <code>text.txt</code> file:
<pre><code class="hljs">The breakfast was good! I really loved the hash browns, you&#x27;re a good cook.
</code></pre>
<h3 id="otherusefulfunctionalitiesoftheflashtextmodule">Other Useful Functionalities of the FlashText Module</h3>
Let's make a dummy <code>keyword_processor</code> and <code>keyword_dictionary</code> to illustrate some of the other useful functionalities of the <code>FlashText</code> module:
<pre><code class="hljs">keywordProcessor = KeywordProcessor()
keywordDictionary = {
 &quot;bad&quot;: [&quot;awful&quot;, &quot;terrible&quot;, &quot;horrible&quot;],
 &quot;good&quot;: [&quot;fine&quot;, &quot;excellent&quot;, &quot;great&quot;]
}
keywordProcessor.add_keywords_from_dict(keywordDictionary)
</code></pre>
To get a list of all keywords in the <code>KeywordProcessor</code> instance, we use the <code>get_all_keywords()</code> function:
<pre><code class="hljs"># List all added keywords
print(keywordProcessor.get_all_keywords())
</code></pre>
Which results in:
<pre><code class="hljs">{&#x27;awful&#x27;: &#x27;bad&#x27;, &#x27;terrible&#x27;: &#x27;bad&#x27;, &#x27;horrible&#x27;: &#x27;bad&#x27;, &#x27;fine&#x27;: &#x27;good&#x27;, &#x27;excellent&#x27;: &#x27;good&#x27;, &#x27;great&#x27;: &#x27;good&#x27;}
</code></pre>
To check if a keyword is present in the <code>KeywordProcessor</code>, we can use the <code>in</code> operator:
<pre><code class="hljs">&#x27;bad&#x27; in keywordProcessor
# Output: true
# keyword `bad` is PRESENT in the keywordProcessor

&#x27;red&#x27; in keywordProcessor
# Output: false
# keyword `red` is NOT PRESENT in the keywordProcessor

&#x27;awful&#x27; in keywordProcessor
# Output: false
# keyword `awful` is NOT THE KEYWORD in the keywordProcessor
# instead, it IS REPLACEMENT WORD
</code></pre>
And to access a <code>replacement_word</code> based on a certain <code>keyword</code>:
<pre><code class="hljs">keywordProcessor[&#x27;fine&#x27;]
# Output: &#x27;good&#x27;

keywordProcessor[&#x27;excellent&#x27;]
# Output: &#x27;good&#x27;

keywordProcessor[&#x27;goood&#x27;]
# Output: None
# There is no keyword `goood` in the keywordProcessor
</code></pre>
And finally, to remove keywords from a <code>KeywordProcessor</code>, we use the <code>remove_keyword()</code> function:
<pre><code class="hljs">keyword_processor.remove_keyword(&#x27;fine&#x27;)
# This will remove `fine` from the keywordProcessor
</code></pre>
​Alternatively, we can specify list or dictionary of keyword-value pairs that we want to remove, and use them to remove specific elements:
<pre><code class="hljs"># Using a dictionary to remove keywords
keywordProcessor.remove_keywords_from_dict({&quot;bad&quot;: [&quot;awful&quot;, &quot;terrible&quot;]})
# This will remove keywords `awful` and `terrible` from the keywordProcessor

# Using a list to remove keywords
keywordProcessor.remove_keywords_from_list([&quot;fine&quot;, &quot;excellent&quot;])
# This will remove keywords `fine` and `excellent` from the keywordProcessor
</code></pre>
<h2 id="flashtextvsregularexpressions">FlashText vs Regular Expressions</h2>
FlashText was primarily created as an alternative to regular expressions, so it would be useful to compare the two of them. In fact, it was created as a response to a <a rel="nofollow noopener" target="_blank" href="https://stackoverflow.com/questions/44178449/regex-replace-is-taking-time-for-millions-of-documents-how-to-make-it-faster/">question on StackOverflow</a>.
When comparing the speed of execution - FlashText is the clear winner. It takes around the same time for the same text, with a small and large number of keywords. On the other hand, with regular expressions - the execution time increases proportionally to the number of keywords to be replaced.
As the <a rel="nofollow noopener" target="_blank" href="https://www.freecodecamp.org/news/regex-was-taking-5-days-flashtext-does-it-in-15-minutes-55f04411025f/">author of FlashText notes</a> - for large queries, it can take regular expressions days to execute, while FlashText does it in 15 minutes:
<img src="https://s3.stackabuse.com/media/articles/search-and-replace-text-with-python-1.png" alt="replace-benchmark">
Credit: Vikash Singh, author of FlashText, at <a rel="nofollow noopener" target="_blank" href="https://www.freecodecamp.org/news/regex-was-taking-5-days-flashtext-does-it-in-15-minutes-55f04411025f/">FreeCodeCamp</a>
<blockquote>
Benchmarks have shown that FlashText takes less time than RegEx to find and replace keywords when the number of keywords exceeds 500.
</blockquote>
Though, when it comes to the special character matching, FlashText has no chance of beating regular expressions. Even more, FlashText doesn't even have the support for that kind of matching - it can only match plain keywords without any special characters.
<blockquote>
Special character matching describes the situations where some characters in the word have a special meaning and can match multiple different characters. 
For example, the character <code>\d</code> describes digits from 0 to 9, meaning that the keyword <code>number\d</code> will match words <code>number0</code>, <code>number1</code>, <code>number2</code>, etc. 
FlashText is not designed with special character matching in mind, so it can only match equal string literals. The word <code>number1</code> can only be matched with the keyword <code>number1</code> and there is no way of using a single keyword to match multiple different words.
</blockquote>
<h2 id="conclusion">Conclusion</h2>
As we've already seen, FlashText is a very simple yet powerful tool. It is pretty lightweight, easy to learn, and very time-efficient no matter the number of keywords to be replaced.
As with any other tool, the key is to know what is the best use-case scenario for it. If you have more than 500 keywords to be replaced and those keywords are simple, without any special character matching, there is no reason not to go with the FlashText over regular expressions.
On the other hand, if you have less than 500 keywords or some kind of special character matching, you should probably ditch FlashText and go with good old regular expressions given their flexibility and syntax.

Dimitrije Stamenic

In this tutorial, we'll take a look at how to find and replace words in a text file, using Python and FlashText, in an extremely efficient manner - without using regular expressions (regex).

Searching and Replacing Words in Python with FlashText

<h2 id="introduction">Introduction</h2>
The software engineering process often reveals to us many redundant elements inside the structure and code of our software. Knowing this, some of the primary responsibilities of a developer are to write easily understandable and maintainable code - not just solutions.
However, projects often get more complex with time, making the initial software structure a critical element that must be well thought-out and implemented from the very beginning.
<blockquote>
Design Patterns are intended to solve this issue.
</blockquote>
Design patterns are a set of standards used to optimize specific tasks related to the <a target="_blank" href="https://stackabuse.com/object-oriented-programming-in-python/">Object Oriented Programming</a> (OOP) paradigm. They aim to reduce the overall count of code lines, optimize structures, and standardize the software architecture.
The Object-Oriented Programming paradigm delivers a structure based on classes, where each class represents a blueprint for an object (instance of that class) that has its own attributes and methods. These classes are related and have their own dependencies, compositions, inheritance, etc. Translating real-life problems and structures to software solutions is the primary motivation for implementing this structure.
In this guide, we’ll explore one of the Behavioral Design Patterns and its implementation in Python: the Template Method.
This design pattern will give us a general method composed of multiple steps. The classes related to our template method class can then call these steps individually or overwrite them.
In addition, we’ll learn how to use the <a rel="nofollow noopener" target="_blank" href="https://docs.python.org/3/library/abc.html">ABC Library</a> in Python, which defines an inheritance relationship for abstract base classes (ABCs). We'll use this library to create a simple template method example.
<h2 id="behavioraldesignpatterns">Behavioral Design Patterns</h2>
The Template Method is a Behavioral Design Pattern. What is a Behavioral Design pattern exactly?
<blockquote>
There are three widely recognized software design patterns: Creational, Structural, and Behavioral.
</blockquote>
<ul>
<li>
Creational Design Patterns are intended to enable the creation of objects while abstracting/hiding away the object's creation logic. Creational Design Patterns are used to give programs greater flexibility in selecting the objects they should create for any use case.
</li>
<li>
Structural Design Patterns are intended to handle the composition of objects and classes, relying on inheritance to control how objects are created and given functions.
</li>
<li>
Behavioral Design Patterns are focused on the communication that occurs between objects, controlling how data moves between objects, and distributing behavior between classes.
</li>
</ul>
<blockquote>
The Template Method is focused on the distribution of functions and methods across classes.
</blockquote>
<h2 id="thetemplatemethoddesignpattern">The Template Method Design Pattern</h2>
The template method design pattern allows us to create a base class that contains some number of steps needed to complete a process. When you define these steps with a template, it becomes possible to create one or more concrete classes and overwrite the template steps. This lets you implement some or all of the steps, depending on the concrete class, without overwriting the entire process.
To use the template method, we require an abstract class. The abstract class is essentially one major process broken up into smaller steps or minor processes. To put that another way, the abstract class will make use of the template method (the major process) and within the template we’ll find calls to the minor steps that complete the major process. These minor processes will be methods/functions that the concrete classes can call.
Using an abstract class means we don’t have to instantiate the whole base class to get access to the steps defined with the template method. Instead, we can create subclasses from the abstract class and overwrite just the steps we need in the individual subclasses.
Once we define the abstract class, we can create the concrete classes that will overwrite the steps we need. We’ll use an inheritance relationship to achieve this. Depending on the context of the concrete class, we will overwrite all the steps or just some of them.
We can represent the structure of the template method with a class diagram like this, in accordance with the OOP paradigm:
<img src="https://s3.stackabuse.com/media/articles/template-method-design-pattern-in-python-1.jpg" alt="UML diagram of the template method design pattern">
Here you can see that we begin by creating an abstract class with a template method consisting of multiple steps/functions. From this abstract class, we create two concrete classes that use different steps of the template method.
<h3 id="thetemplatemethodvsthefactorymethod">The Template Method vs the Factory Method</h3>
There's some confusion regarding the differences between the Template method Pattern and the <a target="_blank" href="https://stackabuse.com/the-factory-method-design-pattern-in-python">Factory Method Pattern</a>. This is because their structure is similar, although they aren't the same thing. The Factory Method is a Creational Pattern used to create objects from a superclass. In contrast, the Template Method is a Behavioral Pattern used to define a general method composed of steps that can be modified by subclasses of the abstract class, containing the template method.
<blockquote>
In other words, while the Factory Method creates objects, the Template Method overwrites the functionalities of a major/base process.
</blockquote>
Now that we've clarified the difference between these patterns, we can explore how to implement the Template Method Design Pattern in Python.

 <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: Python doesn’t support abstract classes without using a specific library. To use abstract class associations, we need to import the <a rel="nofollow noopener" target="_blank" href="https://docs.python.org/3/library/abc.html">ABC</a> library.

 </div>
 </div>
 </div>
 <h2 id="theabclibrary">The ABC Library</h2>
The ABC library provides infrastructure for managing abstract base classes in Python. This means we can create class relationships like inheritance or implementations for abstract classes - something required for implementing most design patterns and particularly important in the Template Method's case.
<h2 id="whentousethetemplatemethodpattern">When to Use the Template Method Pattern?</h2>
You'll want to use the Template Method when you need to use or modify some or all of the steps of an algorithm. In these cases, you'll need to differentiate the steps of your algorithm or process, making them individually accessible via inheritance or implementation.
Let's take a look at a practical example:
We have two groups of researchers, one from University A and another from University B. These two groups are studying the effects of quarantine, implemented by governments in response to the SARS‑CoV‑2 pandemic. Both groups have the same base research process. The basic research process is a template that the two research groups can use to proceed with their investigation. Yet the research groups can customize the research process in terms of:
<ul>
<li>Which steps are carried out during the research.</li>
<li>How each research step is carried out.</li>
</ul>
Let's represent this research with a class diagram before creating the model with Python code.
The research guideline is composed of 4 steps:
<ul>
<li>University A decides to apply 2 of the 4 steps (2 and 3)</li>
<li>University B applies the 3 of the steps (1, 3 and 4)</li>
<li>Both groups modified all the chosen steps.</li>
<li>Finally, step number 3 must be applied for both groups as it is mandatory.</li>
</ul>
We already have our diagram class, we just have to change it so it fits with our problem.
Updating the diagram to fit the conditions we specified, we end up with the following model:
<img src="https://s3.stackabuse.com/media/articles/template-method-design-pattern-in-python-2.jpg" alt="UML diagram - Python implementation of template method design pattern">
<h2 id="implementingthetemplatemethoddesignpatterninpython">Implementing the Template Method Design Pattern in Python</h2>
Now that we have the outline for our abstract and concrete classes, let's implement them in Python.
Let's start with our abstract class - <code>researchGuideline.py</code>, which will contain our template methods with the four principal steps for the research.
First, we'll import the ABC library. This library contains a class called <code>ABC</code>, and we'll use it as a superclass for our research template, turning it into an abstract base class.
Next, we'll define our steps as class methods. These methods will be empty for now, but when we define the subclasses - they will overwrite the steps:
<pre><code class="hljs"># Importing the ABC library
from abc import ABC, abstractmethod

# Creating our abstract class:
class ResearchGuideline(ABC):
 
 # Template Method definition:
 def templateMethod(self):
 # Calling all the steps
 self.step1()
 self.step2()
 self.step3()
 self.step4()
 
 # Defining the Template Method Steps
 def step1(self):
 pass

 def step2(self):
 pass
 
 @abstractmethod
 def step3(self):
 pass

 def step4(self):
 pass
</code></pre>
Notice how we added the <code>@abstractmethod</code> decorator to step 3. This shows that an abstract class' subclasses must always overwrite that method. We must include this decorator in the imports, as it’s also part of the ABC library.
Let's define our concrete classes now. We are talking about Universities A and B, with their respective steps. We will create a subclass for both of the universities by using the <code>ResearchGuideline</code> template.
For both classes, we have to import the <code>ResearchGuideline</code> class and create an inheritance between the superclass and the subclass. This allows us to use the steps we defined in the guideline/template and overwrite them. The application of the steps will be a simple log/print in this case.
Let's start with the first subclass:
<pre><code class="hljs">from researchGuideline import ResearchGuideline

class UniversityA(ResearchGuideline):
 def step2(self):
 print(&quot;Step 2 - Applied by University A&quot;)
 
 def step3(self):
 print(&quot;Step 3 - Applied by University A&quot;)
</code></pre>
We'll save this in a Python file called <code>universityA</code>. Now let's set up the second subclass:
<pre><code class="hljs">from researchGuideline import ResearchGuideline

class UniversityB(ResearchGuideline):
 def step1(self):
 print(&quot;Step 1 - Applied by University B&quot;)
 
 def step3(self):
 print(&quot;Step 3 - Applied by University B&quot;)

 def step4(self):
 print(&quot;Step 4 - Applied by University B&quot;)
</code></pre>
We'll save this in a Python file called <code>universityB</code>.
Notice that we've indicated which university is applying which steps. This helps us appreciate the variation between the two concrete classes.
Our model of the template method, including the abstract class and concrete classes, is done! Now let's create our client script, so that we can apply the model.
First, let's import our classes. This involves importing the abstract class and the two concrete classes. Then, we'll create a function that receives a <code>ResearchGuideline</code> object as a parameter, which is our template/abstract class.
Here's the beauty of the inheritance relationship - because the university classes are subclasses from <code>ResearchGuideline </code>they share the same object type.
We can pass either the <code>UniversityA</code> or <code>UniversityB</code> object as the argument into our function that calls template method (this is <code>client_call()</code> below), and the steps overwritten by the concrete class will change how the template method executes.
Here we use both classes, so we can compare the outputs:
<pre><code class="hljs"># Imports
from researchGuideline import *
from universityA import UniversityA
from universityB import UniversityB

# Auxiliary function
def client_call(research_guideline: ResearchGuideline):
 research_guideline.templateMethod();

# Entry point
if __name__ == &#x27;__main__&#x27;:
 # Calling the Template Method using the University A class as parameter
 print(&quot;University A:&quot;)
 client_call(UniversityA())
 
 # Calling the Template Method using the University A class as parameter
 print(&quot;University B:&quot;)
 client_call(UniversityB())
</code></pre>
Running this code, we obtain the following output:
<pre><code class="hljs">University A:
Step 2 - Applied by University A
Step 3 - Applied by University A
University B:
Step 1 - Applied by University B
Step 3 - Applied by University B
Step 4 - Applied by University B
</code></pre>
<h2 id="conclusion">Conclusion</h2>
The template method is an effective way to distribute tasks between classes, redefine processes, and reduce code. Applying this design pattern to an algorithm or solution can help you avoid redundant methods and streamline longer execution processes.
The template method is also an example of the proper use of the OOP paradigm. The model can't be applied in every instance, so be sure to understand your project's needs before using it.

Dan Nelson

Juan Hurtado

In this guide, we'll take a look at the theory and implementation on the Template Method - a Behavioral Design Pattern, in Python.

Template Method Design Pattern in Python

<h2 id="introduction">Introduction</h2>
Whether you are creating a daily routine app, your own blog, or most any other type of dynamic web app, you will probably need to work with dates. In this article, we're going to learn how to get the current date in JavaScript, so you can successfully develop your applications. In JavaScript, there are a plethora of options to choose from, but the main class being used is <code>Date()</code>. It has a lot of methods and how you use it will depend on the format of the date you want to get. Afterwards, I will show you a popular JavaScript library that can be used for formatting time in general, and not just dates.
<h2 id="usingthedateclass">Using the Date() class</h2>
<code>Date()</code> is a go-to class in JavaScript when talking about time. There are several ways to get the time and date in a granular manner from this class!
<h3 id="usinggetdategetmonthandgetfullyearmethods">Using getDate(), getMonth() and getFullYear() methods</h3>
Note for getDate method: The first thing to notice when using this approach is that we use <code>getDate</code> and not <code>getDay</code>. The reason is that the <code>getDay</code> method returns the day of the week, so since it's Friday now as I'm writing, the <code>getDay</code> method would return 5. The method <code>getDate</code> actually does what we need in this case, it returns the day of the month number. So for me, right now the day of the month is 21 (because it's 21.05.2021.). These methods are easily confused, so I wanted to give a heads up.
Note for getMonth method: Another thing to watch out for is that the month indexes start from 0, so January is 0, February is 1, etc. Basically, when we retrieve the month number, we need to add 1.
Now that we got the potential problems out the way, let's code:
<pre><code class="hljs">let date = new Date()
let day = date.getDate();
let month = date.getMonth()+1;
let year = date.getFullYear();

let fullDate = `${day}.${month}.${year}.`;
console.log(fullDate);
</code></pre>
At first, we instance the class <code>Date</code> and for each part of the date, we use a variable to break it out and inspect each.
We placed each method result in a separate variable and then used <a target="_blank" href="/es6-template-string-literals-in-nodejs">string interpolation</a> to create a complete date. String interpolation is when we pass variables to string; in JavaScript this is achieved between back-ticks ( `` ) and variables are placed in <code>${variableName}</code>. If you don't prefer string interpolation, the other way around this is to simply concatenate (add) strings together like this:
<pre><code class="hljs">let fullDate = day + &quot;.&quot; + month + &quot;.&quot; + year + &quot;.&quot;;
</code></pre>
Our results will be the same in each case:
<pre><code class="hljs">21.5.2021. // string interpolation
21.5.2021. // string concatenation
</code></pre>
Say you want to show the month as <code>05</code> and not <code>5</code>. Unfortunately JavaScript's built-in <code>Date</code> class doesn't have many options for formatting dates to strings like other libraries do. So in this case we'll need to do the formatting ourselves, which we can do with some of JavaScript's methods on strings, like <code>padStart(length, substring)</code>. What it does is &quot;pads&quot; (i.e. prefixes) our string with the<code>substring</code>, until it reaches <code>length</code>. So since we want to make <code>05</code> from <code>5</code>, we want to pad the string with &quot;0&quot; until it reaches length 2. Before all that, we need to cast <code>date.getMonth()+1</code> to type <code>String</code>. Casting is explicitly changing a variable's type from one to the other. Here we change type <code>number</code> to type <code>String</code>. Our <code>month</code> variable will change to:
<pre><code class="hljs">let month = String(date.getMonth()+1).padStart(2, &quot;0&quot;);
</code></pre>
This will change our date format to:
<pre><code class="hljs">21.05.2021.
</code></pre>
<h3 id="usingtojsonmethod">Using toJSON() Method</h3>
Previous method left space for date formatting; you could have a date like <code>dd/mm/yyyy</code>, <code>dd-mm-yyyy</code>, <code>dd.mm.yyyy</code> and all the other variations relating the order of day, month, and year. When using <code>toJSON()</code>, it returns a <code>yyyy-mm-dd</code> format alongside the time format, <code>hh:mm:ss.ms</code>.
Let's preview this approach:
<pre><code class="hljs">let date = new Date().toJSON();
console.log(date);
</code></pre>
This will output:
<pre><code class="hljs">2021-05-21T13:42:07.553Z
</code></pre>
You should see an output similar to this, but obviously your output will be different depending on when you ran the code. We see that we need only the date, which is the first 10 characters, so let's use JavaScript's <code>slice()</code> method. Method <code>slice(a, b)</code> slices a string from point <code>a</code> to point <code>b</code>; in our example from 0 to 10. Let's try it:
<pre><code class="hljs">let date = new Date().toJSON().slice(0, 10);
</code></pre>
This will return:
<pre><code class="hljs">2021-05-21
</code></pre>
We can further slice this string, so we can arrange the parts to variables <code>day, month</code> and <code>year</code>, but it would be overdoing it, so if you need a different format, just use a different approach.
<h3 id="usingtoisostring_toutcstring_andtolocaledatestringmethods">Using toISOString(),_ toUTCString()_, and toLocaleDateString() Methods</h3>
Fun fact: <code>toISOString()</code> returns the exact same result as <code>toJSON()</code>, so we will skip it and go straight into <code>toUTCString()</code>.
<h4 id="usingtoutcstring">Using toUTCString()</h4>
<pre><code class="hljs">let date = new Date().toUTCString();
console.log(date);
</code></pre>
Will give us the output:
<pre><code class="hljs">Fri, 21 May 2021 13:53:30 GMT
</code></pre>
This format also returns date and time, with the addition of the day of the week. As I said in the <code>toJSON()</code> section, you could parse this result further, but it would probably be unnecessary since you have different approaches. Since we're only getting the date, we can slice this. Now there's no need for casting, because this is already a <code>String</code>:
<pre><code class="hljs">let date = new Date().toUTCString().slice(5, 16);
</code></pre>
This will give us the desired output:
<pre><code class="hljs">21 May 2021
</code></pre>
<h4 id="usingtolocaledatestring">Using toLocaleDateString()</h4>
This method returns the date in a format corresponding to your system's language. It even has the option to pass the desired language as an argument and even simple date formatting options such as <code>weekday</code>, <code>month</code>, <code>day</code>, etc. We will divide this into 3 examples:
<ol>
<li>
Default options
Let's see what happens when we call the method without any arguments:
<pre><code class="hljs">let date = new Date().toLocaleDateString();
console.log(date);
</code></pre>
The output, for me, will be:
<pre><code class="hljs">5/21/2021
</code></pre>
This output depends on your locale, mine is US so the format will be as US date format.
</li>
<li>
Passing only language preference
If you want define a specific locale, you can pass it as a string argument, like so:
<pre><code class="hljs">let date = new Date().toLocaleDateString(&quot;fr-FR&quot;);
console.log(date);
</code></pre>
The <code>fr-FR</code> is a locale code for France. You can find all the locale codes <a rel="nofollow noopener" target="_blank" href="https://saimana.com/list-of-country-locale-code/">here</a>.
The French date format is <code>dd/mm/yyyy</code>, so the output will be:
<pre><code class="hljs">21/5/2021
</code></pre>
</li>
<li>
Passing both language preference and options
Finally, let's go through the possible options. Only month and weekday can have a value of &quot;long&quot; or &quot;numeric&quot;. Day and year can only be &quot;numeric&quot;:
<ul>
<li>day</li>
<li>month</li>
<li>year</li>
<li>weekday</li>
</ul>
</li>
</ol>
<pre><code class="hljs">const dateOptions = { 
 day: &#x27;numeric&#x27;,
 month: &#x27;long&#x27;,
 year: &#x27;numeric&#x27;
};

console.log(event.toLocaleDateString(&#x27;fr-FR&#x27;, dateOptions));
</code></pre>
We will exclude <code>weekday</code> since we only need the date. This should output:
<pre><code class="hljs">21 mai 2021
</code></pre>
Now you learned a bit of French, as well.
<h3 id="usingnow">Using now()</h3>
Method <code>now()</code> returns the number of milliseconds passed from January 1st, 1970 - which is the beginning of the Unix epoch in programming. If we pass the number of milliseconds to the <code>Date</code> constructor, we can get an ISO format date. Let's try it:
<pre><code class="hljs">let time = Date.now()
console.log(time);
</code></pre>
Which will output, again, for me:
<pre><code class="hljs">1621608925212
</code></pre>
Now if we pass that <code>time</code> to the constructor, as mentioned above, we can create a date object with that time:
<pre><code class="hljs">let date = new Date(time);
console.log(time);
</code></pre>
This will output:
<pre><code class="hljs">2021-05-21T14:55:25.212Z
</code></pre>
And we already know how to process this, using <code>slice()</code>.
<h2 id="usingmomentjs">Using moment.js</h2>
This is just an alternative for using all the previous methods, a library made specifically for dates and times in JavaScript. You can visit their website <a target="_blank" href="https://stackabuse.com/moment-js-a-better-date-library-for-javascript/">here</a>. Although this library has quite a few features, I will only go over how to create and do simple formatting for a date. Let's see how it works:
<pre><code class="hljs">moment.format();
moment.format(&#x27;Do MMMM YYYY&#x27;);
moment.format(&#x27;Do MMMM YY&#x27;);
</code></pre>
If you don't pass anything to format, you will get an ISO representation of the date, however, you can choose any format you want (and which is defined in Moment's documentation).
The code above will output:
<pre><code class="hljs">2021-05-21T17:17:02+02:00
May 21st 2021
May 21st 21
</code></pre>
This option is not the best if all you're looking for is retrieving the current date. This is because the Moment library is quite large and will bloat your JS code when used in front-end applications. On the other hand, if you need date and time manipulation or more advanced formatting, this is a great library.
<h2 id="conclusion">Conclusion</h2>
There are numerous ways to retrieve a date in JavaScript, you just need to choose one that fits your use-case. For very simple needs, like creating a date or very simple formatting, then you can use the built-in <code>Date</code> class. If you need something a bit more complex with date and time, moments.js is a library to choose.

How to Get the Current Date in JavaScript

<h2 id="introduction">Introduction</h2>
In this tutorial, we'll take a look at how to get the current URL of a loaded HTML page, using JavaScript.
Firstly, let's take a look at a URL:
<pre><code class="hljs">https://www.stackabuse.com:8080/category/article-title.html?searchterm=Example+title#2
</code></pre>
It's a made-up URL, that contains several components - the protocol, domain, port, path, query and hash.
<blockquote>
If you'd like to avoid handling the parsing of URLs manually, especially with more complex URL formats such as Git's - read on <a target="_blank" href="">How to Easily Parse URLs in JavaScript with parse-url</a>!
</blockquote>
<h2 id="urlcomponents">URL Components</h2>
The URL we've defined consists of different segments, divided by certain special characters such as <code>/</code>, <code>?</code> and <code>#</code>. Each of these segments is a URL component:
<ul>
<li>
Protocol - The protocol of a URL refers to the URL segment which defines which protocol is used for data transfer. In our case, we're using <code>https://</code>, signifying the HTTPS protocol.
</li>
<li>
Domain - The domain, also known as the hostname of an URL refers to the proceeding section of a URL - <code>www.stackabuse.com</code>.
</li>
<li>
Port - The port section of an URL is specified after the domain, preceded by <code>:</code>. Most of the time, the port isn't public, so you'll rarely actually see it in deployed applications, but very commonly in the development phase.
</li>
<li>
Path - The path section of an URL follows the domain name and port. It specifies a single resource on a website, HTML page, image, or some other type of file or directory. In our example, the path refers to the <code>/category/article-title.html</code> segment, meaning that it points to the <code>article-title.html</code> file on the server.
</li>
<li>
Query - The query is a string that is usually used to enable internal searches on a website. The query section refers to the <code>?articleTitle=Example+title</code> section of the example URL and is a result of the user entering the search term <code>Example title</code> on the <code>article-title.html</code> page of the website.
</li>
<li>
Hash - The hash section is usually used to represent an anchor on the page, which is commonly a heading, but can be any other <code>&lt;div&gt;</code> or tag, given that we aim at its <code>id</code> attribute. In our case, we aim at <code>#2</code>, scrolling the user's view to the tag with an <code>id=2</code>.
</li>
</ul>
Generally speaking, URLs have a fairly standardized structure, where certain elements are optional, while others aren't:
<pre><code class="hljs">&lt;protocol&gt;//&lt;domain&gt;:&lt;port&gt;/&lt;path&gt;/&lt;query&gt;&lt;hash&gt;
</code></pre>
Now, we can take a closer look at how to access the current URL, as well as each of its components using JavaScript.
<h2 id="howtogetcurrenturlinjavascript">How to Get Current URL in JavaScript</h2>
In JavaScript, the <code>Location</code> object contains the information regarding the URL of the currently loaded webpage. It belongs to <code>window</code>, though, we can access it directly because <code>window</code> is hierarchically located at the top of the scope
To get the current URL, we'll leverage the <code>Location</code> object and retrieve its <code>href</code> property:
<pre><code class="hljs">let url = window.location.href
console.log(url)
</code></pre>
This results in:
<pre><code class="hljs">https://www.stackabuse.com:8080/python/article-title.html?searchterm=Example+title#2
</code></pre>
The <code>href</code> property contains the full URL to the currently loaded resource. If you'd like to retrieve some certain components, rather than the entire URL, the <code>Location</code> object has various properties as well.
<h3 id="geturlorigin">Get URL Origin</h3>
The <code>window.location.origin</code> property returns the base URL (protocol + hostname + port number) of the current URL:
<pre><code class="hljs">console.log(window.location.origin)
</code></pre>
<pre><code class="hljs">https://www.stackabuse.com:8080
</code></pre>
<h3 id="geturlprotocol">Get URL Protocol</h3>
The <code>window.location.protocol</code> property returns the protocol used by the current URL:
<pre><code class="hljs">console.log(window.location.protocol)
</code></pre>
<pre><code class="hljs">https://
</code></pre>
<h3 id="geturlhostandhostname">Get URL Host and Hostname</h3>
The <code>window.location.host</code> property returns the hostname and the port number of the current URL:
<pre><code class="hljs">console.log(window.location.host)
</code></pre>
<pre><code class="hljs">www.stackabuse.com:8080
</code></pre>
On the other hand, the <code>window.location.hostname</code> property returns the hostname of the current URL:
<pre><code class="hljs">console.log(window.location.hostname)
</code></pre>
<pre><code class="hljs">www.stackabuse.com
</code></pre>
<h3 id="geturlport">Get URL Port</h3>
The <code>window.location.port</code> property returns the port number of the current URL:
<pre><code class="hljs">console.log(window.location.port)
</code></pre>
<pre><code class="hljs">8080
</code></pre>
<h3 id="geturlpath">GET URL Path</h3>
The <code>window.location.pathname</code> property returns the path section of the current URL:
<pre><code class="hljs">console.log(window.location.pathname)
</code></pre>
<pre><code class="hljs">/category/article-title.html
</code></pre>
<h3 id="geturlqueryandhash">Get URL Query and Hash</h3>
The <code>window.location.search</code> property returns **the query section ** of the current URL:
<pre><code class="hljs">console.log(window.location.search)
</code></pre>
<pre><code class="hljs">?searchterm=Example+title
</code></pre>
The <code>window.location.hash</code> property returns the hash section of the current URL:
<pre><code class="hljs">console.log(window.location.hash)
</code></pre>
<pre><code class="hljs">#2
</code></pre>
<h2 id="conclusion">Conclusion</h2>
As we've seen, JavaScript provides a powerful, yet simple, way of accessing the current URL. The <code>Location</code> object, accessed by the <code>Window</code> interface enables us to get not only the string representation of the current URL but every single section of it.
The <code>Location</code> object also can change and manipulate the current URL, <a target="_blank" href="https://stackabuse.com/javascript-how-to-redirect-to-another-webpage/">as well as redirect the page to the new URL</a>.

In this tutorial, we'll take a look at how to get the current URL in JavaScript, including its components such as the protocol, domain, port, path, query and hash.