The New Toys
Wiley (Verlag)
  • 1. Auflage
  • |
  • erschienen am 30. Juni 2020
  • |
  • 608 Seiten
E-Book | ePUB mit Adobe-DRM | Systemvoraussetzungen
978-1-119-36796-3 (ISBN)
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-ES2019 plus a preview of ES2020 (and beyond)
* Explores the latest syntax: nullish coalescing, optional chaining, let and const, class syntax, private methods, private fields,, 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.
weitere Ausgaben werden ermittelt
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,, sorry, he's always working or writing - or spending time with his wonderful, supportive wife and fantastic son.

Visit us at for free code samples.


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, where I continue covering new features as they're added.


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 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.


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.


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

for (let i = 0; i < 10; ++i) { /*.*/ setTimeout(() => console.log(i)); }

creates ten different variables called i, and why using

let a = "ay"; var b = "bee";

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...

Dateiformat: ePUB
Kopierschutz: Adobe-DRM (Digital Rights Management)


Computer (Windows; MacOS X; Linux): Installieren Sie bereits vor dem Download die kostenlose Software Adobe Digital Editions (siehe E-Book Hilfe).

Tablet/Smartphone (Android; iOS): Installieren Sie bereits vor dem Download die kostenlose App Adobe Digital Editions (siehe E-Book Hilfe).

E-Book-Reader: Bookeen, Kobo, Pocketbook, Sony, Tolino u.v.a.m. (nicht Kindle)

Das Dateiformat ePUB ist sehr gut für Romane und Sachbücher geeignet - also für "fließenden" Text ohne komplexes Layout. Bei E-Readern oder Smartphones passt sich der Zeilen- und Seitenumbruch automatisch den kleinen Displays an. Mit Adobe-DRM wird hier ein "harter" Kopierschutz verwendet. Wenn die notwendigen Voraussetzungen nicht vorliegen, können Sie das E-Book leider nicht öffnen. Daher müssen Sie bereits vor dem Download Ihre Lese-Hardware vorbereiten.

Bitte beachten Sie bei der Verwendung der Lese-Software Adobe Digital Editions: wir empfehlen Ihnen unbedingt nach Installation der Lese-Software diese mit Ihrer persönlichen Adobe-ID zu autorisieren!

Weitere Informationen finden Sie in unserer E-Book Hilfe.

Download (sofort verfügbar)

25,99 €
inkl. 5% MwSt.
Download / Einzel-Lizenz
ePUB mit Adobe-DRM
siehe Systemvoraussetzungen
E-Book bestellen