<h2 id="introduction">Introduction</h2>
Java is a type-safe, verbose language. There are advantages to this, but also some drawbacks. Namely - there's oftentimes a lot of boilerplate code and simple operations such as printing an array aren't as simple as supplying it to the <code>println()</code> method:
<pre><code class="hljs">int[] array = new int[]{1, 2, 3, 4, 5, 6};
System.out.println(array);
</code></pre>
This results in the hashes of object reference in memory, not its contents:
<pre><code class="hljs">[I@7c3df479
</code></pre>
This is because Java's arrays don't override the <code>toString()</code> method of the <code>Object</code> class, and just return the hash of the object itself. This is an obviously missing feature in the language, and it's not exactly clear why such a feature would be missing, especially with other languages having support for printing such fundamental data structures.
<blockquote>
In this guide, we'll take a look at several ways of printing arrays in one line - utilizing the built-in helper methods and the Stream API, weighing the differences between the approaches and when to use which one.
</blockquote>
<h2 id="arraystostring">Arrays.toString()</h2>
The simplest and most straightforward way to print an array in a single line is to use the helper <code>Arrays</code> class, residing in the <code>java.util</code> package:
<pre><code class="hljs">int[] array = new int[]{1, 2, 3, 4, 5, 6};
System.out.println(Arrays.toString(array));
</code></pre>
Under the hood, it uses a <code>StringBuilder</code> to append each element through a simple <code>for</code> loop, and you get a result you might expect when printing an array as-is:
<pre><code class="hljs">[1, 2, 3, 4, 5, 6]
</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: This approach fails on nested arrays, in which case, an element is an array, so its reference to the object in memory is added instead of its contents.

 </div>
 </div>
 </div>
 So, this 2D array can't be printed with <code>Arrays.toString()</code>:
<pre><code class="hljs">int[][] array = new int[][]{{1, 2, 3, 4, 5, 6}, {7, 8, 9, 10, 11, 12}};
System.out.println(Arrays.toString(array));
</code></pre>
And results in:
<pre><code class="hljs">[[I@7c3df479, [I@7106e68e]
</code></pre>
<h2 id="arraysdeeptostring">Arrays.deepToString()</h2>
If you'd like to work with nested arrays, you can use the <code>deepToString()</code> method instead:
<pre><code class="hljs">int[][] array = new int[][]{{1, 2, 3, 4, 5, 6}, {7, 8, 9, 10, 11, 12}};
System.out.println(Arrays.deepToString(array));
</code></pre>
This results in the expected output:
<pre><code class="hljs">[[1, 2, 3, 4, 5, 6], [7, 8, 9, 10, 11, 12]]
</code></pre>
<h2 id="printarrayinonelinewithjavastreams">Print Array in One Line with Java Streams</h2>
<code>Arrays.toString()</code> and <code>Arrays.toDeepString()</code> just print the contents in a fixed manner and were added as convenience methods that remove the need for you to create a manual <code>for</code> loop. When printing though, you might want to format the output a bit, or perform additional operations on the elements while going through them.
The Stream API was added in Java 8, as one of the first steps in introducing the Functional Programming paradigm into Java. Generally, when printing an array with a <code>Stream</code>, you'll call the <code>forEach()</code> method, though there are multiple ways of <a target="_blank" href="https://stackabuse.com/java-convert-array-to-stream/">obtaining a Stream from an Array</a>.
<blockquote>
If you'd like to read more about the <code>forEach()</code> method, read our <a target="_blank" href="https://stackabuse.com/guide-to-java-streams-foreach-with-examples/">Guided to Stream.forEach() in Java</a>!
</blockquote>
The easiest way to obtain a Stream from an Array is the <code>Stream.of()</code> method, which can be used with other collections as well (but depends on the data type), though you could also use <code>Arrays.stream()</code> (more robust) or convert the array to a list and stream that (a bit redundant though) via <code>Arrays.asList().stream()</code>.
From all of these - you'll most likely be using the <code>Arrays.stream()</code> method as it doesn't concern itself with whether the elements are a primitive type or an object, which is a concern when using the <code>Stream.of()</code> method.
With <code>Stream.of()</code>, depending on the data type you're using, you'll either use a <code>Stream</code> or a derived variant, such as <code>IntStream</code>. This is important, lest the code return a hash instead of the contents.
<pre><code class="hljs">int[] intArray = new int[]{1, 2, 3, 4, 5, 6};
String[] objArray = new String[]{&quot;Java&quot;, &quot;Python&quot;, &quot;JavaScript&quot;};

// If using Stream.of(), primitive types need to be flatmapped
Stream.of(intArray).flatMapToInt(Arrays::stream).forEach(System.out::print);
IntStream.of(intArray).forEach(System.out::print);
// Stream.of() with objects
Stream.of(objArray).forEach(System.out::print);

// Arrays.stream() works with both primitive types and objects
Arrays.stream(intArray).forEach(System.out::print);
Arrays.stream(objArray).forEach(System.out::print);

// If using asList(), primitive types need to be flatMapped
Arrays.asList(intArray).stream().flatMapToInt(Arrays::stream).forEach(System.out::print);
Arrays.asList(objArray).stream().forEach(System.out::print);
</code></pre>
These all result in:
<pre><code class="hljs">123456
JavaPythonJavaScript
</code></pre>
Generally speaking, the <code>Arrays.stream()</code> method is the safest one to use and is also the shortest/most readable one.
Although not very stylized right now - using Streams allows you to add any intermediary operation in the pipeline, so if you'd like to collect these with a delimiter, for instance, you could use a <code>Collector</code>:
<pre><code class="hljs">System.out.println(Arrays.stream(objArray).collect(Collectors.joining(&quot;,&quot;)));
</code></pre>
This results in:
<pre><code class="hljs">Java,Python,JavaScript
</code></pre>
You can get creative here, with multiple operations, such as transforming the values, filtering them and then joining:
<pre><code class="hljs">String[] objArray = new String[]{&quot;Java&quot;, &quot;Python&quot;, &quot;JavaScript&quot;};

System.out.println(Arrays.stream(objArray)
 map(String::toUpperCase)
 filter(e -&gt; e.startsWith(&quot;J&quot;))
 collect(Collectors.joining(&quot;,&quot;)));
</code></pre>
Which maps all of the elements to their counterparts in upper case, filters given a predicate (that an element starts with &quot;J&quot;) and then joins them with a delimiter:
<pre><code class="hljs">JAVA,JAVASCRIPT
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this guide, we've taken a look at how to print an array in Java in a single line - a feature that's missing by default.
We've taken a look at how to print arrays via the built-in helper methods of the <code>Arrays</code> class, as well as how to utilize the Stream API to customize this process.

David Landup

In this short tutorial, we'll take a look at how to print an array in a single line in Java, using Arrays.toString(), Arrays.deepToString(), the Stream API and other methods.

Java - How to Print an Array in One Line

<h2 id="introduction">Introduction</h2>
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 noopener noreferrer" 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 noopener noreferrer" 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).
Matplotlib is a data visualization library that fueled an entire generation of engineers to start visualizing data, and the engine behind many other popular libraries such as Seaborn.
Given how common PDF documents are for creating reports (which oftentimes include graphs), we'll take a look at how to integrate Matplotlib charts in a PDF document using borb.
<h2 id="installingborbandmatplotlib">Installing borb (and Matplotlib)</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>
Matplotlib can be installed via <code>pip</code>:
<pre><code class="hljs">$ pip install matplotlib
</code></pre>
<h2 id="integratingmatplotlibchartsinpdfdocumentswithborb">Integrating Matplotlib Charts in PDF Documents with borb</h2>
Before we can create a chart, such as a Pie Chart, we're going to write a small utility function that generates <code>N</code> colors, evenly distributed among the color-spectrum.
This will help us whenever we need to create a plot and color each section:
<pre><code class="hljs">from borb.pdf.canvas.color.color import HSVColor, HexColor
from decimal import Decimal
import typing

def create_n_colors(n: int) -&gt; typing.List[str]:
 # The base color is borb-blue
 base_hsv_color: HSVColor = HSVColor.from_rgb(HexColor(&quot;56cbf9&quot;))
 # This array comprehension creates n HSVColor objects, transforms then to RGB, and then returns their hex string
 return [HSVColor(base_hsv_color.hue + Decimal(x / 360), Decimal(1), Decimal(1)).to_rgb().to_hex_string() for x in range(0, 360, int(360/n))]
</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: HSL (hue, saturation, lightness) and HSV/HSB (hue, saturation, value/hue, saturation, brightness) are alternative representations of the RGB color model.

 </div>
 </div>
 </div>
 HSL and HSV/HSB were designed in the 1970s by computer graphics researchers to more closely align with the way human vision perceives color-making attributes. In these models, colors of each hue are arranged in a radial slice, around a central axis of neutral colors which ranges from black at the bottom to white at the top:
<img src="https://s3.stackabuse.com/media/articles/integrating-matplotlib-charts-in-a-pdf-in-python-with-borb-2.png" alt="hsv cone spectrum"> 
Credits: Wikimedia (CC BY-SA 3.0) license
The advantage of using this representation for <code>Color</code> is that we can easily divide the color-spectrum in equal parts.
Now we can define a <code>create_pie_chart()</code> function (or a function for other types of plots):
<pre><code class="hljs"># New import(s)
import matplotlib.pyplot as plt
from borb.pdf.canvas.layout.image.chart import Chart
from borb.pdf.canvas.layout.layout_element import Alignment

def create_piechart(labels: typing.List[str], data: typing.List[float]):

 # Symetric figure to ensure equal aspect ratio
 fig1, ax1 = plt.subplots(figsize=(4, 4))
 ax1.pie(
 data,
 explode=[0 for _ in range(0, len(labels))],
 labels=labels,
 autopct=&quot;%1.1f%%&quot;,
 shadow=True,
 startangle=90,
 colors=create_n_colors(len(labels)),
 )

 ax1.axis(&quot;equal&quot;) # Equal aspect ratio ensures that pie is drawn as a circle.

 return Chart(
 plt.gcf(),
 width=Decimal(200),
 height=Decimal(200),
 horizontal_alignment=Alignment.CENTERED,
 )
</code></pre>
Here, we've used Matplotlib to create a pie chart, via the <code>pie()</code> function.
<blockquote>
If you'd like to learn more about creating Pie Charts, read our <a target="_blank" href="https://stackabuse.com/matplotlib-pie-chart-tutorial-and-examples/">Guide to Matplotlib Pie Charts</a>!
</blockquote>
The <code>gcf()</code> function of the <code>PyPlot</code> instance returns the current figure (get current figure). This figure can be embedded into a PDF document, by injecting it in a <code>Chart</code> constructor, alongside your customization arguments such as the <code>width</code>, <code>height</code> and <code>horizontal_alignment</code>.
That's it! You just supply a Matplotlib figure to the <code>Chart</code> constructor.
<h2 id="addingamatplotlibcharttoapdfdocument">Adding a Matplotlib Chart to a PDF Document</h2>
Now it's time to create our basic PDF <code>Document</code> and add content to it.
<pre><code class="hljs"># New import(s)
from borb.pdf.document import Document
from borb.pdf.page.page import Page
from borb.pdf.pdf import PDF
from borb.pdf.canvas.layout.page_layout.multi_column_layout import MultiColumnLayout
from borb.pdf.canvas.layout.page_layout.page_layout import PageLayout
from borb.pdf.canvas.layout.text.paragraph import Paragraph

# Create empty Document
pdf = Document()

# Create empty Page
page = Page()

# Add Page to Document
pdf.append_page(page)

# Create PageLayout
layout: PageLayout = MultiColumnLayout(page)

# Write title
layout.add(Paragraph(&quot;About Lorem Ipsum&quot;, 
 font_size=Decimal(20), 
 font=&quot;Helvetica-Bold&quot;))

</code></pre>
We'll be using hyphenation in this PDF to ensure the text can be laid out even more smoothly. Hyphenation in borb is pretty straightforward:
<pre><code class="hljs"># New import(s)
from borb.pdf.canvas.layout.hyphenation.hyphenation import Hyphenation

# Create hyphenation algorithm
hyphenation_algorithm: Hyphenation = Hyphenation(&quot;en-gb&quot;)

# Write paragraph
layout.add(Paragraph(
 &quot;&quot;&quot;
 Lorem Ipsum is simply dummy text of the printing and typesetting industry. 
 Lorem Ipsum has been the industry&#x27;s standard dummy text ever since the 1500s, 
 when an unknown printer took a galley of type and scrambled it to make a type specimen book. 
 It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged. 
 It was popularized in the 1960s with the release of Letraset sheets containing Lorem Ipsum passages, 
 and more recently with desktop publishing software like Aldus PageMaker including versions of Lorem Ipsum.
 &quot;&quot;&quot;, text_alignment=Alignment.JUSTIFIED, hyphenation=hyphenation_algorithm))
</code></pre>
Now we can add a pie chart using the function we declared earlier;
<pre><code class="hljs"># Write graph
layout.add(create_piechart([&quot;Loren&quot;, &quot;Ipsum&quot;, &quot;Dolor&quot;], 
 [0.6, 0.3, 0.1]))
</code></pre>
Next we're going to write three more <code>Paragraph</code> objects. 
One of them is going to be more of a quote (border on the side, different font, etc).
<pre><code class="hljs"># Write paragraph
layout.add(Paragraph(
 &quot;&quot;&quot;
 Contrary to popular belief, Lorem Ipsum is not simply random text. 
 It has roots in a piece of classical Latin literature from 45 BC, making it over 2000 years old. 
 Richard McClintock, a Latin professor at Hampden-Sydney College in Virginia, looked up one of the more obscure Latin words, 
 consectetur, from a Lorem Ipsum passage, and going through the cities of the word in classical literature, 
 discovered the undoubtable source.
 &quot;&quot;&quot;, text_alignment=Alignment.JUSTIFIED, hyphenation=hyphenation_algorithm))

# Write paragraph
layout.add(Paragraph(
 &quot;&quot;&quot;
 Lorem Ipsum is simply dummy text of the printing and typesetting industry. 
 &quot;&quot;&quot;, 
 font=&quot;Courier-Bold&quot;,
 text_alignment=Alignment.JUSTIFIED, 
 hyphenation=hyphenation_algorithm,
 border_color=HexColor(&quot;56cbf9&quot;),
 border_width=Decimal(3),
 border_left=True,
 padding_left=Decimal(5),
 padding_bottom=Decimal(5),
))

# Write paragraph
layout.add(Paragraph(
 &quot;&quot;&quot;
 Lorem Ipsum comes from sections 1.10.32 and 1.10.33 of &quot;de Finibus Bonorum et Malorum&quot; 
 (The Extremes of Good and Evil) by Cicero, written in 45 BC. 
 This book is a treatise on the theory of ethics, very popular during the Renaissance.
 &quot;&quot;&quot;, text_alignment=Alignment.JUSTIFIED, hyphenation=hyphenation_algorithm))
</code></pre>
Let's add another plot
<pre><code class="hljs"># Write graph
layout.add(create_piechart([&quot;Loren&quot;, &quot;Ipsum&quot;, &quot;Dolor&quot;, &quot;Sit&quot;, &quot;Amet&quot;], 
 [600, 30, 89, 100, 203]))
</code></pre>
And one more <code>Paragraph</code> of content
<pre><code class="hljs"># Write paragraph
layout.add(Paragraph(
 &quot;&quot;&quot;
 It is a long established fact that a reader will be distracted by the readable content of a page when looking at its layout. 
 The point of using Lorem Ipsum is that it has a more-or-less normal distribution of letters, as opposed to using &#x27;Content here, content here&#x27;, 
 making it look like readable English. Many desktop publishing packages and web page editors now use Lorem Ipsum as their default model text, 
 and a search for &#x27;lorem ipsum&#x27; will uncover many websites still in their infancy. 
 Various versions have evolved over the years, sometimes by accident, sometimes on purpose (injected humor and the like).
 &quot;&quot;&quot;, text_alignment=Alignment.JUSTIFIED, hyphenation=hyphenation_algorithm))
</code></pre>
Finally, we can store the <code>Document</code>:
<pre><code class="hljs"># Write to disk
with open(&quot;output.pdf&quot;, &quot;wb&quot;) as pdf_file_handle:
 PDF.dumps(pdf_file_handle, pdf)
</code></pre>
Running this code results in a PDF document that looks like this:
<img src="https://s3.stackabuse.com/media/articles/integrating-matplotlib-charts-in-a-pdf-using-borb-1.PNG" alt="integrating matplotlib charts in pdf with python and borb">
<h2 id="conclusion">Conclusion</h2>
In this guide you've learned how to integrate Matplotlib charts in a PDF using <code>borb</code>. From here, the sky's the limit! The more creative you get with data visualization, the nicer your PDFs will be.

Joris Schellekens

Integrating Matplotlib Charts in a PDF in Python With borb

Branko Ilic

Jovana Ninkovic

In this guide, we'll take a look at the theory and implementation of Heap Sort in Java - we'll be implementing it via a Heap and a PriorityQueue.

Heap Sort in Java

In this detailed guide, we'll take a look at Prim's Algorithm and how to find an MST (Minimum Spanning Tree) in a graph in Java in theory and practice.

Graphs in Java: Minimum Spanning Trees - Prim's Algorithm

<h2 id="introduction">Introduction</h2>
Axios is a JavaScript library for making HTTP requests, either in the browser or Node.js.
Unlike the popular <a target="_blank" href="/the-node-js-request-module/">Requests</a> library, Axios is natively promise-based, making it more suitable for modern applications taking advantage of newer JavaScript features, like Promises and the async/await syntax.
If you're experienced in web development and would just like to find an answer as to how to send a PUT request with Axios - the long story short is:
<pre><code class="hljs">const axios = require(&#x27;axios&#x27;);

// Wrapper, specific put() function
const res = await axios.put(&#x27;/api/article/123&#x27;, {
 title: &#x27;Making PUT Requests with Axios&#x27;,
 status: &#x27;published&#x27;
});

// General HTTP function
const res = await axios({
 method: &#x27;put&#x27;,
 url: &#x27;/api/article/123&#x27;,
 data: {
 title: &#x27;Making PUT Requests with Axios&#x27;,
 status: &#x27;published&#x27;
 }
});
</code></pre>
However, if you're new to working with Axios or would like to know more about how this works - read on!
<h2 id="httprequestsandverbs">HTTP Requests and Verbs</h2>
The modern web is built on the HTTP protocol and a request-response lifecycle, where a client requests a resource, and a server responds with it.
The HTTP protocol defines a number of methods with varying intentions, namely <code>GET</code>, <code>POST</code>, <code>DELETE</code>, etc. which allow a client to &quot;state&quot; their intention. One of the more common HTTP methods is the <code>PUT</code> method, which is most commonly used for sending data to a server, either for creating a new resource or for patching or editing data on an existing resource.
For instance, a REST API service for a blog may have a route that allows you to perform CRUD (Create, Read, Update, Delete) operations on the <code>article</code> resource using the path <code>/api/article/[id]</code>.
Sending a <code>GET</code> request to this route might return the article specified by the <code>id</code>. Sending a <code>PUT</code> request to this path would edit the specified attributes article. These attributes can be specified in the body of the request, which is serialized to JSON format by default.
<blockquote>
If you'd like to read more about creating REST APIs with Node.js - read our <a target="_blank" href="https://stackabuse.com/building-a-rest-api-with-node-and-express/">Guide to Building a REST API with Node and Express</a>!
</blockquote>
<h2 id="sendingaputrequestwithaxios">Sending a PUT Request with Axios</h2>
Let's see how we can use the Axios library to send an HTTP PUT request from your JavaScript application.
First, you can install <code>axios</code> using <code>yarn</code> or <code>npm</code>:
<pre><code class="hljs">$ npm install axios --save
</code></pre>
<pre><code class="hljs">$ yarn add axios
</code></pre>
It's also available for frontend applications via a number of CDNs, such as jsDelivr:
<pre><code class="hljs">&lt;script src=&quot;https://cdn.jsdelivr.net/npm/axios/dist/axios.min.js&quot;&gt;&lt;/script&gt;
</code></pre>
Once the library is installed, you'll need to instantiate an instance:
<pre><code class="hljs">const axios = require(&#x27;axios&#x27;);
</code></pre>
The simplest way to make the <code>PUT</code> call is to simply use the <code>put()</code> function of the <code>axios</code> instance, and supply the body of that request in the form of a JavaScript object:
<pre><code class="hljs">const res = await axios.put(&#x27;/api/article/123&#x27;, {
 title: &#x27;Making PUT Requests with Axios&#x27;,
 status: &#x27;published&#x27;
});
</code></pre>
The only arguments needed here are the URL and the data you wish to send, which in our case is the title in which we want to edit the article resource.
The JavaScript object we've created to hold the <code>title</code> and <code>status</code> is serialized into JSON, sent to a request handler, which performs an action and returns a result. The <code>body</code> of the request we're sending is the serialized JSON, which can easily be retrieved on the back-end.

 <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: Since JSON is being sent - which is a very universal format, most frameworks will have no issues reading the sent data and deserializing it into whatever representation the back-end uses, regardless of the tech stack.

 </div>
 </div>
 </div>
 The object returned by Axios, <code>res</code> in this case, has a standard schema for all calls:
<pre><code class="hljs">{
 data: {},
 status: 200,
 statusText: &#x27;OK&#x27;,
 headers: {},
 config: {},
 request: {}
}
</code></pre>
Where:
<ul>
<li><code>data</code>: The data returned by the service you called - typically, a JSON response from a REST API.</li>
<li><code>status</code>: The HTTP status returned by the service, denoting how the operation went - like 200 (OK), 301 (Moved Permanently), 404 (Not Found), etc.</li>
<li><code>statusText</code>: The HTTP status text describing the status code in a human-readable format - like 'OK', 'Moved Permanently', or 'Not Found'.</li>
<li><code>headers</code>: An object containing all headers returned by the service, like 'Cache-Control'.</li>
<li><code>config</code>: The config object provided to the call (optional).</li>
<li><code>request</code>: The request object for this call, which is a <code>ClientRequest</code> in Node.js or <code>XMLHttpRequest</code> in the browser.</li>
</ul>
Another way to make a PUT request with Axios is a more generic method in which you specify the HTTP method within the arguments.
This is done by using the <code>axios()</code> default method and config object:
<pre><code class="hljs">const res = await axios({
 method: &#x27;put&#x27;,
 url: &#x27;/api/article/123&#x27;,
 data: {
 title: &#x27;Making PUT Requests with Axios&#x27;,
 status: &#x27;published&#x27;
 }
});
</code></pre>
The result of this call is exactly the same as the <code>axios.put()</code> call from earlier - the only difference being that the <code>axios.put()</code> method is a convenience method that wraps the general method, imbuing it with the <code>method: 'put'</code> field.
<h2 id="axiosvsput">axios() vs put()</h2>
So why would you use one method over the other? That may depend on a few factors, like readability or the context in which the method is used, but also to a large degree - your personal preference.
The more generic <code>axios()</code> call is more flexible since all options/configs are specified within the same object, making it easier to add more configs, like headers for example, or switching method verbs.
Since the <code>put()</code> method just wraps <code>axios()</code>, the underlying functionality is fundamentally the same.
<h2 id="handlingerrors">Handling Errors</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: When sending requests - you might not always get an expected result back.

 </div>
 </div>
 </div>
 Generally speaking - you'll want to try sending a request, and catch exceptions if they arise in that process, which changes the call procedure a tiny bit:
<pre><code class="hljs">try {
 const { data } = await axios({
 method: &#x27;put&#x27;,
 url: &#x27;/api/article/123&#x27;,
 data: {
 title: &#x27;Making PUT Requests with Axios&#x27;,
 status: &#x27;published&#x27;
 }
 });

 console.log(data);
} catch (err) {
 if (err.response.status === 404) {
 console.log(&#x27;Resource could not be found!&#x27;);
 } else {
 console.log(err.message);
 }
}
</code></pre>
The main difference here is the error handling, which uses the <code>response</code> object within the error to determine the cause rather than the <code>data</code> object returned from the call itself.
Typically, error-handling is more robust than just checking whether the status is a single integer - however, this way you can alter the flow of the logic based on how the request was handled (or wasn't).
<h2 id="conclusion">Conclusion</h2>
In this article we gave a short introduction to the Axios library and the HTTP PUT method.
We also showed a few examples of how Axios can be used to make PUT calls, as well as how other configurations can be called and how simple errors can be handled.

Scott Robinson

In this practical guide, we'll take a look at how to send a PUT HTTP request with JavaScript's Axios library, in the Node.js environment - with examples and best practices.

Sending PUT HTTP Requests with Axios

<h2 id="introduction">Introduction</h2>
<blockquote>
Sorting is one of the fundamental techniques used in solving problems, especially in those related to writing and implementing efficient algorithms.
</blockquote>
Usually, sorting is paired with searching - meaning we first sort elements in the given collection, then search for something within it, as it is generally easier to search for something in a sorted, rather than an unsorted collection, as we can make educated guesses and impose assumptions on the data.
<blockquote>
There are many algorithms that can efficiently sort elements, but in this guide we'll be taking a look at the theory behind as well as how to implement Quicksort in Java.
</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">
 Fun fact: Since JDK7, the algorithm used for <a target="_blank" href="https://github.com/openjdk-mirror/jdk7u-jdk/blob/master/src/share/classes/java/util/Arrays.java" rel="nofollow noopener noreferrer">off-the-shelf sorting in the JVM for Arrays</a> is a dual-pivot Quicksort!

 </div>
 </div>
 </div>
 <h2 id="quicksortinjava">Quicksort in Java</h2>
Quicksort is a sorting algorithm belonging to the divide-and-conquer group of algorithms, and it's an in-place (no need for auxiliary data structures), non-stable (doesn't guarantee relative order of same-value elements after sorting) sorting algorithm.
The divide-and-conquer algorithms recursively break down a problem into two or more sub-problems of the same type, making them simpler to solve. The breakdown continues until a problem is simple enough to be solved on it's own (we call this the base case).
This algorithm has been shown to give the best results when working with large arrays, and on the other hand when working with smaller arrays an algorithm like <a target="_blank" href="https://stackabuse.com/selection-sort-in-java/">Selection Sort</a> might prove more efficient.
Quicksort modifies the base idea of Selection Sort, so that instead of a minimum (or a maximum), in every step of the way an element is placed on the spot it belongs on in the sorted array.
This element is called the pivot. However, if we wanted to use the divide-and-conquer approach and reduce the problem of sorting the array to a smaller group of two sub-arrays we need to abide by the following: while we're placing our pivot at it's spot in the array we need to group the rest of the elements in two smaller groups - the ones left of the pivot are lesser or equal to it, and the ones on the right are bigger than the pivot.
This is actually the key step of the algorithm - called partitioning, and implementing it efficiently is a must if we want our Quicksort to be efficient as well.
Before discussing how Quicksort works, we should address how we choose which element is the pivot. The perfect scenario is that we always choose the element that splits the array in exact halves. However, since this is almost impossible to achieve, we can approach this problem in a few different ways.
<blockquote>
For example, the pivot can be the first or the last element in the array (or a sub-array) we're currently processing. We can pick a median element as the pivot, or even choose a random element to play the role.
</blockquote>
We have a variety of ways of accomplishing this task, and the approach we'll be taking in this article is to always choose the first (that is, leftmost element of the array) as the pivot. Now let's jump into an example and explain how it all works.
<h2 id="visualizationofquicksort">Visualization of Quicksort</h2>
Suppose we have the following array:
<img src="https://s3.stackabuse.com/media/articles/quicksort-in-java-1.jpg" alt="array">
In this example, the pivot in the first iteration will be <code>4</code>, since the decision is to pick the first element of the array as the pivot. Now comes in the partitioning - we need to place <code>4</code> at the position it will be found in the sorted array.
The index of that position will be <code>2</code>, so after the first partitioning our array will look like this:
<img src="https://s3.stackabuse.com/media/articles/quicksort-in-java-2.jpg" alt="array">

 <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 noticeable that the elements located left and right from the pivot aren't sorted as they should be.

 </div>
 </div>
 </div>
 This is to be expected - whenever we partition an array that isn't the base case (that is of size <code>1</code>), the elements are grouped in a random order.
The important thing is what we discussed earlier: the elements left of the pivot are lesser or equal, and the elements on the right are bigger than the pivot. That isn't to say that they can't be sorted in the first grouping - while unlikely it can still happen.
We continue on, and see that here divide-and-conquer kicks in - we can break down our original problem into two smaller ones:
<img src="https://s3.stackabuse.com/media/articles/quicksort-in-java-3.jpg" alt="array">
For the problem on the left we have an array of size <code>2</code>, and the pivot element will be <code>2</code>. After positioning the pivot at its place (at the position <code>1</code>), we get an array <code>[1, 2]</code> after which we have no more cases for the left side of the problem, since the only two subcases of <code>[1, 2]</code> are <code>[1]</code> and <code>[2]</code> which are both base cases. With this we finish with the left side of subcases and consider that part of the array sorted.
Now for the right side - the pivot is <code>13</code>. Since it's the largest of all of the numbers in the array we're processing, we have the following setup:
<img src="https://s3.stackabuse.com/media/articles/quicksort-in-java-4.jpg" alt="array">
Unlike earlier when the pivot broke down our array into two subcases, there's only one case here - <code>[8, 10, 7, 5]</code>. The pivot now is <code>8</code> and we need to bring it to the position <code>5</code> in the array:
<img src="https://s3.stackabuse.com/media/articles/quicksort-in-java-5.jpg" alt="array">
The pivot now splits the array in two subcases: <code>[7, 5]</code> and <code>[10]</code>. Since <code>[10]</code> is of size <code>1</code>, that is our base case and we don't consider it at all.
The only subarray left is the array of <code>[7, 5]</code>. Here, <code>7</code> is the pivot, and after bringing it to its position (index <code>4</code>), to the left of it at the position <code>3</code> is only <code>5</code>. We have no more subcases and this is where the algorithm ends.
After running Quicksort, we have the following sorted array:
<img src="https://s3.stackabuse.com/media/articles/quicksort-in-java-6.jpg" alt="templateniz">
<blockquote>
This approach also accounts for duplicates in the array, since all of the elements left of the pivot are lesser or equal than the pivot itself.
</blockquote>
<h2 id="implementingquicksortinjava">Implementing Quicksort in Java</h2>
With a good intuition of how Quicksort works - we can follow through with an implementation. First of all, we'll go through the main part of the program that will be running Quicksort itself.
Since Quicksort is a divide-and-conquer algorithm, it's naturally implemented recursively, although you could do it iteratively as well (any recursive function can also be implemented iteratively) - though, the implementation is not as clean:
<pre><code class="hljs">static void quicksort(int[] arr, int low, int high){
 if(low &lt; high){
 int p = partition(arr, low, high);
 quicksort(arr, low, p-1);
 quicksort(arr, p+1, high);
 }
}
</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: low and high represent the left and right margins of the array that's currently being processed.

 </div>
 </div>
 </div>
 The <code>partition(arr, low, high)</code> method partitions the array, and upon it's execution the variable <code>p</code> stores the position of the pivot after the partitioning.
This method is only invoked when we're processing arrays that have more than one element, hence the partitioning only takes place if <code>low &lt; high</code>.
Since Quicksort works in-place, the starting multiset of elements that can be found within the array stays unchanged, but we've accomplished exactly what we aimed to do - group up smaller or equal elements left to the pivot, and bigger than the pivot on the right.
Afterwards, we call the <code>quicksort</code> method recursively twice: for the part of the array from <code>low</code> to <code>p-1</code> and for the part from <code>p+1</code> to <code>high</code>.
Before we discuss the <code>partition()</code> method, for the sake of readability we'll implement a simple <code>swap()</code> function that swaps two elements in the same array:
<pre><code class="hljs">static void swap(int[] arr, int low, int pivot){
 int tmp = arr[low];
 arr[low] = arr[pivot];
 arr[pivot] = tmp;
}
</code></pre>
Now, let's dive into the code for the <code>partition()</code> method and see how it does what we've explained above:
<pre><code class="hljs">static int partition(int[] arr, int low, int high){
 int p = low, j;
 for(j=low+1; j &lt;= high; j++)
 if(arr[j] &lt; arr[low])
 swap(arr, ++p, j);

 swap(arr, low, p);
 return p;
}
</code></pre>
When the <code>for</code> loop is done executing, <code>j</code> has value of <code>high+1</code>, meaning the elements on <code>arr[p+1, high]</code> are higher or equal than the pivot. Because of this it's required we do one more swap of the elements on the position <code>low</code> and <code>p</code>, bringing the pivot at its correct position in the array (that is, position <code>p</code>).
The last thing we need to do is run our <code>quicksort()</code> method and sort an array. We'll be using the same array as we did in the example before, and calling <code>quicksort(arr, low, high)</code> will sort the <code>arr[low, high]</code> part of the array:
<pre><code class="hljs">public static void main(String[] args) {
 int[] arr = {4, 8, 1, 10, 13, 5, 2, 7};
 // Sorting the whole array
 quicksort(arr, 0, arr.length - 1); 
}
</code></pre>
This results in:
<pre><code class="hljs">1, 2, 3, 4, 5, 7, 8, 10, 13
</code></pre>
<h2 id="complexityofquicksort">Complexity of Quicksort</h2>
Quicksort, as well as other algorithms that apply the divide-and-conquer tactic, has a time complexity of <code>O(n log n)</code>. However, compared to something like <a target="_blank" href="https://stackabuse.com/merge-sort-in-java/">Merge Sort</a>, which has the worst-case time complexity of <code>O(n log n)</code>, Quicksort can theoretically have the worst-case of <code>O(n^2)</code>.
The complexity depends on how much time we take to efficiently choose a pivot, which can sometimes be as difficult as sorting the array itself, and since we expect the choosing of a pivot to be <code>O(1)</code> we usually can't guarantee that in every step of the way we'll be choosing the best pivot possible.
Even though the worst-case of Quicksort can be <code>O(n^2)</code>, most of the pivot-choosing strategies are implemented such so they don't deter the complexity too much, which is why the average complexity of Quicksort is <code>O(n log n)</code>. It's widely implemented and used, and the name itself is an homage to its performance capabilities.
On the other hand, where Quicksort hands-down beats Merge Sort is the space complexity - Merge Sort requires <code>O(n)</code> space because it uses a separate array for merging, while Quicksort sorts in-place and has the space complexity of <code>O(1)</code>.
<h2 id="conclusion">Conclusion</h2>
In this article we've covered how the Quicksort algorithm works, how it's implemented and discussed its complexity. Even though the choice of the pivot can &quot;make or break&quot; this algorithm, it's usually considered as one of the most efficient sorting algorithms and is widely used whenever we have a need for sorting arrays with huge amounts of elements.

In this guide we'll take a look at the theory and how to implement a single-pivot Quicksort in Java with a time and space complexity analysis.

Quicksort in JAVA

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="noreferrer nofollow nopener" 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 noopener noreferrer" 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 generate a PDF with a fillable form.
</blockquote>
<h2 id="installingborb">Installing borb</h2>
borb can be downloaded from source on <a rel="noreferrer 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="generatingapdfdocumentwithborb">Generating a PDF Document with borb</h2>
Now that <code>borb</code> is installed, we can import the building blocks and construct a simple PDF page:
<pre><code class="hljs">from borb.pdf.document import Document
from borb.pdf.page.page import Page
from borb.pdf.pdf import PDF
from borb.pdf.canvas.layout.page_layout.multi_column_layout import SingleColumnLayout
from borb.pdf.canvas.layout.page_layout.page_layout import PageLayout
</code></pre>
The following code represents the basic steps on creating a PDF document using <code>borb</code>:
<ul>
<li>Creating an empty Document</li>
<li>Creating an empty Page</li>
<li>Appending the Page to the Document</li>
<li>Creating a PageLayout that is responsible for handling the flow of content (here we'll use SingleColumnLayout)</li>
<li>Adding content to the PageLayout</li>
<li>Persisting the Document to disk</li>
</ul>
With that being said, let's go ahead and create a <code>Document</code>:
<pre><code class="hljs"># 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>
With the initial steps out of the way - we can add the content in. In this instance, it'll be a fillable form. We're going to create a form with some basic user-information questions, such as a name, surname, etc:
<ul>
<li>Name</li>
<li>Surname</li>
<li>Gender</li>
<li>Place of residence</li>
<li>Nationality</li>
</ul>
To ensure everything is laid out just right, we're going to add this content to a <code>Table</code>. The left column will contain the field name (e.g. &quot;name&quot;, &quot;surname&quot;), the right column will contain the fields to be filled in.
We'll additionally add another <code>Paragraph</code> right above the form to annotate it:
<pre><code class="hljs"># New import(s)
from borb.pdf.canvas.layout.table.fixed_column_width_table import FixedColumnWidthTable
from borb.pdf.canvas.layout.text.paragraph import Paragraph
from borb.pdf.canvas.layout.forms.text_field import TextField
from borb.pdf.canvas.color.color import HexColor
from decimal import Decimal
from borb.pdf.canvas.layout.layout_element import Alignment
from borb.pdf.canvas.layout.forms.drop_down_list import DropDownList

# Let&#x27;s start by adding a heading
layout.add(Paragraph(&quot;Patient Information:&quot;, font=&quot;Helvetica-Bold&quot;))

# Use a table to lay out the form
table: FixedColumnWidthTable = FixedColumnWidthTable(number_of_rows=5, number_of_columns=2)

# Name
table.add(Paragraph(&quot;Name : &quot;, horizontal_alignment=Alignment.RIGHT, font_color=HexColor(&quot;56cbf9&quot;)))
table.add(TextField(value=&quot;Doe&quot;, font_color=HexColor(&quot;56cbf9&quot;), font_size=Decimal(20)))

# Surname
table.add(Paragraph(&quot;Surname : &quot;, horizontal_alignment=Alignment.RIGHT, font_color=HexColor(&quot;56cbf9&quot;)))
table.add(TextField(value=&quot;John&quot;, font_color=HexColor(&quot;56cbf9&quot;), font_size=Decimal(20)))
</code></pre>
These input fields are <code>TextField</code>s, which accept a string passed into them. We're going to model the gender field as a dropdown list, from which the reader can choose one of four options:
<ul>
<li>Female</li>
<li>Male</li>
<li>Other</li>
<li>Prefer not to disclose</li>
</ul>
Let's see how that translates to <code>borb</code>:
<pre><code class="hljs"># Gender
table.add(Paragraph(&quot;Gender : &quot;, horizontal_alignment=Alignment.RIGHT))
table.add(DropDownList(
 possible_values=[
 &quot;Female&quot;,
 &quot;Male&quot;,
 &quot;Other&quot;,
 &quot;Prefer not to disclose&quot;,
 ]
))
</code></pre>
We could do a similar thing for country of residence and nationality, but it would involve having to find a list of all countries in the world and passing it to the constructor of the <code>DropDownList</code>.
This stands for any sufficiently long list.
Because this particular field (a list of all countries) is such a common requirement, <code>borb</code> comes preloaded with the class <code>CountryDropDownList</code>:
<pre><code class="hljs"># New import(s)
from borb.pdf.canvas.layout.forms.country_drop_down_list import CountryDropDownList

# Country of Residence
table.add(Paragraph(&quot;Country of Residence : &quot;, horizontal_alignment=Alignment.RIGHT))
table.add(CountryDropDownList(value=&quot;Belgium&quot;))

# Nationality
table.add(Paragraph(&quot;Nationality : &quot;, horizontal_alignment=Alignment.RIGHT))
table.add(CountryDropDownList(value=&quot;Belgium&quot;))
</code></pre>
Now we can finally add the <code>Table</code> to our <code>PageLayout</code>:
<pre><code class="hljs"># Set some properties on the table to make the layout prettier
table.set_padding_on_all_cells(Decimal(5), Decimal(5), Decimal(5), Decimal(5))
table.no_borders()

# Adding Table to PageLayout
layout.add(table)
</code></pre>
Now let's add a (nonsense) data protection policy:
<pre><code class="hljs"># Data protection policy
layout.add(Paragraph(&quot;Data Protection Policy&quot;, 
 font=&quot;Helvetica-Bold&quot;))

# Dummy text
layout.add(Paragraph(
 &quot;&quot;&quot;
 ** Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. 
 Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. 
 Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. 
 Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
 &quot;&quot;&quot;,
 font=&quot;Helvetica-Oblique&quot;
))
</code></pre>
Let's wrap things up by adding a footer. For now, we'll just add a rectangle filled in the accent color, at the bottom of the page. Nothing too fancy.
<pre><code class="hljs"># New import(s)
import typing
from borb.pdf.canvas.geometry.rectangle import Rectangle
from borb.pdf.page.page_size import PageSize
from borb.pdf.canvas.line_art.line_art_factory import LineArtFactory
from borb.pdf.canvas.layout.image.shape import Shape

ps: typing.Tuple[Decimal, Decimal] = PageSize.A4_PORTRAIT.value
r: Rectangle = Rectangle(Decimal(0), Decimal(32), ps[0], Decimal(8))
Shape(points=LineArtFactory.rectangle(r), stroke_color=HexColor(&quot;56cbf9&quot;), fill_color=HexColor(&quot;56cbf9&quot;)).layout(page, r)
</code></pre>
Lastly, we can store the <code>Document</code> we created using the <code>PDF</code> class:
<pre><code class="hljs"># New import(s)
from borb.pdf.pdf import PDF

# Store
with open(&quot;output.pdf&quot;, &quot;wb&quot;) as out_file_handle:
 PDF.dumps(out_file_handle, pdf)
</code></pre>
What does this look like in the end? When we run the code and produce the PDF file - it'll have a few empty fields:
<img src="https://s3.stackabuse.com/media/articles/creating-a-form-in-a-pdf-document-in-python-with-borb-1.png" alt="Fillable form in pdf created in python with borb">
By selecting these fields, you can use your keyboard to enter the details in:
<img src="https://s3.stackabuse.com/media/articles/creating-a-form-in-a-pdf-document-in-python-with-borb-2.png" alt="filled pdf form python borb">
<h2 id="conclusion">Conclusion</h2>
In this guide you've learned how to include form-elements in your PDF, allowing the reader to interact with the PDF.

In this guide, we'll take a look at how to add a fillable, interactive form in a PDF document using Python and borb, with dropdown menus and input text fields.

Creating a Form in a PDF Document in Python With borb

<h2 id="introduction">Introduction</h2>
For web developers, validating user inputs in various types of forms is of crucial importance. Since that is the starting point of data being sent between the client and the server, you need to make sure that everything starts off on the right foot - lest you end up with robust validation on the server end, which is oftentimes a bigger hassle than doing it on the front-end.

 <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">
 Additionally, input can be malicious - in which case, you have to take security into consideration as well. It's better to avoid it altogether by validating input on the front-end.

 </div>
 </div>
 </div>
 <blockquote>
In this article, we'll take a look at how to validate email addresses in JavaScript using Regular Expressions.
</blockquote>
<h2 id="regularexpressionsinjavascript">Regular Expressions in JavaScript</h2>
For anyone unfamiliar with regular expressions, or anyone feeling like they need a quick reminder, here it is!
<blockquote>
Regular expressions are sequences of metacharacters, denoting a pattern. These patterns can be of various kinds: a mix of letters with digits, special characters and even different language characters. An abbreviation for regular expression is RegEx or RegExp.
</blockquote>
Through metacharacters, quantifiers, groups and escape characters - you can express just about any pattern. For instance, this expression denotes a sequence of characters that contains any valid letter between A-Z (both lowercase and uppercase) or digits, in any combination:
<pre><code class="hljs">^([A-Za-z]|[0-9])+$
</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">
 This is also known as checking whether a sequence is alphanumeric.

 </div>
 </div>
 </div>
 For the rest of the guide, we will assume that you are somewhat familiar with Regular Expressions.
<blockquote>
If you aren't familiar with Regular Expressions and would like to learn more - read our <a target="_blank" href="https://stackabuse.com/guide-to-regular-expressions-and-matching-strings-in-javascript/">Guide to Regular Expressions and Matching Strings in JavaScript</a>!
</blockquote>
<h2 id="matchingemailformatsinjavascriptwithregularexpressions">Matching Email Formats in JavaScript with Regular Expressions</h2>
First and foremost, a regular expression that matches all the possible valid email addresses doesn't exist. However, the one that matches 99.9%, does. When validating emails, or really any input, a good practice, which can more or less guarantee that the user will match the RegEx, is to limit the user input upfront.
For example, mandatory usage of gmail.com or yahoo.com and straight-up rejecting the non-supported providers (though, you do run into the issue of scalability and staying up-to-date with this approach).
Another question is raised:
<blockquote>
What is the format of an email?
</blockquote>
It's surprisingly a loose definition, as we'll shortly see - and you can go simple or robust on this. We'll cover the most general regular expressions for validating email, as well as those which are more specific in the guide.
Before we get into the code, let's preview the email formats that we will be looking into:
<ul>
<li>General format - (something)@(some_domain).(some_toplevel_domain)</li>
<li>Specific hosts or domains - referring to a specific type of domain, or top-level domain</li>
<li>RFC 5322 - Internet Message Format, covering 99.9% of email addresses</li>
</ul>
<h2 id="generalemailformatregularexpression">General Email Format Regular Expression</h2>
After many attempts at validating with robust Regular Expressions, many engineers fall back to the good old &quot;general&quot; format that works most of the time. Whether this is a good thing or not is debatable.
What does an email address entail? It has to have a <code>@</code> symbol, as well as some string preceding it, and some string proceeding it. Additionally, the second string needs to contain a dot, which has an additional 2-3 characters after that.
In conclusion, this is a rough sketch:
<pre><code class="hljs">(randomString)@(randomString2).(2-3 characters)
</code></pre>
This follows the general intuition of these emails being valid:
<pre><code class="hljs">someone@gmail.com
john.doe.1@yahoo.com
david@davitech.io
</code></pre>
With that in mind, to generally validate an email address in JavaScript via Regular Expressions, we translate the rough sketch into a <code>RegExp</code>:
<pre><code class="hljs">let regex = new RegExp(&#x27;[a-z0-9]+@[a-z]+\.[a-z]{2,3}&#x27;);

let testEmails = [&quot;notanemail.com&quot;, &quot;workingexample@email.com&quot;, &quot;another_working@somethingelse.org&quot;, &quot;notworking@1.com&quot;];

testEmails.forEach((address) =&gt; {
 console.log(regex.test(address))
});
</code></pre>
The first string can contain any lowercase alphanumeric characters - <code>john.doe.1</code>, <code>workingemail</code>, etc.
This results in:
<pre><code class="hljs">false
true
true
false
</code></pre>
Will this always work? No. There will be some malformed emails that pass-through. You also can't perform spam-detection using this Regular Expression so an email address that intuitively looks like a spam passes this expression just fine:
<pre><code class="hljs">console.log(regex.test(&quot;aaa@aa.aa&quot;)); // true
</code></pre>
Though, even the most robust, complex email address validation expressions fail on this - they're there to validate the form, not whether the email exists.
<blockquote>
Technically speaking, <code>aaa@aa.aa</code> could exist, so who are we to say it doesn't based on just a Regular Expression?
</blockquote>
<h2 id="specificemailaddresses">Specific Email Addresses</h2>
Lowering the amount of uncertainty helps. The less uncertainty there is, the less restrictions you need to impose using an expression. This makes specific email address validation more accurate using the same general formats as we've just seen - you don't have to cover as many edge cases.
Let's take a look at some general cases referring to the domain and top-level domain.
<h3 id="validatinganemailaddressdomainwithjavascript">Validating an Email Address Domain with JavaScript</h3>
Say, you work in a company called Stack Abuse. All the staff have an email ending with <code>@stackabuse.com</code> and the user string is the one changing. The rough sketch would look like this:
<pre><code class="hljs">(randomString)@stackabuse.com
</code></pre>
This makes our task a lot easier, as some of the variables such as the domain name and organization type are now fixed. These two are the typical problem-causing variables, as domain names can vary wildly.
To validate an email address pertaining to a specific domain thus becomes an easy task, utilizing the <code>RegExp</code> class:
<pre><code class="hljs">let regex = new RegExp(&#x27;[a-z0-9]+@stackabuse.com&#x27;);

let testEmails = [&quot;notanemail.com&quot;, &quot;workingexample@stackabuse.com&quot;, &quot;not_working@stackabuse.org&quot;];

testEmails.forEach((address) =&gt; {
 console.log(regex.test(address))
});
</code></pre>
This results in:
<pre><code class="hljs">false
true
false
</code></pre>
With this approach, you can change any literal string to match it according to your needs. As always, the first part of the regular expression can be changed to match cases with uppercase letters, including special characters such as <code>+</code> or <code>_</code>, etc.
<h3 id="validatingemailaddresstopleveldomainsinjavascript">Validating Email Address Top-Level Domains in JavaScript</h3>
This case is pretty similar to the previous one, except that we will be limiting the last two or three characters of the email. 
These can be literally any of: .com, .org, .edu, .eu, .us, etc. Let's match only emails containing <code>.edu</code> since it is never solely this top-level domain, but instead something like <code>example@yale.edu.com</code>.
<pre><code class="hljs">let regex = new RegExp(&#x27;[a-z0-9]+@[a-z]+\.edu\.[a-z]{2,3}&#x27;);

let testEmails = [&quot;notanemail.com&quot;, &quot;someone@stackabuse.com&quot;, &quot;example@yale.edu.com&quot;];

testEmails.forEach((address) =&gt; {
 console.log(regex.test(address))
});
</code></pre>
An invalid email, as well as a valid one fail - because they don't contain an <code>edu</code> in their top-level domain, though, the made-up Yale address works:
<pre><code class="hljs">false
false
true
</code></pre>
<h2 id="rfc5322format">RFC 5322 Format</h2>
The RFC 5322 Format is an Internet Message Format (classic format of an email message). The RFC 5322 only dictates what should be allowed - it isn't an expression itself.
There are multiple expressions that implement the rules laid out, and these can get pretty complex.
<blockquote>
If implemented correctly, the RFC 5322-compliant Regular Expression should validate 99.99% of the valid email addresses.
</blockquote>
A short-hand version is:
<pre><code class="hljs">let regex = new RegExp(&quot;([!#-&#x27;*+/-9=?A-Z^-~-]+(\.[!#-&#x27;*+/-9=?A-Z^-~-]+)*|\&quot;\(\[\]!#-[^-~ \t]|(\\[\t -~]))+\&quot;)@([!#-&#x27;*+/-9=?A-Z^-~-]+(\.[!#-&#x27;*+/-9=?A-Z^-~-]+)*|\[[\t -Z^-~]*])&quot;);
</code></pre>
While an extended version that covers additional edge-cases is:
<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])?|\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-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>
These expressions aren't particularly easy to comprehend unless you break them down into groups and spend some time reading through them. Though, an easier way is to visualize it:
<img src="https://s3.stackabuse.com/media/articles/java-regular-expressions-how-to-validate-emails.png" alt="">
*Image and claim of accuracy are courtesy of <a target="_blank" rel="nofollow noopener noreferrer" href="http://emailregex.com/">EmailRegex.com</a>.
That being said, let's use this expression instead to validate a couple of addresses:
<pre><code class="hljs">let regex = new RegExp(&quot;([!#-&#x27;*+/-9=?A-Z^-~-]+(\.[!#-&#x27;*+/-9=?A-Z^-~-]+)*|\&quot;\(\[\]!#-[^-~ \t]|(\\[\t -~]))+\&quot;)@([!#-&#x27;*+/-9=?A-Z^-~-]+(\.[!#-&#x27;*+/-9=?A-Z^-~-]+)*|\[[\t -Z^-~]*])&quot;);

let testEmails = [&quot;notanemail.com&quot;, &quot;workingexample@stackabuse.com&quot;, &quot;example@yale.edu.com&quot;];

testEmails.forEach((address) =&gt; {
 console.log(regex.test(address))
});
</code></pre>
This results in:
<pre><code class="hljs">false
true
true
</code></pre>
You can go ahead and test this expression interactively through a beautiful interface at <a target="_blank" rel="nofollow noopener noreferrer" target="_regex101.com">regex101</a>.
<h2 id="conclusion">Conclusion</h2>
In conclusion, there is really not a single &quot;proper&quot; way to validate email addresses using regular expressions. However, there is a wrong way - if you don't cover the cases that shouldn't be correct.
For those who want to make sure that literally, almost everything is covered - use the RFC 5322 Format.

Lazar Ristic

In this guide, we'll take a look at how to validate an email address in JavaScript, using Regular Expressions (RegEx), through practical examples, covering all edge cases.

Validate Email Addresses with Regular Expressions in JavaScript

<h2 id="introduction">Introduction</h2>
<blockquote>
In this article, we'll be taking a look at how to round a number to an integer (whole number) in JavaScript.
</blockquote>
JavaScript provides three different methods to achieve this goal: the <code>round()</code> method, the <code>ceil()</code> method and the <code>floor()</code> method.
All of these are static methods of the <code>Math</code> object. This means that they will be called directly via <code>Math.method_name()</code>, not as a method of an instance of <code>Math</code> object - <code>Math</code> has no constructor.

 <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: These methods can only be called on numbers, everything else will result in a <code>NaN</code> value. The only exception is when it's called on <code>null</code> - calling methods on <code>null</code> will always return 0.

 </div>
 </div>
 </div>
 <h2 id="theceilmethod">The ceil() Method</h2>
The name of this method is actually an abbreviation of the word ceiling - so its name automatically rings a bell that it rounds a number to the closest integer value larger than the current number.
If the number is an integer already - there's nothing to round, so it'll simply return the integer instead:
<pre><code class="hljs">let x = 4.7
console.log(Math.ceil(x))
// Output: 5

let y = -3.2
console.log(Math.ceil(y))
// Output: -3

let z = &quot;something not a number&quot;
console.log(Math.ceil(z))
// Output: NaN

console.log(Math.ceil(null))
// Output: 0
</code></pre>
You'll use <code>ceil()</code> when you specifically want to round to the next upper bound. <code>5.1</code> is rounded to <code>6</code>, so if you want to round to the closest integer, you'll use the <code>round()</code> function, covered in a later section of this guide.
<h2 id="thefloormethod">The floor() Method</h2>
Similar to <code>ceil()</code>, <code>floor()</code>'s method is also carefully chosen to fit its purpose. It rounds the integer to the closest integer smaller than the current one:
<pre><code class="hljs">let x = 4.7
console.log(Math.floor(x))
// Output: 4

let y = -3.2
console.log(Math.floor(y))
// Output: -4

let z = &quot;something not a number&quot;
console.log(Math.floor(z))
// Output: NaN

console.log(Math.floor(null))
// Output: 0
</code></pre>
<h2 id="theroundmethod">The round() Method</h2>
The <code>round()</code> method can be viewed as a two-in-one method, containing both <code>ceil()</code> and <code>floor()</code>. It rounds the number to the closest integer - it either &quot;ceils&quot; the number, or &quot;floors&quot; it, based on its value:
<pre><code class="hljs">let x = 4.7
console.log(Math.round(x))
// Output: 5

let y = 4.2 
console.log(Math.round(y))
// Output: 4

let z = 4.5
console.log(Math.round(z))
// Output: 5

console.log(Math.round(null))
// Output: 0
</code></pre>
Everything up to x.49 will be rounded down to the lower value, while everything higher than that will be rounded to the higher value.
<h2 id="conclusion">Conclusion</h2>
In this quick article, we had a look at some of the methods that can be used to round a non-integer in JavaScript. Some key notes to take away from this article are:
<ul>
<li>Math.ceil() - rounds the number to a higher value</li>
<li>Math.floor() - rounds the number to a lower value</li>
<li>Math.round() - rounds the number to either lower or higher value, depending on the number</li>
<li>When called with <code>null</code> as an argument, the methods always return 0</li>
<li>When called with anything but a number or null as an argument, the methods always return <code>NaN</code></li>
</ul>

In this guide, we'll take a look at how to round a number to an integer (whole number) in JavaScript, using ceil(), floor() and round(), with practical examples.