You Dont Know JS Types Grammar (Kyle Simpson)（Z-Library）

【One-Line Pitch】 A compact, opinionated deep dive into JavaScript’s type system and syntax that explains why coercion, primitives, and grammar quirks behave the way they do. Read it if you already write JavaScript daily but still flinch at `NaN`, `typeof null`, or `[] + {}`. 【Book Arc】 - **Opening (~0%–10%)**: Frames the book’s premise — most developers avoid or misunderstand JS types — and sets up the seven built-in types plus the `typeof` operator, including its famous `null` bug. - **Early (~10%–32%)**: Walks through primitives in detail: `undefined` vs. undeclared (and the `typeof` safety guard), array-likes and conversion, numeric literals in multiple bases, IEEE 754 floating-point pitfalls, and special values like `NaN`, `Infinity`, and `-0`. - **Middle (~32%–48%)**: Covers value vs. reference semantics, then the native constructors (`String`, `Number`, `Boolean`, `Object`, `Function`, `RegExp`, `Date`, `Error`), boxing/unboxing via `valueOf()`, and when constructor forms are actually justified. - **Late (~48%–75%)**: Moves into the coercion controversy — abstract operations like `ToInt32`, implicit vs. explicit conversion, and how coercion shows up in comparisons and arithmetic. - **Ending (~75%–100%)**: Explores grammar nuances: statements vs. expressions, operator precedence, automatic semicolon insertion, and other syntax corners that trip up even experienced developers. 【Key Takeaways】 - **JavaScript has seven built-in types, but `typeof` doesn’t map 1-to-1** (Opening): `typeof null === "object"` is a two-decade-old bug you must memorize, not fix. (Opening) - **`typeof` on an undeclared variable is a safety guard, not a bug** (Early): It returns `"undefined"` instead of throwing `ReferenceError`, which is genuinely useful for feature detection and global flags like `DEBUG`. (Early) - **All JS numbers are 64-bit floats — “integers” are just floats without a fractional part** (Early): This explains `0.1 + 0.2 !== 0.3`, `NaN`’s self-inequality, `Infinity / Infinity === NaN`, and the existence of `-0`. (Early) - **Primitives are passed by value-copy; objects by reference-copy** (Middle): Boxing a primitive in `new Number(..)` does not let you mutate the shared primitive — a common misconception worth internalizing. (Middle) - **Object wrappers around primitives are usually a trap** (Middle): `new Boolean(false)` is truthy, so `if (!a)` never runs. Prefer `Object(..)` for explicit boxing and `valueOf()` for unboxing. (Middle) - **Most native constructors have no good reason to exist** (Middle): `new Object()`, `new Function(..)`, and `new Array(..)` are almost always worse than literals; `RegExp(..)` and `Date(..)` are the exceptions with real use cases. (Middle) - **Coercion is a feature, not a flaw** (Late): Understanding abstract operations like `ToInt32` and implicit conversion lets you use coercion deliberately rather than fearing it. (Late) - **Grammar details — statements vs. expressions, ASI, precedence — cause real bugs** (Ending): These are the corners most developers never formally learn, and where subtle production issues hide. (Ending) 【Reading Tips】 - **Skim the preface and conventions** (~0%–10%); the real content starts with the built-in types chapter. - **Deep-read the numbers and special-values sections** (~19%–32%): `NaN`, `-0`, and floating-point behavior are the highest-yield material for day-to-day debugging. - **Treat the natives chapter as a reference** (~39%–48%): You don’t need to memorize every constructor, but note which ones have legitimate uses (`RegExp`, `Date`, `Error`). - **Slow down on coercion and grammar** (~48%–100%): These are the chapters that change how you read other people’s code; expect to re-read examples. - **Keep a console open**: Every claim in this book is verifiable in a browser or Node REPL — test as you go. 【Coverage Limits】 The excerpts cover the book’s opening through roughly the middle, with only brief glimpses of the coercion and grammar chapters; specific examples and chapter-level detail from the later half are not fully represented here.