JavaScript for Impatient Programmers

I Background
	Before you buy the book
		About the content
		Previewing and buying this book
		About the author
		Acknowledgements
	FAQ: book and supplementary material
		How to read this book
		I own a digital version
		I own the print version
		Notations and conventions
	Why JavaScript? (bonus)
		The cons of JavaScript
		The pros of JavaScript
		Pro and con of JavaScript: innovation
	The nature of JavaScript (bonus)
		JavaScript's influences
		The nature of JavaScript
		Tips for getting started with JavaScript
	History and evolution of JavaScript
		How JavaScript was created
		Standardizing JavaScript
		Timeline of ECMAScript versions
		Ecma Technical Committee 39 (TC39)
		The TC39 process
		FAQ: TC39 process
		Evolving JavaScript: Don't break the web
	New JavaScript features
		New in ECMAScript 2021
		New in ECMAScript 2020
		New in ECMAScript 2019
		New in ECMAScript 2018
		New in ECMAScript 2017
		New in ECMAScript 2016
		Source of this chapter
	FAQ: JavaScript
		What are good references for JavaScript?
		How do I find out what JavaScript features are supported where?
		Where can I look up what features are planned for JavaScript?
		Why does JavaScript fail silently so often?
		Why can't we clean up JavaScript, by removing quirks and outdated features?
		How can I quickly try out a piece of JavaScript code?
II First steps
	Using JavaScript: the big picture
		What are you learning in this book?
		The structure of browsers and Node.js
		JavaScript references
		Further reading
	Syntax
		An overview of JavaScript's syntax
		(Advanced)
		Identifiers
		Statement vs. expression
		Ambiguous syntax
		Semicolons
		Automatic semicolon insertion (ASI)
		Semicolons: best practices
		Strict mode vs. sloppy mode
	Consoles: interactive JavaScript command lines
		Trying out JavaScript code
		The console.* API: printing data and more
	Assertion API
		Assertions in software development
		How assertions are used in this book
		Normal comparison vs. deep comparison
		Quick reference: module assert
	Getting started with quizzes and exercises
		Quizzes
		Exercises
		Unit tests in JavaScript
III Variables and values
	Variables and assignment
		let
		const
		Deciding between const and let
		The scope of a variable
		(Advanced)
		Terminology: static vs. dynamic
		Global variables and the global object
		Declarations: scope and activation
		Closures
	Values
		What's a type?
		JavaScript's type hierarchy
		The types of the language specification
		Primitive values vs. objects
		The operators typeof and instanceof: what's the type of a value?
		Classes and constructor functions
		Converting between types
	Operators
		Making sense of operators
		The plus operator (+)
		Assignment operators
		Equality: == vs. ===
		Ordering operators
		Various other operators
IV Primitive values
	The non-values undefined and null
		undefined vs. null
		Occurrences of undefined and null
		Checking for undefined or null
		The nullish coalescing operator (??) for default values [ES2020]
		undefined and null don't have properties
		The history of undefined and null
	Booleans
		Converting to boolean
		Falsy and truthy values
		Truthiness-based existence checks
		Conditional operator (? :)
		Binary logical operators: And (x && y), Or (x || y)
		Logical Not (!)
	Numbers
		Numbers are used for both floating point numbers and integers
		Number literals
		Arithmetic operators
		Converting to number
		Error values
		The precision of numbers: careful with decimal fractions
		(Advanced)
		Background: floating point precision
		Integer numbers in JavaScript
		Bitwise operators
		Quick reference: numbers
	Math
		Data properties
		Exponents, roots, logarithms
		Rounding
		Trigonometric Functions
		Various other functions
		Sources
	Bigints – arbitrary-precision integers [ES2020] (advanced)
		Why bigints?
		Bigints
		Bigint literals
		Reusing number operators for bigints (overloading)
		The wrapper constructor BigInt
		Coercing bigints to other primitive types
		TypedArrays and DataView operations for 64-bit values
		Bigints and JSON
		FAQ: Bigints
	Unicode – a brief introduction (advanced)
		Code points vs. code units
		Encodings used in web development: UTF-16 and UTF-8
		Grapheme clusters – the real characters
	Strings
		Plain string literals
		Accessing characters and code points
		String concatenation via +
		Converting to string
		Comparing strings
		Atoms of text: Unicode characters, JavaScript characters, grapheme clusters
		Quick reference: Strings
	Using template literals and tagged templates
		Disambiguation: ``template''
		Template literals
		Tagged templates
		Examples of tagged templates (as provided via libraries)
		Raw string literals
		(Advanced)
		Multiline template literals and indentation
		Simple templating via template literals
	Symbols
		Symbols are primitives that are also like objects
		The descriptions of symbols
		Use cases for symbols
		Publicly known symbols
		Converting symbols
V Control flow and data flow
	Control flow statements
		Controlling loops: break and continue
		Conditions of control flow statements
		if statements [ES1]
		switch statements [ES3]
		while loops [ES1]
		do-while loops [ES3]
		for loops [ES1]
		for-of loops [ES6]
		for-await-of loops [ES2018]
		for-in loops (avoid) [ES1]
		Recomendations for looping
	Exception handling
		Motivation: throwing and catching exceptions
		throw
		The try statement
		Error classes
	Callable values
		Kinds of functions
		Ordinary functions
		Specialized functions
		Summary: kinds of callable values
		Returning values from functions and methods
		Parameter handling
		Methods of functions: .call(), .apply(), .bind()
	Evaluating code dynamically: eval(), new Function() (advanced)
		eval()
		new Function()
		Recommendations
VI Modularity
	Modules
		Overview: syntax of ECMAScript modules
		JavaScript source code formats
		Before we had modules, we had scripts
		Module systems created prior to ES6
		ECMAScript modules
		Named exports and imports
		Default exports and imports
		More details on exporting and importing
		npm packages
		Naming modules
		Module specifiers
		Loading modules dynamically via import() [ES2020]
		import.meta – metadata for the current module [ES2020]
		Polyfills: emulating native web platform features (advanced)
	Single objects
		What is an object?
		Objects as records
		Spreading into object literals (...) [ES2018]
		Methods and the special variable this
		Optional chaining for property accesses and method calls [ES2020] (advanced)
		Objects as dictionaries (advanced)
		Standard methods (advanced)
		Advanced topics
	Prototype chains and classes
		Prototype chains
		Classes
		Private data for classes
		Subclassing
		FAQ: objects
VII Collections
	Synchronous iteration
		What is synchronous iteration about?
		Core iteration constructs: iterables and iterators
		Iterating manually
		Iteration in practice
		Quick reference: synchronous iteration
	Arrays (Array)
		The two roles of Arrays in JavaScript
		Basic Array operations
		for-of and Arrays [ES6]
		Array-like objects
		Converting iterable and Array-like values to Arrays
		Creating and filling Arrays with arbitrary lengths
		Multidimensional Arrays
		More Array features (advanced)
		Adding and removing elements (destructively and non-destructively)
		Methods: iteration and transformation (.find(), .map(), .filter(), etc.)
		.sort(): sorting Arrays
		Quick reference: Array
	Typed Arrays: handling binary data (advanced)
		The basics of the API
		Element types
		More information on Typed Arrays
		Quick references: indices vs. offsets
		Quick reference: ArrayBuffers
		Quick reference: Typed Arrays
		Quick reference: DataViews
	Maps (Map)
		Using Maps
		Example: Counting characters
		A few more details about the keys of Maps (advanced)
		Missing Map operations
		Quick reference: Map
		FAQ: Maps
	WeakMaps (WeakMap) (advanced)
		WeakMaps are black boxes
		The keys of a WeakMap are weakly held
		Examples
		WeakMap API
	Sets (Set)
		Using Sets
		Examples of using Sets
		What Set elements are considered equal?
		Missing Set operations
		Quick reference: Set
		FAQ: Sets
	WeakSets (WeakSet) (advanced)
		Example: Marking objects as safe to use with a method
		WeakSet API
	Destructuring
		A first taste of destructuring
		Constructing vs. extracting
		Where can we destructure?
		Object-destructuring
		Array-destructuring
		Examples of destructuring
		What happens if a pattern part does not match anything?
		What values can't be destructured?
		(Advanced)
		Default values
		Parameter definitions are similar to destructuring
		Nested destructuring
	Synchronous generators (advanced)
		What are synchronous generators?
		Calling generators from generators (advanced)
		Background: external iteration vs. internal iteration
		Use case for generators: reusing traversals
		Advanced features of generators
VIII Asynchronicity
	Asynchronous programming in JavaScript
		A roadmap for asynchronous programming in JavaScript
		The call stack
		The event loop
		How to avoid blocking the JavaScript process
		Patterns for delivering asynchronous results
		Asynchronous code: the downsides
		Resources
	Promises for asynchronous programming [ES6]
		The basics of using Promises
		Examples
		Error handling: don't mix rejections and exceptions
		Promise-based functions start synchronously, settle asynchronously
		Promise combinator functions: working with Arrays of Promises
		Concurrency and Promise.all() (advanced)
		Tips for chaining Promises
		Quick reference: Promise combinator functions
	Async functions
		Async functions: the basics
		Returning from async functions
		await: working with Promises
		(Advanced)
		Immediately invoked async arrow functions
		Concurrency and await
		Tips for using async functions
	Asynchronous iteration
		Basic asynchronous iteration
		Asynchronous generators
		Async iteration over Node.js streams
IX More standard library
	Regular expressions (RegExp)
		Creating regular expressions
		Syntax
		Flags
		Properties of regular expression objects
		Methods for working with regular expressions
		The flags /g and /y, and the property .lastIndex (advanced)
		Techniques for working with regular expressions
	Dates (Date)
		Best practice: avoid the built-in Date
		Time standards
		Background: date time formats (ISO)
		Time values
		Creating Dates
		Getters and setters
		Converting Dates to strings
	Creating and parsing JSON (JSON)
		The discovery and standardization of JSON
		JSON syntax
		Using the JSON API
		Customizing stringification and parsing (advanced)
		FAQ
X Miscellaneous topics
	Next steps: overview of web development (bonus)
		Tips against feeling overwhelmed
		Things worth learning for web development
		Example: tool-based JavaScript workflow
		An overview of JavaScript tools
		Tools not related to JavaScript
XI Appendices
	Index