JavaScript for impatient programmers (beta)

I Background
- 1 About this book (ES2019 edition)
  - 1.1 What’s in this book?
  - 1.2 What is not covered by this book?
  - 1.3 About the author
  - 1.4 Acknowledgements
- 2 FAQ: book and supplementary material
  - 2.1 How to read this book
  - 2.2 Purchases and support
  - 2.3 Notations and conventions
- 3 Why JavaScript? (bonus)
  - 3.1 The cons of JavaScript
  - 3.2 The pros of JavaScript
  - 3.3 Pro and con of JavaScript: innovation
- 4 The nature of JavaScript (bonus)
  - 4.1 JavaScript’s influences
  - 4.2 The nature of JavaScript
  - 4.3 Tips for getting started with JavaScript
- 5 History and evolution of JavaScript
  - 5.1 How JavaScript was created
  - 5.2 Standardizing JavaScript
  - 5.3 Timeline of ECMAScript versions
  - 5.4 Ecma Technical Committee 39 (TC39)
  - 5.5 The TC39 process
  - 5.6 FAQ: TC39 process
  - 5.7 Evolving JavaScript: don’t break the web
- 6 FAQ: JavaScript
  - 6.1 What are good references for JavaScript?
  - 6.2 How do I find out what JavaScript features are supported where?
  - 6.3 Where can I look up what features are planned for JavaScript?
  - 6.4 Why does JavaScript fail silently so often?
  - 6.5 Why can’t we clean up JavaScript, by removing quirks and outdated features?
  - 6.6 How can I quickly try out a piece of JavaScript code?
II First steps
- 7 The big picture
  - 7.1 What are you learning in this book?
  - 7.2 The structure of browsers and Node.js
  - 7.3 JavaScript references
  - 7.4 Further reading
- 8 Syntax
  - 8.1 An overview of JavaScript’s syntax
  - 8.2 (Advanced)
  - 8.3 Identifiers
  - 8.4 Statement vs. expression
  - 8.5 Ambiguous syntax
  - 8.6 Semicolons
  - 8.7 Automatic semicolon insertion (ASI)
  - 8.8 Semicolons: best practices
  - 8.9 Strict mode vs. sloppy mode
- 9 Consoles: interactive JavaScript command lines
  - 9.1 Trying out JavaScript code
  - 9.2 The console.* API: printing data and more
- 10 Assertion API
  - 10.1 Assertions in software development
  - 10.2 How assertions are used in this book
  - 10.3 Normal comparison vs. deep comparison
  - 10.4 Quick reference: module assert
- 11 Getting started with quizzes and exercises
  - 11.1 Quizzes
  - 11.2 Exercises
  - 11.3 Unit tests in JavaScript
III Variables and values
- 12 Variables and assignment
  - 12.1 let
  - 12.2 const
  - 12.3 Deciding between let and const
  - 12.4 The scope of a variable
  - 12.5 (Advanced)
  - 12.6 Terminology: static vs. dynamic
  - 12.7 Global variables
  - 12.8 Declarations: scope and activation
  - 12.9 Closures
  - 12.10 Further reading
- 13 Values
  - 13.1 What’s a type?
  - 13.2 JavaScript’s type hierarchy
  - 13.3 The types of the language specification
  - 13.4 Primitive values vs. objects
  - 13.5 The operators typeof and instanceof: what’s the type of a value?
  - 13.6 Classes and constructor functions
  - 13.7 Converting between types
- 14 Operators
  - 14.1 Making sense of operators
  - 14.2 The plus operator (+)
  - 14.3 Assignment operators
  - 14.4 Equality: == vs. ===
  - 14.5 Ordering operators
  - 14.6 Various other operators
IV Primitive values
- 15 The non-values undefined and null
  - 15.1 undefined vs. null
  - 15.2 Occurrences of undefined and null
  - 15.3 Checking for undefined or null
  - 15.4 undefined and null don’t have properties
  - 15.5 The history of undefined and null
- 16 Booleans
  - 16.1 Converting to boolean
  - 16.2 Falsy and truthy values
  - 16.3 Conditional operator (? :)
  - 16.4 Binary logical operators: And (x && y), Or (x || y)
  - 16.5 Logical Not (!)
- 17 Numbers
  - 17.1 JavaScript only has floating point numbers
  - 17.2 Number literals
  - 17.3 Arithmetic operators
  - 17.4 Converting to number
  - 17.5 Error values
  - 17.6 Error value: NaN
  - 17.7 Error value: Infinity
  - 17.8 The precision of numbers: careful with decimal fractions
  - 17.9 (Advanced)
  - 17.10 Background: floating point precision
  - 17.11 Integers in JavaScript
  - 17.12 Bitwise operators
  - 17.13 Quick reference: numbers
- 18 Math
  - 18.1 Data properties
  - 18.2 Exponents, roots, logarithms
  - 18.3 Rounding
  - 18.4 Trigonometric Functions
  - 18.5 Various other functions
  - 18.6 Sources
- 19 Unicode – a brief introduction (advanced)
  - 19.1 Code points vs. code units
  - 19.2 Encodings used in web development: UTF-16 and UTF-8
  - 19.3 Grapheme clusters – the real characters
- 20 Strings
  - 20.1 Plain string literals
  - 20.2 Accessing characters and code points
  - 20.3 String concatenation via +
  - 20.4 Converting to string
  - 20.5 Comparing strings
  - 20.6 Atoms of text: Unicode characters, JavaScript characters, grapheme clusters
  - 20.7 Quick reference: Strings
- 21 Using template literals and tagged templates
  - 21.1 Disambiguation: “template”
  - 21.2 Template literals
  - 21.3 Tagged templates
  - 21.4 Raw string literals
  - 21.5 (Advanced)
  - 21.6 Multi-line template literals and indentation
  - 21.7 Simple templating via template literals
- 22 Symbols
  - 22.1 Use cases for symbols
  - 22.2 Publicly known symbols
  - 22.3 Converting symbols
V Control flow and data flow
- 23 Control flow statements
  - 23.1 Controlling loops: break and continue
  - 23.2 if statements
  - 23.3 switch statements
  - 23.4 while loops
  - 23.5 do-while loops
  - 23.6 for loops
  - 23.7 for-of loops
  - 23.8 for-await-of loops
  - 23.9 for-in loops (avoid)
- 24 Exception handling
  - 24.1 Motivation: throwing and catching exceptions
  - 24.2 throw
  - 24.3 The try statement
  - 24.4 Error classes
- 25 Callable values
  - 25.1 Kinds of functions
  - 25.2 Ordinary functions
  - 25.3 Specialized functions
  - 25.4 More kinds of functions and methods
  - 25.5 Returning values from functions and methods
  - 25.6 Parameter handling
  - 25.7 Dynamically evaluating code via eval() and new Function()
- 26 Environments: under the hood of variables (bonus)
  - 26.1 Environment: data structure for managing variables
  - 26.2 Recursion via environments
  - 26.3 Nested scopes via environments
  - 26.4 Closures and environments
VI Modularity
- 27 Modules
  - 27.1 JavaScript source code formats
  - 27.2 Before we had modules, we had scripts
  - 27.3 Module systems created prior to ES6
  - 27.4 ECMAScript modules
  - 27.5 Exporting
  - 27.6 Importing
  - 27.7 npm packages
  - 27.8 Naming modules
  - 27.9 Module specifiers
  - 27.10 Preview: loading modules dynamically
  - 27.11 Preview: import.meta.url
  - 27.12 Quick reference: exporting and importing
- 28 Single objects
  - 28.1 What is an object?
  - 28.2 Objects as records
  - 28.3 Spreading into object literals (...)
  - 28.4 Methods
  - 28.5 Objects as dictionaries (advanced)
  - 28.6 Standard methods (advanced)
  - 28.7 Advanced topics
- 29 Prototype chains and classes
  - 29.1 Prototype chains
  - 29.2 Classes
  - 29.3 Private data for classes
  - 29.4 Subclassing
  - 29.5 FAQ: objects
VII Collections
- 30 Synchronous iteration
  - 30.1 What is synchronous iteration about?
  - 30.2 Core iteration constructs: iterables and iterators
  - 30.3 Iterating manually
  - 30.4 Iteration in practice
  - 30.5 Quick reference: synchronous iteration
- 31 Arrays (Array)
  - 31.1 The two roles of Arrays in JavaScript
  - 31.2 Basic Array operations
  - 31.3 for-of and Arrays
  - 31.4 Array-like objects
  - 31.5 Converting iterable and Array-like values to Arrays
  - 31.6 Creating and filling Arrays with arbitrary lengths
  - 31.7 Multidimensional Arrays
  - 31.8 More Array features (advanced)
  - 31.9 Adding and removing elements (destructively and non-destructively)
  - 31.10 Methods: iteration and transformation (.find(), .map(), .filter(), etc.)
  - 31.11 .sort(): sorting Arrays
  - 31.12 Quick reference: Array<T>
- 32 Typed Arrays: handling binary data (Advanced)
  - 32.1 The basics of the API
  - 32.2 Element types
  - 32.3 More information on Typed Arrays
  - 32.4 Quick references: indices vs. offsets
  - 32.5 Quick reference: ArrayBuffers
  - 32.6 Quick reference: Typed Arrays
  - 32.7 Quick reference: DataViews
- 33 Maps (Map)
  - 33.1 Using Maps
  - 33.2 Example: Counting characters
  - 33.3 A few more details about the keys of Maps (advanced)
  - 33.4 Missing Map operations
  - 33.5 Quick reference: Map<K,V>
  - 33.6 FAQ: Maps
- 34 WeakMaps (WeakMap)
  - 34.1 WeakMaps are black boxes
  - 34.2 The keys of a WeakMap are weakly held
  - 34.3 Examples
  - 34.4 WeakMap API
- 35 Sets (Set)
  - 35.1 Using Sets
  - 35.2 Examples of using Sets
  - 35.3 What Set elements are considered equal?
  - 35.4 Missing Set operations
  - 35.5 Quick reference: Set<T>
- 36 WeakSets (WeakSet)
  - 36.1 Example: Marking objects as safe to use with a method
  - 36.2 WeakSet API
- 37 Destructuring
  - 37.1 A first taste of destructuring
  - 37.2 Constructing vs. extracting
  - 37.3 Where can we destructure?
  - 37.4 Object-destructuring
  - 37.5 Array-destructuring
  - 37.6 Examples of destructuring
  - 37.7 What happens if a pattern part does not match anything?
  - 37.8 What values can’t be destructured?
  - 37.9 (Advanced)
  - 37.10 Default values
  - 37.11 Parameter definitions are similar to destructuring
  - 37.12 Nested destructuring
- 38 Synchronous generators (advanced)
  - 38.1 What are synchronous generators?
  - 38.2 Calling generators from generators (advanced)
  - 38.3 Background: external iteration vs. internal iteration
  - 38.4 Example: Reusing loops
  - 38.5 Advanced features of generators
VIII Asynchronicity
- 39 Asynchronous programming in JavaScript
  - 39.1 A roadmap for asynchronous programming in JavaScript
  - 39.2 The call stack
  - 39.3 The event loop
  - 39.4 How to avoid blocking the JavaScript process
  - 39.5 Patterns for delivering asynchronous results
  - 39.6 Asynchronous code: the downsides
  - 39.7 Resources
- 40 Promises for asynchronous programming
  - 40.1 The basics of using Promises
  - 40.2 Examples
  - 40.3 Error handling: don’t mix rejections and exceptions
  - 40.4 Promise-based functions start synchronously, settle asynchronously
  - 40.5 Promise.all(): concurrency and Arrays of Promises
  - 40.6 Tips for chaining Promises
  - 40.7 Further reading
- 41 Async functions
  - 41.1 Async functions: the basics
  - 41.2 Returning from async functions
  - 41.3 await: working with Promises
  - 41.4 (Advanced)
  - 41.5 Immediately invoked async arrow functions
  - 41.6 Concurrency and await
  - 41.7 Tips for using async functions
- 42 Asynchronous iteration
  - 42.1 Basic asynchronous iteration
  - 42.2 Asynchronous generators
  - 42.3 Async iteration over Node.js streams
IX More standard library
- 43 Regular expressions (RegExp)
  - 43.1 Creating regular expressions
  - 43.2 Syntax
  - 43.3 Flags
  - 43.4 Properties of regular expression objects
  - 43.5 Methods for working with regular expressions
  - 43.6 Flag /g and its pitfalls
  - 43.7 Techniques for working with regular expressions
- 44 Dates (Date)
  - 44.1 Best practice: don’t use the current built-in API
  - 44.2 Time zones
  - 44.3 Background: date time formats (ISO)
  - 44.4 Time values
  - 44.5 Creating Dates
  - 44.6 Getters and setters
  - 44.7 Converting Dates to strings
- 45 Creating and parsing JSON (JSON)
  - 45.1 The discovery and standardization of JSON
  - 45.2 JSON syntax
  - 45.3 Using the JSON API
  - 45.4 Customizing stringification and parsing (advanced)
  - 45.5 FAQ
X Miscellaneous topics
- 46 Next steps: overview of web development (bonus)
  - 46.1 Tips against feeling overwhelmed
  - 46.2 Things worth learning for web development
  - 46.3 Example: tool-based JavaScript workflow
  - 46.4 An overview of JavaScript tools
  - 46.5 Tools not related to JavaScript
XI Appendices
- A Index

JavaScript for impatient programmers (beta)

Table of contents