INTRODUCTION

THIS BOOK IS FOR ANY JAVASCRIPT (OR TYPESCRIPT) programmer who wants to get up to speed on the latest features added to JavaScript in the last few years, and who wants to know how to stay informed as the language continues to evolve and grow. You can find nearly all of the information in this book somewhere on the web if you look hard enough and you're cautious about what sites you trust; this book provides all of the technical details in one place, along with showing you how to keep track of the changes as they continue to be made. You can continue to stay up-to-date via the book's website at https://thenewtoys.dev, where I continue covering new features as they're added.

WHAT DOES THIS BOOK COVER?

Here's a glance at what's in each chapter:

• Chapter 1: The New Toys in ES2015-ES2020, and Beyond - begins with introducing various players in the JavaScript world and some important terminology. Then it describes the definition of "The New Toys" for the purposes of the book; covers the way new features are added to JavaScript, how that process is managed, and by whom; and explains how to follow and participate in that process. It finishes by introducing some tools for using the new toys in older environments (or using the very newest toys in current environments).
• Chapter 2: Block-Scoped Declarations: let and const - covers the new declaration keywords let and const and the new scoping concepts they support, including in-depth coverage of scoping in loops, particularly the new handling in for loops.
• Chapter 3: New Function Features - covers the variety of new features related to functions: arrow functions, default parameter values, rest parameters, the name property, and various syntax improvements.
• Chapter 4: Classes - covers the new class feature: the basics, what it is and what it isn't, subclassing, super, subclassing built-ins like Array and Error, and the new.target feature. Chapter 4 leaves coverage of private fields and other features making their way through the proposals process to Chapter 18.
• Chapter 5: New Object Features - covers computed property names, shorthand properties, getting and setting an object's prototype, the new Symbol type and how it relates to objects, method syntax, property order, property spread syntax, and a host of new object functions.
• Chapter 6: Iterables, Iterators, for-of, Iterable Spread, Generators - covers iteration, a powerful new tool for collections and lists, and generators, a powerful new way to interact with functions.
• Chapter 7: Destructuring - covers this important new syntax and how to use it to extract data from objects and from arrays and other iterables, with defaults, deep picking, and more.
• Chapter 8: Promises - dives deep into this important new tool for coping with asynchronous processes.
• Chapter 9: Asynchronous Functions, Iterators, and Generators - goes into detail about the new async/ await syntax that lets you use familiar logical flow structures with asynchronous code, as well as how asynchronous iterators and generators work and the new for-await-of loop.
• Chapter 10: Templates, Tag Functions, and New String Features - describes template literal syntax, tag functions, and lots of new string features like better Unicode support, updates to familiar methods, and lots of new methods.
• Chapter 11: New Array Features, Typed Arrays - covers the wide range of new array methods, various other array updates, typed arrays such as Int32Array, and advanced features for interacting with typed array data.
• Chapter 12: Maps and Sets - teaches you all about the new keyed collections Map and Set, and also their "weak" cousins WeakMap and WeakSet.
• Chapter 13: Modules - is a deep dive into this exciting and powerful way to organize your code.
• Chapter 14: Reflection-Reflect and Proxy - covers the powerful new dynamic metaprogramming features of the Reflect and Proxy objects and how they relate to one another.
• Chapter 15: Regular Expression Updates - describes all of the updates to regular expressions that have been done the past several years such as new flags, named capture groups, lookbehind assertions, and new Unicode features.
• Chapter 16: Shared Memory - covers the complex and potentially difficult area of sharing memory across threads in a JavaScript program, including covering SharedArrayBuffer and the Atomics object as well as fundamental concepts and notes on pitfalls.
• Chapter 17: Miscellany - covers a wide range of things that didn't quite fit in elsewhere: BigInt, the new integer literal syntaxes (binary, new octal), optional catch bindings, new math methods, the exponentiation operator, various additions to the Math object (no pun!), tail call optimization, nullish coalescing, optional chaining, and "Annex B" (browser-only) features defined for compatibility reasons.
• Chapter 18: Upcoming Class Features - takes us a bit into the future, describing enhancements to classes that haven't quite been finished yet but which are far along in the process: public field declarations, private fields, and private methods.
• Chapter 19: A Look Ahead . - winds up with looking forward to some further enhancements currently in the pipeline: top-level await, WeakRefs and cleanup callbacks, RegExp match indices, Atomics.asyncWait, a couple of new syntax features, legacy RegExp features, and various upcoming standard library additions.
• Appendix: Fantastic Features and Where to Find Them - (with apologies to J.K. Rowling) provides lists of the new toys and tells you which chapter covers each of them. The lists are: Features in Alphabetical Order; New Fundamentals; New Syntax, Keywords, Operators, Loops, and Similar; New Literal Forms; Standard Library Additions and Changes; and Miscellaneous.

WHO SHOULD READ THIS BOOK

You should read this book if:

• You have at least a basic understanding of JavaScript, and
• You want to learn the new features added in the last several years.

This isn't an academic book just for experts. It's a pragmatic book for everyday JavaScript programmers.

Almost anyone picking up this book is already going to know some of what's in it, and almost no one picking up this book will already know all of it. Maybe you're already clear on the basics of let and const, but you don't quite get async functions yet. Maybe promises are old hat to you, but you saw some syntax you didn't recognize in some modern code you ran across. You'll find all of it from ES2015 through ES2020 (and beyond) covered here.

HOW TO USE THIS BOOK

Read Chapter 1. Chapter 1 defines a lot of terms I use throughout the rest of the book. Skipping Chapter 1 will likely trip you up.

After that, you have a choice to make: read the chapters in order, or jump around?

I've laid out the chapters in the order I have for a reason; and I build on the content of earlier chapters in later chapters. For instance, you'll learn about promises in Chapter 8, which is important to understanding async functions in Chapter 9. Naturally, I suggest reading them in the order I've arranged them. But I bet you're a smart person who knows their own mind; if you jump around instead, you'll be just fine.

I do suggest that you read-or at least skim-all of the chapters (with the possible exception of Chapter 16; more on that in a minute). Even if you think you know a feature, there's probably something here that you don't know, or only think you know. For instance: maybe you're planning to skip Chapter 2 because you already know all there is to know about let and const. Maybe you even know why

creates ten different variables called i, and why using

at global scope creates a window.b property but doesn't create a window.a property. Even if you do, I'd skim Chapter 2 just to be sure there aren't other wrinkles you haven't picked up.

Chapter 16 is a bit of a special case: it's about sharing memory between threads. Most JavaScript programmers don't need to share memory between threads. Some of you will, and that's why Chapter 16 is there, but most won't and if you're in that category, just tuck away the fact that if you think you need shared memory at some point in the future...