<h2 id="introduction">Introduction</h2>
Regular Expressions, or RegEx for short, are expressions of patterns that can be used for text search and replace actions, validations, string splitting, and much more. These patterns consist of characters, digits and special characters, in such a form that the pattern matches certain segments of text we're searching through.
Regular Expressions are widely used for pattern-matching, and various programming languages have interfaces for representing them, as well as interacting with the matches results.
In this article, we will take a look at how to validate email addresses in Python, using Regular Expressions.
<blockquote>
If you would like to learn more about Python's interface with Regular Expressions, read our <a target="_blank" href="https://stackabuse.com/introduction-to-regular-expressions-in-python/">Guide to Regular Expressions in Python</a>!
</blockquote>
<h2 id="generalpurposeemailregularexpression">General-Purpose Email Regular Expression</h2>
It's worth noting that there is no such regular expression that matches every possible valid email address. Although, there are expressions that can match most valid email addresses.
We need to define what kind of email address format are we looking for. The most common email format is:
<pre><code class="hljs">(username)@(domainname).(top-leveldomain)
</code></pre>
Thus, we can boil it down to a pattern of the <code>@</code> symbol dividing the prefix from the domain segment.
The prefix is the recipient;s name - a string that may contain uppercase and lowercase letters, numbers, and some special characters like the <code>.</code> (dot), <code>-</code>(hyphen), and <code>_</code> (underscore).
The domain consists of its name and a top-level domain divided by a <code>.</code> (dot) symbol. The domain name can have uppercase and lowercase letters, numbers, and <code>-</code> (hyphen) symbols. Additionally, the top-level domain name must be at least 2 characters long (either all uppercase or lowercase letters), but can be longer.

 <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: There are a lot more detailed rules regarding valid emails, such as character count, more specific characters that can be used, etc. We'll be taking a look at an extended, highly fail-proof Regular Expression as defined by RFC5322 after the general-purpose approach.

 </div>
 </div>
 </div>
 In simple terms, our email Regular Expression could look like this:
<pre><code class="hljs">(string1)@(string2).(2+characters)
</code></pre>
This would match correctly for email addresses such as:
<pre><code class="hljs">name.surname@gmail.com
anonymous123@yahoo.co.uk
my_email@outlook.co
</code></pre>
Again, using the same expression, these email addresses would fail:
<pre><code class="hljs">johnsnow@gmail
anonymous123@...uk
myemail@outlook.
</code></pre>
It's worth noting that the strings shouldn't contain certain special characters, lest they break the form again. Additionally, the top-level domain can't be <code>..</code>. Accounting for those cases as well, we can put these rules down into a concrete expression that takes in a few more cases into account than the first representation:
<pre><code class="hljs">([A-Za-z0-9]+[.-_])*[A-Za-z0-9]+@[A-Za-z0-9-]+(\.[A-Z|a-z]{2,})+
</code></pre>
A special character in the prefix cannot be just before the <code>@</code> symbol, nor can the prefix start with it, so we made sure that there is at least one alphanumeric character before and after every special character.
As for the domain, an email can contain a few top-level domains divided with a dot.
Obviously, this regex is more complicated than the first one, but it covers all of the rules we have defined for the email format. Yet again, it can probably fail to properly validate some edge case that we haven't thought of.
<h2 id="validateemailaddresswithpython">Validate Email Address with Python</h2>
The <code>re</code> module contains classes and methods to represent and work with Regular Expressions in Python, so we'll import it into our script. The method that we will be using is <code>re.fullmatch(pattern, string, flags)</code>. This method returns a match object only if the whole string matches the pattern, in any other case it returns <code>None</code>.

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: <code>re.fullmatch()</code> was introduced in Python 3.4, before that, <code>re.match()</code> was used instead. On newer versions, <code>fullmatch()</code> is preferred.

 </div>
 </div>
 </div>
 Let's <code>compile()</code> the Regular Expression from before, and define a simple function that accepts an email address and uses the expression to validate it:
<pre><code class="hljs">import re

regex = re.compile(r&#x27;([A-Za-z0-9]+[.-_])*[A-Za-z0-9]+@[A-Za-z0-9-]+(\.[A-Z|a-z]{2,})+&#x27;)

def isValid(email):
 if re.fullmatch(regex, email):
 print(&quot;Valid email&quot;)
 else:
 print(&quot;Invalid email&quot;)
</code></pre>
The <code>re.compile()</code> method compiles a regex pattern into a regex object. It's mostly used for efficiency reasons, when we plan on matching the pattern more than once.
Now, let's test the code on some of the examples we took a look at earlier:
<pre><code class="hljs">isValid(&quot;name.surname@gmail.com&quot;)
isValid(&quot;anonymous123@yahoo.co.uk&quot;)
isValid(&quot;anonymous123@...uk&quot;)
isValid(&quot;...@domain.us&quot;)
</code></pre>
This results in:
<pre><code class="hljs">Valid email
Valid email
Invalid email
Invalid email
</code></pre>
Awesome, we've got a functioning system!
<h2 id="robustemailregularexpression">Robust Email Regular Expression</h2>
The expression we've used above works well for the majority of cases and will work well for any reasonable application. However, if security is of higher concern, or if you enjoy writing Regular Expressions, you may opt to tighten the scope of possibilities while still allowing valid email addresses to pass.
Long expressions tend to get a bit convoluted and hard to read, and this expression is no exception:
<pre><code class="hljs">(?:[a-z0-9!#$%&amp;&#x27;*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&amp;&#x27;*+/=^_`{|}~-]+)*
|&quot;(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]
|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*&quot;)
@
(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?
|\[(?:(?:(2(5[0-5]|[0-4][0-9])
|1[0-9][0-9]|[1-9]?[0-9]))\.){3}(?:(2(5[0-5]|[0-4][0-9])
|1[0-9][0-9]|[1-9]?[0-9])|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]
|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])
</code></pre>
<ul>
<li>Adapted RegEx by <a rel="nofollow noopener noreferrer" target="_blank" href="https://stackoverflow.com/users/15625/bortzmeyer">bortzmeyer</a></li>
</ul>
This is the <a rel="nofollow noopener noreferrer" target="_blank" href="https://www.ietf.org/rfc/rfc5322.txt">RFC5322</a>-compliant Regular Expression that covers 99.99% of input email addresses.* Explaining it with words is typically off the table, but visualizing it helps a lot:
<img src="https://s3.stackabuse.com/media/articles/java-regular-expressions-how-to-validate-emails.png" alt="">
*Image and claim are courtesy of <a target="_blank" rel="nofollow noopener noreferrer" href="http://emailregex.com/">EmailRegex.com</a>.
This actually isn't the only expression that satisfies RFC5322. Many of them do, with varying degrees of success. A shorter version which still complies with the specification can be easily imported into Python's <code>re.compile()</code> method to represent an expression:
<pre><code class="hljs">import re

regex = re.compile(r&quot;([-!#-&#x27;*+/-9=?A-Z^-~]+(\.[-!#-&#x27;*+/-9=?A-Z^-~]+)*|\&quot;([]!#-[^-~ \t]|(\\[\t -~]))+\&quot;)@([-!#-&#x27;*+/-9=?A-Z^-~]+(\.[-!#-&#x27;*+/-9=?A-Z^-~]+)*|\[[\t -Z^-~]*])&quot;)

def isValid(email):
 if re.fullmatch(regex, email):
 print(&quot;Valid email&quot;)
 else:
 print(&quot;Invalid email&quot;)

isValid(&quot;name.surname@gmail.com&quot;)
isValid(&quot;anonymous123@yahoo.co.uk&quot;)
isValid(&quot;anonymous123@...uk&quot;)
isValid(&quot;...@domain.us&quot;)
</code></pre>
This also results in:
<pre><code class="hljs">Valid email
Valid email
Invalid email
Invalid email
</code></pre>
<h2 id="conclusion">Conclusion</h2>
To wrap up this guide, let's revise what we've learned. There are many ways to validate emails using Regular Expressions, mostly depending on what certain format we are looking for. In relation to that, there is no one unique pattern that works for all email formats, we simply need to define the rules that we want the format to follow and construct a pattern accordingly.
Each new rule reduces the degree of freedom on the accepted addresses.

David Landup

Anđela Niketić

In this guide, we'll take a look at how to validate email addresses in Python with Regular Expressions, with a general-purpose simple expression as well as an RFC5322-compliant robust regex.

Python: Validate Email Address with Regular Expressions (RegEx)

Cansın Güler

In this extensive guide, we'll take a look at functional programming and applying Predicates in Java, with Lambda Functions!

Functional Programming in Java 8: Definitive Guide to Predicates

<h2 id="introduction">Introduction</h2>
A stream represents a sequence of elements and supports different kinds of operations that lead to the desired result. The source of a stream is usually a Collection or an Array, from which data is streamed from.
Streams differ from collections in several ways; most notably in that the streams are not a data structure that stores elements. They're functional in nature, and it's worth noting that operations on a stream produce a result and typically return another stream, but do not modify its source.
To &quot;solidify&quot; the changes, you collect the elements of a stream back into a <code>Collection</code>.
Many simple mathematical operations and concepts find their usage in programming, and most often these are just as straightforward in programming as they are in math itself. Summing up elements isn't indifferent to this, and it's usage is often overlooked because there are many ways to utilize this simple task.
<blockquote>
In this guide, we'll take a look at how to sum all elements in a collection in Java, using <code>summingDouble()</code>, <code>summingLong()</code> and <code>summingInt()</code>.
</blockquote>

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: It's worth noting that you can sum the elements themselves, if they're summable, or <a target="_blank" href="https://stackabuse.com/java-8-streams-guide-to-reduce/">reduce them</a> to a numerical representation and then sum the reductions, if they aren't.

 </div>
 </div>
 </div>
 <h2 id="collectorsandstreamcollect">Collectors and Stream.collect()</h2>
Collectors represent implementations of the <code>Collector</code> interface, which implements various useful reduction operations, such as accumulating elements into collections, summarizing elements based on a specific parameter, etc.
<blockquote>
All predefined implementations can be found within the <code>Collectors</code> class.
</blockquote>
You can also very easily implement your own collector and use it instead of the predefined ones, though - you can get pretty far with the built-in collectors, as they cover the vast majority of cases in which you might want to use them.
To be able to use the class in our code we need to import it:
<pre><code class="hljs">import static java.util.stream.Collectors.*;
</code></pre>
<code>Stream.collect()</code> performs a mutable reduction operation on the elements of the stream.

 <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">
 A mutable reduction operation collects input elements into a mutable container, such as a <code>Collection</code>, as it processes the elements of the stream.

 </div>
 </div>
 </div>
 <h2 id="definitionofthesumming_collectors">Definition of the summing_() Collectors</h2>
Within the <code>Collectors</code> class itself, we find an abundance of unique methods that deliver on the different needs of a user. One such group is made of summing methods - <code>summingInt()</code>, <code>summingDouble()</code> and <code>summingLong()</code>.
Even though each of these methods work for a distinctive data type listed within their names, they all work fairly similarly, with minor differences:
<pre><code class="hljs">public static &lt;T&gt; Collector&lt;T,?,Integer&gt; summingInt(ToIntFunction&lt;? super T&gt; mapper)

public static &lt;T&gt; Collector&lt;T,?,Double&gt; summingDouble(ToDoubleFunction&lt;? super T&gt; mapper)

public static &lt;T&gt; Collector&lt;T,?,Long&gt; summingLong(ToLongFunction&lt;? super T&gt; mapper)
</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: The generic <code>T</code> in the method signatures represents the type of the input elements we're working with.

 </div>
 </div>
 </div>
 Earlier we stated that these methods can only be used for numerical inputs. The predefined <code>ToIntFunction</code>, <code>ToDoubleFunction</code> and <code>ToLongFunction</code> from <code>java.util.function</code> enable us to do exactly such conversions - from object types to their primitive <code>int, double, long</code> types.
Before we begin diving into each of the individual methods, we'll be defining a class that we'll use for our examples alongside a few fields.
This class will be called <code>Product</code>:
<pre><code class="hljs">public class Product {
 private String name;
 private Integer quantity;
 private Double price;
 private Long productNumber;

 // Constructor, getters and setters
}
</code></pre>
The class has four fields of different types:
<ul>
<li><code>String name</code> - we won't end up using this field since this is a non-numeric value, but in order to have meaningful examples we need to name our products.</li>
<li><code>Integer quantity</code> - the number of products in our inventory.</li>
<li><code>Double price</code> - the price of the product.</li>
<li><code>Long productNumber</code> - a six-digit code for every of our products.</li>
</ul>
Alongside these four fields, we also have a simple constructor and getters for everything except the name of the product itself. Let's also instantiate our <code>List</code> of products in the main program:
<pre><code class="hljs">List&lt;Product&gt; products = Arrays.asList(
 new Product(&quot;Milk&quot;, 37, 3.60, 12345600L),
 new Product(&quot;Carton of Eggs&quot;, 50, 1.20, 12378300L),
 new Product(&quot;Olive oil&quot;, 28, 37.0, 13412300L),
 new Product(&quot;Peanut butter&quot;, 33, 4.19, 15121200L),
 new Product(&quot;Bag of rice&quot;, 26, 1.70, 21401265L)
);
</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: Besides this class, which we'll have to reduce to a field in order to sum, we'll also be taking a look at examples of <code>List</code>s consisting only of <code>Integer</code>, <code>Double</code> and <code>Long</code> elements.

 </div>
 </div>
 </div>
 <h3 id="collectorssummingint">Collectors.summingInt()</h3>
The <code>summingInt()</code> method returns a <code>Collector</code> that produces the sum of a integer-valued function applied to the input elements. In other words - it sums the integers in the collection and returns the result. In the case of no input elements, the return value is <code>0</code>.
Let's start off with a basic example with a <code>List</code> of <code>Integers</code>:
<pre><code class="hljs">List&lt;Integer&gt; numbers = Arrays.asList(1, 2, 3, 4, 5);
Integer sum = numbers.stream().collect(Collectors.summingInt(Integer::intValue));
System.out.println(&quot;Sum: &quot; + sum);
</code></pre>
We apply the <code>.stream()</code> method to create a stream of <code>Integer</code> instances, after which we use the previously discussed <code>.collect()</code> method to collect the elements using <code>summingInt()</code>. The method itself, again, accepts the <code>ToIntFunction</code>, which can be used to reduce instances to an integer that can be summed.
Since we're using Integers already, we can simply pass in a method reference denoting their <code>intValue</code>, as no further reduction is needed:
<pre><code class="hljs">Sum: 15
</code></pre>
More often than not - you'll be working with lists of custom objects and would like to sum some of their fields. For instance, we can sum the quantities of each product in the <code>productList</code>, denoting the total inventory we have.
In such a case, the we can use a method reference, such as <code>Product::getQuantity</code> as our <code>ToIntFunction</code>, to reduce the objects into a single integer each, and then sum these integers:
<pre><code class="hljs">Integer sumOfQuantities = products.stream().collect(Collectors.summingInt(Product::getQuantity));
System.out.println(&quot;Total number of products: &quot; + sumOfQuantities);
</code></pre>
This results in:
<pre><code class="hljs">Total number of products: 174
</code></pre>
<blockquote>
If you'd like to read more about reduction and reducing operations, which are typically at the core of summing and averaging operations, amongst other tasks - read our <a target="_blank" href="https://stackabuse.com/java-8-streams-guide-to-reduce/">Java 8 Streams: Definitive Guide to reduce()</a>!
</blockquote>
<h3 id="collectorssummingdouble">Collectors.summingDouble()</h3>
In much the same way <code>summingInt()</code> returns the result of summed integer values - <code>summingDouble()</code> returns the result of summed double values.
This method varies from the <code>summingInt()</code> in one regard, however. The sum returned can vary depending on the order in which values are recorded, due to accumulated rounding errors. Values sorted by increasing order tend to produce more accurate results.

 <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 any value is a <code>NaN</code> or the sum at any point is <code>NaN</code>, the result will also be <code>NaN</code>.

 </div>
 </div>
 </div>
 Let's start off with a list of doubles:
<pre><code class="hljs">List&lt;Double&gt; numbers = Arrays.asList(3.0, 5.5, 11.3, 40.3, 21.1);
Double sum = numbers.stream().collect(Collectors.summingDouble(Double::doubleValue));
System.out.println(sum);
</code></pre>
After rounding off our output it prints out:
<pre><code class="hljs">81.2
</code></pre>
Again, we typically work with custom objects and not wrapper/primitive types. Prices of our products are expressed in doubles, so we could sum prices. If we were to buy a single instance of every product in the inventory, what would the price be?
Let's use <code>summingDouble()</code> to get a quote for the price:
<pre><code class="hljs">Double sumOfPrices = products.stream().collect(Collectors.summingDouble(Product::getPrice));
System.out.println(&quot;The total sum of prices: &quot; + sumOfPrices);
</code></pre>
This gives us:
<pre><code class="hljs">The total sum of prices: 47.69
</code></pre>
If we wanted to get a little creative and count the total price of all of our products combined we can do that using this method as well. However, it does require beforehand calculations that makes this significantly easier:
<pre><code class="hljs">List&lt;Double&gt; productPrices = new ArrayList&lt;&gt;();
for(Product product : products){
 productPrices.add(product.getPrice() * product.getQuantity());
}

Double sumOfPrices = productPrices.stream().collect(Collectors.summingDouble(Double::doubleValue));
System.out.println(&quot;Sum of all product prices : &quot; + sumOfPrices);
</code></pre>
Running this code gives us the following:
<pre><code class="hljs">Sum of all product prices : 1411.67
</code></pre>
<h3 id="collectorssumminglong">Collectors.summingLong()</h3>
The third and last method from the summing group of methods is <code>summingLong()</code>. This method, as the previous two do, returns a <code>Collector</code> that produces the sum of a long-valued function applied to the input elements. If no elements are present, the result is <code>0</code>:
<pre><code class="hljs">List&lt;Long&gt; numbers = Arrays.asList(23L, 11L, 13L, 49L, 7L);
Long sum = numbers.stream().collect(Collectors.summingLong(Long::longValue));
System.out.println(sum);
</code></pre>
This outputs:
<pre><code class="hljs">103
</code></pre>
Finally, our <code>productNumber</code> field is of type <code>Long</code>. Turns out, the numbers were carefully chosen to encode a secret message once split up and converted from decimal to ASCII. We'll sum the longs and write a custom helper function to decode the message:
<pre><code class="hljs">Long productNumbers = products.stream().collect(Collectors.summingLong(Product::getProductNumber));
System.out.println(productNumbers);
System.out.println(decodeMessage(productNumbers));
</code></pre>
The <code>decodeMessage()</code> method takes in a <code>Long</code>, breaks it up and considers each two characters as a decimal representation of a <code>Character</code>, before adding the characters up and returning the message:
<pre><code class="hljs">public static String decodeMessage(Long encodedMessage) {
 String message = String.valueOf(encodedMessage);
 String[] characters = message.split(&quot;&quot;);
 StringBuilder result = new StringBuilder();

 for (int i = 1; i &lt; characters.length; i+=2) {
 result.append(Character.toString(Integer.parseInt(characters[i-1]+characters[i])));
 }

 return result.toString();
}
</code></pre>
Awesome, let's take a look at the result:
<pre><code class="hljs">74658665
JAVA
</code></pre>
Not an exciting secret message, by all means, but a message nonetheless.
<h2 id="conclusion">Conclusion</h2>
In this guide, we've taken a look at summing collectors, and explored the <code>summingInt()</code>, <code>summingDouble()</code> and <code>summingLong()</code> methods.
We've explored their usage on primitive wrappers, as well as custom objects, which are typically reduced to a field for summation operations.

Branko Ilic

In this Java 8 Streams guide, we'll take a look at the summing collectors for integers, doubles and longs in Java, with practical examples and tips.

Guide to Java 8 Collectors: summingDouble(), summingLong() and summingInt()

Data takes many shapes and forms - one of the most common data structure being lists/arrays. Strings are, essentially, sequences of alphanumeric characters. The parallel between these is apparent, and we often convert between one and the other.
<blockquote>
In this guide, we'll take a look at how to convert/collect a list to a string in Python.
</blockquote>
<h2 id="convertlisttostringinpythonwithjoin">Convert List to String in Python with join()</h2>
The general approach you'll be using is the <code>join()</code> function, with a couple of options to choose from. The function is invoked on a string denoting a separator - and this separator will be added between all joined items.

 <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: Although you can define a separator upfront, it's typically just instantiated as an empty string, upon which the <code>join()</code> function is called.

 </div>
 </div>
 </div>
 Let's take a look at a list of characters that we'd like to join:
<pre><code class="hljs">base_list = [&#x27;M&#x27;, &#x27;K&#x27;, &#x27;V&#x27;, &#x27;N&#x27;, &#x27;L&#x27;, &#x27;I&#x27;, &#x27;L&#x27;, &#x27;F&#x27;, &#x27;S&#x27;, &#x27;L&#x27;, &#x27;L&#x27;, &#x27;V&#x27;]
</code></pre>
The simplest way to join these into a single string is to just pass the list into the <code>join()</code> function:
<pre><code class="hljs">string = &quot;&quot;.join(base_list)
print(string)
</code></pre>
This results in:
<pre><code class="hljs">MKVNLILFSLLV
</code></pre>
We've joined a few characters, denoting the amino-acids present at the start of the sequence of a protein found in the E. coli bacteria!
Each of these elements is of type <code>str</code>, so there's no issue in naturally putting these into a string. Though, sometimes, you might want to convert a certain element into a different type.
Additionally, if you use a different delimiter, you can get a different representation as well:
<pre><code class="hljs">string = &quot;, &quot;.join(base_list)
</code></pre>
This results in:
<pre><code class="hljs">M, K, V, N, L, I, L, F, S, L, L, V
</code></pre>
<h2 id="convertlisttostringinpythonwithlistcomprehension">Convert List to String in Python with List Comprehension</h2>

 <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 implicitly converts any data types it can, so you won't need to explicitly convert them in most cases.

 </div>
 </div>
 </div>
 If you do have to convert the elements, you can simply use a list comprehension:
<pre><code class="hljs">string = &quot;&quot;.join(str(element) for element in base_list)
</code></pre>
Each element in the list is now passed through the <code>str()</code> function, which converts them to a string. You can substitute this with any other function, including custom ones. For instance, let's create a function that capitalizes each element in the 'off chance' an element isn't capitalized as it should be:
<pre><code class="hljs">base_list = [&#x27;m&#x27;, &#x27;K&#x27;, &#x27;V&#x27;, &#x27;N&#x27;, &#x27;L&#x27;, &#x27;I&#x27;, &#x27;L&#x27;, &#x27;f&#x27;, &#x27;S&#x27;, &#x27;L&#x27;, &#x27;L&#x27;, &#x27;V&#x27;]

def capitalize_char(char):
 return char.upper()

string = &quot;&quot;.join(capitalize_char(element) for element in base_list)

print(string)
</code></pre>
<code>m</code> and <code>f</code> have been flipped to lowercase, which shouldn't have happened. We've passed in the <code>capitalize_char()</code> function into the list comprehension, returning the capitalized version of each element we've passed in. This results in:
<pre><code class="hljs">MKVNLILFSLLV
</code></pre>
<h2 id="convertlisttostringinpythonwithmap">Convert List to String in Python with map()</h2>
Finally, for a more clean and easy way to pass elements through a function - we can use <code>map()</code>. Generally, the <code>map()</code> function is used to map values of one collection to another, typically using a different (or even reduced) format.
For instance, you could map each character to another list of booleans, where each boolean represents if the character is uppercase or not.
Of course, you can also always do a 1-to-1 mapping using the <code>map()</code> function and, well, just map a string to a string, joining them together into a single one:
<pre><code class="hljs">base_list = [&#x27;M&#x27;, &#x27;K&#x27;, &#x27;V&#x27;, &#x27;N&#x27;, &#x27;L&#x27;, &#x27;I&#x27;, &#x27;L&#x27;, &#x27;F&#x27;, &#x27;S&#x27;, &#x27;L&#x27;, &#x27;L&#x27;, &#x27;V&#x27;]

string = &quot;&quot;.join(map(str, base_list))

print(string)
</code></pre>
This results in:
<pre><code class="hljs">MKVNLILFSLLV
</code></pre>
<blockquote>
If you'd like to read more about mapping in Python, read our <a target="_blank" href="https://stackabuse.com/map-filter-and-reduce-in-python-with-examples/">Guide to map(), filter() and reduce() in Python</a>!
</blockquote>
<h2 id="conclusion">Conclusion</h2>
In this short guide, we've taken a look at how to convert a list to a string in Python, collecting the elements into a single piece.
Strings are inherently lists of characters, and they behave in much the same way, but can be treated as individual elements as well.
You've learned how to use the <code>join()</code> function in its plain form, as well as how to use it with list comprehensions, custom methods and the <code>map()</code> function!

In this short practical guide, learn how to join strings into a list with the join() function, list comprehensions, custom methods and the map() function!

Python: Convert List to String with join()

In this guide, learn how to use Collectors.groupingByConcurrent() collector in Java 8 to collect and group elements of streams concurrently, with downstream collectors and suppliers, through examples.

Guide to Java 8 Collectors: groupingByConcurrent()

Data can take many shapes and forms - and it's oftentimes represented as strings.
Be it from a CSV file or input text, we split strings oftentimes to obtain lists of features or elements.
<blockquote>
In this guide, we'll take a look at how to split a string into a list in Python, with the <code>split()</code> method.
</blockquote>
<h2 id="splitstringintolistinpython">Split String into List in Python</h2>
The <code>split()</code> method of the string class is fairly straightforward. It splits the string, given a delimiter, and returns a list consisting of the elements split out from the string.

 <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">
 By default, the delimiter is set to a whitespace - so if you omit the delimiter argument, your string will be split on each whitespace.

 </div>
 </div>
 </div>
 Let's take a look at the behavior of the <code>split()</code> method:
<pre><code class="hljs">string = &quot;Age,University,Name,Grades&quot;

lst = string.split(&#x27;,&#x27;)

print(lst)
print(&#x27;Element types:&#x27;, type(lst[0]))
print(&#x27;Length:&#x27;, len(lst))
</code></pre>
Our string had elements delimited with a comma, as in a CSV (comma-separated values) file, so we've set the delimiter appropriately.
This results in a list of elements of type <code>str</code>, no matter what other type they can represent:
<pre><code class="hljs">[&#x27;Age&#x27;, &#x27;University&#x27;, &#x27;Name&#x27;, &#x27;Grades&#x27;]
Element types: &lt;class &#x27;str&#x27;&gt;
Length: 4
</code></pre>
<h2 id="splitstringintolisttrimwhitespacesandchangecapitalization">Split String into List, Trim Whitespaces and Change Capitalization</h2>
Not all input strings are clean - so you won't always have a perfectly formatted string to split. Sometimes, strings may contain whitespaces that shouldn't be in the &quot;final product&quot; or have a mismatch of capitalized and non-capitalized letters.
Thankfully, it's pretty easy to process this list and each element in it, after you've split it:
<pre><code class="hljs"># Contains whitespaces after commas, which will stay after splitting
string = &quot;age, uNiVeRsItY, naMe, gRaDeS&quot;
lst = string.split(&#x27;,&#x27;)

print(lst)
</code></pre>
This results in:
<pre><code class="hljs">[&#x27;age&#x27;, &#x27; uNiVeRsItY&#x27;, &#x27; naMe&#x27;, &#x27; gRaDeS&#x27;]
</code></pre>
No good! Each element starts with a whitespace and the elements aren't properly capitalized at all. Applying a function to each element of a list can easily be done through a simple <code>for</code> loop so we'll want to apply a <code>strip()</code>/<code>trim()</code> (to get rid of the whitespaces) and a capitalization function.
Since we're not only looking to capitalize the first letter but also keep the rest lowercase (to enforce conformity), let's define a helper function for that:
<pre><code class="hljs">def capitalize_word(string):
 return string[:1].capitalize() + string[1:].lower()
</code></pre>
The method takes a string, slices it on its first letter and capitalizes it. The rest of the string is converted to lowercase and the two changed strings are then concatenated.
We can now use this method in a loop as well:
<pre><code class="hljs">string = &quot;age, uNiVeRsItY, naMe, gRaDeS&quot;

lst = string.split(&#x27;,&#x27;)
lst = [s.strip() for s in lst]
lst = [capitalize_word(s) for s in lst]

print(lst)
print(&#x27;Element types:&#x27;, type(lst[0]))
print(&#x27;Length:&#x27;, len(lst))
</code></pre>
This results in a clean:
<pre><code class="hljs">[&#x27;Age&#x27;, &#x27;University&#x27;, &#x27;Name&#x27;, &#x27;Grades&#x27;]
Element types: &lt;class &#x27;str&#x27;&gt;
Length: 4
</code></pre>
<h2 id="splitstringintolistandconverttointeger">Split String into List and Convert to Integer</h2>
What happens if you're working with a string-represented list of integers? After splitting, you won't be able to perform integer operations on these, since they're ostensibly strings.
Thankfully, we can use the same <code>for</code> loop as before to convert the elements into integers:
<pre><code class="hljs">string = &quot;1,2,3,4&quot;

lst = string.split(&#x27;,&#x27;)
lst = [int(s) for s in lst]

print(lst)
print(&#x27;Element types:&#x27;, type(lst[0]))
print(&#x27;Length:&#x27;, len(lst))
</code></pre>
Which now results in:
<pre><code class="hljs">[1, 2, 3, 4]
Element types: &lt;class &#x27;int&#x27;&gt;
Length: 4
</code></pre>
<h2 id="splitstringintolistwithlimiter">Split String into List with Limiter</h2>
Besides the delimiter, the <code>split()</code> method accepts a limiter - the number of times a split should occur.
It's an integer and is defined after the delimiter:
<pre><code class="hljs">string = &quot;Age, University, Name, Grades&quot;

lst = string.split(&#x27;,&#x27;, 2)
print(lst)
</code></pre>
Here, two splits occur, on the first and second comma, and no splits happen after that:
<pre><code class="hljs">[&#x27;Age&#x27;, &#x27; University&#x27;, &#x27; Name, Grades&#x27;]
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this short guide, you've learned how to split a string into a list in Python.
You've also learned how to trim the whitespaces and fix capitalization as a simple processing step alongside splitting a string into a list.

In this short guide, learn how to split a string into a list in Python. Also, learn how to split a string and then trim the elements, and make the first letters capitalized, through practical examples!

Python: Split String into List with split()

In this detailed guide, learn how to use the groupingBy() collector in Java 8 to collect and group elements of streams, with downstream collectors and suppliers, through examples.

Guide to Java 8 Collectors: groupingBy()

The Portable Document Format (PDF) is not a WYSIWYG (What You See is What You Get) format. It was developed to be platform-agnostic, independent of the underlying operating system and rendering engines.
To achieve this, PDF was constructed to be interacted with via something more like a programming language, and relies on a series of instructions and operations to achieve a result. In fact, PDF is based on a scripting language - <a rel="nofollow noreferrer noopener" target="_blank" href="https://www.adobe.com/products/postscript.html">PostScript</a>, which was the first device-independent Page Description Language.
In this guide, we'll be using <a rel="nofollow noreferrer noopener" target="_blank" href="https://borbpdf.com/">borb</a> - a Python library dedicated to reading, manipulating and generating PDF documents. It offers both a low-level model (allowing you access to the exact coordinates and layout if you choose to use those) and a high-level model (where you can delegate the precise calculations of margins, positions, etc to a layout manager).
<blockquote>
In this guide, we'll take a look at how to convert a UTF-8 book (from Project Gutenberg) to a PDF document.
</blockquote>

 <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: Project Gutenberg eBooks may be freely used in the United States because most are not protected by U.S. copyright law. They may not be free of copyright in other countries.

 </div>
 </div>
 </div>
 <h2 id="installingborb">Installing borb</h2>
borb can be downloaded from source on <a rel="nofollow noopener" target="_blank" href="https://github.com/jorisschellekens/borb">GitHub</a>, or installed via <code>pip</code>:
<pre><code class="hljs">$ pip install borb
</code></pre>
<h2 id="installingunidecode">Installing unidecode</h2>
For this project we will also use <code>unidecode</code>, it's a wonderful little library that converts text from UTF-8 to ASCII. Keep in mind that not every character in UTF-8 can be represented as an ASCII character.
This is a lossy conversion, in principle so there will be some discrepancy every time you do a conversion:
<pre><code class="hljs">$ pip install unidecode
</code></pre>
<h2 id="creatingapdfdocumentwithborb">Creating a PDF Document with borb</h2>
Creating a PDF document using borb typically follows the same steps every time:
<pre><code class="hljs">from borb.pdf.document import Document
from borb.pdf.page.page import Page
from borb.pdf.pdf import PDF

import typing
import re

from borb.pdf.canvas.layout.page_layout.multi_column_layout import SingleColumnLayout
from borb.pdf.canvas.layout.page_layout.page_layout import PageLayout

# Create empty Document
pdf = Document()

# Create empty Page
page = Page()

# Add Page to Document
pdf.append_page(page)

# Create PageLayout
layout: PageLayout = SingleColumnLayout(page)
</code></pre>
<h2 id="creatingebookswithborb">Creating Ebooks with borb</h2>

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: We'll be dealing with raw text books. Each book will have a different structure and each book requires a different approach to rendering. This is a highly subjective (styling) and highly book-dependent task, though, the general process is the same.

 </div>
 </div>
 </div>
 The book we'll be downloading is UTF-8 encoded. Not every font supports every character. In fact, the PDF spec defines 14 standard fonts (which every reader/writer ought to have embedded), none of which support the full UTF-8 range.
So, to make our lives a bit easier, we're going to be using this little utility function to convert a <code>str</code> to ASCII:
<pre><code class="hljs">from unidecode import unidecode

def to_ascii(s: str) -&gt; str:
 s_out: str = &quot;&quot;
 for c in s:
 if c == &#x27;“&#x27; or c == &#x27;”&#x27; or c == &#x27;â&#x27;:
 s_out += &#x27;&quot;&#x27;
 else:
 s_out += unidecode(c) 
 return s_out
</code></pre>
Next, in our main method, we're going to be downloading the UTF-8 book.
In our example, we'll be using &quot;The Mysterious affair at Styles&quot; by Agatha Christie, which can be easily obtained in raw format from Project Gutenberg:
<pre><code class="hljs"># Define which ebook to fetch
url = &#x27;https://www.gutenberg.org/files/863/863-0.txt&#x27;

# Download text
import requests
txt = requests.get(url).text
print(&quot;Downloaded %d bytes of text...&quot; % len(txt))

# Split to lines
lines_of_text: typing.List[str] = re.split(&#x27;\r\n&#x27;, txt)
lines_of_text = [to_ascii(x) for x in lines_of_text]

# Debug
print(&quot;This ebook contains %d lines... &quot; % len(lines_of_text))
</code></pre>
This prints:
<pre><code class="hljs">Downloaded 361353 bytes of text...
This ebook contains 8892 lines...
</code></pre>
The first lines of text are a general header added by Project Gutenberg. We don't really want that in our eBook so we're going to simply delete it, by checking whether a line starts with a certain pattern and slicing it off via the <a target="_blank" href="https://stackabuse.com/python-slice-notation-on-string/">slice notation</a>:
<pre><code class="hljs"># Skip header
header_offset: int = 0
for i in range(0, len(lines_of_text)):
 if lines_of_text[i].startswith(&quot;*** START OF THE PROJECT GUTENBERG EBOOK&quot;):
 header_offset = i + 1
 break
while lines_of_text[header_offset].isspace():
 header_offset += 1
lines_of_text = lines_of_text[header_offset:]
print(&quot;The first %d lines are the gutenberg header...&quot; % header_offset)
</code></pre>
This prints:
<pre><code class="hljs">The first 24 lines are the gutenberg header...
</code></pre>
Similarly, the last lines of text are just a copyright notice. We'll delete that as well:
<pre><code class="hljs"># Skip footer
footer_offset: int = len(lines_of_text)
for i in range(0, len(lines_of_text)):
 if &quot;*** END OF THE PROJECT GUTENBERG EBOOK&quot; in lines_of_text[i]:
 footer_offset = i
 break
lines_of_text = lines_of_text[0:footer_offset]
print(&quot;The last %d lines are the gutenberg footer ..&quot; % (len(lines_of_text) - footer_offset))
</code></pre>
With that out of the way, we're going to process the main body of text.
This code took some trial and error and if you're working with a different book - it will take some trial and error too.
Figuring out when to insert a chapter title, when to start a new paragraph, what the table of contents is, etc. depends on the book as well. This is an opportunity to play around with borb a bit, and try to parse the input yourself with a different book:
<pre><code class="hljs">from borb.pdf.canvas.layout.text.paragraph import Paragraph
from borb.pdf.canvas.layout.text.heading import Heading
from borb.pdf.canvas.color.color import HexColor, X11Color
from decimal import Decimal

# Main processing loop
i: int = 0
while i &lt; len(lines_of_text):
 
 # Process lines
 paragraph_text: str = &quot;&quot;
 while i &lt; len(lines_of_text) and not len(lines_of_text[i]) == 0:
 paragraph_text += lines_of_text[i]
 paragraph_text += &quot; &quot;
 i += 1

 # Empty line
 if len(paragraph_text) == 0:
 i += 1
 continue

 # Space
 if paragraph_text.isspace():
 i += 1
 continue

 # Contains the word &#x27;CHAPTER&#x27; multiple times (likely to be table of contents)
 if sum([1 for x in paragraph_text.split(&#x27; &#x27;) if &#x27;CHAPTER&#x27; in x]) &gt; 2:
 i += 1
 continue

 # Debug
 print(&quot;Processing line %d / %d&quot; % (i, len(lines_of_text)))

 # Outline
 if paragraph_text.startswith(&quot;CHAPTER&quot;):
 print(&quot;Adding Header of %d bytes ..&quot; % len(paragraph_text))
 try:
 page = Page()
 pdf.append_page(page)
 layout = SingleColumnLayout(page)
 layout.add(Heading(paragraph_text, font_color=HexColor(&quot;13505B&quot;), font_size=Decimal(20)))
 except:
 pass
 continue

 # Default
 try:
 layout.add(Paragraph(paragraph_text))
 except:
 pass
 
 # Default behavior
 i += 1
</code></pre>
All that's left is to store the final PDF document:
<pre><code class="hljs">with open(&quot;output.pdf&quot;, &quot;wb&quot;) as pdf_file_handle:
 PDF.dumps(pdf_file_handle, pdf)
</code></pre>
<img src="https://s3.stackabuse.com/media/articles/using-borb-to-create-e-books-from-project-gutenberg-1.png" alt="creating pdf ebooks with borb">
<h2 id="conclusion">Conclusion</h2>
In this guide you've learned how to process a large piece of text and create a PDF out of it automatically using borb.
Creating books from raw text files is not a standard process, and you'll have to test things out and play around with the loops and the way you treat text to get it right.

Joris Schellekens

Using borb with Python to Create E-books From Project Gutenberg

<h2 id="introduction">Introduction</h2>
Strings are one of the most common data types used in software - they represent strings of characters that we parse as words.
String concatenation is a pretty standard task, especially since we don't always deal with static strings. We often create strings dynamically, such as with ES6 Templates, or simply concatenate strings to form new ones.
<blockquote>
If you'd like to read more about creating dynamic formatted strings - read our <a target="_blank" href="https://stackabuse.com/es6-template-string-literals-in-nodejs/">Guide to ES6 Templates/String Literals in Node.js</a>!
</blockquote>
In this tutorial, we'll take a look at how to join/append/concatenate strings in JavaScript.

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: Strings are immutable, meaning they can't really be changed. Whenever you call a changing operation on a string, a copy is constructed with the changes applied and it's returned instead of the original one.

 </div>
 </div>
 </div>
 <h2 id="concatenatewiththeoperator">Concatenate With the + Operator</h2>
The easiest, and probably most intuitive approach to string concatenation is using the <code>+</code> operator:
<pre><code class="hljs">console.log(&quot;hello &quot; + &quot;world&quot;);
</code></pre>
Running this short piece of code results in:
<pre><code class="hljs">hello world
</code></pre>
It is possible to assign a string in memory to a reference variable, and reference the object instead of concatenating it directly:
<pre><code class="hljs">let firstWord = &quot;hello &quot;;
let secondWord = &quot;world&quot;;
let newWord = firstWord + secondWord;
</code></pre>
This also results in:
<pre><code class="hljs">hello world
</code></pre>

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: In most cases, you can reasonably replace a <code>=</code> and <code>+</code> with the shorthand <code>+=</code>, which lets you omit the reference to the first operand, which will be replaced with the variable you're assigning the result to.

 </div>
 </div>
 </div>
 Instead, you could be writing the short-hand version:
<pre><code class="hljs">let word = &quot;hello &quot;;
word += &quot;world&quot;;
console.log(word);
</code></pre>
It's worth noting that other data types can be thrown into the mix as well, and whenever implicit conversion is possible - JavaScript will &quot;match&quot; the data types into strings.
For instance, integers are easily converted to strings so if you try concatenating an integer onto a string - the integer is converted before being appended. A string may not be converted into an integer at all times - such as when it doesn't represent a number or has odd formatting, so generally, it's easier to convert to a string, than from a string:
<pre><code class="hljs">var str = &quot;hello&quot;;
var int = 21;
var boolean = true;

console.log(str+int);
console.log(str+boolean)
</code></pre>
This results in both the boolean and integer being converted into string representations and then appended to the &quot;hello&quot; string:
<pre><code class="hljs">hello21
hellotrue
</code></pre>
<h2 id="stringprototypeconcat">String.prototype.concat()</h2>
The <code>concat()</code> method was created specifically for this task - to concatenate strings. It can be invoked over any string, and accepts another string to be concatenated to the calling one.
In a sense, it's similar to using the short-hand <code>+=</code> operator:
<pre><code class="hljs">let string1 = &quot;Java&quot;;
let string2 = &quot;Script&quot;;

console.log(string1.concat(string2));
</code></pre>
This results in:
<pre><code class="hljs">JavaScript
</code></pre>
Additionally, you can specify a delimiter as the first argument, which is then added in-between all of the concatenated strings:
<pre><code class="hljs">let string1 = &quot;Java&quot;;
let string2 = &quot;Script&quot;;

console.log(string1.concat(&quot;, &quot;, string2));
</code></pre>
This results in:
<pre><code class="hljs">Java, Script
</code></pre>
<h2 id="arrayprototypejoin">Array.prototype.join()</h2>
The <code>join()</code> method of the <code>Array</code> class is used to join the elements of an array into a string, with a default delimiter of a comma (<code>,</code>).
This allows us to deal with a larger number of strings in a much more concise way, and it's not unheard of to read a file into an array, or to work with an array of strings you'd like to join together.
If you don't pass in any arguments into the method - the default value will be used to delimit the newly joined strings. Let's pass in an empty string to skip that and just join them similar to what we've seen before:
<pre><code class="hljs">let elements = [&quot;JavaScript&quot;, &quot;HTML&quot;, &quot;CSS&quot;];
console.log(elements.join(&quot;&quot;));
</code></pre>
This results in:
<pre><code class="hljs">JavaScriptHTMLCSS
</code></pre>
<h2 id="whichapproachtouse">Which Approach to Use?</h2>
It's advised to prefer the <code>concat()</code> function instead of the + operator, due to performance benefits. However, this doesn't actually always hold and takes in several assumptions into mind.
First of all - the number of strings you're concatenating plays a role in this, as well as other factors you might not even be aware of. Let's benchmark the <code>concat()</code> method as well as the <code>+</code> operator:
<pre><code class="hljs">console.time(&#x27;Concatenating with Operator&#x27;);
concatWithOperator();
console.timeEnd(&#x27;Concatenating with Operator&#x27;);

console.time(&#x27;Concatenating with Function&#x27;);
concatWithFunction();
console.timeEnd(&#x27;Concatenating with Function&#x27;);

function concatWithOperator() {
 let result = &quot;&quot;;
 for (let i = 0; i &lt; 10000; i++) {
 result += i;
 }
}

function concatWithFunction() {
 let result = &quot;&quot;;
 for (let i = 0; i &lt; 10000; i++) {
 result = result.concat(i);
 }
}
</code></pre>
This results in:
<pre><code class="hljs">Concatenating with Operator: 3.232ms
Concatenating with Function: 1.509ms
</code></pre>
But wait, let's switch the environment and run this on a different machine:
<pre><code class="hljs">Concatenating with Operator: 1.985ms
Concatenating with Function: 1.990ms
</code></pre>
And let's run that on the same machine again:
<pre><code class="hljs">Concatenating with Operator: 2.030ms
Concatenating with Function: 0.934ms
</code></pre>
The execution times vary wildly (although, all of them are acceptable in speed). It's also worth noting the official statement from <a target="_blank" rel="nofollow noopener noreferrer" href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/concat">MDN</a>, regarding the performance benefits:
<blockquote>
It is strongly recommended that the assignment operators (+, +=) are used instead of the concat() method.
</blockquote>
Which might seem odd, given the fact that <code>concat()</code> outperforms the operators in the tests or at worst is the same speed. What gives? Well, benchmarking code like this isn't as easy as simply running it and observing the results.
Your browser, its version, as well as the optimizer it uses may vary from machine to machine, and properties like those really impact the performance. For instance, we've used different strings in the concatenation, the ones generated from iteration. If we were to use the same string, an optimizer such as Google's V8 would further optimize the usage of the string.

 <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">
 Test and verify your own code instead of taking advice at face value. Not all machines and environments are the same, and what works great on one, might not work great on another. Take this into consideration when creating applications as well.

 </div>
 </div>
 </div>
 <h2 id="conclusion">Conclusion</h2>
We've taken a look at how to concatenate strings in JavaScript using the <code>+</code> operator, the <code>join()</code> method of the <code>Arrays</code> class as well as the <code>concat()</code> method of the <code>String</code> class.
We've taken a look at the official stance and ran our own tests to see which approach is the most performant - and as usual, it depends on various factors.

In this short tutorial, we'll take a look at how to join/concatenate/append strings in JavaScript using the + operator, concat() and join() methods, as well as benchmark and test our code's performance.