Node.js in Practice (Alex R. Young, Marc Harter)（Z-Library）

【One-Line Pitch】 A problem/solution cookbook of 115 tested Node.js techniques that turns working JavaScript knowledge into production-ready Node skills, from event loops and buffers to streams, modules, and deployment. Best for developers who already know basic Node and want field-tested answers to everyday problems. 【Book Arc】 - **Opening (~0%–10%)**: Sets up the book's Problem/Solution format and gets you building a real project—creating a project with `npm init`, writing a `package.json`, and implementing a first custom stream class. - **Early (~10%–30%)**: Covers Node's built-in environment: globals like `process` and `Buffer`, module installation and loading with `npm`/`require`, standard I/O and exit codes, and binary data handling including parsing binary specs and designing a custom network protocol. - **Early–Middle (~30%–40%)**: Dives into event-based programming with `EventEmitter`—listener management, `newListener`, alternatives to `EventEmitter`, and pitfalls of managing many event names. - **Middle (~40%–55%)**: Tackles streams, framed as Node's most powerful and misunderstood feature: built-in streams, readable/writable/duplex/transform classes, inheritance patterns, and practical uses like a static web server. - **Late (~55%–85%)**: (Excerpts do not cover this range in detail.) Based on the book's stated contents, this stage addresses testing, debugging, integrating Node with external systems, and deployment. - **Ending (~85%–100%)**: (Excerpts do not cover this range.) Presumably consolidates integration and deployment techniques into a production workflow. 【Key Takeaways】 - **The Problem/Solution format is the book's core structure** (Opening): each of the 115 techniques states a problem, gives a tested solution, then discusses trade-offs—making it a reference you can jump into rather than a linear tutorial. - **`npm` is a project-management tool, not just an installer** (Opening): using `npm init` and `package.json` early makes even small scripts reproducible and portable across machines. - **Globals like `process` and `Buffer` are always available and surprisingly powerful** (Early): standard I/O, exit codes, and binary handling come built in, so you can do a lot before loading any module. - **Graceful shutdown requires tracking async work** (Early): because Node programs are asynchronous, you often need counters or explicit connection closes (e.g., database connections) before the process can exit cleanly. - **`process.nextTick`, `setImmediate`, and timers behave differently** (Early): understanding when each runs on the event loop is the key to writing predictable asynchronous code. - **Buffers underpin streams and binary parsing** (Early): reading binary specifications byte-by-byte and using bitmasks lets you build custom protocols and convert raw data into usable JavaScript types. - **`EventEmitter` is flexible but has sharp edges** (Early–Middle): `newListener`, `listeners()`, and alternatives like Redis pub/sub help, and using objects as event names avoids bugs when event counts grow. - **Streams are the feature most worth mastering** (Middle): inheriting correctly from `Readable`/`Writable`/`Duplex`/`Transform` (via `Object.create` or `util.inherits`) unlocks efficient, scalable I/O like streaming files to clients. 【Reading Tips】 - Treat it as a reference, not a cover-to-cover read: use the technique numbering and clusters to jump to the problem you're facing. - Deep-read the streams chapter (Middle) and the events chapter (Early–Middle)—these are the conceptual backbone and the excerpts show the most depth there. - Skim the binary/protocol techniques (Early) unless you actually work with binary formats; the bitmask and byte-offset details are dense. - Type out the small project in the Opening yourself—`npm init`, `package.json`, and a first stream class—to internalize the workflow. - Keep the book's stated coverage of testing, debugging, integration, and deployment in mind as your next stop after the core chapters. 【Coverage Limits】 The excerpts concentrate on the Opening through Middle chapters (globals, modules, buffers, events, streams); the Late and Ending material on testing, debugging, integration, and deployment is only described in the book's front matter and is not detailed in the excerpts.