Victoria Seniuk

In this tutorial, we'll implement the Data Transfer Object Pattern in a Java Spring Boot application. We'll also cover examples of mapping entities to DTOs.

Data Transfer Object Pattern in Java - Implementation and Mapping

Marcus Sanatan

Janith Kasun

Axios is a Promised-based JavaScript library that sends HTTP requests. This tutorial shows you how to send various HTTP request with Axios to a JSON API.

Making Asynchronous HTTP Requests in JavaScript with Axios

<h2 id="introduction">Introduction</h2>
In this article, we'll take a look at how we can leverage the <code>Runtime</code> and <code>ProcessBuilder</code> classes to execute shell commands and scripts with Java.
We use computers to automate many things in our daily jobs. System administrators run many commands all the time, some of which are very repetitive and require minimal changes in-between runs.
This process is also ripe for automation. There's no need to run everything manually. Using Java, we can run single or multiple shell commands, execute shell scripts, run the terminal/command prompt, set working directories and manipulate environment variables through core classes.
<h2 id="runtimeexec">Runtime.exec()</h2>
The <code>Runtime</code> class in Java is a high-level class, present in every single Java application. Through it, the application itself communicates with the environment it's in.
By extracting the runtime associated with our application via the <code>getRuntime()</code> method, we can use the <code>exec()</code> method to execute commands directly or run <code>.bat</code>/<code>.sh</code> files.
The <code>exec()</code> method offers a few overloaded variations:
<ul>
<li><code>public Process exec(String command)</code> - Executes the command contained in <code>command</code> in a separate process.</li>
<li><code>public Process exec(String command, String[] envp)</code> - Executes the <code>command</code>, with an array of environment variables. They're provided as an array of Strings, following the <code>name=value</code> format.</li>
<li><code>public Process exec(String command, String[] envp, File dir)</code> - Executes the <code>command</code>, with the specified environment variables, from within the <code>dir</code> directory.</li>
<li><code>public Process exec(String cmdArray[])</code> - Executes a command in the form of an array of Strings.</li>
<li><code>public Process exec(String cmdArray[], String[] envp)</code> - Executes a command with the specified environment variables.</li>
<li><code>public Process exec(String cmdarray[], String[] envp, File dir)</code> - Executes a command, with the specified environment variables, from within the <code>dir</code> directory.</li>
</ul>
It's worth noting that these processes are run externally from the interpreter and will be system-dependent.
What's also worth noting is the difference between <code>String command</code> and <code>String cmdArray[]</code>. They achieve the same thing. A <code>command</code> is broken down into an array anyway, so using any of these two should yield the same results.
It's up to you to decide whether <code>exec(&quot;dir /folder&quot;)</code> or <code>exec(new String[]{&quot;dir&quot;, &quot;/folder&quot;}</code> is what you'd like to use.
Let's write up a few examples to see how these overloaded methods differ from each other.
<h3 id="executingacommandfromstring">Executing a Command from String</h3>
Let's start off with the simplest approach out of these three:
<pre><code class="hljs">Process process = Runtime.getRuntime().exec(&quot;ping www.stackabuse.com&quot;);
</code></pre>
Running this code will execute the command we've supplied in String format. However, we don't see anything when we run this.
To validate if this ran correctly, we'll want to get ahold of the <code>process</code> object. Let's use a <code>BufferedReader</code> to take a look at what's going on:
<pre><code class="hljs">public static void printResults(Process process) throws IOException {
 BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
 String line = &quot;&quot;;
 while ((line = reader.readLine()) != null) {
 System.out.println(line);
 }
}
</code></pre>
Now, when we run this method after the <code>exec()</code> method, it should yield something along the lines of:
<pre><code class="hljs">Pinging www.stackabuse.com [104.18.57.23] with 32 bytes of data:
Reply from 104.18.57.23: bytes=32 time=21ms TTL=56
Reply from 104.18.57.23: bytes=32 time=21ms TTL=56
Reply from 104.18.57.23: bytes=32 time=21ms TTL=56
Reply from 104.18.57.23: bytes=32 time=21ms TTL=56

Ping statistics for 104.18.57.23:
 Packets: Sent = 4, Received = 4, Lost = 0 (0% loss),
Approximate round trip times in milli-seconds:
 Minimum = 21ms, Maximum = 21ms, Average = 21ms
</code></pre>
Keep in mind that we'll have to extract the process information from the <code>Process</code> instances as we go through other examples.
<h3 id="specifytheworkingdirectory">Specify the Working Directory</h3>
If you'd like to run a command from, say, a certain folder, we'd do something along the lines of:
<pre><code class="hljs">Process process = Runtime.getRuntime()
 .exec(&quot;cmd /c dir&quot;, null, new File(&quot;C:\\Users\\&quot;));
 //.exec(&quot;sh -c ls&quot;, null, new File(&quot;Pathname&quot;)); for non-Windows users
printResults(process);
</code></pre>
Here, we've provided the <code>exec()</code> method with a <code>command</code>, a <code>null</code> for new environment variables and a <code>new File()</code> which is set as our working directory.
The addition of <code>cmd /c</code> before a command such as <code>dir</code> is worth noting.
Since I'm working on Windows, this opens up the <code>cmd</code> and <code>/c</code> carries out the subsequent command. In this case, it's <code>dir</code>.
The reason why this wasn't mandatory for the <code>ping</code> example, but is mandatory for this example is nicely <a rel="nofollow noopener" target="_blank" href="https://stackoverflow.com/questions/31776546/why-does-runtime-execstring-work-for-some-but-not-all-commands/31776547">answered</a> by an SO user.
Running the previous piece of code will result in:
<pre><code class="hljs">Volume in drive C has no label.
 Volume Serial Number is XXXX-XXXX

 Directory of C:\Users

08/29/2019 05:01 PM &lt;DIR&gt; .
08/29/2019 05:01 PM &lt;DIR&gt; ..
08/18/2016 09:11 PM &lt;DIR&gt; Default.migrated
08/29/2019 05:01 PM &lt;DIR&gt; Public
05/15/2020 11:08 AM &lt;DIR&gt; User
 0 File(s) 0 bytes
 5 Dir(s) 212,555,214,848 bytes free
</code></pre>
Let's take a look at how we could supply the previous command in several individual parts, instead of a single String:
<pre><code class="hljs">Process process = Runtime.getRuntime().exec(
 new String[]{&quot;cmd&quot;, &quot;/c&quot;, &quot;dir&quot;},
 null, 
 new File(&quot;C:\\Users\\&quot;));
 
printResults(process);
</code></pre>
Running this piece of code will also result in:
<pre><code class="hljs">Volume in drive C has no label.
 Volume Serial Number is XXXX-XXXX

 Directory of C:\Users

08/29/2019 05:01 PM &lt;DIR&gt; .
08/29/2019 05:01 PM &lt;DIR&gt; ..
08/18/2016 09:11 PM &lt;DIR&gt; Default.migrated
08/29/2019 05:01 PM &lt;DIR&gt; Public
05/15/2020 11:08 AM &lt;DIR&gt; User
 0 File(s) 0 bytes
 5 Dir(s) 212,542,808,064 bytes free
</code></pre>
Ultimately, regardless of the approach - using a single String or a String array, the command you input will always be broken down into an array before getting processed by underlying logic.
Which one you'd like to use boils down just to which one you find more readable.
<h3 id="usingenvironmentvariables">Using Environment Variables</h3>
Let's take a look at how we can use environment variables:
<pre><code class="hljs">Process process = Runtime.getRuntime().exec(
 &quot;cmd /c echo %var1%&quot;,
 new String[]{&quot;var1=value1&quot;});
 
printResults(process);
</code></pre>
We can supply as many environment variables as we'd like within the String array. Here, we've just printed the value of <code>var1</code> using <code>echo</code>.
Running this code will return:
<pre><code class="hljs">value1
</code></pre>
<h3 id="runningbatandshfiles">Running .bat and .sh Files</h3>
Sometimes, it's just much easier to offload everything into a file and run that file instead of adding everything programmatically.
Depending on your operating system, you'd use either <code>.bat</code> or <code>.sh</code> files. Let's create one with the contents:
<pre><code class="hljs">echo Hello World
</code></pre>
Then, let's use the same approach as before:
<pre><code class="hljs">Process process = Runtime.getRuntime().exec(
 &quot;cmd /c start file.bat&quot;,
 null,
 new File(&quot;C:\\Users\\User\\Desktop\\&quot;));
</code></pre>
This'll open up the command prompt and run the <code>.bat</code> file in the working directory we've set.
Running this code surely enough results in:
<img src="https://stackabuse.s3.amazonaws.com/media/executing-shell-commands-in-java-1.PNG" alt="command prompt with hello world">
With all of the overloaded <code>exec()</code> signatures taken care of, let's take a look at the <code>ProcessBuilder</code> class and how we can execute commands using it.
<h2 id="processbuilder">ProcessBuilder</h2>
<code>ProcessBuilder</code> is the underlying mechanism that runs the commands when we use the <code>Runtime.getRuntime().exec()</code> method:
<pre><code class="hljs">/**
 * Executes the specified command and arguments in a separate process with
 * the specified environment and working directory.
 *...
*/
public Process exec(String[] cmdarray, String[] envp, File dir) throws IOException {
 return new ProcessBuilder(cmdarray)
 .environment(envp)
 .directory(dir)
 .start();
}
</code></pre>
JavaDocs for the <code>Runtime</code> class
Taking a look at how the <code>ProcessBuilder</code> takes our input from the <code>exec()</code> method and runs the command, gives us a good idea of how to use it as well.
It accepts a <code>String[] cmdarray</code>, and that's enough to get it running. Alternatively, we can supply it with optional arguments such as the <code>String[] envp</code> and <code>File dir</code>.
Let's explore these options.
<h3 id="processbuilderexecutingcommandfromstrings">ProcessBuilder: Executing Command from Strings</h3>
Instead of being able to provide a single String, such as <code>cmd /c dir</code>, we'll have to break it up in this case. For example, if we wanted to list the files in the <code>C:/Users</code> directory like before, we'd do:
<pre><code class="hljs">ProcessBuilder processBuilder = new ProcessBuilder();
processBuilder.command(&quot;cmd&quot;, &quot;/c&quot;, &quot;dir C:\\Users&quot;);

Process process = processBuilder.start();
printResults(process);
</code></pre>
To actually execute a <code>Process</code>, we run the <code>start()</code> command and assign the returned value to a <code>Process</code> instance.
Running this code will yield:
<pre><code class="hljs"> Volume in drive C has no label.
 Volume Serial Number is XXXX-XXXX

 Directory of C:\Users

08/29/2019 05:01 PM &lt;DIR&gt; .
08/29/2019 05:01 PM &lt;DIR&gt; ..
08/18/2016 09:11 PM &lt;DIR&gt; Default.migrated
08/29/2019 05:01 PM &lt;DIR&gt; Public
05/15/2020 11:08 AM &lt;DIR&gt; User
 0 File(s) 0 bytes
 5 Dir(s) 212,517,294,080 bytes free
</code></pre>
However, this approach isn't any better than the previous one. What's useful with the <code>ProcessBuilder</code> class is that it's customizable. We can set things programmatically, not just via commands.
<h3 id="processbuilderspecifytheworkingdirectory">ProcessBuilder: Specify the Working Directory</h3>
Instead of supplying the working directory via the command, let's set it programmatically:
<pre><code class="hljs">processBuilder.command(&quot;cmd&quot;, &quot;/c&quot;, &quot;dir&quot;).directory(new File(&quot;C:\\Users\\&quot;));
</code></pre>
Here, we've set the working directory to be the same as before, but we've moved that definition out of the command itself. Running this code will provide the same result as the last example.
<h3 id="processbuilderenvironmentvariables">ProcessBuilder: Environment Variables</h3>
Using <code>ProcessBuilder</code>s methods, it's easy to retrieve a list of environment variables in the form of a <code>Map</code>. It's also easy to set environment variables so that your program can use them.
Let's get the environment variables currently available and then add some for later use:
<pre><code class="hljs">ProcessBuilder processBuilder = new ProcessBuilder();

Map&lt;String, String&gt; environmentVariables = processBuilder.environment();
environmentVariables.forEach((key, value) -&gt; System.out.println(key + value));
</code></pre>
Here, we've packed the returned environment variables into a <code>Map</code> and ran a <code>forEach()</code> on it to print out the values to our console.
Running this code will yield a list of the environment variables you have on your machine:
<pre><code class="hljs">DriverDataC:\Windows\System32\Drivers\DriverData
HerokuPathE:\Heroku
ProgramDataC:\ProgramData
...
</code></pre>
Now, let's add an environment variable to that list and use it:
<pre><code class="hljs">environmentVariables.put(&quot;var1&quot;, &quot;value1&quot;);

processBuilder.command(&quot;cmd&quot;, &quot;/c&quot;, &quot;echo&quot;, &quot;%var1%&quot;);
Process process = processBuilder.start();
printResults(process);
</code></pre>
Running this code will yield:
<pre><code class="hljs">value1
</code></pre>
Of course, once the program has finished running, this variable will not stay in the list.
<h3 id="processbuilderrunningbatandshfiles">ProcessBuilder: Running .bat and .sh Files</h3>
If you'd like to run a file, again, we'd just supply the <code>ProcessBuilder</code> instance with the required information:
<pre><code class="hljs">processBuilder
 .command(&quot;cmd&quot;, &quot;/c&quot;, &quot;start&quot;, &quot;file.bat&quot;)
 .directory(new File(&quot;C:\\Users\\User\\Desktop&quot;));
Process process = processBuilder.start();
</code></pre>
Running this code results in the command prompt opening up and executing the <code>.bat</code> file:
<img src="https://stackabuse.s3.amazonaws.com/media/executing-shell-commands-in-java-1.PNG" alt="command prompt hello world bat file">
<h2 id="conclusion">Conclusion</h2>
In this article, we've explored examples of running shell commands in Java. We've used the <code>Runtime</code> and <code>ProcessBuilder</code> classes to do this.
Using Java, we can run single or multiple shell commands, execute shell scripts, run the terminal/command prompt, set working directories and manipulate environment variables through core classes.

David Landup

In this tutorial, we'll cover how to execute shell commands, bat and sh files in Java. We'll be covering examples for all exec() and ProcessBuilder approaches.

Executing Shell Commands in Java

Executing Shell Commands with Java

<h2 id="introduction">Introduction</h2>
Selection Sort is one of the simpler and more intuitive sorting algorithms. It is an in-place, unstable, comparison algorithm.
This means that it transforms the input collection using no auxiliary data structures and that the input is overridden by the output (in-place algorithm).
Additionally, during its execution, it only reads list elements through a single abstract comparison operation, usually a &quot;less than or equal to&quot; operator (comparison algorithm).
Finally, the order of duplicate elements isn't preserved after sorting (unstable algorithm).
It is usually taught early on in most Computer Science courses, given that it is very easy to understand and translate into code. Despite its quadratic time complexity, it has performance advantages over some more complex sorting algorithms, such as Quicksort or Merge Sort, in some specific cases.
In this article, we will explain the idea behind Selection Sort and implement it in JavaScript.
After that, we'll analyze its time complexity and compare it to other sorting algorithms. Finally, we will discuss when it can be used, as well as when it should be avoided.
<h2 id="selectionsort">Selection Sort</h2>
This algorithm divides the input array into two sublists - a sorted and unsorted sublist. The sorted list is located at the start of the collection, and all elements to the right of the final sorted element are considered unsorted.
Initially, the sorted list is empty, while the rest of the collection is unsorted. Selection Sort goes through the unsorted sublist and finds the smallest or largest element.
The element is then swapped with the leftmost element of the unsorted sublist. Then, the sorted sublist is expanded to include that element.
This is repeated, finding the fitting element, swapping it with the leftmost element of the unsorted list, and expanding the sorted list to encompass it.
After each iteration, one less element needs to be checked, until the entire array or list is sorted. In other words, after the k-th iteration, the first k elements of the array or list are guaranteed to be sorted.
Let's look at this visual representation of how Selection Sort works on the array of:
<pre><code class="hljs"> 5, 2, 4, 6, 1, 3
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/selection-sort-in-javascript-1.gif" alt="selection sort visualization">
<h2 id="selectionsortimplementation">Selection Sort Implementation</h2>
Now that we've gotten over the idea behind Selection Sort and its visual representation, we can move on to the algorithm implementation in JavaScript:
<pre><code class="hljs">function selectionSort(inputArr) { 
 let n = inputArr.length;
 
 for(let i = 0; i &lt; n; i++) {
 // Finding the smallest number in the subarray
 let min = i;
 for(let j = i+1; j &lt; n; j++){
 if(inputArr[j] &lt; inputArr[min]) {
 min=j; 
 }
 }
 if (min != i) {
 // Swapping the elements
 let tmp = inputArr[i]; 
 inputArr[i] = inputArr[min];
 inputArr[min] = tmp; 
 }
 }
 return inputArr;
}
</code></pre>
We're iterating through the entire input array, and for each element of the array - we find the smallest number in the unsorted subarray. If the smallest number isn't the first one in the unsorted subarray (isn't already in its place), we swap it with the first element of the unsorted subarray.
Without checking if the smallest element is already the first element of the unsorted subarray, we'd be performing unnecessary swaps.
Now, let's add the input array and invoke our function:
<pre><code class="hljs">let inputArr = [5, 2, 4, 6, 1, 3];
selectionSort(inputArr);
console.log(inputArr);
</code></pre>
The output of this code will be:
<pre><code class="hljs">(6) [1, 2, 3, 4, 5, 6]
</code></pre>
<h2 id="timecomplexity">Time Complexity</h2>
The time complexity of Selection Sort is not difficult to analyze.
In the first iteration, throughout the array of n elements, we make n-1 comparisons and potentially one swap. In the second iteration, we will make n-2 comparisons, and so on.
Therefore, the total number of comparisons will be (n-2) + (n-1) + ...+ 1, which adds up to n(n-1)/2 = (n2-n)/2. This leads us to a running time of O(n2).
O(n2) is a pretty bad time complexity for a sorting algorithm. When sorting a collection, you'd use faster sorting algorithms like Quicksort or Merge Sort with a time complexity of O(nlogn).
The best-case performance of Selection Sort is also O(n2), so checking whether the array or list is sorted or not is also really inefficient.
On the other hand, when compared to other quadratic time complexity algorithms like <a target="_blank" href="/bubble-sort-and-cocktail-shaker-sort-in-javascript">Bubble Sort</a>, Selection Sort holds itself quite well, outperforming Bubble Sort and its variants, as well as Gnome Sort.
Insertion sort, however, can be faster than Selection Sort in case the collection is almost sorted. And Insertion Sort is pretty much unbeaten with short collections.
<h2 id="selectionsortvariants">Selection Sort Variants</h2>
Even though the best, worst and average-case performances of this algorithm are O(n2), making it pretty inefficient, Selection Sort is very important for the overall development of sorting algorithms. It was, in fact, a base for some very widely used and efficient sorting algorithms!
Perhaps the most famous variant is Heap Sort, which internally uses a heap data structure for storing elements. Using heaps can speed up the finding and removal of elements to an O(logn) time.
This is a very beneficial optimization that reduces the total running time from O(n^2) to O(nlogn), which is considered good for sorting algorithms.
Another variant is the BidirectionaL Selection Sort, similar to how Bubble Sort has a bidirectional counterpart. It's sometimes known as Cocktail Sort (again, similar to Bubble's Cocktail Shaker Sort), and does the same job in ~25% fewer comparisons.
<h2 id="conclusion">Conclusion</h2>
Selection Sort is a fundamental and simple, thus inefficient sorting algorithm. It served as a basis for some of the widely-used and adopted algorithms and isn't used very often itself in the development industry.
However, if the input collection is small, Selection Sort is a better option than Quicksort or Merge Sort. But then again, Insertion Sort has shown to be more effective than Selection Sort in these cases.
In this article, we've gone over the idea behind Selection Sort, implemented it in JavaScript, explored its time complexity and briefly mentioned some of its variants.

Mila Lukic

In this tutorial, we'll talk about the idea behind Selection Sort, implement it with examples, and analyze its time complexity. Additionally, we'll compare it to similar algorithms.

Selection Sort in JavaScript

<h2 id="introduction">Introduction</h2>
Bubble Sort, sometimes also referred to as Sinking Sort is one of the most widely known sorting algorithms. It is usually one of the first sorting algorithms that CS students come across due to its simplicity and the fact that it is quite intuitive and easy to translate into code.
However, this simple algorithm has shown poor performance in real-life problems. Especially compared to faster, more popular and widely used algorithms like Quicksort or Merge Sort. This is why Bubble Sort is used primarily as an educational tool.
In this article, we'll explain how Bubble Sort works and implement it in JavaScript. We will also check out its time complexity, and compare it to some other sorting algorithms.
Additionally, we'll implement one of its variants - Cocktail Shaker Sort in an attempt to optimize it.
<h2 id="bubblesort">Bubble Sort</h2>
Bubble Sort is a comparison-type sorting algorithm. This means that it compares individual elements within the collection during runtime. Depending on your data type and purpose, the comparison can be done via a relational operator or through a custom comparison function.
The idea behind Bubble Sort is rather simple. Starting from the beginning of the collection we want to be sorted - we compare elements within a pair. If the pair is in the desired order, we do nothing. If it isn't, we swap the elements it consists of.
This is done again, and again, until all elements in the collection are sorted. Let's look at a visual representation of how Bubble Sort works:
<img src="https://stackabuse.s3.amazonaws.com/media/bubble-sort-in-java-1.gif" alt="bubble sort visualization gif">
Taking a look at the element with the value of <code>8</code>, we can see it &quot;bubbling up&quot; from the beginning of the array to its proper place. This is where the name of &quot;Bubble Sort&quot; comes from.
<h2 id="bubblesortimplementation">Bubble Sort Implementation</h2>
Now that we've went over the idea behind Bubble Sort, we can start with the implementation:
<pre><code class="hljs">function bubbleSort(inputArr) {
 let n = inputArr.length;
 
 for(let i = 0; i &lt; n; i++) {
 for(let j = 0; j &lt; n; j++) {
 // Comparing and swapping the elements
 if(inputArr[j] &gt; inputArr[j+1]){
 let t = inputArr[j];
 inputArr[j] = inputArr[j+1];
 inputArr[j+1] = t;
 }
 }
 }
 return inputArr;
}
</code></pre>
The implementation is pretty intuitive. We iterate through the array <code>n</code> times with a <code>for</code> loop, where <code>n</code> is the length of the array. For each iteration, we &quot;bubble up&quot; an element to its correct place. This is done through another <code>for</code> loop that compares the element to its adjacent one, switching them if need be.
Finally, we return the sorted array. Let's populate an array and sort it:
<pre><code class="hljs">let inputArr = [5,1,4,2,8];
bubbleSort(inputArr);
console.log(inputArr);
</code></pre>
Running this code will yield:
<pre><code class="hljs">(5) [1, 2, 4, 5, 8]
</code></pre>
Let's take a look at how this is done with concrete values:
First iteration:
[5, 1, 4, 2, 8] -&gt; [1, 5, 4, 2, 8] - We are swapping 5 and 1, since 5 &gt; 1 
[1, 5, 4, 2, 8] -&gt; [1, 4, 5, 2, 8] - We are swapping 5 and 4, since 5 &gt; 4 
[1, 4, 5, 2, 8] -&gt; [1, 4, 2, 5, 8] - We are swapping 5 and 2, since 5 &gt; 2 
[1, 4, 2, 5, 8] -&gt; [1, 4, 2, 5, 8] - No change, since 5 &lt; 8
Second iteration:
[1, 4, 2, 5, 8] -&gt; [1, 4, 2, 5, 8] - No change, since 1 &lt; 4 
[1, 4, 2, 5, 8] -&gt; [1, 2, 4, 5, 8] - We are swapping 4 and 2, since 4 &gt; 2 
[1, 2, 4, 5, 8] -&gt; [1, 2, 4, 5, 8] - No change, since 4 &lt; 5 
[1, 2, 4, 5, 8] -&gt; [1, 2, 4, 5, 8] - No change, since 5 &lt; 8
The array is sorted within two iterations, however, our algorithm will continue running <code>n</code> times, comparing all the elements over and over again. This is because we've told it to iterate <code>inputArr.length</code> times.
Bubble Sort is inefficient in and of itself - especially with a flaw like this. There are two things we can do to optimize it, though.
<h2 id="optimizations">Optimizations</h2>
The first optimization we can implement is - terminate the algorithm if the array is sorted - i.e. no swaps are made. This can be done via a <code>boolean</code> flag. Each time we swap any elements, it's set to <code>true</code>:
<pre><code class="hljs">function bubbleSort(inputArr) {
 let n = inputArr.length;
 let sorted = false;
 
 while (!sorted) {
 sorted = true;
 for(let i = 0; i &lt; n; i++){
 if(inputArr[i] &gt; inputArr[i+1]){
 let t = inputArr[i];
 inputArr[i] = inputArr[i+1];
 inputArr[i+1] = t;
 sorted = false;
 }
 }
 }
 return inputArr;
}
</code></pre>
As soon as we finish iterating through the array, and no swaps were made, the <code>while</code> loop will stop looping and the array is returned.
Let's populate the array again and sort it:
<pre><code class="hljs">let inputArr = [5,1,4,2,8];
bubbleSort(inputArr);
console.log(inputArr);
</code></pre>
This code results in:
<pre><code class="hljs">[1, 2, 4, 5, 8]
</code></pre>
A thing that's worth noting is that with the first iteration finished, the largest element will be located at the end of the array. The next iteration will place the second largest element before the largest one, and so on.
This means that with each iteration, we don't really need to look at the last element, since we know it's in the right place. Thus, in the k-th iteration, we only really need to take a look at n-k+1 iterations:
<pre><code class="hljs">function bubbleSort(inputArr) {
 
 let n = inputArr.length;
 let sorted = false;
 let numOfIterations = 0;
 
 while(!sorted) {
 sorted = true;
 for(let i = 0; i &lt; n-numOfIterations+1; i++){
 if(inputArr[i] &gt; inputArr[i+1]){
 let t = inputArr[i];
 inputArr[i] = inputArr[i+1];
 inputArr[i+1] = t;
 sorted = false;
 numOfIterations++;
 }
 }
 } 
 return inputArr;
}
</code></pre>
Let's populate the array again and sort it:
<pre><code class="hljs">let inputArr = [5,1,4,2,8];
bubbleSort(inputArr);
console.log(inputArr);
</code></pre>
This code results in:
<pre><code class="hljs">(5) [1, 2, 4, 5, 8]
</code></pre>
<h2 id="cocktailshakersortvsbubblesort">Cocktail Shaker Sort vs Bubble Sort</h2>
Another optimization of Bubble Sort is its derived variant called Cocktail Shaker Sort, also known as Bidirectional Bubble Sort or simply Cocktail Sort.
This algorithm extends Bubble Sort by operating in two directions. Instead of going from the start to finish, and repeating that, it goes from start to finish, and then from finish to start again, in a single full iteration. Effectively, it accomplishes double the work of Bubble Sort in a single full iteration, though in practice it doesn't typically perform two times faster.
This is because it has a similar comparison-count. It compares more elements per iteration than regular Bubble Sort and it does double the swaps per iteration. The reason it's faster is because the range of possible swaps per iteration gets smaller and smaller, giving it a slightly better performance.
Let's go ahead and implement the algorithm:
<pre><code class="hljs">function cocktailShakerSort(inputArr) {

 let n = inputArr.length;
 let sorted = false;

 while (!sorted) {
 sorted = true;
 for (let i = 0; i &lt; n - 1; i++) {
 if (inputArr[i] &gt; inputArr[i + 1]){
 let tmp = inputArr[i];
 inputArr[i] = inputArr[i + 1];
 inputArr[i+1] = tmp;
 sorted = false;
 }
 }

 if (sorted)
 break;
 sorted = true;

 for (let j = n - 1; j &gt; 0; j--) {
 if (inputArr[j-1] &gt; inputArr[j]) {
 let tmp = inputArr[j];
 inputArr[j] = inputArr[j + 1];
 inputArr[j+1] = tmp;
 sorted = false;
 }
 }
 }
 return inputArr;
}
</code></pre>
The first part is the same as regular Bubble Sort. Though, after we pass forwards, we go backwards. First, we check if the array is sorted with the previous forward-pass. If not, we go backwards, swapping if necessary. If no swaps are made, the algorithm is terminated and the result is returned.
If we didn't check for swaps in the second pass, we'd have to pass an additional time forwards to verify if the array is sorted.
Let's take a look at the manual example from before - this time, with Cocktail Shaker:
[5, 1, 4, 2, 8] -&gt; [1, 5, 4, 2, 8] - We are swapping 5 and 1, since 5 &gt; 1 
[1, 5, 4, 2, 8] -&gt; [1, 4, 5, 2, 8] - We are swapping 5 and 4, since 5 &gt; 4 
[1, 4, 5, 2, 8] -&gt; [1, 4, 2, 5, 8] - We are swapping 5 and 2, since 5 &gt; 2 
[1, 4, 2, 5, 8] -&gt; [1, 4, 2, 5, 8] - No change, since 5 &lt; 8 
[1, 4, 2, 5, 8] -&gt; [1, 4, 2, 5, 8] - No change, since 5 &gt; 2 
[1, 4, 2, 5, 8] -&gt; [1, 2, 4, 5, 8] - We are swapping 4 and 2, since 2 &lt; 4 
[1, 2, 4, 5, 8] -&gt; [1, 2, 4, 5, 8] - No change, since 2 &gt; 1
Here, our array is sorted within 1 iteration, unlike Bubble Sort's 2 iterations. Cocktail Sort did this with 7 comparisons, whereas Bubble Sort did this with 8. This isn't a lot at this scale, though with larger numbers, we'll see performance boosts.
<blockquote>
Typically, this results in a 33% faster performance.
</blockquote>
Donald E. Knuth mentioned Cocktail Shaker Sort, along with a few similar Bubble Sort variants, in his famous monograph &quot;The Art of Computer Programming&quot;:
<blockquote>
But none of these refinements leads to an algorithm better than straight insertion [that is, insertion sort]; and we already know that straight insertion isn't suitable for large N. [...]
In short, the bubble sort seems to have nothing to recommend it, except a catchy name and the fact that it leads to some interesting theoretical problems.
</blockquote>
<h2 id="timecomplexityandcomparison">Time Complexity and Comparison</h2>
Since our array contains <code>n</code> elements, Bubble Sort performs O(n) comparisons, <code>n</code> times. This leads us to a total running time of O(n2) - average and worst-case. This is a horrible time complexity for a sorting algorithm.
For reference, most common sorting algorithms, such as Quicksort or Merge Sort, have an average running time of O(nlogn).
Theoretically, Bubble Sort could have a O(n) complexity, if we run it on a sorted collection, which outperforms all other algorithms except Insertion Sort and Cube Sort. Though, the rarity of this case doesn't justify using it in practice.
Using the built-in <code>console.time()</code> function, we can compare the time it takes to run the code on arrays of different lengths:
<pre><code class="hljs">console.time(&#x27;bubble&#x27;);
bubbleSort(inputArr);
console.timeEnd(&#x27;bubble&#x27;);
</code></pre>
We'll be doing this for arrays of size 100, 1 000 and 10 000:
<table class="table table-striped">
 <tr>
 <th>Number of elements</td>
 <th>Unoptimized Bubble Sort</td>
 <th>Bubble Sort with a 'boolean' flag</td>
 <th>Bubble Sort with n-k+1 iterations</td>
 <th>Cocktail Shaker Sort</td>
 </tr>
 <tr>
 <td>100</td>
 <td>2ms</td>
 <td>1ms</td>
 <td>1ms</td>
 <td>1ms</td>
 </tr>
 <tr>
 <td>1000</td>
 <td>8ms</td>
 <td>6ms</td>
 <td>1ms</td>
 <td>1ms</td>
 </tr>
 <tr>
 <td>10 000</td>
 <td>402ms</td>
 <td>383ms</td>
 <td>2ms</td>
 <td>1ms</td>
 </tr>
</table>
What's evident here is just how inefficient the first implementation is compared to variants like Cocktail Shaker.
<h2 id="conclusion">Conclusion</h2>
Although Bubble Sort is very intuitive and easy to understand and implement, it is highly impractical for solving most problems.
It has an average and worst-case running time of O(n2), and can only run on its best-case running time of O(n) when the array is already sorted.
Its space complexity is O(1), which is great. Unfortunately, that's not nearly enough to make up for the awful time complexity.
Even among simple O(n2) sorting algorithms, Insertion Sort or Selection Sort are usually considerably more efficient.
Due to its simplicity, Bubble Sort is often used as an introduction to sorting algorithms at introductory computer science courses.

In this tutorial, we'll be implementing and optimizing Bubble Sort and Cocktail Shaker Sort in JavaScript with examples.
We'll also perform Big O analysis.

Bubble Sort and Cocktail Shaker Sort in JavaScript

Taimoor Choudhary

In this article, we'll go through many examples of using MapStruct for Advanced Java Mapping, exception handling and MapStruct annotations.

Guide to MapStruct in Java - Advanced Mapping Library

<h2 id="introduction">Introduction</h2>
Jest is a popular, open-source test framework for JavaScript. We can use Jest to create mocks in our test - objects that replace real objects in our code while it's being tested.
In our previous series on <a target="_blank" href="/using-stubs-for-testing-in-javascript-with-sinon-js">unit testing techniques using Sinon.js</a>, we covered how we can use Sinon.js to stub, spy, and mock Node.js applications - particularly HTTP calls.
In this series, we are going to cover unit testing techniques in Node.js using <a rel="nofollow noopener" target="_blank" href="https://jestjs.io/docs/getting-started">Jest</a>. Jest was created by Facebook and integrates well with many JavaScript libraries and frameworks like React, Angular and Vue to name a few. It has a particular focus on simplicity and performance.
In this article, we will review what mocks are, then focus on how we can set up Jest for a Node.js application to mock an HTTP call in our test. We will then compare how we use Jest and Sinon to create mocks for our programs.
<h2 id="whataremocks">What are Mocks?</h2>
In unit testing, mocks provide us with the capability to stub the functionality provided by a dependency and a means to observe how our code interacts with the dependency. Mocks are especially useful when it's expensive or impractical to include a dependency directly into our tests, for example, in cases where your code is making HTTP calls to an API or interacting with the database layer.
It is preferable to stub out the responses for these dependencies, while making sure that they are called as required. This is where mocks come in handy.
Let us now see how we can use Jest to create mocks in Node.js.
<h2 id="settingupjestinanodejsapplication">Setting up Jest in a Node.js Application</h2>
In this tutorial, we will set up a Node.js app that will make HTTP calls to a JSON API containing photos in an album. Jest will be used to mock the API calls in our tests.
First, let's create the directory under which our files will reside and move into it:
<pre><code class="hljs">$ mkdir PhotoAlbumJest &amp;&amp; cd PhotoAlbumJest
</code></pre>
Then, let's initialize the Node project with the default settings:
<pre><code class="hljs">$ npm init -y
</code></pre>
Once the project is initialized, we will then proceed to create an <code>index.js</code> file at the root of the directory:
<pre><code class="hljs">$ touch index.js
</code></pre>
To help us out with the HTTP requests, we'll be using <a rel="nofollow noopener" target="_blank" href="https://github.com/axios/axios">Axios</a>.
<h3 id="settingupaxios">Setting up Axios</h3>
We will be using <code>axios</code> as our HTTP client. Axios is a lightweight, promise-based HTTP client for Node.js which can also be used by web browsers. This makes it a good fit for our use case.
Let's first install it:
<pre><code class="hljs">$ npm i axios --save
</code></pre>
Before using <code>axios</code>, we'll create a file called <code>axiosConfig.js</code> through which we'll configure the Axios client. Configuring the client allows us to use common settings across a set of HTTP requests.
For example, we can set authorization headers for a set of HTTP requests, or most commonly, a base URL which will be used for all HTTP requests.
Let's create the configuration file:
<pre><code class="hljs">touch axiosConfig.js
</code></pre>
Now, let's access <code>axios</code> and configure the base URL:
<pre><code class="hljs">const axios = require(&#x27;axios&#x27;);

const axiosInstance = axios.default.create({
 baseURL: &#x27;https://jsonplaceholder.typicode.com/albums&#x27;
});

module.exports = axiosInstance;
</code></pre>
After setting the <code>baseURL</code>, we've exported the <code>axios</code> instance so that we can use it across our application. We'll be using <code>www.jsonplaceholder.typicode.com</code> which is a fake online REST API for testing and prototyping.
In the <code>index.js</code> file we created earlier, let's define a function that returns a list of photo URLs given an album's ID:
<pre><code class="hljs">const axios = require(&#x27;./axiosConfig&#x27;);

const getPhotosByAlbumId = async (id) =&gt; {
 const result = await axios.request({
 method: &#x27;get&#x27;,
 url: `/${id}/photos?_limit=3`
 });
 const { data } = result;
 return data;
};

module.exports = getPhotosByAlbumId;
</code></pre>
To hit our API we simply use the <code>axios.request()</code> method of our <code>axios</code> instance. We pass in the name of the method, which in our case is a <code>get</code> and the <code>url</code> which we will invoke.
The string we pass to the <code>url</code> field will be concatenated to the <code>baseURL</code> from <code>axiosConfig.js</code>.
Now, let's set up a Jest test for this function.
<h3 id="settingupjest">Setting up Jest</h3>
To set up Jest, we must first install Jest as a development dependency using <code>npm</code>:
<pre><code class="hljs">$ npm i jest -D
</code></pre>
The <code>-D</code> flag is a shortcut for <code>--save-dev</code>, which tells NPM to save it as a development dependency.
We will then proceed to create a configuration file for Jest called <code>jest.config.js</code>:
<pre><code class="hljs">touch jest.config.js
</code></pre>
Now, in the <code>jest.config.js</code> file, we'll set the directories in which our tests will reside:
<pre><code class="hljs">module.exports = {
 testMatch: [
 &#x27;&lt;rootDir&gt;/**/__tests__/**/?(*.)(spec|test).js&#x27;,
 &#x27;&lt;rootDir&gt;/**/?(*.)(spec|test).js&#x27;
 ],
 testEnvironment: &#x27;node&#x27;,
};
</code></pre>
The <code>testMatch</code> value is an array of global patterns that Jest will use to detect the test files. In our case, we are specifying that any file inside the <code>__tests__</code> directory or anywhere in our project that has either a <code>.spec.js</code> or .<code>test.js</code> extension should be treated as a test file.
Note: In JavaScript, it's common to see test files end with <code>.spec.js</code>. Developers use &quot;spec&quot; as shorthand for &quot;specification&quot;. The implication is that the tests contain the functional requirements or specification for the functions being implemented.
The <code>testEnvironment</code> value represents the environment in which Jest is running, that is, whether in Node.js or in the browser. You can read more about other allowable configuration options <a rel="nofollow noopener" target="_blank" href="https://jestjs.io/docs/en/configuration.html#options">here</a>.
Now let's modify our <code>package.json</code> test script so that it uses Jest as our test runner:
<pre><code class="hljs">&quot;scripts&quot;: {
 &quot;test&quot;: &quot;jest&quot;
},
</code></pre>
Our setup is done. To test that our configuration works, create a test file at the root of the directory called <code>index.spec.js</code>:
<pre><code class="hljs">touch index.spec.js
</code></pre>
Now, within the file, let's write a test:
<pre><code class="hljs">describe(&#x27;sum of 2 numbers&#x27;, () =&gt; {
 it(&#x27; 2 + 2 equal 4&#x27;, () =&gt; {
 expect(2 + 2).toEqual(4)
 });
});
</code></pre>
Run this code with the following command:
<pre><code class="hljs">$ npm test
</code></pre>
You should get this result:
<pre><code class="hljs"> PASS ./index.spec.js
 sum of 2 numbers
 ✓ 2 + 2 equal 4 (3ms)

Test Suites: 1 passed, 1 total
Tests: 1 passed, 1 total
Snapshots: 0 total
Time: 0.897s, estimated 1s
Ran all test suites.
</code></pre>
With Jest set up correctly, we can now proceed to write the code to mock our HTTP call.
<h3 id="mockinganhttpcallwithjest">Mocking an HTTP Call With Jest</h3>
In the <code>index.spec.js</code> file, we'll start fresh, deleting the old code and writing a new script that'll mock an HTTP call:
<pre><code class="hljs">const axios = require(&#x27;./axiosConfig&#x27;);
const getPhotosByAlbumId = require(&#x27;./index&#x27;);

jest.mock(&#x27;./axiosConfig&#x27;, () =&gt; {
 return {
 baseURL: &#x27;https://jsonplaceholder.typicode.com/albums&#x27;,
 request: jest.fn().mockResolvedValue({
 data: [
 {
 albumId: 3,
 id: 101,
 title: &#x27;incidunt alias vel enim&#x27;,
 url: &#x27;https://via.placeholder.com/600/e743b&#x27;,
 thumbnailUrl: &#x27;https://via.placeholder.com/150/e743b&#x27;
 },
 {
 albumId: 3,
 id: 102,
 title: &#x27;eaque iste corporis tempora vero distinctio consequuntur nisi nesciunt&#x27;,
 url: &#x27;https://via.placeholder.com/600/a393af&#x27;,
 thumbnailUrl: &#x27;https://via.placeholder.com/150/a393af&#x27;
 },
 {
 albumId: 3,
 id: 103,
 title: &#x27;et eius nisi in ut reprehenderit labore eum&#x27;,
 url: &#x27;https://via.placeholder.com/600/35cedf&#x27;,
 thumbnailUrl: &#x27;https://via.placeholder.com/150/35cedf&#x27;
 }
 ]
 }),
 }
});

</code></pre>
Here, we first import our dependencies using the <code>require</code> syntax. Since we do not want to make any actual network calls, we create a manual mock of our <code>axiosConfig</code> using the <code>jest.mock()</code> method. The <code>jest.mock()</code> method takes the module path as an argument and an optional implementation of the module as a factory parameter.
For the factory parameter, we specify that our mock, <code>axiosConfig</code>, should return an object consisting of <code>baseURL</code> and <code>request()</code>. The <code>baseUrl</code> is set to the base URL of the API. The <code>request()</code> is a mock function that returns an array of photos.
The <code>request()</code> function we've defined here replaces the real <code>axios.request()</code> function. When we call the <code>request()</code> method, our mock method will be called instead.
What's important to note is the <code>jest.fn()</code> function. It returns a new mock function, and its implementation is defined within the parentheses. What we've done via the <code>mockResolvedValue()</code> function is provide a new implementation for the <code>request()</code> function.
Typically, this is done via the <code>mockImplementation()</code> function, though since we're really only just returning the <code>data</code> which holds our results - we can use the sugar function instead.
<code>mockResolvedValue()</code> is the same as <code>mockImplementation(() =&gt; Promise.resolve(value))</code>.
With a mock in place, let's go ahead and write a test:
<pre><code class="hljs">describe(&#x27;test getPhotosByAlbumId&#x27;, () =&gt; {
 afterEach(() =&gt; jest.resetAllMocks());

 it(&#x27;fetches photos by album id&#x27;, async () =&gt; {
 const photos = await getPhotosByAlbumId(3);
 expect(axios.request).toHaveBeenCalled();
 expect(axios.request).toHaveBeenCalledWith({ method: &#x27;get&#x27;, url: &#x27;/3/photos?_limit=3&#x27; });
 expect(photos.length).toEqual(3);
 expect(photos[0].albumId).toEqual(3)
 });
});
</code></pre>
After each test case, we ensure that the <code>jest.resetAllMocks()</code> function is called to reset the state of all mocks.
In our test case, we call the <code>getPhotosByAlbumId()</code> function with an ID of <code>3</code> as the argument. We then make our assertions.
The first assertion expects that the <code>axios.request()</code> method was called, while the second assertion checks that the method was called with the correct parameters. We also check that the length of the returned array is <code>3</code> and that the first object of the array has an <code>albumId</code> of <code>3</code>.
Let's run our new tests with:
<pre><code class="hljs">npm test
</code></pre>
We should get the following result:
<pre><code class="hljs">PASS ./index.spec.js
 test getPhotosByAlbumId
 ✓ fetches photos by album id (7ms)

Test Suites: 1 passed, 1 total
Tests: 1 passed, 1 total
Snapshots: 0 total
Time: 0.853s, estimated 1s
Ran all test suites.
</code></pre>
With this new familiarity and experience, let's do a quick comparison of the testing experiences with Jest and Sinon, which is commonly used for mocking as well.
<h2 id="sinonmocksvsjestmocks">Sinon Mocks vs Jest Mocks</h2>
Sinon.js and Jest have different ways they approach the concept of mocking. The following are some of the key differences to note:
<ul>
<li>In Jest, Node.js modules are automatically mocked in your tests when you place the mock files in a <code>__mocks__</code> folder that's next to the <code>node_modules</code> folder. For example, if you a file called <code>__mock__/fs.js</code>, then every time the <code>fs</code> module is called in your test, Jest will automatically use the mocks. On the other hand, with Sinon.js you must mock each dependency manually using the <code>sinon.mock()</code> method on each test that needs it.</li>
<li>In Jest, we use the <code>jest.fn().mockImplementation()</code> method to replace a mocked function's implementation with a stubbed response. A good example of this can be found in the Jest documentation <a rel="nofollow noopener" target="_blank" href="https://jestjs.io/docs/en/es6-class-mocks#calling-jestmockdocsenjest-objectjestmockmodulename-factory-options-with-the-module-factory-parameter">here</a>. In Sinon.js, we use the <code>mock.expects()</code> method to handle that.</li>
<li>Jest provides a large number of methods for working with their mock API and particularly with modules. You can view all of them <a rel="nofollow noopener" target="_blank" href="https://jestjs.io/docs/en/jest-object#mock-modules">here</a>. Sinon.js, on the other hand, has fewer methods to work with mocks and exposes a generally simpler API.</li>
<li>Sinon.js mocks ship as part of the Sinon.js library which can be plugged in and used in combination with other testing frameworks like Mocha and assertion libraries like Chai. Jest Mocks, on the other hand, ship as part of the Jest framework, which also ships with its own assertions API.</li>
</ul>
Sinon.js mocks are often most beneficial when you're testing a small application that may not require the entire power of a framework like Jest. It's also useful when you already have a test setup and need to add mocking to a few components in your application.
However, when working with large applications that have many dependencies, leveraging on the power of Jest's mock API alongside its framework can be greatly beneficial to ensure a consistent testing experience.
<h2 id="conclusion">Conclusion</h2>
In this article, we have looked at how we can use Jest to mock an HTTP call made with <code>axios</code>. We first set up the application to use <code>axios</code> as our HTTP request library and then set up Jest to help us with unit testing. Finally, we've reviewed some differences between Sinon.js and Jest mocks and when we could best employ either.
To read more about Jest mocks and how you can leverage them for more advanced use cases, check out their documentation <a rel="nofollow noopener" target="_blank" href="https://jestjs.io/docs/en/manual-mocks">here</a>.
As always, the code from this tutorial can be found on <a rel="nofollow noopener" target="_blank" href="https://github.com/Allan690/Jest-Mocks-Tutorial-SA">GitHub</a>.

Allan Mogusu

Jest is a popular, open-source test framework for JavaScript. In this tutorial, we will use Jest to mock HTTP calls in our tests through an example script.

Using Mocks for Testing in JavaScript with Jest

Using Mocks for Testing in JavaScript With Jest

<h2 id="introduction">Introduction</h2>
The <code>map()</code>, <code>filter()</code> and <code>reduce()</code> functions bring a bit of functional programming to Python. All three of these are convenience functions that can be replaced with <a target="_blank" href="/list-comprehensions-in-python/">List Comprehensions</a> or loops, but provide a more elegant and short-hand approach to some problems.
Before continuing, we'll go over a few things you should be familiar with before reading about the aforementioned methods:
<blockquote>
What is an anonymous function/method or lambda?
</blockquote>
An anonymous method is a method without a name, i.e. not bound to an identifier like when we define a method using <code>def method:</code>.
Note: Though most people use the terms &quot;anonymous function&quot; and &quot;lambda function&quot; interchangeably - they're not the same. This mistake happens because in most programming languages lambdas are anonymous and all anonymous functions are lambdas. This is also the case in Python. Thus, we won't go into this distinction further in this article.
<blockquote>
What is the syntax of a lambda function (or lambda operator)?
</blockquote>
<pre><code class="hljs">lambda arguments: expression
</code></pre>
Think of lambdas as one-line methods without a name. They work practically the same as any other method in Python, for example:
<pre><code class="hljs">def add(x,y):
 return x + y
</code></pre>
Can be translated to:
<pre><code class="hljs">lambda x, y: x + y
</code></pre>
Lambdas differ from normal Python methods because they can have only one expression, can't contain any statements and their return type is a <code>function</code> object. So the line of code above doesn't exactly return the value <code>x + y</code> but the function that calculates <code>x + y</code>.
<blockquote>
Why are lambdas relevant to <code>map()</code>, <code>filter()</code> and <code>reduce()</code>?
</blockquote>
All three of these methods expect a <code>function</code> object as the first argument. This <code>function</code> object can be a pre-defined method with a name (like <code>def add(x,y)</code>).
Though, more often than not, functions passed to <code>map()</code>, <code>filter()</code>, and <code>reduce()</code> are the ones you'd use only once, so there's often no point in defining a referenceable function.
To avoid defining a new function for your different <code>map()</code>/<code>filter()</code>/<code>reduce()</code> needs - a more elegant solution would be to use a short, disposable, anonymous function that you will only use once and never again - a lambda.
<h2 id="themapfunction">The map() Function</h2>
The <code>map()</code> function iterates through all items in the given iterable and executes the <code>function</code> we passed as an argument on each of them.
The syntax is:
<pre><code class="hljs">map(function, iterable(s))
</code></pre>
We can pass as many iterable objects as we want after passing the <code>function</code> we want to use:
<pre><code class="hljs"># Without using lambdas
def starts_with_A(s):
 return s[0] == &quot;A&quot;

fruit = [&quot;Apple&quot;, &quot;Banana&quot;, &quot;Pear&quot;, &quot;Apricot&quot;, &quot;Orange&quot;]
map_object = map(starts_with_A, fruit)

print(list(map_object))
</code></pre>
This code will result in:
<pre><code class="hljs">[True, False, False, True, False]
</code></pre>
As we can see, we ended up with a new list where the function <code>starts_with_A()</code> was evaluated for each of the elements in the list <code>fruit</code>. The results of this function were added to the list sequentially.
A prettier way to do this exact same thing is by using lambdas:
<pre><code class="hljs">fruit = [&quot;Apple&quot;, &quot;Banana&quot;, &quot;Pear&quot;, &quot;Apricot&quot;, &quot;Orange&quot;]
map_object = map(lambda s: s[0] == &quot;A&quot;, fruit)

print(list(map_object))
</code></pre>
We get the same output:
<pre><code class="hljs">[True, False, False, True, False]
</code></pre>
Note: You may have noticed that we've cast <code>map_object</code> to a list to print each element's value. We did this because calling <code>print()</code> on a list will print the actual values of the elements. Calling <code>print()</code> on <code>map_object</code> would print the memory addresses of the values instead.
The <code>map()</code> function returns the <code>map_object</code> type, which is an iterable and we could have printed the results like this as well:
<pre><code class="hljs">for value in map_object:
 print(value)
</code></pre>
If you'd like the <code>map()</code> function to return a list instead, you can just cast it when calling the function:
<pre><code class="hljs">result_list = list(map(lambda s: s[0] == &quot;A&quot;, fruit))
</code></pre>
<h2 id="thefilterfunction">The filter() Function</h2>
Similar to <code>map()</code>, <code>filter()</code> takes a <code>function</code> object and an iterable and creates a new list.
As the name suggests, <code>filter()</code> forms a new list that contains only elements that satisfy a certain condition, i.e. the <code>function</code> we passed returns <code>True</code>.
The syntax is:
<pre><code class="hljs">filter(function, iterable(s))
</code></pre>
Using the previous example, we can see that the new list will only contain elements for which the <code>starts_with_A()</code> function returns <code>True</code>:
<pre><code class="hljs"># Without using lambdas
def starts_with_A(s):
 return s[0] == &quot;A&quot;

fruit = [&quot;Apple&quot;, &quot;Banana&quot;, &quot;Pear&quot;, &quot;Apricot&quot;, &quot;Orange&quot;]
filter_object = filter(starts_with_A, fruit)

print(list(filter_object))
</code></pre>
Running this code will result in a shorter list:
<pre><code class="hljs">[&#x27;Apple&#x27;, &#x27;Apricot&#x27;]
</code></pre>
Or, rewritten using a lambda:
<pre><code class="hljs">fruit = [&quot;Apple&quot;, &quot;Banana&quot;, &quot;Pear&quot;, &quot;Apricot&quot;, &quot;Orange&quot;]
filter_object = filter(lambda s: s[0] == &quot;A&quot;, fruit)

print(list(filter_object))
</code></pre>
Printing gives us the same output:
<pre><code class="hljs">[&#x27;Apple&#x27;, &#x27;Apricot&#x27;]
</code></pre>
<h2 id="thereducefunction">The reduce() Function</h2>
<code>reduce()</code> works differently than <code>map()</code> and <code>filter()</code>. It does not return a new list based on the <code>function</code> and iterable we've passed. Instead, it returns a single value.
Also, in Python 3 <code>reduce()</code> isn't a built-in function anymore, and it can be found in the <code>functools</code> module.
The syntax is:
<pre><code class="hljs">reduce(function, sequence[, initial])
</code></pre>
<code>reduce()</code> works by calling the <code>function</code> we passed for the first two items in the sequence. The result returned by the <code>function</code> is used in another call to <code>function</code> alongside with the next (third in this case), element.
This process repeats until we've gone through all the elements in the sequence.
The optional argument <code>initial</code> is used, when present, at the beginning of this &quot;loop&quot; with the first element in the first call to <code>function</code>. In a way, the <code>initial</code> element is the 0th element, before the first one, when provided.
<code>reduce()</code> is a bit harder to understand than <code>map()</code> and <code>filter()</code>, so let's look at a step by step example:
<ol>
<li>
We start with a list <code>[2, 4, 7, 3]</code> and pass the <code>add(x, y)</code> function to <code>reduce()</code> alongside this list, without an <code>initial</code> value
</li>
<li>
<code>reduce()</code> calls <code>add(2, 4)</code>, and <code>add()</code> returns <code>6</code>
</li>
<li>
<code>reduce()</code> calls <code>add(6, 7)</code> (result of the previous call to <code>add()</code> and the next element in the list as parameters), and <code>add()</code> returns <code>13</code>
</li>
<li>
<code>reduce()</code> calls <code>add(13, 3)</code>, and <code>add()</code> returns <code>16</code>
</li>
<li>
Since no more elements are left in the sequence, <code>reduce()</code> returns <code>16</code>
</li>
</ol>
The only difference, if we had given an <code>initial</code> value would have been an additional step - 1.5. where <code>reduce()</code> would call <code>add(initial, 2)</code> and use that return value in step 2.
Let's go ahead and use the <code>reduce()</code> function:
<pre><code class="hljs">from functools import reduce

def add(x, y):
 return x + y

list = [2, 4, 7, 3]
print(reduce(add, list))
</code></pre>
Running this code would yield:
<pre><code class="hljs">16
</code></pre>
Again, this could be written using lambdas:
<pre><code class="hljs">from functools import reduce

list = [2, 4, 7, 3]
print(reduce(lambda x, y: x + y, list))
print(&quot;With an initial value: &quot; + str(reduce(lambda x, y: x + y, list, 10)))
</code></pre>
And the code would result in:
<pre><code class="hljs">16
With an initial value: 26
</code></pre>
<h2 id="conclusion">Conclusion</h2>
As mentioned previously, these functions are convenience functions. They are there so you can avoid writing more cumbersome code, but avoid using both them and lambda expressions too much.
Don't force these tools because &quot;you can&quot;, as it can often lead to illegible code that's hard to maintain. Use them only when it's absolutely clear what's going on as soon as you look at the function or lambda expression.
If you catch yourself struggling to fit the necessary logic into one <code>map()</code> function, or one lambda expression, it's much better to just write a slightly longer for-loop/defined method and avoid unnecessary confusion later.

Olivera Popović

In this tutorial, we'll be going over examples of the map(), filter() and reduce() functions in Python - both using Lambdas and regular functions.

map(), filter(), and reduce() in Python with Examples

In this tutorial, we'll dive into Node's EventEmitter class to make an event-emitting application. We'll also extend it into a custom class and cover important functions.