Accelerated ES6 JavaScript Training

The "let" keyword is a brand-new addition to JavaScript and whilst it allows us to create variables like "var" does, it also introduces "Block Scope" to JavaScript. What all that is? Have a look at this lecture to learn more!

Besides "let", "const" was added to make the declaration of constants easy.

With let & const, Hoisting changed a bit in ES6, learn how it changed, with this lecture.

ES6 introduces a new way to write Functions - the (Fat) Arrow Syntax. Learn how it works and what's special about it, in this lecture.

Besides a different Syntax, (Fat) Arrow Functions introduce one huge new feature/ change to functions. Learn which change it is, with this video.

This lectures teaches you how to set and work with Default Parameters in JavaScript Functions.

When creating Objects with the Literal Notation, you now got some new tools available. Learn more in this lecture.

A couple of new operators were added with ES6, one important one is the Rest Operator, which is explained in this lecture.

Closely related to the Rest Operator, the Spread Operator is another new operator added with ES6. This lecture shows you how to work with it.

A new Loop was added with ES6. Learn all about it in this lecture.

There's also a new way to create (complex) strings. This lecture dives into Template Literals and gets you going with them.

A new concept was added with ES6: Destructuring. Learn more about it and see how it is used with Arrays, in this lecture.

Like Arrays, Objects may be destructured as well.  Learn more about it, in this lecture.

Time to summarize Destructuring and tie all things together.

A quick wrap up of this module.

Let me give you a brief module introduction and explain what Modules and Classes are.

As ES6 doesn't run natively in the Browser yet, we need to set up some things in our workspace before we can use Modules. This lecture shows the necessary steps.

Time to dive into Modules and cover their basics.

There are different ways to export or import code with ES6 Modules. This lecture shows and explains the different ways to do it.

There are some important things to know, when working with ES6 Modules. Have a look at this article to quickly understand it.

Classes make the creation of Object Blueprints even easier than before. Learn how to work with classes, in this lecture.

It's important to understand how Classes work together with Prototypes. This lecture will get you there.

A big feature of ES6 is, that the classes may also inherit from each other. This lecture shows how that works.

With ES5, Prototypes were the way to implement Inheritance in JavaScript. With Inheritance now also available with the ES6 classes, the question is how both concepts are related. This lecture dives into that question.

ES6 classes may also expose static methods which can be used without instantiating a class. This lecture explores this concept.

Time to combine Classes and Modules and see how both concepts work together.

You may also encapsulate certain properties in your classes and use Getters and Setters for that.

You may not only extend your own Classes, you can also extend built-in Objects. This lecture dives into that concept.

Learn which built-in Objects may be extended.

A quick module wrap up.

Let me give you a brief introduction to this modules and ES6 Symbols.

What are Symbols? This lecture answers this question.

We just learned that Symbols provide a unique ID. But there's also the possibility of sharing one ID over multiple Symbols. How and why? Have a look at this lecture.

Let's have a look at the advantages (unique) IDs/ Symbols offer us.

Built-in Objects in JavaScript use Symbols and we can take advantage of those "well-known" Symbols. This lecture dives deeper into this topic.

A quick module introduction.

Let's dive into Iterators first. This lecture gives you the basics about them.

Now that we know what Iterators are, it's important to see them in action. This lecture will do just that.

The cool thing about Iterators is, that we can use them in our own objects. Learn how to do that, with this lecture.

Iterators are one half of that module, Generators are the other. What are Generators? Have a look at this lecture to learn more.

As with Iterators, it's best to see Generators in Action and also learn how they are related to Iterators.

What if you wanted to control the execution flow of your Iterator? You can do that with throw() and return(), as this lecture shows.

Let me introduce the concept of Promises and this module to you.

The first important step is to understand how Promises are created and how to work with them. This lecture explores those topics.

A Promise might not be resolved due to various reasons, therefore, you can also reject it. Learn how, in this lecture.

What's better than one Promise? Multiple Promises, used together! 

You already learned how to reject Promises and handle that case. But there's also another way to handle rejected Promises. This lecture shows which way I mean.

There exist some cool, built-in methods for Promises. Learn more about them, in this lecture.

A quick wrap up of the concepts learned in this module.

A quick module introduction.

The built-in Object object received some additions and new features. Learn more about it in this lecture.

The Math Object also saw some additions. Let's dive into some of them!

There are now even more things you can do with Strings in JavaScript. Let's have a closer look in this video.

You already guessed it, the Number Object also has some new tricks to show. Let's have a look at them.

Arrays got loads of new features and methods, time to have a look at them.

Arrays got loads of new features and methods, time to have a look at them.

A quick module wrap up.

Let me give a brief introduction to Maps and Sets and this Module in general.

How does a Map work, how is it created and how can you add items to it? This lecture answers these questions.

We got items in the Map. And now what? There are a couple of ways to work with those items. This lecture explores your possibilities.

As a Map is a collection, you may loop through it. This lecture shows how.

Time for a quick summary of the concepts learned and the Map Object.

Besides the Map, there also is the WeakMap. What's that? This lecture explains it, as well as the differences between the "normal" Map and the WeakMap.

Besides Maps, Sets are another new form of Collections in ES6. Let's learn what they are, how they work, how to create a Set and how to add items to it.

Like Maps, Sets also don't hold Items to then do nothing with them. Therefore, let's have a look at the interaction possibilities we have.

Of course you may also loop through sets. There's an interesting behavior, as we will see in this lecture.

Let me summarize the different concepts learned.

We not only have Maps and WeakMaps, we also have WeakSets. Not what's that? Learn more, in this lecture.

A quick module introduction.

The Reflect API offers you a method to create objects. Yet another way? Yes, but you'll also learn why it has this method.

You may also call functions with the Reflect API. Why and how? Have a look at this lecture.

The Reflect API also offers some new methods to work with Prototypes. Learn which methods that are and how you may use them.

See how you can combine the various Reflect API methods discussed until now.

 You may also access Properties through the Reflect API. Learn more, in this lecture.

Accessing Properties is great, but what if you want to find out which Properties an object has? The ownKeys() method might be helpful!

Accessing Properties, analyzing Properties - can we also create and delete Properties? Of course we can!

You can also control if an Object should be extendable or not. Additionally, I'll give a short wrap up of that module.

What are Proxies? And why might they be useful? This lecture will answer these questions.

So, Traps are an important part of Proxies. Let's see how they actually work.

I mentioned it all the time: Proxies and the Reflect API work together very well. Let's see that in action.

Now we're getting fancy - you may use Proxies as Prototypes. This lecture shows you how to do that.

We're getting even fancier - you can also wrap Proxies! Why and how? Let's have a look.

Back to "more normal" use cases. You may also wrap functions, not only objects.

Sometimes, you only temporarily want to use a Proxy. For such an use case, you may use revocable Proxies.

A quick module wrap up.