ES6, ES2016 (ES7), and ES2017 (ES8) bring new ways of creating numbers and new properties to the Number object to make working with numbers easier. The Number object was enhanced greatly in ES6 to make it easier to create mathematically rich applications and prevent the common misconceptions that caused the errors.

Earlier, there was no native way to represent numeric constants as binary. But now, you can prefix numeric constants using the 0b token to make JavaScript interpret them as binary.
Here is an example:

let a = 0b00001111;
let b = 15;
console.log(a === b);
console.log(a);

The output is as follows:

true
15

Here, 0b00001111 is a binary representation of 15, base 10 decimal.

ES6 and above add a lot of new methods to the Math object, related to trigonometry, arithmetic, and miscellaneous. This lets developers use native methods instead of external math libraries. Native methods are optimized for performance and have better decimal precision.

Often there is a need to use mathematical functions related to trigonometry, exponential, logarithmic, and so on. JavaScript provides native methods for that to make our work easy.

The following example code, which shows all trigonometry-related methods that are added to the Math object:

console.log(Math.sinh(0)); //hyberbolic sine of a value
console.log(Math.cosh(0)); //hyberbolic cosine of a value
console...

There are some new properties added to the global Array object and to its instances to make working with arrays easier. Arrays in JavaScript lacked features and capabilities when compared with programming languages such as Python and Ruby. Let's take a look at some popular methods associated with arrays and their use cases.

The Array.from() method creates a new array instance from an iterable object. The first argument is a reference to the iterable object. The second argument is optional and is a callback (known as the Map function) that is called for every element of the iterable object. The third argument is also optional and is the value of this inside...

A collection is an object that stores multiple elements as a single unit. ES6 introduced various new collection objects to provide better ways of storing and organizing data.

The array was the only collection object available in ES5. Now we have ArrayBuffers, SharedArrayBuffers, Typed Arrays, Sets, and Maps, which are built in collection objects.

Let's explore the different collection objects provided in JavaScript.

Elements of arrays can be of any type, such as strings, numbers, objects, and so on. Arrays can grow dynamically. The problem with arrays is that they are slow in terms of execution time and occupy more memory. This causes issues while developing applications that require too much computation...

Objects have existed in JavaScript for a long time. They form the backbone of JavaScript, as almost every data type can be associated with objects. (new String(), new Number(), new Boolean(), and so on). You'll often find yourself working and manipulating objects all the time when working with web applications or JavaScript in general.

ES6, ES2016 (ES7), and ES2017 (ES8) introduce a lot of new properties and methods associated with objects. Let us take a look at them.

ES8 introduced the Object.values() method so that a programmer can retrieve all the values of an object as an array. This was earlier possible by manually iterating over every property of the object and storing its value in the...

In this chapter, we learned about new features added in ES8, ES7, and ES6 for working with numbers, strings, arrays, and objects. We saw how arrays impact performance in math-rich applications and how array buffers can be used instead. We also walked through the new collection objects provided by ES8.

In the next chapter, we will take a look at the Symbols and Iteration protocol, and we will also explore the yield keyword and generators. A lot of exciting and cutting-edge stuff is coming your way! Hold tight!