JavaScript权威指南（原书第7版）（经典的JavaScript犀牛书全新升级） (OReilly精品图书系列) (大卫·弗拉纳根(David Flanagan) 李松峰 [译])（Z-Library）

# JavaScript: The Definitive Guide (7th Edition) — Reading Guide ## 【One-Line Pitch】 The definitive reference for JavaScript, covering everything from language fundamentals to advanced metaprogramming and browser APIs — essential for any developer who wants to truly master the language rather than just use it. ## 【Book Arc】 - **Opening (~0%–7%)**: JavaScript types, values, and variables — the foundation of the language, including numbers, strings, null/undefined, and the pitfalls of floating-point arithmetic and Unicode normalization. - **Early (~7%–27%)**: Operators, expressions, and statements — from logical operators and operator precedence to control flow, plus the essentials of object literals and array basics. - **Early–Middle (~27%–47%)**: Functions and objects in depth — closures, functional programming techniques, classes and prototypes, modules, and collections like Set and Map. - **Middle (~47%–60%)**: Working with data and asynchronous programming — regular expressions, JSON serialization, iterators, callbacks, and the full promise-based async model. - **Late (~60%–67%)**: Metaprogramming and the browser environment — property attributes, proxies, reflection, and the Document Object Model (DOM) for client-side JavaScript. - **Ending (~67%+)**: Advanced browser APIs — events, DOM manipulation, and Canvas graphics for building rich web applications. ## 【Key Takeaways】 - **Floating-point arithmetic is approximate** (Early): JavaScript uses IEEE-754 binary floats, so values like 0.1 cannot be represented exactly — never compare floats for equality; use integers (e.g., cents) for financial calculations. - **null and undefined are distinct but often interchangeable** (Early): undefined means "not initialized" while null means "no value" — use `===` to distinguish them, and prefer null for intentional "no value" assignments. - **Short-circuit evaluation powers idiomatic JavaScript** (Early): The `&&` and `||` operators don't just return booleans — they return operand values, enabling patterns like `book && book.author` for safe property access. - **Functions are the core building block** (Early): JavaScript functions are objects that can be assigned, passed, and nested — this enables closures, namespacing via IIFEs, and functional programming with `map()` and `reduce()`. - **Prototypes make classes dynamic** (Middle): JavaScript's prototype-based inheritance means you can add methods to existing classes at runtime — a powerful technique for polyfilling new features in older environments. - **Sets are optimized for membership testing** (Middle): `Set.has()` is fast regardless of set size, unlike `Array.includes()` which slows down with larger arrays — use Sets when membership checks are frequent. - **Promises solve callback hell** (Middle): Promise chains with `.then()` and `.catch()` provide a cleaner async model than nested callbacks, and `promiseSequence()` patterns enable elegant sequential async operations. - **Proxies enable metaprogramming** (Late): Proxy objects can intercept and customize operations on target objects — useful for creating read-only wrappers, logging, and testing frameworks. ## 【Reading Tips】 - **Skim the early type chapters** (~0%–7%) if you're already familiar with JavaScript basics — but don't skip the sections on floating-point precision and Unicode normalization, as these cause real-world bugs. - **Deep-read the function and object chapters** (~27%–47%) — closures, `this` binding, and prototype chains are the hardest concepts for most developers and form the foundation for everything else. - **Pay special attention to the async chapters** (~47%–60%) — promises and async/await are critical for modern JavaScript; the book's promise chain diagrams are worth studying carefully. - **Use the metaprogramming chapter** (~60%) as a reference rather than reading it cover-to-cover — proxies and reflection are advanced topics you'll only need when building libraries or frameworks. - **Keep this book as a reference** — it's not meant to be read once; the detailed API coverage makes it invaluable for looking up specific methods and behaviors as you encounter them. ## 【Coverage Limits】 This guide synthesizes the first ~67% of the book, covering language fundamentals through DOM and Canvas APIs. The final third (advanced browser APIs, storage, networking, and worker threads) is not covered in the available excerpts. ##