JavaScript for impatient programmers (ES2021 edition) (Dr. Axel Rauschmayer)（Z-Library）

【One-Line Pitch】 A fast, modern, and opinionated tour of JavaScript for people who already know how to program but want to skip the legacy baggage and learn the language as it is written today. Best for developers coming from another language, or self-taught JS users who want to fill in gaps and understand *why* the language behaves the way it does. 【Book Arc】 - **Opening (~0%–10%)**: Orients you with the book's philosophy — learn modern features first, treat JavaScript as an unconventional language worth understanding rather than memorizing — and surveys recent ECMAScript additions (ES2017–ES2019) so you know what "modern" means here. - **Early (~10%–30%)**: Builds the foundation: syntax overview, statements vs. expressions, the console API, and how to run the book's quizzes and exercises. Then moves into variables, `const`/`let` rules, scope, closures, and the primitive value types including numbers and their floating-point quirks. - **Middle (~30%–50%)**: Deepens the data-model layer — bigints for arbitrary-precision integers, strings and their methods, and template literals including tagged and raw string literals. This is where the "optional advanced sections" pattern becomes visible. - **Late (~50%–80%)**: Moves into the collection and iteration machinery: Arrays (including iteration/transformation methods like `.map()`, `.filter()`, `.find()`, and `.sort()`), Typed Arrays for binary data, Maps, WeakMaps, Sets, WeakSets, and destructuring. - **Ending (~80%–100%)**: The excerpts do not cover the closing chapters in detail, but the table of contents indicates the book continues through the remaining essential language features and quick-reference material. 【Key Takeaways】 - **Modern-first pedagogy** (Opening): The book deliberately front-loads contemporary syntax and features rather than walking through JavaScript's historical evolution, which makes it faster for experienced programmers but means you may need to look elsewhere for legacy patterns. (Opening) - **JavaScript is unconventional beneath conventional syntax** (Early): The author explicitly warns that C-style syntax hides a very unusual language, and urges readers to learn the quirks and their rationales rather than just the surface grammar. (Early) - **Simple rules of thumb over exhaustive rules** (Early): The book teaches safety heuristics — e.g., "always use `===`, never `==`" — alongside the details, which is useful for readers who want to write correct code before they fully understand the edge cases. (Early) - **`const` by default, `let` only when needed** (Early): The recommendation is to prefer `const` for immutable bindings and reserve `let` for variables whose values actually change; `const` works naturally with `for-of` loops but not plain `for` loops. (Early) - **Closures are functions plus their birth-scope connections** (Early): The book frames closures through bound vs. free variables, explaining that a closure retains access to the variables that existed where it was created — a foundational concept for understanding scope and factory functions. (Early) - **Numbers have real precision limits** (Early): JavaScript uses 64-bit floating point for both integers and floats, with safe integers limited to 53 bits plus sign; bigints (ES2020) exist precisely to go beyond that range, but they don't interoperate freely with numbers or JSON. (Early/Middle) - **Collections go beyond plain objects and arrays** (Late): Maps, Sets, WeakMaps, and WeakSets each solve specific problems — key flexibility, uniqueness, and weak references for garbage collection — and the book treats them as first-class tools, not curiosities. (Late) - **Advanced material is clearly marked and optional** (throughout): Sections tagged "(advanced)" let you skip deeper dives (floating-point internals, WeakMap mechanics, Typed Arrays) on a first pass without losing the thread. (throughout) 【Reading Tips】 - **Skim the syntax overview and ECMAScript feature lists** in the opening chapters if you already write JavaScript; they're orientation, not depth. Slow down at variables, scope, and closures — those chapters carry the most conceptual weight. - **Treat "(advanced)" sections as a second pass.** Read the main text first, finish the book, then return to the advanced sections that matter for your work (e.g., Typed Arrays if you handle binary data, WeakMaps if you manage caches). - **Do the quizzes and exercises** if you have access to them; the book is designed around test-driven reinforcement, and the excerpts show exercises are integrated per-chapter rather than saved for the end. - **Keep a mental list of the "rules of thumb"** the author gives (like `===` over `==`, `const` over `let`) and revisit them after finishing — they become more meaningful once you've seen the edge cases. - **Don't expect framework or DOM coverage.** This is a language book; use it alongside a browser/Node-specific resource if you're building applications. 【Coverage Limits】 This guide is based on stratified excerpts covering roughly the first half of the book (through Sets, WeakSets, and destructuring), plus the table of contents and front matter. The later chapters — including the full treatment of functions, objects, classes, modules, asynchronous programming, and regular expressions — are not represented in the excerpts, so this guide cannot speak to their content or quality.