你不知道的JavaScript（上卷）= You Don’t Know JS Scope closures this object prototypes (Kyle Simpson 赵望野, 梁杰) (Z-Library)

【One-Line Pitch】 A deep-dive into the two most misunderstood corners of JavaScript—scope/closures and `this`/prototypes—that turns "it just works" familiarity into genuine understanding. Best for developers who can ship code but freeze when asked *why* a callback sees the wrong value or why `this` isn't what they expected. 【Book Arc】 - **Opening (~0%–10%)**: Frames the mission—most developers blame the language for behavior they never learned, blacklisting features until only a "safe" subset remains. Establishes that JavaScript is a compiled language and that scope is the rule-set for storing and finding variables. - **Early (~10%–25%)**: Builds the scope foundation: LHS/RHS lookups, the nested "building/bubble" model of lexical scope, and the three scope units—function scope, block scope (`let`/`const`, `try/catch`), and IIFEs. Solves the question of *where variables live and how the engine finds them*. - **Early (~25%–35%)**: Covers hoisting (declarations rise, assignments don't; functions win over variables) and then closure—the payoff of lexical scope—leading into the module pattern and modern module loaders. - **Middle (~35%–55%)**: Shifts to `this`. Debunks the two big myths (that `this` points to the function itself or to its lexical scope), then introduces call-site analysis and the binding rules. - **Late (~55%–end)**: Moves into objects and prototypes—how `new` really differs from class-based languages, hard binding via `bind(..)`, and the "safer this" / DMZ-object technique. Excerpts thin out here, so later prototype-chain material is only lightly represented. 【Key Takeaways】 - **JavaScript is a compiled language, not purely interpreted** (Opening): The engine parses and compiles before executing, which is why hoisting and scope rules exist at all—understanding this reframes "weird" behavior as predictable. - **Scope is a lookup system, and LHS vs. RHS matters** (Early): Assignments (LHS) find a *container*; reads (RHS) find a *value*. Distinguishing them explains reference errors and silent global leaks. - **Lexical scope is fixed at author time** (Early): Nested scopes behave like floors in a building—lookups climb outward and stop at the global scope. `eval` and `with` can cheat this, but doing so is a documented anti-pattern. - **Block scope is real and useful beyond `var`** (Early): `let`/`const` and `try/catch` give finer-grained scope, which also helps garbage collection by not retaining large data longer than needed. - **Hoisting is function-first** (Early): Function declarations are hoisted before variable declarations, so a later `var foo` won't override an earlier `function foo`—a classic source of confusion. - **Closures are the natural consequence of lexical scope** (Early): Once you understand scope, closures stop being magic; the module pattern is just closure applied deliberately, including the ability to mutate a public API from inside. - **`this` is determined by the call site, not where the function is written** (Middle): Four binding rules apply in priority order, and reading the call stack (or a debugger breakpoint) is the reliable way to find the real call location. - **Arrow functions abandon `this` binding entirely** (Middle): They inherit `this` lexically, which is why they "fix" the `var self = this` problem—but also why they behave unlike normal functions. 【Reading Tips】 - **Deep-read the scope chapters (Opening–Early)**: They are the prerequisite for everything else; skimming here makes closures and `this` feel arbitrary. - **Skim the acknowledgments and front matter**: The excerpted material includes long contributor lists and publishing details that carry no technical content. - **Treat `this` as a decision tree, not a vibe**: When confused, locate the call site first, then apply the binding rules in order—this is the book's core method. - **Run the examples yourself**: Many snippets target ES6-era engines; testing them (and their pre-ES6 polyfill equivalents) cements the mental model. - **Take away the "why," not the syntax**: The book's value is a durable mental model that outlives any framework. 【Coverage Limits】 The excerpts cover scope, closures, hoisting, and the early `this`/binding material well, but the later object/prototype chapters are only lightly represented, so this guide cannot detail the full prototype chain or `new`-vs-class mechanics.