Deep JavaScript

I Frontmatter
- 1 About this book
  - 1.1 Where is the homepage of this book?
  - 1.2 What is in this book?
  - 1.3 What do I get for my money?
  - 1.4 How can I preview the content?
  - 1.5 How do I report errors?
  - 1.6 Tips for reading
  - 1.7 Notations and conventions
  - 1.8 Acknowledgements
II Types, values, variables
- 2 Type coercion in JavaScript
  - 2.1 What is type coercion?
  - 2.2 Operations that help implement coercion in the ECMAScript specification
  - 2.3 Intermission: expressing specification algorithms in JavaScript
  - 2.4 Example coercion algorithms
  - 2.5 Operations that coerce
  - 2.6 Glossary: terms related to type conversion
- 3 The destructuring algorithm
  - 3.1 Preparing for the pattern matching algorithm
  - 3.2 The pattern matching algorithm
  - 3.3 Empty object patterns and Array patterns
  - 3.4 Applying the algorithm
- 4 Environments: under the hood of variables
  - 4.1 Environment: data structure for managing variables
  - 4.2 Recursion via environments
  - 4.3 Nested scopes via environments
  - 4.4 Closures and environments
- 5 A detailed look at global variables
  - 5.1 Scopes
  - 5.2 Lexical environments
  - 5.3 The global object
  - 5.4 In browsers, globalThis does not point directly to the global object
  - 5.5 The global environment
  - 5.6 Conclusion: Why does JavaScript have both normal global variables and the global object?
  - 5.7 Further reading and sources of this chapter
- 6 % is a remainder operator, not a modulo operator (bonus)
  - 6.1 Remainder operator rem vs. modulo operator mod
  - 6.2 An intuitive understanding of the remainder operation
  - 6.3 An intuitive understanding of the modulo operation
  - 6.4 Similarities and differences between rem and mod
  - 6.5 The equations behind remainder and modulo
  - 6.6 Where are rem and mod used in programming languages?
  - 6.7 Further reading and sources of this chapter
III Working with data
- 7 Copying objects and Arrays
  - 7.1 Shallow copying vs. deep copying
  - 7.2 Shallow copying in JavaScript
  - 7.3 Deep copying in JavaScript
  - 7.4 Further reading
- 8 Updating data destructively and non-destructively
  - 8.1 Examples: updating an object destructively and non-destructively
  - 8.2 Examples: updating an Array destructively and non-destructively
  - 8.3 Manual deep updating
  - 8.4 Implementing generic deep updating
- 9 The problems of shared mutable state and how to avoid them
  - 9.1 What is shared mutable state and why is it problematic?
  - 9.2 Avoiding sharing by copying data
  - 9.3 Avoiding mutations by updating non-destructively
  - 9.4 Preventing mutations by making data immutable
  - 9.5 Libraries for avoiding shared mutable state
IV OOP: object property attributes
- 10 Property attributes: an introduction
  - 10.1 The structure of objects
  - 10.2 Property descriptors
  - 10.3 Retrieving descriptors for properties
  - 10.4 Defining properties via descriptors
  - 10.5 Object.create(): Creating objects via descriptors
  - 10.6 Use cases for Object.getOwnPropertyDescriptors()
  - 10.7 Omitting descriptor properties
  - 10.8 What property attributes do built-in constructs use?
  - 10.9 API: property descriptors
  - 10.10 Further reading
- 11 Protecting objects from being changed
  - 11.1 Levels of protection: preventing extensions, sealing, freezing
  - 11.2 Preventing extensions of objects
  - 11.3 Sealing objects
  - 11.4 Freezing objects
  - 11.5 Further reading
- 12 Properties: assignment vs. definition
  - 12.1 Assignment vs. definition
  - 12.2 Assignment and definition in theory (optional)
  - 12.3 Definition and assignment in practice
  - 12.4 Which language constructs use definition, which assignment?
  - 12.5 Further reading and sources of this chapter
- 13 Enumerability of properties
  - 13.1 How enumerability affects property-iterating constructs
  - 13.2 The enumerability of pre-defined and created properties
  - 13.3 Use cases for enumerability
  - 13.4 Conclusion
V OOP: techniques
- 14 Techniques for instantiating classes
  - 14.1 The problem: initializing a property asynchronously
  - 14.2 Solution: Promise-based constructor
  - 14.3 Solution: static factory method
  - 14.4 Subclassing a Promise-based constructor (optional)
  - 14.5 Conclusion
  - 14.6 Further reading
- 15 Copying instances of classes: .clone() vs. copy constructors
  - 15.1 .clone() methods
  - 15.2 Static factory methods
  - 15.3 Acknowledgements
- 16 Immutable wrappers for collections
  - 16.1 Wrapping objects
  - 16.2 An immutable wrapper for Maps
  - 16.3 An immutable wrapper for Arrays
VI Regular expressions
- 17 Regular expressions: lookaround assertions by example
  - 17.1 Cheat sheet: lookaround assertions
  - 17.2 Warnings for this chapter
  - 17.3 Example: Specifying what comes before or after a match (positive lookaround)
  - 17.4 Example: Specifying what does not come before or after a match (negative lookaround)
  - 17.5 Interlude: pointing lookaround assertions inward
  - 17.6 Example: match strings not starting with 'abc'
  - 17.7 Example: match substrings that do not contain '.mjs'
  - 17.8 Example: skipping lines with comments
  - 17.9 Example: smart quotes
  - 17.10 Acknowledgements
  - 17.11 Further reading
- 18 Composing regular expressions via re-template-tag (bonus)
  - 18.1 The basics
  - 18.2 A tour of the features
  - 18.3 Why is this useful?
  - 18.4 re and named capture groups
VII Miscellaneous topics
- 19 Exploring Promises by implementing them
  - 19.1 Refresher: states of Promises
  - 19.2 Version 1: Stand-alone Promise
  - 19.3 Version 2: Chaining .then() calls
  - 19.4 Convenience method .catch()
  - 19.5 Omitting reactions
  - 19.6 The implementation
  - 19.7 Version 3: Flattening Promises returned from .then() callbacks
  - 19.8 Version 4: Exceptions thrown in reaction callbacks
  - 19.9 Version 5: Revealing constructor pattern
- 20 Metaprogramming with Proxies
  - 20.1 Overview
  - 20.2 Programming versus metaprogramming
  - 20.3 Proxies explained
  - 20.4 Use cases for Proxies
  - 20.5 The design of the Proxy API
  - 20.6 FAQ: Proxies
  - 20.7 Reference: the Proxy API
  - 20.8 Conclusion
  - 20.9 Further reading
- 21 The property .name of functions (bonus)
  - 21.1 Names of functions
  - 21.2 Constructs that provide names for functions
  - 21.3 Things to look out for with names of functions
  - 21.4 Changing the names of functions
  - 21.5 The function property .name in the ECMAScript specification

Deep JavaScript

Table of contents