WebAssembly实战 ( etc.)（Z-Library）

【One-Line Pitch】 A hands-on guide to escaping JavaScript's performance ceiling by compiling C/C++ into WebAssembly, aimed at web developers who already know some JavaScript and want to ship near-native-speed browser code without abandoning their existing codebase. 【Book Arc】 - **Opening (~0%–10%)**: Frames why WebAssembly exists — the interpreter/JIT trade-off, the shift from glue language to full application platform — then walks through the binary format itself: modules, sections, s-expressions, and the sandboxing model that keeps Wasm inside the JavaScript VM's security envelope. - **Early (~10%–33%)**: The practical core. You set up Emscripten, compile a first C program, and learn the three output shapes (HTML template, JS plumbing, bare `.wasm`). Then the book reverses the arrow: instead of JS calling into Wasm, Wasm calls back into JavaScript, first via Emscripten's library merging, then via function pointers and Promises. - **Middle (~33%–52%)**: Advanced composition. Dynamic linking lets two or more modules join at runtime; multiple instances of one module can each link to a shared core module. The book builds this out with a real validation scenario where common logic lives in one module and page-specific modules link to it. - **Late (~52%–70%)**: Concurrency and beyond-the-browser. Web Workers prefetch modules on background threads; pthreads bring parallel processing inside the module. Then the same modules run under Node.js, with Emscripten's generated JS detecting its environment automatically. - **Ending (~70%–100%)**: Debugging and testing. A card-matching game is built purely in WebAssembly text format so you can read what the browser shows in View Source, then extended to demonstrate debugging options, and finally wrapped with integration tests. 【Key Takeaways】 - **WebAssembly's real win is predictability, not raw speed** (Opening): JavaScript's JIT optimizes hot paths but can deoptimize; compiled Wasm arrives already in machine code, so performance is consistent rather than best-case. This matters when you're choosing whether to port logic at all. - **The security model is architectural, not bolted on** (Opening): modules never touch device memory directly — the host passes an ArrayBuffer as linear memory, and the framework bounds-checks every access. Table entries are reached by index through the framework, not by raw pointer. Understanding this explains why Wasm can't just do anything a native binary can. - **Emscripten's plumbing is a convenience you should learn to remove** (Early): the generated JS hides loading, instantiation, and helpers like `ccall`. The book deliberately shows the bare `WebAssembly.instantiateStreaming` path so you can see what's actually happening — useful when plumbing gets in your way. - **Conditional compilation keeps one codebase portable** (Early): `__EMSCRIPTEN__` lets the same C/C++ source serve desktop and Wasm targets, including headers only when Emscripten is compiling. This is the practical answer to "how do I reuse existing code without forking it." - **Function pointers turn a one-way call into a conversation** (Early): passing `OnSuccess`/`OnError` pointers into a module lets it report back directly instead of stuffing error strings into a caller-supplied buffer. The JS side wraps this in a Promise, which is the idiomatic bridge. - **Dynamic linking trades size for modularity** (Middle): a shared core module plus thin page-specific modules avoids duplicating validation logic. The cost is build complexity — `MAIN_MODULE=2` and dead-code elimination interact, and you must explicitly export the C library functions your side modules need. - **Threading in Wasm is opt-in and environment-sensitive** (Late): Web Workers handle prefetching and background work; pthreads handle in-module parallelism. Neither is free — the book treats them as advanced topics precisely because the setup is non-trivial. - **Text format is your debugging window** (Ending): building a game in s-expressions makes the module's structure legible in the browser. When binary debugging stalls, the text format is what you read. 【Reading Tips】 - Read chapters 1–3 in order and do not skip Appendix A. The toolchain setup is the single biggest source of early friction, and the book explicitly says the appendix exists to get you to a working build. - Parts 1–2 (through chapter 6) are the core; treat them as a linear course. Parts 3–4 (chapters 7–13) are modular — jump to dynamic linking, threading, or debugging based on what you're actually building. - When the book shows the "no Emscripten plumbing" path, slow down. It's the least convenient chapter and the most educational one; the raw WebAssembly API is what you'll need when the generated code misbehaves. - Keep the card-matching game chapters for last even if debugging is your immediate need — they assume the text-format grounding from earlier chapters. - The excerpts do not cover the book's treatment of Rust or non-C/C++ toolchains in depth; if that's your stack, verify coverage before buying. 【Coverage Limits】 This guide is synthesized from stratified excerpts covering the book's structure, early chapters, and part introductions; specific code listings, later chapter details, and the full debugging/testing content are only partially represented. Claims about chapter contents beyond what the excerpts describe are marked as such.