The JavaScript language was born a chimera. Fortunately, it was born to a web browser, which let JavaScript spread much further and faster than its virtues otherwise suggested. Nevertheless, JavaScript’s monstrous nature had to be dealt with, which was done primarily in two approaches: through rose-colored glasses (for example, [1]) or through revision and standardization. This book describes the recent results of the latter approach, ECMAScript 6.

The 22 chapters in this book can be divided into three parts: an introductory part, a second part on language features, and a third part on advanced JavaScript. The introductory part has two chapters. The first chapter introduces JavaScript via the usual “Hello World!” program. The second chapter describes setting up a basic JavaScript development environment, including the npm package manager, the gulp build tool, and the babal transcompiler. The book’s second part describes JavaScript’s major features, one feature per chapter: variables (chapter 3), expressions (chapter 5), scope (chapter 7), objects (chapter 9), iterators and generators (chapter 12), and so on. The third part of the book describes advanced JavaScript aspects such as idioms (functional abstraction and asynchronous programming, chapters 13 and 14), libraries (math, regular expressions, and JQuery, chapters 16, 17, and 19) and tools (the browser and the node host execution environments, chapters 18 and 20). Two appendices present JavaScript keywords and operator precedence.

The index is complete with the occasional exception (for example, the delete operator referenced in chapter 5 and described in chapter 3 isn’t indexed). The book isn’t a cookbook; there are code fragments on almost every page, but few running examples either within or across chapters. The code isn’t indexed, nor is it officially available on the Internet. The final chapter provides references and further resources that are as complete as can be expected for moving targets like JavaScript and its development practices. Selected chapters also end with references to follow-up material.

There is no orientation toward either side of the client-server architecture.

The chapters on the typical browser environment and the node ecosystem are overviews providing brief introductions. Apart from suggestions for exploration and experiment, there are no exercises or problems. The book recommends readers sit in front of a JavaScript REPL and try out examples and suggestions. There is an errata section on the publisher’s website, as there are for earlier book editions, so make sure you understand which one you’re looking at.

The JavaScript described by the book is ECMAScript 6 (EC6), a version of the standard ahead of the state of practice described by most browsers, which more or less faithfully implement ECMAScript 5 (EC5). Readers seriously engaging this book should be willing to either commit to EC6, to move from EC5 to EC6, or to compile EC6 to EC5, which the book describes how to do. There seems to be a bias toward EC6 features implemented in browsers. For example, there is no mention of tail-call optimizations; the book describes only the node module system, which is different from the EC6 module system; and proxies are covered, but the reflection application programming interface (API) isn’t. Sticking to browser-implemented features seems reasonable, but browsers develop toward more complete coverage over time, and some transcompilers, such as babel, handle some of these features.

The book reads best as an introduction to the JavaScript language. Readers are assumed to know programming, but not necessarily JavaScript. Readers familiar with JavaScript will note the book hits the highlights--truthiness and equality, arrays, iterating over object properties, capturing loop-index values in closures, class definition and instantiation, and so on--and, where appropriate, how EC6 provides amelioration. The writing is smooth and readable (although there appears to be a disastrous cut-and-paste error on page 132, where a couple of sections are about strings and characters instead of arrays and elements, the chapter subject). The author is particularly good at slipping JavaScript gotchas into the examples; the active reader quickly learns to be less complacent when keyboarding through the examples in a REPL.

Novice programmers should steer clear of this book because it’s not primarily about programming, but instead the JavaScript language. Experienced programmers wanting to learn JavaScript are this book’s sweet spot. However, the book provides only a cursory introduction to other parts of the JavaScript environment, and those also interested in JavaScript development will have to branch out from this book to other material (for which the book provides some guidance). Experienced JavaScript programmers wanting to move on to EC6 will likely find the book protracted, redundant, and incomplete.

More reviews about this item: Amazon