JavaScript for impatient programmers (ES2021 edition)

I BACKGROUND
1 Before you buy the book
1.1 About the content
1.2 Previewing and buying 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 I own a digital version
2.3 I own the print version
2.4 Notations and conventions
3 History and evolution of JavaScript
3.1 How JavaScript was created
3.2 Standardizing JavaScript
3.3 Timeline of ECMAScript versions
3.4 Ecma Technical Committee 39 (TC39)
3.5 The TC39 process
3.6 FAQ: TC39 process
3.7 Evolving JavaScript: Don’t break the web
4 New JavaScript features
4.1 New in ECMAScript 2021
4.2 New in ECMAScript 2020
4.3 New in ECMAScript 2019
4.4 New in ECMAScript 2018
4.5 New in ECMAScript 2017
4.6 New in ECMAScript 2016
4.7 Source of this chapter
5 FAQ: JavaScript
5.1 What are good references for JavaScript?
5.2 How do I find out what JavaScript features are supported where?
5.3 Where can I look up what features are planned for JavaScript?
5.4 Why does JavaScript fail silently so often?
5.5 Why can’t we clean up JavaScript, by removing quirks and outdated features?
5.6 How can I quickly try out a piece of JavaScript code?
II FIRST STEPS
6 Using JavaScript: the big picture
6.1 What are you learning in this book?
6.2 The structure of browsers and Node.js
6.3 JavaScript references
6.4 Further reading
7 Syntax
7.1 An overview of JavaScript’s syntax
7.2 (Advanced)
7.3 Identifiers
7.4 Statement vs. expression
7.5 Ambiguous syntax
7.6 Semicolons
7.7 Automatic semicolon insertion (ASI)
7.8 Semicolons: best practices
7.9 Strict mode vs. sloppy mode
8 Consoles: interactive JavaScript command lines
8.1 Trying out JavaScript code
8.2 The console.* API: printing data and more
9 Assertion API
9.1 Assertions in software development
9.2 How assertions are used in this book
9.3 Normal comparison vs. deep comparison
9.4 Quick reference: module assert
10 Getting started with quizzes and exercises
10.1 Quizzes
10.2 Exercises
10.3 Unit tests in JavaScript
III VARIABLES AND VALUES
11 Variables and assignment
11.1 let
11.2 const
11.3 Deciding between const and let
11.4 The scope of a variable
11.5 (Advanced)
11.6 Terminology: static vs. dynamic
11.7 Global variables and the global object
11.8 Declarations: scope and activation
11.9 Closures
12 Values
12.1 What’s a type?
12.2 JavaScript’s type hierarchy
12.3 The types of the language specification
12.4 Primitive values vs. objects
12.5 The operators typeof and instanceof: what’s the type of a value?
12.6 Classes and constructor functions
12.7 Converting between types
13 Operators
13.1 Making sense of operators
13.2 The plus operator (+)
13.3 Assignment operators
13.4 Equality: == vs. ===
13.5 Ordering operators
13.6 Various other operators
IV PRIMITIVE VALUES
14 The non-values undefined and null
14.1 undefined vs. null
14.2 Occurrences of undefined and null
14.3 Checking for undefined or null
14.4 The nullish coalescing operator (??) for default values [ES2020]
14.5 undefined and null don’t have properties
14.6 The history of undefined and null
15 Booleans
15.1 Converting to boolean
15.2 Falsy and truthy values
15.3 Truthiness-based existence checks
15.4 Conditional operator (? :)
15.5 Binary logical operators: And (x && y), Or (x || y)
15.6 Logical Not (!)
16 Numbers
16.1 Numbers are used for both floating point numbers and integers
16.2 Number literals
16.3 Arithmetic operators
16.4 Converting to number
16.5 Error values
16.6 The precision of numbers: careful with decimal fractions
16.7 (Advanced)
16.8 Background: floating point precision
16.9 Integer numbers in JavaScript
16.10 Bitwise operators
16.11 Quick reference: numbers
17 Math
17.1 Data properties
17.2 Exponents, roots, logarithms
17.3 Rounding
17.4 Trigonometric Functions
17.5 Various other functions
17.6 Sources
18 Bigints – arbitrary-precision integers [ES2020] (advanced)
18.1 Why bigints?
18.2 Bigints
18.3 Bigint literals
18.4 Reusing number operators for bigints (overloading)
18.5 The wrapper constructor BigInt
18.6 Coercing bigints to other primitive types
18.7 TypedArrays and DataView operations for 64-bit values
18.8 Bigints and JSON
18.9 FAQ: Bigints
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 Examples of tagged templates (as provided via libraries)
21.5 Raw string literals
21.6 (Advanced)
21.7 Multiline template literals and indentation
21.8 Simple templating via template literals
22 Symbols
22.1 Symbols are primitives that are also like objects
22.2 The descriptions of symbols
22.3 Use cases for symbols
22.4 Publicly known symbols
22.5 Converting symbols
V CONTROL FLOW AND DATA FLOW
23 Control flow statements
23.1 Controlling loops: break and continue
23.2 Conditions of control flow statements
23.3 if statements [ES1]
23.4 switch statements [ES3]
23.5 while loops [ES1]
23.6 do-while loops [ES3]
23.7 for loops [ES1]
23.8 for-of loops [ES6]
23.9 for-await-of loops [ES2018]
23.10 for-in loops (avoid) [ES1]
23.11 Recomendations for looping
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 Summary: kinds of callable values
25.5 Returning values from functions and methods
25.6 Parameter handling
25.7 Methods of functions: .call(), .apply(), .bind()
26 Evaluating code dynamically: eval(), new Function() (advanced)
26.1 eval()
26.2 new Function()
26.3 Recommendations
VI MODULARITY
27 Modules
27.1 Overview: syntax of ECMAScript modules
27.2 JavaScript source code formats
27.3 Before we had modules, we had scripts
27.4 Module systems created prior to ES6
27.5 ECMAScript modules
27.6 Named exports and imports
27.7 Default exports and imports
27.8 More details on exporting and importing
27.9 npm packages
27.10 Naming modules
27.11 Module specifiers
27.12 Loading modules dynamically via import() [ES2020]
27.13 import.meta – metadata for the current module [ES2020]
27.14 Polyfills: emulating native web platform features (advanced)
28 Single objects
28.1 What is an object?
28.2 Objects as records
28.3 Spreading into object literals (...) [ES2018]
28.4 Methods and the special variable this
28.5 Optional chaining for property accesses and method calls [ES2020] (advanced)
28.6 Objects as dictionaries (advanced)
28.7 Standard methods (advanced)
28.8 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 [ES6]
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
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
33.6 FAQ: Maps
34 WeakMaps (WeakMap) (advanced)
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
35.6 FAQ: Sets
36 WeakSets (WeakSet) (advanced)
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 Use case for generators: reusing traversals
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 [ES6]
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 combinator functions: working with Arrays of Promises
40.6 Concurrency and Promise.all() (advanced)
40.7 Tips for chaining Promises
40.8 Quick reference: Promise combinator functions
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 The flags /g and /y, and the property .lastIndex (advanced)
43.7 Techniques for working with regular expressions
44 Dates (Date)
44.1 Best practice: avoid the built-in Date
44.2 Time standards
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
46 Where are the remaining chapters?
X APPENDICES
A Index