<h2 id="introduction">Introduction</h2>
When writing any kind of code in Java, developers tend to work with objects more often than with primitive values (<code>int</code>, <code>boolean</code>, etc). This is because objects are at the very essence of object-oriented programming: they allow a programmer to write abstract code in a clean and structured manner.
Furthermore, every object in Java can either contain a value or not. If it does, its value is stored on the heap and the variable which we are using has a reference to that object. If the object contains no value, this defaults to <code>null</code> - a special placeholder denoting the absence of a value.
The fact that each object can become <code>null</code>, combined with the natural tendency to use objects instead of primitives, means that some arbitrary piece of code might (and often-times will) result in an unexpected <code>NullPointerException</code>.
Before the <code>Optional</code> class was introduced in Java 8, these kind of <code>NullPointerException</code> errors were much more common in everyday life of a Java programmer.
In the following sections, we will dive deeper into explaining <code>Optional</code> and seeing how it can be used to overcome some of the common problems concerning null values.
<h2 id="theoptionalclass">The Optional Class</h2>
An <a rel="nofollow noopener" target="_blank" href="https://docs.oracle.com/javase/8/docs/api/java/util/Optional.html">Optional</a> is essentially a container. It is designed either to store a value or to be &quot;empty&quot; if the value is non-existent - a replacement for the <code>null</code> value. As we will see in some later examples, this replacement is crucial as it allows implicit null-checking for every object represented as an <code>Optional</code>.
This means that explicit null-checking is no longer needed from a programmer's point of view - it becomes enforced by the language itself.
<h2 id="creatingoptionals">Creating Optionals</h2>
Let's take a look at how easy it is to create instances of <code>Optional</code> and wrap objects that we already have in our applications.
We'll be using our custom class for this, the <code>Spaceship</code> class:
<pre><code class="hljs">public class Spaceship {
 private Engine engine;
 private String pilot;

 // Constructor, Getters and Setters
}
</code></pre>
And our <code>Engine</code> looks like:
<pre><code class="hljs">public class Engine {
 private VelocityMonitor monitor;

 // Constructor, Getters and Setters
}
</code></pre>
And furthermore, we've got the <code>VelocityMonitor</code> class:
<pre><code class="hljs">public class VelocityMonitor {
 private int speed;

 // Constructor, Getters and Setters
}
</code></pre>
These classes are arbitrary and only serve to make a point, there's no real implementation behind them.
<h3 id="of">of()</h3>
The first approach to creating <code>Optional</code>s is using the <code>.of()</code> method, passing a reference to a non-null object:
<pre><code class="hljs">Spaceship falcon = new Spaceship();
Optional&lt;Spaceship&gt; optionalFalcon = Optional.of(falcon);
</code></pre>
If the <code>falcon</code> was <code>null</code>, the method <code>.of()</code> would throw a <code>NullPointerException</code>.
Without <code>Optional</code>, trying to access any of the fields or methods of <code>falcon</code> (assuming it's <code>null</code>), without performing a null-check would result in a crash of the program.
With <code>Optional</code>, the <code>.of()</code> method notices the <code>null</code> value and throws the <code>NullPointerException</code> immediately - potentially also crashing the program.
<blockquote>
If the program crashes in both approaches, why even bother using <code>Optional</code>?
</blockquote>
The program wouldn't crash somewhere deeper in the code (when accessing <code>falcon</code>) but at the very first use (initialization) of a <code>null</code> object, minimizing potential damage.
<h3 id="ofnullable">ofNullable()</h3>
If <code>falcon</code> is allowed to be a <code>null</code>, instead of the <code>.of()</code> method, we'd use the <code>.ofNullable()</code> method. They perform the same if the value is non-<code>null</code>. The difference is obvious when the reference points to <code>null</code> in which case - the <code>.ofNullable()</code> method is perfectly contempt with this piece of code:
<pre><code class="hljs">Spaceship falcon = null;
Optional&lt;Spaceship&gt; optionalFalcon = Optional.ofNullable(falcon);
</code></pre>
<h3 id="empty">empty()</h3>
And finally, instead of wrapping an existing reference variable (<code>null</code> or non-<code>null</code>), we can create a <code>null</code> value in the context of an <code>Optional</code>. It's kind of like an empty container which returns an empty instance of <code>Optional</code>:
<pre><code class="hljs">Optional&lt;Spaceship&gt; emptyFalcon = Optional.empty();
</code></pre>
<h2 id="checkingforvalues">Checking for Values</h2>
After creating <code>Optional</code>s and packing information in them, it's only natural that we'd want to access them.
Before accessing though, we should check if there are any values, or if the <code>Optional</code>s are empty.
<h3 id="ispresent">isPresent()</h3>
Since catching exceptions is a demanding operation, it would be better to use one of the API methods to check if the value exists before trying to access it - and alter the flow if it doesn't.
If it does, then <code>.get()</code> method can be used to access the value. Though, more on that method in latter sections.
To check if the value is present inside an <code>Optional</code>, we use the <code>.isPresent()</code> method. This is essentially a replacement for the <code>null</code>-check of the old days:
<pre><code class="hljs">// Without Optional
Spaceship falcon = hangar.getFalcon();
if (falcon != null) {
 System.out.println(falcon.get());
} else {
 System.out.printn(&quot;The Millennium Falcon is out and about!&quot;);
}

// With Optional
Optional&lt;Spaceship&gt; optionalFalcon = Optional.ofNullable(hangar.getFalcon());
if (optionalFalcon.isPresent()) {
 System.out.println(falcon.get());
} else {
 System.out.println(&quot;The Millennium Falcon is out and about!&quot;);
}
</code></pre>
Since the <code>falcon</code> can also not be in the hangar, we can also expect a <code>null</code> value, thus <code>.ofNullable()</code> is used.
<h3 id="ifpresent">ifPresent()</h3>
To make things even easier, <code>Optional</code> also contains a conditional method which bypasses the presence check entirely:
<pre><code class="hljs">Optional&lt;Spaceship&gt; optionalFalcon = Optional.ofNullable(hangar.getFalcon());
optionalFalcon.ifPresent(System.out::println);
</code></pre>
If a value is present, the contents are printed through a <a target="_blank" href="/method-references-in-java-8">Method Reference</a>. If there's no value in the container, nothing happens. You still might want to use the previous approach if you'd like to define an <code>else {}</code> statement, though.
This reflects what we mentioned earlier when we said that <code>null</code>-checks with <code>Optional</code> are implicit and enforced by the type-system.
<h3 id="isempty">isEmpty()</h3>
Another way to check for a value is to use <code>.isEmpty()</code>. Essentially, calling <code>Optional.isEmpty()</code> is the same as calling <code>!Optional.isPresent()</code>. There's no particular difference that exists:
<pre><code class="hljs">Optional&lt;Spaceship&gt; optionalFalcon = Optional.ofNullable(hangar.getFalcon());
if (optionalFalcon.isEmpty()) {
 System.out.println(&quot;Please check if the Millennium Falcon has returned in 5 minutes.&quot;);
} else {
 optionalFalcon.doSomething();
}
</code></pre>
<h3 id="nestednullchecks">Nested Null-Checks</h3>
Our <code>Spaceship</code> class, as defined earlier, has an attribute <code>Engine</code>, which has an attribute <code>VelocityMonitor</code>.
Suppose now that we want to access the velocity monitor object and obtain the current velocity of the spaceship, taking into consideration that all these values could potentially be <code>null</code>.
Obtaining the velocity might look something like this:
<pre><code class="hljs">if (falcon != null) {
 Engine engine = falcon.getEngine();
 if (engine != null) {
 VelocityMonitor monitor = engine.getVelocityMonitor();
 if (monitor != null) {
 Velocity velocity = monitor.getVelocity();
 System.out.println(velocity);
 }
 }
}
</code></pre>
The above example shows how tedious it is to perform such checks, not to mention the amount of boilerplate code needed to make the checks possible in the first place.
An alternative solution using <code>Optional</code> would be:
<pre><code class="hljs">Velocity velocity = falcon
 .flatMap(Spaceship::getEngine)
 .flatMap(Engine::getVelocityMonitor)
 .map(VelocityMonitor::getVelocity);
</code></pre>
Note: Not sure what's going on above? Check out the <a href="#exampleexplanation">explanation below</a> for the details.
Using this kind of approach, no explicit checks are needed. If any of the objects contain an empty <code>Optional</code>, the end result will also be an empty <code>Optional</code>.
To make things work like this, we need to modify our existing definitions of the <code>Spaceship</code> and <code>Engine</code> classes:
<pre><code class="hljs">public class Spaceship {
 private Optional&lt;Engine&gt; engine;
 private String pilot;

 // Constructor, Getters and Setters
}
</code></pre>
<pre><code class="hljs">public class Engine {
 private Optional&lt;VelocityMonitor&gt; monitor;

 // Constructor, Getters and Setters
}
</code></pre>
What we have changed are the attribute definitions: they are now wrapped inside <code>Optional</code> objects to make this kind of alternative solution possible.
This might seem a bit tedious at first but if planned from the beginning, it takes almost the same amount of effort typing it.
Furthermore, having an <code>Optional</code> attribute instead of a regular object reflects the fact that the attribute might or might not exist. Notice how this is quite helpful since we don't have semantic meanings of this kind with regular attribute definitions.
<h3 id="exampleexplanation">Example Explanation</h3>
In this section, we'll take a bit of time to explain the previous example with <code>flatMaps</code> and <code>maps</code>. If you understand it without further explanation, please feel free to skip this section.
The first method call is performed on <code>falcon</code> which is of type <code>Optional&lt;Spaceship&gt;</code>. Calling the <code>getEngine</code> method returns an object of type <code>Optional&lt;Engine&gt;</code>. Combining these two types, the type of the returned object becomes <code>Optional&lt;Optional&lt;Engine&gt;&gt;</code>.
Since we would like to view this object as an <code>Engine</code> container and perform further calls on it, we need some kind of mechanism to &quot;peel off&quot; the outer <code>Optional</code> layer.
Such a mechanism exists and it is called <code>flatMap</code>. This API method combines the <code>map</code> and the <code>flat</code> operations by first applying a function to each of the elements and then flattening the result into a one-level stream.
The <code>map</code> method, on the other hand, only applies a function without flattening the stream. In our case, the use of <code>map</code> and <code>flatMap</code> would give us <code>Optional&lt;Optional&lt;Engine&gt;&gt;</code> and <code>Optional&lt;Engine&gt;</code> respectively.
Calling <code>flatMap</code> on an object of type <code>Optional</code> would therefore yield with a one-level <code>Optional</code>, allowing us to use multiple similar method calls in a succession.
This finally leaves us with<code>Optional&lt;Engine&gt;</code>, which we wanted in the first place.
<h3 id="alternativeresults">Alternative results</h3>
<h3 id="orelse">.orElse()</h3>
The previous example can be further expanded by using the <code>orElse(T other)</code> method. The method will return the <code>Optional</code> object upon which it is called only if there is a value contained within it.
If the <code>Optional</code> is empty, the method returns the <code>other</code> value. This is essentially an <code>Optional</code> version of the ternary operator:
<pre><code class="hljs">// Ternary Operator
Spaceship falcon = maybeFalcon != null ? maybeFalcon : new Spaceship(&quot;Millennium Falcon&quot;);

// Optional and orElse()
Spaceship falcon = maybeFalcon.orElse(new Spaceship(&quot;Millennium Falcon&quot;));
</code></pre>
As with the <code>ifPresent()</code> method, this kind of approach takes advantage of the <a target="_blank" href="/lambda-expressions-in-java/">lambda expressions</a> to make code more readable and less error-prone.
<h3 id="orelseget">.orElseGet()</h3>
Instead of providing the <code>other</code> value directly as an argument, we can use a 
<a rel="nofollow noopener" target="_blank" href="https://docs.oracle.com/javase/8/docs/api/java/util/function/Supplier.html">Supplier</a> instead. The difference between <code>.orElse()</code> and <code>.orElseGet()</code>, while maybe not evident at first glance, exists:
<pre><code class="hljs">// orElse()
Spaceship falcon = maybeFalcon.orElse(new Spaceship(&quot;Millennium Falcon&quot;));

// orElseGet()
Spaceship falcon = maybeFalcon.orElseGet(() -&gt; new Spaceship(&quot;Millennium Falcon&quot;));
</code></pre>
If <code>maybeFalcon</code> doesn't contain a value, both methods will return a new <code>Spaceship</code>. In this case, their behavior is the same. The difference becomes clear if <code>maybeFalcon</code> does contain a value.
In the first case, the <code>new Spaceship</code> object will not be returned but it will be created. This will happen regardless of whether or not the value exists. In the second case, the <code>new Spaceship</code> will be created only if <code>maybeFalcon</code> doesn't contain a value.
It's similar to how <code>do-while</code> does the task regardless of the <code>while</code> loop, at least once.
This might seem like a negligible difference but it becomes pretty important if creating spaceships is a demanding operation. In the first case, we're always creating a new object - even if it will never be used.
<code>.orElseGet()</code> should be preferred instead of <code>.orElse()</code> in such cases.
<h3 id="orelsethrow">.orElseThrow()</h3>
Instead of returning an alternative value (as we've seen in the previous two sections), we can throw an exception. This is accomplished with the <code>.orElseThrow()</code> method which instead of an alternative value accepts a supplier which returns the exception in case it needs to be thrown.
This can be useful in cases where the end result is of high importance and must not be empty. Throwing an exception in this case might be the safest option:
<pre><code class="hljs">// Throwing an exception
Spaceship falcon = maybeFalcon.orElseThrow(NoFuelException::new);
</code></pre>
<h2 id="gettingvaluesfromoptional">Getting Values from Optional</h2>
<h3 id="get">.get()</h3>
After seeing many different ways of checking and accessing the value inside <code>Optional</code>, let's now take a look at one final way of obtaining the value which also uses some of the previously shown methods.
The simplest way to access a value inside an <code>Optional</code> is with <code>.get()</code>. This method returns the value present, or throws a <code>NoSuchElementException</code> if the value is absent:
<pre><code class="hljs">Optional&lt;Spaceship&gt; optionalFalcon = Optional.ofNullable(hangar.getFalcon());
if (falcon.isPresent()) {
 Spaceship falcon = optionalFalcon.get()

 // Fly the falcon
}
</code></pre>
As expected, the <code>.get()</code> method returns a non-<code>null</code> instance of the <code>Spaceship</code> class and assigns it to the <code>falcon</code> object.
<h2 id="conclusion">Conclusion</h2>
<code>Optional</code> was introduced to Java as a way to fix the issues with <code>null</code> references. Before <code>Optional</code>, every object was allowed to either contain a value or not (i.e. being <code>null</code>).
The introduction of <code>Optional</code> essentially enforces <code>null</code>-checking by the type-system making it unnecessary to perform such checks manually.
This was a big step both in improving the language and its usability by adding an additional layer of type-checking. Using this system instead of the old-fashioned <code>null</code>-checking allows writing clear and concise code without the need to add boilerplate and perform tiring checks by hand.

Luka Čupić

The Optional class was introduced in Java 8 to fix many of the issues with null references. In this article, we'll dive into the class, how it's used and improve code with Optionals.

Guide to Optional in Java 8

Guide to Using Optional in Java 8

Guest Contributor

The Builder Design pattern takes care of object construction and allows us to build complex objects with less human-induced errors and improves maintainability and scalability.

The Builder Design Pattern in Java

<h2 id="introduction">Introduction</h2>
If you wanted to select elements from an array or object before the ES2015 update to JavaScript, you would have to individually select them or use a loop.
The ES2015 specification introduced the destructuring assignment, a quicker way to retrieve array elements or object properties into variables.
In this article, we'll use the destructuring assignment to get values from arrays and objects into variables. We'll then see some advanced usage of the destructuring assignment that allows us to set default values for variables, capture unassigned entries, and swap variables in one line.
<h2 id="arraydestructuring">Array Destructuring</h2>
When we want to take items from an array and use them in separate variables, we usually write code like this:
<pre><code class="hljs">let myArray = [1, 2, 3];
let first = myArray[0];
let second = myArray[1];
let third = myArray[2];
</code></pre>
Since the major ES2015 update to JavaScript, we can now do that same task like this:
<pre><code class="hljs">let myArray = [1, 2, 3];
let [first, second, third] = myArray;
</code></pre>
The second, shorter example used JavaScript's destructuring syntax on <code>myArray</code>. When we destructure an array, we are copying the values of its elements to variables. Array destructuring syntax is just like regular variable assignment syntax (<code>let x = y;</code>). The difference is that the left side consists of one or more variables in an array.
The above code created three new variables: <code>first</code>, <code>second</code>, and <code>third</code>. It also assigned values to those variables: <code>first</code> is equal to 1, <code>second</code> is equal to 2, and <code>third</code> is equal to 3.
With this syntax, JavaScript sees that <code>first</code> and 1 have the same index in their respective arrays, 0. The variables are assigned values corresponding to their order. As long as the location matches between the left and right side, the destructuring assignment will be done accordingly.
The destructuring syntax also works with objects, let's see how.
<h2 id="objectdestructuring">Object Destructuring</h2>
Before the destructuring syntax was available, if we wanted to store an object's properties into different variables we would write code like this:
<pre><code class="hljs">const foobar = {
 foo: &quot;hello&quot;,
 bar: &quot;world&quot;
};

const foo = foobar.foo;
const bar = foobar.bar;
</code></pre>
With the destructuring syntax, we can now quickly do the same thing with fewer lines of code:
<pre><code class="hljs">const foobar = {
 foo: &quot;hello&quot;,
 bar: &quot;world&quot;
};

const { foo, bar } = foobar;
</code></pre>
While array items are destructured via their position, object properties are destructured by their key name. In the above example, after declaring the object <code>foobar</code> we then create two variables: <code>foo</code> and <code>bar</code>. Each variable is assigned the value of the object property with the same name. Therefore <code>foo</code> is &quot;hello&quot; and <code>bar</code> is &quot;world&quot;.
Note: The destructuring assignment works whether you declare a variable with <code>var</code>, <code>let</code>, or <code>const</code>.
If you prefer to give a different variable name while destructuring an object, we can make a minor adjustment to our code:
<pre><code class="hljs">const foobar = {
 foo: &quot;hello&quot;,
 bar: &quot;world&quot;
};

const { foo: baz, bar } = foobar;
console.log(baz, bar); // hello world
</code></pre>
With a colon, we can match an object property and give the created variable a new name. The above code does not create a variable <code>foo</code>. If you try to use <code>foo</code> you will get a <code>ReferenceError</code>, indicating that it was not defined.
Now that we've got the basics of destructuring arrays and objects, let's look at some neat tricks with this new syntax. We'll start with our option to select default values.
<h2 id="defaultvaluesindestructuredvariables">Default Values in Destructured Variables</h2>
What happens if we try to destructure more variables than the number of array elements or object properties? Let's see with a quick example:
<pre><code class="hljs">let [alpha1, alpha2, alpha3] = [&#x27;a&#x27;, &#x27;b&#x27;];

console.log(alpha1, alpha2, alpha3);
</code></pre>
Our output will be:
<pre><code class="hljs">a b undefined
</code></pre>
Unassigned variables are set to <code>undefined</code>. If we want to avoid our destructured variables from being <code>undefined</code>, we can give them a default value. Let's reuse the previous example, and default <code>alpha3</code> to 'c':
<pre><code class="hljs">let [alpha1, alpha2, alpha3 = &#x27;c&#x27;] = [&#x27;a&#x27;, &#x27;b&#x27;];

console.log(alpha1, alpha2, alpha3);
</code></pre>
If we run this in <code>node</code> or the browser, we will see the following output in the console:
<pre><code class="hljs">a b c
</code></pre>
Default values are created by using the <code>=</code> operator when we create a variable. When we create variables with a default value, if there's a match in the destructuring environment it will be overwritten.
Let's confirm that's the case with the following example, which sets a default value on an object:
<pre><code class="hljs">const { prime1 = 1, prime2 } = { prime1: 2, prime2: 3 };

console.log(prime1, prime2);
</code></pre>
In the above example, we default <code>prime1</code> to 1. It should be overwritten to be 2 as there is a <code>prime1</code> property on the object in the right-hand side of the assignment. Running this produces:
<pre><code class="hljs">2 3
</code></pre>
Great! We've confirmed that default values are overwritten when there's a match. This is also good because the first prime number is indeed 2 and not 1.
Default values are helpful when we have too little values in the array or object. Let's see how to handle cases when there are a lot more values that don't need to be variables.
<h2 id="capturingunassignedentriesinadestructuredassignment">Capturing Unassigned Entries in a Destructured Assignment</h2>
Sometimes we want to select a few entries from an array or object and capture the remaining values we did not put into individual variables. We can do just that with the <code>...</code> operator.
Let's place the first element of an array into a new variable, but keep the other elements in a new array:
<pre><code class="hljs">const [favoriteSnack, ...fruits] = [&#x27;chocolate&#x27;, &#x27;apple&#x27;, &#x27;banana&#x27;, &#x27;mango&#x27;];
</code></pre>
In the above code, we set <code>favoriteSnack</code> to 'chocolate'. Because we used the <code>...</code> operator, <code>fruits</code> is equal to the remaining array items, which is <code>['apple', 'banana', 'mango']</code>.
We refer to variables created with <code>...</code> in the destructuring assignment as the rest element. The rest element must be the last element of the destructuring assignment.
As you may have suspected, we can use the rest element in objects as well:
<pre><code class="hljs">const { id, ...person } = {
 name: &#x27;Tracy&#x27;,
 age: 24,
 id: 1020212,
};
</code></pre>
We extract the <code>id</code> property of the object on the right-hand side of the destructuring assignment into its own variable. We then put the remaining properties of the object into a <code>person</code> variable. In this case, <code>id</code> would be equal to <code>1020212</code> and <code>person</code> would be equal to <code>{ name: 'Tracy', age: 24 }</code>.
Now that we've seen how to keep all the data, let's see how flexible the destructuring assignment is when we want to omit data.
<h2 id="selectivevaluesinadestructuringassignment">Selective Values in a Destructuring Assignment</h2>
We don't have to assign every entry to a variable. For instance, if we only want to assign one variable from many options we can write:
<pre><code class="hljs">const [name] = [&#x27;Katrin&#x27;, &#x27;Judy&#x27;, &#x27;Eva&#x27;];
const { nyc: city } = { nyc: &#x27;New York City&#x27;, ldn: &#x27;London&#x27; };
</code></pre>
We assigned <code>name</code> to 'Katrin' from the array and <code>city</code> to 'New York City' from the object. With objects, because we match by key names it's trivial to select particular properties we want in variables. In the above example, how could we capture 'Katrin' and 'Eva' without having to take 'Judy' as well?
The destructuring syntax allows us to put holes for values we aren't interested in. Let's use a hole to capture 'Katrin' and 'Eva' in one go:
<pre><code class="hljs">const [name1, , name2] = [&#x27;Katrin&#x27;, &#x27;Judy&#x27;, &#x27;Eva&#x27;];
</code></pre>
Note the gap in the variable assignment between <code>name1</code> and <code>name2</code>.
So far we have seen how flexible the destructuring assignment can be, albeit only with flat values. In JavaScript, arrays can contain arrays and objects can be nested with objects. We can also have arrays with objects and objects with arrays. Let's see how the destructuring assignment handles nested values.
<h2 id="destructuringnestedvalues">Destructuring Nested Values</h2>
We can nest destructuring variables to match nested entries of an array and object, giving us fine-grained control of what we select. Consider having an array of arrays. Let's copy the first element of each inner array into their own variable:
<pre><code class="hljs">let [[part1], [part2], [part3], [part4]] = [[&#x27;fee&#x27;, &#x27;mee&#x27;], [&#x27;fi&#x27;, &#x27;li&#x27;], [&#x27;fo&#x27;, &#x27;ko&#x27;], [&#x27;fum&#x27;, &#x27;plum&#x27;]];

console.log(part1, part2, part3, part4);
</code></pre>
Running this code will display the following output:
<pre><code class="hljs">fee fi fo fum
</code></pre>
By simply wrapping each variable in the left-hand side with <code>[]</code>, JavaScript knows that we want the value within an array and not the array itself.
When we destructure nested objects, we have to match the key of the nested object to retrieve it. For example, let's try to capture some details of a prisoner in JavaScript:
<pre><code class="hljs">const {
 name,
 crimes: {
 yearsToServe
 }
} = {
 name: &#x27;John Doe&#x27;,
 crimes: {
 charged: [&#x27;grand theft auto&#x27;, &#x27;stealing candy from a baby&#x27;],
 yearsToServe: 25
 }
};

console.log(yearsToServe);
</code></pre>
To get the <code>yearsToServe</code> property, we first need to match the nested <code>crimes</code> object. In this case, the right-hand side has a <code>yearsToServe</code> property of the <code>crimes</code> object set to 25. Therefore, our <code>yearsToServe</code> variable will be assigned a value of 25.
Note that we did not create a <code>crimes</code> object in the above example. We created two variables: <code>name</code> and <code>yearsToServe</code>. Even though we must match the nested structure, JavaScript does not create intermediate objects.
You've done great so far in covering a lot of the destructured syntax capabilities. Let's have a look at some practical uses for it!
<h2 id="usecasesfordestructuringarraysandobjects">Use Cases for Destructuring Arrays and Objects</h2>
There are many uses for destructuring arrays and object, in addition to the lines of code benefits. Here are a couple of common cases where destructuring improves the readability of our code:
<h3 id="forloops">For Loops</h3>
Developers use the destructuring assignment to quickly pull values of interest from an item in a <code>for</code> loop. For example, if you wanted to print all the keys and values of an object, you can write the following:
<pre><code class="hljs">const greetings = { en: &#x27;hi&#x27;, es: &#x27;hola&#x27;, fr: &#x27;bonjour&#x27; };

for (const [key, value] of Object.entries(greetings)) {
 console.log(`${key}: ${value}`);
}
</code></pre>
First, we create a <code>greetings</code> variable that stores how to say &quot;hello&quot; in different languages. Then we loop through the values of the object using the <code>Object.entries()</code> method which creates a nested array. Each object property is represented by 2 dimensional array with the first item being the key and the second item being its value. In this case, <code>Object.entries()</code> creates the following array <code>[['en', 'hi'], ['es', 'hola'], ['fr', 'bonjour']]</code>.
In our <code>for</code> loop, we destructure the individual arrays into <code>key</code> and <code>value</code> variables. We then log them to the console. Executing this program gives the following output:
<pre><code class="hljs">en: hi
es: hola
fr: bonjour
</code></pre>
<h3 id="swappingvariables">Swapping Variables</h3>
We can use the destructuring syntax to swap variables without a temporary variable. Let's say you're at work and taking a break. You wanted some tea, while your coworker wanted some coffee. Unfortunately, the drinks got mixed up. If this were in JavaScript, you can easily swap the drinks using the destructuring syntax:
<pre><code class="hljs">let myCup = &#x27;coffee&#x27;;
let coworkerCup = &#x27;tea&#x27;;
[myCup, coworkerCup] = [coworkerCup, myCup];
</code></pre>
Now <code>myCup</code> has 'tea' and <code>coworkerCup</code> has 'coffee'. Note how we did not have <code>let</code>, <code>const</code>, or <code>var</code> when using the destructuring assignment. As we aren't declaring new variables, we need to omit those keywords.
<h2 id="conclusion">Conclusion</h2>
With the destructuring assignment, we can quickly extract values from arrays or objects and put them into their own variables. JavaScript does this by matching the variable's array position, or the name of the variable with the name of the object property.
We've seen that we can assign default values to variables we are creating. We can also capture the remaining properties of arrays and objects using the <code>...</code> operator. We can skip entries by having holes, which are indicated by commas with nothing in between them. This syntax is also flexible enough to destructure nested arrays and objects.
We provided a couple of nifty places to use the destructuring assignment. Where will you use them next?

JavaScript's Destructuring Assignment provides a quick and flexible way to take values from array elements and object properties and put them into variables.

JavaScript's Destructuring Assignment

Robley Gori

MongoDB is a document-based non-relational database that allows great and easy horizontal scalability. In this article, we'll use PyMongo to connect to a MongoDB database and perform CRUD operations using Python.

Integrating MongoDB with Python Using PyMongo

<h2 id="introduction">Introduction</h2>
Checking if a file or directory exists is a simple and important operation in many tasks. Before accessing a file, we should check if it exists to avoid a <code>NullPointerException</code>. The same goes for directories.
While some functions may create a new file/directory if the requested one doesn't exist, this may be the opposite of what we want. If we wish to append more information to an existing file and the method goes through without a warning, since it creates the new file it needs - we may have lost some information without realizing it.
Here, we've got a simple structure:
<pre><code class="hljs">02/13/2020 11:53 AM &lt;DIR&gt; directory
02/13/2020 11:55 AM &lt;SYMLINKD&gt; directory_link [directory]
02/13/2020 11:53 AM 0 file.txt
02/13/2020 11:55 AM &lt;SYMLINK&gt; symlink.txt [file.txt]
</code></pre>
There's a <code>file.txt</code> file and a <code>symlink.txt</code> file. The <code>symlink.txt</code> file is a symbolic link to the <code>file.txt</code>.
Similarly, we've got a <code>directory</code> and a symbolic link to it - <code>directory_link</code>.
<h2 id="checkifafileexists">Check if a File Exists</h2>
To work with the <code>Files</code> class, you need to be acquainted with the <code>Path</code> class. <code>Files</code> only accepts <code>Path</code>, and not <code>File</code> objects.
For the purposes of the tutorial, we'll define a <code>File</code> and <code>Path</code> instance for the <code>file.txt</code> in our directory:
<pre><code class="hljs">final static String location = &quot;C:\\file.txt&quot;;

Path path = Paths.get(location);
File file = new File(location);
</code></pre>
<h3 id="filesexists">Files.exists()</h3>
That being said, the first way we can check if a file exists is through the <code>Files</code> class:
<pre><code class="hljs">// Check if file exists through a Path
System.out.println(Files.exists(path));

// Check if a file exists by converting File object to Path
System.out.println(Files.exists(file.toPath()));
</code></pre>
Running this code will yield us:
<pre><code class="hljs">true
true
</code></pre>
<h3 id="filesnotexists">Files.notExists()</h3>
You might be wondering why the <code>notExists()</code> method exists at all:
<blockquote>
If <code>exists()</code> returns <code>true</code>, that means that <code>notExists()</code> should return <code>false</code>. They're logical complements and <code>A = !B</code>, right?
</blockquote>
Well, that's where many get it wrong. If <code>Files.exists()</code> returns <code>false</code>, it doesn't have to mean that the file doesn't exist.
It can also mean that the file's existence cannot be verified. In that case, both <code>Files.exists()</code> and <code>Files.notExists()</code> would return <code>false</code>, as Java cannot determine if the file does or doesn't exist.
This typically happens if you have a file that's locked in a way that Java can't access it. Imagine we had a file that's locked in our directory - <code>lockedFile.txt</code>:
<img src="https://stackabuse.s3.amazonaws.com/media/java-check-if-file-or-directory-exists-1.PNG" alt="file with denied permissions">
And if we tried verifying its existence with:
<pre><code class="hljs">System.out.println(Files.exists(path));
System.out.println(Files.notExists(path));
</code></pre>
We'd be greeted with:
<pre><code class="hljs">false
false
</code></pre>
It exists, obviously, but Java doesn't have permission to confirm that on our system - thus giving conflicting results.
<h3 id="filesisregularfile">Files.isRegularFile()</h3>
Additionally, we can check if the file is a regular file (<code>false</code> if it's a directory) through the <code>isRegularFile()</code> method:
<pre><code class="hljs">System.out.println(Files.isRegularFile(path));
</code></pre>
The output is:
<pre><code class="hljs">true
</code></pre>
<h3 id="fileisfile">File.isFile()</h3>
Instead of using the <code>Files</code> class, we can also perform methods on the file objects themselves:
<pre><code class="hljs">System.out.println(file.isFile());
</code></pre>
This returns:
<pre><code class="hljs">true
</code></pre>
<h3 id="fileexists">File.exists()</h3>
Similar to the previous option, we can run the <code>exists()</code> method:
<pre><code class="hljs">System.out.println(file.exists());
</code></pre>
And this also returns:
<pre><code class="hljs">true
</code></pre>
The difference between these two is that the first one checks if it's a file, and the other one checks if it exists. In different circumstances, they'd return different results.
<h3 id="lockedfiles">Locked Files</h3>
A fun thing to note is that if you're using a <code>File</code> to check for existence, Java can determine if the locked file from before exists or not:
<pre><code class="hljs">System.out.println(file.isFile());
System.out.println(file.exists());
</code></pre>
Running this piece of code will yield:
<pre><code class="hljs">true
true
</code></pre>
With this, it's evident that the locked file can be read by using the <code>File</code> class instead of the <code>Files</code> helper class.
<h2 id="checkifadirectoryexists">Check if a Directory Exists</h2>
Directories are essentially files, that can contain other files. This is why checking if a directory is a file will return <code>true</code>. Though, if you're checking if a directory is a directory (a special type of file), you'll get a more accurate result.
This time around, we're switching our location to:
<pre><code class="hljs">final static String location = &quot;C:\\directory&quot;;
</code></pre>
<h3 id="filesexists">Files.exists()</h3>
Again, just like in the first example, we can check if it exists via:
<pre><code class="hljs">System.out.println(Files.exists(path));
</code></pre>
The output is:
<pre><code class="hljs">true
</code></pre>
<h3 id="filesisdirectory">Files.isDirectory()</h3>
If we'd like to check if it's specifically a directory, we'd use:
<pre><code class="hljs">System.out.println(Files.isDirectory(path));
</code></pre>
And the output is:
<pre><code class="hljs">true
</code></pre>
Note: If the directory doesn't exist, the <code>isDirectory()</code> method will return <code>false</code>. It's due to the way the method is named. What it does is - it checks if the file exists and if it's a directory, not only the latter. A file can't be a directory if it doesn't exist - hence, <code>false</code> is returned.
<h2 id="checkiffileissymboliclink">Check if File is Symbolic Link</h2>
You might also want to check if a file is just a symbolic link. In that case, you'd use the <code>Files</code> class.
Let's switch our location to:
<pre><code class="hljs">final static String location = &quot;C:\\symlink.txt&quot;;
</code></pre>
<h3 id="filesissymboliclink">Files.isSymbolicLink()</h3>
As usual, the <code>Files</code> class accepts a <code>Path</code> to the file:
<pre><code class="hljs">System.out.println(Files.isSymbolicLink(path));
</code></pre>
Running this would yield:
<pre><code class="hljs">true
</code></pre>
<h3 id="filegetcanonicalpathvsfilegetabsolutepath">File.getCanonicalPath() vs File.getAbsolutePath()</h3>
Another way to check for a symbolic link is to compare the results of the file's canonical path and absolute path. If they're different, it's most probably a symbolic link:
<pre><code class="hljs">System.out.println(file.getCanonicalPath());
System.out.println(file.getAbsolutePath());
</code></pre>
Since we're checking for a symbolic link, and we know it is, these should return a different result - a <code>symlink.txt</code> and <code>file.txt</code> path:
<pre><code class="hljs">C:\symlink.txt
C:\symlink.txt
</code></pre>
However, this isn't the case here. This is due to the fact that the symlink was created on Windows with NTFS (New Technology File System). The symlink was created using the <code>mklink</code> command in the CMD.
<h2 id="checkifeitherexist">Check if Either Exist</h2>
From the previous examples, it's evident that the <code>Files.exists()</code> method will return <code>true</code> for both existing files and directories. Though, it doesn't work best when it comes to locked files.
On the other hand, the <code>exists()</code> method from the <code>File</code> class will also return <code>true</code> for both files and directories and can read the locked file that the <code>Files</code> class can't.
<h2 id="conclusion">Conclusion</h2>
Checking for the existence of files and directories is the first line of defense against missing files and directories. Different approaches have different setbacks and you might assume that a method will return an accurate result, but it won't due to how it works in the background.
Being aware of which methods return which results in which circumstances will allow you to avoid nasty exceptions when handling files.
After checking if your file exists or not, you'll likely want to do some <a target="_blank" href="/reading-and-writing-files-in-java/">Reading and Writing Files in Java</a>.

David Landup

Checking if a file or directory exists is a simple and important operation in many tasks. In this article, we'll explore the many different ways that you can employ to check if a file or directory exists if it's a symlink and the setbacks of these approaches.

Java: Check if a File or Directory Exists

<h3 id="introduction">Introduction</h3>
Sorting, although a basic operation, is one of the most important operations a computer should perform. It is a building block in many other algorithms and procedures, such as searching and merging. Knowing different sorting algorithms could help you better understand the ideas behind the different algorithms, as well as help you come up with better algorithms.
The Selection Sort algorithm sorts an array by finding the minimum value of the unsorted part and then swapping it with the first unsorted element. It is an in-place algorithm, meaning you won't need to allocate additional lists. While slow, it is still used as the main sorting algorithm in systems where memory is limited.
<blockquote>
In this article, we will explain how the Selection Sort works and implement it in Python. We will then break down the actions of the algorithm to learn its <a target="_blank" href="/big-o-notation-and-algorithm-analysis-with-python-examples/">time complexity</a>.
</blockquote>
<h3 id="theideabehindtheselectionsort">The Idea Behind the Selection Sort</h3>
So how does the selection sort work? Selection sort breaks the input list into two parts, the sorted part which initially is empty, and the unsorted part, which initially contains the list of all elements. The algorithm then selects the minimum value of all the unsorted elements and swaps it with the first unsorted value, and then increases the sorted part by one.
A high-level implementation of this sort would look something like this:
<pre><code class="hljs">def selection_sort(L):
 for i in range(len(L) - 1):
 min_index = argmin(L[i:])
 L[i], L[min_index] = L[min_index], L[i]
</code></pre>
In the above pseudocode, <code>argmin()</code> is a function that returns the index of the minimum value. The algorithm uses a variable <code>i</code> to keep track of where the sorted list ends and where the unsorted one begins. Since we start with no sorted items and take the minimum value, it will always be the case that every member of the unsorted part is greater than any member of the sorted part.
The first line increments the value of <code>i</code>, the second line finds the minimum value's index, and the third line swaps those values. Swapping works because Python calculated the right-hand side before assigning anything to the left-hand side, so we don't need any temporary variables.
Let's see how it works in action with a list that contains the following elements: <code>[3, 5, 1, 2, 4]</code>.
We begin with the unsorted list:
<ul>
<li>3 5 1 2 4</li>
</ul>
The unsorted section has all the elements. We look through each item and determine that <code>1</code> is the smallest element. So, we swap <code>1</code> with <code>3</code>:
<ul>
<li>1 5 3 2 4</li>
</ul>
Of the remaining unsorted elements, <code>[5, 3, 2, 4]</code>, <code>2</code> is the lowest number. We now swap <code>2</code> with <code>5</code>:
<ul>
<li>1 2 3 5 4</li>
</ul>
This process continues until the list is sorted:
<ul>
<li>1 2 3 5 4</li>
<li>1 2 3 4 5</li>
<li>1 2 3 4 5</li>
</ul>
Let's see how we can implement this in Python!
<h3 id="howtoimplementbubblesortinpython">How to Implement Bubble Sort in Python</h3>
The trick to implementing this algorithm is keeping track of the minimum value and swapping two elements of the list:
<pre><code class="hljs">def selection_sort(L):
 # i indicates how many items were sorted
 for i in range(len(L)-1):
 # To find the minimum value of the unsorted segment
 # We first assume that the first element is the lowest
 min_index = i
 # We then use j to loop through the remaining elements
 for j in range(i+1, len(L)-1):
 # Update the min_index if the element at j is lower than it
 if L[j] &lt; L[min_index]:
 min_index = j
 # After finding the lowest item of the unsorted regions, swap with the first unsorted item
 L[i], L[min_index] = L[min_index], L[i]
</code></pre>
Now let's add some code to the file to test the algorithm:
<pre><code class="hljs">L = [3, 1, 41, 59, 26, 53, 59]
print(L)
selection_sort(L)

# Let&#x27;s see the list after we run the Selection Sort
print(L)
</code></pre>
This will give us:
<pre><code class="hljs">[3, 1, 41, 59, 26, 53, 59]
[1, 3, 26, 41, 53, 59, 59]
</code></pre>
The list was correctly sorted! We know how it works and we can implement the Selection Sort in Python. Let's get into some theory and look at its performance with regard to time.
<h3 id="timecomplexitycalculation">Time Complexity Calculation</h3>
So how long does it take for selection sort to sort our list? We are going to take an approach and calculate exactly how much time the selection sort algorithm takes, given an array of size <code>n</code>. The first line of the code is:
<pre><code class="hljs">def selection_sort(L):
</code></pre>
This line shouldn't take that much since it's only setting the function stack. We say that this is a constant - the size of our input does not change how long it takes for this code to run. Let's say it takes <code>c1</code> operations to perform this line of code. Next, we have:
<pre><code class="hljs">for i in range(len(L)-1):
</code></pre>
This one is a little trickier. First of all, we have two function invocations, <code>len()</code> and <code>range()</code>, which are performed before the <code>for</code> loop begins. The cost of <code>len()</code> is also independent of size in CPython, which is the default Python implementation on Windows, Linux, and Mac. This is also true for the initialization of <code>range()</code>. Let's call these two together <code>c2</code>.
Next, we have the <code>for</code>, which is running <code>n - 1</code> times. This is not a constant, the size of the input does make an impact on how long this is executed. So we have to multiply whatever time it takes for one loop to complete by <code>n - 1</code>.
There is a constant cost for evaluating the <code>in</code> operator, let's say <code>c3</code>. That covers the outer <code>for</code> loop.
The variable assignment is also done in constant time. We'll call this one <code>c4</code>:
<pre><code class="hljs">min_index = i
</code></pre>
We now encounter the inner <code>for</code> loop. It has two constant function invocations. Let's say they take <code>c5</code> operations.

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: <code>c5</code> is different from <code>c2</code>, because the <code>range()</code> here has two arguments, and there is an addition operation being performed here.

 </div>
 </div>
 </div>
 So far we have <code>c1 + c2 + (n - 1) * (c3 + c4 + c5)</code> operations, and then our inner loop begins, multiplying everything by...? Well, it's tricky, but if you look closely, it takes <code>n - 2</code> times in the first loop, <code>n - 3</code> in the second one, and 1 in the last time.
We need to multiply everything by the sum of all numbers between 1 and <code>n - 2</code>. Mathematicians have told us that the sum would be <code>(n - 2) * (n - 1) / 2</code>.

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Advice: Feel free to read more about the sum of integers between 1 and any positive number <code>x</code> <a target="_blank" rel="nofollow noopener" href="https://www.wikihow.com/Sum-the-Integers-from-1-to-N">here</a>.

 </div>
 </div>
 </div>
 The contents of the inner loop are completed in constant time as well. Let's assign the time it takes Python to do the <code>in</code>, <code>if</code>, assignment statement and the variable swap take up an arbitrary constant time of <code>c6</code>.
<pre><code class="hljs">for j in range(i+1, len(L)-1):
 if L[j] &lt; L[min_index]:
 min_index = j
L[i], L[min_index] = L[min_index], L[i]
</code></pre>
All-together we get <code>c1 + c2 + (n - 1) * (c3 + c4 + c5) + (n - 2) * (n - 3) * c6 / 2</code>.
We can simplify this to <code>a * n * n + b * n + c</code>, where <code>a</code>, <code>b</code>, and <code>c</code> represent the values of the evaluated constants.
This is known as O(n2). What does that mean? In summary, our algorithm's performance is based on the squared size of our input list. Therefore, if we double the size of our list, the time it takes to sort it would be multiplied by 4! If we divide the size of our input by 3, the time would shrink by 9!
<h3 id="conclusion">Conclusion</h3>
In this article, we looked at how Selection Sort works and implemented it in Python. We then broke the code down line by line to analyze the algorithm's time complexity.
Learning sorting algorithms will help you get a better understanding of algorithms in general. So, in case you haven't already, you can check out our <a target="_blank" href="/sorting-algorithms-in-python/">sorting algorithms overview</a>!

Marcus Sanatan

Sajjad Heydari

Dimitrije Stamenic

While not the quickest sorting algorithm, Selection Sort is still is still relevant because of how space-efficient it is. In this article, we will explain how Selection Sort works, how to implement it in Python and analyze its time complexity.

Selection Sort in Python

<h2 id="introduction">Introduction</h2>
Test &quot;mocks&quot; are objects that replace real objects while simulating their functions. A mock also has expectations about how the functions being tested will be used.
In some unit test cases we may want to combine the functionality of spies, to observe a method's behavior under call, and that of stubs, to replace a method's functionality, in ensuring that we do not make an actual function call but are still able to monitor the behavior of our target function accordingly. In such a case, we can use mocks.
In this article, we will seek to understand what mocks are and how to use them in unit tests. We'll then get hands-on experience with <a rel="nofollow noopener" target="_blank" href="https://sinonjs.org/">Sinon.js</a> to mock an HTTP request.
This article is the third of our series on unit testing techniques with Sinon.js. We recommend that you read our previous articles on this topic as well:
<ul>
<li><a target="_blank" href="/using-stubs-for-testing-in-javascript-with-sinon-js">Using Stubs for Testing in JavaScript with Sinon.js</a></li>
<li><a target="_blank" href="/using-spies-for-testing-in-javascript-with-sinon">Using Spies for Testing in JavaScript with Sinon.js</a></li>
<li>Using Mocks for Testing in JavaScript with Sinon.js (you are here)</li>
</ul>
<h2 id="whataremocks">What are Mocks?</h2>
Mocks combine the functionality of both spies and stubs, which means that they replace the target function but at the same time provide us with the ability to observe how the function was called.
Furthermore, mocks have built-in assertions called expectations. You define the expectations of how your mocked function will be used upfront. If your mock did not satisfy its expectations, your test will fail.
For example, let's consider a function that communicates with a database to save a contact's details. With a mock, instead of a real database, our function will hit a fake database object. We can determine what kind of response it will give. We'll also state how many times the database should be called and the arguments it should be called with.
Finally, as part of the test, we verify that our database mock was called the exact amount of times we expected. We also check that it got called with only the arguments our function supposed to provide it.
Having seen what mocks are, let us now look at situations where we can employ them.
<h2 id="whyusemocks">Why Use Mocks?</h2>
Mocks are useful when validating how an external dependency is used within a function. Use mocks when you are in interested in:
<ul>
<li>Confirming that your external dependency is used at all</li>
<li>Verifying that your external dependency is used correctly</li>
<li>Ensuring that your function can handle different responses from external dependencies.</li>
</ul>
Imagine that you are testing a function that speaks with a third party API to get some user data. To make requests to the external API, you'll need to make a few calls to authenticate first. It's already becoming inconvenient to use the real API in tests. Additionally, you might not always have an internet connection to access the API while running your tests.
With a mock, we will return fake responses. We can now quickly test that our function behaves correctly when given the fake data in a particular format. We'll also know that our function made requests to the API with the right parameters.
Let's now look at how we can use Sinon.js to create mocks.
<h2 id="usingsinonjstocreateamock">Using Sinon.js to Create a Mock</h2>
We'll use Sinon.js to mock a response from a JSON API that retrieves a list of photos in an album. In addition to Sinon.js, we will be using <a rel="nofollow noopener" target="_blank" href="https://mochajs.org/">Mocha</a> and <a rel="nofollow noopener" target="_blank" href="https://www.chaijs.com/">Chai</a> to setup and run the tests. You can read our guide <a target="_blank" href="/testing-node-js-code-with-mocha-and-chai/">our guide</a> to learn more about them before continuing.
<h3 id="setup">Setup</h3>
Create a directory called <code>SinonMock</code> and move into it:
<pre><code class="hljs">$ mkdir SinonMock
$ cd SinonMock
</code></pre>
We will then use NPM to initialize a project to track the project files we create:
<pre><code class="hljs">$ npm init -y
</code></pre>
Next, we'll install Mocha and Chai as testing dependencies to run our tests, along with Sinon.js:
<pre><code class="hljs">$ npm i mocha chai sinon --save-dev
</code></pre>
Having completed our setup, let's mock an HTTP request.
<h3 id="mockinganhttpcallwithsinonjs">Mocking an HTTP Call with Sinon.js</h3>
In our <a target="_blank" href="/using-spies-for-testing-in-javascript-with-sinon">previous article on test spies</a>, we spied on an HTTP request to the photo album API. We'll continue with that example for this article.
Create a file in the root of the <code>SinonMock</code> directory and call it <code>index.js</code>:
<pre><code class="hljs">$ touch index.js
</code></pre>
In the file created, enter the following code:
<pre><code class="hljs">const request = require(&#x27;request&#x27;);

module.exports = {
 getAlbumById: async function(id) {
 const requestUrl = `https://jsonplaceholder.typicode.com/albums/${id}/photos?_limit=3`;
 return new Promise((resolve, reject) =&gt; {
 request.get(requestUrl, (err, res, body) =&gt; {
 if (err) {
 return reject(err);
 }
 resolve(JSON.parse(body));
 });
 });
 }
};
</code></pre>
To recap, <code>getAlbumById()</code> is a function which calls a JSON API that returns a list of photos. We provide an album ID as the function argument. We have previously explored stubbing and spying on the <code>request.get()</code> method.
Now, we will mock the <code>request</code> object and check if the <code>get()</code> method is called once, as required, and verify if it received the correct arguments. We'll then verify that our function has the correct properties based on what was returned from our mock.
Create another file at the root of the <code>SinonMock</code> directory and call it <code>index.test.js</code>:
<pre><code class="hljs">$ touch index.test.js
</code></pre>
Open the <code>index.test.js</code> file with an editor and enter the following code:
<pre><code class="hljs">const expect = require(&#x27;chai&#x27;).expect;
const request = require(&#x27;request&#x27;);
const sinon = require(&#x27;sinon&#x27;);
const index = require(&#x27;./index&#x27;);

describe(&#x27;with mock: getPhotosByAlbumId&#x27;, () =&gt; {
 it(&#x27;should getPhotosByAlbumId&#x27;, (done) =&gt; {
 let requestMock = sinon.mock(request);
 const myPhotos = [{
 &quot;albumId&quot;: 1,
 &quot;id&quot;: 1,
 &quot;title&quot;: &quot;accusamus beatae ad facilis cum similique qui sunt&quot;,
 &quot;url&quot;: &quot;https://via.placeholder.com/600/92c952&quot;,
 &quot;thumbnailUrl&quot;: &quot;https://via.placeholder.com/150/92c952&quot;
 },
 {
 &quot;albumId&quot;: 1,
 &quot;id&quot;: 2,
 &quot;title&quot;: &quot;reprehenderit est deserunt velit ipsam&quot;,
 &quot;url&quot;: &quot;https://via.placeholder.com/600/771796&quot;,
 &quot;thumbnailUrl&quot;: &quot;https://via.placeholder.com/150/771796&quot;
 },
 {
 &quot;albumId&quot;: 1,
 &quot;id&quot;: 3,
 &quot;title&quot;: &quot;officia porro iure quia iusto qui ipsa ut modi&quot;,
 &quot;url&quot;: &quot;https://via.placeholder.com/600/24f355&quot;,
 &quot;thumbnailUrl&quot;: &quot;https://via.placeholder.com/150/24f355&quot;
 }];

 requestMock.expects(&quot;get&quot;)
 .once()
 .withArgs(&#x27;https://jsonplaceholder.typicode.com/albums/2/photos?_limit=3&#x27;)
 .yields(null, null, JSON.stringify(myPhotos));

 index.getAlbumById(2).then((photos) =&gt; {
 expect(photos.length).to.equal(3);
 photos.forEach((photo) =&gt; {
 expect(photo).to.have.property(&#x27;id&#x27;);
 expect(photo).to.have.property(&#x27;title&#x27;);
 expect(photo).to.have.property(&#x27;url&#x27;);
 });

 requestMock.verify();
 requestMock.restore();
 done();
 });
 });
});
</code></pre>
In our test case above, we first create a mock of the <code>request</code> object using <code>sinon.mock()</code> and name it <code>requestMock</code>. The <code>requestMock</code> object has the functions of the <code>request</code> object but the functions do nothing by default.
After supplying some fixed photo data, we override the original <code>get()</code> method of the request object by using Sinon.js' mock API's <code>expect()</code> method.
The <code>expect()</code> method takes in a single argument, which is the method of the mocked object we anticipate will be used.
The <code>once()</code> method asserts that our expectation is called once. In this case the <code>get()</code> method of the request object will be called exactly one time.
The <code>withArgs()</code> method asserts that we expect the <code>get()</code> method to be called with the array of arguments we supply to it. In our case the URL of the API.
The <code>yields()</code> method puts data into the callback that our mock object accepts. In this case, our error and response are both <code>null</code> but our body has a JSON response.
After this setup, we then call our <code>getAlbumById()</code> method and check if the photos returned to have the correct properties.
Notice the <code>verify()</code> call of the <code>requestMock</code> object to confirm that our expectations were met. If expectations fail, the test will throw an exception. We then call the <code>restore()</code> method to discard the mock created by our test and restore the original request object.
When you run this test, you should get the following result:
<pre><code class="hljs">$ mocha index.test.js

with mock: getPhotosByAlbumId
 ✓ should getPhotosByAlbumId


 1 passing (13ms)

✨ Done in 0.72s.
</code></pre>
To confirm the behavior of our mock, let's see if the expectations fail if we change the URL we communicate with. In your <code>index.js</code> file, change:
<pre><code class="hljs">const requestUrl = `https://jsonplaceholder.typicode.com/albums/${id}/photos?_limit=3`;
</code></pre>
To:
<pre><code class="hljs">const requestUrl = `https://example.com`;
</code></pre>
Now run the tests once more:
<pre><code class="hljs">$ mocha index.test.js
</code></pre>
Since we changed the input to the <code>get()</code> method, the URL argument no longer matches what's in our test. We'll get this output when we run the test:
<pre><code class="hljs">&gt; mocha index.test.js



 with mock: getPhotosByAlbumId
(node:85434) UnhandledPromiseRejectionWarning: ExpectationError: Unexpected call: get(https://example.com, function () {})
 Expected get(https://jsonplaceholder.typicode.com/albums/2/photos?_limit=3[, ...]) once (never called)
</code></pre>
Great! We're pretty certain that our mocks will guarantee that our function behaves as we expect!
By using a mock, we have been able to get the benefits of both spies and stubs. We were able to check that our function was called exactly once, and with the correct arguments, a benefit provided us by spies. We were also able to stub the request so that we were not making an actual HTTP call to the API, which ensured that our test ran quickly.
<h2 id="conclusion">Conclusion</h2>
Mocks in unit testing combine the functionality of both spies and stubs by replacing functions like stubs and at the same time providing us with means of observing the functions to check how they were called, the functionality provided us by spies. Mocks then give us the benefit of verifying how our function was used in a test.
In this article, we introduced the concept of mocking in unit testing, and saw how we could mock an HTTP call. To learn more about Sinon.js mocks, you can review the <a rel="nofollow noopener" target="_blank" href="https://sinonjs.org/releases/latest/mocks/">official documentation</a> of the mocks API.

Allan Mogusu

Sinon.js is a popular framework used in standalone test spies, stubs and mocks for JavaScript. In this article, we'll mock an HTTP request in a unit test.

Using Mocks for Testing in JavaScript with Sinon.js

<h2 id="introduction">Introduction</h2>
The main focus of this article is to help you understand how Spring's <a rel="nofollow noopener" target="_blank" href="https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/beans/factory/annotation/Value.html">@Value</a> annotation works.
<code>@Value</code> is a Java annotation that is used at the field or method/constructor parameter level and it indicates a default value for the affected argument. It is commonly used for injecting values into configuration variables - which we will show and explain in the next part of the article.
<h2 id="basicassignment">Basic Assignment</h2>
For the easiest examples, we will assign values to three different fields using the <code>@Value</code> annotation by giving them explicit values:
<pre><code class="hljs">@Value(&quot;John&quot;)
private String trainee;

@Value(&quot;100&quot;)
private int hoursOfCode;

@Value(&quot;true&quot;)
private boolean passedAssesmentTest;
</code></pre>
It's very important to note that the argument passed to the <code>@Value</code> annotation can only be a <code>String</code>. Spring will convert the value to the specified type and the assignment will be done without any problems - even if we are passing <code>String</code> values to <code>int</code> or <code>boolean</code> variables.
<h2 id="springenvironment">Spring Environment</h2>
Injecting values from properties files with the help of <code>@Value</code> annotation is probably the most used use-case in real-life applications.
We will use the default property file for Spring Boot - <code>application.properties</code>, where we can define variables that we can access afterwards:
<pre><code class="hljs">car.brand=Audi
car.color=Red
car.power=150
</code></pre>
<pre><code class="hljs">@Value(&quot;${car.brand&quot;)
private String brand;

@Value(&quot;${car.color}&quot;)
private String color;

@Value(&quot;${car.power}&quot;)
private int power;
</code></pre>
In this example, the values for the variables are being read from the <code>application.properties</code> file and assigned to them during bean creation.
Most of the time, we'd use this approach to inject configuration values from the <code>application.properties</code> file into beans.
<h2 id="defaultvalue">Default Value</h2>
Default values are used as a &quot;fallback&quot; if the property we wish to inject isn't defined or missing:
<pre><code class="hljs">@Value(&quot;${car.type:Sedan}&quot;)
private String type;
</code></pre>
In the above example, because we don't have any <code>car.type</code> property in <code>application.properties</code>, Spring will assign <code>Sedan</code> to the <code>type</code> variable as the default value.
If the <code>car.type</code> property gets inserted into the properties file, the new value will be used instead.
<h2 id="systemvariables">System Variables</h2>
We can also access system variables which are stored as properties by the Spring application at start:
<pre><code class="hljs">@Value(&quot;${user.name}&quot;)
// Or
@Value(&quot;${username}&quot;)
private String userName;

@Value(&quot;${number.of.processors}&quot;)
// Or
@Value(&quot;${number_of_processors}&quot;)
private int numberOfProcessors;

@Value(&quot;${java.home}&quot;)
private String java;
</code></pre>
The variables can be called with different naming conventions - Spring searches for us and assigns the correct value.
<h2 id="globalmethodvalue">Global Method Value</h2>
Because <code>@Value</code> is processed by the <code>BeanPostProcessor</code> class, it will be invoked when Spring is building the Spring context by instantiating configuration files and beans.
This means that by having <code>@Value</code> on a method, all the arguments will be mapped with the value provided to the annotation:
<pre><code class="hljs">@Value(&quot;${car.brand}&quot;)
public CarData setCarData(String color, String brand) {
 carData.setCarColor(color);
 carData.setCarBrand(brand);
}
</code></pre>
If we are printing <code>carData.getCarColor()</code> and <code>carData.getCarBrand()</code> we will get the <code>car.brand</code> value both times, because like we said, all arguments will be mapped with the value provided.
<h2 id="parametermethodvalue">Parameter Method Value</h2>
We can fix this by using <code>@Value</code> directly on the method parameter:
<pre><code class="hljs">@Value(&quot;${car.brand}&quot;)
public CarData setCarData(@Value(&quot;${car.color}&quot;) String color, String brand) {
 carData.setCarColor(color);
 carData.setCarBrand(brand);
}
</code></pre>
Now, if we are printing the values from the <code>carData</code> object - the color field will have the <code>car.color</code> value, because we provided the value to the parameter of the method itself.
<h2 id="springexpressionlanguagespel">Spring Expression Language (SpEL)</h2>
The Spring Expression Language (SpEL) is an expression language which serves as the foundation for expression evaluation within the Spring portfolio.
Basically, when using SpEL together with the <code>@Value</code> annotation, we are just changing the way we tell Spring what we need. Let's take a closer look:
<pre><code class="hljs">@Value(&quot;#{systemProperties[&#x27;user.name&#x27;]}&quot;)
private String userName;
</code></pre>
This is how you'd inject a specific system property. On the other hand, we could inject all properties by:
<pre><code class="hljs">@Value(&quot;#{systemProperties}&quot;)
private Map&lt;String, String&gt; properties;
</code></pre>
We know now, that we can use the <code>@Value</code> annotation for methods as a global value or as a parameter value.
Since constructors are essentially methods, we can use the annotation in constructors as well:
<pre><code class="hljs">public Driver(@Value(&quot;#{systemProperties[&#x27;user.name&#x27;]}&quot;) String name, String location) {
 this.name = name;
 this.location = location;
}
</code></pre>
<h2 id="injectingintomaps">Injecting into Maps</h2>
With SpEL, we can do some other fairly interesting things when coupled with the <code>@Value</code> annotation. For example, let's make a <code>Map</code> that represents <code>indoor</code> and <code>outdoor</code> hobbies of a student. Each of these can have multiple values:
<pre><code class="hljs">student.hobbies={indoor: &#x27;reading, drawing&#x27;, outdoor: &#x27;fishing, hiking, bushcraft&#x27;}
</code></pre>
Now, to inject this, we'll need a <code>Map&lt;String, List&lt;String&gt;&gt;</code>:
<pre><code class="hljs">@Value(&quot;#{${student.hobbies}}&quot;)
private Map&lt;String, List&lt;String&gt;&gt; hobbies;
</code></pre>
<h2 id="injectingintolists">Injecting into Lists</h2>
If a property has comma-separated-values, such as a simple list of books, we can use SpEL to interpret it and transform it into a list:
<pre><code class="hljs">student.booksRead=Harry Potter,The Hobbit,Game of Thrones
</code></pre>
By using the <code>split()</code> method, and splitting for every comma (<code>,</code>), we can inject these values into a list:
<pre><code class="hljs">@Value(&quot;#{&#x27;${student.booksRead}&#x27;.split(&#x27;,&#x27;)}&quot;)
private List&lt;String&gt; booksRead;
</code></pre>
<h2 id="conclusion">Conclusion</h2>
As soon as you end up working on a real application, you realize that configuration is an important topic and if you are using Spring. There's a big chance you already use or you will have to use the <code>@Value</code> annotation extensively.
Understanding this basic functionality is very important because if you don't, you might end up using it totally wrong.
We also need to be aware that not everything that looks simple is also very good for long term solutions. For example, we should only use <code>@Value</code> in encapsulated components/services (we can call them configuration services).
This way, we will have all our configurations in one place, and that component will only have the responsibility of loading and providing them to other components.

@Value is a Java annotation used at the field or method/constructor level. It's commonly used to inject values into configuration variables.

In this article, we'll cover the many ways you can use the @Value annotation.

The @Value Annotation in Spring

Hiram Kamau

With method overriding, inheriting classes may tweak how we expect a class to behave. In this article, we'll explore one of the core concepts of OOP - polymorphism, through method overriding.