Rediscovering JavaScript: ES6, ES7 & ES8

0%

1.Getting Started

How This Course Will Help You What Does This Course Cover?

2.JavaScript Gotchas

Be Careful Where You Break Lines Use === Instead of ==Declare Before Use Stay One Step Ahead Lint the Code Quiz on JavaScript Gotchas Exercise 1: Let's Vote Solution Review: Let's Vote Exercise 2: Fix the Code Solution Review: Fix the Code Exercise 3: Lint the Code Solution Review: Lint the Code

3.Variables and Constants

Out with var In with let Perils of Mutability const Safer Code With let and const Quiz on Variables and Constants Exercise 1: Let's Get the Output Solution Review: Let's Get the Output

4.Working With Function Arguments

The Power and Perils of arguments Using the Rest Parameter The Spread Operator Uses of the Spread Operator Defining Default Values for Parameters Multiple Default Parameters Expressions as Default Values Quiz on Function Arguments Exercise 1: Calculate the Tax Solution Review: Calculate the Tax Exercise 2: Purchase Items Solution Review: Purchase Items Exercise 3: Place Order Solution Review: Place Order

5.Iterators and Symbols

The Convenience of Enhanced for Symbol—A New Primitive Type Global Registry With Symbol Special Well-Known Symbols Using Custom Iterators Implementing an Iterator Removing Noise With Yield Removing Noise With Generators Combining Generators Creating Infinite Iterators Quiz on Iterators and Symbols Exercise 1: Fibonacci Series Solution Review: Fibonacci Series Exercise 2: Fibonacci Series Index Solution Review: Fibonacci Series Index

6.Arrow Functions and Functional Style

From Anonymous to Arrow Functions Multiline Arrow Functions Using the Rest Parameter and Default Arguments Anonymous vs. Arrow Functions Lexically Scoped this and arguments Limitations of Arrow Functions: Anonymous and Not a Constructor Limitations: No Prototype and new.target Property Limitations: Generators, Exceptions, and Object Literals When to Use Arrow Functions Arrow Functions and Functional Style Quiz on Arrow Functions and Functional Style Exercise 1: Refactor the Code Solution Review: Refactor the Code Exercise 2: Functional Style Programming Solution Review: Functional Style Programming

7.Literals and Destructuring

Using Template Literals Multiline Strings Tagged Template Enhanced Object Literals Array Destructuring: Extracting and Ignoring Values Array Destructuring: Default and Parameters Values Object Destructuring: Extracting Object Properties Object Destructuring: Default and Parameter Values Object Destructuring: Deep Destructuring, and Collisions Object Destructuring: The Role of the Spread Operator Quiz on Literals and Destructuring Exercise 1: Tagged Template Solution Review: Tagged Template Exercise 2: Destructuring Solution Review: Destructuring

8.Working with Classes

Creating a Class Implementing a Constructor Defining a Method Defining Computed Members Creating Properties Defining Class Members Class Expressions New Built-in Classes: Set New Built-in Classes: Map New Built-in Classes: WeakSet and WeakMap Quiz on Working with Classes Exercise 1: Class Implementation Solution Review: Class Implementation Exercise 2: Maps Solution Review: Maps

9.Using Inheritance

Understanding Prototypal Inheritance Inheriting from a Class: Subclass and Overridden Methods Inheriting from a Class: extends keyword and Prototype Chaining Inheriting from a Class: Default Constructors and Legacy Classes Managing Instance Types Managing Instance Types Rules Managing Instance Types with species Quiz on Using Inheritance Exercise 1: Sets Solution Review: Sets Exercise 2: Instance Type Solution Review: Instance Type

10.Using Modules

Introduction Creating a Module Exporting from a Module Default Exports Reexporting from Another Module Importing from a Module Quiz on Using Modules

11.Keeping Your Promises

Introduction No Thanks to Callback Hell Promises to the Rescue Ways to Create a Promise Chaining Promises Working with Multiple Promises: Racing Promises Working with Multiple Promises: Gathering All Promises Async and Await Quiz on Keeping Your Promises Exercise 1: Gathering All Promises Solution Review: Gathering All Promises Exercise 2: Async and Await Solution Review: Async and Await

12.Exploring Metaprogramming

Introduction The Power and Perils of Metaprogramming Dynamic Access Member Injection: Instance Member Injection: Class's Prototype and Property Member Injection: Injecting Multiple Properties Quiz on Exploring Metaprogramming Exercise 1: Injecting a Method Solution Review: Injecting a Method Exercise 2: Injecting Multiple Properties Solution Review: Injecting Multiple Properties

13.Deep Dive into Metaprogramming

Introduction Purpose of Reflect: Invoke Functions and Access Prototypes Purpose of Reflect: Exploring Properties Metaprogramming with Proxy Using Traps Leasing an Object Using a Revocable Proxy Intercepting Function Calls Using Proxy Synthesizing Members with Proxy Synthesizing Members Directly on an Instance Using Decorators Introspecting the Decorated Class Creating a Custom Decorator Quiz on Deep Dive into Metaprogramming Exercise 1: Revocable Proxy Solution Review: Revocable Proxy Exercise 2: Proxy Solution Review: Proxy

14.Conclusion

15.Appendix

How to Run Modern JavaScript

Rediscovering JavaScript: ES6, ES7 & ES8/

...

/

Tagged Template

Tagged Template

Learn the functions, uses, and perks of tagged templates.

We'll cover the following...

A template literal may be untagged or tagged.

Tags

Tags are functions that receive the contents of the provided template literal in two parts:

The template object
The evaluated expressions

The template literals you have seen so far are untagged, but we have the option of placing a tag in front of a template literal.

svg viewer

Built-in tagged template function `raw()`

Before you learn how to write your own tagged template functions, let’s use a built-in tagged template function called raw(). Suppose we want to create a string with some embedded special characters.

In the next example, we create a regular string, but we escape each special character with a backslash.

Javascript (babel-node)

'use strict';
//START:ONE
console.log('some special characters: \\ \\n \\b \'');
//END:ONE

The string captures all the special characters in the output, but creating those characters required repetitive use of \ before each special character. Let’s try to remove the extra \s and see how things go.

Javascript (babel-node)

'use strict';
//START:TWO
console.log("some special characters: \ \n \b '");
//END:TWO

That’s less noisy. By using double quotes, ...