Deep JavaScript Theory and techniques (Axel Rauschmayer) (Z-Library)

【One-Line Pitch】 A spec-grounded tour of JavaScript's trickiest corners—coercion, destructuring, property attributes, and shared mutable state—for developers who want to stop guessing how the language behaves and start reasoning about it from first principles. Best suited to intermediate-to-advanced JS programmers willing to read algorithms, not just recipes. 【Book Arc】 - **Opening (~0%–10%)**: Frames the book's philosophy—language-only, spec-anchored, selective rather than exhaustive—and sets up the ECMAScript specification as a readable reference rather than an intimidating document. - **Early (~10%–32%)**: Builds the type-and-value foundation: how coercion actually works (ToPrimitive, ToNumeric, abstract equality), the destructuring pattern-matching algorithm, global variables and lexical environments, and the remainder-vs-modulo distinction. - **Middle (~32%–48%)**: Moves into data handling: copying objects and Arrays (shallow vs. deep, property attributes, getters/setters), destructive vs. non-destructive updating, and the problems of shared mutable state with strategies to avoid them. - **Late (~48%+)**: Shifts to object internals—property attributes, descriptors, `Object.defineProperty`, `Object.getOwnPropertyDescriptors()`, cloning, and the pitfalls of copying methods that rely on `super`. - **Ending**: The excerpts do not cover the closing chapters, so the book's final synthesis and any forward-looking material on language trends cannot be summarized here. 【Key Takeaways】 - **Coercion is an algorithm, not magic** (Early): `ToPrimitive`, `OrdinaryToPrimitive`, and the `hint` parameter explain why `+`, `==`, and `String()` behave the way they do—and why `Symbol.toPrimitive` lets objects override conversion. - **`%` is remainder, not modulo** (Early): JavaScript's `%` uses `Math.trunc`-style integer division, so negative operands give different results than Python's `mod`; the book shows both implementations side by side. - **Destructuring is pattern matching with precise rules** (Early): Empty object patterns throw on `null`/`undefined`, empty Array patterns require iterables, and default values interact with the algorithm in ways that surprise even experienced developers. - **Global variables live in two records** (Early): The declarative environment record and the object environment record can both hold a binding, and the declarative one wins—explaining why `globalThis` and bare identifiers can diverge. - **Copying is shallow and lossy by default** (Middle): Spread copies values but not property attributes; getters become plain values, setters vanish, and nested objects are shared—`Object.getOwnPropertyDescriptors()` plus `Object.create()` is the faithful alternative. - **Shared mutable state is the root problem** (Middle): The book frames it as overlapping lifetimes plus multiple writers, then offers three remedies—defensive copying, non-destructive updating, and immutability—with libraries like Immutable.js and Immer as practical tools. - **Property attributes are the hidden layer** (Late): `writable`, `enumerable`, and `configurable` determine what copying, cloning, and `defineProperty` actually do; omitting them in descriptors has operation-specific consequences. - **Methods using `super` cannot be freely copied** (Late): They are bound to their home object, a concrete pitfall when cloning or moving methods between objects. 【Reading Tips】 - **Deep-read the coercion and destructuring chapters** (Early): These are the book's most algorithm-heavy sections and repay slow reading with lasting intuition; skim the spec-translation intermissions if you already know the spec. - **Treat the remainder-vs-modulo chapter as a short, high-value detour** (Early): It is self-contained and immediately useful for anyone doing arithmetic with negative numbers. - **Use the copying and shared-state chapters as a practical checklist** (Middle): Before reaching for a library, understand the three avoidance strategies the book lays out—they generalize beyond any specific tool. - **Read the property-attributes material with a REPL open** (Late): Descriptors and `defineProperty` are best understood by experimenting with `getOwnPropertyDescriptors` on real objects. - **Skip the frontmatter and purchasing details** (Opening): They are administrative and add nothing to the technical content. 【Coverage Limits】 This guide is based on stratified excerpts covering roughly the first half of the book; later chapters and the book's conclusion are not represented, so the arc beyond property attributes is inferred only from the table of contents.