Let’s talk about the latest version of JavaScript: ECMAScript 2016 (more commonly known as ES7). ES7 brings two new features: Array.prototype.includes() and the new exponential operator: **.

Array.prototype.includes()

Gone are the days where we used .indexOf() to know if an element existed in an array.

The key word is “exist.”

.indexOf() is fine if we want to know at which index a given element appears.

But if our goal is to know if a given element exists in an array, then .indexOf() is not the best option. And the reason is simple: When querying the existence of something we expect a boolean value, not a number.

Array.prototype.includes() does exactly that. It determines if a given element exists in an array, returning true if it does, false otherwise.

Into The Specification

Array.prototype.includes ( searchElement [ , fromIndex ] )

• searchElement — the element to search for.
• fromIndex (optional) — the index from which to start to search.

Diving into the specification feels like searching for power.

The specification says:

Let’s go step-by-step and try to understand the specification with examples.

1. The difference here is the position of the element 4. Because our first example places 4 in the last position, includes will search the whole array. By specification .includes() returns immediately after finding the searchElement. This makes our second operation much faster.
2. The big difference with the SameValueZero algorithm versus the Strict Equality Comparison (used by .indexOf()) is that it allows detecting the NaN elements.
3. It returns the boolean true when the element is found and false otherwise. No more indexes as result ?
4. As opposite to .indexOf(), .includes() does not skip missing array elements. Instead, it treats them as undefined values.

Are you starting to feel the power?

We haven’t even touched fromIndex.

Let’s check the specification:

The optional second argument fromIndex defaults to 0 (i.e. the whole array is searched). If it is greater than or equal to the length of the array, false is returned, i.e. the array will not be searched. If it is negative, it is used as the offset from the end of the array to compute fromIndex. If the computed index is less than 0, the whole array will be searched.

1. If no fromIndex is provided them the default value of 0 is taken and the whole array is searched.
2. .includes() immediately returns false when the value of fromIndex is bigger than array’s length.
3. When fromIndex is negative, then it’s value is calculated as array.length — fromIndex. This is particularly useful when searching on the last elements. For example, fromIndex = -5 is the same as searching on the last 5 elements.
4. To avoid .includes() from breaking when the fromIndex calculated value is lower than 0, the whole array is searched. I would rather break ?

OK — one last new feature…

The Exponential Operator (**)

We’ve been waiting for the day we can play with exponential numbers like we play with addition, subtraction, multiplication, division.

Well, that day is here.

The operator ** behaves exactly the same way as Math.pow(). It returns the result of raising the first operand to the power of the second (e.g. x ** y).

That’s it!

You now have the power of ES7! Use it well!

Thanks to ?

• 2ality.com by Axel Rauschmayer
• ECMAScript® 2016 Language Specification
• To all He-Man fans
• freeCodeCamp for publishing ❤️

Be sure to check out my articles on ES6:

Let’s explore ES6 Generators
_Generators, aka, an implementation of iterables._medium.freecodecamp.orgOh Yes! Async / Await
_async / await is the new JavaScript syntax to declare an asynchronous function._medium.freecodecamp.org

Since ECMAScript 2015 (also known as ES6) was released, it has introduced a huge set of new features. They include arrow functions, sets, maps, classes and destructuring, and much more. In many ways, ES2015 is almost like learning a new version of JavaScript.

Ecma Technical Committee 39 governs the ECMA specification. They decided to release a new version of ECMAScript every year starting in 2015. A yearly update means no more big releases like ES6.

ECMAScript 2016 introduced only two new features:

• Array.prototype.includes()

• Exponentiation operator

Array.prototype.includes()

Array.prototype.includes() checks the array for the value passed as an argument. It returns true if the array contains the value, otherwise, it returns false.

Before, we needed to use Array.prototype.indexOf() to check if the given array contains an element or not.

let numbers = [1, 2, 3, 4];

if(numbers.indexOf(2) !== -1) {
  console.log('Array contains value');
}

With ECMA2016, we can write:

if (numbers.includes(2)) {
  console.log('Array contains value');
}

Array.prototype.includes() handles NaN better than Array.prototype.indexOf(). If the array contains NaN, then indexOf() does not return a correct index while searching for NaN.

Array.prototype.includes() returns the correct value when searching for NaN.

NaN is a property of the JavaScript global object and represents a value that is Not-a-Number. There are known quirks when comparing NaN to another value. These are addressed in Array.prototype.includes(), but not in Array.protoype.indexOf.

let numbers = [1, 2, 3, 4, NaN];

console.log(numbers.indexOf(NaN)); //Prints -1
console.log(numbers.includes(NaN)); //Prints true

Exponentiation Operator

JavaScript already supports many arithmetic operators like +, -, * and more.

ECMAScript 2016 introduced the exponentiation operator, **.

It has the same purpose as Math.pow(). It returns the first argument raised to the power of the second argument.

let base = 3;
let exponent = 4;
let result = base**exponent;

console.log(result); //81

Conclusion

New features introduced by ECMA2016 provide convenient alternatives to existing functionalities.

Looking ahead, ECMA2017 was finalized in June of this year. New features include async/await, SharedArrayBuffer and some useful methods to Object.prototype.