Next-Gen JavaScript

 Next-Gen JavaScript

I provided a brief introduction to some core next-gen JavaScript features, Here's a quick summary!

let & const

Read more about let :

Read more about const :

let  and const  basically, replace var . 

You use let  instead of var  and const  instead of var  if you plan on never re-assigning this "variable" (effectively turning it into a constant, therefore).

ES6 Arrow Functions

Read more:

Arrow functions are a different way of creating functions in JavaScript. Besides a shorter syntax, they offer advantages when it comes to keeping the scope of the this  keyword (see here).

Arrow function syntax may look strange but it's actually simple.

which you could also write as:



When having no arguments, you have to use empty parentheses in the function declaration:

When having exactly one argument, you may omit the parentheses:

When just returning a value, you can use the following shortcut:

That's equal to:

Exports & Imports

In React projects (and actually in all modern JavaScript projects), you split your code across multiple JavaScript files - so-called modules. You do this, to keep each file/ module focused and manageable.

To still access functionality in another file, you need export  (to make it available) and import  (to get access) statements.

You got two different types of exports: default (unnamed) and named exports:

default => export default ...; 

named => export const someData = ...; 

You can import default exports like this:

import someNameOfYourChoice from './path/to/file.js'; 

Surprisingly, someNameOfYourChoice  is totally up to you.

Named exports have to be imported by their name:

import { someData } from './path/to/file.js'; 

A file can only contain one default and an unlimited amount of named exports. You can also mix the one default with any amount of named exports in one and the same file.

When importing named exports, you can also import all named exports at once with the following syntax:

import * as upToYou from './path/to/file.js'; 

upToYou  is - well - up to you and simply bundles all exported variables/functions in one JavaScript object. For example, if you

 export const someData = ...  (/path/to/file.js ) you can

access it on upToYou  like this: upToYou.someData .


Classes are a feature that basically replaces constructor functions and prototypes. You can define blueprints for JavaScript objects with them. 

Like this:

In the above example, not only the class but also a property of that class (=> name ) is defined. The syntax you see there is the "old" syntax for defining properties. In modern JavaScript projects (as the one used in this course), you can use the following, more convenient way of defining class properties:

You can also define methods. Either like this:

Or like this:

The second approach has the same advantage as all arrow functions have: The this  keyword doesn't change its reference.

You can also use inheritance when using classes:

Spread & Rest Operator

The spread and rest operators actually use the same syntax: ... 

Yes, that is the operator - just three dots. It's usage determines whether you're using it as the spread or rest operator.

Using the Spread Operator:

The spread operator allows you to pull elements out of an array (=> split the array into a list of its elements) or pull the properties out of an object. Here are two examples:

Here's the spread operator used on an object:

newObject  would then be

The spread operator is extremely useful for cloning arrays and objects. Since both are reference types (and not primitives), copying them safely (i.e. preventing the future mutation of the copied original) can be tricky. With the spread operator, you have an easy way of creating a (shallow!) clone of the object or array. 


Destructuring allows you to easily access the values of arrays or objects and assign them to variables.

Here's an example for an array:

And here for an object:

Destructuring is very useful when working with function arguments. Consider this example:

Here, we only want to print the name in the function but we pass a complete person object to the function. Of course, this is no issue but it forces us to call inside of our function. We can condense this code with destructuring:

We get the same result as above but we save some code. By destructuring, we simply pull out the name  property and store it in a variable/ argument named name  which we then can use in the function body.

No comments: