<h2 id="introduction">Introduction</h2>
Bash utilities make so many tasks simple, but not all tasks have a straightforward command or operator. A very common and usual task in many scripting scenarios is concatenating string variables.
Bash doesn't have a built-in function or command-line utility to concatenate two strings together. However, there are many ways you can accomplish this.
<h2 id="concatenatingstringsinbash">Concatenating Strings in Bash</h2>
The following are the steps by which the strings can be concatenated, ordered by the level of complication:
<ol>
<li><code>echo</code> both variables</li>
<li>Format using <code>printf</code></li>
<li>Format using <code>awk</code></li>
<li>Concat string files using <code>join</code></li>
</ol>
Throughout the article, we will be using the variables - <code>string1</code> and <code>string2</code> which you can create in your shell by entering:
<pre><code class="hljs">$ string1=&quot;Stuck&quot;
$ string2=&quot;Together&quot;
</code></pre>
<h3 id="concatenatestringsinbashwithecho">Concatenate Strings in Bash with echo</h3>
Perhaps the simplest of all the hacks is to simply echo both variables formatted next to each other:
<pre><code class="hljs">$ echo &quot;${string1}&quot; &quot;${string2}&quot;
</code></pre>
Notice that we have a blank between both the strings. The snippet can also be written as:
<pre><code class="hljs">$ echo &quot;${string1} ${string2}&quot;
</code></pre>
Both of the snippets will give the same output:
<pre><code class="hljs">Stuck Together
</code></pre>
<h3 id="concatenatestringsinbashwithprintf">Concatenate Strings in Bash with printf</h3>
Let's try concatenating the strings by printing a formatted output on the teletypewriter i.e. terminal. Consider the following snippet, where two string format tags (<code>%s</code>) are split by an empty space that is ready to be substituted by the two variables - <code>$string1</code> and <code>$string2</code>:
<pre><code class="hljs">$ printf &quot;%s %s\n&quot; &quot;$string1&quot; &quot;$string2&quot;
</code></pre>
The two format tags, when substituted with our string variables output:
<pre><code class="hljs">Stuck Together
</code></pre>
String formatting may sound familiar if you are familiar with programming languages. If this sounds overwhelming to you, it's good to learn about what the different tags do (such as <code>%s</code> and <code>%d</code>), which could come in quite handy.
<h3 id="concatenatestringsinbashwithawk">Concatenate Strings in Bash with awk</h3>
A slightly less known command - the <code>awk</code> command, invokes AWK - a scripting language specifically designed for manipulating text and extract strings from them. It doesn't come as a surprise that a scripting language dedicated to manipulating strings also has the ability to concatenate them:
<pre><code class="hljs">$ echo &quot;$string1&quot; &quot;$string2&quot; | awk &#x27;{printf &quot;%s~%s\n&quot;,$1,$2}&#x27;
</code></pre>
Let's break up the command above. We have two snippets chained to each other (hence the <code>|</code> chaining operator). We are sending both the variables <code>string1</code> and <code>string2</code> as inputs to the <code>awk</code> command.
<blockquote>
The syntax of the <code>awk</code> command is: <code>awk '{some_operation}'</code>.
</blockquote>
In our case, we are performing a <code>printf</code> operation inside. We refer to the variables as <code>$1</code> and <code>$2</code>; these refer to the variables passed as arguments from the <code>echo</code>.
Just to show a variation here, we are using a tilde(<code>~</code>) separating the format tags. Thus, it gives the following output:
<pre><code class="hljs">Stuck~Together
</code></pre>
<h3 id="concatenatestringsinbashwithjoin">Concatenate Strings in Bash with join</h3>
Now that the bars have been raised, let's try one final method. Let's try storing our strings in two separate files with one column each. The file <code>string1.txt</code> contains the word <code>&quot;Stuck&quot;</code> written two times in three lines. Same as before, <code>string2.txt</code> will contain the word <code>&quot;Together&quot;</code> written two times in three lines and the following commands create the files for us:
<pre><code class="hljs">$ echo &quot;1 Stuck&quot; &gt; &quot;string1.txt&quot;
$ echo &quot;2 Stuck&quot; &gt;&gt; &quot;string1.txt&quot;
$ echo &quot;1 Together&quot; &gt; &quot;string2.txt&quot;
$ echo &quot;2 Together&quot; &gt;&gt; &quot;string2.txt&quot;
</code></pre>
Both the files can be concatenated by using the following command:
<pre><code class="hljs">$ join string1.txt string2.txt
</code></pre>
For the join command to work, both the files should have a matching column. In our case, we have the matching index column and we get the concatenated output as shown below:
<pre><code class="hljs">1 Stuck Together
2 Stuck Together
</code></pre>
<h2 id="conclusion">Conclusion</h2>
There are multiple ways to perform the concatenation of strings in bash scripting. The choice of the method depends on the level of complexity and the nature of the problem. Which one will you choose?

Marcus Sanatan

Sathiya Sarathi Gunasekaran

Bash does not have a direct command to concatenate strings. However, Bash gives us multiple ways to join them still. Let's find out what they are!

How to Concatenate String Variables in Bash

David Landup

Dimitrije Stamenic

In this tutorial, we'll take a look at the theory and implementation of Radix Sort in Python, as well as Counting Sort as its main subroutine, with illustrated examples.

Radix Sort in Python

<h2 id="introduction">Introduction</h2>
In this tutorial, we'll take a look at how to generate random integers in a specific range in Java.
We'll be taking a look at several approaches, including core Java and third-party solutions:
<ul>
<li><a href="#randomints">Random.ints()</a></li>
<li><a href="#randomnextint">Random.nextInt()</a></li>
<li><a href="#mathrandom">Math.random()</a></li>
<li><a href="#securerandomnextint">SecureRandom.nextInt()</a></li>
<li><a href="#threadlocalrandomnextint">ThreadLocalRandom.nextInt()</a></li>
<li><a href="#splittablerandomints">SplittableRandom.ints()</a></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 each approach, we'll cover how to generate one random integer as well as how to generate a sequence of random integers.

 </div>
 </div>
 </div>
 All of these methods are lower-bound inclusive, and upper-bound exclusive.
<h2 id="randomints">Random.ints()</h2>
We're starting off with <code>Random.ints()</code> which was added to the <code>Random</code> class in Java 8, exactly for this purpose. Java originally didn't have a fully intuitive solution for this task, built-in.
The <code>ints()</code> method returns a sequence of random values, in the form of an <code>IntStream</code>. Being a <code>Stream</code> implementation, it's unbounded:
<pre><code class="hljs">Random random = new Random();
random.ints().forEach(System.out::println);
</code></pre>
This results in:
<pre><code class="hljs">-526320702
-744603161
474879020
1864311422
406782252
...
</code></pre>
This is an unbounded <code>IntStream</code>, which will generate any value from <code>Integer.MIN_VALUE</code> to <code>Integer.MAX_VALUE</code>. However, you can specify a range, as well as the number of elements you'd like to generate.
Additionally, the first argument is the number of elements you'd like to generate - otherwise, the stream will be generate an unlimited number of elements, until your Heap Memory space runs out:
<pre><code class="hljs">List&lt;Integer&gt; intList = new Random().ints(5, 1, 11)
 .boxed()
 .collect(Collectors.toList());

System.out.println(intList);
</code></pre>
Before collecting the <code>IntStream</code>, we'll have to box it via the <code>boxed()</code> method, which returns a stream consisting of the elements of the <code>IntStream</code>, boxed to an <code>Integer</code>. Then, we run <code>collect()</code> on the returned stream - not the original one.
The <code>collect()</code> method of the <code>IntStream</code> doesn't return a collection - it runs a <a rel="nofollow noopener" target="_blank" href="https://docs.oracle.com/javase/8/docs/api/java/util/stream/package-summary.html#MutableReduction">mutable reduction operation</a>.
Running this code results in:
<pre><code class="hljs">[1, 9, 9, 6, 2]
</code></pre>
To generate a single random integer, you can simply tweak the first argument of the <code>ints()</code> method, or use the <code>findFirst()</code> and <code>getAsInt()</code> methods to extract it from the <code>IntStream</code>:
<pre><code class="hljs">int randomInt = new Random().ints(1, 1, 11).findFirst().getAsInt();
System.out.println(randomInt);
</code></pre>
This results in a random integer in the range between <code>1..10</code> (second argument is exclusive):
<pre><code class="hljs">5
</code></pre>
<h2 id="randomnextint">Random.nextInt()</h2>
A more classic example that you'll often see people using is simply utilizing the <code>Random.nextInt()</code> method. It accepts a <code>bound</code> parameter, which sets the upper bound, and sets the lower bound to <code>0</code> by default.
Unfortunately, it doesn't allow you to change this - so a quick and simple &quot;hack&quot; can be used to specify the boundaries:
<pre><code class="hljs">int min = 10;
int max = 100;

System.out.println(new Random().nextInt(max - min) + min);
</code></pre>
This results in a random integer in the range between <code>min</code> and <code>max</code>:
<pre><code class="hljs">53
</code></pre>
Generating a sequence of this would require us to call the method multiple times:
<pre><code class="hljs">public static List&lt;Integer&gt; intsInRange(int size, int lowerBound, int upperBound) {
 Random random = new Random();
 List&lt;Integer&gt; result = new ArrayList&lt;&gt;();
 for (int i = 0; i &lt; size; i++) {
 result.add(random.nextInt(upperBound - lowerBound) + lowerBound);
 }
 return result;
}
</code></pre>
This is a <code>List</code>-limited recreation of the <code>Random.ints()</code> functionality, which simply returns a list of randomly generated integers in a range, with a given size:
<pre><code class="hljs">List&lt;Integer&gt; integerList = intsInRange(5, 0, 10);
System.out.println(integerList);
</code></pre>
Running this code would result in something along the lines of:
<pre><code class="hljs">[3, 8, 2, 2, 9]
</code></pre>
<h2 id="securerandomnextint">SecureRandom.nextInt()</h2>
The <code>SecureRandom</code> class is an alternative to the classic <code>Random</code> class, but provides a cryptographically strong random number generator. <code>Random</code> internally relies on the system's clock to generate number seeds, which isn't truly random.
On the other hand, <code>SecureRandom</code> takes much more random data from the environment to generate a much more random seed.
If cryptographic safety is a thing you're concerned with, you may opt to use <code>SecureRandom</code> instead - which behaves in much the same way as <code>Random</code> from the developer's point of view:
<pre><code class="hljs">int max = 100;
int min = 10;

int randomInt = new SecureRandom().nextInt(max - min) + min;
System.out.println(randomInt);
</code></pre>
Which results in a random integer in the range between <code>min</code> and <code>max</code>:
<pre><code class="hljs">95
</code></pre>
And if you'd like to generate sequences, a helper method can be crafted:
<pre><code class="hljs">public static List&lt;Integer&gt; intsInRange(int size, int lowerBound, int upperBound) {
 SecureRandom random = new SecureRandom();
 List&lt;Integer&gt; result = new ArrayList&lt;&gt;();
 for (int i = 0; i &lt; size; i++) {
 result.add(random.nextInt(upperBound - lowerBound) + lowerBound);
 }
 return result;
}
</code></pre>
Which you can use as:
<pre><code class="hljs">List&lt;Integer&gt; integerList = intsInRange3(5, 0, 10);
System.out.println(integerList);
</code></pre>
And which results in:
<pre><code class="hljs">[0, 9, 5, 6, 5]
</code></pre>
<h2 id="mathrandom">Math.random()</h2>
The <code>Math</code> class provides us with great math-related helper methods. One of them is the <code>Math.random()</code> method, which returns a random value between <code>0..1</code>. Typically, it's used to generate random percentile values.
However, in a similar vein to the <code>Random.nextInt()</code> hack - you can utilize this functionality to generate any integer in a certain range:
<pre><code class="hljs">int min = 10;
int max = 100;

int randomNumber = (int)(Math.random() * (max + 1 - min) + min);
System.out.println(randomNumber);
</code></pre>
Though, this one is even less intuitive than the previous approach. Running this code results in something along the lines of:
<pre><code class="hljs">43
</code></pre>
If you'd like to work with a sequence, we'd create a helper method to append each generated value to a list:
<pre><code class="hljs">public static List&lt;Integer&gt; intsInRange(int size, int lowerBound, int upperBound) {
 List&lt;Integer&gt; result = new ArrayList&lt;&gt;();
 for (int i = 0; i &lt; size; i++) {
 result.add((int)(Math.random() * (upperBound + 1 - lowerBound) + lowerBound));
 }
 return result;
}
</code></pre>
And then we can call it as:
<pre><code class="hljs">List&lt;Integer&gt; integerList = intsInRange(5, 0, 10);
System.out.println(integerList);
</code></pre>
Which produces:
<pre><code class="hljs">[9, 0, 3, 2, 0]
</code></pre>
<h2 id="threadlocalrandomnextint">ThreadLocalRandom.nextInt()</h2>
If you're working in a multi-threaded environment, the <code>ThreadLocalRandom</code> class is meant to be used as a thread-safe equivalent to <code>Random</code>. Fortunately, it does offer a <code>nextInt()</code> method with both an upper and lower bound:
<pre><code class="hljs">int randomInt = ThreadLocalRandom.current().nextInt(0, 10);
System.out.println(randomInt);
</code></pre>
As usual, the lower bound is included, while the upper bound isn't:
<pre><code class="hljs">3
</code></pre>
Similarly, you can create a helper function to generate a sequence of these:
<pre><code class="hljs">public static List&lt;Integer&gt; intsInRange(int size, int lowerBound, int upperBound) {
 List&lt;Integer&gt; result = new ArrayList&lt;&gt;();
 for (int i = 0; i &lt; size; i++) {
 result.add(ThreadLocalRandom.current().nextInt(lowerBound, upperBound));
 }
 return result;
}
</code></pre>
Which you can use as:
<pre><code class="hljs">List&lt;Integer&gt; integerList = intsInRange4(5, 0, 10);
System.out.println(integerList);
</code></pre>
<pre><code class="hljs">[1, 9, 1, 9, 7]
</code></pre>
<h2 id="splittablerandomints">SplittableRandom.ints()</h2>
A less-known class in the Java API is the <code>SplittableRandom</code> class - which is used as a generator of pseudo-random values. As the name implies, it's splittable and runs in parallel, and is really only used when you have tasks that could split again into smaller sub-tasks.
It's worth noting that this class is also based on non-secure seed generation - if you're looking for a safe seed generation, use <code>SecureRandom</code>.
The class offers an <code>ints()</code> method, which from our perspective, works in the same way as <code>Random.ints()</code>:
<pre><code class="hljs">List&lt;Integer&gt; intList = new SplittableRandom().ints(5, 1, 11)
 .boxed()
 .collect(Collectors.toList());

System.out.println(intList);
</code></pre>
Which results in:
<pre><code class="hljs">[3, 2, 8, 10, 3]
</code></pre>
And, if you'd like to generate only one random number, you can ditch the collector and use <code>findFirst()</code> with <code>getAsInt()</code>:
<pre><code class="hljs">int randomInt = new SplittableRandom().ints(1, 1, 11).findFirst().getAsInt();
System.out.println(randomInt);
</code></pre>
Which results in:
<pre><code class="hljs">4
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we've taken an exhaustive look at how to generate random integers in range in Java.
We've gone over the newest and most useful method, as well as some other popular methods of finishing this task. Most of the approaches rely on the <code>Random</code> or <code>Random</code>-equivalent classes, used for more specific contexts.

In this tutorial, we'll go over how to generate random integer(s) in a specific range in Java - single and multiple values, in a wide variety of ways, with examples.

Java: Generate Random Integers in Range

<h2 id="introduction">Introduction</h2>
Plotly is a JavaScript-based, Python data visualization library, focused on interactive and web-based visualizations. It has the simplicity of Seaborn, with a high-level API, but also the interactivity of Bokeh.
In addition to the core library's functionality, using the built-in Plotly Express with Dash, makes it an amazing choice for web-based applications and interactive, data-driven dashboards, usually written in Flask.
In this guide, we'll take a look at how to plot a Scatter Plot with Plotly.
<blockquote>
Scatter Plots explore the relationship between two numerical variables (features) of a dataset.
</blockquote>
<h2 id="importdata">Import Data</h2>
We'll be working with the <a rel="nofollow noopener" target="_blank" href="https://www.kaggle.com/rashikrahmanpritom/heart-attack-analysis-prediction-dataset">Heart Attack Dataset</a> from Kaggle, which contains data on various bodily metrics that we could use as indicators of a heart attack possibility.
Let's import the dataset and print the <code>head()</code> to take a peek:
<pre><code class="hljs">import pandas as pd

df = pd.read_csv(&#x27;heart.csv&#x27;)
print(df.head())
</code></pre>
This results in:
<pre><code class="hljs"> age cp trtbps chol fbs restecg thalachh exng oldpeak slp caa output
0 63 3 145 233 1 0 150 0 2.3 0 0 1
1 37 2 130 250 0 1 187 0 3.5 0 0 1
2 41 1 130 204 0 0 172 0 1.4 2 0 1
3 56 1 120 236 0 1 178 0 0.8 2 0 1
4 57 0 120 354 0 1 163 1 0.6 2 0 1
</code></pre>
Let's explore the relationships between features such as the <code>thalachh</code> (maximum recorded heart rate), <code>trtbps</code> (resting blood pressure), <code>chol</code> (amount of cholesterol) and <code>output</code> (<code>0</code> or <code>1</code>, representing lower or higher chances of experiencing a heart attack respectively).
First, let's go ahead and save our features separately for brevity's sake:
<pre><code class="hljs">max_heartrate = df[&#x27;thalachh&#x27;]
resting_blood_pressure = df[&#x27;trtbps&#x27;]
cholesterol_level = df[&#x27;chol&#x27;]
output = df[&#x27;output&#x27;]
</code></pre>
<h2 id="plotascatterplotwithplotly">Plot a Scatter Plot with Plotly</h2>
Finally, we can go ahead and plot a Scatter Plot. Let's go ahead and first explore the relationship between <code>max_heartrate</code> and <code>cholesterol_level</code>. To plot a Scatter Plot with Plotly, we'll use the <code>scatter()</code> function of the Plotly Express (<code>px</code>) instance:
<pre><code class="hljs">fig = px.scatter(x=cholesterol_level, y=max_heartrate)
fig.show()
</code></pre>
The only required arguments are the <code>x</code> and <code>y</code> features, which will plot a Scatter Plot (without axis labels) in a spun-up server on your browser of choice:
<img src="https://s3.stackabuse.com/media/skill-trees/data-science-in-python/plotly-scatter-plot-tutorial-with-examples-1.png" alt="simple plotly scatter plot">
Alternatively, if you don't want to define your variables beforehand, Plotly offers the exact same syntax as Seaborn - you specify the data source, and the names of the features you'd like to visualize. This will map the features to labels, and plot them directly without having to specify the features like we did before:
<pre><code class="hljs">import pandas as pd
import plotly.express as px

df = pd.read_csv(&#x27;heart.csv&#x27;)

fig = px.scatter(df, x=&#x27;chol&#x27;, y=&#x27;thalachh&#x27;)
fig.show()
</code></pre>
This results in:
<img src="https://s3.stackabuse.com/media/skill-trees/data-science-in-python/plotly-scatter-plot-tutorial-with-examples-2.png" alt="plotly scatter plot with labels">
Note: You can also do a mish-mash of these approaches, where you supply your <code>DataFrame</code> as the source, but also use predefined variables instead of referencing the feature column-names in the <code>scatter()</code> call:
<pre><code class="hljs">fig = px.scatter(df, x=cholesterol_level, y=max_heartrate)
fig.show()
</code></pre>
This results in a labeled Scatter Plot as well:
<img src="https://s3.stackabuse.com/media/skill-trees/data-science-in-python/plotly-scatter-plot-tutorial-with-examples-2.png" alt="labeled plotly scatter plot">
There doesn't seem to be much of a correlation between the cholesterol level and maximum heart rate of individuals in this dataset.
<h2 id="customizingaplotlyscatterplot">Customizing a Plotly Scatter Plot</h2>
Now, we rarely visualize plain plots. The point is to visualize certain characteristics of data, intuitively.
In our case, this might include coloring the markers depending on the <code>output</code> feature, or adding <code>hover_data</code>, which specifies what's shown on the markers when someone hovers over them.
Currently, the <code>hover_data</code> isn't very helpful, only showing us the <code>x</code> and <code>y</code> values, which can already be reasonably inferred from observing the resulting plot.
Let's go ahead and change a few of the parameters to make this plot a bit more intuitive:
<pre><code class="hljs">import pandas as pd
import plotly.express as px

df = pd.read_csv(&#x27;heart.csv&#x27;)

fig = px.scatter(df, x=&#x27;chol&#x27;, y=&#x27;thalachh&#x27;, color=&#x27;output&#x27;, hover_data=[&#x27;sex&#x27;, &#x27;age&#x27;])
fig.show()
</code></pre>
We've set the <code>color</code> of each marker to be mapped to the <code>output</code> feature, coloring higher and lower chances of experiencing a heart attack in different colors. We've also included the <code>sex</code> and <code>age</code> of each individual on their markers.
This results in:
<img src="https://s3.stackabuse.com/media/skill-trees/data-science-in-python/plotly-scatter-plot-tutorial-with-examples-4.PNG" alt="customize plotly scatter plot">
Finally, you can also change the size of the marker, either passing it a scalar value (such as <code>5</code>) to the <code>fig.update_traces()</code> method, or by passing in a vector value (such as mapping the size to a feature) to the <code>size</code> argument.
Let's map the <code>oldpeak</code> feature with the size of each marker:
<pre><code class="hljs">import pandas as pd
import plotly.express as px

df = pd.read_csv(&#x27;heart.csv&#x27;)

fig = px.scatter(df, x=&#x27;chol&#x27;, 
 y=&#x27;thalachh&#x27;, 
 color=&#x27;output&#x27;, 
 size=&#x27;oldpeak&#x27;, 
 hover_data=[&#x27;sex&#x27;, &#x27;age&#x27;])
fig.show()
</code></pre>
Now, each marker will have a variable size, depending on the values of the <code>oldpeak</code> feature:
<img src="https://s3.stackabuse.com/media/skill-trees/data-science-in-python/plotly-scatter-plot-tutorial-with-examples-5.png" alt="variable size plotly scatter plot">
Or, if you want to specifically make all markers of the same, fixed size, you can update the <code>Figure</code>'s traces:
<pre><code class="hljs">import pandas as pd
import plotly.express as px

df = pd.read_csv(&#x27;heart.csv&#x27;)

fig = px.scatter(df, x=&#x27;chol&#x27;,
 y=&#x27;thalachh&#x27;,
 color=&#x27;output&#x27;,
 hover_data=[&#x27;sex&#x27;, &#x27;age&#x27;])

fig.update_traces(marker={&#x27;size&#x27;: 10}) 
fig.show()
</code></pre>
This results in:
<img src="https://s3.stackabuse.com/media/skill-trees/data-science-in-python/plotly-scatter-plot-tutorial-with-examples-6.png" alt="fixed size plotly scatter plot">
<h2 id="conclusion">Conclusion</h2>
In this guide, we've taken a look at how to plot a Scatter Plot using Python and Plotly.
If you're interested in Data Visualization and don't know where to start, make sure to check out our bundle of books on <a class="ebook-link" href="https://gum.co/data-visualization-in-python-book-bundle">Data Visualization in Python</a>:
<div style="border: 1px solid #ebebeb;padding: 15px;">
 <a class="ebook-link" rel="nofollow" target="_blank" href="https://gum.co/data-visualization-in-python-book-bundle" style="text-decoration: none;color: inherit;">
 <h4 style="margin-top: 10px;">Data Visualization in Python</h4>
 <div class="row">
 <div class="col-md-4 col-xs-12">
 <img class="img-responsive center-block" src="https://s3.stackabuse.com/media/ebooks/data-visualization-in-python/dvp-mpl-bundle-1-small.jpg">
 </div>
 <div class="col-md-8 col-xs-12 my-auto">
 Become dangerous with Data Visualization
 ✅ 30-day no-question money-back guarantee 
 ✅ Beginner to Advanced 
 ✅ Updated regularly for free (latest update in April 2021) 
 ✅ Updated with bonus resources and guides 
 </div>
 </div>
 </a>
</div>
Data Visualization in Python with Matplotlib and Pandas is a book designed to take absolute beginners to Pandas and Matplotlib, with basic Python knowledge, and allow them to build a strong foundation for advanced work with these libraries - from simple plots to animated 3D plots with interactive buttons.
<blockquote>
It serves as an in-depth guide that'll teach you everything you need to know about Pandas and Matplotlib, including how to construct plot types that aren't built into the library itself.
</blockquote>
Data Visualization in Python, a book for beginner to intermediate Python developers, guides you through simple data manipulation with Pandas, covers core plotting libraries like Matplotlib and Seaborn, and shows you how to take advantage of declarative and experimental libraries like Altair. More specifically, over the span of 11 chapters this book covers 9 Python libraries: Pandas, Matplotlib, Seaborn, Bokeh, Altair, Plotly, GGPlot, GeoPandas, and VisPy.
<blockquote>
It serves as a unique, practical guide to Data Visualization, in a plethora of tools you might use in your career.
</blockquote>

In this tutorial, we'll take a look at how to plot a Scatter Plot with Plotly and Python - as well as how to customize it, with examples.

Plotly Scatter Plot - Tutorial with Examples

Mila Lukic

In this guide, we'll take a look at the theory and implementation of Borůvka's Algorithm in Python, with illustrations to make it easier to understand.

Borůvka's Algorithm in Python - Theory and Implementation

Graphs in Python: Minimum Spanning Trees - Borůvka's Algorithm

<h2 id="introduction">Introduction</h2>
<code>Map</code> implementations in Java represent structures that map keys to values. A <code>Map</code> cannot contain duplicate keys and each can at most be mapped to one value. The <code>Map&lt;K,V&gt;</code> implementations are generic and accept any <code>K</code> (key) and <code>V</code> (value) to be mapped.
The <code>Map</code> interface also includes methods for some basic operations (such as <code>put()</code>, <code>get()</code>, <code>containsKey()</code>, <code>containsValue()</code>, <code>size()</code>, etc.), bulk operations (such as <code>putAll()</code> and <code>clear()</code>) and collection views (such as <code>keySet()</code>, <code>entrySet()</code> and <code>values()</code>).
The most prominent <code>Map</code> implementations used for general purposes are: <code>HashMap</code>, <code>TreeMap</code> and <code>LinkedHashMap</code>.
In this article, we'll take a look at how to filter a Map by its keys and values:
<ul>
<li><a href="#filteramapwithenhancedforloops">Filter a Map with enhanced for-loops</a></li>
<li><a href="#filteramapbykeyswithstreamfilter">Filter a Map by Keys with Stream.filter()</a></li>
<li><a href="#filteramapbyvalueswithstreamfilter">Filter a Map by Values with Stream.filter()</a></li>
</ul>
<h2 id="filteramapwithenhancedforloops">Filter a Map with enhanced for-loops</h2>
Let's populate a <code>HashMap</code> with some key-value pairs:
<pre><code class="hljs">Map&lt;Integer, String&gt; employeeMap = new HashMap&lt;&gt;();

employeeMap.put(35, &quot;Mark&quot;);
employeeMap.put(40, &quot;John&quot;);
employeeMap.put(23, &quot;Michael&quot;);
employeeMap.put(31, &quot;Jim&quot;);
employeeMap.put(25, &quot;Kevin&quot;);
</code></pre>
The <code>Map</code> has keys of type <code>Integer</code> and values of type <code>String</code>. They represent the age and name of the employees.
We'll filter this map by keys and values and save the results in a <code>Collection</code>, such as another <code>Map</code> implementation, or even another <code>HashMap</code>.
Let's go with the <code>LinkedHashMap</code> which preserves the order of insertion:
<pre><code class="hljs">Map&lt;Integer, String&gt; linkedHashMap = new LinkedHashMap&lt;&gt;();

for (Map.Entry&lt;Integer, String&gt; employee : employeeMap.entrySet()) {
 if(employee.getKey() &gt; 30){
 linkedHashMap.put(employee.getKey(), employee.getValue());
 }
}
 
System.out.println(&quot;Filtered Map: &quot; + linkedHashMap);
</code></pre>
Here, we've gone through the <code>entrySet()</code> of the <code>employeeMap</code>, and added each employee into a <code>LinkedHashMap</code> via its <code>put()</code> method. This would work the exact same for the <code>HashMap</code> implementation, but it wouldn't preserve the order of insertion:
<pre><code class="hljs">Filtered Map: {35=Mark, 40=John, 31=Jim}
</code></pre>
Filtering out by values boils down to much the same approach, albeit, we'll be checking the value of each entry and using that in a condition:
<pre><code class="hljs">Map&lt;Integer, String&gt; linkedHashMap = new LinkedHashMap&lt;&gt;();

for (Map.Entry&lt;Integer, String&gt; employee : employeeMap.entrySet()) {
 if(employee.getValue().equals(&quot;Mark&quot;)){
 linkedHashMap.put(employee.getKey(), employee.getValue());
 }
}

System.out.println(&quot;Filtered Map: &quot; + linkedHashMap);
</code></pre>
And this would output:
<pre><code class="hljs">Filtered Map: {35=Mark}
</code></pre>
This is the manual way to filter a map - iterating and picking the desired elements. Let's now take a look at a more readable, and friendlier way - via the Stream API.
<h2 id="streamfilter">Stream.filter()</h2>
A more modern way to filter maps would be leveraging the Stream API from Java 8, which makes this process much more readable. The <code>filter()</code> method of the <code>Stream</code> class, as the name suggests, filters any <code>Collection</code> based on a given condition.
For example, given a <code>Collection</code> of names, you can filter them out based on conditions such as - containing certain characters or starting with a specific character.
<h2 id="filteramapbykeyswithstreamfilter">Filter a Map by Keys with Stream.filter()</h2>
Let's leverage the Stream API to filter out this same map given the same condition. We'll <code>stream()</code> the <code>entrySet()</code> of the map, and <code>collect()</code> it back into a <code>Map</code>:
<pre><code class="hljs">Map&lt;Integer, String&gt; filteredMap = employeeMap.entrySet()
 .stream().filter(x-&gt;x.getKey() &gt; 30)
 .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

System.out.println(&quot;Filtered map: &quot; + filteredMap);
</code></pre>
What this code does is much the same as what we did manually - for each element in the map's set, we check if their key's value is greater than <code>30</code> and collect the values into a new <code>Map</code>, with their respective keys and values supplied through the <code>getKey()</code> and <code>getValue()</code> method references:
<pre><code class="hljs">Filtered map: {35=Mark, 40=John, 31=Jim}
</code></pre>
<h2 id="filteramapbyvalueswithstreamfilter">Filter a Map by Values with Stream.filter()</h2>
Now, let's populate another map, and instead of a <code>&lt;Integer, String&gt;</code> key-value pair, we'll use a <code>&lt;String, String&gt;</code> pair:
<pre><code class="hljs">Map&lt;String, String&gt; cityMap = new HashMap&lt;&gt;();

cityMap.put(&quot;Tokyo&quot;, &quot;Japan&quot;);
cityMap.put(&quot;Berlin&quot;, &quot;Germany&quot;);
cityMap.put(&quot;Kyoto&quot;, &quot;Japan&quot;);
cityMap.put(&quot;Belgrade&quot;, &quot;Serbia&quot;);
cityMap.put(&quot;Madrid&quot;, &quot;Spain&quot;);
</code></pre>
This time around, we've got city-country pairs, where keys are individual cities, and the values are the countries they're located in. Values don't have to be unique. <code>Kyoto</code> and <code>Tokyo</code>, which are both unique keys can have the same value - <code>Japan</code>.
Sorting this map by values, again, boils down to much the same approach as before - we'll simply use the value, via the <code>getValue()</code> method in the filtering condition:
<pre><code class="hljs">Map&lt;String, String&gt; filteredMap = citiesMap.entrySet()
 .stream().filter(x-&gt;&quot;Japan&quot;.equals(x.getValue()))
 .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

System.out.println(&quot;Filtered map: &quot; + filteredMap)
</code></pre>
Now, this results in a filtered map that contains both <code>Tokyo</code> and <code>Kyoto</code>:
<pre><code class="hljs">Filtered map: {Tokyo=Japan, Kyoto=Japan}
</code></pre>
You can get creative with the outputs and results here. For example, instead of putting these elements into a new map and returning that - we can manipulate the resulting value into other structures as well. For example, we could filter out the keys what have <code>Japan</code> and <code>Serbia</code> as values, and join the keys into a single <code>String</code>:
<pre><code class="hljs">String filteredMap = citiesMap.entrySet()
 .stream().filter(x-&gt; x.getValue().equals(&quot;Japan&quot;) || 
 x.getValue().equals(&quot;Serbia&quot;))
 .map(Map.Entry::getKey).collect(Collectors.joining(&quot;, &quot;));

System.out.println(&quot;Filtered map: &quot; + filteredMap);
</code></pre>
Here, we've used a different <code>Collector</code> than before. The <code>Collectors.joining()</code> returns a new <code>Collector</code> that joins the elements into a <code>String</code>. Other than the <code>CharSequence delimiter</code> we've passed in, we could've also supplied a <code>CharSequence prefix</code> and <code>CharSequence suffix</code> for each joined element.
This results in a <code>String</code>, with all of the filtered elements, separated by a <code>,</code>:
<pre><code class="hljs">Filtered map: Belgrade, Tokyo, Kyoto
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article, we've taken a look at how to filter a <code>Map</code> in Java. We've first gone over how to use enhanced for-loops for pre-Java 8 projects, after which we've dived into the Steam API and leveraged the <code>filter()</code> method.
Filtering maps by either values or keys is rendered into a simple, one-liner task with the help of the Stream API, and you have a wide variety of <code>Collector</code>s to format the output to your liking.

Branko Ilic

In this tutorial, we'll take a look at how to filter a Map by key or value in Java 8, using an enhanced for-loop and the Stream API's `filter()` method, with examples.

How to Filter a Map by Key or Value in Java

<h2 id="introduction">Introduction</h2>
<a rel="nofollow noopener" target="_blank" href="https://arrow.readthedocs.io/en/latest/">Arrow</a> is a Python module for working with date and time. Given that there are several modules that do this, most notably the built-in <code>datetime</code> module, what makes Arrow different?
Most notably, the library is inspired by <a rel="nofollow noopener" target="_blank" href="https://github.com/moment/moment">Moment.js</a>, a JavaScript library that overrides the default implementation of the Date/Time API.
In this guide, we'll take a look at some key features of Arrow, to see how it handles certain common tasks.
First, let's go ahead and install it:
<pre><code class="hljs">$ pip install Arrow
</code></pre>
<h2 id="thearrowclass">The Arrow Class</h2>
The <code>Arrow</code> class is an implementation of the <code>datetime</code> interface, with additional functionalities. Also, it's timezone-aware by default - we'll go into this a bit later, though.
You can easily create a new <code>Arrow</code> instance by supplying its constructor with a few arguments:
<pre><code class="hljs">import arrow
arrow_object = arrow.Arrow(2021, 1, 1)
print(arrow_object)
</code></pre>
This results in:
<pre><code class="hljs">2021-01-01T00:00:00+00:00
</code></pre>
You can also supply the hours, minutes and seconds through the constructor:
<pre><code class="hljs">import arrow
arrow_object = arrow.Arrow(2021, 1, 1, 14, 30, 21)
print(arrow_object)
</code></pre>
This results in:
<pre><code class="hljs">2021-01-01T14:30:21+00:00
</code></pre>
<h2 id="conversionsupportwitharrow">Conversion Support with Arrow</h2>
Parsing a date and time from a string is a straightforward process with Arrow - you simply use the <code>get()</code> method, and supply it with a valid string format. Also, Arrow lets you effortlessly convert between its own implementation of <code>datetime</code> class and the built-in <code>datetime</code> object.
<h3 id="convertstringtodatetimewitharrow">Convert String to Datetime with Arrow</h3>
If a string is already formatted in the ISO 8601 format (<code>YYYY-MM-DDTHH:MM:SS.mmmmmm</code>), it can be passed directly into the <code>get()</code> method:
<pre><code class="hljs">import arrow
datetime = arrow.get(&#x27;2021/03/30 12:05&#x27;)
print(datetime)
</code></pre>
This will print out the <code>Arrow</code> instance, which is Arrow's own implementation of the <code>datetime</code> interface:
<pre><code class="hljs">&lt;Arrow [2021-03-30T12:05:00+00:00]&gt;
</code></pre>
However, in practice, it is unlikely that we will be using correctly formatted strings, following the ISO specification.
Thankfully, we can still parse strings that don't adhere to conventions, by using correct Arrow format tokens. These are predefined and give Arrow the information needed to parse the string correctly:
<pre><code class="hljs">import arrow
datetime = arrow.get(&#x27;March 30 2021 12:05&#x27;, &#x27;MMMM DD YYYY HH:mm&#x27;)
print(datetime)
</code></pre>
Here, we've effectively told Arrow what the format is. It maps the supplied format tokens with the string we'd like to parse, and constructs an <code>Arrow</code> object based on that info. Running this results in:
<pre><code class="hljs">&lt;Arrow [2021-03-30T12:05:00+00:00]&gt;
</code></pre>
<h3 id="convertbetweenarrowanddatetimeobjects">Convert Between Arrow and datetime Objects</h3>
So far, we've been working with <code>Arrow</code> instances. However, many applications and libraries explicitly require you to use a <code>datetime</code> object. Conversion between these two formats is crucial.
Let's take a look at the <code>type()</code> of our variable:
<pre><code class="hljs">type(datetime)
</code></pre>
Output:
<pre><code class="hljs">arrow.arrow.Arrow
</code></pre>
To convert this to a <code>datetime</code> instance, we simply extract the <code>datetime</code> field from the <code>Arrow</code> object:
<pre><code class="hljs">datetime = datetime.datetime
print(datetime)
</code></pre>
This results in a time-zone aware <code>datetime</code> instance:
<pre><code class="hljs">datetime.datetime(2021, 3, 12, 12, 5, tzinfo=tzutc())
</code></pre>
Even though we haven't specified the timezone when creating the original <code>Arrow</code> object, the <code>datetime</code> object has the <code>tzinfo</code> defaulted to UTC. We will refer back to this in the next section, when taking a more detailed look into handling timezones.
For now, we can confirm it is indeed a <code>datetime</code> object type:
<pre><code class="hljs">type(now)
</code></pre>
This results in;
<pre><code class="hljs">datetime.datetime
</code></pre>
Similarly enough, you can easily convert <code>datetime</code> objects into <code>Arrow</code> objects, using the <code>fromdatetime()</code> function:
<pre><code class="hljs">datetime = datetime.datetime(2021, 1, 1, 0, 0)
arrow_object = arrow.Arrow.fromdatetime(datetime)
print(arrow_object)
</code></pre>
This results in:
<pre><code class="hljs">2021-01-01T00:00:00+00:00
</code></pre>
<h2 id="dealingwithtimezones">Dealing with Timezones</h2>
One of the major issues with the <code>datetime</code> module is the way it handles time zones. It is considered timezone-naive, meaning it contains no timezone related data. Arrow on the other hand contains a <code>tzinfo</code> parameter for each instantiation, which you can set through the constructor, or through methods. The <code>tzinfo</code> defaults to UTC, regardless of the user's location.
In practical terms this means that with <code>datetime</code>, a user in Hong Kong would be working in local Hong Kong time whereas a user in UK would be working in local UK time - unless otherwise specified:
<pre><code class="hljs">import datetime
datetime.datetime.now()
</code></pre>
The output for the Hong Kong based user would be:
<pre><code class="hljs">datetime.datetime(2021, 3, 31, 00, 35, 08, 114203)
</code></pre>
Whereas someone based in the UK would see:
<pre><code class="hljs">datetime.datetime(2021, 3, 30, 17, 35, 25, 119213)
</code></pre>
Having a standard default timezone is increasingly important with the rise in remote working as well the globalization of projects. Having to explicitly set timezones for <code>datetime</code> objects gets stale fast. Arrow automates this process, in a single, unified, default timezone. You can set it to other timezones, of course, or even local ones.
Irrespective of the user's geographical location, the following lines of code will give the same output:
<pre><code class="hljs">arrow.now()
</code></pre>
Output:
<pre><code class="hljs">&lt;Arrow [2021-03-30T17:37:28.374335+01:00]&gt;
</code></pre>
We can confirm this corresponds to the UTC time:
<pre><code class="hljs">arrow.utcnow()
</code></pre>
Output:
<pre><code class="hljs">&lt;Arrow [2021-03-30T16:37:59.721766+00:00]&gt;
</code></pre>
We can set time zones on the <code>Arrow</code> instance simply by passing in the timezone string in its constructor:
<pre><code class="hljs">arrow.now(&#x27;US/Pacific)
</code></pre>
This works alongside other parameters that we've used before. Setting a timezone while constructing an <code>Arrow</code> instance works both for converting strings and <code>datetime</code> objects and calling the constructor explicitly:
<pre><code class="hljs">import arrow
import datetime as datetime

date = &#x27;2021.01.01 00:00&#x27;
datetime = datetime.datetime(2021, 1, 1, 0, 0)

arrow_1 = arrow.Arrow(2021, 1, 1, 0, 0, tzinfo=&#x27;US/Pacific&#x27;)
arrow_2 = arrow.get(date, tzinfo=&#x27;US/Pacific&#x27;)
arrow_3 = arrow.Arrow.fromdatetime(datetime, tzinfo=&#x27;US/Pacific&#x27;)

print(arrow_1)
print(arrow_2)
print(arrow_3)
</code></pre>
Now, these <code>Arrow</code> instances will be set to the <code>US/Pacific</code> timezone, and set to the 1st of January, 2021:
<pre><code class="hljs">2021-01-01T00:00:00-08:00
2021-01-01T00:00:00-08:00
2021-01-01T00:00:00-08:00
</code></pre>
As you can see, the objects now have a <code>-08:00</code> suffix, since the <code>US/Pacific</code> timezone is 8 hours behind UTC.
You can also extract the naive versions of these datetimes by calling their <code>naive</code> field:
<pre><code class="hljs">print(arrow_1.naive)
print(arrow_2.naive)
print(arrow_3.naive)
</code></pre>
This will not strip them off their timezone awareness, resulting in what you'd expect when you're working with naive <code>datetime</code> objects:
<pre><code class="hljs">2021-01-01 00:00:00
2021-01-01 00:00:00
2021-01-01 00:00:00
</code></pre>
<h2 id="convertingbetweentimezoneswitharrow">Converting Between Time Zones with Arrow</h2>
Another area worth looking at is how we can convert between different time zones with Arrow by using the <code>to()</code> method. Whilst Arrow is fully compatible with timezone modules, there is no need to import any additional modules for timezone conversion.
To start with we can get the current time and assign it to a variable:
<pre><code class="hljs">utc=arrow.now()
print(utc)
</code></pre>
<pre><code class="hljs">&lt;Arrow [2021-03-30T17:41:08.765166+01:00]&gt;
</code></pre>
Now, let's convert this object to another timezone:
<pre><code class="hljs">utc.to(&#x27;US/Pacific&#x27;)
</code></pre>
This results in:
<pre><code class="hljs">&lt;Arrow [2021-03-30T09:41:08.765166-07:00]&gt;
</code></pre>
Or the time in Hong Kong:
<pre><code class="hljs">utc.to(&#x27;Asia/Hong_Kong&#x27;)
</code></pre>
<pre><code class="hljs">&lt;Arrow [2021-03-30T09:41:08.765166-07:00]&gt;
</code></pre>
We can even specify the time difference with number of hours:
<pre><code class="hljs">utc.to(&#x27;-05:00&#x27;)
</code></pre>
This is a much more intuitive way to convert between timezones, especially if you don't have a list of the appropriate names handy:
<pre><code class="hljs">&lt;Arrow [2021-03-30T11:41:08.765166-05:00]&gt;
</code></pre>
<h2 id="humanizingandshiftingdates">Humanizing and Shifting Dates</h2>
Oftentimes, when dealing with time spans, we don't really need a date. When talking to colleagues, we say:
<blockquote>
&quot;I went shopping yesterday&quot;.
</blockquote>
Not:
<blockquote>
&quot;I went shopping on 2021/12/03&quot;, which is the day before 2021/12/04&quot;, which is the day right now.
</blockquote>
In a lot of cases, you might want to humanize dates, such as annotating when a notification arrived, an email was sent or when someone performed a certain logged action. Thankfully, Arrow allows us to really easily humanize any date via the <code>humanize()</code> function.
This function works wonders with the <code>shift()</code> function, which can shift the dates by <code>0...n</code> days. You might want to make a system that notifies a person of when a certain date is coming up, in human-speak:
<pre><code class="hljs">import arrow

now = arrow.now()
tomorrow = now.shift(days=1)
yesterday = now.shift(days=-1)
next_week = now.shift(days=7)
notification = now.shift(days=-2, hours=-5, minutes=-7)

print(now.humanize())
print(tomorrow.humanize())
print(yesterday.humanize())
print(next_week.humanize())
print(notification.humanize(granularity=[&#x27;day&#x27;, &#x27;hour&#x27;, &#x27;minute&#x27;]))
</code></pre>
Here, we've created an <code>Arrow</code> object using the <code>now()</code> function. Then, we've created a series of objects by shifting the values up or down. The <code>shift()</code> function accepts arguments such as <code>years</code>, <code>months</code>, <code>days</code>, <code>hours</code>, <code>minutes</code> and <code>seconds</code>. We've created a <code>tomorrow</code> and <code>yesterday</code> object by shifting up and down by one day (not in-place), and an object for <code>next_week</code> and an arbitrary <code>notification</code> object that happened 2 days, 5 hours and 7 minutes ago.
Finally, when humanizing, you can specify the <code>granularity</code>, which lets Arrow know how detailed to be when it comes to reporting time in human-speak. By default, it'll set the granularity to <code>day</code> and/or <code>week</code>, depending on the time range. In our case, we've left the default settings on, except for the final object where we specifically want a bit of a finer granularity:
<pre><code class="hljs">just now
in a day
a day ago
in a week
2 days 5 hours and 7 minutes ago
</code></pre>
This is a very intuitive and human way to represent dates to your user - such as counting down days to an event, or counting days from an event.
<h2 id="advantagesofusingarrow">Advantages of Using Arrow</h2>
The advantages of using Arrow could be summarized with the official statements from their documentation:
<blockquote>
Sensible and human-friendly approach.
Supporting many common creation scenarios.
Help you work with dates and times with fewer imports and a lot less code.
</blockquote>
In these, it appears to succeed, and Arrow overcomes the major issues with the <code>datetime</code> library. From what we have seen in our examples above Arrow is certainly an improvement in terms of:
<ul>
<li>Reducing the need for importing multiple modules</li>
<li>Working in just one data type (Arrow)</li>
<li>Being timezone-aware</li>
<li>Simplifying the creation of the most commonly used date and time functions</li>
<li>Easy conversion between various types</li>
<li>Helpful humanization functions</li>
<li>Easily shifting values into the past and future</li>
</ul>
<h2 id="conclusion">Conclusion</h2>
In this guide, we've focused on some of the benefits of using the Arrow library to work with date and time in Python. It's inspired by Moment.js, and offers solutions to some of the known problems of the <code>datetime</code> library.
However, it is worth bearing in mind there are many other date and time modules available. It is also worth noting that being a built-in module gives <code>datetime</code> the advantage of needing users pro-actively looking to replace it.
It all comes down to how important the date and time element is to your project and your code.

Rikesh Nichani

Working with Datetime in Python with Arrow

<h2 id="introduction">Introduction</h2>
JavaScript has a lot of useful built-in methods for string manipulation, one of these methods is the <code>split()</code> method.
In this article we'll be taking a closer look at the <code>split()</code> method and how we can use it in conjunction with regular expressions to split a long string just the way we want.
<h2 id="javascriptssplitmethod">JavaScript's split() Method</h2>
When the <code>split(delimiter, limit)</code> method is used on a string, it returns an array of substrings, and uses the <code>delimiter</code> argument's value as the delimiter. The <code>delimiter</code> argument can also be specified as a regular expression, which will then be used to search through the original string to find delimiters that match the specified expression.
Additionally, we can specify the optional argument <code>limit</code>, which specifies how many elements we want in our resulting substring array. Setting <code>limit=2</code>, for example, will yield an array that contains the first two substrings separated by a delimiter in the original string:
<pre><code class="hljs">const str = &quot;JavaScript is the best programming language!&quot;;

const words = str.split(&quot; &quot;);
console.log(words);
</code></pre>
Here, the string will be broken down on each new word:
<pre><code class="hljs">[&quot;JavaScript&quot;, &quot;is&quot;, &quot;the&quot;, &quot;best&quot;, &quot;programming&quot;, &quot;language!&quot; ]
</code></pre>
If we set the delimiter to something else, such as:
<pre><code class="hljs">const chars = str.split(&quot;&quot;);
console.log(chars);
</code></pre>
The string will be broken down on every character:
<pre><code class="hljs">[&quot;J&quot;, &quot;a&quot;, &quot;v&quot;, &quot;a&quot;, &quot;S&quot;, &quot;c&quot;, &quot;r&quot;, &quot;i&quot;, &quot;p&quot;, &quot;t&quot;, &quot; &quot;, &quot;i&quot;, &quot;s&quot;, &quot; &quot;, &quot;t&quot;, &quot;h&quot;, &quot;e&quot;, &quot; &quot;, &quot;b&quot;, &quot;e&quot;, &quot;s&quot;, &quot;t&quot;, &quot; &quot;, &quot;p&quot;, &quot;r&quot;, &quot;o&quot;, &quot;g&quot;, &quot;r&quot;, &quot;a&quot;, &quot;m&quot;, &quot;m&quot;, &quot;i&quot;, &quot;n&quot;, &quot;g&quot;, &quot; &quot;, &quot;l&quot;, &quot;a&quot;, &quot;n&quot;, &quot;g&quot;, &quot;u&quot;, &quot;a&quot;, &quot;g&quot;, &quot;e&quot;, &quot;!&quot;]
</code></pre>
<h2 id="regularexpressionswiththesplitmethod">Regular Expressions with the split() Method</h2>
Now that we are comfortable with the use of the <code>split()</code> method, let's step it up a notch, and introduce regular expressions to the mix:
<pre><code class="hljs">const paragraph = `The Answer to the Ultimate Question of Life, the Universe, and Everything is 42. Forty two. That&#x27;s all there is.`;

// Split by words
const words = paragraph.split(&quot; &quot;);
console.log(words[2]);

// Split by sentences
const sentences = paragraph.split(/[!?.]/);
console.log(sentences[1]);

// Split all characters, with a limit of 2
const firstTwoChars = paragraph.split(&quot;&quot;, 2);
console.log(firstTwoChars);

// Split and reverse
const reverse = paragraph.split(&quot;&quot;).reverse().join(&quot;&quot;);
console.log(reverse);
</code></pre>
This results in:
<pre><code class="hljs">to
 Forty two
[&quot;T&quot;, &quot;h&quot; ]
.24 si gnihtyrevE dna ,esrevinU eht ,efiL fo noitseuQ etamitlU eht ot rewsnA ehT
</code></pre>
In the second example, we are passing a regular expression as the argument for the <code>split()</code> method.
<ul>
<li><code>/[!?.]/</code> represents a character set - <code>!</code> or <code>?</code> or <code>.</code></li>
</ul>
Put simply, we are splitting the string at any of the specified characters.
In the third example, we are passing <code>2</code> as the second argument, limiting the resulting substring array to two elements.
In the last example, we are reversing the string using the built-in <code>reverse()</code> method. Because <code>reverse()</code> is an array method, we'll first split the original string into an array of individual characters, by using the <code>split(&quot;&quot;)</code> method, and then <code>reverse()</code> it.
Finally, we can <code>join()</code> the results to create a reversed string from the array of characters.
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we took a quick look at how to split a string in vanilla JavaScript. We've gone over the built-in <code>split()</code> method, as well as how to use it with regular expressions.

Abhilash Kakumanu

In this tutorial, we'll take a look at how to split a string in JavaScript, using the split() method with and without regular expressions.

How to Split a String in JavaScript

<h2 id="introduction">Introduction</h2>
In this tutorial, we'll take a look at how to check if a string starts with a substring in JavaScript.
This is easily achieved either through the <code>startsWith()</code> method, or regular expressions.
<h2 id="checkifstringstartswithanotherstringwithstartswith">Check if String Starts with Another String with startsWith()</h2>
The <code>startsWith(searchString[, position])</code> method returns a boolean which indicates whether a string begins with the characters of a specified <code>searchString</code>. Optionally we can also use the <code>position</code> argument to specify the position of the string at which to begin searching.
Let's see this in action:
<pre><code class="hljs">const str = &quot;This is an example for startsWith() method&quot;;

console.log(str.startsWith(&quot;This&quot;)); // true
console.log(str.startsWith(&quot;is&quot;, 2)); // true
</code></pre>
In the first example, we are checking if the string <code>str</code> starts with <code>&quot;This&quot;</code>.
In the second example, we are checking if <code>str</code> starts with <code>&quot;is&quot;</code>, if we are starting our search from index 2 (i.e, 3rd character).
<h2 id="checkifstringstartswithanotherstringwithregularexpressions">Check if String Starts with Another String with Regular Expressions</h2>
Regular Expressions are really powerful, and allow us to match various patterns. This is a great use-case for them, since we're essentially checking for a pattern - if a string starts with a substring.
The <code>regexObj.test(reg)</code> method tries to match the specified regular expression <code>reg</code> to the original string and returns a <code>boolean</code> value which indicates if a match was found:
<pre><code class="hljs">const str = &quot;hello world&quot;;

const regEx = /^he/;

console.log(regEx.test(str)); // true
</code></pre>
In this approach, we are checking whether the pattern <code>regEx</code> occurs in the string <code>str</code>. The <code>^</code> meta character represents that the specified pattern <code>he</code> must be at the start of a line. Thus, the regular expression - <code>/^he/</code> checks if the specified line starts with the substring <code>he</code>.
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we've taken a look at how to check if a string starts with a substring in vanilla JavaScript, using the <code>startsWith()</code> method, as well as Regular Expressions.

In this tutorial, we'll take a look at practical examples on how to check if a string starts with another string in JavaScript, using `startsWith()` and regex.