JavaScript

ALL OF JAVASCRIPT'S NEWEST FEATURES, IN DEPTH, MADE EASY TO UNDERSTAND.

JavaScript is a rapidly changing language and it can be challenging to keep up with all the new toys being added. JavaScript: The New Toys explores the newest features of the world's most popular programming language while also showing readers how to track what's coming next. After setting the stage by covering who manages the process of improving JavaScript, how new features get introduced, terminology, and a high-level overview of new features, it details each new or updated item in depth, with example uses, possible pitfalls, and expert recommendations for updating old habits in light of new features. JavaScript: The New Toys:

* Covers all the additions to JavaScript in ES2015-ES2020 plus a preview of what's coming next
* Explores the latest syntax: nullish coalescing, optional chaining,

```let```

and

```const```

,

```class```

syntax, private methods, private fields,

```new.target```

, numeric separators, BigInt, destructuring, default parameters, arrow functions,

```async```

functions,

```await```

, generator functions,

```...```

(rest and spread), template literals, binary and octal literals,

```**```

(exponentiation), computed property/method names,

```for-of```

,

```for-await-of```

, shorthand properties, and others
* Details the new features and patterns including modules, promises, iteration, generators, Symbol, Proxy, reflection, typed arrays, Atomics, shared memory, WeakMap, WeakSet, and more
* Highlights common pitfalls and explains how to avoid them
* Shows how to follow the improvements process and even participate in the process yourself
* Explains how to use new features even before they're widely supported

With its comprehensive coverage and friendly, accessible style, JavaScript: The New Toys provides an invaluable resource for programmers everywhere, whether they work in web development, Node.js, Electron, Windows Universal Apps, or another JavaScript environment.

About the author

T.J. CROWDER is a software engineer with 30 years of experience, including over 15 years of professional work in JavaScript. He runs Farsight Software, a software contracting and product company. He's often found helping people on Stack Overflow, where he's a top 10 all-time contributor and the top JavaScript contributor. When not working or writing, he…no, sorry, he's always working or writing – or spending time with his wonderful, supportive wife and fantastic son.

Visit us at www.wiley.com for free code samples.

Introduction xxxi

CHAPTER 1: THE NEW TOYS IN ES2015–ES2020, AND BEYOND 1

Definitions, Who’s Who, and Terminology 2

What are the “New Toys”? 4

How Do New Toys Get Created? 6

Keeping Up with the New Toys 9

Using Today’s Toys in Yesterday’s Environments, and Tomorrow’s Toys Today 10

Review 15

CHAPTER 2: BLOCK-SCOPED DECLARATIONS: LET AND CONST 17

An Introduction to let and const 18

True Block Scope 18

Repeated Declarations are an Error 19

Hoisting and the Temporal Dead Zone 20

A New Kind of Global 22

const: Constants for JavaScript 24

Block Scope in Loops 26

Old Habits to New 36

CHAPTER 3: NEW FUNCTION FEATURES 39

Arrow Functions and Lexical this, super, etc. 40

Default Parameter Values 45

“Rest” Parameters 50

Trailing Commas in Parameter Lists and Function Calls 52

The Function name Property 53

Function Declarations in Blocks 55

Function Declarations in Blocks: Standard Semantics 57

Old Habits to New 60

CHAPTER 4: CLASSES 65

What is a Class? 66

Introducing the New class Syntax 66

Comparing with the Older Syntax 75

Creating Subclasses 77

Leaving Off Object.prototype 97

new.target 98

class Declarations vs. class Expressions 101

More to Come 103

Old Habits to New 104

CHAPTER 5: NEW OBJECT FEATURES 105

Computed Property Names 106

Shorthand Properties 107

Getting and Setting an Object’s Prototype 107

Method Syntax, and super Outside Classes 109

Symbol 112

New Object Functions 120

Symbol.toPrimitive 123

Property Order 125

Property Spread Syntax 127

Old Habits to New 128

CHAPTER 6: ITERABLES, ITERATORS, FOR-OF, ITERABLE SPREAD, GENERATORS 131

Iterators, Iterables, the for-of Loop, and Iterable Spread Syntax 131

Generator Functions 146

Old Habits to New 163

CHAPTER 7: DESTRUCTURING 165

Overview 165

Basic Object Destructuring 166

Basic Array (and Iterable) Destructuring 169

Defaults 170

Rest Syntax in Destructuring Patterns 172

Using Different Names 173

Computed Property Names 174

Nested Destructuring 174

Parameter Destructuring 175

Destructuring in Loops 178

Old Habits to New 179

CHAPTER 8: PROMISES 181

Why Promises? 182

Promise Fundamentals 182

Using an Existing Promise 186

Adding Handlers to Already Settled Promises 201

Creating Promises 202

Other Promise Utility Methods 207

Promise Patterns 210

Handle Errors or Return the Promise 210

Promises in Series 211

Promises in Parallel 213

Promise Subclasses 218

Old Habits to New 219

CHAPTER 9: ASYNCHRONOUS FUNCTIONS, ITERATORS, AND GENERATORS 221

async Functions 222

async Iterators, Iterables, and Generators 232

for-await-of 238

Old Habits to New 238

CHAPTER 10: TEMPLATES, TAG FUNCTIONS, AND NEW STRING FEATURES 241

Template Literals 241

Improved Unicode Support 250

Iteration 255

New String Methods 256

Updates to the match, split, search, and replace Methods 259

Old Habits to New 260

CHAPTER 11: NEW ARRAY FEATURES, TYPED ARRAYS 263

New Array Methods 264

Iteration, Spread, Destructuring 276

Stable Array Sort 276

Typed Arrays 277

Old Habits to New 292

CHAPTER 12: MAPS AND SETS 293

Maps 293

Sets 300

WeakMaps 304

WeakSets 314

Old Habits to New 316

CHAPTER 13: MODULES 319

Introduction to Modules 319

Module Fundamentals 320

Renaming Exports 331

Re-Exporting Exports from Another Module 332

Renaming Imports 333

Importing a Module’s Namespace Object 333

Exporting Another Module’s Namespace Object 334

Importing a Module Just for Side Effects 335

Import and Export Entries 335

Imports are Live and Read-Only 338

Module Instances are Realm-Specific 340

How Modules are Loaded 341

Import/Export Syntax Review 348

Dynamic Import 350

Tree Shaking 357

Bundling 359

Import Metadata 360

Worker Modules 360

Old Habits to New 362

CHAPTER 14: REFLECTION—REFLECT AND PROXY 365

Reflect 365

Proxy 371

Old Habits to New 395

CHAPTER 15: REGULAR EXPRESSION UPDATES 397

The Flags Property 398

New Flags 398

Named Capture Groups 400

Lookbehind Assertions 405

Unicode Features 408

Old Habits to New 413

CHAPTER 16: SHARED MEMORY 417

Introduction 417

Here There Be Dragons! 418

Browser Support 418

Shared Memory Basics 420

Memory is Shared, Not Objects 426

Race Conditions, Out-of-Order Stores, Stale Values, Tearing, and More 427

The Atomics Object 429

Shared Memory Example 434

Here There Be Dragons! (Again) 455

Old Habits to New 460

CHAPTER 17: MISCELLANY 461

BigInt 462

New Integer Literals 465

New Math Methods 467

Exponentiation Operator (**) 468

Date.prototype.toString Change 470

Function.prototype.toString Change 471

Number Additions 471

Symbol.isConcatSpreadable 474

Various Syntax Tweaks 475

Various Standard Library / Global Additions 479

Annex B: Browser-Only Features 482

Tail Call Optimization 488

Old Habits to New 491

CHAPTER 18: UPCOMING CLASS FEATURES 493

Public and Private Class Fields, Methods, and Accessors 493

Old Habits to New 514

CHAPTER 19: A LOOK AHEAD . . .517

Top-Level await 518

WeakRefs and Cleanup Callbacks 525

RegExp Match Indices 533

String.prototype.replaceAll 535

Atomics asyncWait 535

Various Syntax Tweaks 536

Legacy Deprecated RegExp Features 537

Thank You for Reading! 538

APPENDIX: FANTASTIC FEATURES AND WHERE TO FIND THEM 539

Index 557