Table of Contents for

Understanding ECMAScript 6

CONTENTS IN DETAIL

FOREWORD by Dan Abramov

ACKNOWLEDGMENTS

INTRODUCTION

The Road to ECMAScript 6

About This Book

Browser and Node.js Compatibility

Who This Book Is For

Overview

Conventions Used

Help and Support

1
BLOCK BINDINGS

var Declarations and Hoisting

Block-Level Declarations

let Declarations

No Redeclaration

const Declarations

The Temporal Dead Zone

Block Bindings in Loops

Functions in Loops

let Declarations in Loops

const Declarations in Loops

Global Block Bindings

Emerging Best Practices for Block Bindings

Summary

2
STRINGS AND REGULAR EXPRESSIONS

Better Unicode Support

UTF-16 Code Points

The codePointAt() Method

The String.fromCodePoint() Method

The normalize() Method

The Regular Expression u Flag

Other String Changes

Methods for Identifying Substrings

The repeat() Method

Other Regular Expression Changes

The Regular Expression y Flag

Duplicating Regular Expressions

The flags Property

Template Literals

Basic Syntax

Multiline Strings

Making Substitutions

Tagged Templates

Summary

3
FUNCTIONS

Functions with Default Parameter Values

Simulating Default Parameter Values in ECMAScript 5

Default Parameter Values in ECMAScript 6

How Default Parameter Values Affect the arguments Object

Default Parameter Expressions

Default Parameter TDZ

Working with Unnamed Parameters

Unnamed Parameters in ECMAScript 5

Rest Parameters

Increased Capabilities of the Function Constructor

The Spread Operator

The name Property

Choosing Appropriate Names

Special Cases of the name Property

Clarifying the Dual Purpose of Functions

Determining How a Function Was Called in ECMAScript 5

The new.target Metaproperty

Block-Level Functions

Deciding When to Use Block-Level Functions

Block-Level Functions in Non-Strict Mode

Arrow Functions

Arrow Function Syntax

Creating Immediately Invoked Function Expressions

No this Binding

Arrow Functions and Arrays

No arguments Binding

Identifying Arrow Functions

Tail Call Optimization

How Tail Calls Are Different in ECMAScript 6

How to Harness Tail Call Optimization

Summary

4
EXPANDED OBJECT FUNCTIONALITY

Object Categories

Object Literal Syntax Extensions

Property Initializer Shorthand

Concise Methods

Computed Property Names

New Methods

The Object.is() Method

The Object.assign() Method

Duplicate Object Literal Properties

Own Property Enumeration Order

Enhancements for Prototypes

Changing an Object’s Prototype

Easy Prototype Access with Super References

A Formal Method Definition

Summary

5
DESTRUCTURING FOR EASIER DATA ACCESS

Why Is Destructuring Useful?

Object Destructuring

Destructuring Assignment

Default Values

Assigning to Different Local Variable Names

Nested Object Destructuring

Array Destructuring

Destructuring Assignment

Default Values

Nested Array Destructuring

Rest Items

Mixed Destructuring

Destructured Parameters

Destructured Parameters Are Required

Default Values for Destructured Parameters

Summary

6
SYMBOLS AND SYMBOL PROPERTIES

Creating Symbols

Using Symbols

Sharing Symbols

Symbol Coercion

Retrieving Symbol Properties

Exposing Internal Operations with Well-Known Symbols

The Symbol.hasInstance Method

The Symbol.isConcatSpreadable Property

The Symbol.match, Symbol.replace, Symbol.search, and Symbol.split Properties

The Symbol.toPrimitive Method

The Symbol.toStringTag Property

The Symbol.unscopables Property

Summary

7
SETS AND MAPS

Sets and Maps in ECMAScript 5

Problems with Workarounds

Sets in ECMAScript 6

Creating Sets and Adding Items

Removing Items

The forEach() Method for Sets

Converting a Set to an Array

Weak Sets

Maps in ECMAScript 6

Map Methods

Map Initialization

The forEach() Method for Maps

Weak Maps

Summary

8
ITERATORS AND GENERATORS

The Loop Problem

What Are Iterators?

What Are Generators?

Generator Function Expressions

Generator Object Methods

Iterables and for-of Loops

Accessing the Default Iterator

Creating Iterables

Built-In Iterators

Collection Iterators

String Iterators

NodeList Iterators

The Spread Operator and Nonarray Iterables

Advanced Iterator Functionality

Passing Arguments to Iterators

Throwing Errors in Iterators

Generator Return Statements

Delegating Generators

Asynchronous Task Running

A Simple Task Runner

Task Running with Data

An Asynchronous Task Runner

Summary

9
INTRODUCING JAVASCRIPT CLASSES

Class-Like Structures in ECMAScript 5

Class Declarations

A Basic Class Declaration

Why Use the Class Syntax?

Class Expressions

A Basic Class Expression

Named Class Expressions

Classes as First-Class Citizens

Accessor Properties

Computed Member Names

Generator Methods

Static Members

Inheritance with Derived Classes

Shadowing Class Methods

Inherited Static Members

Derived Classes from Expressions

Inheriting from Built-Ins

The Symbol.species Property

Using new.target in Class Constructors

Summary

10
IMPROVED ARRAY CAPABILITIES

Creating Arrays

The Array.of() Method

The Array.from() Method

New Methods on All Arrays

The find() and findIndex() Methods

The fill() Method

The copyWithin() Method

Typed Arrays

Numeric Data Types

Array Buffers

Manipulating Array Buffers with Views

Similarities Between Typed and Regular Arrays

Common Methods

The Same Iterators

The of() and from() Methods

Differences Between Typed and Regular Arrays

Behavioral Differences

Missing Methods

Additional Methods

Summary

11
PROMISES AND ASYNCHRONOUS PROGRAMMING

Asynchronous Programming Background

The Event Model

The Callback Pattern

Promise Basics

The Promise Life Cycle

Creating Unsettled Promises

Creating Settled Promises

Executor Errors

Global Promise Rejection Handling

Node.js Rejection Handling

Browser Rejection Handling

Chaining Promises

Catching Errors

Returning Values in Promise Chains

Returning Promises in Promise Chains

Responding to Multiple Promises

The Promise.all() Method

The Promise.race() Method

Inheriting from Promises

Promise-Based Asynchronous Task Running

Summary

12
PROXIES AND THE REFLECTION API

The Array Problem

Introducing Proxies and Reflection

Creating a Simple Proxy

Validating Properties Using the set Trap

Object Shape Validation Using the get Trap

Hiding Property Existence Using the has Trap

Preventing Property Deletion with the deleteProperty Trap

Prototype Proxy Traps

How Prototype Proxy Traps Work

Why Two Sets of Methods?

Object Extensibility Traps

Two Basic Examples

Duplicate Extensibility Methods

Property Descriptor Traps

Blocking Object.defineProperty()

Descriptor Object Restrictions

Duplicate Descriptor Methods

The ownKeys Trap

Function Proxies with the apply and construct Traps

Validating Function Parameters

Calling Constructors Without new

Overriding Abstract Base Class Constructors

Callable Class Constructors

Revocable Proxies

Solving the Array Problem

Detecting Array Indexes

Increasing length When Adding New Elements

Deleting Elements When Reducing length

Implementing the MyArray Class

Using a Proxy as a Prototype

Using the get Trap on a Prototype

Using the set Trap on a Prototype

Using the has Trap on a Prototype

Proxies as Prototypes on Classes

Summary

13
ENCAPSULATING CODE WITH MODULES

What Are Modules?

Basic Exporting

Basic Importing

Importing a Single Binding

Importing Multiple Bindings

Importing an Entire Module

A Subtle Quirk of Imported Bindings

Renaming Exports and Imports

Default Values in Modules

Exporting Default Values

Importing Default Values

Re-exporting a Binding

Importing Without Bindings

Loading Modules

Using Modules in Web Browsers

Browser Module Specifier Resolution

Summary

A
MINOR CHANGES IN ECMASCRIPT 6

Working with Integers

Identifying Integers

Safe Integers

New Math Methods

Unicode Identifiers

Formalizing the __proto__ Property

B
UNDERSTANDING ECMASCRIPT 7 (2016)

The Exponentiation Operator

Order of Operations

Operand Restriction

The Array.prototype.includes() Method

How to Use Array.prototype.includes()

Value Comparison

A Change to Function-Scoped Strict Mode

INDEX