1.  Preface

a.  Conventions Used in This Book

b.  Example Code

c.  O’Reilly Online Learning

d.  How to Contact Us

e.  Acknowledgments

2.  Introduction to JavaScript

a.  1.1 Exploring JavaScript

b.  1.2 Hello World

c.  1.3 A Tour of JavaScript

d.  1.4 Example: Character Frequency Histograms

e.  1.5 Summary

3.  Lexical Structure

a.  2.1 The Text of a JavaScript Program

b.  2.2 Comments

c.  2.3 Literals

d.  2.4 Identifiers and Reserved Words

i.  2.4.1 Reserved Words

e.  2.5 Unicode

i.  2.5.1 Unicode Escape Sequences

ii.  2.5.2 Unicode Normalization

f.  2.6 Optional Semicolons

g.  2.7 Summary

4.  Types, Values, and Variables

a.  3.1 Overview and Definitions

b.  3.2 Numbers

i.  3.2.1 Integer Literals

ii.  3.2.2 Floating-Point Literals

iii.  3.2.3 Arithmetic in JavaScript

iv.  3.2.4 Binary Floating-Point and Rounding Errors

v.  3.2.5 Arbitrary Precision Integers with BigInt

vi.  3.2.6 Dates and Times

c.  3.3 Text

i.  3.3.1 String Literals

ii.  3.3.2 Escape Sequences in String Literals

iii.  3.3.3 Working with Strings

iv.  3.3.4 Template Literals

v.  3.3.5 Pattern Matching

d.  3.4 Boolean Values

e.  3.5 null and undefined

f.  3.6 Symbols

g.  3.7 The Global Object

h.  3.8 Immutable Primitive Values and Mutable Object References

i.  3.9 Type Conversions

i.  3.9.1 Conversions and Equality

ii.  3.9.2 Explicit Conversions

iii.  3.9.3 Object to Primitive Conversions

j.  3.10 Variable Declaration and Assignment

i.  3.10.1 Declarations with let and const

ii.  3.10.2 Variable Declarations with var

iii.  3.10.3 Destructuring Assignment

k.  3.11 Summary

5.  Expressions and Operators

a.  4.1 Primary Expressions

b.  4.2 Object and Array Initializers

c.  4.3 Function Definition Expressions

d.  4.4 Property Access Expressions

i.  4.4.1 Conditional Property Access

e.  4.5 Invocation Expressions

i.  4.5.1 Conditional Invocation

f.  4.6 Object Creation Expressions

g.  4.7 Operator Overview

i.  4.7.1 Number of Operands

ii.  4.7.2 Operand and Result Type

iii.  4.7.3 Operator Side Effects

iv.  4.7.4 Operator Precedence

v.  4.7.5 Operator Associativity

vi.  4.7.6 Order of Evaluation

h.  4.8 Arithmetic Expressions

i.  4.8.1 The + Operator

ii.  4.8.2 Unary Arithmetic Operators

iii.  4.8.3 Bitwise Operators

i.  4.9 Relational Expressions

i.  4.9.1 Equality and Inequality Operators

ii.  4.9.2 Comparison Operators

iii.  4.9.3 The in Operator

iv.  4.9.4 The instanceof Operator

j.  4.10 Logical Expressions

i.  4.10.1 Logical AND (&&)

ii.  4.10.2 Logical OR (||)

iii.  4.10.3 Logical NOT (!)

k.  4.11 Assignment Expressions

i.  4.11.1 Assignment with Operation

l.  4.12 Evaluation Expressions

i.  4.12.1 eval()

ii.  4.12.2 Global eval()

iii.  4.12.3 Strict eval()

m.  4.13 Miscellaneous Operators

i.  4.13.1 The Conditional Operator (?:)

ii.  4.13.2 First-Defined (??)

iii.  4.13.3 The typeof Operator

iv.  4.13.4 The delete Operator

v.  4.13.5 The await Operator

vi.  4.13.6 The void Operator

vii.  4.13.7 The comma Operator (,)

n.  4.14 Summary

6.  Statements

a.  5.1 Expression Statements

b.  5.2 Compound and Empty Statements

c.  5.3 Conditionals

i.  5.3.1 if

ii.  5.3.2 else if

iii.  5.3.3 switch

d.  5.4 Loops

i.  5.4.1 while

ii.  5.4.2 do/while

iii.  5.4.3 for

iv.  5.4.4 for/of

v.  5.4.5 for/in

e.  5.5 Jumps

i.  5.5.1 Labeled Statements

ii.  5.5.2 break

iii.  5.5.3 continue

iv.  5.5.4 return

v.  5.5.5 yield

vi.  5.5.6 throw

vii.  5.5.7 try/catch/finally

f.  5.6 Miscellaneous Statements

i.  5.6.1 with

ii.  5.6.2 debugger

iii.  5.6.3 “use strict”

g.  5.7 Declarations

i.  5.7.1 const, let, and var

ii.  5.7.2 function

iii.  5.7.3 class

iv.  5.7.4 import and export

h.  5.8 Summary of JavaScript Statements

7.  Objects

a.  6.1 Introduction to Objects

b.  6.2 Creating Objects

i.  6.2.1 Object Literals

ii.  6.2.2 Creating Objects with new

iii.  6.2.3 Prototypes

iv.  6.2.4 Object.create()

c.  6.3 Querying and Setting Properties

i.  6.3.1 Objects As Associative Arrays

ii.  6.3.2 Inheritance

iii.  6.3.3 Property Access Errors

d.  6.4 Deleting Properties

e.  6.5 Testing Properties

f.  6.6 Enumerating Properties

i.  6.6.1 Property Enumeration Order

g.  6.7 Extending Objects

h.  6.8 Serializing Objects

i.  6.9 Object Methods

i.  6.9.1 The toString() Method

ii.  6.9.2 The toLocaleString() Method

iii.  6.9.3 The valueOf() Method

iv.  6.9.4 The toJSON() Method

j.  6.10 Extended Object Literal Syntax

i.  6.10.1 Shorthand Properties

ii.  6.10.2 Computed Property Names

iii.  6.10.3 Symbols as Property Names

iv.  6.10.4 Spread Operator

v.  6.10.5 Shorthand Methods

vi.  6.10.6 Property Getters and Setters

k.  6.11 Summary

8.  Arrays

a.  7.1 Creating Arrays

i.  7.1.1 Array Literals

ii.  7.1.2 The Spread Operator

iii.  7.1.3 The Array() Constructor

iv.  7.1.4 Array.of()

v.  7.1.5 Array.from()

b.  7.2 Reading and Writing Array Elements

c.  7.3 Sparse Arrays

d.  7.4 Array Length

e.  7.5 Adding and Deleting Array Elements

f.  7.6 Iterating Arrays

g.  7.7 Multidimensional Arrays

h.  7.8 Array Methods

i.  7.8.1 Array Iterator Methods

ii.  7.8.2 Flattening arrays with flat() and flatMap()

iii.  7.8.3 Adding arrays with concat()

iv.  7.8.4 Stacks and Queues with push(), pop(), shift(), and unshift()

v.  7.8.5 Subarrays with slice(), splice(), fill(), and copyWithin()

vi.  7.8.6 Array Searching and Sorting Methods

vii.  7.8.7 Array to String Conversions

viii.  7.8.8 Static Array Functions

i.  7.9 Array-Like Objects

j.  7.10 Strings as Arrays

k.  7.11 Summary

9.  Functions

a.  8.1 Defining Functions

i.  8.1.1 Function Declarations

ii.  8.1.2 Function Expressions

iii.  8.1.3 Arrow Functions

iv.  8.1.4 Nested Functions

b.  8.2 Invoking Functions

i.  8.2.1 Function Invocation

ii.  8.2.2 Method Invocation

iii.  8.2.3 Constructor Invocation

iv.  8.2.4 Indirect Invocation

v.  8.2.5 Implicit Function Invocation

c.  8.3 Function Arguments and Parameters

i.  8.3.1 Optional Parameters and Defaults

ii.  8.3.2 Rest Parameters and Variable-Length Argument Lists

iii.  8.3.3 The Arguments Object

iv.  8.3.4 The Spread Operator for Function Calls

v.  8.3.5 Destructuring Function Arguments into Parameters

vi.  8.3.6 Argument Types

d.  8.4 Functions as Values

i.  8.4.1 Defining Your Own Function Properties

e.  8.5 Functions as Namespaces

f.  8.6 Closures

g.  8.7 Function Properties, Methods, and Constructor

i.  8.7.1 The length Property

ii.  8.7.2 The name Property

iii.  8.7.3 The prototype Property

iv.  8.7.4 The call() and apply() Methods

v.  8.7.5 The bind() Method

vi.  8.7.6 The toString() Method

vii.  8.7.7 The Function() Constructor

h.  8.8 Functional Programming

i.  8.8.1 Processing Arrays with Functions

ii.  8.8.2 Higher-Order Functions

iii.  8.8.3 Partial Application of Functions

iv.  8.8.4 Memoization

i.  8.9 Summary

10.  Classes

a.  9.1 Classes and Prototypes

b.  9.2 Classes and Constructors

i.  9.2.1 Constructors, Class Identity, and instanceof

ii.  9.2.2 The constructor Property

c.  9.3 Classes with the class Keyword

i.  9.3.1 Static Methods

ii.  9.3.2 Getters, Setters, and other Method Forms

iii.  9.3.3 Public, Private, and Static Fields

iv.  9.3.4 Example: A Complex Number Class

d.  9.4 Adding Methods to Existing Classes

e.  9.5 Subclasses

i.  9.5.1 Subclasses and Prototypes

ii.  9.5.2 Subclasses with extends and super

iii.  9.5.3 Delegation Instead of Inheritance

iv.  9.5.4 Class Hierarchies and Abstract Classes

f.  9.6 Summary

11.  Modules

a.  10.1 Modules with Classes, Objects, and Closures

i.  10.1.1 Automating Closure-Based Modularity

b.  10.2 Modules in Node

i.  10.2.1 Node Exports

ii.  10.2.2 Node Imports

iii.  10.2.3 Node-Style Modules on the Web

c.  10.3 Modules in ES6

i.  10.3.1 ES6 Exports

ii.  10.3.2 ES6 Imports

iii.  10.3.3 Imports and Exports with Renaming

iv.  10.3.4 Re-Exports

v.  10.3.5 JavaScript Modules on the Web

vi.  10.3.6 Dynamic Imports with import()

vii.  10.3.7 import.meta.url

d.  10.4 Summary

12.  The JavaScript Standard Library

a.  11.1 Sets and Maps

i.  11.1.1 The Set Class

ii.  11.1.2 The Map Class

iii.  11.1.3 WeakMap and WeakSet

b.  11.2 Typed Arrays and Binary Data

i.  11.2.1 Typed Array Types

ii.  11.2.2 Creating Typed Arrays

iii.  11.2.3 Using Typed Arrays

iv.  11.2.4 Typed Array Methods and Properties

v.  11.2.5 DataView and Endianness

c.  11.3 Pattern Matching with Regular Expressions

i.  11.3.1 Defining Regular Expressions

ii.  11.3.2 String Methods for Pattern Matching

iii.  11.3.3 The RegExp Class

d.  11.4 Dates and Times

i.  11.4.1 Timestamps

ii.  11.4.2 Date Arithmetic

iii.  11.4.3 Formatting and Parsing Date Strings

e.  11.5 Error Classes

f.  11.6 JSON Serialization and Parsing

i.  11.6.1 JSON Customizations

g.  11.7 The Internationalization API

i.  11.7.1 Formatting Numbers

ii.  11.7.2 Formatting Dates and Times

iii.  11.7.3 Comparing Strings

h.  11.8 The Console API

i.  11.8.1 Formatted Output with Console

i.  11.9 URL APIs

i.  11.9.1 Legacy URL Functions

j.  11.10 Timers

k.  11.11 Summary

13.  Iterators and Generators

a.  12.1 How Iterators Work

b.  12.2 Implementing Iterable Objects

i.  12.2.1 “Closing” an Iterator: The Return Method

c.  12.3 Generators

i.  12.3.1 Generator Examples

ii.  12.3.2 yield* and Recursive Generators

d.  12.4 Advanced Generator Features

i.  12.4.1 The Return Value of a Generator

Function

ii.  12.4.2 The Value of a yield Expression

iii.  12.4.3 The return() and throw() Methods of a Generator

iv.  12.4.4 A Final Note About Generators

e.  12.5 Summary

14.  Asynchronous JavaScript

a.  13.1 Asynchronous Programming with Callbacks

i.  13.1.1 Timers

ii.  13.1.2 Events

iii.  13.1.3 Network Events

iv.  13.1.4 Callbacks and Events in Node

b.  13.2 Promises

i.  13.2.1 Using Promises

ii.  13.2.2 Chaining Promises

iii.  13.2.3 Resolving Promises

iv.  13.2.4 More on Promises and Errors

v.  13.2.5 Promises in Parallel

vi.  13.2.6 Making Promises

vii.  13.2.7 Promises in Sequence

c.  13.3 async and await

i.  13.3.1 await Expressions

ii.  13.3.2 async Functions

iii.  13.3.3 Awaiting Multiple Promises

iv.  13.3.4 Implementation Details

d.  13.4 Asynchronous Iteration

i.  13.4.1 The for/await Loop

ii.  13.4.2 Asynchronous Iterators

iii.  13.4.3 Asynchronous Generators

iv.  13.4.4 Implementing Asynchronous Iterators

e.  13.5 Summary

15.  Metaprogramming

a.  14.1 Property Attributes

b.  14.2 Object Extensibility

c.  14.3 The prototype Attribute

d.  14.4 Well-Known Symbols

i.  14.4.1 Symbol.iterator and Symbol.asyncIterator

ii.  14.4.2 Symbol.hasInstance

iii.  14.4.3 Symbol.toStringTag

iv.  14.4.4 Symbol.species

v.  14.4.5 Symbol.isConcatSpreadable

vi.  14.4.6 Pattern-Matching Symbols

vii.  14.4.7 Symbol.toPrimitive

viii.  14.4.8 Symbol.unscopables

e.  14.5 Template Tags

f.  14.6 The Reflect API


g.  14.7 Proxy Objects

i.  14.7.1 Proxy Invariants

h.  14.8 Summary

16.  JavaScript in Web Browsers

a.  15.1 Web Programming Basics

i.  15.1.1 JavaScript in HTML <script> Tags

ii.  15.1.2 The Document Object Model

iii.  15.1.3 The Global Object in Web Browsers

iv.  15.1.4 Scripts Share a Namespace

v.  15.1.5 Execution of JavaScript Programs

vi.  15.1.6 Program Input and Output

vii.  15.1.7 Program Errors

viii.  15.1.8 The Web Security Model

b.  15.2 Events

i.  15.2.1 Event Categories

ii.  15.2.2 Registering Event Handlers

iii.  15.2.3 Event Handler Invocation

iv.  15.2.4 Event Propagation

v.  15.2.5 Event Cancellation

vi.  15.2.6 Dispatching Custom Events

c.  15.3 Scripting Documents

i.  15.3.1 Selecting Document Elements

ii.  15.3.2 Document Structure and Traversal

iii.  15.3.3 Attributes

iv.  15.3.4 Element Content

v.  15.3.5 Creating, Inserting, and Deleting Nodes

vi.  15.3.6 Example: Generating a Table of Contents

d.  15.4 Scripting CSS

i.  15.4.1 CSS Classes

ii.  15.4.2 Inline Styles

iii.  15.4.3 Computed Styles

iv.  15.4.4 Scripting Stylesheets

v.  15.4.5 CSS Animations and Events

e.  15.5 Document Geometry and Scrolling

i.  15.5.1 Document Coordinates and Viewport Coordinates

ii.  15.5.2 Querying the Geometry of an Element

iii.  15.5.3 Determining the Element at a Point

iv.  15.5.4 Scrolling

v.  15.5.5 Viewport Size, Content Size, and Scroll Position

f.  15.6 Web Components

i.  15.6.1 Using Web Components

ii.  15.6.2 HTML Templates

iii.  15.6.3 Custom Elements

iv.  15.6.4 Shadow DOM

v.  15.6.5 Example: a <search-box> Web

Component

g.  15.7 SVG: Scalable Vector Graphics

i.  15.7.1 SVG in HTML

ii.  15.7.2 Scripting SVG

iii.  15.7.3 Creating SVG Images with JavaScript

h.  15.8 Graphics in a <canvas>

i.  15.8.1 Paths and Polygons

ii.  15.8.2 Canvas Dimensions and Coordinates

iii.  15.8.3 Graphics Attributes

iv.  15.8.4 Canvas Drawing Operations

v.  15.8.5 Coordinate System Transforms

vi.  15.8.6 Clipping

vii.  15.8.7 Pixel Manipulation

i.  15.9 Audio APIs

i.  15.9.1 The Audio() Constructor

ii.  15.9.2 The WebAudio API

j.  15.10 Location, Navigation, and History

i.  15.10.1 Loading New Documents

ii.  15.10.2 Browsing History

iii.  15.10.3 History Management with hashchange Events

iv.  15.10.4 History Management with pushState()

k.  15.11 Networking

i.  15.11.1 fetch()

ii.  15.11.2 Server-Sent Events

iii.  15.11.3 WebSockets

l.  15.12 Storage

i.  15.12.1 localStorage and sessionStorage

ii.  15.12.2 Cookies

iii.  15.12.3 IndexedDB

m.  15.13 Worker Threads and Messaging

i.  15.13.1 Worker Objects

ii.  15.13.2 The Global Object in Workers

iii.  15.13.3 Importing Code into a Worker

iv.  15.13.4 Worker Execution Model

v.  15.13.5 postMessage(), MessagePorts, and MessageChannels

vi.  15.13.6 Cross-Origin Messaging with postMessage()

n.  15.14 Example: The Mandelbrot Set

o.  15.15 Summary and Suggestions for Further Reading

i.  15.15.1 HTML and CSS

ii.  15.15.2 Performance

iii.  15.15.3 Security

iv.  15.15.4 WebAssembly

v.  15.15.5 More Document and Window Features

vi.  15.15.6 Events

vii.  15.15.7 Progressive Web Apps and Service Workers

viii.  15.15.8 Mobile Device APIs

ix.  15.15.9 Binary APIs

x.  15.15.10 Media APIs

xi.  15.15.11 Cryptography and Related APIs

17.  Server-Side JavaScript with Node

a.  16.1 Node Programming Basics

i.  16.1.1 Console Output

ii.  16.1.2 Command-Line Arguments and Environment Variables

iii.  16.1.3 Program Life Cycle

iv.  16.1.4 Node Modules

v.  16.1.5 The Node Package Manager

b.  16.2 Node Is Asynchronous by Default

c.  16.3 Buffers

d.  16.4 Events and EventEmitter

e.  16.5 Streams

i.  16.5.1 Pipes

ii.  16.5.2 Asynchronous Iteration

iii.  16.5.3 Writing to Streams and Handling Backpressure

iv.  16.5.4 Reading Streams with Events

f.  16.6 Process, CPU, and Operating System Details

g.  16.7 Working with Files

i.  16.7.1 Paths, File Descriptors, and FileHandles

ii.  16.7.2 Reading Files

iii.  16.7.3 Writing Files

iv.  16.7.4 File Operations

v.  16.7.5 File Metadata

vi.  16.7.6 Working with Directories

h.  16.8 HTTP Clients and Servers

i.  16.9 Non-HTTP Network Servers and Clients

j.  16.10 Working with Child Processes

i.  16.10.1 execSync() and execFileSync()

ii.  16.10.2 exec() and execFile()

iii.  16.10.3 spawn()

iv.  16.10.4 fork()

k.  16.11 Worker Threads

i.  16.11.1 Creating Workers and Passing Messages

ii.  16.11.2 The Worker Execution Environment

iii.  16.11.3 Communication Channels and MessagePorts

iv.  16.11.4 Transferring MessagePorts and Typed Arrays

v.  16.11.5 Sharing Typed Arrays Between Threads

l.  16.12 Summary

18.  JavaScript Tools and Extensions

a.  17.1 Linting with ESLint

b.  17.2 JavaScript Formatting with Prettier

c.  17.3 Unit Testing with Jest

d.  17.4 Package Management with npm

e.  17.5 Code Bundling

f.  17.6 Transpilation with Babel

g.  17.7 JSX: Markup Expressions in JavaScript

h.  17.8 Type Checking with Flow

i.  17.8.1 Installing and Running Flow

ii.  17.8.2 Using Type Annotations

iii.  17.8.3 Class Types

iv.  17.8.4 Object Types

v.  17.8.5 Type Aliases

vi.  17.8.6 Array Types

vii.  17.8.7 Other Parameterized Types

viii.  17.8.8 Read-Only Types

ix.  17.8.9 Function Types

x.  17.8.10 Union Types

xi.  17.8.11 Enumerated Types and Discriminated Unions

i.  17.9 Summary

19.  Index



Praise for JavaScript: The Definitive Guide, Seventh Edition

“This book is everything you never knew you wanted to know about JavaScript. Take your JavaScript code quality and productivity to the next level. David’s knowledge of the language, its intricacies and gotchas, is astounding, and it shines through in this truly definitive guide to the JavaScript language.”
—Schalk Neethling, Senior Frontend Engineer at MDN Web Docs

“David Flanagan takes readers on a guided tour of JavaScript that will provide them with a feature-complete picture of the language and its ecosystem.”
—Sarah Wachs, Frontend Developer and Women Who Code Berlin Lead

“Any developer interested in being productive in codebases developed throughout JavaScript’s lifetime (including the latest and emerging features) will be well served by a deep and reflective journey through this comprehensive and definitive book.”
—Brian Sletten, President of Bosatsu Consulting






J avaScript: The Definitive Guide



SEVENTH EDITION


Master the World’s Most-Used Programming Language



David Flanagan



J avaScript: The Definitive Guide, Seventh Edition

by David Flanagan


Copyright © 2020 David Flanagan. All rights reserved.


Printed in the United States of America.


Published by O’Reilly Media, Inc., 1005 Gravenstein Highway North, Sebastopol, CA 95472.


O’Reilly books may be purchased for educational, business, or sales promotional use. Online editions are also available for most titles (http://oreilly.com). For more information, contact our corporate/institutional sales department: 800-998-9938 or corporate@oreilly.com.


Acquisitions Editor: Jennifer Pollock

Development Editor: Angela Rufino

Production Editor: Deborah Baker

Copyeditor: Holly Bauer Forsyth

Proofreader: Piper Editorial, LLC

Indexer: Judith McConville

Interior Designer: David Futato

Cover Designer: Karen Montgomery


Illustrator: Rebecca Demarest

June 1998: Third Edition

November 2001: Fourth Edition

August 2006: Fifth Edition

May 2011: Sixth Edition

May 2020: Seventh Edition

Revision History for the Seventh Edition

2020-05-13: First Release

See http://oreilly.com/catalog/errata.csp?isbn=9781491952023 for release details.


The O’Reilly logo is a registered trademark of O’Reilly Media, Inc. JavaScript: The Definitive Guide, Seventh Edition, the cover image, and related trade dress are trademarks of O’Reilly Media, Inc.


While the publisher and the authors have used good faith efforts to ensure that the information and instructions contained in this work are accurate, the publisher and the authors disclaim all responsibility for errors or omissions, including without limitation responsibility for damages resulting from the use of or reliance on this work. Use of the information and instructions contained in this work is at your own risk. If any code samples or other technology this work contains or describes is subject to open source licenses or the intellectual property rights of others, it is your responsibility to ensure that your use thereof complies with such licenses and/or rights.


978-1-491-95202-3

[LSI]



Dedication

To my parents, Donna and Matt, with love and gratitude.



Preface




This book covers the JavaScript language and the JavaScript APIs implemented by web browsers and by Node. I wrote it for readers with some prior programming experience who want to learn JavaScript and also for programmers who already use JavaScript but want to take their understanding to a new level and really master the language. My goal with this book is to document the JavaScript language comprehensively and definitively and to provide an in-depth introduction to the most important client-side and server-side APIs available to JavaScript programs. As a result, this is a long and detailed book. My hope, however, is that it will reward careful study and that the time you spend reading it will be easily recouped in the form of higher programming productivity.


Previous editions of this book included a comprehensive reference section. I no longer feel that it makes sense to include that material in printed form when it is so quick and easy to find up-to-date reference material online. If you need to look up anything related to core or client-side JavaScript, I recommend you visit the MDN website. And for server-side Node APIs, I recommend you go directly to the source and consult the Node.js reference documentation.


Conventions Used in This Book

I use the following typographical conventions in this book:


Italic

Is used for emphasis and to indicate the first use of a term. Italic is also used for email addresses, URLs, and file names.

Cons t ant   wi dt h

Is used in all JavaScript code and CSS and HTML listings, and generally for anything that you would type literally when programming.

Cons t ant   wi dt h   i t al i c

Is occasionally used when explaining JavaScript syntax.

Cons t ant   wi dt h  bol d

Shows commands or other text that should be typed literally by the user



NOTE This element signifies a general note.





IMPORTANT This element indicates a warning or caution.




Example Code

Supplemental material (code examples, exercises, etc.) for this book is available for download at:


https://oreil.ly/javascript_defgd7

This book is here to help you get your job done. In general, if example code is offered with this book, you may use it in your programs and documentation. You do not need to contact us for permission unless you’re reproducing a significant portion of the code. For example, writing a program that uses several chunks of code from this book does not require permission. Selling or distributing examples from O’Reilly books does require permission. Answering a question by citing this book and quoting example code does not require permission. Incorporating a significant amount of example code from this book into your product’s documentation does require permission.


We appreciate, but generally do not require, attribution. An attribution usually includes the title, author, publisher, and ISBN. For example: “JavaScript: The Definitive Guide, Seventh Edition, by David Flanagan (O’Reilly). Copyright 2020 David Flanagan, 978-1-491-95202-3.”


If you feel your use of code examples falls outside fair use or the permission given above, feel free to contact us at permissions@oreilly.com.


O’Reilly Online Learning



NOTE

For more than 40 years, O’Reilly Media has provided technology and business training, knowledge, and insight to help companies succeed.




Our unique network of experts and innovators share their knowledge and expertise through books, articles, and our online learning platform.

O’Reilly’s online learning platform gives you on-demand access to live training courses, in-depth learning paths, interactive coding environments, and a vast collection of text and video from O’Reilly and 200+ other publishers. For more information, visit http://oreilly.com.


How to Contact Us

Please address comments and questions concerning this book to the publisher:


O’Reilly Media, Inc.

1005 Gravenstein Highway North

Sebastopol, CA 95472

800-998-9938 (in the United States or Canada)

707-829-0515 (international or local)

707-829-0104 (fax)

We have a web page for this book, where we list errata, examples, and any additional information. You can access this page at https://oreil.ly/javascript_defgd7.


Email bookquestions@oreilly.com to comment or ask technical questions about this book.


For news and more information about our books and courses, see our website at http://www.oreilly.com.


Find us on Facebook: http://facebook.com/oreilly

Follow us on Twitter: http://twitter.com/oreillymedia


Watch us on YouTube: http://www.youtube.com/oreillymedia



Acknowledgments

Many people have helped with the creation of this book. I’d like to thank my editor, Angela Rufino, for keeping me on track and for her patience with my missed deadlines. Thanks also to my technical reviewers: Brian Sletten, Elisabeth Robson, Ethan Flanagan, Maximiliano Firtman, Sarah Wachs, and Schalk Neethling. Their comments and suggestions have made this a better book.


The production team at O’Reilly has done their usual fine job: Kristen Brown managed the production process, Deborah Baker was the production editor, Rebecca Demarest drew the figures, and Judy McConville created the index.


Editors, reviewers, and contributors to previous editions of this book have included: Andrew Schulman, Angelo Sirigos, Aristotle Pagaltzis, Brendan Eich, Christian Heilmann, Dan Shafer, Dave C. Mitchell, Deb Cameron, Douglas Crockford, Dr. Tankred Hirschmann, Dylan Schiemann, Frank Willison, Geoff Stearns, Herman Venter, Jay Hodges, Jeff Yates, Joseph Kesselman, Ken Cooper, Larry Sullivan, Lynn Rollins, Neil Berkman, Mike Loukides, Nick Thompson, Norris Boyd, Paula Ferguson, Peter-Paul Koch, Philippe Le Hegaret, Raffaele Cecco, Richard Yaker, Sanders Kleinfeld, Scott Furman, Scott Isaacs, Shon Katzenberger, Terry Allen, Todd Ditchendorf, Vidur Apparao, Waldemar Horwat, and Zachary Kessin.

Writing this seventh edition kept me away from my family for many late nights. My love to them and my thanks for putting up with my absences.


David Flanagan, March 2020



Chapter 1. Introduction to J avaScript




JavaScript is the programming language of the web. The overwhelming majority of websites use JavaScript, and all modern web browsers—on desktops, tablets, and phones—include JavaScript interpreters, making JavaScript the most-deployed programming language in history. Over the last decade, Node.js has enabled JavaScript programming outside of web browsers, and the dramatic success of Node means that JavaScript is now also the most-used programming language among software developers. Whether you’re starting from scratch or are already using JavaScript professionally, this book will help you master the language.


If you are already familiar with other programming languages, it may help you to know that JavaScript is a high-level, dynamic, interpreted programming language that is well-suited to object-oriented and functional programming styles. JavaScript’s variables are untyped. Its syntax is loosely based on Java, but the languages are otherwise unrelated. JavaScript derives its first-class functions from Scheme and its prototype-based inheritance from the little-known language Self. But you do not need to know any of those languages, or be familiar with those terms, to use this book and learn JavaScript.


The name “JavaScript” is quite misleading. Except for a superficial syntactic resemblance, JavaScript is completely different from the Java programming language. And JavaScript has long since outgrown its scripting-language roots to become a robust and efficient general-purpose

language suitable for serious software engineering and projects with huge codebases.



J AVASCRIPT: NAMES, VERSIONS, AND MODES

JavaScript was created at Netscape in the early days of the web, and technically, “JavaScript” is a trademark licensed from Sun Microsystems (now Oracle) used to describe Netscape’s (now Mozilla’s) implementation of the language. Netscape submitted the language for standardization to ECMA—the European Computer Manufacturer’s Association—and because of trademark issues, the standardized version of the language was stuck with the awkward name “ECMAScript.” In practice, everyone just calls the language JavaScript. This book uses the name “ECMAScript” and the abbreviation “ES” to refer to the language standard and to versions of that standard.

For most of the 2010s, version 5 of the ECMAScript standard has been supported by all web browsers. This book treats ES5 as the compatibility baseline and no longer discusses earlier versions of the language. ES6 was released in 2015 and added major new features—including class and module syntax— that changed JavaScript from a scripting language into a serious, general-purpose language suitable for large-scale software engineering. Since ES6, the ECMAScript specification has moved to a yearly release cadence, and versions of the language—ES2016, ES2017, ES2018, ES2019, and ES2020—are now identified by year of release.

As JavaScript evolved, the language designers attempted to correct flaws in the early (pre-ES5) versions. In order to maintain backward compatibility, it is not possible to remove legacy features, no matter how flawed. But in ES5 and later, programs can opt in to JavaScript’s strict mode in which a number of early language mistakes have been corrected. The mechanism for opting in is the “use strict” directive described in §5.6.3. That section also summarizes the differences between legacy JavaScript and strict JavaScript. In ES6 and later, the use of new language features often implicitly invokes strict mode. For example, if you use the ES6 cl as s  keyword or create an ES6 module, then all the code within the class or module is automatically strict, and the old, flawed features are not available in those contexts. This book will cover the legacy features of JavaScript but is careful to point out that they are not available in strict mode.



To be useful, every language must have a platform, or standard library, for performing things like basic input and output. The core JavaScript language defines a minimal API for working with numbers, text, arrays, sets, maps, and so on, but does not include any input or output functionality. Input and output (as well as more sophisticated features, such as networking, storage, and graphics) are the responsibility of the “host environment” within which JavaScript is embedded.


The original host environment for JavaScript was a web browser, and this is still the most common execution environment for JavaScript code. The

web browser environment allows JavaScript code to obtain input from the user’s mouse and keyboard and by making HTTP requests. And it allows JavaScript code to display output to the user with HTML and CSS.

Since 2010, another host environment has been available for JavaScript code. Instead of constraining JavaScript to work with the APIs provided by a web browser, Node gives JavaScript access to the entire operating system, allowing JavaScript programs to read and write files, send and receive data over the network, and make and serve HTTP requests. Node is a popular choice for implementing web servers and also a convenient tool for writing simple utility scripts as an alternative to shell scripts.


Most of this book is focused on the JavaScript language itself. Chapter 11 documents the JavaScript standard library, Chapter 15 introduces the web browser host environment, and Chapter 16 introduces the Node host environment.


This book covers low-level fundamentals first, and then builds on those to more advanced and higher-level abstractions. The chapters are intended to be read more or less in order. But learning a new programming language is never a linear process, and describing a language is not linear either: each language feature is related to other features, and this book is full of cross-references—sometimes backward and sometimes forward—to related material. This introductory chapter makes a quick first pass through the language, introducing key features that will make it easier to understand the in-depth treatment in the chapters that follow. If you are already a practicing JavaScript programmer, you can probably skip this chapter. (Although you might enjoy reading Example 1-1 at the end of the chapter before you move on.)

1.1 Exploring J avaScript

When learning a new programming language, it’s important to try the examples in the book, then modify them and try them again to test your understanding of the language. To do that, you need a JavaScript interpreter.


The easiest way to try out a few lines of JavaScript is to open up the web developer tools in your web browser (with F12, Ctrl-Shift-I, or Command-Option-I) and select the Console tab. You can then type code at the prompt and see the results as you type. Browser developer tools often appear as panes at the bottom or right of the browser window, but you can usually detach them as separate windows (as pictured in Figure 1-1), which is often quite convenient.













































Figure 1-1. The JavaScript console in Firefox’s Developer Tools

Another way to try out JavaScript code is to download and install Node from https://nodejs.org. Once Node is installed on your system, you can simply open a Terminal window and type node to begin an interactive JavaScript session like this one:

$   node
Wel c ome   t o   Node. j s   v12. 13. 0.
Type   " . hel p"   f or   mor e   i nf or mat i on. >   . hel p
. br eak	Somet i mes   you   get   s t uc k,	t hi s   get s   you   out . c l ear	Al i as   f or   . br eak
. edi t or	Ent er   edi t or   mode . exi t	Exi t   t he   r epl
. hel p	Pr i nt   t hi s   hel p   mes s age
. l oad	L oad   J S   f r om a   f i l e   i nt o   t he   REPL   s es s i on
. s ave	Save   al l	eval uat ed   c ommands   i n   t hi s   REPL   s es s i on   t o   a f i l e

Pr es s   ^C   t o   abor t   c ur r ent   expr es s i on,	^D  t o   exi t   t he   r epl >   l et   x   =   2,	y   =   3;
undef i ned >   x   +   y
5
>   ( x   ===   2)    &&  ( y   ===   3) t r ue
>   ( x   >   3)    ||   ( y   <   3) f al s e


1.2 Hello World

When you are ready to start experimenting with longer chunks of code, these line-by-line interactive environments may no longer be suitable, and you will probably prefer to write your code in a text editor. From there, you can copy and paste to the JavaScript console or into a Node session. Or you can save your code to a file (the traditional filename extension for JavaScript code is .js) and then run that file of JavaScript code with Node:

$   node   s ni ppet . j s


If you use Node in a noninteractive manner like this, it won’t automatically print out the value of all the code you run, so you’ll have to do that yourself. You can use the function cons ol e. l og( )  to display text and other JavaScript values in your terminal window or in a browser’s developer tools console. So, for example, if you create a hello.js file

containing this line of code:


c ons ol e. l og( " Hel l o   Wor l d! " ) ;


and execute the file with node   hel l o. j s , you’ll see the message “Hello World!” printed out.

If you want to see that same message printed out in the JavaScript console of a web browser, create a new file named hello.html, and put this text in it:

<s c r i pt   s r c =" hel l o. j s " ></ s c r i pt >


Then load hello.html into your web browser using a f i l e: / /  URL like this one:

f i l e: / / / Us er s / us er name/ j avas c r i pt / hel l o. ht ml


Open the developer tools window to see the greeting in the console.



1.3 A Tour of J avaScript

This section presents a quick introduction, through code examples, to the JavaScript language. After this introductory chapter, we dive into JavaScript at the lowest level: Chapter 2 explains things like JavaScript comments, semicolons, and the Unicode character set. Chapter 3 starts to get more interesting: it explains JavaScript variables and the values you can assign to those variables.


Here’s some sample code to illustrate the highlights of those two chapters:


/ /   Anyt hi ng   f ol l owi ng   doubl e   s l as hes   i s   an   Engl i s h- l anguage c omment .

/ /   Read   t he   c omment s   c ar ef ul l y:	t hey   expl ai n   t he   J avaSc r i pt c ode.


/ /   A  var i abl e   i s / /   Var i abl es   ar e

a   s ymbol i c   name   f or   a dec l ar ed   wi t h   t he   l et

val ue. keywor d:

l et   x;	/ /   Dec l ar e   a   var i abl e   named   x.

/ /   Val ues   c an   be   as s i gned   t o   var i abl es   wi t h   an   =   s i gn
x   =   0;	/ /   Now  t he   var i abl e   x   has   t he   val ue   0 x	/ /   =>   0:	A  var i abl e   eval uat es   t o   i t s val ue.

/ /   J avaSc r i pt   s uppor t s   s ever al	t ypes   of    val ues x   =   1;	/ /   Number s .
x   =   0. 01;	/ /   Number s   c an   be   i nt eger s   or   r eal s . x   =   " hel l o   wor l d" ;	/ /   St r i ngs   of    t ext   i n   quot at i on
mar ks .
x   =   ' J avaSc r i pt ' ;	/ /   Si ngl e   quot e   mar ks   al s o   del i mi t s t r i ngs .
x   =   t r ue;	/ /   A  Bool ean   val ue.
x   =   f al s e;	/ /   The   ot her   Bool ean   val ue.
x   =   nul l ;	/ /   Nul l	i s   a   s pec i al	val ue   t hat   means " no   val ue. "
x   =   undef i ned;	/ /   Undef i ned   i s   anot her   s pec i al	val ue l i ke   nul l .


Two other very important types that JavaScript programs can manipulate are objects and arrays. These are the subjects of Chapters 6 and 7, but they are so important that you’ll see them many times before you reach those chapters:


/ /   J avaSc r i pt ' s / /   An   obj ec t   i s val ue   map.

mos t   i mpor t ant   dat at ype   i s a   c ol l ec t i on   of    name/ val ue

t he   obj ec t .
pai r s ,	or   a   s t r i ng   t o

l et   book   =   {	/ /   Obj ec t s   ar e   enc l os ed   i n   c ur l y br ac es .
t opi c :	" J avaSc r i pt " ,	/ /   The   pr oper t y   " t opi c "   has   val ue " J avaSc r i pt . "
edi t i on:	7	/ /   The   pr oper t y   " edi t i on"   has   val ue   7 } ;                                                                     / /   The   c ur l y   br ac e   mar ks   t he   end   of
t he   obj ec t .

/ /   Ac c es s   t he   pr oper t i es   of    an   obj ec t   wi t h   .	or   [ ] :

book. t opi c	/ /   =>   " J avaSc r i pt "
book[ " edi t i on" ]	/ /   =>   7:	anot her   way   t o   ac c es s pr oper t y   val ues .
book. aut hor   =   " Fl anagan" ;	/ /   Cr eat e   new  pr oper t i es   by as s i gnment .
book. c ont ent s   =   { } ;	/ /   { }    i s   an   empt y   obj ec t   wi t h   no pr oper t i es .

/ /   Condi t i onal l y   ac c es s   pr oper t i es   wi t h   ?.	( ES2020) :
book. c ont ent s ?. c h01?. s ec t 1   / /   =>   undef i ned:	book. c ont ent s   has   no c h01   pr oper t y.

/ /   J avaSc r i pt   al s o   s uppor t s   ar r ays   ( numer i c al l y   i ndexed   l i s t s ) of    val ues :
l et   pr i mes   =   [ 2,	3,	5,	7] ;	/ /   An   ar r ay   of    4   val ues ,	del i mi t ed wi t h   [    and   ] .
pr i mes [ 0]	/ /   =>   2:	t he   f i r s t   el ement   ( i ndex   0) of    t he   ar r ay.
pr i mes . l engt h	/ /   =>   4:	how  many   el ement s   i n   t he ar r ay.
pr i mes [ pr i mes . l engt h- 1]	/ /   =>   7:	t he   l as t   el ement   of    t he ar r ay.
pr i mes [ 4]    =   9;	/ /   Add   a   new  el ement   by   as s i gnment .
pr i mes [ 4]    =   11;	/ /   Or   al t er   an   exi s t i ng   el ement   by as s i gnment .
l et   empt y   =   [ ] ;	/ /   [ ]    i s   an   empt y   ar r ay   wi t h   no el ement s .
empt y. l engt h	/ /   =>   0

/ /   Ar r ays   and   obj ec t s   c an   hol d   ot her   ar r ays   and   obj ec t s : l et   poi nt s   =   [	/ /   An   ar r ay   wi t h   2   el ement s .
{ x:	0,	y:	0} ,	/ /   Eac h   el ement   i s   an   obj ec t . { x:	1,	y:	1}
] ;
l et   dat a   =   {	/ /   An   obj ec t   wi t h   2   pr oper t i es
t r i al 1:	[ [ 1, 2] ,	[ 3, 4] ] ,	/ /   The   val ue   of    eac h   pr oper t y   i s   an ar r ay.
t r i al 2:	[ [ 2, 3] ,	[ 4, 5] ]	/ /   The   el ement s   of    t he   ar r ays   ar e ar r ays .
} ;



COMMENT SYNTAX IN CODE EXAMPLES

You may have noticed in the preceding code that some of the comments begin with an arrow (=>). These

show the value produced by the code before the comment and are my attempt to emulate an interactive JavaScript environment like a web browser console in a printed book.

Those / /   => comments also serve as an assertion, and I’ve written a tool that tests the code and verifies that it produces the value specified in the comment. This should help, I hope, to reduce errors in the book.

There are two related styles of comment/assertion. If you see a comment of the form / /   a   ==   42, it means that after the code before the comment runs, the variable a will have the value 42. If you see a comment of the form / /   ! , it means that the code on the line before the comment throws an exception (and the rest of the comment after the exclamation mark usually explains what kind of exception is thrown).

You’ll see these comments used throughout the book.



The syntax illustrated here for listing array elements within square braces or mapping object property names to property values inside curly braces is known as an initializer expression, and it is just one of the topics of Chapter 4. An expression is a phrase of JavaScript that can be evaluated to produce a value. For example, the use of .  and [ ]  to refer to the value of an object property or array element is an expression.

One of the most common ways to form expressions in JavaScript is to use operators:

/ /   Oper at or s   ac t   on   val ues   ( t he   oper ands )    t o   pr oduc e   a   new val ue.
/ /   Ar i t hmet i c   oper at or s   ar e   s ome   of    t he   s i mpl es t : 3   +   2	/ /   =>   5:	addi t i on
3   -    2	/ /   =>   1:	s ubt r ac t i on
3   *   2	/ /   =>   6:	mul t i pl i c at i on 3   /   2	/ /   =>   1. 5:	di vi s i on
poi nt s [ 1] . x   -    poi nt s [ 0] . x	/ /   =>   1:	mor e   c ompl i c at ed   oper ands al s o   wor k
" 3"   +   " 2"	/ /   =>   " 32" :	+   adds   number s , c onc at enat es   s t r i ngs

/ /   J avaSc r i pt   def i nes   s ome   s hor t hand   ar i t hmet i c   oper at or s l et   c ount   =   0;	/ /   Def i ne   a   var i abl e

c ount ++;
c ount - - ;

/ /   I nc r ement
/ /   Dec r ement

t he   var i abl e
t he   var i abl e

c ount   +=   2;	/ /   Add   2:	s ame   as   c ount   =   c ount   +   2; c ount   *=   3;	/ /   Mul t i pl y   by   3:	s ame   as   c ount   =

c ount   *   3;
c ount	/ /   =>   6:	var i abl e   names   ar e expr es s i ons ,    t oo.


/ /   Equal i t y   and   r el at i onal	oper at or s equal ,
/ /   unequal ,	l es s   t han,	gr eat er   t han, t r ue   or   f al s e.

t es t   whet her   t wo   val ues   ar e

and   s o   on.	They   eval uat e   t o

l et   x   =   2,	y   =   3;	/ /   Thes e   =   s i gns   ar e   as s i gnment ,	not

equal i t y   t es t s x   ===   y
x   ! ==   y x   <   y
x   <=   y x   >   y x   >=   y
" t wo"   ===   " t hr ee" di f f er ent
" t wo"   >   " t hr ee"
gr eat er   t han   " t h"


/ /   =>   f al s e:	equal i t y / /   =>   t r ue:    i nequal i t y / /   =>   t r ue:    l es s - t han
/ /   =>   t r ue:	l es s - t han   or   equal / /   =>   f al s e:    gr eat er - t han
/ /   =>   f al s e:	gr eat er - t han   or   equal / /   =>   f al s e:	t he   t wo   s t r i ngs   ar e

/ /   =>   t r ue:	" t w"   i s   al phabet i c al l y

f al s e   ===   ( x   >   y)	/ /   =>   t r ue:	f al s e   i s   equal	t o   f al s e

/ /   L ogi c al	oper at or s   c ombi ne   or   i nver t   bool ean   val ues
( x   ===   2)    &&  ( y   ===   3)	/ /   =>   t r ue:	bot h   c ompar i s ons   ar e t r ue.	&&  i s   AND
( x   >   3)    ||   ( y   <   3)	/ /   =>   f al s e:	nei t her   c ompar i s on   i s t r ue.	||   i s   OR
! ( x   ===   y)	/ /   =>   t r ue:	!   i nver t s   a   bool ean   val ue


If JavaScript expressions are like phrases, then JavaScript statements are like full sentences. Statements are the topic of Chapter 5. Roughly, an expression is something that computes a value but doesn’t do anything: it doesn’t alter the program state in any way. Statements, on the other hand, don’t have a value, but they do alter the state. You’ve seen variable declarations and assignment statements above. The other broad category of statement is control structures, such as conditionals and loops. You’ll see examples below, after we cover functions.


A function is a named and parameterized block of JavaScript code that you define once, and can then invoke over and over again. Functions aren’t

covered formally until Chapter 8, but like objects and arrays, you’ll see them many times before you get to that chapter. Here are some simple examples:

/ /   Func t i ons   ar e   par amet er i z ed   bl oc ks   of    J avaSc r i pt   c ode   t hat   we c an   i nvoke.
f unc t i on   pl us 1( x)    {	/ /   Def i ne   a   f unc t i on   named   " pl us 1" wi t h   par amet er   " x"
r et ur n   x   +   1;	/ /   Ret ur n   a   val ue   one   l ar ger   t han   t he val ue   pas s ed   i n
}	/ /   Func t i ons   ar e   enc l os ed   i n   c ur l y br ac es

pl us 1( y)	/ /   =>   4:	y   i s   3,	s o   t hi s   i nvoc at i on r et ur ns   3+1

l et   s quar e   =   f unc t i on( x)    {    / /   Func t i ons   ar e   val ues   and   c an   be as s i gned   t o   var s
r et ur n   x   *   x;	/ /   Comput e   t he   f unc t i on' s   val ue
} ;	/ /   Semi c ol on   mar ks   t he   end   of    t he as s i gnment .

s quar e( pl us 1( y) )	/ /   =>   16:	i nvoke   t wo   f unc t i ons   i n   one expr es s i on


In ES6 and later, there is a shorthand syntax for defining functions. This concise syntax uses => to separate the argument list from the function body, so functions defined this way are known as arrow functions. Arrow functions are most commonly used when you want to pass an unnamed function as an argument to another function. The preceding code looks like this when rewritten to use arrow functions:

c ons t   pl us 1   =   x   =>   x   +   1;	/ /   The   i nput   x   maps   t o   t he   out put   x +   1
c ons t   s quar e   =   x   =>   x   *   x;	/ /   The   i nput   x   maps   t o   t he   out put   x *   x

pl us 1( y) s ame
s quar e( pl us 1( y) )

/ /   =>   4:	f unc t i on   i nvoc at i on   i s   t he

/ /   =>   16

When we use functions with objects, we get methods:


/ /   When   f unc t i ons   ar e   as s i gned   t o   t he   pr oper t i es   of    an   obj ec t , we   c al l
/ /   t hem " met hods . "	Al l	J avaSc r i pt   obj ec t s   ( i nc l udi ng   ar r ays ) have   met hods :
l et   a   =   [ ] ;	/ /   Cr eat e   an   empt y   ar r ay
a. pus h( 1, 2, 3) ;	/ /   The   pus h( )    met hod   adds   el ement s   t o an   ar r ay
a. r ever s e( ) ;	/ /   Anot her   met hod:	r ever s e   t he   or der of    el ement s


/ /   We   c an   def i ne   our   own   met hods ,	t oo.	The t o   t he   obj ec t
/ /   on   whi c h   t he   met hod   i s   def i ned:	i n   t hi s ar r ay   f r om ear l i er .

" t hi s "   keywor d   r ef er s

c as e,	t he   poi nt s

poi nt s . di s t   =   f unc t i on( )    {    / /   Def i ne   a   met hod   t o   c omput e di s t anc e   bet ween   poi nt s
l et   p1   =   t hi s [ 0] ;	/ /   Fi r s t   el ement   of    ar r ay   we' r e i nvoked   on
l et   p2   =   t hi s [ 1] ;	/ /   Sec ond   el ement   of    t he   " t hi s " obj ec t

l et   a   =   p2. x- p1. x;
l et   b   =   p2. y- p1. y;

/ /   Di f f er enc e   i n   x
/ /   Di f f er enc e   i n   y

c oor di nat es
c oor di nat es

r et ur n   Mat h. s qr t ( a*a   +   / /   The   Pyt hagor ean   t heor em
b*b) ;	/ /   Mat h. s qr t ( )    c omput es   t he   s quar e r oot
} ;
poi nt s . di s t ( )	/ /   =>   Mat h. s qr t ( 2) :	di s t anc e   bet ween our   2   poi nt s


Now, as promised, here are some functions whose bodies demonstrate common JavaScript control structure statements:


/ /   J avaSc r i pt t he   s ynt ax
/ /   of    C,	C++,

s t at ement s   i nc l ude   c ondi t i onal s   and   l oops   us i ng

J ava,	and   ot her   l anguages .

f unc t i on   abs ( x)    {	/ /   A  f unc t i on   t o   c omput e   t he   abs ol ut e val ue.
i f    ( x   >=   0)    {	/ /   The   i f    s t at ement . . .
r et ur n   x;	/ /   exec ut es   t hi s   c ode   i f    t he c ompar i s on   i s   t r ue.
}	/ /   Thi s   i s   t he   end   of    t he   i f    c l aus e.

el s e   {	/ /   The   opt i onal	el s e   c l aus e   exec ut es i t s   c ode   i f
r et ur n   - x;	/ /   t he   c ompar i s on   i s   f al s e.
}	/ /   Cur l y   br ac es   opt i onal	when   1 s t at ement   per   c l aus e.
}	/ /   Not e   r et ur n   s t at ement s   nes t ed i ns i de   i f / el s e.
abs ( - 10)    ===   abs ( 10)	/ /   =>   t r ue

f unc t i on   s um( ar r ay)    {	/ /   Comput e   t he   s um of    t he   el ement s   of an   ar r ay
l et   s um =   0;                               / /   St ar t   wi t h   an   i ni t i al    s um of    0. f or ( l et   x   of    ar r ay)    {      / /   L oop   over   ar r ay,    as s i gni ng   eac h
el ement   t o   x.
s um +=   x;	/ /   Add   t he   el ement   val ue   t o   t he   s um. }	/ /   Thi s   i s   t he   end   of    t he   l oop.
r et ur n   s um;	/ /   Ret ur n   t he   s um. }
s um( pr i mes )	/ /   =>   28:	s um of    t he   f i r s t   5   pr i mes 2+3+5+7+11

f unc t i on   f ac t or i al ( n)    {	/ /   A  f unc t i on   t o   c omput e   f ac t or i al s l et   pr oduc t   =   1;	/ /   St ar t   wi t h   a   pr oduc t   of    1
whi l e( n   >   1)    {	/ /   Repeat   s t at ement s   i n   { }    whi l e   expr i n   ( )    i s   t r ue
pr oduc t   *=   n;	/ /   Shor t c ut   f or   pr oduc t   =   pr oduc t   * n;
n- - ;	/ /   Shor t c ut   f or   n   =   n   -    1 }	/ /   End   of    l oop
r et ur n   pr oduc t ;	/ /   Ret ur n   t he   pr oduc t }
f ac t or i al ( 4)	/ /   =>   24:	1*4*3*2

f unc t i on   f ac t or i al 2( n)    {	/ /   Anot her   ver s i on   us i ng   a   di f f er ent l oop
l et   i ,	pr oduc t   =   1;	/ /   St ar t   wi t h   1
f or ( i =2;	i	<=   n;	i ++)	/ /   Aut omat i c al l y   i nc r ement   i	f r om 2 up   t o   n
pr oduc t   *=   i ;	/ /   Do   t hi s   eac h   t i me.	{ }    not   needed

f or   1- l i ne r et ur n
}

l oops
pr oduc t ;	/ /   Ret ur n   t he   f ac t or i al

f ac t or i al 2( 5)	/ /   =>   120:	1*2*3*4*5

JavaScript supports an object-oriented programming style, but it is significantly different than “classical” object-oriented programming languages. Chapter 9 covers object-oriented programming in JavaScript in detail, with lots of examples. Here is a very simple example that demonstrates how to define a JavaScript class to represent 2D geometric points. Objects that are instances of this class have a single method, named di s t ance( ) , that computes the distance of the point from the origin:


c l as s   Poi nt   {	/ /   By   c onvent i on,	c l as s   names   ar e c api t al i z ed.
c ons t r uc t or ( x,	y)    {	/ /   Cons t r uc t or   f unc t i on   t o   i ni t i al i z e new  i ns t anc es .
t hi s . x   =   x;	/ /   Thi s   keywor d   i s   t he   new  obj ec t bei ng   i ni t i al i z ed.
t hi s . y   =   y;	/ /   St or e   f unc t i on   ar gument s   as   obj ec t pr oper t i es .
}	/ /   No   r et ur n   i s   nec es s ar y   i n c ons t r uc t or   f unc t i ons .

di s t anc e( )    {	/ /   Met hod   t o   c omput e   di s t anc e   f r om or i gi n   t o   poi nt .
r et ur n   Mat h. s qr t (	/ /   Ret ur n   t he   s quar e   r oot   of    x²   +   y² . t hi s . x   *   t hi s . x   +	/ /   t hi s   r ef er s   t o   t he   Poi nt
obj ec t   on   whi c h
t hi s . y   *   t hi s . y	/ /   t he   di s t anc e   met hod   i s i nvoked.
) ; }
}

/ /   Us e   t he   Poi nt ( )    c ons t r uc t or   f unc t i on   wi t h   " new"   t o   c r eat e Poi nt   obj ec t s
l et   p   =   new  Poi nt ( 1,	1) ;	/ /   The   geomet r i c   poi nt   ( 1, 1) .

/ /   Now  us e   a   met hod   of    t he   Poi nt   obj ec t   p
p. di s t anc e( )	/ /   =>   Mat h. SQRT2


This introductory tour of JavaScript’s fundamental syntax and capabilities ends here, but the book continues with self-contained chapters that cover

additional features of the language:


Chapter 10, Modules

Shows how JavaScript code in one file or script can use JavaScript functions and classes defined in other files or scripts.

Chapter 11, The JavaScript Standard Library

Covers the built-in functions and classes that are available to all JavaScript programs. This includes important data stuctures like maps and sets, a regular expression class for textual pattern matching, functions for serializing JavaScript data structures, and much more.

Chapter 12, Iterators and Generators

Explains how the f or / of  loop works and how you can make your own classes iterable with f or / of . It also covers generator functions and the yi el d statement.

Chapter 13, Asynchronous JavaScript

This chapter is an in-depth exploration of asynchronous programming in JavaScript, covering callbacks and events, Promise-based APIs, and the as ync and awai t  keywords. Although the core JavaScript language is not asynchronous, asynchronous APIs are the default in both web browsers and Node, and this chapter explains the techniques for working with those APIs.

Chapter 14, Metaprogramming

Introduces a number of advanced features of JavaScript that may be of interest to programmers writing libraries of code for other JavaScript programmers to use.

Chapter 15, JavaScript in Web Browsers

Introduces the web browser host environment, explains how web browsers execute JavaScript code, and covers the most important of

the many APIs defined by web browsers. This is by far the longest chapter in the book.

Chapter 16, Server-Side JavaScript with Node

Introduces the Node host environment, covering the fundamental programming model and the data structures and APIs that are most important to understand.

Chapter 17, JavaScript Tools and Extensions

Covers tools and language extensions that are worth knowing about because they are widely used and may make you a more productive programmer.


1.4 Example: Character Frequency Histograms

This chapter concludes with a short but nontrivial JavaScript program. Example 1-1 is a Node program that reads text from standard input, computes a character frequency histogram from that text, and then prints out the histogram. You could invoke the program like this to analyze the character frequency of its own source code:

$   node   c har f r eq. j s   <   c har f r eq. j s T:	###########   11. 22%
E:	##########   10. 15% R:	#######   6. 68%
S:	######   6. 44% A:	######   6. 16% N:	######   5. 81% O:	#####   5. 45%
I :	#####   4. 54% H:	####   4. 07% C:	###   3. 36%
L :	###   3. 20% U:	###   3. 08% / :	###   2. 88%

This example uses a number of advanced JavaScript features and is intended to demonstrate what real-world JavaScript programs can look like. You should not expect to understand all of the code yet, but be assured that all of it will be explained in the chapters that follow.

Example 1-1. Computing character frequency histograms with JavaScript
/ **
*   Thi s   Node   pr ogr am r eads   t ext   f r om s t andar d   i nput ,	c omput es   t he f r equenc y
*   of    eac h   l et t er   i n   t hat   t ext ,	and   di s pl ays   a   hi s t ogr am of    t he mos t
*   f r equent l y   us ed   c har ac t er s .	I t   r equi r es   Node   12   or   hi gher   t o r un.
*
*   I n   a   Uni x- t ype   envi r onment   you   c an   i nvoke   t he   pr ogr am l i ke t hi s :
*	node   c har f r eq. j s   <   c or pus . t xt */


/ /   Thi s   c l as s   ext ends   Map   s o   t hat   t he s pec i f i ed
/ /   val ue   i ns t ead   of    nul l	when   t he   key

get ( )    met hod   r et ur ns   t he

i s   not   i n   t he   map

c l as s   Def aul t Map   ext ends   Map   { c ons t r uc t or ( def aul t Val ue)    {
s uper ( ) ;	/ /   I nvoke   s uper c l as s c ons t r uc t or
t hi s . def aul t Val ue   =   def aul t Val ue;	/ /   Remember   t he   def aul t val ue
}

get ( key)    {
i f    ( t hi s . has ( key) )    {	/ /   I f    t he   key   i s   al r eady i n   t he   map
r et ur n   s uper . get ( key) ;	/ /   r et ur n   i t s   val ue   f r om s uper c l as s .
}
el s e   {


def aul t

}
}

r et ur n   t hi s . def aul t Val ue;	/ /   Ot her wi s e   r et ur n   t he val ue
}

/ /   Thi s   c l as s   c omput es   and   di s pl ays   l et t er   f r equenc y   hi s t ogr ams c l as s   Hi s t ogr am {
c ons t r uc t or ( )    {
t hi s . l et t er Count s   =   new  Def aul t Map( 0) ;	/ /   Map   f r om l et t er s   t o   c ount s
t hi s . t ot al L et t er s   =   0;	/ /   How  many l et t er s   i n   al l
}

/ /   Thi s   f unc t i on   updat es   t he   hi s t ogr am wi t h   t he   l et t er s   of t ext .
add( t ext )    {
/ /   Remove   whi t es pac e   f r om t he   t ext ,	and   c onver t   t o   upper c as e
t ext   =   t ext . r epl ac e( / \ s / g,	" " ) . t oUpper Cas e( ) ;

/ /   Now  l oop   t hr ough   t he   c har ac t er s   of    t he   t ext f or ( l et   c har ac t er   of    t ext )    {
l et   c ount   =   t hi s . l et t er Count s . get ( c har ac t er ) ;	/ /   Get ol d   c ount


I nc r ement

}
}

t hi s . l et t er Count s . s et ( c har ac t er ,	c ount +1) ;	/ / i t
t hi s . t ot al L et t er s ++;



/ /   Conver t gr aphi c
t oSt r i ng( )

t he   hi s t ogr am t o   a   s t r i ng   t hat   di s pl ays   an   ASCI I

{

/ /   Conver t   t he   Map   t o   an   ar r ay   of    [ key, val ue]    ar r ays l et   ent r i es   =   [ . . . t hi s . l et t er Count s ] ;

/ /   Sor t   t he   ar r ay   by   c ount ,	t hen   al phabet i c al l y
ent r i es . s or t ( ( a, b)    =>   {	/ /   A  f unc t i on   t o def i ne   s or t   or der .
i f    ( a[ 1]    ===   b[ 1] )    {	/ /   I f    t he   c ount s   ar e t he   s ame
r et ur n   a[ 0]    <   b[ 0]    ?   - 1   :	1;	/ /   s or t al phabet i c al l y.
}    el s e   {	/ /   I f    t he   c ount s di f f er
r et ur n   b[ 1]    -    a[ 1] ;	/ /   s or t   by   l ar ges t c ount .
} } ) ;


/ /   Conver t   t he   c ount s   t o   per c ent ages f or ( l et   ent r y   of    ent r i es )    {
ent r y[ 1]    =   ent r y[ 1]    /   t hi s . t ot al L et t er s *100; }

/ /   Dr op   any   ent r i es   l es s   t han   1%
ent r i es   =   ent r i es . f i l t er ( ent r y   =>   ent r y[ 1]    >=   1) ;

/ /   Now  c onver t   eac h   ent r y   t o   a   l i ne   of    t ext l et   l i nes   =   ent r i es . map(
( [ l , n] )    =>   ` ${ l } :	${ " #" . r epeat ( Mat h. r ound( n) ) } ${ n. t oFi xed( 2) } %`
) ;

/ /   And   r et ur n   t he   c onc at enat ed   l i nes ,	s epar at ed   by   newl i ne c har ac t er s .
r et ur n   l i nes . j oi n( " \ n" ) ;
} }


/ /   Thi s   as ync   ( Pr omi s e- r et ur ni ng) obj ec t ,
/ /   as ync hr onous l y   r eads   c hunks   of adds   t hos e   c hunks   t o
/ /   t he   hi s t ogr am.	When   i t   r eac hes r et ur ns   t hi s   hi s t ogr am

f unc t i on   c r eat es   a   Hi s t ogr am

t ext   f r om s t andar d   i nput ,	and

t he   end   of    t he   s t r eam,	i t

as ync   f unc t i on   hi s t ogr amFr omSt di n( )    {
pr oc es s . s t di n. s et Enc odi ng( " ut f - 8" ) ;	/ /   Read   Uni c ode   s t r i ngs , not   byt es
l et   hi s t ogr am =   new  Hi s t ogr am( ) ;
f or   awai t   ( l et   c hunk   of    pr oc es s . s t di n)    { hi s t ogr am. add( c hunk) ;
}
r et ur n   hi s t ogr am; }


/ /   Thi s   one   f i nal	l i ne   of    c ode / /   I t   makes   a   Hi s t ogr am obj ec t t he   hi s t ogr am.

i s   t he   mai n   body   of    t he   pr ogr am. f r om s t andar d   i nput ,    t hen   pr i nt s

hi s t ogr amFr omSt di n( ) . t hen( hi s t ogr am =>   { c ons ol e. l og( hi s t ogr am. t oSt r i ng( ) ) ;	} ) ;

1.5 Summary

This book explains JavaScript from the bottom up. This means that we start with low-level details like comments, identifiers, variables, and types; then build to expressions, statements, objects, and functions; and then cover high-level language abstractions like classes and modules. I take the word definitive in the title of this book seriously, and the coming chapters explain the language at a level of detail that may feel off-putting at first. True mastery of JavaScript requires an understanding of the details, however, and I hope that you will make time to read this book cover to cover. But please don’t feel that you need to do that on your first reading. If you find yourself feeling bogged down in a section, simply skip to the next. You can come back and master the details once you have a working knowledge of the language as a whole.



Chapter 2. Lexical Structure




The lexical structure of a programming language is the set of elementary rules that specifies how you write programs in that language. It is the lowest-level syntax of a language: it specifies what variable names look like, the delimiter characters for comments, and how one program statement is separated from the next, for example. This short chapter documents the lexical structure of JavaScript. It covers:

Case sensitivity, spaces, and line breaks

Comments

Literals

Identifiers and reserved words

Unicode

Optional semicolons


2.1 The Text of a J avaScript Program

JavaScript is a case-sensitive language. This means that language keywords, variables, function names, and other identifiers must always be typed with a consistent capitalization of letters. The whi l e keyword, for example, must be typed “while,” not “While” or “WHILE.” Similarly, onl i ne, Onl i ne, OnLi ne, and ONLI NE are four distinct variable names.

JavaScript ignores spaces that appear between tokens in programs. For the

most part, JavaScript also ignores line breaks (but see §2.6 for an exception). Because you can use spaces and newlines freely in your programs, you can format and indent your programs in a neat and consistent way that makes the code easy to read and understand.


In addition to the regular space character (\ u0020), JavaScript also recognizes tabs, assorted ASCII control characters, and various Unicode space characters as whitespace. JavaScript recognizes newlines, carriage returns, and a carriage return/line feed sequence as line terminators.


2.2 Comments

JavaScript supports two styles of comments. Any text between a / /  and the end of a line is treated as a comment and is ignored by JavaScript. Any text between the characters / * and */  is also treated as a comment; these comments may span multiple lines but may not be nested. The following lines of code are all legal JavaScript comments:

/ /   Thi s   i s   a   s i ngl e- l i ne   c omment .

/ *   Thi s   i s   al s o   a   c omment   */	/ /   and   her e   i s   anot her   c omment .


/ *
*   Thi s   i s   a s t ar t   of
*   eac h   l i ne l ook   c ool !
*/


mul t i - l i ne   c omment .	The

ar e   not   a   r equi r ed   par t


ext r a   *   c har ac t er s   at   t he

of    t he   s ynt ax;	t hey   j us t



2.3 Literals

A literal is a data value that appears directly in a program. The following are all literals:


12 1. 2
" hel l o   wor l d" ' Hi '
t r ue
f al s e nul l

/ /   The   number   t wel ve
/ /   The   number   one   poi nt   t wo / /   A  s t r i ng   of    t ext
/ /   Anot her   s t r i ng / /   A  Bool ean   val ue
/ /   The   ot her   Bool ean   val ue / /   Abs enc e   of    an   obj ec t



Complete details on numeric and string literals appear in Chapter 3.



2.4 Identifiers and Reserved Words

An identifier is simply a name. In JavaScript, identifiers are used to name constants, variables, properties, functions, and classes and to provide labels for certain loops in JavaScript code. A JavaScript identifier must begin with a letter, an underscore (_), or a dollar sign ($). Subsequent characters can be letters, digits, underscores, or dollar signs. (Digits are not allowed as the first character so that JavaScript can easily distinguish identifiers from numbers.) These are all legal identifiers:

i
my_var i abl e_name v13
_dummy $s t r


Like any language, JavaScript reserves certain identifiers for use by the language itself. These “reserved words” cannot be used as regular identifiers. They are listed in the next section.


2.4.1 Reserved Words

The following words are part of the JavaScript language. Many of these (such as i f , whi l e, and f or ) are reserved keywords that must not be used as the names of constants, variables, functions, or classes (though

they can all be used as the names of properties within an object). Others (such as f r om, of , get , and s et ) are used in limited contexts with no syntactic ambiguity and are perfectly legal as identifiers. Still other keywords (such as l et ) can’t be fully reserved in order to retain backward compatibility with older programs, and so there are complex rules that govern when they can be used as identifiers and when they cannot. (l et  can be used as a variable name if declared with var  outside of a class, for example, but not if declared inside a class or with cons t .) The simplest course is to avoid using any of these words as identifiers, except for f r om, s et , and t ar get , which are safe to use and are already in common use.


as	c ons t
as ync	c ont i nue whi l e
awai t	debugger br eak	def aul t yi el d
c as e	del et e c at c h	do
c l as s	el s e

expor t ext ends

f al s e
f i nal l y

f or
f r om
f unc t i on

get	nul l	t ar get	voi d i f	of	t hi s

i mpor t	r et ur n	t hr ow	wi t h i n	s et	t r ue

i ns t anc eof	s t at i c	t r y
l et	s uper	t ypeof new	s wi t c h	var



JavaScript also reserves or restricts the use of certain keywords that are not currently used by the language but that might be used in future versions:

enum	i mpl ement s	i nt er f ac e	pac kage	pr i vat e	pr ot ec t ed	publ i c


For historical reasons, ar gument s  and eval  are not allowed as identifiers in certain circumstances and are best avoided entirely.


2.5 Unicode

JavaScript programs are written using the Unicode character set, and you

can use any Unicode characters in strings and comments. For portability and ease of editing, it is common to use only ASCII letters and digits in identifiers. But this is a programming convention only, and the language allows Unicode letters, digits, and ideographs (but not emojis) in identifiers. This means that programmers can use mathematical symbols and words from non-English languages as constants and variables:

c ons t   π  =   3. 14; c ons t   s í	=   t r ue;


2.5.1 Unicode Escape Sequences

Some computer hardware and software cannot display, input, or correctly process the full set of Unicode characters. To support programmers and systems using older technology, JavaScript defines escape sequences that allow us to write Unicode characters using only ASCII characters. These Unicode escapes begin with the characters \ u and are either followed by exactly four hexadecimal digits (using uppercase or lowercase letters A–F) or by one to six hexadecimal digits enclosed within curly braces. These Unicode escapes may appear in JavaScript string literals, regular expression literals, and identifiers (but not in language keywords). The Unicode escape for the character “é,” for example, is \ u00E9; here are three different ways to write a variable name that includes this character:

l et   c af é   =   1;	/ /   Def i ne   a   var i abl e   us i ng   a   Uni c ode   c har ac t er c af \ u00e9	/ /   =>   1;	ac c es s   t he   var i abl e   us i ng   an   es c ape
s equenc e
c af \ u{ E9}	/ /   =>   1;	anot her   f or m of    t he   s ame   es c ape   s equenc e


Early versions of JavaScript only supported the four-digit escape sequence. The version with curly braces was introduced in ES6 to better support Unicode codepoints that require more than 16 bits, such as emoji:

c ons ol e. l og( " \ u{ 1F600} " ) ;	/ /   Pr i nt s   a   s mi l ey   f ac e   emoj i


Unicode escapes may also appear in comments, but since comments are ignored, they are simply treated as ASCII characters in that context and not interpreted as Unicode.


2.5.2 Unicode Normalization

If you use non-ASCII characters in your JavaScript programs, you must be aware that Unicode allows more than one way of encoding the same character. The string “é,” for example, can be encoded as the single Unicode character \ u00E9 or as a regular ASCII “e” followed by the acute accent combining mark \ u0301. These two encodings typically look exactly the same when displayed by a text editor, but they have different binary encodings, meaning that they are considered different by JavaScript, which can lead to very confusing programs:

c ons t   c af é   =   1;	/ /   Thi s   c ons t ant   i s   named   " c af \ u{ e9} "
c ons t   c af é   =   2;	/ /   Thi s   c ons t ant   i s   di f f er ent :	" c af e\ u{ 301} "

c af é	/ /   =>   1: c af é	/ /   =>   2: val ue

t hi s   c ons t ant   has   one   val ue
t hi s   i ndi s t i ngui s habl e   c ons t ant   has   a   di f f er ent



The Unicode standard defines the preferred encoding for all characters and specifies a normalization procedure to convert text to a canonical form suitable for comparisons. JavaScript assumes that the source code it is interpreting has already been normalized and does not do any normalization on its own. If you plan to use Unicode characters in your JavaScript programs, you should ensure that your editor or some other tool performs Unicode normalization of your source code to prevent you from ending up with different but visually indistinguishable identifiers.

2.6 Optional Semicolons

Like many programming languages, JavaScript uses the semicolon (; ) to separate statements (see Chapter 5) from one another. This is important for making the meaning of your code clear: without a separator, the end of one statement might appear to be the beginning of the next, or vice versa. In JavaScript, you can usually omit the semicolon between two statements if those statements are written on separate lines. (You can also omit a semicolon at the end of a program or if the next token in the program is a closing curly brace: } .) Many JavaScript programmers (and the code in this book) use semicolons to explicitly mark the ends of statements, even where they are not required. Another style is to omit semicolons whenever possible, using them only in the few situations that require them. Whichever style you choose, there are a few details you should understand about optional semicolons in JavaScript.

Consider the following code. Since the two statements appear on separate lines, the first semicolon could be omitted:

a   =   3; b   =   4;


Written as follows, however, the first semicolon is required:


a   =   3;	b   =   4;


Note that JavaScript does not treat every line break as a semicolon: it usually treats line breaks as semicolons only if it can’t parse the code without adding an implicit semicolon. More formally (and with three exceptions described a bit later), JavaScript treats a line break as a semicolon if the next nonspace character cannot be interpreted as a

continuation of the current statement. Consider the following code:


l et   a a
= 3
c ons ol e. l og( a)


JavaScript interprets this code like this:


l et   a;	a   =   3;	c ons ol e. l og( a) ;


JavaScript does treat the first line break as a semicolon because it cannot parse the code l et   a   a without a semicolon. The second a could stand alone as the statement a; , but JavaScript does not treat the second line break as a semicolon because it can continue parsing the longer statement a   =   3; .


These statement termination rules lead to some surprising cases. This code looks like two separate statements separated with a newline:

l et   y   =   x   +   f
( a+b) . t oSt r i ng( )


But the parentheses on the second line of code can be interpreted as a function invocation of f  from the first line, and JavaScript interprets the code like this:

l et   y   =   x   +   f ( a+b) . t oSt r i ng( ) ;


More likely than not, this is not the interpretation intended by the author of the code. In order to work as two separate statements, an explicit semicolon is required in this case.

In general, if a statement begins with ( , [ , / , +, or - , there is a chance that it could be interpreted as a continuation of the statement before. Statements beginning with / , +, and -  are quite rare in practice, but statements beginning with (  and [  are not uncommon at all, at least in some styles of JavaScript programming. Some programmers like to put a defensive semicolon at the beginning of any such statement so that it will continue to work correctly even if the statement before it is modified and a previously terminating semicolon removed:

l et   x   =   0	/ /   Semi c ol on   omi t t ed   her e ; [ x, x+1, x+2] . f or Eac h( c ons ol e. l og)    / /   Def ens i ve   ;	keeps   t hi s s t at ement   s epar at e


There are three exceptions to the general rule that JavaScript interprets line breaks as semicolons when it cannot parse the second line as a continuation of the statement on the first line. The first exception involves the r et ur n, t hr ow, yi el d, br eak, and cont i nue statements (see Chapter 5). These statements often stand alone, but they are sometimes followed by an identifier or expression. If a line break appears after any of these words (before any other tokens), JavaScript will always interpret that line break as a semicolon. For example, if you write:

r et ur n t r ue;


JavaScript assumes you meant:


r et ur n;	t r ue;


However, you probably meant:


r et ur n   t r ue;

This means that you must not insert a line break between r et ur n,
br eak, or cont i nue and the expression that follows the keyword. If you do insert a line break, your code is likely to fail in a nonobvious way that is difficult to debug.

The second exception involves the ++ and −− operators (§4.8). These operators can be prefix operators that appear before an expression or postfix operators that appear after an expression. If you want to use either of these operators as postfix operators, they must appear on the same line as the expression they apply to. The third exception involves functions defined using concise “arrow” syntax: the => arrow itself must appear on the same line as the parameter list.


2.7 Summary

This chapter has shown how JavaScript programs are written at the lowest level. The next chapter takes us one step higher and introduces the primitive types and values (numbers, strings, and so on) that serve as the basic units of computation for JavaScript programs.



Chapter 3. Types, Values, and Variables




Computer programs work by manipulating values, such as the number 3.14 or the text “Hello World.” The kinds of values that can be represented and manipulated in a programming language are known as types, and one of the most fundamental characteristics of a programming language is the set of types it supports. When a program needs to retain a value for future use, it assigns the value to (or “stores” the value in) a variable. Variables have names, and they allow use of those names in our programs to refer to values. The way that variables work is another fundamental characteristic of any programming language. This chapter explains types, values, and variables in JavaScript. It begins with an overview and some definitions.


3.1 Overview and Definitions

JavaScript types can be divided into two categories: primitive types and object types. JavaScript’s primitive types include numbers, strings of text (known as strings), and Boolean truth values (known as booleans). A significant portion of this chapter is dedicated to a detailed explanation of the numeric (§3.2) and string (§3.3) types in JavaScript. Booleans are covered in §3.4.


The special JavaScript values nul l  and undef i ned are primitive values, but they are not numbers, strings, or booleans. Each value is typically considered to be the sole member of its own special type. §3.5 has more about nul l  and undef i ned. ES6 adds a new special-purpose

type, known as Symbol, that enables the definition of language extensions without harming backward compatibility. Symbols are covered briefly in §3.6.


Any JavaScript value that is not a number, a string, a boolean, a symbol, nul l , or undef i ned is an object. An object (that is, a member of the type object) is a collection of properties where each property has a name and a value (either a primitive value or another object). One very special object, the global object, is covered in §3.7, but more general and more detailed coverage of objects is in Chapter 6.

An ordinary JavaScript object is an unordered collection of named values. The language also defines a special kind of object, known as an array, that represents an ordered collection of numbered values. The JavaScript language includes special syntax for working with arrays, and arrays have some special behavior that distinguishes them from ordinary objects. Arrays are the subject of Chapter 7.


In addition to basic objects and arrays, JavaScript defines a number of other useful object types. A Set object represents a set of values. A Map object represents a mapping from keys to values. Various “typed array” types facilitate operations on arrays of bytes and other binary data. The RegExp type represents textual patterns and enables sophisticated matching, searching, and replacing operations on strings. The Date type represents dates and times and supports rudimentary date arithmetic. Error and its subtypes represent errors that can arise when executing JavaScript code. All of these types are covered in Chapter 11.


JavaScript differs from more static languages in that functions and classes are not just part of the language syntax: they are themselves values that

can be manipulated by JavaScript programs. Like any JavaScript value that is not a primitive value, functions and classes are a specialized kind of object. They are covered in detail in Chapters 8 and 9.


The JavaScript interpreter performs automatic garbage collection for memory management. This means that a JavaScript programmer generally does not need to worry about destruction or deallocation of objects or other values. When a value is no longer reachable—when a program no longer has any way to refer to it—the interpreter knows it can never be used again and automatically reclaims the memory it was occupying. (JavaScript programmers do sometimes need to take care to ensure that values do not inadvertently remain reachable—and therefore nonreclaimable—longer than necessary.)


JavaScript supports an object-oriented programming style. Loosely, this means that rather than having globally defined functions to operate on values of various types, the types themselves define methods for working with values. To sort the elements of an array a, for example, we don’t pass a to a s or t ( )  function. Instead, we invoke the s or t ( )  method of a:


a. s or t ( ) ;	/ /   The   obj ec t - or i ent ed   ver s i on   of    s or t ( a) .


Method definition is covered in Chapter 9. Technically, it is only JavaScript objects that have methods. But numbers, strings, boolean, and symbol values behave as if they have methods. In JavaScript, nul l  and undef i ned are the only values that methods cannot be invoked on.


JavaScript’s object types are mutable and its primitive types are immutable. A value of a mutable type can change: a JavaScript program can change the values of object properties and array elements. Numbers,

booleans, symbols, nul l , and undef i ned are immutable—it doesn’t even make sense to talk about changing the value of a number, for example. Strings can be thought of as arrays of characters, and you might expect them to be mutable. In JavaScript, however, strings are immutable: you can access the text at any index of a string, but JavaScript provides no way to alter the text of an existing string. The differences between mutable and immutable values are explored further in §3.8.

JavaScript liberally converts values from one type to another. If a program expects a string, for example, and you give it a number, it will automatically convert the number to a string for you. And if you use a
non-boolean value where a boolean is expected, JavaScript will convert accordingly. The rules for value conversion are explained in §3.9. JavaScript’s liberal value conversion rules affect its definition of equality, and the == equality operator performs type conversions as described in §3.9.1. (In practice, however, the == equality operator is deprecated in favor of the strict equality operator ===, which does no type conversions. See §4.9.1 for more about both operators.)

Constants and variables allow you to use names to refer to values in your programs. Constants are declared with cons t  and variables are declared with l et  (or with var  in older JavaScript code). JavaScript constants and variables are untyped: declarations do not specify what kind of values will be assigned. Variable declaration and assignment are covered in §3.10.

As you can see from this long introduction, this is a wide-ranging chapter that explains many fundamental details about how data is represented and manipulated in JavaScript. We’ll begin by diving right in to the details of JavaScript numbers and text.

3.2 Numbers

JavaScript’s primary numeric type, Number, is used to represent integers and to approximate real numbers. JavaScript represents numbers using the 64-bit floating-point format defined by the IEEE 754 standard,1 which means it can represent numbers as large as ±1.7976931348623157 × 10308 and as small as ±5 × 10−324.


The JavaScript number format allows you to exactly represent all integers between −9,007,199,254,740,992 (−253) and 9,007,199,254,740,992 (253), inclusive. If you use integer values larger than this, you may lose precision in the trailing digits. Note, however, that certain operations in JavaScript (such as array indexing and the bitwise operators described in Chapter 4) are performed with 32-bit integers. If you need to exactly represent larger integers, see §3.2.5.


When a number appears directly in a JavaScript program, it’s called a numeric literal. JavaScript supports numeric literals in several formats, as described in the following sections. Note that any numeric literal can be preceded by a minus sign (-) to make the number negative.


3.2.1 Integer Literals

In a JavaScript program, a base-10 integer is written as a sequence of digits. For example:

0 3
10000000


In addition to base-10 integer literals, JavaScript recognizes hexadecimal (base-16) values. A hexadecimal literal begins with 0x or 0X, followed by

a string of hexadecimal digits. A hexadecimal digit is one of the digits 0 through 9 or the letters a (or A) through f (or F), which represent values 10 through 15. Here are examples of hexadecimal integer literals:


0xf f 0xBADCAFE

/ /   =>   255:	( 15*16   +   15) / /   =>   195939070



In ES6 and later, you can also express integers in binary (base 2) or octal (base 8) using the prefixes 0b and 0o (or 0B and 0O) instead of 0x:


0b10101 0o377

/ /   =>   21: / /   =>   255:

( 1*16   +   0*8   + ( 3*64   +   7*8   +

1*4   +   0*2   +   1*1) 7*1)



3.2.2 Floating-Point Literals

Floating-point literals can have a decimal point; they use the traditional syntax for real numbers. A real value is represented as the integral part of the number, followed by a decimal point and the fractional part of the number.


Floating-point literals may also be represented using exponential notation: a real number followed by the letter e (or E), followed by an optional plus or minus sign, followed by an integer exponent. This notation represents the real number multiplied by 10 to the power of the exponent.


More succinctly, the syntax is:


[ di gi t s ] [ . di gi t s ] [ ( E|e) [ ( +|- ) ] di gi t s ]


For example:


3. 14
2345. 6789
. 333333333333333333
6. 02e23	/ /   6. 02   ×   10² ³

1. 4738223E- 32	/ /   1. 4738223   ×   10⁻ ³ ²



SEPARATORS IN NUMERIC LITERALS

You can use underscores within numeric literals to break long literals up into chunks that are easier to read:


l et   bi l l i on   =   1_000_000_000; l et   byt es   =   0x89_AB_CD_EF;
l et   bi t s   =   0b0001_1101_0111;

/ /   Under s c or e   as   a   t hous ands   s epar at or . / /   As   a   byt es   s epar at or .
/ /   As   a   ni bbl e   s epar at or .

l et   f r act i on   =   0. 123_456_789;	/ /   Wor ks   i n   t he   f r ac t i onal    par t ,    t oo.


At the time of this writing in early 2020, underscores in numeric literals are not yet formally standardized as part of JavaScript. But they are in the advanced stages of the standardization process and are implemented by all major browsers and by Node.



3.2.3 Arithmetic in J avaScript

JavaScript programs work with numbers using the arithmetic operators . that the language provides. These include + for addition, -  for subtraction, * for multiplication, /  for division, and %for modulo (remainder after division). ES2016 adds ** for exponentiation. Full details on these and other operators can be found in Chapter 4.

In addition to these basic arithmetic operators, JavaScript supports more complex mathematical operations through a set of functions and constants defined as properties of the Mat h object:


Mat h. pow( 2, 53)	/ /   =>   9007199254740992:	2   t o   t he   power 53
Mat h. r ound( . 6)	/ /   =>   1. 0:	r ound   t o   t he   near es t   i nt eger Mat h. c ei l ( . 6)	/ /   =>   1. 0:	r ound   up   t o   an   i nt eger
Mat h. f l oor ( . 6)	/ /   =>   0. 0:	r ound   down   t o   an   i nt eger Mat h. abs ( - 5)	/ /   =>   5:	abs ol ut e   val ue
Mat h. max( x, y, z )	/ /   Ret ur n   t he   l ar ges t   ar gument Mat h. mi n( x, y, z )	/ /   Ret ur n   t he   s mal l es t   ar gument
Mat h. r andom( )	/ /   Ps eudo- r andom number   x   wher e   0   <=   x

<   1. 0
Mat h. PI	/ /   π:	c i r c umf er enc e   of    a   c i r c l e   / di amet er
Mat h. E	/ /   e:	The   bas e   of    t he   nat ur al	l ogar i t hm Mat h. s qr t ( 3)	/ /   =>   3**0. 5:	t he   s quar e   r oot   of    3
Mat h. pow( 3,	1/ 3)	/ /   =>   3**( 1/ 3) :	t he   c ube   r oot   of    3 Mat h. s i n( 0)                                       / /   Tr i gonomet r y:    al s o   Mat h. c os ,
Mat h. at an,	et c .
Mat h. l og( 10)	/ /   Nat ur al	l ogar i t hm of    10 Mat h. l og( 100) / Mat h. L N10	/ /   Bas e   10   l ogar i t hm of    100 Mat h. l og( 512) / Mat h. L N2	/ /   Bas e   2   l ogar i t hm of    512 Mat h. exp( 3)	/ /   Mat h. E   c ubed


ES6 defines more functions on the Mat h object:


Mat h. c br t ( 27)	/ /   =>   3:	c ube   r oot
Mat h. hypot ( 3,	4)    / /   =>   5:	s quar e   r oot   of    s um of    s quar es   of    al l ar gument s
Mat h. l og10( 100)      / /   =>   2:    Bas e- 10   l ogar i t hm Mat h. l og2( 1024)      / /   =>   10:    Bas e- 2   l ogar i t hm
Mat h. l og1p( x)	/ /   Nat ur al	l og   of    ( 1+x) ;	ac c ur at e   f or   ver y s mal l	x
Mat h. expm1( x)	/ /   Mat h. exp( x) - 1;	t he   i nver s e   of    Mat h. l og1p( ) Mat h. s i gn( x)	/ /   - 1,	0,	or   1   f or   ar gument s   <,	==,	or   >   0 Mat h. i mul ( 2, 3)	/ /   =>   6:    opt i mi z ed   mul t i pl i c at i on   of    32- bi t
i nt eger s
Mat h. c l z 32( 0xf )	/ /   =>   28:	number   of    l eadi ng   z er o   bi t s   i n   a   32-bi t   i nt eger
Mat h. t r unc ( 3. 9)	/ /   =>   3:	c onver t   t o   an   i nt eger   by   t r unc at i ng f r ac t i onal	par t
Mat h. f r ound( x)	/ /   Round   t o   near es t   32- bi t   f l oat   number Mat h. s i nh( x)	/ /   Hyper bol i c   s i ne.	Al s o   Mat h. c os h( ) , Mat h. t anh( )
Mat h. as i nh( x)	/ /   Hyper bol i c   ar c s i ne.	Al s o   Mat h. ac os h( ) , Mat h. at anh( )

Arithmetic in JavaScript does not raise errors in cases of overflow, underflow, or division by zero. When the result of a numeric operation is larger than the largest representable number (overflow), the result is a special infinity value, I nf i ni t y. Similarly, when the absolute value of a

negative value becomes larger than the absolute value of the largest representable negative number, the result is negative infinity, -
I nf i ni t y. The infinite values behave as you would expect: adding, subtracting, multiplying, or dividing them by anything results in an infinite value (possibly with the sign reversed).

Underflow occurs when the result of a numeric operation is closer to zero than the smallest representable number. In this case, JavaScript returns 0. If underflow occurs from a negative number, JavaScript returns a special value known as “negative zero.” This value is almost completely indistinguishable from regular zero and JavaScript programmers rarely need to detect it.


Division by zero is not an error in JavaScript: it simply returns infinity or negative infinity. There is one exception, however: zero divided by zero does not have a well-defined value, and the result of this operation is the special not-a-number value, NaN. NaN also arises if you attempt to divide infinity by infinity, take the square root of a negative number, or use arithmetic operators with non-numeric operands that cannot be converted to numbers.

JavaScript predefines global constants I nf i ni t y and NaN to hold the positive infinity and not-a-number value, and these values are also available as properties of the Number  object:

I nf i ni t y	/ /   A  pos i t i ve   number   t oo   bi g   t o r epr es ent
Number . POSI TI VE_I NFI NI TY	/ /   Same   val ue

1/ 0
Number . MAX_VAL UE   *   2

/ /   =>   I nf i ni t y
/ /   =>   I nf i ni t y;	over f l ow


- I nf i ni t y	/ /   A  negat i ve   number   t oo   bi g   t o r epr es ent

Number . NEGATI VE_I NFI NI TY	/ /   The   s ame   val ue

- 1/ 0
- Number . MAX_VAL UE   *   2

/ /   =>   - I nf i ni t y / /   =>   - I nf i ni t y


NaN	/ /   The   not - a- number   val ue
Number . NaN	/ /   The   s ame   val ue,	wr i t t en   anot her

way 0/ 0
I nf i ni t y/ I nf i ni t y


/ /   =>   NaN / /   =>   NaN


Number . MI N_VAL UE/ 2	/ /   =>   0:	under f l ow
- Number . MI N_VAL UE/ 2	/ /   =>   - 0:	negat i ve   z er o
- 1/ I nf i ni t y	/ /   - >   - 0:	al s o   negat i ve   0 - 0

/ /   The   f ol l owi ng   Number   pr oper t i es   ar e   def i ned   i n   ES6

Number . par s eI nt ( ) f unc t i on
Number . par s eFl oat ( ) f unc t i on

/ /   Same   as

/ /   Same   as

t he   gl obal

t he   gl obal

par s eI nt ( )

par s eFl oat ( )

Number . i s NaN( x)	/ /   I s   x   t he   NaN  val ue?
Number . i s Fi ni t e( x)	/ /   I s   x   a   number   and   f i ni t e? Number . i s I nt eger ( x)	/ /   I s   x   an   i nt eger ?
Number . i s Saf eI nt eger ( x)    / /   I s   x   an   i nt eger   - ( 2**53)    <   x   <   2**53? Number . MI N_SAFE_I NTEGER  / /   =>   - ( 2**53   -    1)
Number . MAX_SAFE_I NTEGER  / /   =>   2**53   -    1
Number . EPSI L ON	/ /   =>   2**- 52:	s mal l es t   di f f er enc e bet ween   number s


The not-a-number value has one unusual feature in JavaScript: it does not compare equal to any other value, including itself. This means that you can’t write x   ===   NaN to determine whether the value of a variable x is NaN. Instead, you must write x   ! =   x or Number . i s NaN( x) . Those expressions will be true if, and only if, x has the same value as the global constant NaN.


The global function i s NaN( )  is similar to Number . i s NaN( ) . It returns t r ue if its argument is NaN, or if that argument is a non-numeric value that cannot be converted to a number. The related function

Number . i s Fi ni t e( )  returns t r ue if its argument is a number other than NaN, I nf i ni t y, or - I nf i ni t y. The global i s Fi ni t e( ) function returns t r ue if its argument is, or can be converted to, a finite number.

The negative zero value is also somewhat unusual. It compares equal (even using JavaScript’s strict equality test) to positive zero, which means that the two values are almost indistinguishable, except when used as a divisor:

l et   z er o   =   0;	/ /   Regul ar   z er o
l et   negz   =   - 0;	/ /   Negat i ve   z er o

z er o   ===   negz equal
1/ z er o   ===   1/ negz not   equal

/ /   =>   t r ue:	z er o   and   negat i ve   z er o   ar e

/ /   =>   f al s e:	I nf i ni t y   and   - I nf i ni t y   ar e



3.2.4 Binary Floating-Point and Rounding Errors

There are infinitely many real numbers, but only a finite number of them (18,437,736,874,454,810,627, to be exact) can be represented exactly by the JavaScript floating-point format. This means that when you’re working with real numbers in JavaScript, the representation of the number will often be an approximation of the actual number.


The IEEE-754 floating-point representation used by JavaScript (and just about every other modern programming language) is a binary representation, which can exactly represent fractions like 1/ 2, 1/ 8, and 1/ 1024. Unfortunately, the fractions we use most commonly (especially when performing financial calculations) are decimal fractions: 1/ 10,
1/ 100, and so on. Binary floating-point representations cannot exactly represent numbers as simple as 0. 1.

JavaScript numbers have plenty of precision and can approximate 0. 1 very closely. But the fact that this number cannot be represented exactly can lead to problems. Consider this code:


l et   x   =   . 3   -    . 2;
l et   y   =   . 2   -    . 1;

/ /   t hi r t y   c ent s   mi nus
/ /   t went y   c ent s   mi nus

20   c ent s
10   c ent s

x   ===   y	/ /   =>   f al s e:	t he   t wo   val ues   ar e   not   t he s ame!
x   ===   . 1	/ /   =>   f al s e:	. 3- . 2   i s   not   equal	t o   . 1
y   ===   . 1	/ /   =>   t r ue:	. 2- . 1   i s   equal	t o   . 1


Because of rounding error, the difference between the approximations of .3 and .2 is not exactly the same as the difference between the approximations of .2 and .1. It is important to understand that this problem is not specific to JavaScript: it affects any programming language that uses binary floating-point numbers. Also, note that the values x and y in the code shown here are very close to each other and to the correct value. The computed values are adequate for almost any purpose; the problem only arises when we attempt to compare values for equality.

If these floating-point approximations are problematic for your programs, consider using scaled integers. For example, you might manipulate monetary values as integer cents rather than fractional dollars.


3.2.5 Arbitrary Precision Integers with BigInt

One of the newest features of JavaScript, defined in ES2020, is a new numeric type known as BigInt. As of early 2020, it has been implemented in Chrome, Firefox, Edge, and Node, and there is an implementation in progress in Safari. As the name implies, BigInt is a numeric type whose values are integers. The type was added to JavaScript mainly to allow the representation of 64-bit integers, which are required for compatibility with

many other programming languages and APIs. But BigInt values can have thousands or even millions of digits, should you have need to work with numbers that large. (Note, however, that BigInt implementations are not suitable for cryptography because they do not attempt to prevent timing attacks.)


BigInt literals are written as a string of digits followed by a lowercase letter n. By default, the are in base 10, but you can use the 0b, 0o, and 0x prefixes for binary, octal, and hexadecimal BigInts:


1234n 0b111111n 0o7777n
0x8000000000000000n

/ /   A  not - s o- bi g   Bi gI nt   l i t er al / /   A  bi nar y   Bi gI nt
/ /   An   oc t al	Bi gI nt
/ /   =>   2n**63n:	A  64- bi t   i nt eger



You can use Bi gI nt ( )  as a function for converting regular JavaScript numbers or strings to BigInt values:

Bi gI nt ( Number . MAX_SAFE_I NTEGER)	/ /   =>   9007199254740991n
l et   s t r i ng   =   " 1"   +   " 0" . r epeat ( 100) ;    / /   1   f ol l owed   by   100   z er os . Bi gI nt ( s t r i ng)                                                             / /   =>   10n**100n:    one   googol


Arithmetic with BigInt values works like arithmetic with regular JavaScript numbers, except that division drops any remainder and rounds down (toward zero):


1000n   +   2000n 3000n   -    2000n 2000n   *   3000n 3000n   /   997n 3000n   %  997n

/ /   =>   3000n / /   =>   1000n
/ /   =>   6000000n
/ /   =>   3n:	t he   quot i ent   i s   3
/ /   =>   9n:	and   t he   r emai nder   i s   9

( 2n   **   131071n)    -    1n	/ /   A  Mer s enne   pr i me   wi t h   39457   dec i mal di gi t s


Although the standard +, - , *, / , %, and ** operators work with BigInt, it is important to understand that you may not mix operands of type BigInt

with regular number operands. This may seem confusing at first, but there is a good reason for it. If one numeric type was more general than the other, it would be easy to define arithmetic on mixed operands to simply return a value of the more general type. But neither type is more general than the other: BigInt can represent extraordinarily large values, making it more general than regular numbers. But BigInt can only represent integers, making the regular JavaScript number type more general. There is no way around this problem, so JavaScript sidesteps it by simply not allowing mixed operands to the arithmetic operators.


Comparison operators, by contrast, do work with mixed numeric types (but see §3.9.1 for more about the difference between == and ===):


1   <   2n	/ / 2   >   1n	/ / 0   ==   0n	/ / 0   ===   0n	/ /

=>   t r ue =>   t r ue =>   t r ue
=>   f al s e:	t he   ===   c hec ks   f or   t ype   equal i t y   as   wel l



The bitwise operators (described in §4.8.3) generally work with BigInt operands. None of the functions of the Mat h object accept BigInt operands, however.


3.2.6 Dates and Times

JavaScript defines a simple Date class for representing and manipulating the numbers that represent dates and times. JavaScript Dates are objects, but they also have a numeric representation as a timestamp that specifies the number of elapsed milliseconds since January 1, 1970:

l et   t i mes t amp   =   Dat e. now( ) ;	/ /   The   c ur r ent   t i me   as   a   t i mes t amp ( a   number ) .
l et   now  =   new  Dat e( ) ;	/ /   The   c ur r ent   t i me   as   a   Dat e obj ec t .
l et   ms   =   now. get Ti me( ) ;	/ /   Conver t   t o   a   mi l l i s ec ond

t i mes t amp.
l et   i s o   =   now. t oI SOSt r i ng( ) ;	/ /   Conver t   t o   a   s t r i ng   i n   s t andar d f or mat .


The Date class and its methods are covered in detail in §11.4. But we will see Date objects again in §3.9.3 when we examine the details of JavaScript type conversions.


3.3 Text

The JavaScript type for representing text is the string. A string is an immutable ordered sequence of 16-bit values, each of which typically represents a Unicode character. The length of a string is the number of 16-bit values it contains. JavaScript’s strings (and its arrays) use zero-based indexing: the first 16-bit value is at position 0, the second at position 1, and so on. The empty string is the string of length 0. JavaScript does not have a special type that represents a single element of a string. To represent a single 16-bit value, simply use a string that has a length of 1.



CHARACTERS, CODEPOINTS, AND J AVASCRIPT STRINGS

JavaScript uses the UTF-16 encoding of the Unicode character set, and JavaScript strings are sequences of unsigned 16-bit values. The most commonly used Unicode characters (those from the “basic multilingual plane”) have codepoints that fit in 16 bits and can be represented by one element of a string. Unicode characters whose codepoints do not fit in 16 bits are encoded using the rules of UTF-16 as a sequence (known as a “surrogate pair”) of two 16-bit values. This means that a JavaScript string of length 2 (two 16-bit values) might represent only a single Unicode character:

l et   eur o   =   " €" ; l et   l ove   =   " ❤" ;
eur o. l engt h	/ /   =>   1:    t hi s   c har ac t er   has   one   16- bi t   el ement
l ove. l engt h	/ /   =>   2:    UTF- 16   enc odi ng   of    ❤  i s   " \ ud83d\ udc 99"


Most string-manipulation methods defined by JavaScript operate on 16-bit values, not characters. They do not treat surrogate pairs specially, they perform no normalization of the string, and don’t even ensure that a string is well-formed UTF-16.

In ES6, however, strings are iterable, and if you use the f or / of  loop or . . .  operator with a string, it will iterate the actual characters of the string, not the 16-bit values.




3.3.1 String Literals

To include a string in a JavaScript program, simply enclose the characters of the string within a matched pair of single or double quotes or backticks ('  or " or ` ). Double-quote characters and backticks may be contained within strings delimited by single-quote characters, and similarly for strings delimited by double quotes and backticks. Here are examples of string literals:

" "	/ /   The   empt y   s t r i ng:	i t   has   z er o   c har ac t er s ' t es t i ng'
" 3. 14"
' name=" myf or m" '
" Woul dn' t   you   pr ef er   O' Rei l l y' s   book?"
" τ   i s   t he   r at i o   of    a   c i r c l e' s   c i r c umf er enc e   t o   i t s   r adi us " ` " She   s ai d   ' hi ' " ,	he   s ai d. `


Strings delimited with backticks are a feature of ES6, and allow JavaScript expressions to be embedded within (or interpolated into) the string literal. This expression interpolation syntax is covered in §3.3.4.


The original versions of JavaScript required string literals to be written on a single line, and it is common to see JavaScript code that creates long strings by concatenating single-line strings with the + operator. As of ES5, however, you can break a string literal across multiple lines by ending each line but the last with a backslash (\ ). Neither the backslash nor the line terminator that follow it are part of the string literal. If you need to include a newline character in a single-quoted or double-quoted string literal, use the character sequence \ n (documented in the next section). The ES6 backtick syntax allows strings to be broken across multiple lines, and in this case, the line terminators are part of the string literal:

/ /   A  s t r i ng   r epr es ent i ng   2   l i nes   wr i t t en   on   one   l i ne: ' t wo\ nl i nes '

/ /   A  one- l i ne   s t r i ng   wr i t t en   on   3   l i nes : " one\
l ong\ l i ne"

/ /   A  t wo- l i ne   s t r i ng   wr i t t en   on   t wo   l i nes :
` t he   newl i ne   c har ac t er   at   t he   end   of    t hi s   l i ne i s   i nc l uded   l i t er al l y   i n   t hi s   s t r i ng`


Note that when you use single quotes to delimit your strings, you must be careful with English contractions and possessives, such as can’t and O’Reilly’s. Since the apostrophe is the same as the single-quote character, you must use the backslash character (\ ) to “escape” any apostrophes that appear in single-quoted strings (escapes are explained in the next section).

In client-side JavaScript programming, JavaScript code may contain strings of HTML code, and HTML code may contain strings of JavaScript code. Like JavaScript, HTML uses either single or double quotes to delimit its strings. Thus, when combining JavaScript and HTML, it is a good idea to use one style of quotes for JavaScript and the other style for HTML. In the following example, the string “Thank you” is single-quoted within a JavaScript expression, which is then double-quoted within an HTML event-handler attribute:

<but t on   onc l i c k=" al er t ( ' Thank   you' ) " >Cl i c k   Me</but t on>


3.3.2 Escape Sequences in String Literals

The backslash character (\ ) has a special purpose in JavaScript strings. Combined with the character that follows it, it represents a character that is not otherwise representable within the string. For example, \ n is an escape sequence that represents a newline character.

Another example, mentioned earlier, is the \ '  escape, which represents the single quote (or apostrophe) character. This escape sequence is useful when you need to include an apostrophe in a string literal that is contained within single quotes. You can see why these are called escape sequences: the backslash allows you to escape from the usual interpretation of the single-quote character. Instead of using it to mark the end of the string, you use it as an apostrophe:

' You\ ' r e   r i ght ,	i t   c an\ ' t   be   a   quot e'


Table 3-1 lists the JavaScript escape sequences and the characters they represent. Three escape sequences are generic and can be used to represent any character by specifying its Unicode character code as a hexadecimal number. For example, the sequence \ xA9 represents the copyright symbol, which has the Unicode encoding given by the hexadecimal number A9. Similarly, the \ u escape represents an arbitrary Unicode character specified by four hexadecimal digits or one to five digits when the digits are enclosed in curly braces: \ u03c0 represents the character π, for example, and \ u{ 1f 600}  represents the “grinning face” emoji.


Table 3-1. JavaScript escape sequences

Sequ
ence	Character represented

\ 0	The NUL character (\ u0000)

\ b	Backspace (\ u0008)

\ t	Horizontal tab (\ u0009)

\ n	Newline (\ u000A)

\ v	Vertical tab (\ u000B)

\ f	Form feed (\ u000C)

\ r	Carriage return (\ u000D)

\ "	Double quote (\ u0022)

\ '	Apostrophe or single quote (\ u0027)

\ \	Backslash (\ u005C)

\ xnn	The Unicode character specified by the two hexadecimal digits nn

\ unnn	The Unicode character specified by the four hexadecimal digits nnnn n

\ u{ n	The Unicode character specified by the codepoint n, where n is one to six }	hexadecimal digits between 0 and 10FFFF (ES6)



If the \  character precedes any character other than those shown in
Table 3-1, the backslash is simply ignored (although future versions of the language may, of course, define new escape sequences). For example, \ # is the same as #. Finally, as noted earlier, ES5 allows a backslash before a line break to break a string literal across multiple lines.


3.3.3 Working with Strings

One of the built-in features of JavaScript is the ability to concatenate strings. If you use the + operator with numbers, it adds them. But if you use this operator on strings, it joins them by appending the second to the first. For example:

l et   ms g   =   " Hel l o,	"   +   " wor l d" ;	/ /   Pr oduc es   t he   s t r i ng   " Hel l o, wor l d"
l et   gr eet i ng   =   " Wel c ome   t o   my   bl og, "   +   "   "   +   name;


Strings can be compared with the standard === equality and ! == inequality operators: two strings are equal if and only if they consist of

exactly the same sequence of 16-bit values. Strings can also be compared with the <, <=, >, and >= operators. String comparison is done simply by comparing the 16-bit values. (For more robust locale-aware string comparison and sorting, see §11.7.3.)

To determine the length of a string—the number of 16-bit values it contains—use the l engt h property of the string:


s . l engt h


In addition to this l engt h property, JavaScript provides a rich API for working with strings:

l et   s   =   " Hel l o,	wor l d" ;	/ /   St ar t   wi t h   s ome   t ext .

/ /   Obt ai ni ng   por t i ons   of    a   s t r i ng
s . s ubs t r i ng( 1, 4)	/ /   =>   " el l " :	t he   2nd,	3r d,	and   4t h c har ac t er s .
s . s l i c e( 1, 4)	/ /   =>   " el l " :	s ame   t hi ng
s . s l i c e( - 3)	/ /   =>   " r l d" :	l as t   3   c har ac t er s
s . s pl i t ( " ,	" )	/ /   =>   [ " Hel l o" ,	" wor l d" ] :	s pl i t   at del i mi t er   s t r i ng

/ /   Sear c hi ng   a   s t r i ng
s . i ndexOf ( " l " )	/ /   =>   2:	pos i t i on   of    f i r s t   l et t er   l
s . i ndexOf ( " l " ,	3)	/ /   =>   3:	pos i t i on   of    f i r s t   " l "   at   or af t er   3
s . i ndexOf ( " z z " )	/ /   =>   - 1:	s   does   not   i nc l ude   t he s ubs t r i ng   " z z "
s . l as t I ndexOf ( " l " )	/ /   =>   10:	pos i t i on   of    l as t   l et t er   l

/ /   Bool ean   s ear c hi ng   f unc t i ons   i n   ES6   and   l at er
s . s t ar t s Wi t h( " Hel l " )	/ /   =>   t r ue:	t he   s t r i ng   s t ar t s   wi t h   t hes e s . ends Wi t h( " ! " )	/ /   =>   f al s e:    s   does   not   end   wi t h   t hat
s . i nc l udes ( " or " )	/ /   =>   t r ue:	s   i nc l udes   s ubs t r i ng   " or "

/ /   Cr eat i ng   modi f i ed   ver s i ons   of    a   s t r i ng
s . r epl ac e( " l l o" ,	" ya" )	/ /   =>   " Heya,	wor l d" s . t oL ower Cas e( )                         / /   =>   " hel l o,    wor l d"

s . t oUpper Cas e( )	/ /   =>   " HEL L O,	WORL D"
s . nor mal i z e( )	/ /   Uni c ode   NFC   nor mal i z at i on:	ES6 s . nor mal i z e( " NFD" )	/ /   NFD  nor mal i z at i on.	Al s o   " NFKC" , " NFKD"

/ /   I ns pec t i ng   i ndi vi dual	( 16- bi t )    c har ac t er s   of    a   s t r i ng s . c har At ( 0)                                    / /   =>   " H" :	t he   f i r s t   c har ac t er
s . c har At ( s . l engt h- 1)	/ /   =>   " d" :	t he   l as t   c har ac t er
s . c har CodeAt ( 0)	/ /   =>   72:	16- bi t   number   at   t he   s pec i f i ed pos i t i on
s . c odePoi nt At ( 0)	/ /   =>   72:	ES6,	wor ks   f or   c odepoi nt s   >   16 bi t s

/ /   St r i ng   paddi ng   f unc t i ons   i n   ES2017
" x" . padSt ar t ( 3)	/ /   =>   "	x" :	add   s pac es   on   t he   l ef t   t o   a l engt h   of    3
" x" . padEnd( 3)	/ /   =>   " x	" :	add   s pac es   on   t he   r i ght   t o a   l engt h   of    3
" x" . padSt ar t ( 3,	" *" )	/ /   =>   " **x" :	add   s t ar s   on   t he   l ef t   t o   a l engt h   of    3
" x" . padEnd( 3,	" - " )	/ /   =>   " x- - " :	add   das hes   on   t he   r i ght   t o a   l engt h   of    3

/ /   Spac e   t r i mmi ng   f unc t i ons .	t r i m( )    i s   ES5;	ot her s   ES2019
"   t es t   " . t r i m( )	/ /   =>   " t es t " :	r emove   s pac es   at   s t ar t   and end
"   t es t   " . t r i mSt ar t ( )	/ /   =>   " t es t   " :	r emove   s pac es   on   l ef t . Al s o   t r i mL ef t
"   t es t   " . t r i mEnd( )	/ /   =>   "   t es t " :	r emove   s pac es   at   r i ght . Al s o   t r i mRi ght

/ /   Mi s c el l aneous   s t r i ng   met hods
s . c onc at ( " ! " )	/ /   =>   " Hel l o,	wor l d! " :	j us t   us e   + oper at or   i ns t ead
" <>" . r epeat ( 5)	/ /   =>   " <><><><><>" :	c onc at enat e   n c opi es .	ES6


Remember that strings are immutable in JavaScript. Methods like
r epl ace( )  and t oUpper Cas e( )  return new strings: they do not modify the string on which they are invoked.

Strings can also be treated like read-only arrays, and you can access

individual characters (16-bit values) from a string using square brackets instead of the char At ( )  method:


l et   s   =   " hel l o,	wor l d" ;

s [ 0]
s [ s . l engt h- 1]

/ /   =>   " h"
/ /   =>   " d"



3.3.4 Template Literals

In ES6 and later, string literals can be delimited with backticks:


l et   s   =   ` hel l o   wor l d` ;


This is more than just another string literal syntax, however, because these template literals can include arbitrary JavaScript expressions. The final value of a string literal in backticks is computed by evaluating any included expressions, converting the values of those expressions to strings and combining those computed strings with the literal characters within the backticks:

l et   name   =   " Bi l l " ;
l et   gr eet i ng   =   ` Hel l o   ${    name   } . ` ;	/ /   gr eet i ng   ==   " Hel l o   Bi l l . "


Everything between the ${  and the matching }  is interpreted as a JavaScript expression. Everything outside the curly braces is normal string literal text. The expression inside the braces is evaluated and then converted to a string and inserted into the template, replacing the dollar sign, the curly braces, and everything in between them.

A template literal may include any number of expressions. It can use any of the escape characters that normal strings can, and it can span any number of lines, with no special escaping required. The following template literal includes four JavaScript expressions, a Unicode escape

sequence, and at least four newlines (the expression values may include newlines as well):

l et   er r or Mes s age   =   ` \
\ u2718   Tes t   f ai l ur e   at   ${ f i l ename} : ${ l i nenumber } : ${ exc ept i on. mes s age}
St ac k   t r ac e:
${ exc ept i on. s t ac k} ` ;


The backslash at the end of the first line here escapes the initial newline so that the resulting string begins with the Unicode ✘ character (\ u2718) rather than a newline.

TAGGED TEMPLATE LITERALS

A powerful but less commonly used feature of template literals is that, if a function name (or “tag”) comes right before the opening backtick, then the text and the values of the expressions within the template literal are passed to the function. The value of this “tagged template literal” is the return value of the function. This could be used, for example, to apply HTML or SQL escaping to the values before substituting them into the text.


ES6 has one built-in tag function: St r i ng. r aw( ) . It returns the text within backticks without any processing of backslash escapes:

` \ n` . l engt h	/ /   =>   1:	t he   s t r i ng   has   a   s i ngl e   newl i ne c har ac t er
St r i ng. r aw` \ n` . l engt h	/ /   =>   2:	a   bac ks l as h   c har ac t er   and   t he l et t er   n


Note that even though the tag portion of a tagged template literal is a function, there are no parentheses used in its invocation. In this very specific case, the backtick characters replace the open and close parentheses.

The ability to define your own template tag functions is a powerful feature of JavaScript. These functions do not need to return strings, and they can be used like constructors, as if defining a new literal syntax for the language. We’ll see an example in §14.5.


3.3.5 Pattern Matching

JavaScript defines a datatype known as a regular expression (or RegExp) for describing and matching patterns in strings of text. RegExps are not one of the fundamental datatypes in JavaScript, but they have a literal syntax like numbers and strings do, so they sometimes seem like they are fundamental. The grammar of regular expression literals is complex and the API they define is nontrivial. They are documented in detail in §11.3. Because RegExps are powerful and commonly used for text processing, however, this section provides a brief overview.


Text between a pair of slashes constitutes a regular expression literal. The second slash in the pair can also be followed by one or more letters, which modify the meaning of the pattern. For example:

/ ^HTML / ;	/ /   Mat c h   t he   l et t er s   H  T   M L   at   t he   s t ar t of    a   s t r i ng
/ [ 1- 9] [ 0- 9] */ ;	/ /   Mat c h   a   nonz er o   di gi t ,	f ol l owed   by   any   # of    di gi t s
/ \ bj avas c r i pt \ b/ i ;	/ /   Mat c h   " j avas c r i pt "   as   a   wor d,	c as e-i ns ens i t i ve


RegExp objects define a number of useful methods, and strings also have methods that accept RegExp arguments. For example:

l et   t ext   =   " t es t i ng:	1,	2,	3" ;	/ /   Sampl e   t ext
l et   pat t er n   =   / \ d+/ g;	/ /   Mat c hes   al l	i ns t anc es   of    one or   mor e   di gi t s
pat t er n. t es t ( t ext )	/ /   =>   t r ue:	a   mat c h   exi s t s

t ext . s ear c h( pat t er n)	/ /   =>   9:	pos i t i on   of    f i r s t mat c h
t ext . mat c h( pat t er n)	/ /   =>   [ " 1" ,	" 2" ,	" 3" ] :	ar r ay   of al l	mat c hes
t ext . r epl ac e( pat t er n,	" #" )	/ /   =>   " t es t i ng:	#,	#,	#"
t ext . s pl i t ( / \ D+/ )	/ /   =>   [ " " , " 1" , " 2" , " 3" ] :	s pl i t on   nondi gi t s


3.4 Boolean Values

A boolean value represents truth or falsehood, on or off, yes or no. There are only two possible values of this type. The reserved words t r ue and f al s e evaluate to these two values.


Boolean values are generally the result of comparisons you make in your JavaScript programs. For example:

a   ===   4


This code tests to see whether the value of the variable a is equal to the number 4. If it is, the result of this comparison is the boolean value t r ue. If a is not equal to 4, the result of the comparison is f al s e.


Boolean values are commonly used in JavaScript control structures. For example, the i f / el s e statement in JavaScript performs one action if a boolean value is t r ue and another action if the value is f al s e. You usually combine a comparison that creates a boolean value directly with a statement that uses it. The result looks like this:

i f    ( a   ===   4)    { b   =   b   +   1;
}    el s e   {
a   =   a   +   1; }

This code checks whether a equals 4. If so, it adds 1 to b; otherwise, it adds 1 to a.


As we’ll discuss in §3.9, any JavaScript value can be converted to a boolean value. The following values convert to, and therefore work like, f al s e:

undef i ned nul l
0
- 0 NaN
" "	/ /   t he   empt y   s t r i ng


All other values, including all objects (and arrays) convert to, and work like, t r ue. f al s e, and the six values that convert to it, are sometimes called falsy values, and all other values are called truthy. Any time JavaScript expects a boolean value, a falsy value works like f al s e and a truthy value works like t r ue.


As an example, suppose that the variable o either holds an object or the value nul l . You can test explicitly to see if o is non-null with an i f statement like this:

i f    ( o   ! ==   nul l )    . . .


The not-equal operator ! == compares o to nul l  and evaluates to either
t r ue or f al s e. But you can omit the comparison and instead rely on the fact that nul l  is falsy and objects are truthy:

i f    ( o)    . . .


In the first case, the body of the i f  will be executed only if o is not nul l .

The second case is less strict: it will execute the body of the i f  only if o is not f al s e or any falsy value (such as nul l  or undef i ned). Which i f  statement is appropriate for your program really depends on what values you expect to be assigned to o. If you need to distinguish nul l from 0 and " " , then you should use an explicit comparison.


Boolean values have a t oSt r i ng( )  method that you can use to convert them to the strings “true” or “false”, but they do not have any other useful methods. Despite the trivial API, there are three important boolean operators.

The &&operator performs the Boolean AND operation. It evaluates to a truthy value if and only if both of its operands are truthy; it evaluates to a falsy value otherwise. The || operator is the Boolean OR operation: it evaluates to a truthy value if either one (or both) of its operands is truthy and evaluates to a falsy value if both operands are falsy. Finally, the unary !  operator performs the Boolean NOT operation: it evaluates to t r ue if its operand is falsy and evaluates to f al s e if its operand is truthy. For example:

i f    ( ( x   ===   0   &&  y   ===   0)    ||   ! ( z   ===   0) )    {
/ /   x   and   y   ar e   bot h   z er o   or   z   i s   non- z er o }


Full details on these operators are in §4.10.



3.5 null and undefined

nul l  is a language keyword that evaluates to a special value that is usually used to indicate the absence of a value. Using the t ypeof operator on nul l  returns the string “object”, indicating that nul l  can be

thought of as a special object value that indicates “no object”. In practice, however, nul l  is typically regarded as the sole member of its own type, and it can be used to indicate “no value” for numbers and strings as well as objects. Most programming languages have an equivalent to JavaScript’s nul l : you may be familiar with it as NULL, ni l , or None.


JavaScript also has a second value that indicates absence of value. The undef i ned value represents a deeper kind of absence. It is the value of variables that have not been initialized and the value you get when you query the value of an object property or array element that does not exist. The undef i ned value is also the return value of functions that do not explicitly return a value and the value of function parameters for which no argument is passed. undef i ned is a predefined global constant (not a language keyword like nul l , though this is not an important distinction in practice) that is initialized to the undef i ned value. If you apply the
t ypeof  operator to the undef i ned value, it returns “undefined”, indicating that this value is the sole member of a special type.

Despite these differences, nul l  and undef i ned both indicate an absence of value and can often be used interchangeably. The equality operator == considers them to be equal. (Use the strict equality operator === to distinguish them.) Both are falsy values: they behave like f al s e when a boolean value is required. Neither nul l  nor undef i ned have any properties or methods. In fact, using .  or [ ]  to access a property or method of these values causes a TypeError.

I consider undef i ned to represent a system-level, unexpected, or error-like absence of value and nul l  to represent a program-level, normal, or expected absence of value. I avoid using nul l  and undef i ned when I

can, but if I need to assign one of these values to a variable or property or pass or return one of these values to or from a function, I usually use
nul l . Some programmers strive to avoid nul l  entirely and use undef i ned in its place wherever they can.


3.6 Symbols

Symbols were introduced in ES6 to serve as non-string property names. To understand Symbols, you need to know that JavaScript’s fundamental Object type is an unordered collection of properties, where each property has a name and a value. Property names are typically (and until ES6, were exclusively) strings. But in ES6 and later, Symbols can also serve this purpose:

l et   s t r name   =   " s t r i ng   name" ;	/ /   A  s t r i ng   t o   us e   as   a pr oper t y   name
l et   s ymname   =   Symbol ( " pr opname" ) ;	/ /   A  Symbol	t o   us e   as   a

pr oper t y   name
t ypeof    s t r name s t r i ng
t ypeof    s ymname s ymbol


/ /   =>   " s t r i ng" :

/ /   =>   " s ymbol " :


s t r name   i s   a

s ymname   i s   a

l et   o   =   { } ;	/ /   Cr eat e   a   new  obj ec t
o[ s t r name]    =   1;	/ /   Def i ne   a   pr oper t y   wi t h   a s t r i ng   name
o[ s ymname]    =   2;	/ /   Def i ne   a   pr oper t y   wi t h   a Symbol	name
o[ s t r name]	/ /   =>   1:	ac c es s   t he   s t r i ng-named   pr oper t y
o[ s ymname]	/ /   =>   2:	ac c es s   t he   s ymbol -named   pr oper t y


The Symbol type does not have a literal syntax. To obtain a Symbol value, you call the Symbol ( )  function. This function never returns the same value twice, even when called with the same argument. This means that if you call Symbol ( )  to obtain a Symbol value, you can safely use that

value as a property name to add a new property to an object and do not need to worry that you might be overwriting an existing property with the same name. Similarly, if you use symbolic property names and do not share those symbols, you can be confident that other modules of code in your program will not accidentally overwrite your properties.


In practice, Symbols serve as a language extension mechanism. When ES6 introduced the f or / of  loop (§5.4.4) and iterable objects (Chapter 12), it needed to define standard method that classes could implement to make themselves iterable. But standardizing any particular string name for this iterator method would have broken existing code, so a symbolic name was used instead. As we’ll see in Chapter 12, Symbol . i t er at or  is a Symbol value that can be used as a method name to make an object iterable.

The Symbol ( )  function takes an optional string argument and returns a unique Symbol value. If you supply a string argument, that string will be included in the output of the Symbol’s t oSt r i ng( )  method. Note, however, that calling Symbol ( )  twice with the same string produces two completely different Symbol values.

l et   s   =   Symbol ( " s ym_x" ) ;
s . t oSt r i ng( )	/ /   =>   " Symbol ( s ym_x) "


t oSt r i ng( )  is the only interesting method of Symbol instances. There are two other Symbol-related functions you should know about, however. Sometimes when using Symbols, you want to keep them private to your own code so you have a guarantee that your properties will never conflict with properties used by other code. Other times, however, you might want to define a Symbol value and share it widely with other code. This would be the case, for example, if you were defining some kind of extension that

you wanted other code to be able to participate in, as with the Symbol . i t er at or  mechanism described earlier.


To serve this latter use case, JavaScript defines a global Symbol registry. The Symbol . f or ( )  function takes a string argument and returns a Symbol value that is associated with the string you pass. If no Symbol is already associated with that string, then a new one is created and returned; otherwise, the already existing Symbol is returned. That is, the
Symbol . f or ( )  function is completely different than the Symbol ( ) function: Symbol ( )  never returns the same value twice, but
Symbol . f or ( )  always returns the same value when called with the same string. The string passed to Symbol . f or ( )  appears in the output of t oSt r i ng( )  for the returned Symbol, and it can also be retrieved by calling Symbol . keyFor ( )  on the returned Symbol.

l et   s   =   Symbol . f or ( " s har ed" ) ; l et   t   =   Symbol . f or ( " s har ed" ) ; s   ===   t	/ /   =>   t r ue

s . t oSt r i ng( )
Symbol . keyFor ( t )

/ /   =>   " Symbol ( s har ed) "
/ /   =>   " s har ed"



3.7 The Global Object

The preceding sections have explained JavaScript’s primitive types and values. Object types—objects, arrays, and functions—are covered in chapters of their own later in this book. But there is one very important object value that we must cover now. The global object is a regular JavaScript object that serves a very important purpose: the properties of this object are the globally defined identifiers that are available to a JavaScript program. When the JavaScript interpreter starts (or whenever a web browser loads a new page), it creates a new global object and gives it

an initial set of properties that define:


Global constants like undef i ned, I nf i ni t y, and NaN

Global functions like i s NaN( ) , par s eI nt ( )  (§3.9.2), and eval ( )  (§4.12)

Constructor functions like Dat e( ) , RegExp( ) , St r i ng( ) , Obj ect ( ) , and Ar r ay( )  (§3.9.2)

Global objects like Math and JSON (§6.8)

The initial properties of the global object are not reserved words, but they deserve to be treated as if they are. This chapter has already described some of these global properties. Most of the others will be covered elsewhere in this book.


In Node, the global object has a property named gl obal  whose value is the global object itself, so you can always refer to the global object by the name gl obal  in Node programs.


In web browsers, the Window object serves as the global object for all JavaScript code contained in the browser window it represents. This global Window object has a self-referential wi ndowproperty that can be used to refer to the global object. The Window object defines the core global properties, but it also defines quite a few other globals that are specific to web browsers and client-side JavaScript. Web worker threads (§15.13) have a different global object than the Window with which they are associated. Code in a worker can refer to its global object as s el f .


ES2020 finally defines gl obal Thi s  as the standard way to refer to the global object in any context. As of early 2020, this feature has been implemented by all modern browsers and by Node.

3.8 Immutable Primitive Values and Mutable Object References

There is a fundamental difference in JavaScript between primitive values (undef i ned, nul l , booleans, numbers, and strings) and objects (including arrays and functions). Primitives are immutable: there is no way to change (or “mutate”) a primitive value. This is obvious for numbers and booleans—it doesn’t even make sense to change the value of a number. It is not so obvious for strings, however. Since strings are like arrays of characters, you might expect to be able to alter the character at any specified index. In fact, JavaScript does not allow this, and all string methods that appear to return a modified string are, in fact, returning a new string value. For example:

l et   s   =   " hel l o" ;	/ /   St ar t   wi t h   s ome   l ower c as e   t ext
s . t oUpper Cas e( ) ;	/ /   Ret ur ns   " HEL L O" ,	but   does n' t   al t er   s
s	/ /   =>   " hel l o" :	t he   or i gi nal	s t r i ng   has   not c hanged


Primitives are also compared by value: two values are the same only if they have the same value. This sounds circular for numbers, booleans, nul l , and undef i ned: there is no other way that they could be compared. Again, however, it is not so obvious for strings. If two distinct string values are compared, JavaScript treats them as equal if, and only if, they have the same length and if the character at each index is the same.

Objects are different than primitives. First, they are mutable—their values can change:

l et   o   =   {    x:	1   } ;	/ /   St ar t   wi t h   an   obj ec t
o. x   =   2;	/ /   Mut at e   i t   by   c hangi ng   t he   val ue   of    a pr oper t y
o. y   =   3;	/ /   Mut at e   i t   agai n   by   addi ng   a   new  pr oper t y


l et   a   =   [ 1, 2, 3] ;	/ /   Ar r ays   ar e   al s o   mut abl e
a[ 0]    =   0;	/ /   Change   t he   val ue   of    an   ar r ay   el ement a[ 3]    =   4;	/ /   Add   a   new  ar r ay   el ement


Objects are not compared by value: two distinct objects are not equal even if they have the same properties and values. And two distinct arrays are not equal even if they have the same elements in the same order:

l et   o   =   { x:	1} ,	p   =   { x:	1} ;	/ /   Two   obj ec t s   wi t h   t he   s ame pr oper t i es
o   ===   p	/ /   =>   f al s e:	di s t i nc t   obj ec t s   ar e never   equal
l et   a   =   [ ] ,	b   =   [ ] ;	/ /   Two   di s t i nc t ,	empt y   ar r ays
a   ===   b	/ /   =>   f al s e:	di s t i nc t   ar r ays   ar e never   equal


Objects are sometimes called reference types to distinguish them from JavaScript’s primitive types. Using this terminology, object values are references, and we say that objects are compared by reference: two object values are the same if and only if they refer to the same underlying object.

l et   a   =   [ ] ;	/ /   The   var i abl e   a   r ef er s   t o   an   empt y   ar r ay. l et   b   =   a;	/ /   Now  b   r ef er s   t o   t he   s ame   ar r ay.
b[ 0]    =   1;	/ /   Mut at e   t he   ar r ay   r ef er r ed   t o   by   var i abl e   b. a[ 0]	/ /   =>   1:	t he   c hange   i s   al s o   vi s i bl e   t hr ough
var i abl e   a.
a   ===   b	/ /   =>   t r ue:	a   and   b   r ef er   t o   t he   s ame   obj ec t ,	s o t hey   ar e   equal .


As you can see from this code, assigning an object (or array) to a variable simply assigns the reference: it does not create a new copy of the object. If you want to make a new copy of an object or array, you must explicitly copy the properties of the object or the elements of the array. This example demonstrates using a f or  loop (§5.4.3):


l et   a   =   [ " a" , " b" , " c " ] ;	/ /   An   ar r ay   we   want   t o   c opy

l et   b   =   [ ] ;	/ /   A  di s t i nc t   ar r ay   we' l l c opy   i nt o
f or ( l et   i	=   0;	i	<   a. l engt h;	i ++)    {    / /   For   eac h   i ndex   of    a[ ]
b[ i ]    =   a[ i ] ;	/ /   Copy   an   el ement   of    a   i nt o b
}
l et   c   =   Ar r ay. f r om( b) ;	/ /   I n   ES6,	c opy   ar r ays   wi t h Ar r ay. f r om( )


Similarly, if we want to compare two distinct objects or arrays, we must compare their properties or elements. This code defines a function to compare two arrays:

f unc t i on   equal Ar r ays ( a,	b)    {
i f    ( a   ===   b)    r et ur n   t r ue;	/ /   I dent i c al	ar r ays ar e   equal
i f    ( a. l engt h   ! ==   b. l engt h)    r et ur n   f al s e;	/ /   Di f f er ent - s i z e ar r ays   not   equal
f or ( l et   i	=   0;	i	<   a. l engt h;	i ++)    {	/ /   L oop   t hr ough   al l el ement s
i f    ( a[ i ]    ! ==   b[ i ] )    r et ur n   f al s e;	/ /   I f    any   di f f er , ar r ays   not   equal
}
r et ur n   t r ue;	/ /   Ot her wi s e   t hey ar e   equal
}



3.9 Type Conversions

JavaScript is very flexible about the types of values it requires. We’ve seen this for booleans: when JavaScript expects a boolean value, you may supply a value of any type, and JavaScript will convert it as needed. Some values (“truthy” values) convert to t r ue and others (“falsy” values) convert to f al s e. The same is true for other types: if JavaScript wants a string, it will convert whatever value you give it to a string. If JavaScript wants a number, it will try to convert the value you give it to a number (or

to NaN if it cannot perform a meaningful conversion).


Some examples:



10   +   "   obj ec t s " s t r i ng
" 7"   *   " 4"

/ /   =>   " 10

/ /   =>   28:

obj ec t s " :	Number   10

bot h   s t r i ngs   c onver t

c onver t s   t o   a

t o   number s

l et   n   =   1   -    " x" ;	/ /   n   ==   NaN;	s t r i ng   " x"   c an' t   c onver t   t o   a number
n   +   "   obj ec t s "	/ /   =>   " NaN  obj ec t s " :	NaN  c onver t s   t o   s t r i ng " NaN"


Table 3-2 summarizes how values convert from one type to another in JavaScript. Bold entries in the table highlight conversions that you may find surprising. Empty cells indicate that no conversion is necessary and none is performed.


Table 3-2. JavaScript type conversions


Value

undef i ned

nul l

t r ue

f al s e

to String

" undef i ned"

" nul l "

" t r ue"

" f al s e"

to Number

NaN

0

1

0

to Boolean

f al s e

f al s e



" "  (empty string)

" 1. 2"  (nonempty, numeric)

" one"  (nonempty, non-numeric)

0	f al s e

1. 2	t r ue

NaN	t r ue


0	" 0"	f al s e

- 0	" 0"	f al s e

1 (finite, non-zero)	" 1"	t r ue


I nf i ni t y

- I nf i ni t y

NaN

" I nf i ni t y"	t r ue

" - I nf i ni t y"	t r ue

" NaN"	f al s e



{ }  (any object)

[ ]  (empty array)

[ 9]  (one numeric element)

[ ' a' ]  (any other array)

f unc t i on( ) { }  (any function)


see §3.9.3

" "

" 9"

use join() method

see §3.9.3

see §3.9.3	t r ue

0	t r ue

9	t r ue

NaN	t r ue

NaN	t r ue




The primitive-to-primitive conversions shown in the table are relatively straightforward. Conversion to boolean was already discussed in §3.4. Conversion to strings is well defined for all primitive values. Conversion to numbers is just a little trickier. Strings that can be parsed as numbers convert to those numbers. Leading and trailing spaces are allowed, but any leading or trailing nonspace characters that are not part of a numeric literal cause the string-to-number conversion to produce NaN. Some numeric conversions may seem surprising: t r ue converts to 1, and f al s e and the empty string convert to 0.

Object-to-primitive conversion is somewhat more complicated, and it is the subject of §3.9.3.


3.9.1 Conversions and Equality

JavaScript has two operators that test whether two values are equal. The “strict equality operator,” ===, does not consider its operands to be equal if they are not of the same type, and this is almost always the right operator to use when coding. But because JavaScript is so flexible with

type conversions, it also defines the == operator with a flexible definition of equality. All of the following comparisons are true, for example:


nul l	==   undef i ned   / / equal .
" 0"   ==   0	/ / c ompar i ng.
0   ==   f al s e	/ / c ompar i ng.
" 0"   ==   f al s e	/ / c ompar i ng!

=>   t r ue:

=>   t r ue:

=>   t r ue:

=>   t r ue:

Thes e   t wo   val ues   ar e   t r eat ed   as

St r i ng   c onver t s   t o   a   number   bef or e

Bool ean   c onver t s   t o   number   bef or e

Bot h   oper ands   c onver t   t o   0   bef or e



§4.9.1 explains exactly what conversions are performed by the == operator in order to determine whether two values should be considered equal.

Keep in mind that convertibility of one value to another does not imply equality of those two values. If undef i ned is used where a boolean value is expected, for example, it will convert to f al s e. But this does not mean that undef i ned  ==   f al s e. JavaScript operators and statements expect values of various types and perform conversions to those types. The i f  statement converts undef i ned to f al s e, but the == operator never attempts to convert its operands to booleans.


3.9.2 Explicit Conversions

Although JavaScript performs many type conversions automatically, you may sometimes need to perform an explicit conversion, or you may prefer to make the conversions explicit to keep your code clearer.


The simplest way to perform an explicit type conversion is to use the Bool ean( ) , Number ( ) , and St r i ng( )  functions:


Number ( " 3" )	/ /   =>   3


St r i ng( f al s e)
Bool ean( [ ] )

/ /   =>   " f al s e" :	Or   us e   f al s e. t oSt r i ng( )
/ /   =>   t r ue



Any value other than nul l  or undef i ned has a t oSt r i ng( )  method, and the result of this method is usually the same as that returned by the
St r i ng( )  function.


As an aside, note that the Bool ean( ) , Number ( ) , and St r i ng( ) functions can also be invoked—with new—as constructor. If you use them this way, you’ll get a “wrapper” object that behaves just like a primitive boolean, number, or string value. These wrapper objects are a historical leftover from the earliest days of JavaScript, and there is never really any good reason to use them.

Certain JavaScript operators perform implicit type conversions and are sometimes used explicitly for the purpose of type conversion. If one operand of the + operator is a string, it converts the other one to a string. The unary + operator converts its operand to a number. And the unary ! operator converts its operand to a boolean and negates it. These facts lead to the following type conversion idioms that you may see in some code:


x   +   " "	/ /   => +x	/ /   => x- 0	/ /   => ! ! x	/ /   =>

St r i ng( x) Number ( x) Number ( x)
Bool ean( x) :	Not e   doubl e   !



Formatting and parsing numbers are common tasks in computer programs, and JavaScript has specialized functions and methods that provide more precise control over number-to-string and string-to-number conversions.


The t oSt r i ng( )  method defined by the Number class accepts an optional argument that specifies a radix, or base, for the conversion. If you

do not specify the argument, the conversion is done in base 10. However, you can also convert numbers in other bases (between 2 and 36). For example:

l et   n   =   17;
l et   bi nar y   =   " 0b"   +   n. t oSt r i ng( 2) ;	/ /   bi nar y   ==   " 0b10001" l et   oc t al	=   " 0o"   +   n. t oSt r i ng( 8) ;	/ /   oc t al	==   " 0o21"
l et   hex   =   " 0x"   +   n. t oSt r i ng( 16) ;	/ /   hex   ==   " 0x11"


When working with financial or scientific data, you may want to convert numbers to strings in ways that give you control over the number of decimal places or the number of significant digits in the output, or you may want to control whether exponential notation is used. The Number class defines three methods for these kinds of number-to-string conversions. t oFi xed( )  converts a number to a string with a specified number of digits after the decimal point. It never uses exponential notation. t oExponent i al ( )  converts a number to a string using exponential notation, with one digit before the decimal point and a specified number of digits after the decimal point (which means that the number of significant digits is one larger than the value you specify).
t oPr eci s i on( )  converts a number to a string with the number of significant digits you specify. It uses exponential notation if the number of significant digits is not large enough to display the entire integer portion of the number. Note that all three methods round the trailing digits or pad with zeros as appropriate. Consider the following examples:

l et   n   =   123456. 789;

n. t oFi xed( 0) n. t oFi xed( 2) n. t oFi xed( 5)
n. t oExponent i al ( 1) n. t oExponent i al ( 3)
n. t oPr ec i s i on( 4)

/ /   =>   " 123457"
/ /   =>   " 123456. 79"
/ /   =>   " 123456. 78900" / /   =>   " 1. 2e+5"
/ /   =>   " 1. 235e+5"
/ /   =>   " 1. 235e+5"


n. t oPr ec i s i on( 7)
n. t oPr ec i s i on( 10)

/ /   =>   " 123456. 8"
/ /   =>   " 123456. 7890"



In addition to the number-formatting methods shown here, the Intl.NumberFormat class defines a more general, internationalized number-formatting method. See §11.7.1 for details.


If you pass a string to the Number ( )  conversion function, it attempts to parse that string as an integer or floating-point literal. That function only works for base-10 integers and does not allow trailing characters that are not part of the literal. The par s eI nt ( )  and par s eFl oat ( )  functions (these are global functions, not methods of any class) are more flexible. par s eI nt ( )  parses only integers, while par s eFl oat ( )  parses both integers and floating-point numbers. If a string begins with “0x” or “0X”, par s eI nt ( )  interprets it as a hexadecimal number. Both par s eI nt ( ) and par s eFl oat ( )  skip leading whitespace, parse as many numeric characters as they can, and ignore anything that follows. If the first nonspace character is not part of a valid numeric literal, they return NaN:

par s eI nt ( " 3   bl i nd   mi c e" )	/ /   =>   3
par s eFl oat ( "   3. 14   met er s " )	/ /   =>   3. 14

par s eI nt ( " - 12. 34" ) par s eI nt ( " 0xFF" ) par s eI nt ( " 0xf f " ) par s eI nt ( " - 0XFF" ) par s eFl oat ( " . 1" ) par s eI nt ( " 0. 1" )
par s eI nt ( " . 1" )

/ /   =>   - 12 / /   =>   255 / /   =>   255 / /   =>   - 255 / /   =>   0. 1 / /   =>   0
/ /   =>   NaN:	i nt eger s   c an' t   s t ar t

wi t h   " . "
par s eFl oat ( " $72. 47" )	/ /   =>   NaN:	number s   c an' t   s t ar t   wi t h " $"


par s eI nt ( )  accepts an optional second argument specifying the radix (base) of the number to be parsed. Legal values are between 2 and 36. For

example:


par s eI nt ( " 11" ,	2)	/ /   =>   3:	( 1*2   +   1)
par s eI nt ( " f f " ,	16)	/ /   =>   255:	( 15*16   +   15) par s eI nt ( " z z " ,	36)	/ /   =>   1295:    ( 35*36   +   35) par s eI nt ( " 077" ,    8)	/ /   =>   63:    ( 7*8   +   7)
par s eI nt ( " 077" ,	10)	/ /   =>   77:	( 7*10   +   7)


3.9.3 Object to Primitive Conversions

The previous sections have explained how you can explicitly convert values of one type to another type and have explained JavaScript’s implicit conversions of values from one primitive type to another primitive type. This section covers the complicated rules that JavaScript uses to convert objects to primitive values. It is long and obscure, and if this is your first reading of this chapter, you should feel free to skip ahead to §3.10.


One reason for the complexity of JavaScript’s object-to-primitive conversions is that some types of objects have more than one primitive representation. Date objects, for example, can be represented as strings or as numeric timestamps. The JavaScript specification defines three fundamental algorithms for converting objects to primitive values:


prefer-string

This algorithm returns a primitive value, preferring a string value, if a conversion to string is possible.

prefer-number

This algorithm returns a primitive value, preferring a number, if such a conversion is possible.

no-preference

This algorithm expresses no preference about what type of primitive

value is desired, and classes can define their own conversions. Of the built-in JavaScript types, all except Date implement this algorithm as prefer-number. The Date class implements this algorithm as prefer-string.


The implementation of these object-to-primitive conversion algorithms is explained at the end of this section. First, however, we explain how the algorithms are used in JavaScript.

OBJ ECT-TO-BOOLEAN CONVERSIONS

Object-to-boolean conversions are trivial: all objects convert to t r ue. Notice that this conversion does not require the use of the object-to-primitive algorithms described, and that it literally applies to all objects, including empty arrays and even the wrapper object new
Bool ean( f al s e) .


OBJ ECT-TO-STRING CONVERSIONS

When an object needs to be converted to a string, JavaScript first converts it to a primitive using the prefer-string algorithm, then converts the resulting primitive value to a string, if necessary, following the rules in Table 3-2.


This kind of conversion happens, for example, if you pass an object to a built-in function that expects a string argument, if you call St r i ng( )  as a conversion function, and when you interpolate objects into template literals (§3.3.4).

OBJ ECT-TO-NUMBER CONVERSIONS

When an object needs to be converted to a number, JavaScript first converts it to a primitive value using the prefer-number algorithm, then

converts the resulting primitive value to a number, if necessary, following the rules in Table 3-2.


Built-in JavaScript functions and methods that expect numeric arguments convert object arguments to numbers in this way, and most (see the exceptions that follow) JavaScript operators that expect numeric operands convert objects to numbers in this way as well.

SPECIAL CASE OPERATOR CONVERSIONS

Operators are covered in detail in Chapter 4. Here, we explain the special case operators that do not use the basic object-to-string and object-to-number conversions described earlier.


The + operator in JavaScript performs numeric addition and string concatenation. If either of its operands is an object, JavaScript converts them to primitive values using the no-preference algorithm. Once it has two primitive values, it checks their types. If either argument is a string, it converts the other to a string and concatenates the strings. Otherwise, it converts both arguments to numbers and adds them.

The == and ! = operators perform equality and inequality testing in a loose way that allows type conversions. If one operand is an object and the other is a primitive value, these operators convert the object to primitive using the no-preference algorithm and then compare the two primitive values.

Finally, the relational operators <, <=, >, and >= compare the order of their operands and can be used to compare both numbers and strings. If either operand is an object, it is converted to a primitive value using the prefer-number algorithm. Note, however, that unlike the object-to-number conversion, the primitive values returned by the prefer-number conversion

are not then converted to numbers.


Note that the numeric representation of Date objects is meaningfully comparable with < and >, but the string representation is not. For Date objects, the no-preference algorithm converts to a string, so the fact that JavaScript uses the prefer-number algorithm for these operators means that we can use them to compare the order of two Date objects.

THE TOSTRING() AND VALUEOF() METHODS

All objects inherit two conversion methods that are used by object-to-primitive conversions, and before we can explain the prefer-string, prefer-number, and no-preference conversion algorithms, we have to explain these two methods.


The first method is t oSt r i ng( ) , and its job is to return a string representation of the object. The default t oSt r i ng( )  method does not return a very interesting value (though we’ll find it useful in §14.4.3):

( { x:	1,	y:	2} ) . t oSt r i ng( )	/ /   =>   " [ obj ec t   Obj ec t ] "


Many classes define more specific versions of the t oSt r i ng( )  method. The t oSt r i ng( )  method of the Array class, for example, converts each array element to a string and joins the resulting strings together with commas in between. The t oSt r i ng( )  method of the Function class converts user-defined functions to strings of JavaScript source code. The Date class defines a t oSt r i ng( )  method that returns a human-readable (and JavaScript-parsable) date and time string. The RegExp class defines a t oSt r i ng( )  method that converts RegExp objects to a string that looks like a RegExp literal:

[ 1, 2, 3] . t oSt r i ng( )	/ /   =>   " 1, 2, 3"
( f unc t i on( x)    {    f ( x) ;	} ) . t oSt r i ng( )	/ /   =>   " f unc t i on( x)    {    f ( x) ; } "
/ \ d+/ g. t oSt r i ng( )	/ /   =>   " / \ \ d+/ g" l et   d   =   new  Dat e( 2020, 0, 1) ;
d. t oSt r i ng( )	/ /   =>   " Wed   J an   01   2020   00: 00: 00   GMT- 0800   ( Pac i f i c St andar d   Ti me) "


The other object conversion function is called val ueOf ( ) . The job of this method is less well defined: it is supposed to convert an object to a primitive value that represents the object, if any such primitive value exists. Objects are compound values, and most objects cannot really be represented by a single primitive value, so the default val ueOf ( ) method simply returns the object itself rather than returning a primitive. Wrapper classes such as String, Number, and Boolean define val ueOf ( ) methods that simply return the wrapped primitive value. Arrays, functions, and regular expressions simply inherit the default method. Calling
val ueOf ( )  for instances of these types simply returns the object itself. The Date class defines a val ueOf ( )  method that returns the date in its internal representation: the number of milliseconds since January 1, 1970:

l et   d   =   new  Dat e( 2010,	0,	1) ;	/ /   J anuar y   1,	2010,	( Pac i f i c t i me)
d. val ueOf ( )	/ /   =>   1262332800000


OBJ ECT-TO-PRIMITIVE CONVERSION ALGORITHMS

With the t oSt r i ng( )  and val ueOf ( )  methods explained, we can now explain approximately how the three object-to-primitive algorithms work (the complete details are deferred until §14.4.7):

The prefer-string algorithm first tries the t oSt r i ng( )  method. If the method is defined and returns a primitive value, then JavaScript uses that primitive value (even if it is not a string!). If

t oSt r i ng( )  does not exist or if it returns an object, then JavaScript tries the val ueOf ( )  method. If that method exists and returns a primitive value, then JavaScript uses that value. Otherwise, the conversion fails with a TypeError.

The prefer-number algorithm works like the prefer-string algorithm, except that it tries val ueOf ( )  first and
t oSt r i ng( )  second.

The no-preference algorithm depends on the class of the object being converted. If the object is a Date object, then JavaScript uses the prefer-string algorithm. For any other object, JavaScript uses the prefer-number algorithm.

The rules described here are true for all built-in JavaScript types and are the default rules for any classes you define yourself. §14.4.7 explains how you can define your own object-to-primitive conversion algorithms for the classes you define.


Before we leave this topic, it is worth noting that the details of the prefer-number conversion explain why empty arrays convert to the number 0 and single-element arrays can also convert to numbers:

Number ( [ ] )	/ /   =>   0:	t hi s   i s   unexpec t ed! Number ( [ 99] )	/ /   =>   99:    r eal l y?


The object-to-number conversion first converts the object to a primitive using the prefer-number algorithm, then converts the resulting primitive value to a number. The prefer-number algorithm tries val ueOf ( )  first and then falls back on t oSt r i ng( ) . But the Array class inherits the default val ueOf ( )  method, which does not return a primitive value. So when we try to convert an array to a number, we end up invoking the
t oSt r i ng( )  method of the array. Empty arrays convert to the empty string. And the empty string converts to the number 0. An array with a

single element converts to the same string that that one element does. If an array contains a single number, that number is converted to a string, and then back to a number.


3.10 Variable Declaration and Assignment

One of the most fundamental techniques of computer programming is the use of names—or identifiers—to represent values. Binding a name to a value gives us a way to refer to that value and use it in the programs we write. When we do this, we typically say that we are assigning a value to a variable. The term “variable” implies that new values can be assigned: that the value associated with the variable may vary as our program runs. If we permanently assign a value to a name, then we call that name a constant instead of a variable.


Before you can use a variable or constant in a JavaScript program, you must declare it. In ES6 and later, this is done with the l et  and cons t keywords, which we explain next. Prior to ES6, variables were declared with var , which is more idiosyncratic and is explained later on in this section.


3.10.1 Declarations with let and const

In modern JavaScript (ES6 and later), variables are declared with the l et keyword, like this:

l et   i ;
l et   s um;


You can also declare multiple variables in a single l et  statement:


l et   i ,	s um;



It is a good programming practice to assign an initial value to your variables when you declare them, when this is possible:

l et   mes s age   =   " hel l o" ;
l et   i	=   0,	j	=   0,	k   =   0;
l et   x   =   2,	y   =   x*x;	/ /   I ni t i al i z er s   c an   us e   pr evi ous l y   dec l ar ed var i abl es


If you don’t specify an initial value for a variable with the l et  statement, the variable is declared, but its value is undef i ned until your code assigns a value to it.

To declare a constant instead of a variable, use cons t  instead of l et . cons t  works just like l et  except that you must initialize the constant when you declare it:

c ons t   H0   =   74;	/ /   Hubbl e   c ons t ant   ( km/ s / Mpc )
c ons t   C   =   299792. 458;	/ /   Speed   of    l i ght   i n   a   vac uum ( km/ s )
c ons t   AU  =   1. 496E8;	/ /   As t r onomi c al	Uni t :	di s t anc e   t o   t he   s un ( km)


As the name implies, constants cannot have their values changed, and any attempt to do so causes a TypeError to be thrown.


It is a common (but not universal) convention to declare constants using names with all capital letters such as H0 or HTTP_NOT_FOUND as a way to distinguish them from variables.


WHEN TO USE CONST

There are two schools of thought about the use of the c ons t  keyword. One approach is to use c ons t  only for values that are fundamentally unchanging, like the physical constants shown, or program version numbers, or byte sequences used to identify file

types, for example. Another approach recognizes that many of the so-called variables in our program don’t actually ever change as our program runs. In this approach, we declare everything with c ons t , and then if we find that we do actually want to allow the value to vary, we switch the declaration to l et . This may help prevent bugs by ruling out accidental changes to variables that we did not intend.

In one approach, we use c ons t  only for values that must not change. In the other, we use c ons t  for any value that does not happen to change. I prefer the former approach in my own code.




In Chapter 5, we’ll learn about the f or , f or / i n, and f or / of  loop statements in JavaScript. Each of these loops includes a loop variable that gets a new value assigned to it on each iteration of the loop. JavaScript allows us to declare the loop variable as part of the loop syntax itself, and this is another common way to use l et :


f or ( l et   i	=   0,	l en   =   dat a. l engt h;	i	<   l en;	i ++) c ons ol e. l og( dat a[ i ] ) ;
f or ( l et   dat um of    dat a)    c ons ol e. l og( dat um) ;
f or ( l et   pr oper t y   i n   obj ec t )    c ons ol e. l og( pr oper t y) ;


It may seem surprising, but you can also use cons t  to declare the loop “variables” for f or / i n and f or / of  loops, as long as the body of the loop does not reassign a new value. In this case, the cons t  declaration is just saying that the value is constant for the duration of one loop iteration:

f or ( c ons t   dat um of    dat a)    c ons ol e. l og( dat um) ;
f or ( c ons t   pr oper t y   i n   obj ec t )    c ons ol e. l og( pr oper t y) ;


VARIABLE AND CONSTANT SCOPE

The scope of a variable is the region of your program source code in which it is defined. Variables and constants declared with l et  and cons t

are block scoped. This means that they are only defined within the block of code in which the l et  or cons t  statement appears. JavaScript class and function definitions are blocks, and so are the bodies of i f / el s e statements, whi l e loops, f or  loops, and so on. Roughly speaking, if a variable or constant is declared within a set of curly braces, then those curly braces delimit the region of code in which the variable or constant is defined (though of course it is not legal to reference a variable or constant from lines of code that execute before the l et  or cons t  statement that declares the variable). Variables and constants declared as part of a f or ,
f or / i n, or f or / of  loop have the loop body as their scope, even though they technically appear outside of the curly braces.

When a declaration appears at the top level, outside of any code blocks, we say it is a global variable or constant and has global scope. In Node and in client-side JavaScript modules (see Chapter 10), the scope of a global variable is the file that it is defined in. In traditional client-side JavaScript, however, the scope of a global variable is the HTML document in which it is defined. That is: if one <s cr i pt > declares a global variable or constant, that variable or constant is defined in all of the
<s cr i pt > elements in that document (or at least all of the scripts that execute after the l et  or cons t  statement executes).

REPEATED DECLARATIONS

It is a syntax error to use the same name with more than one l et  or cons t  declaration in the same scope. It is legal (though a practice best avoided) to declare a new variable with the same name in a nested scope:

c ons t   x   =   1;	/ /   Dec l ar e   x   as   a   gl obal	c ons t ant i f    ( x   ===   1)    {
l et   x   =   2;	/ /   I ns i de   a   bl oc k   x   c an   r ef er   t o   a   di f f er ent val ue

c ons ol e. l og( x) ;	/ /   Pr i nt s   2 }
c ons ol e. l og( x) ;	/ /   Pr i nt s   1:	we' r e   bac k   i n   t he   gl obal	s c ope now
l et   x   =   3;	/ /   ERROR!   Synt ax   er r or   t r yi ng   t o   r e- dec l ar e x

DECLARATIONS AND TYPES

If you’re used to statically typed languages such as C or Java, you may think that the primary purpose of variable declarations is to specify the type of values that may be assigned to a variable. But, as you have seen, there is no type associated with JavaScript’s variable declarations.2 A JavaScript variable can hold a value of any type. For example, it is perfectly legal (but generally poor programming style) in JavaScript to assign a number to a variable and then later assign a string to that variable:

l et   i	=   10; i	=   " t en" ;


3.10.2 Variable Declarations with var

In versions of JavaScript before ES6, the only way to declare a variable is with the var  keyword, and there is no way to declare constants. The syntax of var  is just like the syntax of l et :

var   x;
var   dat a   =   [ ] ,	c ount   =   dat a. l engt h;
f or ( var   i	=   0;	i	<   c ount ;	i ++)    c ons ol e. l og( dat a[ i ] ) ;


Although var  and l et  have the same syntax, there are important differences in the way they work:

Variables declared with var  do not have block scope. Instead, they are scoped to the body of the containing function no matter

how deeply nested they are inside that function.

If you use var  outside of a function body, it declares a global variable. But global variables declared with var  differ from globals declared with l et  in an important way. Globals declared with var  are implemented as properties of the global object (§3.7). The global object can be referenced as gl obal Thi s . So if you write var   x   =   2;  outside of a function, it is like you wrote gl obal Thi s . x   =   2; . Note however, that the analogy is not perfect: the properties created with global var  declarations cannot be deleted with the del et e operator (§4.13.4). Global variables and constants declared with l et  and cons t  are not properties of the global object.

Unlike variables declared with l et , it is legal to declare the same variable multiple times with var . And because var  variables have function scope instead of block scope, it is actually common to do this kind of redeclaration. The variable i  is frequently used for integer values, and especially as the index variable of f or loops. In a function with multiple f or  loops, it is typical for each one to begin f or ( var   i	=   0;	. . . . Because var  does not scope these variables to the loop body, each of these loops is (harmlessly) re-declaring and re-initializing the same variable.

One of the most unusual features of var  declarations is known as hoisting. When a variable is declared with var , the declaration is lifted up (or “hoisted”) to the top of the enclosing function. The initialization of the variable remains where you wrote it, but the definition of the variable moves to the top of the function. So variables declared with var  can be used, without error, anywhere in the enclosing function. If the initialization code has not run yet, then the value of the variable may be undef i ned, but you won’t get an error if you use the variable before it is initialized. (This can be a source of bugs and is one of the important misfeatures that l et  corrects: if you declare a variable with l et but attempt to use it before the l et  statement runs, you will get

an actual error instead of just seeing an undef i ned value.)



USING UNDECLARED VARIABLES

In strict mode (§5.6.3), if you attempt to use an undeclared variable, you’ll get a reference error when you run your code. Outside of strict mode, however, if you assign a value to a name that has not been declared with l et , c ons t , or var , you’ll end up creating a new global variable. It will be a global no matter now deeply nested within functions and blocks your code is, which is almost certainly not what you want, is
bug-prone, and is one of the best reasons for using strict mode!

Global variables created in this accidental way are like global variables declared with var : they define properties of the global object. But unlike the properties defined by proper var  declarations, these properties can be deleted with the del et e operator (§4.13.4).




3.10.3 Destructuring Assignment

ES6 implements a kind of compound declaration and assignment syntax known as destructuring assignment. In a destructuring assignment, the value on the righthand side of the equals sign is an array or object (a “structured” value), and the lefthand side specifies one or more variable names using a syntax that mimics array and object literal syntax. When a destructuring assignment occurs, one or more values are extracted (“destructured”) from the value on the right and stored into the variables named on the left. Destructuring assignment is perhaps most commonly used to initialize variables as part of a cons t , l et , or var  declaration statement, but it can also be done in regular assignment expressions (with variables that have already been declared). And, as we’ll see in §8.3.5, destructuring can also be used when defining the parameters to a function.

Here are simple destructuring assignments using arrays of values:

l et   [ x, y]    =   [ 1, 2] ;	/ /   Same   as   l et   x=1,	y=2
[ x, y]    =   [ x+1, y+1] ;	/ /   Same   as   x   =   x   +   1,	y   =   y   +   1
[ x, y]    =   [ y, x] ;	/ /   Swap   t he   val ue   of    t he   t wo   var i abl es
[ x, y]	/ /   =>   [ 3, 2] :	t he   i nc r ement ed   and   s wapped val ues


Notice how destructuring assignment makes it easy to work with functions that return arrays of values:

/ /   Conver t   [ x, y]    c oor di nat es   t o   [ r , t het a]    pol ar   c oor di nat es f unc t i on   t oPol ar ( x,	y)    {
r et ur n   [ Mat h. s qr t ( x*x+y*y) ,	Mat h. at an2( y, x) ] ; }

/ /   Conver t   pol ar   t o   Car t es i an   c oor di nat es f unc t i on   t oCar t es i an( r ,	t het a)    {
r et ur n   [ r *Mat h. c os ( t het a) ,	r *Mat h. s i n( t het a) ] ; }

l et   [ r , t het a]    =   t oPol ar ( 1. 0,	1. 0) ;	/ /   r   ==   Mat h. s qr t ( 2) ;	t het a ==   Mat h. PI / 4
l et   [ x, y]    =   t oCar t es i an( r , t het a) ;	/ /   [ x,	y]    ==   [ 1. 0,	1, 0]


We saw that variables and constants can be declared as part of JavaScript’s various f or  loops. It is possible to use variable destructuring in this context as well. Here is a code that loops over the name/value pairs of all properties of an object and uses destructuring assignment to convert those pairs from two-element arrays into individual variables:

l et   o   =   {    x:	1,	y:	2   } ;	/ /   The   obj ec t   we' l l	l oop   over f or ( c ons t   [ name,    val ue]    of    Obj ec t . ent r i es ( o) )    {
c ons ol e. l og( name,	val ue) ;	/ /   Pr i nt s   " x   1"   and   " y   2" }


The number of variables on the left of a destructuring assignment does not have to match the number of array elements on the right. Extra variables on the left are set to undef i ned, and extra values on the right are

ignored. The list of variables on the left can include extra commas to skip certain values on the right:

l et   [ x, y]    =   [ 1] ;	/ /   x   ==   1;	y   ==   undef i ned [ x, y]    =   [ 1, 2, 3] ;	/ /   x   ==   1;	y   ==   2
[ , x, , y]    =   [ 1, 2, 3, 4] ;	/ /   x   ==   2;	y   ==   4


If you want to collect all unused or remaining values into a single variable when destructuring an array, use three dots (. . . ) before the last variable name on the left-hand side:

l et   [ x,	. . . y]    =   [ 1, 2, 3, 4] ;	/ /   y   ==   [ 2, 3, 4]


We’ll see three dots used this way again in §8.3.2, where they are used to indicate that all remaining function arguments should be collected into a single array.


Destructuring assignment can be used with nested arrays. In this case, the lefthand side of the assignment should look like a nested array literal:

l et   [ a,	[ b,	c ] ]    =   [ 1,	[ 2, 2. 5] ,	3] ;	/ /   a   ==   1;	b   ==   2;	c   ==   2. 5


A powerful feature of array destructuring is that it does not actually require an array! You can use any iterable object (Chapter 12) on the righthand side of the assignment; any object that can be used with a f or / of  loop (§5.4.4) can also be destructured:


l et   [ f i r s t ,	. . . r es t ]    =   " Hel l o" ;	/ /   f i r s t   ==   " H" ;	r es t   == [ " e" , " l " , " l " , " o" ]


Destructuring assignment can also be performed when the righthand side is an object value. In this case, the lefthand side of the assignment looks something like an object literal: a comma-separated list of variable names

within curly braces:


l et   t r ans par ent   =   { r :	0. 0,	g:	0. 0,	b:	0. 0,	a:	1. 0} ;	/ /   A  RGBA c ol or
l et   { r ,	g,	b}    =   t r ans par ent ;	/ /   r   ==   0. 0;	g   ==   0. 0;	b   ==   0. 0


The next example copies global functions of the Mat h object into variables, which might simplify code that does a lot of trigonometry:

/ /   Same   as   c ons t   s i n=Mat h. s i n,	c os =Mat h. c os ,	t an=Mat h. t an c ons t   { s i n,	c os ,	t an}    =   Mat h;


Notice in the code here that the Mat h object has many properties other than the three that are destructured into individual variables. Those that are not named are simply ignored. If the lefthand side of this assignment had included a variable whose name was not a property of Mat h, that variable would simply be assigned undef i ned.


In each of these object destructuring examples, we have chosen variable names that match the property names of the object we’re destructuring. This keeps the syntax simple and easy to understand, but it is not required. Each of the identifiers on the lefthand side of an object destructuring assignment can also be a colon-separated pair of identifiers, where the first is the name of the property whose value is to be assigned and the second is the name of the variable to assign it to:

/ /   Same   as   c ons t   c os i ne   =   Mat h. c os ,	t angent   =   Mat h. t an; c ons t   {    c os :	c os i ne,	t an:	t angent   }    =   Mat h;


I find that object destructuring syntax becomes too complicated to be useful when the variable names and property names are not the same, and I tend to avoid the shorthand in this case. If you choose to use it, remember that property names are always on the left of the colon, in both

object literals and on the left of an object destructuring assignment.


Destructuring assignment becomes even more complicated when it is used with nested objects, or arrays of objects, or objects of arrays, but it is legal:

l et   poi nt s   =   [ { x:	1,	y:	2} ,	{ x:	3,	y:	4} ] ;	/ /   An   ar r ay   of t wo   poi nt   obj ec t s
l et   [ { x:	x1,	y:	y1} ,	{ x:	x2,	y:	y2} ]    =   poi nt s ;	/ /   des t r uc t ur ed i nt o   4   var i abl es .
( x1   ===   1   &&  y1   ===   2   &&  x2   ===   3   &&  y2   ===   4)    / /   =>   t r ue


Or, instead of destructuring an array of objects, we could destructure an object of arrays:

l et   poi nt s   =   {    p1:	[ 1, 2] ,	p2:	[ 3, 4]    } ;	/ /   An   obj ec t   wi t h 2   ar r ay   pr ops
l et   {    p1:	[ x1,	y1] ,	p2:	[ x2,	y2]    }    =   poi nt s ;	/ /   des t r uc t ur ed i nt o   4   var s
( x1   ===   1   &&  y1   ===   2   &&  x2   ===   3   &&  y2   ===   4)    / /   =>   t r ue


Complex destructuring syntax like this can be hard to write and hard to read, and you may be better off just writing out your assignments explicitly with traditional code like l et   x1   =   poi nt s . p1[ 0] ; .



UNDERSTANDING COMPLEX DESTRUCTURING

If you find yourself working with code that uses complex destructuring assignments, there is a useful regularity that can help you make sense of the complex cases. Think first about a regular (single-value) assignment. After the assignment is done, you can take the variable name from the lefthand side of the assignment and use it as an expression in your code, where it will evaluate to whatever value you assigned it. The same thing is true for destructuring assignment. The lefthand side of a destructuring assignment looks like an array literal or an object literal (§6.2.1 and §6.10). After the assignment has been done, the lefthand side will actually work as a valid array literal or object literal elsewhere in your code. You can check that you’ve written a destructuring assignment correctly by trying to use the lefthand side on the righthand side of another assignment expression:

/ /   St ar t   wi t h   a   dat a   s t r uc t ur e   and   a   c ompl ex   des t r uc t ur i ng l et   poi nt s   =   [ { x:    1,    y:    2} ,    { x:    3,    y:    4} ] ;
l et   [ { x:    x1,    y:    y1} ,    { x:    x2,    y:    y2} ]    =   poi nt s ;


/ /   Chec k   your   des t r uc t ur i ng   s ynt ax   by   f l i ppi ng   t he   as s i gnment   ar ound l et   poi nt s 2   =   [ { x:    x1,    y:    y1} ,    { x:    x2,    y:    y2} ] ;    / /   poi nt s 2   ==   poi nt s





3.11 Summary

Some key points to remember about this chapter:


How to write and manipulate numbers and strings of text in JavaScript.

How to work with JavaScript’s other primitive types: booleans, Symbols, nul l , and undef i ned.

The differences between immutable primitive types and mutable reference types.

How JavaScript converts values implicitly from one type to another and how you can do so explicitly in your programs.

How to declare and initialize constants and variables (including with destructuring assignment) and the lexical scope of the variables and constants you declare.





1


2

This is the format for numbers of type doubl e in Java, C++, and most modern programming languages.

There are JavaScript extensions, such as TypeScript and Flow (§17.8), that allow types to be specified as part of variable declarations with syntax like l et   x:	number   =   0; .



Chapter 4. Expressions and Operators




This chapter documents JavaScript expressions and the operators with which many of those expressions are built. An expression is a phrase of JavaScript that can be evaluated to produce a value. A constant embedded literally in your program is a very simple kind of expression. A variable name is also a simple expression that evaluates to whatever value has been assigned to that variable. Complex expressions are built from simpler expressions. An array access expression, for example, consists of one expression that evaluates to an array followed by an open square bracket, an expression that evaluates to an integer, and a close square bracket. This new, more complex expression evaluates to the value stored at the specified index of the specified array. Similarly, a function invocation expression consists of one expression that evaluates to a function object and zero or more additional expressions that are used as the arguments to the function.


The most common way to build a complex expression out of simpler expressions is with an operator. An operator combines the values of its operands (usually two of them) in some way and evaluates to a new value. The multiplication operator * is a simple example. The expression x   *   y evaluates to the product of the values of the expressions x and y. For simplicity, we sometimes say that an operator returns a value rather than “evaluates to” a value.

This chapter documents all of JavaScript’s operators, and it also explains

expressions (such as array indexing and function invocation) that do not use operators. If you already know another programming language that uses C-style syntax, you’ll find that the syntax of most of JavaScript’s expressions and operators is already familiar to you.


4.1 Primary Expressions

The simplest expressions, known as primary expressions, are those that stand alone—they do not include any simpler expressions. Primary expressions in JavaScript are constant or literal values, certain language keywords, and variable references.


Literals are constant values that are embedded directly in your program. They look like these:


1. 23
" hel l o"
/ pat t er n/

/ /   A  number   l i t er al / /   A  s t r i ng   l i t er al
/ /   A  r egul ar   expr es s i on   l i t er al



JavaScript syntax for number literals was covered in §3.2. String literals were documented in §3.3. The regular expression literal syntax was introduced in §3.3.5 and will be documented in detail in §11.3.


Some of JavaScript’s reserved words are primary expressions:



t r ue	/ / f al s e	/ / nul l	/ / t hi s	/ /

Eval ut es   t o   t he   bool ean   t r ue   val ue Eval uat es   t o   t he   bool ean   f al s e   val ue Eval uat es   t o   t he   nul l	val ue
Eval uat es   t o   t he   " c ur r ent "   obj ec t



We learned about t r ue, f al s e, and nul l  in §3.4 and §3.5. Unlike the other keywords, t hi s  is not a constant—it evaluates to different values in different places in the program. The t hi s  keyword is used in object-

oriented programming. Within the body of a method, t hi s  evaluates to the object on which the method was invoked. See §4.5, Chapter 8 (especially §8.2.2), and Chapter 9 for more on t hi s .


Finally, the third type of primary expression is a reference to a variable, constant, or property of the global object:


i
s um
undef i ned
gl obal	obj ec t

/ /   Eval uat es   t o   t he / /   Eval uat es   t o   t he / /   The   val ue   of    t he

val ue   of    t he   var i abl e   i . val ue   of    t he   var i abl e   s um.
" undef i ned"   pr oper t y   of    t he



When any identifier appears by itself in a program, JavaScript assumes it is a variable or constant or property of the global object and looks up its value. If no variable with that name exists, an attempt to evaluate a nonexistent variable throws a ReferenceError instead.


4.2 Object and Array Initializers

Object and array initializers are expressions whose value is a newly created object or array. These initializer expressions are sometimes called object literals and array literals. Unlike true literals, however, they are not primary expressions, because they include a number of subexpressions that specify property and element values. Array initializers have a slightly simpler syntax, and we’ll begin with those.


An array initializer is a comma-separated list of expressions contained within square brackets. The value of an array initializer is a newly created array. The elements of this new array are initialized to the values of the comma-separated expressions:

[ ]	/ /   An   empt y   ar r ay:	no   expr es s i ons   i ns i de   br ac ket s means   no   el ement s

[ 1+2, 3+4]	/ /   A  2- el ement   ar r ay.	Fi r s t   el ement   i s   3,	s ec ond   i s 7


The element expressions in an array initializer can themselves be array initializers, which means that these expressions can create nested arrays:

l et   mat r i x   =   [ [ 1, 2, 3] ,	[ 4, 5, 6] ,	[ 7, 8, 9] ] ;


The element expressions in an array initializer are evaluated each time the array initializer is evaluated. This means that the value of an array initializer expression may be different each time it is evaluated.


Undefined elements can be included in an array literal by simply omitting a value between commas. For example, the following array contains five elements, including three undefined elements:

l et   s par s eAr r ay   =   [ 1, , , , 5] ;


A single trailing comma is allowed after the last expression in an array initializer and does not create an undefined element. However, any array access expression for an index after that of the last expression will necessarily evaluate to undefined.


Object initializer expressions are like array initializer expressions, but the square brackets are replaced by curly brackets, and each subexpression is prefixed with a property name and a colon:

l et   p   =   {    x:	2. 3,	y:	- 1. 2   } ;	/ /   An   obj ec t   wi t h   2   pr oper t i es l et   q   =   { } ;                                                     / /   An   empt y   obj ec t   wi t h   no
pr oper t i es
q. x   =   2. 3;	q. y   =   - 1. 2;	/ /   Now  q   has   t he   s ame   pr oper t i es as   p


In ES6, object literals have a much more feature-rich syntax (you can find

details in §6.10). Object literals can be nested. For example:


l et   r ec t angl e   =   {
upper L ef t :    {    x:    2,    y:    2   } , l ower Ri ght :    {    x:    4,    y:    5   }
} ;


We’ll see object and array initializers again in Chapters 6 and 7.



4.3 Function Definition Expressions

A function definition expression defines a JavaScript function, and the value of such an expression is the newly defined function. In a sense, a function definition expression is a “function literal” in the same way that an object initializer is an “object literal.” A function definition expression typically consists of the keyword f unct i on followed by a comma-separated list of zero or more identifiers (the parameter names) in parentheses and a block of JavaScript code (the function body) in curly braces. For example:

/ /   Thi s   f unc t i on   r et ur ns   t he   s quar e   of    t he   val ue   pas s ed   t o   i t . l et   s quar e   =   f unc t i on( x)    {    r et ur n   x   *   x;	} ;


A function definition expression can also include a name for the function. Functions can also be defined using a function statement rather than a function expression. And in ES6 and later, function expressions can use a compact new “arrow function” syntax. Complete details on function definition are in Chapter 8.


4.4 Property Access Expressions

A property access expression evaluates to the value of an object property

or an array element. JavaScript defines two syntaxes for property access:



expr es s i on   . expr es s i on   [

i dent i f i er expr es s i on   ]



The first style of property access is an expression followed by a period and an identifier. The expression specifies the object, and the identifier specifies the name of the desired property. The second style of property access follows the first expression (the object or array) with another expression in square brackets. This second expression specifies the name of the desired property or the index of the desired array element. Here are some concrete examples:

l et   o   =   { x:	1,	y:	{ z :	3} } ;	/ /   An   exampl e   obj ec t
l et   a   =   [ o,	4,	[ 5,	6] ] ;	/ /   An   exampl e   ar r ay   t hat   c ont ai ns   t he

obj ec t
o. x	/ /   =>   1:
o. y. z	/ /   =>   3:


pr oper t y   x   of
pr oper t y   z   of


expr es s i on   o
expr es s i on   o. y

o[ " x" ]	/ /   =>   1:	pr oper t y   x   of    obj ec t   o

a[ 1]
expr es s i on   a a[ 2] [ " 1" ]
expr es s i on   a[ 2]

/ /   =>   4:	el ement   at

/ /   =>   6:	el ement   at

i ndex   1   of

i ndex   1   of

a[ 0] . x	/ /   =>   1:	pr oper t y   x   of    expr es s i on a[ 0]


With either type of property access expression, the expression before the . or [  is first evaluated. If the value is nul l  or undef i ned, the expression throws a TypeError, since these are the two JavaScript values that cannot have properties. If the object expression is followed by a dot and an identifier, the value of the property named by that identifier is looked up and becomes the overall value of the expression. If the object expression is followed by another expression in square brackets, that second expression is evaluated and converted to a string. The overall value of the expression is then the value of the property named by that string. In

either case, if the named property does not exist, then the value of the property access expression is undef i ned.


The .identifier syntax is the simpler of the two property access options, but notice that it can only be used when the property you want to access has a name that is a legal identifier, and when you know the name when you write the program. If the property name includes spaces or punctuation characters, or when it is a number (for arrays), you must use the square bracket notation. Square brackets are also used when the property name is not static but is itself the result of a computation (see §6.3.1 for an example).


Objects and their properties are covered in detail in Chapter 6, and arrays and their elements are covered in Chapter 7.


4.4.1 Conditional Property Access

ES2020 adds two new kinds of property access expressions:



expr es s i on expr es s i on

?.	i dent i f i er
?. [    expr es s i on   ]



In JavaScript, the values nul l  and undef i ned are the only two values that do not have properties. In a regular property access expression using . or [ ] , you get a TypeError if the expression on the left evaluates to nul l or undef i ned. You can use ?.  and ?. [ ]  syntax to guard against errors of this type.

Consider the expression a?. b. If a is nul l  or undef i ned, then the expression evaluates to undef i ned without any attempt to access the property b. If a is some other value, then a?. b evaluates to whatever

a. b would evaluate to (and if a does not have a property named b, then the value will again be undef i ned).


This form of property access expression is sometimes called “optional chaining” because it also works for longer “chained” property access expressions like this one:

l et   a   =   {    b:	nul l	} ;
a. b?. c . d	/ /   =>   undef i ned


a is an object, so a. b is a valid property access expression. But the value of a. b is nul l , so a. b. c would throw a TypeError. By using ?. instead of .  we avoid the TypeError, and a. b?. c evaluates to
undef i ned. This means that ( a. b?. c) . d will throw a TypeError, because that expression attempts to access a property of the value undef i ned. But—and this is a very important part of “optional chaining”—a. b?. c. d (without the parentheses) simply evaluates to
undef i ned and does not throw an error. This is because property access with ?.  is “short-circuiting”: if the subexpression to the left of ?. evaluates to nul l  or undef i ned, then the entire expression immediately evaluates to undef i ned without any further property access attempts.

Of course, if a. b is an object, and if that object has no property named c, then a. b?. c. d will again throw a TypeError, and we will want to use another conditional property access:

l et   a   =   {    b:	{ }    } ;
a. b?. c ?. d	/ /   =>   undef i ned


Conditional property access is also possible using ?. [ ]  instead of [ ] . In

the expression a?. [ b] [ c] , if the value of a is nul l  or undef i ned, then the entire expression immediately evaluates to undef i ned, and subexpressions b and c are never even evaluated. If either of those expressions has side effects, the side effect will not occur if a is not defined:

l et   a;	/ /   Oops ,	we   f or got   t o   i ni t i al i z e   t hi s   var i abl e! l et   i ndex   =   0;
t r y   {
a[ i ndex++] ;	/ /   Thr ows   TypeEr r or }    c at c h( e)    {
i ndex	/ /   =>   1:	i nc r ement   oc c ur s   bef or e   TypeEr r or   i s t hr own
}
a?. [ i ndex++]	/ /   =>   undef i ned:	bec aus e   a   i s   undef i ned
i ndex	/ /   =>   1:	not   i nc r ement ed   bec aus e   ?. [ ]    s hor t -c i r c ui t s
a[ i ndex++]	/ /   ! TypeEr r or :	c an' t   i ndex   undef i ned.


Conditional property access with ?.  and ?. [ ]  is one of the newest features of JavaScript. As of early 2020, this new syntax is supported in the current or beta versions of most major browsers.


4.5 Invocation Expressions

An invocation expression is JavaScript’s syntax for calling (or executing) a function or method. It starts with a function expression that identifies the function to be called. The function expression is followed by an open parenthesis, a comma-separated list of zero or more argument expressions, and a close parenthesis. Some examples:

f ( 0)	/ /   f    i s   t he   f unc t i on   expr es s i on;	0   i s   t he ar gument   expr es s i on.
Mat h. max( x, y, z )    / /   Mat h. max   i s   t he   f unc t i on;	x,	y,	and   z   ar e   t he ar gument s .

a. s or t ( )	/ /   a. s or t   i s   t he   f unc t i on;	t her e   ar e   no ar gument s .


When an invocation expression is evaluated, the function expression is evaluated first, and then the argument expressions are evaluated to produce a list of argument values. If the value of the function expression is not a function, a TypeError is thrown. Next, the argument values are assigned, in order, to the parameter names specified when the function was defined, and then the body of the function is executed. If the function uses a r et ur n statement to return a value, then that value becomes the value of the invocation expression. Otherwise, the value of the invocation expression is undef i ned. Complete details on function invocation, including an explanation of what happens when the number of argument expressions does not match the number of parameters in the function definition, are in Chapter 8.

Every invocation expression includes a pair of parentheses and an expression before the open parenthesis. If that expression is a property access expression, then the invocation is known as a method invocation. In method invocations, the object or array that is the subject of the property access becomes the value of the t hi s  keyword while the body of the function is being executed. This enables an object-oriented programming paradigm in which functions (which we call “methods” when used this way) operate on the object of which they are part. See Chapter 9 for details.


4.5.1 Conditional Invocation

In ES2020, you can also invoke a function using ?. ( )  instead of ( ) . Normally when you invoke a function, if the expression to the left of the parentheses is nul l  or undef i ned or any other non-function, a

TypeError is thrown. With the new ?. ( )  invocation syntax, if the expression to the left of the ?.  evaluates to nul l  or undef i ned, then the entire invocation expression evaluates to undef i ned and no exception is thrown.

Array objects have a s or t ( )  method that can optionally be passed a function argument that defines the desired sorting order for the array elements. Before ES2020, if you wanted to write a method like s or t ( ) that takes an optional function argument, you would typically use an i f statement to check that the function argument was defined before invoking it in the body of the i f :

f unc t i on   s quar e( x,	l og)    {    / /   The   s ec ond   ar gument   i s   an   opt i onal f unc t i on
i f    ( l og)    {	/ /   I f    t he   opt i onal	f unc t i on   i s   pas s ed l og( x) ;	/ /   I nvoke   i t
}
r et ur n   x   *   x;	/ /   Ret ur n   t he   s quar e   of    t he   ar gument }


With this conditional invocation syntax of ES2020, however, you can simply write the function invocation using ?. ( ) , knowing that invocation will only happen if there is actually a value to be invoked:

f unc t i on   s quar e( x,	l og)    {    / /   The   s ec ond   ar gument   i s   an   opt i onal f unc t i on
l og?. ( x) ;                                     / /   Cal l    t he   f unc t i on   i f    t her e   i s   one r et ur n   x   *   x;                          / /   Ret ur n   t he   s quar e   of    t he   ar gument
}


Note, however, that ?. ( )  only checks whether the lefthand side is nul l or undef i ned. It does not verify that the value is actually a function. So the s quar e( )  function in this example would still throw an exception if

you passed two numbers to it, for example.


Like conditional property access expressions (§4.4.1), function invocation with ?. ( )  is short-circuiting: if the value to the left of ?.  is nul l  or undef i ned, then none of the argument expressions within the parentheses are evaluated:

l et   f    =   nul l ,	x   =   0; t r y   {
f ( x++) ;	/ /   Thr ows   TypeEr r or   bec aus e   f    i s   nul l }    c at c h( e)    {
x	/ /   =>   1:	x   get s   i nc r ement ed   bef or e   t he   exc ept i on   i s t hr own
}
f ?. ( x++)	/ /   =>   undef i ned:	f    i s   nul l ,	but   no   exc ept i on   t hr own x	/ /   =>   1:	i nc r ement   i s   s ki pped   bec aus e   of    s hor t -
c i r c ui t i ng


Conditional invocation expressions with ?. ( )  work just as well for methods as they do for functions. But because method invocation also involves property access, it is worth taking a moment to be sure you understand the differences between the following expressions:

o. m( )	/ /   Regul ar   pr oper t y   ac c es s ,	r egul ar   i nvoc at i on
o?. m( )            / /   Condi t i onal    pr oper t y   ac c es s ,    r egul ar   i nvoc at i on o. m?. ( )         / /   Regul ar   pr oper t y   ac c es s ,    c ondi t i onal    i nvoc at i on


In the first expression, o must be an object with a property mand the value of that property must be a function. In the second expression, if o is nul l or undef i ned, then the expression evaluates to undef i ned. But if o has any other value, then it must have a property mwhose value is a function. And in the third expression, o must not be nul l  or
undef i ned. If it does not have a property m, or if the value of that property is nul l , then the entire expression evaluates to undef i ned.

Conditional invocation with ?. ( )  is one of the newest features of JavaScript. As of the first months of 2020, this new syntax is supported in the current or beta versions of most major browsers.


4.6 Object Creation Expressions

An object creation expression creates a new object and invokes a function (called a constructor) to initialize the properties of that object. Object creation expressions are like invocation expressions except that they are prefixed with the keyword new:


new  Obj ec t ( ) new  Poi nt ( 2, 3)


If no arguments are passed to the constructor function in an object creation expression, the empty pair of parentheses can be omitted:

new  Obj ec t new  Dat e


The value of an object creation expression is the newly created object. Constructors are explained in more detail in Chapter 9.


4.7 Operator Overview

Operators are used for JavaScript’s arithmetic expressions, comparison expressions, logical expressions, assignment expressions, and more. Table 4-1 summarizes the operators and serves as a convenient reference.


Note that most operators are represented by punctuation characters such as + and =. Some, however, are represented by keywords such as del et e and i ns t anceof . Keyword operators are regular operators, just like

those expressed with punctuation; they simply have a less succinct syntax.


Table 4-1 is organized by operator precedence. The operators listed first have higher precedence than those listed last. Operators separated by a horizontal line have different precedence levels. The column labeled A gives the operator associativity, which can be L (left-to-right) or R (right-to-left), and the column N specifies the number of operands. The column labeled Types lists the expected types of the operands and (after the → symbol) the result type for the operator. The subsections that follow the table explain the concepts of precedence, associativity, and operand type. The operators themselves are individually documented following that discussion.


Table 4-1. JavaScript operators


Operator

++

- -

-

+

~

!

del et e

t ypeof

voi d

**

*, / , %

Operation

Pre- or post-increment

Pre- or post-decrement

Negate number

Convert to number

Invert bits

Invert boolean value

Remove a property

Determine type of operand

Return undefined value

Exponentiate

Multiply, divide, remainder

A	N	Types

R	1	lval→num

R	1	lval→num

R	1	num→num

R	1	any→num

R	1	int→int

R	1	bool→bool

R	1	lval→bool

R	1	any→str

R	1	any→undef

R	2	num,num→num

L	2	num,num→num



+, -

+

<<

>>

>>>

<, <=,>, >=

<, <=,>, >=

i ns t anc eof

i n

==

! =

===

! ==

&

^

|

&&

||

??

?:

=

**=, *=, / =, %=,

Add, subtract

Concatenate strings

Shift left

Shift right with sign extension

Shift right with zero extension

Compare in numeric order

Compare in alphabetical order

Test object class

Test whether property exists

Test for non-strict equality

Test for non-strict inequality

Test for strict equality

Test for strict inequality

Compute bitwise AND

Compute bitwise XOR

Compute bitwise OR

Compute logical AND

Compute logical OR

Choose 1st defined operand

Choose 2nd or 3rd operand

Assign to a variable or property

Operate and assign

L	2	num,num→num

L	2	str,str→str

L	2	int,int→int

L	2	int,int→int

L	2	int,int→int

L	2	num,num→bool

L	2	str,str→bool

L	2	obj,func→bool

L	2	any,obj→bool

L	2	any,any→bool

L	2	any,any→bool

L	2	any,any→bool

L	2	any,any→bool

L	2	int,int→int

L	2	int,int→int

L	2	int,int→int

L	2	any,any→any

L	2	any,any→any

L	2	any,any→any

R	3	bool,any,any→any

R	2	lval,any→any

R	2	lval,any→any


+=, - =, &=, ^=, |=,


<<=, >>=, >>>=

,	Discard 1st operand, return 2nd	L	2	any,any→any


4.7.1 Number of Operands

Operators can be categorized based on the number of operands they expect (their arity). Most JavaScript operators, like the * multiplication operator, are binary operators that combine two expressions into a single, more complex expression. That is, they expect two operands. JavaScript also supports a number of unary operators, which convert a single expression into a single, more complex expression. The − operator in the expression −x is a unary operator that performs the operation of negation on the operand x. Finally, JavaScript supports one ternary operator, the conditional operator ?: , which combines three expressions into a single expression.


4.7.2 Operand and Result Type

Some operators work on values of any type, but most expect their operands to be of a specific type, and most operators return (or evaluate to) a value of a specific type. The Types column in Table 4-1 specifies operand types (before the arrow) and result type (after the arrow) for the operators.


JavaScript operators usually convert the type (see §3.9) of their operands as needed. The multiplication operator * expects numeric operands, but the expression " 3"   *   " 5" is legal because JavaScript can convert the operands to numbers. The value of this expression is the number 15, not the string “15”, of course. Remember also that every JavaScript value is either “truthy” or “falsy,” so operators that expect boolean operands will

work with an operand of any type.


Some operators behave differently depending on the type of the operands used with them. Most notably, the + operator adds numeric operands but concatenates string operands. Similarly, the comparison operators such as < perform comparison in numerical or alphabetical order depending on the type of the operands. The descriptions of individual operators explain their type-dependencies and specify what type conversions they perform.

Notice that the assignment operators and a few of the other operators listed in Table 4-1 expect an operand of type l val . lvalue is a historical term that means “an expression that can legally appear on the left side of an assignment expression.” In JavaScript, variables, properties of objects, and elements of arrays are lvalues.


4.7.3 Operator Side Effects

Evaluating a simple expression like 2   *   3 never affects the state of your program, and any future computation your program performs will be unaffected by that evaluation. Some expressions, however, have side effects, and their evaluation may affect the result of future evaluations. The assignment operators are the most obvious example: if you assign a value to a variable or property, that changes the value of any expression that uses that variable or property. The ++ and - -  increment and decrement operators are similar, since they perform an implicit assignment. The
del et e operator also has side effects: deleting a property is like (but not the same as) assigning undef i ned to the property.

No other JavaScript operators have side effects, but function invocation and object creation expressions will have side effects if any of the

operators used in the function or constructor body have side effects.


4.7.4 Operator Precedence

The operators listed in Table 4-1 are arranged in order from high precedence to low precedence, with horizontal lines separating groups of operators at the same precedence level. Operator precedence controls the order in which operations are performed. Operators with higher precedence (nearer the top of the table) are performed before those with lower precedence (nearer to the bottom).


Consider the following expression:


w  =   x   +   y*z ;


The multiplication operator * has a higher precedence than the addition operator +, so the multiplication is performed before the addition. Furthermore, the assignment operator = has the lowest precedence, so the assignment is performed after all the operations on the right side are completed.

Operator precedence can be overridden with the explicit use of parentheses. To force the addition in the previous example to be performed first, write:

w  =   ( x   +   y) *z ;


Note that property access and invocation expressions have higher precedence than any of the operators listed in Table 4-1. Consider this expression:

/ /   my   i s   an   obj ec t   wi t h   a   pr oper t y   named   f unc t i ons   whos e   val ue i s   an


/ /   ar r ay   of    f unc t i ons .	We ar gument
/ /   y,	and   t hen   we   as k   f or

i nvoke   f unc t i on

t he   t ype   of    t he

number   x,	pas s i ng   i t

val ue   r et ur ned.

t ypeof    my. f unc t i ons [ x] ( y)


Although t ypeof  is one of the highest-priority operators, the t ypeof operation is performed on the result of the property access, array index, and function invocation, all of which have higher priority than operators.

In practice, if you are at all unsure about the precedence of your operators, the simplest thing to do is to use parentheses to make the evaluation order explicit. The rules that are important to know are these: multiplication and division are performed before addition and subtraction, and assignment has very low precedence and is almost always performed last.


When new operators are added to JavaScript, they do not always fit naturally into this precedence scheme. The ?? operator (§4.13.2) is shown in the table as lower-precedence than || and &&, but, in fact, its precedence relative to those operators is not defined, and ES2020 requires you to explicitly use parentheses if you mix ?? with either || or &&. Similarly, the new ** exponentiation operator does not have a well-defined precedence relative to the unary negation operator, and you must use parentheses when combining negation with exponentiation.


4.7.5 Operator Associativity

In Table 4-1, the column labeled A specifies the associativity of the operator. A value of L specifies left-to-right associativity, and a value of R specifies right-to-left associativity. The associativity of an operator specifies the order in which operations of the same precedence are performed. Left-to-right associativity means that operations are performed from left to right. For example, the subtraction operator has left-to-right

associativity, so:


w  =   x   -    y   -    z ;


is the same as:


w  =   ( ( x   -    y)    -    z ) ;


On the other hand, the following expressions:


y   =   a   **   b   **   c ; x   =   ~- y;
w  =   x   =   y   =   z ;
q   =   a?b: c ?d: e?f : g;


are equivalent to:


y   =   ( a   **   ( b   **   c ) ) ; x   =   ~( - y) ;
w  =   ( x   =   ( y   =   z ) ) ;
q   =   a?b: ( c ?d: ( e?f : g) ) ;


because the exponentiation, unary, assignment, and ternary conditional operators have right-to-left associativity.


4.7.6 Order of Evaluation

Operator precedence and associativity specify the order in which operations are performed in a complex expression, but they do not specify the order in which the subexpressions are evaluated. JavaScript always evaluates expressions in strictly left-to-right order. In the expression w  = x   +   y   *   z , for example, the subexpression wis evaluated first, followed by x, y, and z . Then the values of y and z are multiplied, added to the value of x, and assigned to the variable or property specified by

expression w. Adding parentheses to the expressions can change the relative order of the multiplication, addition, and assignment, but not the left-to-right order of evaluation.

Order of evaluation only makes a difference if any of the expressions being evaluated has side effects that affect the value of another expression. If expression x increments a variable that is used by expression z , then the fact that x is evaluated before z is important.


4.8 Arithmetic Expressions

This section covers the operators that perform arithmetic or other numerical manipulations on their operands. The exponentiation, multiplication, division, and subtraction operators are straightforward and are covered first. The addition operator gets a subsection of its own because it can also perform string concatenation and has some unusual type conversion rules. The unary operators and the bitwise operators are also covered in subsections of their own.


Most of these arithmetic operators (except as noted as follows) can be used with BigInt (see §3.2.5) operands or with regular numbers, as long as you don’t mix the two types.


The basic arithmetic operators are ** (exponentiation), * (multiplication), /  (division), %(modulo: remainder after division), + (addition), and -(subtraction). As noted, we’ll discuss the + operator in a section of its own. The other five basic operators simply evaluate their operands, convert the values to numbers if necessary, and then compute the power, product, quotient, remainder, or difference. Non-numeric operands that cannot convert to numbers convert to the NaN value. If either operand is

(or converts to) NaN, the result of the operation is (almost always) NaN.


The ** operator has higher precedence than *, / , and %(which in turn have higher precedence than + and - ). Unlike the other operators, ** works right-to-left, so 2**2**3 is the same as 2**8, not 4**3. There is a natural ambiguity to expressions like - 3**2. Depending on the relative precedence of unary minus and exponentiation, that expression could mean ( - 3) **2 or - ( 3**2) . Different languages handle this differently, and rather than pick sides, JavaScript simply makes it a syntax error to omit parentheses in this case, forcing you to write an unambiguous expression. ** is JavaScript’s newest arithmetic operator: it was added to the language with ES2016. The Mat h. pow( )  function has been available since the earliest versions of JavaScript, however, and it performs exactly the same operation as the ** operator.


The /  operator divides its first operand by its second. If you are used to programming languages that distinguish between integer and floating-point numbers, you might expect to get an integer result when you divide one integer by another. In JavaScript, however, all numbers are floating-point, so all division operations have floating-point results: 5/ 2 evaluates to 2. 5, not 2. Division by zero yields positive or negative infinity, while 0/ 0 evaluates to NaN: neither of these cases raises an error.


The %operator computes the first operand modulo the second operand. In other words, it returns the remainder after whole-number division of the first operand by the second operand. The sign of the result is the same as the sign of the first operand. For example, 5   %  2 evaluates to 1, and - 5 %  2 evaluates to - 1.


While the modulo operator is typically used with integer operands, it also

works for floating-point values. For example, 6. 5   %  2. 1 evaluates to 0. 2.


4.8.1 The + Operator

The binary + operator adds numeric operands or concatenates string operands:


1   +   2
" hel l o"   +   "   "   +   " t her e" " 1"   +   " 2"

/ /   =>   3
/ /   =>   " hel l o   t her e" / /   =>   " 12"



When the values of both operands are numbers, or are both strings, then it is obvious what the + operator does. In any other case, however, type conversion is necessary, and the operation to be performed depends on the conversion performed. The conversion rules for + give priority to string concatenation: if either of the operands is a string or an object that converts to a string, the other operand is converted to a string and concatenation is performed. Addition is performed only if neither operand is string-like.

Technically, the + operator behaves like this:


If either of its operand values is an object, it converts it to a primitive using the object-to-primitive algorithm described in §3.9.3. Date objects are converted by their t oSt r i ng( ) method, and all other objects are converted via val ueOf ( ) , if that method returns a primitive value. However, most objects do not have a useful val ueOf ( )  method, so they are converted via t oSt r i ng( )  as well.

After object-to-primitive conversion, if either operand is a string, the other is converted to a string and concatenation is performed.

Otherwise, both operands are converted to numbers (or to NaN) and addition is performed.

Here are some examples:



1   +   2
" 1"   +   " 2" " 1"   +   2

/ /   =>   3:	addi t i on
/ /   =>   " 12" :	c onc at enat i on
/ /   =>   " 12" :	c onc at enat i on   af t er   number - t o- s t r i ng

1   +   { }	/ /   =>   " 1[ obj ec t   Obj ec t ] " :	c onc at enat i on   af t er

obj ec t - t o- s t r i ng
t r ue   +   t r ue	/ /   => 2   +   nul l	/ /   => 2   +   undef i ned   / /   => NaN


2:	addi t i on   af t er   bool ean- t o- number 2:	addi t i on   af t er   nul l	c onver t s   t o   0
NaN:	addi t i on   af t er   undef i ned   c onver t s   t o



Finally, it is important to note that when the + operator is used with strings and numbers, it may not be associative. That is, the result may depend on the order in which operations are performed.

For example:


1   +   2   +   "   bl i nd   mi c e"	/ /   =>   " 3   bl i nd   mi c e" 1   +   ( 2   +   "   bl i nd   mi c e" )	/ /   =>   " 12   bl i nd   mi c e"


The first line has no parentheses, and the + operator has left-to-right associativity, so the two numbers are added first, and their sum is concatenated with the string. In the second line, parentheses alter this order of operations: the number 2 is concatenated with the string to produce a new string. Then the number 1 is concatenated with the new string to produce the final result.


4.8.2 Unary Arithmetic Operators

Unary operators modify the value of a single operand to produce a new value. In JavaScript, the unary operators all have high precedence and are all right-associative. The arithmetic unary operators described in this

section (+, - , ++, and - - ) all convert their single operand to a number, if necessary. Note that the punctuation characters + and -  are used as both unary and binary operators.

The unary arithmetic operators are the following:


Unary plus (+)

The unary plus operator converts its operand to a number (or to NaN) and returns that converted value. When used with an operand that is already a number, it doesn’t do anything. This operator may not be used with BigInt values, since they cannot be converted to regular numbers.

Unary minus (- )

When -  is used as a unary operator, it converts its operand to a number, if necessary, and then changes the sign of the result.

Increment (++)

The ++ operator increments (i.e., adds 1 to) its single operand, which must be an lvalue (a variable, an element of an array, or a property of an object). The operator converts its operand to a number, adds 1 to that number, and assigns the incremented value back into the variable, element, or property.

The return value of the ++ operator depends on its position relative to the operand. When used before the operand, where it is known as the pre-increment operator, it increments the operand and evaluates to the incremented value of that operand. When used after the operand, where it is known as the post-increment operator, it increments its operand but evaluates to the unincremented value of that operand. Consider the difference between these two lines of code:


l et   i	=   1,	j	=   ++i ;	/ /   i	and   j	ar e   bot h   2


l et   n   =   1,	m =   n++;	/ /   n   i s   2,	m i s   1


Note that the expression x++ is not always the same as x=x+1. The ++ operator never performs string concatenation: it always converts its operand to a number and increments it. If x is the string “1”, ++x is the number 2, but x+1 is the string “11”.

Also note that, because of JavaScript’s automatic semicolon insertion, you cannot insert a line break between the post-increment operator and the operand that precedes it. If you do so, JavaScript will treat the operand as a complete statement by itself and insert a semicolon before it.

This operator, in both its pre- and post-increment forms, is most commonly used to increment a counter that controls a f or  loop (§5.4.3).

Decrement (- - )

The - -  operator expects an lvalue operand. It converts the value of the operand to a number, subtracts 1, and assigns the decremented value back to the operand. Like the ++ operator, the return value of - -depends on its position relative to the operand. When used before the operand, it decrements and returns the decremented value. When used after the operand, it decrements the operand but returns the undecremented value. When used after its operand, no line break is allowed between the operand and the operator.


4.8.3 Bitwise Operators

The bitwise operators perform low-level manipulation of the bits in the binary representation of numbers. Although they do not perform traditional arithmetic operations, they are categorized as arithmetic operators here because they operate on numeric operands and return a numeric value. Four of these operators perform Boolean algebra on the individual bits of the operands, behaving as if each bit in each operand

were a boolean value (1=true, 0=false). The other three bitwise operators are used to shift bits left and right. These operators are not commonly used in JavaScript programming, and if you are not familiar with the binary representation of integers, including the two’s complement representation of negative integers, you can probably skip this section.


The bitwise operators expect integer operands and behave as if those values were represented as 32-bit integers rather than 64-bit floating-point values. These operators convert their operands to numbers, if necessary, and then coerce the numeric values to 32-bit integers by dropping any fractional part and any bits beyond the 32nd. The shift operators require a right-side operand between 0 and 31. After converting this operand to an unsigned 32-bit integer, they drop any bits beyond the 5th, which yields a number in the appropriate range. Surprisingly, NaN, I nf i ni t y, and -
I nf i ni t y all convert to 0 when used as operands of these bitwise operators.

All of these bitwise operators except >>> can be used with regular number operands or with BigInt (see §3.2.5) operands.


Bitwise AND (&)

The &operator performs a Boolean AND operation on each bit of its integer arguments. A bit is set in the result only if the corresponding bit is set in both operands. For example, 0x1234   &  0x00FF evaluates to 0x0034.

Bitwise OR (|)

The | operator performs a Boolean OR operation on each bit of its integer arguments. A bit is set in the result if the corresponding bit is set in one or both of the operands. For example, 0x1234   |   0x00FF evaluates to 0x12FF.


Bitwise XOR (^)

The ^ operator performs a Boolean exclusive OR operation on each bit of its integer arguments. Exclusive OR means that either operand one is t r ue or operand two is t r ue, but not both. A bit is set in this operation’s result if a corresponding bit is set in one (but not both) of the two operands. For example, 0xFF00   ^   0xF0F0 evaluates to 0x0FF0.

Bitwise NOT (~)

The ~ operator is a unary operator that appears before its single integer operand. It operates by reversing all bits in the operand. Because of the way signed integers are represented in JavaScript, applying the ~ operator to a value is equivalent to changing its sign and subtracting 1. For example, ~0x0F evaluates to 0xFFFFFFF0, or −16.

Shift left (<<)

The << operator moves all bits in its first operand to the left by the number of places specified in the second operand, which should be an integer between 0 and 31. For example, in the operation a   <<   1, the first bit (the ones bit) of a becomes the second bit (the twos bit), the second bit of a becomes the third, etc. A zero is used for the new first bit, and the value of the 32nd bit is lost. Shifting a value left by one position is equivalent to multiplying by 2, shifting two positions is equivalent to multiplying by 4, and so on. For example, 7   <<   2 evaluates to 28.

Shift right with sign (>>)

The >> operator moves all bits in its first operand to the right by the number of places specified in the second operand (an integer between 0 and 31). Bits that are shifted off the right are lost. The bits filled in on the left depend on the sign bit of the original operand, in order to preserve the sign of the result. If the first operand is positive, the result has zeros placed in the high bits; if the first operand is negative, the

result has ones placed in the high bits. Shifting a positive value right one place is equivalent to dividing by 2 (discarding the remainder), shifting right two places is equivalent to integer division by 4, and so on. 7   >>   1 evaluates to 3, for example, but note that and −7   >>   1 evaluates to −4.

Shift right with zero fill (>>>)

The >>> operator is just like the >> operator, except that the bits shifted in on the left are always zero, regardless of the sign of the first operand. This is useful when you want to treat signed 32-bit values as if they are unsigned integers. −1   >>   4 evaluates to −1, but −1   >>> 4 evaluates to 0x0FFFFFFF, for example. This is the only one of the JavaScript bitwise operators that cannot be used with BigInt values. BigInt does not represent negative numbers by setting the high bit the way that 32-bit integers do, and this operator only makes sense for that particular two’s complement representation.


4.9 Relational Expressions

This section describes JavaScript’s relational operators. These operators test for a relationship (such as “equals,” “less than,” or “property of”) between two values and return t r ue or f al s e depending on whether that relationship exists. Relational expressions always evaluate to a boolean value, and that value is often used to control the flow of program execution in i f , whi l e, and f or  statements (see Chapter 5). The subsections that follow document the equality and inequality operators, the comparison operators, and JavaScript’s other two relational operators, i n and i ns t anceof .


4.9.1 Equality and Inequality Operators

The == and === operators check whether two values are the same, using

two different definitions of sameness. Both operators accept operands of any type, and both return t r ue if their operands are the same and f al s e if they are different. The === operator is known as the strict equality operator (or sometimes the identity operator), and it checks whether its two operands are “identical” using a strict definition of sameness. The == operator is known as the equality operator; it checks whether its two operands are “equal” using a more relaxed definition of sameness that allows type conversions.

The ! = and ! == operators test for the exact opposite of the == and === operators. The ! = inequality operator returns f al s e if two values are equal to each other according to == and returns t r ue otherwise. The ! == operator returns f al s e if two values are strictly equal to each other and returns t r ue otherwise. As you’ll see in §4.10, the !  operator computes the Boolean NOT operation. This makes it easy to remember that ! = and ! == stand for “not equal to” and “not strictly equal to.”



THE =, ==, AND ===  OPERATORS

JavaScript supports =, ==, and === operators. Be sure you understand the differences between these assignment, equality, and strict equality operators, and be careful to use the correct one when coding! Although it is tempting to read all three operators as “equals,” it may help to reduce confusion if you read “gets” or “is assigned” for =, “is equal to” for ==, and “is strictly equal to” for ===.

The == operator is a legacy feature of JavaScript and is widely considered to be a source of bugs. You should almost always use === instead of ==, and ! == instead of ! =.



As mentioned in §3.8, JavaScript objects are compared by reference, not by value. An object is equal to itself, but not to any other object. If two distinct objects have the same number of properties, with the same names and values, they are still not equal. Similarly, two arrays that have the same elements in the same order are not equal to each other.

STRICT EQUALITY

The strict equality operator === evaluates its operands, then compares the two values as follows, performing no type conversion:

If the two values have different types, they are not equal.

If both values are nul l  or both values are undef i ned, they are equal.

If both values are the boolean value t r ue or both are the boolean value f al s e, they are equal.

If one or both values is NaN, they are not equal. (This is surprising, but the NaN value is never equal to any other value, including itself! To check whether a value x is NaN, use x   ! == x, or the global i s NaN( )  function.)

If both values are numbers and have the same value, they are equal. If one value is 0 and the other is - 0, they are also equal.

If both values are strings and contain exactly the same 16-bit values (see the sidebar in §3.3) in the same positions, they are equal. If the strings differ in length or content, they are not equal. Two strings may have the same meaning and the same visual appearance, but still be encoded using different sequences of 16-bit values. JavaScript performs no Unicode normalization, and a pair of strings like this is not considered equal to the === or == operators.

If both values refer to the same object, array, or function, they are equal. If they refer to different objects, they are not equal, even if both objects have identical properties.

EQUALITY WITH TYPE CONVERSION

The equality operator == is like the strict equality operator, but it is less strict. If the values of the two operands are not the same type, it attempts

some type conversions and tries the comparison again:


If the two values have the same type, test them for strict equality as described previously. If they are strictly equal, they are equal. If they are not strictly equal, they are not equal.

If the two values do not have the same type, the == operator may still consider them equal. It uses the following rules and type conversions to check for equality:

If one value is nul l  and the other is undef i ned, they are equal.

If one value is a number and the other is a string, convert the string to a number and try the comparison again, using the converted value.

If either value is t r ue, convert it to 1 and try the comparison again. If either value is f al s e, convert it to 0 and try the comparison again.

If one value is an object and the other is a number or string, convert the object to a primitive using the algorithm described in §3.9.3 and try the comparison again. An object is converted to a primitive value by either its t oSt r i ng( )  method or its val ueOf ( ) method. The built-in classes of core JavaScript attempt val ueOf ( )  conversion before t oSt r i ng( ) conversion, except for the Date class, which performs t oSt r i ng( )  conversion.

Any other combinations of values are not equal.

As an example of testing for equality, consider the comparison:


" 1"   ==   t r ue	/ /   =>   t r ue


This expression evaluates to t r ue, indicating that these very different-

looking values are in fact equal. The boolean value t r ue is first converted to the number 1, and the comparison is done again. Next, the string " 1" is converted to the number 1. Since both values are now the same, the comparison returns t r ue.


4.9.2 Comparison Operators

The comparison operators test the relative order (numerical or alphabetical) of their two operands:


Less than (<)

The < operator evaluates to t r ue if its first operand is less than its second operand; otherwise, it evaluates to f al s e.

Greater than (>)

The > operator evaluates to t r ue if its first operand is greater than its second operand; otherwise, it evaluates to f al s e.

Less than or equal (<=)

The <= operator evaluates to t r ue if its first operand is less than or equal to its second operand; otherwise, it evaluates to f al s e.

Greater than or equal (>=)

The >= operator evaluates to t r ue if its first operand is greater than or equal to its second operand; otherwise, it evaluates to f al s e.


The operands of these comparison operators may be of any type. Comparison can be performed only on numbers and strings, however, so operands that are not numbers or strings are converted.


Comparison and conversion occur as follows:

If either operand evaluates to an object, that object is converted to a primitive value, as described at the end of §3.9.3; if its
val ueOf ( )  method returns a primitive value, that value is used. Otherwise, the return value of its t oSt r i ng( )  method is used.

If, after any required object-to-primitive conversion, both operands are strings, the two strings are compared, using alphabetical order, where “alphabetical order” is defined by the numerical order of the 16-bit Unicode values that make up the strings.

If, after object-to-primitive conversion, at least one operand is not a string, both operands are converted to numbers and compared numerically. 0 and - 0 are considered equal. I nf i ni t y is larger than any number other than itself, and - I nf i ni t y is smaller than any number other than itself. If either operand is (or converts to) NaN, then the comparison operator always returns f al s e. Although the arithmetic operators do not allow BigInt values to be mixed with regular numbers, the comparison operators do allow comparisons between numbers and BigInts.

Remember that JavaScript strings are sequences of 16-bit integer values, and that string comparison is just a numerical comparison of the values in the two strings. The numerical encoding order defined by Unicode may not match the traditional collation order used in any particular language or locale. Note in particular that string comparison is case-sensitive, and all capital ASCII letters are “less than” all lowercase ASCII letters. This rule can cause confusing results if you do not expect it. For example, according to the < operator, the string “Zoo” comes before the string “aardvark”.


For a more robust string-comparison algorithm, try the
St r i ng. l ocal eCompar e( )  method, which also takes locale-specific definitions of alphabetical order into account. For case-insensitive comparisons, you can convert the strings to all lowercase or all uppercase

using St r i ng. t oLower Cas e( )  or St r i ng. t oUpper Cas e( ) . And, for a more general and better localized string comparison tool, use the Intl.Collator class described in §11.7.3.

Both the + operator and the comparison operators behave differently for numeric and string operands. + favors strings: it performs concatenation if either operand is a string. The comparison operators favor numbers and only perform string comparison if both operands are strings:


1   +   2
" 1"   +   " 2" " 1"   +   2 11   <   3
" 11"   <   " 3" " 11"   <   3 11.
" one"   <   3 NaN.

/ /   =>   3:	addi t i on.
/ /   =>   " 12" :	c onc at enat i on.
/ /   =>   " 12" :	2   i s   c onver t ed   t o   " 2" . / /   =>   f al s e:    numer i c   c ompar i s on.
/ /   =>   t r ue:	s t r i ng   c ompar i s on.
/ /   =>   f al s e:	numer i c   c ompar i s on,	" 11"   c onver t ed   t o

/ /   =>   f al s e:	numer i c   c ompar i s on,	" one"   c onver t ed   t o



Finally, note that the <= (less than or equal) and >= (greater than or equal) operators do not rely on the equality or strict equality operators for determining whether two values are “equal.” Instead, the less-than-or-equal operator is simply defined as “not greater than,” and the greater-than-or-equal operator is defined as “not less than.” The one exception occurs when either operand is (or converts to) NaN, in which case, all four comparison operators return f al s e.


4.9.3 The in Operator

The i n operator expects a left-side operand that is a string, symbol, or value that can be converted to a string. It expects a right-side operand that is an object. It evaluates to t r ue if the left-side value is the name of a property of the right-side object. For example:

l et   poi nt   =   { x:	1,	y:	1} ;	/ /   Def i ne   an   obj ec t

" x"   i n   poi nt " x"
" z "   i n   poi nt pr oper t y.
" t oSt r i ng"   i n   poi nt met hod

/ /   =>   t r ue:	obj ec t   has   pr oper t y   named

/ /   =>   f al s e:	obj ec t   has   no   " z "

/ /   =>   t r ue:	obj ec t   i nher i t s   t oSt r i ng


l et   dat a   =   [ 7, 8, 9] ;	/ /   An   ar r ay   wi t h   el ement s   ( i ndi c es )

0,	1,	and   2 " 0"   i n   dat a 1   i n   dat a
s t r i ngs
3   i n   dat a


/ /   =>   t r ue:    ar r ay   has   an   el ement   " 0" / /   =>   t r ue:    number s   ar e   c onver t ed   t o

/ /   =>   f al s e:	no   el ement   3



4.9.4 The instanceof Operator

The i ns t anceof  operator expects a left-side operand that is an object and a right-side operand that identifies a class of objects. The operator evaluates to t r ue if the left-side object is an instance of the right-side class and evaluates to f al s e otherwise. Chapter 9 explains that, in JavaScript, classes of objects are defined by the constructor function that initializes them. Thus, the right-side operand of i ns t anceof  should be a function. Here are examples:

l et   d   =   new  Dat e( ) ;	/ /   Cr eat e   a   new  obj ec t   wi t h   t he   Dat e( )

c ons t r uc t or
d   i ns t anc eof    Dat e
d   i ns t anc eof    Obj ec t Obj ec t
d   i ns t anc eof    Number


/ /   =>   t r ue:	d   was   c r eat ed   wi t h   Dat e( )
/ /   =>   t r ue:	al l	obj ec t s   ar e   i ns t anc es   of

/ /   =>   f al s e:	d   i s   not   a   Number   obj ec t

l et   a   =   [ 1,	2,	3] ;	/ /   Cr eat e   an   ar r ay   wi t h   ar r ay   l i t er al

s ynt ax
a   i ns t anc eof    Ar r ay a   i ns t anc eof    Obj ec t a   i ns t anc eof    RegExp expr es s i ons


/ /   =>   t r ue:	a   i s   an   ar r ay
/ /   =>   t r ue:	al l	ar r ays   ar e   obj ec t s / /   =>   f al s e:    ar r ays   ar e   not   r egul ar



Note that all objects are instances of Obj ect . i ns t anceof  considers the “superclasses” when deciding whether an object is an instance of a

class. If the left-side operand of i ns t anceof  is not an object,
i ns t anceof  returns f al s e. If the righthand side is not a class of objects, it throws a TypeEr r or .


In order to understand how the i ns t anceof  operator works, you must understand the “prototype chain.” This is JavaScript’s inheritance mechanism, and it is described in §6.3.2. To evaluate the expression o
i ns t anceof   f , JavaScript evaluates f . pr ot ot ype, and then looks for that value in the prototype chain of o. If it finds it, then o is an instance of f  (or of a subclass of f ) and the operator returns t r ue. If
f . pr ot ot ype is not one of the values in the prototype chain of o, then o is not an instance of f  and i ns t anceof  returns f al s e.


4.10 Logical Expressions

The logical operators &&, ||, and !  perform Boolean algebra and are often used in conjunction with the relational operators to combine two relational expressions into one more complex expression. These operators are described in the subsections that follow. In order to fully understand them, you may want to review the concept of “truthy” and “falsy” values introduced in §3.4.


4.10.1 Logical AND (&&)

The &&operator can be understood at three different levels. At the simplest level, when used with boolean operands, &&performs the Boolean AND operation on the two values: it returns t r ue if and only if both its first operand and its second operand are t r ue. If one or both of these operands is f al s e, it returns f al s e.

&&is often used as a conjunction to join two relational expressions:


x   ===   0   &&  y   ===   0	/ /   t r ue   i f ,	and   onl y   i f ,	x   and   y   ar e   bot h   0


Relational expressions always evaluate to t r ue or f al s e, so when used like this, the &&operator itself returns t r ue or f al s e. Relational operators have higher precedence than &&(and ||), so expressions like these can safely be written without parentheses.

But &&does not require that its operands be boolean values. Recall that all JavaScript values are either “truthy” or “falsy.” (See §3.4 for details. The falsy values are f al s e, nul l , undef i ned, 0, - 0, NaN, and " " . All other values, including all objects, are truthy.) The second level at which &&can be understood is as a Boolean AND operator for truthy and falsy values. If both operands are truthy, the operator returns a truthy value. Otherwise, one or both operands must be falsy, and the operator returns a falsy value. In JavaScript, any expression or statement that expects a boolean value will work with a truthy or falsy value, so the fact that && does not always return t r ue or f al s e does not cause practical problems.


Notice that this description says that the operator returns “a truthy value” or “a falsy value” but does not specify what that value is. For that, we need to describe &&at the third and final level. This operator starts by evaluating its first operand, the expression on its left. If the value on the left is falsy, the value of the entire expression must also be falsy, so && simply returns the value on the left and does not even evaluate the expression on the right.

On the other hand, if the value on the left is truthy, then the overall value of the expression depends on the value on the righthand side. If the value

on the right is truthy, then the overall value must be truthy, and if the value on the right is falsy, then the overall value must be falsy. So when the value on the left is truthy, the &&operator evaluates and returns the value on the right:

l et   o   =   { x:	1} ; l et   p   =   nul l ;
o   &&  o. x	/ /   =>   1:	o   i s   t r ut hy,	s o   r et ur n   val ue   of    o. x
p   &&  p. x	/ /   =>   nul l :	p   i s   f al s y,	s o   r et ur n   i t   and   don' t eval uat e   p. x


It is important to understand that &&may or may not evaluate its right-side operand. In this code example, the variable p is set to nul l , and the expression p. x would, if evaluated, cause a TypeError. But the code uses &&in an idiomatic way so that p. x is evaluated only if p is truthy—not nul l  or undef i ned.


The behavior of &&is sometimes called short circuiting, and you may sometimes see code that purposely exploits this behavior to conditionally execute code. For example, the following two lines of JavaScript code have equivalent effects:

i f    ( a   ===   b)    s t op( ) ;	/ /   I nvoke   s t op( )    onl y   i f    a   ===   b ( a   ===   b)    &&  s t op( ) ;	/ /   Thi s   does   t he   s ame   t hi ng


In general, you must be careful whenever you write an expression with side effects (assignments, increments, decrements, or function invocations) on the righthand side of &&. Whether those side effects occur depends on the value of the lefthand side.

Despite the somewhat complex way that this operator actually works, it is most commonly used as a simple Boolean algebra operator that works on

truthy and falsy values.


4.10.2 Logical OR (||)

The || operator performs the Boolean OR operation on its two operands. If one or both operands is truthy, it returns a truthy value. If both operands are falsy, it returns a falsy value.

Although the || operator is most often used simply as a Boolean OR operator, it, like the &&operator, has more complex behavior. It starts by evaluating its first operand, the expression on its left. If the value of this first operand is truthy, it short-circuits and returns that truthy value without ever evaluating the expression on the right. If, on the other hand, the value of the first operand is falsy, then || evaluates its second operand and returns the value of that expression.

As with the &&operator, you should avoid right-side operands that include side effects, unless you purposely want to use the fact that the right-side expression may not be evaluated.

An idiomatic usage of this operator is to select the first truthy value in a set of alternatives:


/ /   I f    maxWi dt h   i s   t r ut hy,	us e i n
/ /   t he   pr ef er enc es   obj ec t .	I f har dc oded   c ons t ant .

t hat .	Ot her wi s e,	l ook   f or   a   val ue

t hat   i s   not   t r ut hy,	us e   a

l et   max   =   maxWi dt h   ||   pr ef er enc es . maxWi dt h   ||   500;


Note that if 0 is a legal value for maxWi dt h, then this code will not work correctly, since 0 is a falsy value. See the ?? operator (§4.13.2) for an alternative.

Prior to ES6, this idiom is often used in functions to supply default values for parameters:

/ /   Copy   t he   pr oper t i es   of    o   t o   p,	and   r et ur n   p f unc t i on   c opy( o,	p)    {
p   =   p   ||   { } ;	/ /   I f    no   obj ec t   pas s ed   f or   p,	us e   a   newl y
c r eat ed   obj ec t .
/ /   f unc t i on   body   goes   her e }


In ES6 and later, however, this trick is no longer needed because the default parameter value could simply be written in the function definition itself: f unct i on  copy( o,	p={ } )   {   . . .	} .


4.10.3 Logical NOT (!)

The !  operator is a unary operator; it is placed before a single operand. Its purpose is to invert the boolean value of its operand. For example, if x is truthy, ! x evaluates to f al s e. If x is falsy, then ! x is t r ue.


Unlike the &&and || operators, the !  operator converts its operand to a boolean value (using the rules described in Chapter 3) before inverting the converted value. This means that !  always returns t r ue or f al s e and that you can convert any value x to its equivalent boolean value by applying this operator twice: ! ! x (see §3.9.2).


As a unary operator, !  has high precedence and binds tightly. If you want to invert the value of an expression like p  &&  q, you need to use parentheses: ! ( p  &&  q) . It is worth noting two laws of Boolean algebra here that we can express using JavaScript syntax:

/ /   DeMor gan' s   L aws
! ( p   &&  q)    ===   ( ! p   ||   ! q)      / /   =>   t r ue:    f or   al l    val ues   of    p   and   q ! ( p   ||   q)    ===   ( ! p   &&  ! q)      / /   =>   t r ue:    f or   al l    val ues   of    p   and   q




4.11 Assignment Expressions

JavaScript uses the = operator to assign a value to a variable or property. For example:

i	=   0;	/ /   Set   t he   var i abl e   i	t o   0.
o. x   =   1;	/ /   Set   t he   pr oper t y   x   of    obj ec t   o   t o   1.


The = operator expects its left-side operand to be an lvalue: a variable or object property (or array element). It expects its right-side operand to be an arbitrary value of any type. The value of an assignment expression is the value of the right-side operand. As a side effect, the = operator assigns the value on the right to the variable or property on the left so that future references to the variable or property evaluate to the value.

Although assignment expressions are usually quite simple, you may sometimes see the value of an assignment expression used as part of a larger expression. For example, you can assign and test a value in the same expression with code like this:

( a   =   b)    ===   0


If you do this, be sure you are clear on the difference between the = and === operators! Note that = has very low precedence, and parentheses are usually necessary when the value of an assignment is to be used in a larger expression.

The assignment operator has right-to-left associativity, which means that when multiple assignment operators appear in an expression, they are evaluated from right to left. Thus, you can write code like this to assign a

single value to multiple variables:


i	=   j	=   k   =   0;	/ /   I ni t i al i z e   3   var i abl es   t o   0


4.11.1 Assignment with Operation

Besides the normal = assignment operator, JavaScript supports a number of other assignment operators that provide shortcuts by combining assignment with some other operation. For example, the += operator performs addition and assignment. The following expression:

t ot al	+=   s al es Tax;


is equivalent to this one:


t ot al	=   t ot al	+   s al es Tax;


As you might expect, the += operator works for numbers or strings. For numeric operands, it performs addition and assignment; for string operands, it performs concatenation and assignment.

Similar operators include - =, *=, &=, and so on. Table 4-2 lists them all.


Table 4-2. Assignment operators

Operator	Example	Equivalent

+=	a   +=   b	a   =   a   +   b

- =	a   - =   b	a   =   a   -    b

*=	a   *=   b	a   =   a   *   b

/ =	a   / =   b	a   =   a   /   b

%=	a   %=   b	a   =   a   %  b


**=	a   **=   b	a   =   a   **   b

<<=	a   <<=   b	a   =   a   <<   b

>>=	a   >>=   b	a   =   a   >>   b

>>>=	a   >>>=   b	a   =   a   >>>   b

&=	a   &=   b	a   =   a   &  b

|=	a   |=   b	a   =   a   |   b

^=	a   ^=   b	a   =   a   ^   b



In most cases, the expression:


a   op=   b


where op is an operator, is equivalent to the expression:


a   =   a   op   b


In the first line, the expression a is evaluated once. In the second, it is evaluated twice. The two cases will differ only if a includes side effects such as a function call or an increment operator. The following two assignments, for example, are not the same:

dat a[ i ++]    *=   2;
dat a[ i ++]    =   dat a[ i ++]    *   2;



4.12 Evaluation Expressions

Like many interpreted languages, JavaScript has the ability to interpret strings of JavaScript source code, evaluating them to produce a value. JavaScript does this with the global function eval ( ) :

eval ( " 3+2" )	/ /   =>   5


Dynamic evaluation of strings of source code is a powerful language feature that is almost never necessary in practice. If you find yourself using eval ( ) , you should think carefully about whether you really need to use it. In particular, eval ( )  can be a security hole, and you should never pass any string derived from user input to eval ( ) . With a language as complicated as JavaScript, there is no way to sanitize user input to make it safe to use with eval ( ) . Because of these security issues, some web servers use the HTTP “Content-Security-Policy” header to disable eval ( )  for an entire website.


The subsections that follow explain the basic use of eval ( )  and explain two restricted versions of it that have less impact on the optimizer.



IS EVAL() A FUNCTION OR AN OPERATOR?

eval ( )  is a function, but it is included in this chapter on expressions because it really should have been an operator. The earliest versions of the language defined an eval ( )  function, and ever since then, language designers and interpreter writers have been placing restrictions on it that make it more and more operator-like. Modern JavaScript interpreters perform a lot of code analysis and optimization. Generally speaking, if a function calls eval ( ) , the interpreter cannot optimize that function. The problem with defining eval ( )  as a function is that it can be given other names:

l et   f    =   eval ; l et   g   =   f ;


If this is allowed, then the interpreter can’t know for sure which functions call eval ( ) , so it cannot optimize aggressively. This issue could have been avoided if eval ( )  was an operator (and a reserved word). We’ll learn (in §4.12.2 and §4.12.3) about restrictions placed on eval ( )  to make it more operator-like.



4.12.1 eval()

eval ( )  expects one argument. If you pass any value other than a string, it simply returns that value. If you pass a string, it attempts to parse the

string as JavaScript code, throwing a SyntaxError if it fails. If it successfully parses the string, then it evaluates the code and returns the value of the last expression or statement in the string or undef i ned if the last expression or statement had no value. If the evaluated string throws an exception, that exception propogates from the call to eval ( ) .


The key thing about eval ( )  (when invoked like this) is that it uses the variable environment of the code that calls it. That is, it looks up the values of variables and defines new variables and functions in the same way that local code does. If a function defines a local variable x and then calls eval ( " x" ) , it will obtain the value of the local variable. If it calls eval ( " x=1" ) , it changes the value of the local variable. And if the function calls eval ( " var   y   =   3; " ) , it declares a new local variable y. On the other hand, if the evaluated string uses l et  or cons t , the variable or constant declared will be local to the evaluation and will not be defined in the calling environment.

Similarly, a function can declare a local function with code like this:


eval ( " f unc t i on   f ( )    {    r et ur n   x+1;	} " ) ;


If you call eval ( )  from top-level code, it operates on global variables and global functions, of course.

Note that the string of code you pass to eval ( )  must make syntactic sense on its own: you cannot use it to paste code fragments into a function. It makes no sense to write eval ( " r et ur n; " ) , for example, because
r et ur n is only legal within functions, and the fact that the evaluated string uses the same variable environment as the calling function does not make it part of that function. If your string would make sense as a

standalone script (even a very short one like x=0 ), it is legal to pass to eval ( ) . Otherwise, eval ( )  will throw a SyntaxError.


4.12.2 Global eval()

It is the ability of eval ( )  to change local variables that is so problematic to JavaScript optimizers. As a workaround, however, interpreters simply do less optimization on any function that calls eval ( ) . But what should a JavaScript interpreter do, however, if a script defines an alias for
eval ( )  and then calls that function by another name? The JavaScript specification declares that when eval ( )  is invoked by any name other than “eval”, it should evaluate the string as if it were top-level global code. The evaluated code may define new global variables or global functions, and it may set global variables, but it will not use or modify any variables local to the calling function, and will not, therefore, interfere with local optimizations.

A “direct eval” is a call to the eval ( )  function with an expression that uses the exact, unqualified name “eval” (which is beginning to feel like a reserved word). Direct calls to eval ( )  use the variable environment of the calling context. Any other call—an indirect call—uses the global object as its variable environment and cannot read, write, or define local variables or functions. (Both direct and indirect calls can define new variables only with var . Uses of l et  and cons t  inside an evaluated string create variables and constants that are local to the evaluation and do not alter the calling or global environment.)

The following code demonstrates:


c ons t   geval	=   eval ;	/ /   Us i ng   anot her   name   does   a gl obal	eval

l et   x   =   " gl obal " ,	y   =   " gl obal " ;	/ /   Two   gl obal	var i abl es
f unc t i on   f ( )    {	/ /   Thi s   f unc t i on   does   a   l oc al eval
l et   x   =   " l oc al " ;	/ /   Def i ne   a   l oc al	var i abl e eval ( " x   +=   ' c hanged' ; " ) ;	/ /   Di r ec t   eval	s et s   l oc al
var i abl e
r et ur n   x;	/ /   Ret ur n   c hanged   l oc al var i abl e
}
f unc t i on   g( )    {	/ /   Thi s   f unc t i on   does   a   gl obal eval
l et   y   =   " l oc al " ;	/ /   A  l oc al	var i abl e
geval ( " y   +=   ' c hanged' ; " ) ;	/ /   I ndi r ec t   eval	s et s   gl obal var i abl e
r et ur n   y;	/ /   Ret ur n   unc hanged   l oc al var i abl e
}
c ons ol e. l og( f ( ) ,	x) ;	/ /   L oc al	var i abl e   c hanged:	pr i nt s " l oc al c hanged   gl obal " :
c ons ol e. l og( g( ) ,	y) ;	/ /   Gl obal	var i abl e   c hanged:	pr i nt s   " l oc al gl obal c hanged" :


Notice that the ability to do a global eval is not just an accommodation to the needs of the optimizer; it is actually a tremendously useful feature that allows you to execute strings of code as if they were independent, top-level scripts. As noted at the beginning of this section, it is rare to truly need to evaluate a string of code. But if you do find it necessary, you are more likely to want to do a global eval than a local eval.


4.12.3 Strict eval()

Strict mode (see §5.6.3) imposes further restrictions on the behavior of the eval ( )  function and even on the use of the identifier “eval”. When
eval ( )  is called from strict-mode code, or when the string of code to be evaluated itself begins with a “use strict” directive, then eval ( )  does a local eval with a private variable environment. This means that in strict mode, evaluated code can query and set local variables, but it cannot

define new variables or functions in the local scope.


Furthermore, strict mode makes eval ( )  even more operator-like by effectively making “eval” into a reserved word. You are not allowed to overwrite the eval ( )  function with a new value. And you are not allowed to declare a variable, function, function parameter, or catch block parameter with the name “eval”.


4.13 Miscellaneous Operators

JavaScript supports a number of other miscellaneous operators, described in the following sections.


4.13.1 The Conditional Operator (?:)

The conditional operator is the only ternary operator (three operands) in JavaScript and is sometimes actually called the ternary operator. This operator is sometimes written ?: , although it does not appear quite that way in code. Because this operator has three operands, the first goes before the ?, the second goes between the ? and the : , and the third goes after the : . It is used like this:

x   >   0   ?   x   :	- x	/ /   The   abs ol ut e   val ue   of    x


The operands of the conditional operator may be of any type. The first operand is evaluated and interpreted as a boolean. If the value of the first operand is truthy, then the second operand is evaluated, and its value is returned. Otherwise, if the first operand is falsy, then the third operand is evaluated and its value is returned. Only one of the second and third operands is evaluated; never both.

While you can achieve similar results using the i f  statement (§5.3.1), the ?:  operator often provides a handy shortcut. Here is a typical usage, which checks to be sure that a variable is defined (and has a meaningful, truthy value) and uses it if so or provides a default value if not:

gr eet i ng   =   " hel l o   "   +   ( us er name   ?   us er name   :	" t her e" ) ;


This is equivalent to, but more compact than, the following i f  statement:


gr eet i ng   =   " hel l o   " ; i f    ( us er name)    {
gr eet i ng   +=   us er name; }    el s e   {
gr eet i ng   +=   " t her e" ; }


4.13.2 First-Defined (??)

The first-defined operator ?? evaluates to its first defined operand: if its left operand is not nul l  and not undef i ned, it returns that value. Otherwise, it returns the value of the right operand. Like the &&and || operators, ?? is short-circuiting: it only evaluates its second operand if the first operand evaluates to nul l  or undef i ned. If the expression a has no side effects, then the expression a   ??   b is equivalent to:

( a   ! ==   nul l	&&  a   ! ==   undef i ned)    ?   a   :	b


?? is a useful alternative to || (§4.10.2) when you want to select the first defined operand rather than the first truthy operand. Although || is nominally a logical OR operator, it is also used idiomatically to select the first non-falsy operand with code like this:

/ /   I f    maxWi dt h   i s   t r ut hy,	us e   t hat .	Ot her wi s e,	l ook   f or   a   val ue i n

/ /   t he   pr ef er enc es   obj ec t .	I f    t hat   i s   not   t r ut hy,	us e   a har dc oded   c ons t ant .
l et   max   =   maxWi dt h   ||   pr ef er enc es . maxWi dt h   ||   500;


The problem with this idiomatic use is that zero, the empty string, and f al s e are all falsy values that may be perfectly valid in some
circumstances. In this code example, if maxWi dt h is zero, that value will be ignored. But if we change the || operator to ??, we end up with an expression where zero is a valid value:


/ /   I f    maxWi dt h   i s   def i ned, i n
/ /   t he   pr ef er enc es   obj ec t . har dc oded   c ons t ant .

us e   t hat .	Ot her wi s e,	l ook   f or   a   val ue

I f    t hat   i s   not   def i ned,	us e   a

l et   max   =   maxWi dt h   ??   pr ef er enc es . maxWi dt h   ??   500;


Here are more examples showing how ?? works when the first operand is falsy. If that operand is falsy but defined, then ?? returns it. It is only when the first operand is “nullish” (i.e., nul l  or undef i ned) that this operator evaluates and returns the second operand:

l et   opt i ons   =   {    t i meout :	0,	t i t l e:	" " ,	ver bos e:	f al s e,	n:	nul l } ;
opt i ons . t i meout   ??   1000	/ /   =>   0:	as   def i ned   i n   t he   obj ec t opt i ons . t i t l e   ??   " Unt i t l ed"   / /   =>   " " :    as   def i ned   i n   t he   obj ec t opt i ons . ver bos e   ??   t r ue	/ /   =>   f al s e:	as   def i ned   i n   t he
obj ec t
opt i ons . qui et   ??   f al s e	/ /   =>   f al s e:	pr oper t y   i s   not   def i ned opt i ons . n   ??   10	/ /   =>   10:	pr oper t y   i s   nul l


Note that the t i meout , t i t l e, and ver bos e expressions here would have different values if we used || instead of ??.


The ?? operator is similar to the &&and || operators but does not have higher precedence or lower precedence than they do. If you use it in an

expression with either of those operators, you must use explicit parentheses to specify which operation you want to perform first:

( a   ??   b)    ||   c         / /   ??   f i r s t ,    t hen   || a   ??   ( b   ||   c )         / /   ||   f i r s t ,    t hen   ??
a   ??   b   ||   c	/ /   Synt axEr r or :	par ent hes es   ar e   r equi r ed


The ?? operator is defined by ES2020, and as of early 2020, is newly supported by current or beta versions of all major browsers. This operator is formally called the “nullish coalescing” operator, but I avoid that term because this operator selects one of its operands but does not “coalesce” them in any way that I can see.


4.13.3 The typeof Operator

t ypeof  is a unary operator that is placed before its single operand, which can be of any type. Its value is a string that specifies the type of the operand. Table 4-3 specifies the value of the t ypeof  operator for any JavaScript value.


Table 4-3. Values returned by the typeof operator

x	t ypeof    x


undef i ned

nul l

t r ue or f al s e

any number or NaN

any BigInt

any string

any symbol

" undef i ned"

" obj ec t "

" bool ean"

" number "

" bi gi nt "

" s t r i ng"

" s ymbol "



any function

any nonfunction object



You might use the t ypeof

" f unc t i on"

" obj ec t "



operator in an expression like this:



/ /   I f    t he   val ue   i s   a   s t r i ng,	wr ap   i t   i n   quot es ,	ot her wi s e, c onver t
( t ypeof    val ue   ===   " s t r i ng" )    ?   " ' "   +   val ue   +   " ' "   :
val ue. t oSt r i ng( )


Note that t ypeof  returns “object” if the operand value is nul l . If you want to distinguish nul l  from objects, you’ll have to explicitly test for this special-case value.

Although JavaScript functions are a kind of object, the t ypeof  operator considers functions to be sufficiently different that they have their own return value.

Because t ypeof  evaluates to “object” for all object and array values other than functions, it is useful only to distinguish objects from other, primitive types. In order to distinguish one class of object from another, you must use other techniques, such as the i ns t anceof  operator (see §4.9.4), the cl as s  attribute (see §14.4.3), or the cons t r uct or property (see §9.2.2 and §14.3).


4.13.4 The delete Operator

del et e is a unary operator that attempts to delete the object property or array element specified as its operand. Like the assignment, increment, and decrement operators, del et e is typically used for its property deletion side effect and not for the value it returns. Some examples:

l et   o   =   {    x:	1,	y:	2} ;	/ /   St ar t   wi t h   an   obj ec t
del et e   o. x;	/ /   Del et e   one   of    i t s   pr oper t i es
" x"   i n   o	/ /   =>   f al s e:	t he   pr oper t y   does   not   exi s t anymor e

l et   a   =   [ 1, 2, 3] ;	/ /   St ar t   wi t h   an   ar r ay
del et e   a[ 2] ;	/ /   Del et e   t he   l as t   el ement   of    t he   ar r ay
2   i n   a	/ /   =>   f al s e:	ar r ay   el ement   2   does n' t exi s t   anymor e
a. l engt h	/ /   =>   3:	not e   t hat   ar r ay   l engt h   does n' t c hange,    t hough


Note that a deleted property or array element is not merely set to the undef i ned value. When a property is deleted, the property ceases to exist. Attempting to read a nonexistent property returns undef i ned, but you can test for the actual existence of a property with the i n operator (§4.9.3). Deleting an array element leaves a “hole” in the array and does not change the array’s length. The resulting array is sparse (§7.3).

del et e expects its operand to be an lvalue. If it is not an lvalue, the operator takes no action and returns t r ue. Otherwise, del et e attempts to delete the specified lvalue. del et e returns t r ue if it successfully deletes the specified lvalue. Not all properties can be deleted, however: non-configurable properties (§14.1) are immune from deletion.

In strict mode, del et e raises a SyntaxError if its operand is an unqualified identifier such as a variable, function, or function parameter: it only works when the operand is a property access expression (§4.4). Strict mode also specifies that del et e raises a TypeError if asked to delete any non-configurable (i.e., nondeleteable) property. Outside of strict mode, no exception occurs in these cases, and del et e simply returns f al s e to indicate that the operand could not be deleted.

Here are some example uses of the del et e operator:

l et   o   =   { x:	1,	y:	2} ;
del et e   o. x;	/ /   Del et e   one   of    t he   obj ec t   pr oper t i es ;	r et ur ns t r ue.
t ypeof    o. x;	/ /   Pr oper t y   does   not   exi s t ;	r et ur ns   " undef i ned" . del et e   o. x;	/ /   Del et e   a   nonexi s t ent   pr oper t y;	r et ur ns   t r ue. del et e   1;	/ /   Thi s   makes   no   s ens e,	but   i t   j us t   r et ur ns   t r ue.
/ /   Can' t   del et e   a   var i abl e;	r et ur ns   f al s e,	or   Synt axEr r or   i n s t r i c t   mode.
del et e   o;
/ /   Undel et abl e   pr oper t y:	r et ur ns   f al s e,	or   TypeEr r or   i n   s t r i c t mode.
del et e   Obj ec t . pr ot ot ype;


We’ll see the del et e operator again in §6.4.


4.13.5 The await Operator

awai t  was introduced in ES2017 as a way to make asynchronous programming more natural in JavaScript. You will need to read Chapter 13 to understand this operator. Briefly, however, awai t  expects a Promise object (representing an asynchronous computation) as its sole operand, and it makes your program behave as if it were waiting for the asynchronous computation to complete (but it does this without actually blocking, and it does not prevent other asynchronous operations from proceeding at the same time). The value of the awai t  operator is the fulfillment value of the Promise object. Importantly, awai t  is only legal within functions that have been declared asynchronous with the as ync keyword. Again, see Chapter 13 for full details.


4.13.6 The void Operator

voi d is a unary operator that appears before its single operand, which may be of any type. This operator is unusual and infrequently used; it evaluates its operand, then discards the value and returns undef i ned.

Since the operand value is discarded, using the voi d operator makes sense only if the operand has side effects.

The voi d operator is so obscure that it is difficult to come up with a practical example of its use. One case would be when you want to define a function that returns nothing but also uses the arrow function shortcut syntax (see §8.1.3) where the body of the function is a single expression that is evaluated and returned. If you are evaluating the expression solely for its side effects and do not want to return its value, then the simplest thing is to use curly braces around the function body. But, as an alternative, you could also use the void operator in this case:

l et   c ount er   =   0;
c ons t   i nc r ement   =   ( )    =>   voi d   c ount er ++;

i nc r ement ( ) c ount er

/ /   =>   undef i ned / /   =>   1



4.13.7 The comma Operator (,)

The comma operator is a binary operator whose operands may be of any type. It evaluates its left operand, evaluates its right operand, and then returns the value of the right operand. Thus, the following line:

i =0,	j =1,	k=2;


evaluates to 2 and is basically equivalent to:


i	=   0;	j	=   1;	k   =   2;


The lefthand expression is always evaluated, but its value is discarded, which means that it only makes sense to use the comma operator when the lefthand expression has side effects. The only situation in which the comma operator is commonly used is with a f or  loop (§5.4.3) that has

multiple loop variables:


/ /   The   f i r s t   c omma   bel ow  i s   par t   of    t he   s ynt ax   of    t he   l et s t at ement
/ /   The   s ec ond   c omma   i s   t he   c omma   oper at or :	i t   l et s   us   s queez e   2 / /   expr es s i ons   ( i ++   and   j - - )    i nt o   a   s t at ement   ( t he   f or   l oop)
t hat   expec t s   1.
f or ( l et   i =0, j =10;	i	<   j ;	i ++, j - - )    {
c ons ol e. l og( i +j ) ; }


4.14 Summary

This chapter covers a wide variety of topics, and there is lots of reference material here that you may want to reread in the future as you continue to learn JavaScript. Some key points to remember, however, are these:

Expressions are the phrases of a JavaScript program.

Any expression can be evaluated to a JavaScript value.

Expressions can also have side effects (such as variable assignment) in addition to producing a value.

Simple expressions such as literals, variable references, and property accesses can be combined with operators to produce larger expressions.

JavaScript defines operators for arithmetic, comparisons, Boolean logic, assignment, and bit manipulation, along with some miscellaneous operators, including the ternary conditional operator.

The JavaScript + operator is used to both add numbers and concatenate strings.

The logical operators &&and || have special “short-circuiting” behavior and sometimes only evaluate one of their arguments. Common JavaScript idioms require you to understand the special

behavior of these operators.



Chapter 5. Statements




Chapter 4 described expressions as JavaScript phrases. By that analogy, statements are JavaScript sentences or commands. Just as English sentences are terminated and separated from one another with periods, JavaScript statements are terminated with semicolons (§2.6). Expressions are evaluated to produce a value, but statements are executed to make something happen.


One way to “make something happen” is to evaluate an expression that has side effects. Expressions with side effects, such as assignments and function invocations, can stand alone as statements, and when used this way are known as expression statements. A similar category of statements are the declaration statements that declare new variables and define new functions.


JavaScript programs are nothing more than a sequence of statements to execute. By default, the JavaScript interpreter executes these statements one after another in the order they are written. Another way to “make something happen” is to alter this default order of execution, and JavaScript has a number of statements or control structures that do just this:


Conditionals

Statements like i f  and s wi t ch that make the JavaScript interpreter execute or skip other statements depending on the value of an expression


Loops

Statements like whi l e and f or  that execute other statements repetitively

Jumps

Statements like br eak, r et ur n, and t hr owthat cause the interpreter to jump to another part of the program


The sections that follow describe the various statements in JavaScript and explain their syntax. Table 5-1, at the end of the chapter, summarizes the syntax. A JavaScript program is simply a sequence of statements, separated from one another with semicolons, so once you are familiar with the statements of JavaScript, you can begin writing JavaScript programs.


5.1 Expression Statements

The simplest kinds of statements in JavaScript are expressions that have side effects. This sort of statement was shown in Chapter 4. Assignment statements are one major category of expression statements. For example:

gr eet i ng   =   " Hel l o   "   +   name; i	*=   3;


The increment and decrement operators, ++ and - - , are related to assignment statements. These have the side effect of changing a variable value, just as if an assignment had been performed:

c ount er ++;


The del et e operator has the important side effect of deleting an object property. Thus, it is almost always used as a statement, rather than as part

of a larger expression:


del et e   o. x;


Function calls are another major category of expression statements. For example:

c ons ol e. l og( debugMes s age) ;
di s pl aySpi nner ( ) ;	/ /   A  hypot het i c al	f unc t i on   t o   di s pl ay   a s pi nner   i n   a   web   app.


These function calls are expressions, but they have side effects that affect the host environment or program state, and they are used here as statements. If a function does not have any side effects, there is no sense in calling it, unless it is part of a larger expression or an assignment statement. For example, you wouldn’t just compute a cosine and discard the result:

Mat h. c os ( x) ;


But you might well compute the value and assign it to a variable for future use:

c x   =   Mat h. c os ( x) ;


Note that each line of code in each of these examples is terminated with a semicolon.


5.2 Compound and Empty Statements

Just as the comma operator (§4.13.7) combines multiple expressions into a single expression, a statement block combines multiple statements into a single compound statement. A statement block is simply a sequence of

statements enclosed within curly braces. Thus, the following lines act as a single statement and can be used anywhere that JavaScript expects a single statement:

{
x   =   Mat h. PI ;
c x   =   Mat h. c os ( x) ;
c ons ol e. l og( " c os ( π)    =   "   +   c x) ; }


There are a few things to note about this statement block. First, it does not end with a semicolon. The primitive statements within the block end in semicolons, but the block itself does not. Second, the lines inside the block are indented relative to the curly braces that enclose them. This is optional, but it makes the code easier to read and understand.


Just as expressions often contain subexpressions, many JavaScript statements contain substatements. Formally, JavaScript syntax usually allows a single substatement. For example, the whi l e loop syntax includes a single statement that serves as the body of the loop. Using a statement block, you can place any number of statements within this single allowed substatement.

A compound statement allows you to use multiple statements where JavaScript syntax expects a single statement. The empty statement is the opposite: it allows you to include no statements where one is expected. The empty statement looks like this:

;


The JavaScript interpreter takes no action when it executes an empty statement. The empty statement is occasionally useful when you want to

create a loop that has an empty body. Consider the following f or  loop (f or  loops will be covered in §5.4.3):

/ /   I ni t i al i z e   an   ar r ay   a
f or ( l et   i	=   0;	i	<   a. l engt h;	a[ i ++]    =   0)    ;


In this loop, all the work is done by the expression a[ i ++]   =   0, and no loop body is necessary. JavaScript syntax requires a statement as a loop body, however, so an empty statement—just a bare semicolon—is used.

Note that the accidental inclusion of a semicolon after the right parenthesis of a f or  loop, whi l e loop, or i f  statement can cause frustrating bugs that are difficult to detect. For example, the following code probably does not do what the author intended:

i f    ( ( a   ===   0)    ||   ( b   ===   0) ) ;	/ /   Oops !   Thi s   l i ne   does   not hi ng. . . o   =   nul l ;	/ /   and   t hi s   l i ne   i s   al ways
exec ut ed.


When you intentionally use the empty statement, it is a good idea to comment your code in a way that makes it clear that you are doing it on purpose. For example:

f or ( l et   i	=   0;	i	<   a. l engt h;	a[ i ++]    =   0)    / *   empt y   */   ;



5.3 Conditionals

Conditional statements execute or skip other statements depending on the value of a specified expression. These statements are the decision points of your code, and they are also sometimes known as “branches.” If you imagine a JavaScript interpreter following a path through your code, the conditional statements are the places where the code branches into two or

more paths and the interpreter must choose which path to follow.


The following subsections explain JavaScript’s basic conditional, the i f / el s e statement, and also cover s wi t ch, a more complicated, multiway branch statement.


5.3.1 if

The i f  statement is the fundamental control statement that allows JavaScript to make decisions, or, more precisely, to execute statements conditionally. This statement has two forms. The first is:

i f    ( expr es s i on) s t at ement


In this form, expression is evaluated. If the resulting value is truthy, statement is executed. If expression is falsy, statement is not executed. (See §3.4 for a definition of truthy and falsy values.) For example:

i f    ( us er name   ==   nul l )	/ /   I f    us er name   i s   nul l	or   undef i ned, us er name   =   " J ohn   Doe" ;	/ /   def i ne   i t


Or similarly:


/ /   I f    us er name   i s   nul l ,	undef i ned,	f al s e,	0,	" " ,	or   NaN,	gi ve   i t a   new  val ue
i f    ( ! us er name)    us er name   =   " J ohn   Doe" ;


Note that the parentheses around the expression are a required part of the syntax for the i f  statement.


JavaScript syntax requires a single statement after the i f  keyword and parenthesized expression, but you can use a statement block to combine multiple statements into one. So the i f  statement might also look like

this:


i f    ( ! addr es s )    {

addr es s mes s age
}

=   " " ;
=   " Pl eas e   s pec i f y   a   mai l i ng   addr es s . " ;



The second form of the i f  statement introduces an el s e clause that is executed when expression is f al s e. Its syntax is:

i f    ( expr es s i on) s t at ement 1
el s e
s t at ement 2


This form of the statement executes s t at ement 1 if expression is truthy and executes s t at ement 2 if expression is falsy. For example:

i f    ( n   ===   1)
c ons ol e. l og( " You   have   1   new  mes s age. " ) ; el s e
c ons ol e. l og( ` You   have   ${ n}    new  mes s ages . ` ) ;


When you have nested i f  statements with el s e clauses, some caution is required to ensure that the el s e clause goes with the appropriate i f statement. Consider the following lines:

i	=   j	=   1; k   =   2;
i f    ( i	===   j )
i f    ( j	===   k)
c ons ol e. l og( " i	equal s   k" ) ; el s e
c ons ol e. l og( " i	does n' t   equal	j " ) ;	/ /   WRONG! !


In this example, the inner i f  statement forms the single statement allowed

by the syntax of the outer i f  statement. Unfortunately, it is not clear (except from the hint given by the indentation) which i f  the el s e goes with. And in this example, the indentation is wrong, because a JavaScript interpreter actually interprets the previous example as:

i f    ( i	===   j )    {
i f    ( j	===   k)
c ons ol e. l og( " i	equal s   k" ) ; el s e
c ons ol e. l og( " i	does n' t   equal	j " ) ;	/ /   OOPS! }


The rule in JavaScript (as in most programming languages) is that by default an el s e clause is part of the nearest i f  statement. To make this example less ambiguous and easier to read, understand, maintain, and debug, you should use curly braces:

i f    ( i	===   j )    {
i f    ( j	===   k)    {
c ons ol e. l og( " i	equal s   k" ) ; }
}    el s e   {	/ /   What   a   di f f er enc e   t he   l oc at i on   of    a   c ur l y   br ac e makes !
c ons ol e. l og( " i	does n' t   equal	j " ) ; }


Many programmers make a habit of enclosing the bodies of i f  and el s e statements (as well as other compound statements, such as whi l e loops) within curly braces, even when the body consists of only a single statement. Doing so consistently can prevent the sort of problem just shown, and I advise you to adopt this practice. In this printed book, I place a premium on keeping example code vertically compact, and I do not always follow my own advice on this matter.

5.3.2 else if

The i f / el s e statement evaluates an expression and executes one of two pieces of code, depending on the outcome. But what about when you need to execute one of many pieces of code? One way to do this is with an
el s e   i f  statement. el s e   i f  is not really a JavaScript statement, but simply a frequently used programming idiom that results when repeated i f / el s e statements are used:

i f    ( n   ===   1)    {
/ /   Exec ut e   c ode   bl oc k   #1 }    el s e   i f    ( n   ===   2)    {
/ /   Exec ut e   c ode   bl oc k   #2 }    el s e   i f    ( n   ===   3)    {
/ /   Exec ut e   c ode   bl oc k   #3 }    el s e   {
/ /   I f    al l	el s e   f ai l s ,	exec ut e   bl oc k   #4 }


There is nothing special about this code. It is just a series of i f statements, where each following i f  is part of the el s e clause of the previous statement. Using the el s e   i f  idiom is preferable to, and more legible than, writing these statements out in their syntactically equivalent, fully nested form:

i f    ( n   ===   1)    {
/ /   Exec ut e   c ode   bl oc k   #1 }
el s e   {
i f    ( n   ===   2)    {
/ /   Exec ut e   c ode   bl oc k   #2 }
el s e   {
i f    ( n   ===   3)    {
/ /   Exec ut e   c ode   bl oc k   #3 }
el s e   {

/ /   I f    al l	el s e   f ai l s ,	exec ut e   bl oc k   #4 }
} }


5.3.3 switch

An i f  statement causes a branch in the flow of a program’s execution, and you can use the el s e   i f  idiom to perform a multiway branch. This is not the best solution, however, when all of the branches depend on the value of the same expression. In this case, it is wasteful to repeatedly evaluate that expression in multiple i f  statements.


The s wi t ch statement handles exactly this situation. The s wi t ch keyword is followed by an expression in parentheses and a block of code in curly braces:

s wi t c h( expr es s i on)    { s t at ement s
}


However, the full syntax of a s wi t ch statement is more complex than this. Various locations in the block of code are labeled with the cas e keyword followed by an expression and a colon. When a s wi t ch executes, it computes the value of expression and then looks for a cas e label whose expression evaluates to the same value (where sameness is determined by the === operator). If it finds one, it starts executing the block of code at the statement labeled by the cas e. If it does not find a cas e with a matching value, it looks for a statement labeled def aul t : . If there is no def aul t :  label, the s wi t ch statement skips the block of code altogether.

s wi t ch is a confusing statement to explain; its operation becomes much

clearer with an example. The following s wi t ch statement is equivalent to the repeated i f / el s e statements shown in the previous section:

s wi t c h( n)    {
c as e   1:	/ /   St ar t   her e   i f    n   ===   1 / /   Exec ut e   c ode   bl oc k   #1.
br eak;	/ /   St op   her e
c as e   2:	/ /   St ar t   her e   i f    n   ===   2 / /   Exec ut e   c ode   bl oc k   #2.
br eak;	/ /   St op   her e
c as e   3:	/ /   St ar t   her e   i f    n   ===   3 / /   Exec ut e   c ode   bl oc k   #3.
br eak;	/ /   St op   her e
def aul t :	/ /   I f    al l	el s e   f ai l s . . . / /   Exec ut e   c ode   bl oc k   #4.
br eak;	/ /   St op   her e
}


Note the br eak keyword used at the end of each cas e in this code. The br eak statement, described later in this chapter, causes the interpreter to jump to the end (or “break out”) of the s wi t ch statement and continue with the statement that follows it. The cas e clauses in a s wi t ch statement specify only the starting point of the desired code; they do not specify any ending point. In the absence of br eak statements, a s wi t ch statement begins executing its block of code at the cas e label that matches the value of its expression and continues executing statements until it reaches the end of the block. On rare occasions, it is useful to write code like this that “falls through” from one cas e label to the next, but 99% of the time you should be careful to end every cas e with a br eak statement. (When using s wi t ch inside a function, however, you may use a r et ur n statement instead of a br eak statement. Both serve to terminate the s wi t ch statement and prevent execution from falling through to the next cas e.)

Here is a more realistic example of the s wi t ch statement; it converts a value to a string in a way that depends on the type of the value:

f unc t i on   c onver t ( x)    { s wi t c h( t ypeof    x)    {
c as e   " number " :	/ /   Conver t   t he   number   t o   a hexadec i mal	i nt eger
r et ur n   x. t oSt r i ng( 16) ;
c as e   " s t r i ng" :	/ /   Ret ur n   t he   s t r i ng   enc l os ed   i n quot es

r et ur n   ' " ' def aul t :
us ual	way

+   x   +   ' " ' ;
/ /   Conver t   any   ot her   t ype   i n   t he

r et ur n   St r i ng( x) ; }
}


Note that in the two previous examples, the cas e keywords are followed by number and string literals, respectively. This is how the s wi t ch statement is most often used in practice, but note that the ECMAScript standard allows each cas e to be followed by an arbitrary expression.


The s wi t ch statement first evaluates the expression that follows the
s wi t ch keyword and then evaluates the cas e expressions, in the order in which they appear, until it finds a value that matches.1 The matching case is determined using the === identity operator, not the == equality operator, so the expressions must match without any type conversion.

Because not all of the cas e expressions are evaluated each time the
s wi t ch statement is executed, you should avoid using cas e expressions that contain side effects such as function calls or assignments. The safest course is simply to limit your cas e expressions to constant expressions.


As explained earlier, if none of the cas e expressions match the s wi t ch

expression, the s wi t ch statement begins executing its body at the statement labeled def aul t : . If there is no def aul t :  label, the
s wi t ch statement skips its body altogether. Note that in the examples shown, the def aul t :  label appears at the end of the s wi t ch body, following all the cas e labels. This is a logical and common place for it, but it can actually appear anywhere within the body of the statement.


5.4 Loops

To understand conditional statements, we imagined the JavaScript interpreter following a branching path through your source code. The looping statements are those that bend that path back upon itself to repeat portions of your code. JavaScript has five looping statements: whi l e, do/ whi l e, f or , f or / of  (and its f or / awai t  variant), and f or / i n. The following subsections explain each in turn. One common use for loops is to iterate over the elements of an array. §7.6 discusses this kind of loop in detail and covers special looping methods defined by the Array class.


5.4.1 while

Just as the i f  statement is JavaScript’s basic conditional, the whi l e statement is JavaScript’s basic loop. It has the following syntax:

whi l e   ( expr es s i on) s t at ement


To execute a whi l e statement, the interpreter first evaluates expression. If the value of the expression is falsy, then the interpreter skips over the statement that serves as the loop body and moves on to the next statement in the program. If, on the other hand, the expression is truthy, the

interpreter executes the statement and repeats, jumping back to the top of the loop and evaluating expression again. Another way to say this is that the interpreter executes statement repeatedly while the expression is truthy. Note that you can create an infinite loop with the syntax whi l e( t r ue) .


Usually, you do not want JavaScript to perform exactly the same operation over and over again. In almost every loop, one or more variables change with each iteration of the loop. Since the variables change, the actions performed by executing statement may differ each time through the loop. Furthermore, if the changing variable or variables are involved in expression, the value of the expression may be different each time through the loop. This is important; otherwise, an expression that starts off truthy would never change, and the loop would never end! Here is an example of a whi l e loop that prints the numbers from 0 to 9:


l et   c ount   =   0;
whi l e( c ount   <   10)    {
c ons ol e. l og( c ount ) ; c ount ++;
}


As you can see, the variable count  starts off at 0 and is incremented each time the body of the loop runs. Once the loop has executed 10 times, the expression becomes f al s e (i.e., the variable count  is no longer less than 10), the whi l e statement finishes, and the interpreter can move on to the next statement in the program. Many loops have a counter variable like count . The variable names i , j , and k are commonly used as loop counters, though you should use more descriptive names if it makes your code easier to understand.


5.4.2 do/while

The do/ whi l e loop is like a whi l e loop, except that the loop expression is tested at the bottom of the loop rather than at the top. This means that the body of the loop is always executed at least once. The syntax is:

do
s t at ement
whi l e   ( expr es s i on) ;


The do/ whi l e loop is less commonly used than its whi l e cousin—in practice, it is somewhat uncommon to be certain that you want a loop to execute at least once. Here’s an example of a do/ whi l e loop:

f unc t i on   pr i nt Ar r ay( a)    {
l et   l en   =   a. l engt h,	i	=   0; i f    ( l en   ===   0)    {
c ons ol e. l og( " Empt y   Ar r ay" ) ; }    el s e   {
do   {
c ons ol e. l og( a[ i ] ) ; }    whi l e( ++i	<   l en) ;
} }


There are a couple of syntactic differences between the do/ whi l e loop and the ordinary whi l e loop. First, the do loop requires both the do keyword (to mark the beginning of the loop) and the whi l e keyword (to mark the end and introduce the loop condition). Also, the do loop must always be terminated with a semicolon. The whi l e loop doesn’t need a semicolon if the loop body is enclosed in curly braces.


5.4.3 for

The f or  statement provides a looping construct that is often more

convenient than the whi l e statement. The f or  statement simplifies loops that follow a common pattern. Most loops have a counter variable of some kind. This variable is initialized before the loop starts and is tested before each iteration of the loop. Finally, the counter variable is incremented or otherwise updated at the end of the loop body, just before the variable is tested again. In this kind of loop, the initialization, the test, and the update are the three crucial manipulations of a loop variable. The f or  statement encodes each of these three manipulations as an expression and makes those expressions an explicit part of the loop syntax:

f or ( i ni t i al i z e   ;	t es t   ;	i nc r ement ) s t at ement


initialize, test, and increment are three expressions (separated by semicolons) that are responsible for initializing, testing, and incrementing the loop variable. Putting them all in the first line of the loop makes it easy to understand what a f or  loop is doing and prevents mistakes such as forgetting to initialize or increment the loop variable.

The simplest way to explain how a f or  loop works is to show the equivalent whi l e loop:2

i ni t i al i z e; whi l e( t es t )    {
s t at ement
i nc r ement ; }


In other words, the initialize expression is evaluated once, before the loop begins. To be useful, this expression must have side effects (usually an assignment). JavaScript also allows initialize to be a variable declaration statement so that you can declare and initialize a loop counter at the same time. The test expression is evaluated before each iteration and controls

whether the body of the loop is executed. If test evaluates to a truthy value, the statement that is the body of the loop is executed. Finally, the increment expression is evaluated. Again, this must be an expression with side effects in order to be useful. Generally, it is either an assignment expression, or it uses the ++ or - -  operators.


We can print the numbers from 0 to 9 with a f or  loop like the following. Contrast it with the equivalent whi l e loop shown in the previous section:

f or ( l et   c ount   =   0;	c ount   <   10;	c ount ++)    { c ons ol e. l og( c ount ) ;
}


Loops can become a lot more complex than this simple example, of course, and sometimes multiple variables change with each iteration of the loop. This situation is the only place that the comma operator is commonly used in JavaScript; it provides a way to combine multiple initialization and increment expressions into a single expression suitable for use in a f or loop:

l et   i ,	j ,	s um =   0;
f or ( i	=   0,	j	=   10   ;	i	<   10   ;	i ++,	j - - )    { s um +=   i	*   j ;
}


In all our loop examples so far, the loop variable has been numeric. This is quite common but is not necessary. The following code uses a f or  loop to traverse a linked list data structure and return the last object in the list (i.e., the first object that does not have a next  property):


f unc t i on   t ai l ( o)    {	/ /   Ret ur n   t he   t ai l of    l i nked   l i s t   o
f or ( ;	o. next ;	o   =   o. next )    / *   empt y   */   ;	/ /   Tr aver s e   whi l e o. next   i s   t r ut hy

r et ur n   o; }


Note that this code has no initialize expression. Any of the three expressions may be omitted from a f or  loop, but the two semicolons are required. If you omit the test expression, the loop repeats forever, and
f or ( ; ; )  is another way of writing an infinite loop, like whi l e( t r ue) .


5.4.4 for/of

ES6 defines a new loop statement: f or / of . This new kind of loop uses the f or  keyword but is a completely different kind of loop than the regular f or  loop. (It is also completely different than the older f or / i n loop that we’ll describe in §5.4.5.)

The f or / of  loop works with iterable objects. We’ll explain exactly what it means for an object to be iterable in Chapter 12, but for this chapter, it is enough to know that arrays, strings, sets, and maps are iterable: they represent a sequence or set of elements that you can loop or iterate through using a f or / of  loop.


Here, for example, is how we can use f or / of  to loop through the elements of an array of numbers and compute their sum:

l et   dat a   =   [ 1,	2,	3,	4,	5,	6,	7,	8,	9] ,	s um =   0; f or ( l et   el ement   of    dat a)    {
s um +=   el ement ; }
s um	/ /   =>   45


Superficially, the syntax looks like a regular f or  loop: the f or  keyword is followed by parentheses that contain details about what the loop should do. In this case, the parentheses contain a variable declaration (or, for

variables that have already been declared, simply the name of the variable) followed by the of  keyword and an expression that evaluates to an iterable object, like the dat a array in this case. As with all loops, the body of a f or / of  loop follows the parentheses, typically within curly braces.

In the code just shown, the loop body runs once for each element of the dat a array. Before each execution of the loop body, the next element of the array is assigned to the element variable. Array elements are iterated in order from first to last.

Arrays are iterated “live”—changes made during the iteration may affect the outcome of the iteration. If we modify the preceding code by adding the line dat a. pus h( s um) ;  inside the loop body, then we create an infinite loop because the iteration can never reach the last element of the array.

FOR/OF WITH OBJ ECTS

Objects are not (by default) iterable. Attempting to use f or / of  on a regular object throws a TypeError at runtime:

l et   o   =   {    x:	1,	y:	2,	z :	3   } ;
f or ( l et   el ement   of    o)    {    / /   Thr ows   TypeEr r or   bec aus e   o   i s   not i t er abl e
c ons ol e. l og( el ement ) ; }


If you want to iterate through the properties of an object, you can use the f or / i n loop (introduced in §5.4.5), or use f or / of  with the
Obj ect . keys ( )  method:


l et   o   =   {    x:	1,	y:	2,	z :	3   } ;

l et   keys   =   " " ;
f or ( l et   k   of    Obj ec t . keys ( o) )    { keys   +=   k;
}
keys	/ /   =>   " xyz "


This works because Obj ect . keys ( )  returns an array of property names for an object, and arrays are iterable with f or / of . Note also that this iteration of the keys of an object is not live as the array example above was—changes to the object o made in the loop body will have no effect on the iteration. If you don’t care about the keys of an object, you can also iterate through their corresponding values like this:

l et   s um =   0;
f or ( l et   v   of    Obj ec t . val ues ( o) )    { s um +=   v;
}
s um / /   =>   6


And if you are interested in both the keys and the values of an object’s properties, you can use f or / of  with Obj ect . ent r i es ( )  and destructuring assignment:

l et   pai r s   =   " " ;
f or ( l et   [ k,	v]    of    Obj ec t . ent r i es ( o) )    { pai r s   +=   k   +   v;
}
pai r s	/ /   =>   " x1y2z 3"


Obj ect . ent r i es ( )  returns an array of arrays, where each inner array represents a key/value pair for one property of the object. We use destructuring assignment in this code example to unpack those inner arrays into two individual variables.

FOR/OF WITH STRINGS

Strings are iterable character-by-character in ES6:


l et   f r equenc y   =   { } ;
f or ( l et   l et t er   of    " mi s s i s s i ppi " )    { i f    ( f r equenc y[ l et t er ] )    {
f r equenc y[ l et t er ] ++; }    el s e   {
f r equenc y[ l et t er ]    =   1; }
}
f r equenc y	/ /   =>   { m:	1,	i :	4,	s :	4,	p:	2}


Note that strings are iterated by Unicode codepoint, not by UTF-16 character. The string “I ❤	” has a . l engt h of 5 (because the two emoji characters each require two UTF-16 characters to represent). But if you iterate that string with f or / of , the loop body will run three times, once for each of the three code points “I”, “❤”, and “	.”

FOR/OF WITH SET AND MAP

The built-in ES6 Set and Map classes are iterable. When you iterate a Set with f or / of , the loop body runs once for each element of the set. You could use code like this to print the unique words in a string of text:

l et   t ext   =   " Na   na   na   na   na   na   na   na   Bat man! " ; l et   wor dSet   =   new  Set ( t ext . s pl i t ( "   " ) ) ;
l et   uni que   =   [ ] ;
f or ( l et   wor d   of    wor dSet )    { uni que. pus h( wor d) ;
}
uni que   / /   =>   [ " Na" ,	" na" ,	" Bat man! " ]


Maps are an interesting case because the iterator for a Map object does not iterate the Map keys, or the Map values, but key/value pairs. Each time through the iteration, the iterator returns an array whose first element is a

key and whose second element is the corresponding value. Given a Map m, you could iterate and destructure its key/value pairs like this:

l et   m =   new  Map( [ [ 1,	" one" ] ] ) ; f or ( l et   [ key,	val ue]    of    m)    {

key           / / val ue     / /
}

=>   1
=>   " one"



ASYNCHRONOUS ITERATION WITH FOR/AWAIT

ES2018 introduces a new kind of iterator, known as an asynchronous iterator, and a variant on the f or / of  loop, known as the f or / awai t loop that works with asynchronous iterators.

You’ll need to read Chapters 12 and 13 in order to understand the f or / awai t  loop, but here is how it looks in code:

/ /   Read   c hunks   f r om an   as ync hr onous l y   i t er abl e   s t r eam and   pr i nt t hem out
as ync   f unc t i on   pr i nt St r eam( s t r eam)    {
f or   awai t   ( l et   c hunk   of    s t r eam)    { c ons ol e. l og( c hunk) ;
} }


5.4.5 for/in

A f or / i n loop looks a lot like a f or / of  loop, with the of  keyword changed to i n. While a f or / of  loop requires an iterable object after the of , a f or / i n loop works with any object after the i n. The f or / of loop is new in ES6, but f or / i n has been part of JavaScript since the very beginning (which is why it has the more natural sounding syntax).

The f or / i n statement loops through the property names of a specified

object. The syntax looks like this:


f or   ( var i abl e   i n   obj ec t ) s t at ement


variable typically names a variable, but it may be a variable declaration or anything suitable as the left-hand side of an assignment expression. object is an expression that evaluates to an object. As usual, statement is the statement or statement block that serves as the body of the loop.


And you might use a f or / i n loop like this:


f or ( l et   p   i n   o)    {	/ /   As s i gn   pr oper t y   names   of    o   t o   var i abl e p
c ons ol e. l og( o[ p] ) ;	/ /   Pr i nt   t he   val ue   of    eac h   pr oper t y }


To execute a f or / i n statement, the JavaScript interpreter first evaluates the object expression. If it evaluates to nul l  or undef i ned, the interpreter skips the loop and moves on to the next statement. The interpreter now executes the body of the loop once for each enumerable property of the object. Before each iteration, however, the interpreter evaluates the variable expression and assigns the name of the property (a string value) to it.

Note that the variable in the f or / i n loop may be an arbitrary expression, as long as it evaluates to something suitable for the left side of an assignment. This expression is evaluated each time through the loop, which means that it may evaluate differently each time. For example, you can use code like the following to copy the names of all object properties into an array:

l et   o   =   {    x:	1,	y:	2,	z :	3   } ;

l et   a   =   [ ] ,	i	=   0;
f or ( a[ i ++]    i n   o)    / *   empt y   */ ;


JavaScript arrays are simply a specialized kind of object, and array indexes are object properties that can be enumerated with a f or / i n loop. For example, following the previous code with this line enumerates the array indexes 0, 1, and 2:

f or ( l et   i	i n   a)    c ons ol e. l og( i ) ;


I find that a common source of bugs in my own code is the accidental use of f or / i n with arrays when I meant to use f or / of . When working with arrays, you almost always want to use f or / of  instead of f or / i n.


The f or / i n loop does not actually enumerate all properties of an object. It does not enumerate properties whose names are symbols. And of the properties whose names are strings, it only loops over the enumerable properties (see §14.1). The various built-in methods defined by core JavaScript are not enumerable. All objects have a t oSt r i ng( )  method, for example, but the f or / i n loop does not enumerate this t oSt r i ng property. In addition to built-in methods, many other properties of the built-in objects are non-enumerable. All properties and methods defined by your code are enumerable, by default. (You can make them non-enumerable using techniques explained in §14.1.)

Enumerable inherited properties (see §6.3.2) are also enumerated by the f or / i n loop. This means that if you use f or / i n loops and also use
code that defines properties that are inherited by all objects, then your loop may not behave in the way you expect. For this reason, many programmers prefer to use a f or / of  loop with Obj ect . keys ( ) instead of a f or / i n loop.

If the body of a f or / i n loop deletes a property that has not yet been enumerated, that property will not be enumerated. If the body of the loop defines new properties on the object, those properties may or may not be enumerated. See §6.6.1 for more information on the order in which
f or / i n enumerates the properties of an object.



5.5 J umps

Another category of JavaScript statements are jump statements. As the name implies, these cause the JavaScript interpreter to jump to a new location in the source code. The br eak statement makes the interpreter jump to the end of a loop or other statement. cont i nue makes the interpreter skip the rest of the body of a loop and jump back to the top of a loop to begin a new iteration. JavaScript allows statements to be named, or labeled, and br eak and cont i nue can identify the target loop or other statement label.

The r et ur n statement makes the interpreter jump from a function invocation back to the code that invoked it and also supplies the value for the invocation. The t hr owstatement is a kind of interim return from a generator function. The t hr owstatement raises, or throws, an exception and is designed to work with the t r y/ cat ch/ f i nal l y statement, which establishes a block of exception-handling code. This is a complicated kind of jump statement: when an exception is thrown, the interpreter jumps to the nearest enclosing exception handler, which may be in the same function or up the call stack in an invoking function.

Details about each of these jump statements are in the sections that follow.


5.5.1 Labeled Statements

Any statement may be labeled by preceding it with an identifier and a colon:

i dent i f i er :	s t at ement


By labeling a statement, you give it a name that you can use to refer to it elsewhere in your program. You can label any statement, although it is only useful to label statements that have bodies, such as loops and conditionals. By giving a loop a name, you can use br eak and
cont i nue statements inside the body of the loop to exit the loop or to jump directly to the top of the loop to begin the next iteration. br eak and cont i nue are the only JavaScript statements that use statement labels; they are covered in the following subsections. Here is an example of a labeled whi l e loop and a cont i nue statement that uses the label.

mai nl oop:	whi l e( t oken   ! ==   nul l )    { / /   Code   omi t t ed. . .
c ont i nue   mai nl oop;	/ /   J ump   t o   t he   next   i t er at i on   of    t he named   l oop
/ /   Mor e   c ode   omi t t ed. . . }


The identifier you use to label a statement can be any legal JavaScript identifier that is not a reserved word. The namespace for labels is different than the namespace for variables and functions, so you can use the same identifier as a statement label and as a variable or function name. Statement labels are defined only within the statement to which they apply (and within its substatements, of course). A statement may not have the same label as a statement that contains it, but two statements may have the same label as long as neither one is nested within the other. Labeled statements may themselves be labeled. Effectively, this means that any statement may have multiple labels.

5.5.2 break

The br eak statement, used alone, causes the innermost enclosing loop or s wi t ch statement to exit immediately. Its syntax is simple:

br eak;


Because it causes a loop or s wi t ch to exit, this form of the br eak statement is legal only if it appears inside one of these statements.

You’ve already seen examples of the br eak statement within a s wi t ch statement. In loops, it is typically used to exit prematurely when, for whatever reason, there is no longer any need to complete the loop. When a loop has complex termination conditions, it is often easier to implement some of these conditions with br eak statements rather than trying to express them all in a single loop expression. The following code searches the elements of an array for a particular value. The loop terminates in the normal way when it reaches the end of the array; it terminates with a
br eak statement if it finds what it is looking for in the array:


f or ( l et   i    =   0;    i    <   a. l engt h;    i ++)    { i f    ( a[ i ]    ===   t ar get )    br eak;
}


JavaScript also allows the br eak keyword to be followed by a statement label (just the identifier, with no colon):

br eak   l abel name;


When br eak is used with a label, it jumps to the end of, or terminates, the enclosing statement that has the specified label. It is a syntax error to use br eak in this form if there is no enclosing statement with the

specified label. With this form of the br eak statement, the named statement need not be a loop or s wi t ch: br eak can “break out of” any enclosing statement. This statement can even be a statement block grouped within curly braces for the sole purpose of naming the block with a label.

A newline is not allowed between the br eak keyword and the labelname. This is a result of JavaScript’s automatic insertion of omitted semicolons: if you put a line terminator between the br eak keyword and the label that follows, JavaScript assumes you meant to use the simple, unlabeled form of the statement and treats the line terminator as a semicolon. (See §2.6.)

You need the labeled form of the br eak statement when you want to break out of a statement that is not the nearest enclosing loop or a
s wi t ch. The following code demonstrates:


l et   mat r i x   =   get Dat a( ) ;	/ /   Get   a   2D  ar r ay   of    number s   f r om s omewher e
/ /   Now  s um al l	t he   number s   i n   t he   mat r i x. l et   s um =   0,	s uc c es s   =   f al s e;
/ /   St ar t   wi t h   a   l abel ed   s t at ement   t hat   we   c an   br eak   out   of    i f er r or s   oc c ur
c omput eSum:	i f    ( mat r i x)    {
f or ( l et   x   =   0;	x   <   mat r i x. l engt h;	x++)    { l et   r ow  =   mat r i x[ x] ;
i f    ( ! r ow)    br eak   c omput eSum;
f or ( l et   y   =   0;	y   <   r ow. l engt h;	y++)    { l et   c el l	=   r ow[ y] ;
i f    ( i s NaN( c el l ) )    br eak   c omput eSum; s um +=   c el l ;
} }
s uc c es s   =   t r ue; }
/ /   The   br eak   s t at ement s   j ump   her e.	I f    we   ar r i ve   her e   wi t h s uc c es s   ==   f al s e


/ /   t hen   t her e / /   Ot her wi s e,

was   s omet hi ng   wr ong   wi t h   t he   mat r i x   we   wer e   gi ven. s um c ont ai ns   t he   s um of    al l	c el l s   of    t he   mat r i x.



Finally, note that a br eak statement, with or without a label, can not transfer control across function boundaries. You cannot label a function definition statement, for example, and then use that label inside the function.


5.5.3 continue

The cont i nue statement is similar to the br eak statement. Instead of exiting a loop, however, cont i nue restarts a loop at the next iteration. The cont i nue statement’s syntax is just as simple as the br eak statement’s:

c ont i nue;


The cont i nue statement can also be used with a label:


c ont i nue   l abel name;


The cont i nue statement, in both its labeled and unlabeled forms, can be used only within the body of a loop. Using it anywhere else causes a syntax error.

When the cont i nue statement is executed, the current iteration of the enclosing loop is terminated, and the next iteration begins. This means different things for different types of loops:

In a whi l e loop, the specified expression at the beginning of the loop is tested again, and if it’s t r ue, the loop body is executed starting from the top.

In a do/ whi l e loop, execution skips to the bottom of the loop,

where the loop condition is tested again before restarting the loop at the top.

In a f or  loop, the increment expression is evaluated, and the test expression is tested again to determine if another iteration should be done.

In a f or / of  or f or / i n loop, the loop starts over with the next iterated value or next property name being assigned to the specified variable.

Note the difference in behavior of the cont i nue statement in the whi l e and f or  loops: a whi l e loop returns directly to its condition, but a f or loop first evaluates its increment expression and then returns to its condition. Earlier, we considered the behavior of the f or  loop in terms of an “equivalent” whi l e loop. Because the cont i nue statement behaves differently for these two loops, however, it is not actually possible to perfectly simulate a f or  loop with a whi l e loop alone.


The following example shows an unlabeled cont i nue statement being used to skip the rest of the current iteration of a loop when an error occurs:

f or ( l et   i	=   0;	i	<   dat a. l engt h;	i ++)    {
i f    ( ! dat a[ i ] )    c ont i nue;	/ /   Can' t   pr oc eed   wi t h   undef i ned dat a
t ot al	+=   dat a[ i ] ; }


Like the br eak statement, the cont i nue statement can be used in its labeled form within nested loops when the loop to be restarted is not the immediately enclosing loop. Also, as with the br eak statement, line breaks are not allowed between the cont i nue statement and its labelname.

5.5.4 return

Recall that function invocations are expressions and that all expressions have values. A r et ur n statement within a function specifies the value of invocations of that function. Here’s the syntax of the r et ur n statement:

r et ur n   expr es s i on;


A r et ur n statement may appear only within the body of a function. It is a syntax error for it to appear anywhere else. When the r et ur n statement is executed, the function that contains it returns the value of expression to its caller. For example:

f unc t i on   s quar e( x)    {    r et ur n   x*x;	}    / /   A  f unc t i on   t hat   has   a r et ur n   s t at ement
s quar e( 2)	/ /   =>   4


With no r et ur n statement, a function invocation simply executes each of the statements in the function body in turn until it reaches the end of the function and then returns to its caller. In this case, the invocation expression evaluates to undef i ned. The r et ur n statement often appears as the last statement in a function, but it need not be last: a function returns to its caller when a r et ur n statement is executed, even if there are other statements remaining in the function body.

The r et ur n statement can also be used without an expression to make the function return undef i ned to its caller. For example:

f unc t i on   di s pl ayObj ec t ( o)    {
/ /   Ret ur n   i mmedi at el y   i f    t he   ar gument   i s   nul l	or   undef i ned. i f    ( ! o)    r et ur n;
/ /   Res t   of    f unc t i on   goes   her e. . . }

Because of JavaScript’s automatic semicolon insertion (§2.6), you cannot include a line break between the r et ur n keyword and the expression that follows it.


5.5.5 yield

The yi el d statement is much like the r et ur n statement but is used only in ES6 generator functions (see §12.3) to produce the next value in the generated sequence of values without actually returning:

/ /   A  gener at or   f unc t i on   t hat   yi el ds   a   r ange   of    i nt eger s f unc t i on*   r ange( f r om,	t o)    {
f or ( l et   i	=   f r om;	i	<=   t o;	i ++)    { yi el d   i ;
} }


In order to understand yi el d, you must understand iterators and generators, which will not be covered until Chapter 12. yi el d is included here for completeness, however. (Technically, though, yi el d is an operator rather than a statement, as explained in §12.4.2.)


5.5.6 throw

An exception is a signal that indicates that some sort of exceptional condition or error has occurred. To throw an exception is to signal such an error or exceptional condition. To catch an exception is to handle it—to take whatever actions are necessary or appropriate to recover from the exception. In JavaScript, exceptions are thrown whenever a runtime error occurs and whenever the program explicitly throws one using the t hr ow statement. Exceptions are caught with the t r y/ cat ch/ f i nal l y statement, which is described in the next section.

The t hr owstatement has the following syntax:


t hr ow  expr es s i on;


expression may evaluate to a value of any type. You might throw a number that represents an error code or a string that contains a human-readable error message. The Error class and its subclasses are used when the JavaScript interpreter itself throws an error, and you can use them as well. An Error object has a name property that specifies the type of error and a mes s age property that holds the string passed to the constructor function. Here is an example function that throws an Error object when invoked with an invalid argument:

f unc t i on   f ac t or i al ( x)    {
/ /   I f    t he   i nput   ar gument   i s   i nval i d,	t hr ow  an   exc ept i on! i f    ( x   <   0)    t hr ow  new  Er r or ( " x   mus t   not   be   negat i ve" ) ;
/ /   Ot her wi s e,	c omput e   a   val ue   and   r et ur n   nor mal l y l et   f ;
f or ( f    =   1;	x   >   1;	f    *=   x,	x- - )    / *   empt y   */   ; r et ur n   f ;
}
f ac t or i al ( 4)	/ /   =>   24


When an exception is thrown, the JavaScript interpreter immediately stops normal program execution and jumps to the nearest exception handler. Exception handlers are written using the cat ch clause of the
t r y/ cat ch/ f i nal l y statement, which is described in the next section. If the block of code in which the exception was thrown does not have an associated cat ch clause, the interpreter checks the next-highest enclosing block of code to see if it has an exception handler associated
with it. This continues until a handler is found. If an exception is thrown in a function that does not contain a t r y/ cat ch/ f i nal l y statement to handle it, the exception propagates up to the code that invoked the

function. In this way, exceptions propagate up through the lexical structure of JavaScript methods and up the call stack. If no exception handler is ever found, the exception is treated as an error and is reported to the user.


5.5.7 try/catch/finally

The t r y/ cat ch/ f i nal l y statement is JavaScript’s exception handling mechanism. The t r y clause of this statement simply defines the block of code whose exceptions are to be handled. The t r y block is followed by a cat ch clause, which is a block of statements that are invoked when an exception occurs anywhere within the t r y block. The cat ch clause is followed by a f i nal l y block containing cleanup code that is guaranteed to be executed, regardless of what happens in the t r y block. Both the
cat ch and f i nal l y blocks are optional, but a t r y block must be accompanied by at least one of these blocks. The t r y, cat ch, and
f i nal l y blocks all begin and end with curly braces. These braces are a required part of the syntax and cannot be omitted, even if a clause contains only a single statement.

The following code illustrates the syntax and purpose of the t r y/ cat ch/ f i nal l y statement:


t r y   {
/ /   Nor mal l y,	t hi s   c ode   r uns   f r om t he   t op   of    t he   bl oc k   t o   t he bot t om
/ /   wi t hout   pr obl ems .	But   i t   c an   s omet i mes   t hr ow  an exc ept i on,
/ /   ei t her   di r ec t l y,	wi t h   a   t hr ow  s t at ement ,	or   i ndi r ec t l y, by   c al l i ng
/ /   a   met hod   t hat   t hr ows   an   exc ept i on. }
c at c h( e)    {

/ /   The   s t at ement s   i n   t hi s   bl oc k   ar e i f ,	t he   t r y
/ /   bl oc k   t hr ows   an   exc ept i on.	Thes e

exec ut ed   i f ,	and   onl y

s t at ement s   c an   us e   t he

l oc al	var i abl e
/ /   e   t o   r ef er   t o   t he   Er r or   obj ec t   or   ot her   val ue   t hat   was t hr own.
/ /   Thi s   bl oc k   may   handl e   t he   exc ept i on   s omehow,	may   i gnor e t he
/ /   exc ept i on   by   doi ng   not hi ng,	or   may   r et hr ow  t he   exc ept i on wi t h   t hr ow.
}
f i nal l y   {
/ /   Thi s   bl oc k   c ont ai ns   s t at ement s   t hat   ar e   al ways   exec ut ed, r egar dl es s   of
/ /   what   happens   i n   t he   t r y   bl oc k.	They   ar e   exec ut ed   whet her t he   t r y
/ /   bl oc k   t er mi nat es :
/ /	1)    nor mal l y,	af t er   r eac hi ng   t he   bot t om of    t he   bl oc k / /	2)    bec aus e   of    a   br eak,	c ont i nue,	or   r et ur n   s t at ement
/ /	3)    wi t h   an   exc ept i on   t hat   i s   handl ed   by   a   c at c h   c l aus e above
/ /	4)    wi t h   an   unc aught   exc ept i on   t hat   i s   s t i l l	pr opagat i ng }


Note that the cat ch keyword is generally followed by an identifier in parentheses. This identifier is like a function parameter. When an exception is caught, the value associated with the exception (an Error object, for example) is assigned to this parameter. The identifier associated with a cat ch clause has block scope—it is only defined within the
cat ch block.


Here is a realistic example of the t r y/ cat ch statement. It uses the
f act or i al ( )  method defined in the previous section and the client-side JavaScript methods pr ompt ( )  and al er t ( )  for input and output:

t r y   {
/ /   As k   t he   us er   t o   ent er   a   number
l et   n   =   Number ( pr ompt ( " Pl eas e   ent er   a   pos i t i ve   i nt eger " , " " ) ) ;
/ /   Comput e   t he   f ac t or i al	of    t he   number ,	as s umi ng   t he   i nput i s   val i d
l et   f    =   f ac t or i al ( n) ; / /   Di s pl ay   t he   r es ul t

al er t ( n   +   " !   =   "   +   f ) ; }
c at c h( ex)    {	/ /   I f    t he   us er ' s   i nput   was   not   val i d,	we   end   up her e
al er t ( ex) ;	/ /   Tel l	t he   us er   what   t he   er r or   i s }


This example is a t r y/ cat ch statement with no f i nal l y clause. Although f i nal l y is not used as often as cat ch, it can be useful. However, its behavior requires additional explanation. The f i nal l y clause is guaranteed to be executed if any portion of the t r y block is executed, regardless of how the code in the t r y block completes. It is generally used to clean up after the code in the t r y clause.


In the normal case, the JavaScript interpreter reaches the end of the t r y block and then proceeds to the f i nal l y block, which performs any necessary cleanup. If the interpreter left the t r y block because of a
r et ur n, cont i nue, or br eak statement, the f i nal l y block is executed before the interpreter jumps to its new destination.

If an exception occurs in the t r y block and there is an associated cat ch block to handle the exception, the interpreter first executes the cat ch block and then the f i nal l y block. If there is no local cat ch block to handle the exception, the interpreter first executes the f i nal l y block and then jumps to the nearest containing cat ch clause.


If a f i nal l y block itself causes a jump with a r et ur n, cont i nue, br eak, or t hr owstatement, or by calling a method that throws an exception, the interpreter abandons whatever jump was pending and performs the new jump. For example, if a f i nal l y clause throws an
exception, that exception replaces any exception that was in the process of

being thrown. If a f i nal l y clause issues a r et ur n statement, the method returns normally, even if an exception has been thrown and has not yet been handled.

t r y and f i nal l y can be used together without a cat ch clause. In this case, the f i nal l y block is simply cleanup code that is guaranteed to be executed, regardless of what happens in the t r y block. Recall that we can’t completely simulate a f or  loop with a whi l e loop because the cont i nue statement behaves differently for the two loops. If we add a
t r y/ f i nal l y statement, we can write a whi l e loop that works like a f or  loop and that handles cont i nue statements correctly:

/ /   Si mul at e   f or ( i ni t i al i z e   ;	t es t   ; i nc r ement   )    body; i ni t i al i z e   ;
whi l e(    t es t   )    {
t r y   {    body   ;	}
f i nal l y   {    i nc r ement   ;	} }


Note, however, that a body that contains a br eak statement behaves slightly differently (causing an extra increment before exiting) in the whi l e loop than it does in the f or  loop, so even with the f i nal l y
clause, it is not possible to completely simulate the f or  loop with whi l e.



BARE CATCH CLAUSES

Occasionally you may find yourself using a cat ch clause solely to detect and stop the propagation of an exception, even though you do not care about the type or the value of the exception. In ES2019 and later, you can omit the parentheses and the identifier and use the cat ch keyword bare in this case. Here is an example:


/ /   L i ke   J SON. par s e( ) , f unc t i on  par s eJ SON( s )
t r y   {

but   r et ur n   undef i ned   i ns t ead   of    t hr owi ng   an   er r or {

r et ur n  J SON. par s e( s ) ; }   c at c h  {
/ /   Somet hi ng   went   wr ong   but   we   don' t   c ar e   what   i t   was r et ur n  undef i ned;

} }





5.6 Miscellaneous Statements

This section describes the remaining three JavaScript statements—wi t h, debugger , and " us e   s t r i ct " .


5.6.1 with

The wi t h statement runs a block of code as if the properties of a specified object were variables in scope for that code. It has the following syntax:

wi t h   ( obj ec t ) s t at ement


This statement creates a temporary scope with the properties of object as variables and then executes statement within that scope.


The wi t h statement is forbidden in strict mode (see §5.6.3) and should be considered deprecated in non-strict mode: avoid using it whenever possible. JavaScript code that uses wi t h is difficult to optimize and is likely to run significantly more slowly than the equivalent code written without the wi t h statement.


The common use of the wi t h statement is to make it easier to work with deeply nested object hierarchies. In client-side JavaScript, for example, you may have to type expressions like this one to access elements of an HTML form:

doc ument . f or ms [ 0] . addr es s . val ue

If you need to write expressions like this a number of times, you can use the wi t h statement to treat the properties of the form object like variables:

wi t h( doc ument . f or ms [ 0] )    {
/ /   Ac c es s   f or m el ement s   di r ec t l y   her e.	For   exampl e: name. val ue   =   " " ;
addr es s . val ue   =   " " ; emai l . val ue   =   " " ;
}


This reduces the amount of typing you have to do: you no longer need to prefix each form property name with document . f or ms [ 0] . It is just as simple, of course, to avoid the wi t h statement and write the preceding code like this:

l et   f    =   doc ument . f or ms [ 0] ; f . name. val ue   =   " " ;
f . addr es s . val ue   =   " " ; f . emai l . val ue   =   " " ;


Note that if you use cons t  or l et  or var  to declare a variable or constant within the body of a wi t h statement, it creates an ordinary variable and does not define a new property within the specified object.


5.6.2 debugger

The debugger  statement normally does nothing. If, however, a debugger program is available and is running, then an implementation may (but is not required to) perform some kind of debugging action. In practice, this statement acts like a breakpoint: execution of JavaScript code stops, and you can use the debugger to print variables’values, examine the call stack, and so on. Suppose, for example, that you are getting an exception in your

function f ( )  because it is being called with an undefined argument, and you can’t figure out where this call is coming from. To help you in debugging this problem, you might alter f ( )  so that it begins like this:

f unc t i on   f ( o)    {
i f    ( o   ===   undef i ned)    debugger ;	/ /   Tempor ar y   l i ne   f or debuggi ng   pur pos es
. . .	/ /   The   r es t   of    t he   f unc t i on goes   her e.
}


Now, when f ( )  is called with no argument, execution will stop, and you can use the debugger to inspect the call stack and find out where this incorrect call is coming from.

Note that it is not enough to have a debugger available: the debugger statement won’t start the debugger for you. If you’re using a web browser and have the developer tools console open, however, this statement will cause a breakpoint.


5.6.3 “use strict”

" us e   s t r i ct " is a directive introduced in ES5. Directives are not statements (but are close enough that " us e   s t r i ct " is documented here). There are two important differences between the " us e   s t r i ct " directive and regular statements:

It does not include any language keywords: the directive is just an expression statement that consists of a special string literal (in single or double quotes).

It can appear only at the start of a script or at the start of a function body, before any real statements have appeared.

The purpose of a " us e   s t r i ct " directive is to indicate that the code that follows (in the script or function) is strict code. The top-level (nonfunction) code of a script is strict code if the script has a " us e
s t r i ct " directive. A function body is strict code if it is defined within strict code or if it has a " us e   s t r i ct " directive. Code passed to the eval ( )  method is strict code if eval ( )  is called from strict code or if the string of code includes a " us e   s t r i ct " directive. In addition to code explicitly declared to be strict, any code in a cl as s  body
(Chapter 9) or in an ES6 module (§10.3) is automatically strict code. This means that if all of your JavaScript code is written as modules, then it is all automatically strict, and you will never need to use an explicit " us e
s t r i ct " directive.


Strict code is executed in strict mode. Strict mode is a restricted subset of the language that fixes important language deficiencies and provides stronger error checking and increased security. Because strict mode is not the default, old JavaScript code that still uses the deficient legacy features of the language will continue to run correctly. The differences between strict mode and non-strict mode are the following (the first three are particularly important):

The wi t h statement is not allowed in strict mode.

In strict mode, all variables must be declared: a ReferenceError is thrown if you assign a value to an identifier that is not a declared variable, function, function parameter, cat ch clause parameter, or property of the global object. (In non-strict mode, this implicitly declares a global variable by adding a new property to the global object.)

In strict mode, functions invoked as functions (rather than as methods) have a t hi s  value of undef i ned. (In non-strict

mode, functions invoked as functions are always passed the global object as their t hi s  value.) Also, in strict mode, when a function is invoked with cal l ( )  or appl y( )  (§8.7.4), the
t hi s  value is exactly the value passed as the first argument to cal l ( )  or appl y( ) . (In non-strict mode, nul l  and
undef i ned values are replaced with the global object and nonobject values are converted to objects.)

In strict mode, assignments to nonwritable properties and attempts to create new properties on non-extensible objects throw a TypeError. (In non-strict mode, these attempts fail silently.)

In strict mode, code passed to eval ( )  cannot declare variables or define functions in the caller’s scope as it can in non-strict mode. Instead, variable and function definitions live in a new scope created for the eval ( ) . This scope is discarded when the eval ( )  returns.

In strict mode, the Arguments object (§8.3.3) in a function holds a static copy of the values passed to the function. In non-strict mode, the Arguments object has “magical” behavior in which elements of the array and named function parameters both refer to the same value.

In strict mode, a SyntaxError is thrown if the del et e operator is followed by an unqualified identifier such as a variable, function, or function parameter. (In nonstrict mode, such a del et e expression does nothing and evaluates to f al s e.)

In strict mode, an attempt to delete a nonconfigurable property throws a TypeError. (In non-strict mode, the attempt fails and the del et e expression evaluates to f al s e.)

In strict mode, it is a syntax error for an object literal to define two or more properties by the same name. (In non-strict mode, no error occurs.)

In strict mode, it is a syntax error for a function declaration to

have two or more parameters with the same name. (In non-strict mode, no error occurs.)

In strict mode, octal integer literals (beginning with a 0 that is not followed by an x) are not allowed. (In non-strict mode, some implementations allow octal literals.)

In strict mode, the identifiers eval  and ar gument s  are treated like keywords, and you are not allowed to change their value. You cannot assign a value to these identifiers, declare them as variables, use them as function names, use them as function parameter names, or use them as the identifier of a cat ch block.

In strict mode, the ability to examine the call stack is restricted. ar gument s . cal l er  and ar gument s . cal l ee both throw a TypeError within a strict mode function. Strict mode functions also have cal l er  and ar gument s  properties that throw TypeError when read. (Some implementations define these nonstandard properties on non-strict functions.)


5.7 Declarations

The keywords cons t , l et , var , f unct i on, cl as s , i mpor t , and expor t  are not technically statements, but they look a lot like statements, and this book refers informally to them as statements, so they deserve a mention in this chapter.

These keywords are more accurately described as declarations rather than statements. We said at the start of this chapter that statements “make something happen.” Declarations serve to define new values and give them names that we can use to refer to those values. They don’t make much happen themselves, but by providing names for values they, in an important sense, define the meaning of the other statements in your program.

When a program runs, it is the program’s expressions that are being evaluated and the program’s statements that are being executed. The declarations in a program don’t “run” in the same way: instead, they define the structure of the program itself. Loosely, you can think of declarations as the parts of the program that are processed before the code starts running.


JavaScript declarations are used to define constants, variables, functions, and classes and for importing and exporting values between modules. The next subsections give examples of all of these declarations. They are all covered in much more detail elsewhere in this book.


5.7.1 const, let, and var

The cons t , l et , and var  declarations are covered in §3.10. In ES6 and later, cons t  declares constants, and l et  declares variables. Prior to ES6, the var  keyword was the only way to declare variables and there was no way to declare constants. Variables declared with var  are scoped to the containing function rather than the containing block. This can be a source of bugs, and in modern JavaScript there is really no reason to use var instead of l et .

c ons t   TAU  =   2*Mat h. PI ; l et   r adi us   =   3;
var   c i r c umf er enc e   =   TAU  *   r adi us ;


5.7.2 function

The f unct i on declaration is used to define functions, which are covered in detail in Chapter 8. (We also saw f unct i on in §4.3, where it was used as part of a function expression rather than a function declaration.) A function declaration looks like this:

f unc t i on   ar ea( r adi us )    {
r et ur n   Mat h. PI	*   r adi us   *   r adi us ; }


A function declaration creates a function object and assigns it to the specified name—ar ea in this example. Elsewhere in our program, we can refer to the function—and run the code inside it—by using this name. The function declarations in any block of JavaScript code are processed before that code runs, and the function names are bound to the function objects throughout the block. We say that function declarations are “hoisted” because it is as if they had all been moved up to the top of whatever scope they are defined within. The upshot is that code that invokes a function can exist in your program before the code that declares the function.

§12.3 describes a special kind of function known as a generator. Generator declarations use the f unct i on keyword but follow it with an asterisk. §13.3 describes asynchronous functions, which are also declared using the f unct i on keyword but are prefixed with the as ync keyword.


5.7.3 class

In ES6 and later, the cl as s  declaration creates a new class and gives it a name that we can use to refer to it. Classes are described in detail in Chapter 9. A simple class declaration might look like this:

c l as s   Ci r c l e   {
c ons t r uc t or ( r adi us )    {    t hi s . r   =   r adi us ;	}
ar ea( )    {    r et ur n   Mat h. PI	*   t hi s . r   *   t hi s . r ;	}
c i r c umf er enc e( )    {    r et ur n   2   *   Mat h. PI	*   t hi s . r ;	} }


Unlike functions, class declarations are not hoisted, and you cannot use a class declared this way in code that appears before the declaration.

5.7.4 import and export

The i mpor t  and expor t  declarations are used together to make values defined in one module of JavaScript code available in another module. A module is a file of JavaScript code with its own global namespace, completely independent of all other modules. The only way that a value (such as function or class) defined in one module can be used in another module is if the defining module exports it with expor t  and the using module imports it with i mpor t . Modules are the subject of Chapter 10, and i mpor t  and expor t  are covered in detail in §10.3.


i mpor t  directives are used to import one or more values from another file of JavaScript code and give them names within the current module. i mpor t  directives come in a few different forms. Here are some examples:

i mpor t   Ci r c l e   f r om ' . / geomet r y/ c i r c l e. j s ' ;
i mpor t   {    PI ,	TAU  }    f r om ' . / geomet r y/ c ons t ant s . j s ' ;
i mpor t   {    magni t ude   as   hypot enus e   }    f r om ' . / vec t or s / ut i l s . j s ' ;


Values within a JavaScript module are private and cannot be imported into other modules unless they have been explicitly exported. The expor t directive does this: it declares that one or more values defined in the current module are exported and therefore available for import by other modules. The expor t  directive has more variants than the i mpor t directive does. Here is one of them:

/ /   geomet r y/ c ons t ant s . j s c ons t   PI	=   Mat h. PI ;
c ons t   TAU  =   2   *   PI ; expor t   {    PI ,    TAU  } ;


The expor t  keyword is sometimes used as a modifier on other

declarations, resulting in a kind of compound declaration that defines a constant, variable, function, or class and exports it at the same time. And when a module exports only a single value, this is typically done with the special form expor t   def aul t :


expor t   c ons t   TAU  =   2   *   Mat h. PI ;
expor t   f unc t i on   magni t ude( x, y)    {    r et ur n   Mat h. s qr t ( x*x   +   y*y) ;	} expor t   def aul t   c l as s   Ci r c l e   {    / *   c l as s   def i ni t i on   omi t t ed   her e */   }


5.8 Summary of J avaScript Statements

This chapter introduced each of the JavaScript language’s statements, which are summarized in Table 5-1.


Table 5-1. JavaScript statement syntax


Statement

break


case

class

const

continue

debugger

default

do/while

export

for

Purpose

Exit from the innermost loop or s wi t c h or from named enclosing statement

Label a statement within a s wi t c h

Declare a class

Declare and initialize one or more constants

Begin next iteration of the innermost loop or the named loop

Debugger breakpoint

Label the default statement within a s wi t c h

An alternative to the whi l e loop

Declare values that can be imported into other modules

An easy-to-use loop



for/await

for/in

for/of

function

if/else

import

label

let

return

switch

throw

try/catch/finall y

“use strict”

var

while

with

yield

Asynchronously iterate the values of an async iterator

Enumerate the property names of an object

Enumerate the values of an iterable object such as an array

Declare a function

Execute one statement or another depending on a condition

Declare names for values defined in other modules

Give statement a name for use with br eak and c ont i nue

Declare and initialize one or more block-scoped variables (new syntax)

Return a value from a function

Multiway branch to c as e or def aul t :  labels

Throw an exception

Handle exceptions and code cleanup


Apply strict mode restrictions to script or function

Declare and initialize one or more variables (old syntax)

A basic loop construct

Extend the scope chain (deprecated and forbidden in strict mode)

Provide a value to be iterated; only used in generator functions







1





2

The fact that the c as e expressions are evaluated at runtime makes the JavaScript s wi t c h statement much different from (and less efficient than) the s wi t c h statement of C, C++, and Java. In those languages, the c as e expressions must be compile-time constants of the same type, and s wi t c h statements can often compile down to highly efficient jump tables.

When we consider the c ont i nue statement in §5.5.3, we’ll see that this whi l e loop is not an exact equivalent of the f or  loop.



Chapter 6. Objects




Objects are JavaScript’s most fundamental datatype, and you have already seen them many times in the chapters that precede this one. Because objects are so important to the JavaScript language, it is important that you understand how they work in detail, and this chapter provides that detail. It begins with a formal overview of objects, then dives into practical sections about creating objects and querying, setting, deleting, testing, and enumerating the properties of objects. These property-focused sections are followed by sections that explain how to extend, serialize, and define important methods on objects. Finally, the chapter concludes with a long section about new object literal syntax in ES6 and more recent versions of the language.


6.1 Introduction to Objects

An object is a composite value: it aggregates multiple values (primitive values or other objects) and allows you to store and retrieve those values by name. An object is an unordered collection of properties, each of which has a name and a value. Property names are usually strings (although, as we’ll see in §6.10.3, property names can also be Symbols), so we can say that objects map strings to values. This string-to-value mapping goes by various names—you are probably already familiar with the fundamental data structure under the name “hash,” “hashtable,” “dictionary,” or “associative array.” An object is more than a simple string-to-value map, however. In addition to maintaining its own set of properties, a JavaScript object also inherits the properties of another object, known as its

“prototype.” The methods of an object are typically inherited properties, and this “prototypal inheritance” is a key feature of JavaScript.


JavaScript objects are dynamic—properties can usually be added and deleted—but they can be used to simulate the static objects and “structs” of statically typed languages. They can also be used (by ignoring the value part of the string-to-value mapping) to represent sets of strings.


Any value in JavaScript that is not a string, a number, a Symbol, or t r ue, f al s e, nul l , or undef i ned is an object. And even though strings, numbers, and booleans are not objects, they can behave like immutable objects.

Recall from §3.8 that objects are mutable and manipulated by reference rather than by value. If the variable x refers to an object and the code l et y   =   x;  is executed, the variable y holds a reference to the same object, not a copy of that object. Any modifications made to the object through the variable y are also visible through the variable x.


The most common things to do with objects are to create them and set, query, delete, test, and enumerate their properties. These fundamental operations are described in the opening sections of this chapter. The sections after that cover more advanced topics.


A property has a name and a value. A property name may be any string, including the empty string (or any Symbol), but no object may have two properties with the same name. The value may be any JavaScript value, or it may be a getter or setter function (or both). We’ll learn about getter and setter functions in §6.10.6.

It is sometimes important to be able to distinguish between properties defined directly on an object and those that are inherited from a prototype object. JavaScript uses the term own property to refer to non-inherited properties.


In addition to its name and value, each property has three property attributes:

The writable attribute specifies whether the value of the property can be set.

The enumerable attribute specifies whether the property name is returned by a f or / i n loop.

The configurable attribute specifies whether the property can be deleted and whether its attributes can be altered.

Many of JavaScript’s built-in objects have properties that are read-only, non-enumerable, or non-configurable. By default, however, all properties of the objects you create are writable, enumerable, and configurable. §14.1 explains techniques for specifying non-default property attribute values for your objects.


6.2 Creating Objects

Objects can be created with object literals, with the newkeyword, and with the Obj ect . cr eat e( )  function. The subsections below describe each technique.


6.2.1 Object Literals

The easiest way to create an object is to include an object literal in your JavaScript code. In its simplest form, an object literal is a comma-

separated list of colon-separated name:value pairs, enclosed within curly braces. A property name is a JavaScript identifier or a string literal (the empty string is allowed). A property value is any JavaScript expression; the value of the expression (it may be a primitive value or an object value) becomes the value of the property. Here are some examples:

l et   empt y   =   { } ;	/ /   An   obj ec t   wi t h   no pr oper t i es
l et   poi nt   =   {    x:	0,	y:	0   } ;	/ /   Two   numer i c pr oper t i es
l et   p2   =   {    x:	poi nt . x,	y:	poi nt . y+1   } ;	/ /   Mor e   c ompl ex   val ues l et   book   =   {
" mai n   t i t l e" :	" J avaSc r i pt " ,	/ /   Thes e   pr oper t y   names i nc l ude   s pac es ,
" s ub- t i t l e" :	" The   Def i ni t i ve   Gui de" ,	/ /   and   hyphens ,	s o   us e s t r i ng   l i t er al s .
f or :	" al l	audi enc es " ,	/ /   f or   i s   r es er ved,	but no   quot es .
aut hor :	{	/ /   The   val ue   of    t hi s pr oper t y   i s
f i r s t name:	" Davi d" ,	/ /   i t s el f    an   obj ec t . s ur name:	" Fl anagan"
} } ;


A trailing comma following the last property in an object literal is legal, and some programming styles encourage the use of these trailing commas so you’re less likely to cause a syntax error if you add a new property at the end of the object literal at some later time.


An object literal is an expression that creates and initializes a new and distinct object each time it is evaluated. The value of each property is evaluated each time the literal is evaluated. This means that a single object literal can create many new objects if it appears within the body of a loop or in a function that is called repeatedly, and that the property values of these objects may differ from each other.

The object literals shown here use simple syntax that has been legal since the earliest versions of JavaScript. Recent versions of the language have introduced a number of new object literal features, which are covered in §6.10.


6.2.2 Creating Objects with new

The newoperator creates and initializes a new object. The newkeyword must be followed by a function invocation. A function used in this way is called a constructor and serves to initialize a newly created object. JavaScript includes constructors for its built-in types. For example:

l et   o   =   new  Obj ec t ( ) ;	/ /   Cr eat e   an   empt y   obj ec t :	s ame   as   { } . l et   a   =   new  Ar r ay( ) ;	/ /   Cr eat e   an   empt y   ar r ay:    s ame   as   [ ] .
l et   d   =   new  Dat e( ) ;	/ /   Cr eat e   a   Dat e   obj ec t   r epr es ent i ng   t he c ur r ent   t i me
l et   r   =   new  Map( ) ;	/ /   Cr eat e   a   Map   obj ec t   f or   key/ val ue mappi ng


In addition to these built-in constructors, it is common to define your own constructor functions to initialize newly created objects. Doing so is covered in Chapter 9.


6.2.3 Prototypes

Before we can cover the third object creation technique, we must pause for a moment to explain prototypes. Almost every JavaScript object has a second JavaScript object associated with it. This second object is known as a prototype, and the first object inherits properties from the prototype.


All objects created by object literals have the same prototype object, and we can refer to this prototype object in JavaScript code as
Obj ect . pr ot ot ype. Objects created using the newkeyword and a

constructor invocation use the value of the pr ot ot ype property of the constructor function as their prototype. So the object created by new Obj ect ( )  inherits from Obj ect . pr ot ot ype, just as the object
created by { }  does. Similarly, the object created by new  Ar r ay( )  uses Ar r ay. pr ot ot ype as its prototype, and the object created by new
Dat e( )  uses Dat e. pr ot ot ype as its prototype. This can be confusing when first learning JavaScript. Remember: almost all objects have a prototype, but only a relatively small number of objects have a
pr ot ot ype property. It is these objects with pr ot ot ype properties that define the prototypes for all the other objects.

Obj ect . pr ot ot ype is one of the rare objects that has no prototype: it does not inherit any properties. Other prototype objects are normal objects that do have a prototype. Most built-in constructors (and most user-defined constructors) have a prototype that inherits from Obj ect . pr ot ot ype. For example, Dat e. pr ot ot ype inherits properties from
Obj ect . pr ot ot ype, so a Date object created by new  Dat e( ) inherits properties from both Dat e. pr ot ot ype and
Obj ect . pr ot ot ype. This linked series of prototype objects is known as a prototype chain.

An explanation of how property inheritance works is in §6.3.2. Chapter 9 explains the connection between prototypes and constructors in more detail: it shows how to define new “classes” of objects by writing a constructor function and setting its pr ot ot ype property to the prototype object to be used by the “instances” created with that constructor. And we’ll learn how to query (and even change) the prototype of an object in §14.3.

6.2.4 Object.create()

Obj ect . cr eat e( )  creates a new object, using its first argument as the prototype of that object:

l et   o1   =   Obj ec t . c r eat e( { x:	1,	y:	2} ) ;	/ /   o1   i nher i t s pr oper t i es   x   and   y.
o1. x   +   o1. y	/ /   =>   3


You can pass nul l  to create a new object that does not have a prototype, but if you do this, the newly created object will not inherit anything, not even basic methods like t oSt r i ng( )  (which means it won’t work with the + operator either):

l et   o2   =   Obj ec t . c r eat e( nul l ) ;	/ /   o2   i nher i t s   no pr ops   or   met hods .


If you want to create an ordinary empty object (like the object returned by { }  or new  Obj ect ( ) ), pass Obj ect . pr ot ot ype:


l et   o3   =   Obj ec t . c r eat e( Obj ec t . pr ot ot ype) ;	/ /   o3   i s   l i ke   { }    or new  Obj ec t ( ) .


The ability to create a new object with an arbitrary prototype is a powerful one, and we’ll use Obj ect . cr eat e( )  in a number of places throughout this chapter. (Obj ect . cr eat e( )  also takes an optional second argument that describes the properties of the new object. This second argument is an advanced feature covered in §14.1.)

One use for Obj ect . cr eat e( )  is when you want to guard against unintended (but nonmalicious) modification of an object by a library function that you don’t have control over. Instead of passing the object directly to the function, you can pass an object that inherits from it. If the

function reads properties of that object, it will see the inherited values. If it sets properties, however, those writes will not affect the original object.

l et   o   =   {    x:	" don' t   c hange   t hi s   val ue"   } ;
l i br ar y. f unc t i on( Obj ec t . c r eat e( o) ) ;	/ /   Guar d   agai ns t   ac c i dent al modi f i c at i ons


To understand why this works, you need to know how properties are queried and set in JavaScript. These are the topics of the next section.


6.3 Querying and Setting Properties

To obtain the value of a property, use the dot (. ) or square bracket ([ ] ) operators described in §4.4. The lefthand side should be an expression whose value is an object. If using the dot operator, the righthand side must be a simple identifier that names the property. If using square brackets, the value within the brackets must be an expression that evaluates to a string that contains the desired property name:

l et   aut hor   =   book. aut hor ;	/ /   Get   t he   " aut hor "   pr oper t y   of t he   book.
l et   name   =   aut hor . s ur name;	/ /   Get   t he   " s ur name"   pr oper t y   of t he   aut hor .
l et   t i t l e   =   book[ " mai n   t i t l e" ] ;	/ /   Get   t he   " mai n   t i t l e"   pr oper t y of    t he   book.


To create or set a property, use a dot or square brackets as you would to query the property, but put them on the lefthand side of an assignment expression:

book. edi t i on   =   7;	/ /   Cr eat e   an   " edi t i on" pr oper t y   of    book.
book[ " mai n   t i t l e" ]    =   " ECMASc r i pt " ;	/ /   Change   t he   " mai n   t i t l e" pr oper t y.

When using square bracket notation, we’ve said that the expression inside the square brackets must evaluate to a string. A more precise statement is that the expression must evaluate to a string or a value that can be converted to a string or to a Symbol (§6.10.3). In Chapter 7, for example, we’ll see that it is common to use numbers inside the square brackets.


6.3.1 Objects As Associative Arrays

As explained in the preceding section, the following two JavaScript expressions have the same value:

obj ec t . pr oper t y obj ec t [ " pr oper t y" ]


The first syntax, using the dot and an identifier, is like the syntax used to access a static field of a struct or object in C or Java. The second syntax, using square brackets and a string, looks like array access, but to an array indexed by strings rather than by numbers. This kind of array is known as an associative array (or hash or map or dictionary). JavaScript objects are associative arrays, and this section explains why that is important.


In C, C++, Java, and similar strongly typed languages, an object can have only a fixed number of properties, and the names of these properties must be defined in advance. Since JavaScript is a loosely typed language, this rule does not apply: a program can create any number of properties in any object. When you use the .  operator to access a property of an object, however, the name of the property is expressed as an identifier. Identifiers must be typed literally into your JavaScript program; they are not a datatype, so they cannot be manipulated by the program.

On the other hand, when you access a property of an object with the [ ]

array notation, the name of the property is expressed as a string. Strings are JavaScript datatypes, so they can be manipulated and created while a program is running. So, for example, you can write the following code in JavaScript:

l et   addr   =   " " ;
f or ( l et   i	=   0;	i	<   4;	i ++)    {
addr   +=   c us t omer [ ` addr es s ${ i } ` ]    +   " \ n" ; }


This code reads and concatenates the addr es s 0, addr es s 1, addr es s 2, and addr es s 3 properties of the cus t omer  object.


This brief example demonstrates the flexibility of using array notation to access properties of an object with string expressions. This code could be rewritten using the dot notation, but there are cases in which only the array notation will do. Suppose, for example, that you are writing a program that uses network resources to compute the current value of the user’s stock market investments. The program allows the user to type in the name of each stock they own as well as the number of shares of each stock. You might use an object named por t f ol i o to hold this information. The object has one property for each stock. The name of the property is the name of the stock, and the property value is the number of shares of that stock. So, for example, if a user holds 50 shares of stock in IBM, the
por t f ol i o. i bmproperty has the value 50.


Part of this program might be a function for adding a new stock to the portfolio:

f unc t i on   adds t oc k( por t f ol i o,	s t oc kname,	s har es )    { por t f ol i o[ s t oc kname]    =   s har es ;
}

Since the user enters stock names at runtime, there is no way that you can know the property names ahead of time. Since you can’t know the property names when you write the program, there is no way you can use the .  operator to access the properties of the por t f ol i o object. You can use the [ ]  operator, however, because it uses a string value (which is dynamic and can change at runtime) rather than an identifier (which is static and must be hardcoded in the program) to name the property.

In Chapter 5, we introduced the f or / i n loop (and we’ll see it again shortly, in §6.6). The power of this JavaScript statement becomes clear when you consider its use with associative arrays. Here is how you would use it when computing the total value of a portfolio:

f unc t i on   c omput eVal ue( por t f ol i o)    { l et   t ot al	=   0. 0;
f or ( l et   s t oc k   i n   por t f ol i o)    {	/ /   For   eac h   s t oc k   i n   t he por t f ol i o:
l et   s har es   =   por t f ol i o[ s t oc k] ;	/ /   get   t he   number   of s har es
l et   pr i c e   =   get Quot e( s t oc k) ;	/ /   l ook   up   s har e   pr i c e t ot al	+=   s har es   *   pr i c e;	/ /   add   s t oc k   val ue   t o
t ot al	val ue }
r et ur n   t ot al ;	/ /   Ret ur n   t ot al	val ue. }


JavaScript objects are commonly used as associative arrays as shown here, and it is important to understand how this works. In ES6 and later, however, the Map class described in §11.1.2 is often a better choice than using a plain object.


6.3.2 Inheritance

JavaScript objects have a set of “own properties,” and they also inherit a

set of properties from their prototype object. To understand this, we must consider property access in more detail. The examples in this section use the Obj ect . cr eat e( )  function to create objects with specified prototypes. We’ll see in Chapter 9, however, that every time you create an instance of a class with new, you are creating an object that inherits properties from a prototype object.

Suppose you query the property x in the object o. If o does not have an own property with that name, the prototype object of o1 is queried for the property x. If the prototype object does not have an own property by that name, but has a prototype itself, the query is performed on the prototype of the prototype. This continues until the property x is found or until an object with a nul l  prototype is searched. As you can see, the
pr ot ot ype attribute of an object creates a chain or linked list from which properties are inherited:

l et   o   =   { } ;	/ /   o   i nher i t s   obj ec t   met hods   f r om Obj ec t . pr ot ot ype
o. x   =   1;	/ /   and   i t   now  has   an   own   pr oper t y   x. l et   p   =   Obj ec t . c r eat e( o) ;	/ /   p   i nher i t s   pr oper t i es   f r om o   and Obj ec t . pr ot ot ype
p. y   =   2;	/ /   and   has   an   own   pr oper t y   y.
l et   q   =   Obj ec t . c r eat e( p) ;	/ /   q   i nher i t s   pr oper t i es   f r om p,	o, and. . .
q. z   =   3;	/ /   . . . Obj ec t . pr ot ot ype   and   has   an   own pr oper t y   z .
l et   f    =   q. t oSt r i ng( ) ;	/ /   t oSt r i ng   i s   i nher i t ed   f r om Obj ec t . pr ot ot ype
q. x   +   q. y	/ /   =>   3;	x   and   y   ar e   i nher i t ed   f r om o and   p


Now suppose you assign to the property x of the object o. If o already has an own (non-inherited) property named x, then the assignment simply changes the value of this existing property. Otherwise, the assignment

creates a new property named x on the object o. If o previously inherited the property x, that inherited property is now hidden by the newly created own property with the same name.

Property assignment examines the prototype chain only to determine whether the assignment is allowed. If o inherits a read-only property named x, for example, then the assignment is not allowed. (Details about when a property may be set are in §6.3.3.) If the assignment is allowed, however, it always creates or sets a property in the original object and never modifies objects in the prototype chain. The fact that inheritance occurs when querying properties but not when setting them is a key feature of JavaScript because it allows us to selectively override inherited properties:

l et   uni t c i r c l e   =   {    r :	1   } ;	/ /   An   obj ec t   t o   i nher i t   f r om l et   c   =   Obj ec t . c r eat e( uni t c i r c l e) ;	/ /   c   i nher i t s   t he   pr oper t y   r c . x   =   1;	c . y   =   1;                                                  / /   c   def i nes   t wo   pr oper t i es of    i t s   own
c . r   =   2;	/ /   c   over r i des   i t s   i nher i t ed pr oper t y
uni t c i r c l e. r	/ /   =>   1:	t he   pr ot ot ype   i s   not af f ec t ed

There is one exception to the rule that a property assignment either fails or creates or sets a property in the original object. If o inherits the property x, and that property is an accessor property with a setter method (see §6.10.6), then that setter method is called rather than creating a new property x in o. Note, however, that the setter method is called on the object o, not on the prototype object that defines the property, so if the setter method defines any properties, it will do so on o, and it will again leave the prototype chain unmodified.

6.3.3 Property Access Errors

Property access expressions do not always return or set a value. This section explains the things that can go wrong when you query or set a property.


It is not an error to query a property that does not exist. If the property x is not found as an own property or an inherited property of o, the property access expression o. x evaluates to undef i ned. Recall that our book object has a “sub-title” property, but not a “subtitle” property:

book. s ubt i t l e	/ /   =>   undef i ned:	pr oper t y   does n' t   exi s t


It is an error, however, to attempt to query a property of an object that does not exist. The nul l  and undef i ned values have no properties, and it is an error to query properties of these values. Continuing the preceding example:

l et   l en   =   book. s ubt i t l e. l engt h;	/ /   ! TypeEr r or :	undef i ned   does n' t have   l engt h


Property access expressions will fail if the lefthand side of the .  is nul l or undef i ned. So when writing an expression like
book. aut hor . s ur name, you should be careful if you are not certain that book and book. aut hor  are actually defined. Here are two ways to guard against this kind of problem:

/ /   A  ver bos e   and   expl i c i t   t ec hni que l et   s ur name   =   undef i ned;
i f    ( book)    {
i f    ( book. aut hor )    {
s ur name   =   book. aut hor . s ur name; }
}


/ /   A  c onc i s e   and   i di omat i c   al t er nat i ve   t o   get   s ur name   or   nul l	or undef i ned
s ur name   =   book   &&  book. aut hor   &&  book. aut hor . s ur name;


To understand why this idiomatic expression works to prevent TypeError exceptions, you might want to review the short-circuiting behavior of the &&operator in §4.10.1.


As described in §4.4.1, ES2020 supports conditional property access with ?. , which allows us to rewrite the previous assignment expression as:


l et   s ur name   =   book?. aut hor ?. s ur name;


Attempting to set a property on nul l  or undef i ned also causes a TypeError. Attempts to set properties on other values do not always succeed, either: some properties are read-only and cannot be set, and some objects do not allow the addition of new properties. In strict mode (§5.6.3), a TypeError is thrown whenever an attempt to set a property fails. Outside of strict mode, these failures are usually silent.

The rules that specify when a property assignment succeeds and when it fails are intuitive but difficult to express concisely. An attempt to set a property p of an object o fails in these circumstances:

o has an own property p that is read-only: it is not possible to set read-only properties.

o has an inherited property p that is read-only: it is not possible to hide an inherited read-only property with an own property of the same name.

o does not have an own property p; o does not inherit a property p with a setter method, and o’s extensible attribute (see §14.2) is

f al s e. Since p does not already exist in o, and if there is no setter method to call, then p must be added to o. But if o is not extensible, then no new properties can be defined on it.


6.4 Deleting Properties

The del et e operator (§4.13.4) removes a property from an object. Its single operand should be a property access expression. Surprisingly,
del et e does not operate on the value of the property but on the property itself:

del et e   book. aut hor ;	/ /   The   book   obj ec t   now  has   no aut hor   pr oper t y.
del et e   book[ " mai n   t i t l e" ] ;	/ /   Now  i t   does n' t   have   " mai n t i t l e" ,	ei t her .


The del et e operator only deletes own properties, not inherited ones. (To delete an inherited property, you must delete it from the prototype object in which it is defined. Doing this affects every object that inherits from that prototype.)

A del et e expression evaluates to t r ue if the delete succeeded or if the delete had no effect (such as deleting a nonexistent property). del et e also evaluates to t r ue when used (meaninglessly) with an expression that is not a property access expression:

l et   o   =   { x:	1} ;	/ /   o   has   own   pr oper t y   x   and   i nher i t s   pr oper t y t oSt r i ng
del et e   o. x	/ /   =>   t r ue:	del et es   pr oper t y   x
del et e   o. x	/ /   =>   t r ue:	does   not hi ng   ( x   does n' t   exi s t ) but   t r ue   anyway
del et e   o. t oSt r i ng	/ /   =>   t r ue:	does   not hi ng   ( t oSt r i ng   i s n' t   an
own   pr oper t y)
del et e   1	/ /   =>   t r ue:	nons ens e,	but   t r ue   anyway

del et e does not remove properties that have a configurable attribute of f al s e. Certain properties of built-in objects are non-configurable, as are properties of the global object created by variable declaration and function declaration. In strict mode, attempting to delete a non-configurable property causes a TypeError. In non-strict mode, del et e simply evaluates to f al s e in this case:

/ /   I n   s t r i c t   mode,	al l	t hes e   del et i ons   t hr ow  TypeEr r or   i ns t ead of    r et ur ni ng   f al s e
del et e   Obj ec t . pr ot ot ype   / /   =>   f al s e:	pr oper t y   i s   non-c onf i gur abl e
var   x   =   1;	/ /   Dec l ar e   a   gl obal	var i abl e
del et e   gl obal Thi s . x	/ /   =>   f al s e:	c an' t   del et e   t hi s   pr oper t y f unc t i on   f ( )    { }	/ /   Dec l ar e   a   gl obal	f unc t i on
del et e   gl obal Thi s . f	/ /   =>   f al s e:	c an' t   del et e   t hi s   pr oper t y ei t her


When deleting configurable properties of the global object in non-strict mode, you can omit the reference to the global object and simply follow the del et e operator with the property name:


gl obal Thi s . x   =   1;	/ /   Cr eat e   a   c onf i gur abl e   gl obal	pr oper t y ( no   l et   or   var )
del et e   x	/ /   =>   t r ue:	t hi s   pr oper t y   c an   be   del et ed


In strict mode, however, del et e raises a SyntaxError if its operand is an unqualified identifier like x, and you have to be explicit about the property access:

del et e   x;	/ /   Synt axEr r or   i n   s t r i c t   mode del et e   gl obal Thi s . x;	/ /   Thi s   wor ks


6.5 Testing Properties

JavaScript objects can be thought of as sets of properties, and it is often

useful to be able to test for membership in the set—to check whether an object has a property with a given name. You can do this with the i n operator, with the has OwnPr oper t y( )  and
pr oper t yI s Enumer abl e( )  methods, or simply by querying the property. The examples shown here all use strings as property names, but they also work with Symbols (§6.10.3).

The i n operator expects a property name on its left side and an object on its right. It returns t r ue if the object has an own property or an inherited property by that name:

l et   o   =   {    x:	1   } ;

" x"   i n   o " y"   i n   o
" t oSt r i ng"   i n   o

/ /   =>   t r ue:	o   has   an   own   pr oper t y   " x"
/ /   =>   f al s e:    o   does n' t   have   a   pr oper t y   " y" / /   =>   t r ue:    o   i nher i t s   a   t oSt r i ng   pr oper t y



The has OwnPr oper t y( )  method of an object tests whether that object has an own property with the given name. It returns f al s e for inherited properties:

l et   o   =   {    x:	1   } ;
o. has OwnPr oper t y( " x" )	/ /   =>   t r ue:	o   has   an   own   pr oper t y   x o. has OwnPr oper t y( " y" )	/ /   =>   f al s e:    o   does n' t   have   a
pr oper t y   y
o. has OwnPr oper t y( " t oSt r i ng" )    / /   =>   f al s e:	t oSt r i ng   i s   an i nher i t ed   pr oper t y


The pr oper t yI s Enumer abl e( )  refines the has OwnPr oper t y( ) test. It returns t r ue only if the named property is an own property and its enumerable attribute is t r ue. Certain built-in properties are not enumerable. Properties created by normal JavaScript code are enumerable unless you’ve used one of the techniques shown in §14.1 to make them non-enumerable.

l et   o   =   {    x:	1   } ;
o. pr oper t yI s Enumer abl e( " x" )	/ /   =>   t r ue:	o   has   an   own   enumer abl e pr oper t y   x
o. pr oper t yI s Enumer abl e( " t oSt r i ng" )	/ /   =>   f al s e:	not   an   own pr oper t y
Obj ec t . pr ot ot ype. pr oper t yI s Enumer abl e( " t oSt r i ng" )    / /   =>   f al s e: not   enumer abl e


Instead of using the i n operator, it is often sufficient to simply query the property and use ! == to make sure it is not undefined:

l et   o   =   {    x:	1   } ;
o. x   ! ==   undef i ned	/ /   =>   t r ue:	o   has   a   pr oper t y   x
o. y   ! ==   undef i ned	/ /   =>   f al s e:	o   does n' t   have   a   pr oper t y y
o. t oSt r i ng   ! ==   undef i ned   / /   =>   t r ue:	o   i nher i t s   a   t oSt r i ng pr oper t y


There is one thing the i n operator can do that the simple property access technique shown here cannot do. i n can distinguish between properties that do not exist and properties that exist but have been set to
undef i ned. Consider this code:


l et   o   =   {    x:	undef i ned   } ;	/ /   Pr oper t y   i s   expl i c i t l y   s et   t o undef i ned
o. x   ! ==   undef i ned	/ /   =>   f al s e:	pr oper t y   exi s t s   but   i s undef i ned
o. y   ! ==   undef i ned	/ /   =>   f al s e:	pr oper t y   does n' t   even

exi s t
" x"   i n   o	/ / " y"   i n   o	/ / exi s t


=>   t r ue:	t he   pr oper t y   exi s t s =>   f al s e:    t he   pr oper t y   does n' t

del et e   o. x;	/ /   Del et e   t he   pr oper t y   x
" x"   i n   o	/ /   =>   f al s e:	i t   does n' t   exi s t   anymor e


6.6 Enumerating Properties

Instead of testing for the existence of individual properties, we sometimes

want to iterate through or obtain a list of all the properties of an object. There are a few different ways to do this.


The f or / i n loop was covered in §5.4.5. It runs the body of the loop once for each enumerable property (own or inherited) of the specified object, assigning the name of the property to the loop variable. Built-in methods that objects inherit are not enumerable, but the properties that your code adds to objects are enumerable by default. For example:

l et   o   =   { x:	1,	y:	2,	z :	3} ;	/ /   Thr ee   enumer abl e   own pr oper t i es
o. pr oper t yI s Enumer abl e( " t oSt r i ng" )	/ /   =>   f al s e:	not   enumer abl e f or ( l et   p   i n   o)    {	/ /   L oop   t hr ough   t he
pr oper t i es
c ons ol e. l og( p) ;	/ /   Pr i nt s   x,	y,	and   z ,	but not   t oSt r i ng
}


To guard against enumerating inherited properties with f or / i n, you can add an explicit check inside the loop body:

f or ( l et   p   i n   o)    {
i f    ( ! o. has OwnPr oper t y( p) )    c ont i nue;	/ /   Ski p   i nher i t ed pr oper t i es
}

f or ( l et   p   i n   o)    {
i f    ( t ypeof    o[ p]    ===   " f unc t i on" )    c ont i nue;	/ /   Ski p   al l met hods
}


As an alternative to using a f or / i n loop, it is often easier to get an array of property names for an object and then loop through that array with a
f or / of  loop. There are four functions you can use to get an array of property names:

Obj ect . keys ( )  returns an array of the names of the enumerable own properties of an object. It does not include non-enumerable properties, inherited properties, or properties whose name is a Symbol (see §6.10.3).

Obj ect . get OwnPr oper t yNames ( )  works like
Obj ect . keys ( )  but returns an array of the names of non-enumerable own properties as well, as long as their names are strings.

Obj ect . get OwnPr oper t ySymbol s ( )  returns own properties whose names are Symbols, whether or not they are enumerable.

Ref l ect . ownKeys ( )  returns all own property names, both enumerable and non-enumerable, and both string and Symbol. (See §14.6.)

There are examples of the use of Obj ect . keys ( )  with a f or / of  loop in §6.7.


6.6.1 Property Enumeration Order

ES6 formally defines the order in which the own properties of an object are enumerated. Obj ect . keys ( ) ,
Obj ect . get OwnPr oper t yNames ( ) ,
Obj ect . get OwnPr oper t ySymbol s ( ) , Ref l ect . ownKeys ( ) , and related methods such as J SON. s t r i ngi f y( )  all list properties in the following order, subject to their own additional constraints about whether they list non-enumerable properties or properties whose names are strings or Symbols:

String properties whose names are non-negative integers are listed first, in numeric order from smallest to largest. This rule means that arrays and array-like objects will have their properties

enumerated in order.

After all properties that look like array indexes are listed, all remaining properties with string names are listed (including properties that look like negative numbers or floating-point numbers). These properties are listed in the order in which they were added to the object. For properties defined in an object literal, this order is the same order they appear in the literal.

Finally, the properties whose names are Symbol objects are listed in the order in which they were added to the object.

The enumeration order for the f or / i n loop is not as tightly specified as it is for these enumeration functions, but implementations typically enumerate own properties in the order just described, then travel up the prototype chain enumerating properties in the same order for each prototype object. Note, however, that a property will not be enumerated if a property by that same name has already been enumerated, or even if a non-enumerable property by the same name has already been considered.


6.7 Extending Objects

A common operation in JavaScript programs is needing to copy the properties of one object to another object. It is easy to do that with code like this:

l et   t ar get   =   { x:	1} ,	s our c e   =   { y:	2,	z :	3} ; f or ( l et   key   of    Obj ec t . keys ( s our c e) )    {
t ar get [ key]    =   s our c e[ key] ; }
t ar get	/ /   =>   { x:	1,	y:	2,	z :	3}


But because this is a common operation, various JavaScript frameworks have defined utility functions, often named ext end( ) , to perform this

copying operation. Finally, in ES6, this ability comes to the core JavaScript language in the form of Obj ect . as s i gn( ) .


Obj ect . as s i gn( )  expects two or more objects as its arguments. It modifies and returns the first argument, which is the target object, but does not alter the second or any subsequent arguments, which are the source objects. For each source object, it copies the enumerable own properties of that object (including those whose names are Symbols) into the target object. It processes the source objects in argument list order so that properties in the first source object override properties by the same name in the target object and properties in the second source object (if there is one) override properties with the same name in the first source object.

Obj ect . as s i gn( )  copies properties with ordinary property get and set operations, so if a source object has a getter method or the target object has a setter method, they will be invoked during the copy, but they will not themselves be copied.

One reason to assign properties from one object into another is when you have an object that defines default values for many properties and you want to copy those default properties into another object if a property by that name does not already exist in that object. Using
Obj ect . as s i gn( )  naively will not do what you want:


Obj ec t . as s i gn( o,	def aul t s ) ;	/ /   over wr i t es   ever yt hi ng   i n   o   wi t h def aul t s


Instead, what you can do is to create a new object, copy the defaults into it, and then override those defaults with the properties in o:


o   =   Obj ec t . as s i gn( { } ,	def aul t s ,	o) ;

We’ll see in §6.10.4 that you can also express this object copy-and-override operation using the . . .  spread operator like this:


o   =   { . . . def aul t s ,	. . . o} ;


We could also avoid the overhead of the extra object creation and copying by writing a version of Obj ect . as s i gn( )  that copies properties only if they are missing:


/ /   L i ke   Obj ec t . as s i gn( )    but / /   ( and   al s o   does n' t   handl e

does n' t   over r i de   exi s t i ng   pr oper t i es Symbol	pr oper t i es )

f unc t i on   mer ge( t ar get ,    . . . s our c es )    { f or ( l et   s our c e   of    s our c es )    {
f or ( l et   key   of    Obj ec t . keys ( s our c e) )    {
i f    ( ! ( key   i n   t ar get ) )    {    / /   Thi s   i s   di f f er ent   t han Obj ec t . as s i gn( )
t ar get [ key]    =   s our c e[ key] ; }
} }
r et ur n   t ar get ; }
Obj ec t . as s i gn( { x:	1} ,	{ x:	2,	y:	2} ,	{ y:	3,	z :	4} )	/ /   =>   { x:	2, y:	3,	z :	4}
mer ge( { x:	1} ,	{ x:	2,	y:	2} ,	{ y:	3,	z :	4} )	/ /   =>   { x:	1, y:	2,	z :    4}


It is straightforward to write other property manipulation utilities like this mer ge( )  function. A r es t r i ct ( )  function could delete properties of an object if they do not appear in another template object, for example. Or a s ubt r act ( )  function could remove all of the properties of one object from another object.


6.8 Serializing Objects

Object serialization is the process of converting an object’s state to a

string from which it can later be restored. The functions
J SON. s t r i ngi f y( )  and J SON. par s e( )  serialize and restore JavaScript objects. These functions use the JSON data interchange format. JSON stands for “JavaScript Object Notation,” and its syntax is very similar to that of JavaScript object and array literals:

l et   o   =   { x:	1,	y:	{ z :	[ f al s e,	nul l ,	" " ] } } ;	/ /   Def i ne   a   t es t obj ec t
l et   s   =   J SON. s t r i ngi f y( o) ;	/ /   s   ==   ' { " x" : 1, " y" : { " z " : [ f al s e, nul l , " " ] } } '
l et   p   =   J SON. par s e( s ) ;	/ /   p   ==   { x:	1,	y:	{ z :	[ f al s e,	nul l , " " ] } }


JSON syntax is a subset of JavaScript syntax, and it cannot represent all JavaScript values. Objects, arrays, strings, finite numbers, t r ue, f al s e, and nul l  are supported and can be serialized and restored. NaN,
I nf i ni t y, and - I nf i ni t y are serialized to nul l . Date objects are serialized to ISO-formatted date strings (see the Dat e. t oJ SON( ) function), but J SON. par s e( )  leaves these in string form and does not restore the original Date object. Function, RegExp, and Error objects and the undef i ned value cannot be serialized or restored.
J SON. s t r i ngi f y( )  serializes only the enumerable own properties of an object. If a property value cannot be serialized, that property is simply omitted from the stringified output. Both J SON. s t r i ngi f y( )  and
J SON. par s e( )  accept optional second arguments that can be used to customize the serialization and/or restoration process by specifying a list of properties to be serialized, for example, or by converting certain values during the serialization or stringification process. Complete documentation for these functions is in §11.6.


6.9 Object Methods

As discussed earlier, all JavaScript objects (except those explicitly created without a prototype) inherit properties from Obj ect . pr ot ot ype. These inherited properties are primarily methods, and because they are universally available, they are of particular interest to JavaScript programmers. We’ve already seen the has OwnPr oper t y( )  and
pr oper t yI s Enumer abl e( )  methods, for example. (And we’ve also already covered quite a few static functions defined on the Obj ect constructor, such as Obj ect . cr eat e( )  and Obj ect . keys ( ) .) This section explains a handful of universal object methods that are defined on Obj ect . pr ot ot ype, but which are intended to be replaced by other, more specialized implementations. In the sections that follow, we show examples of defining these methods on a single object. In Chapter 9, you’ll learn how to define these methods more generally for an entire class of objects.


6.9.1 The toString() Method

The t oSt r i ng( )  method takes no arguments; it returns a string that somehow represents the value of the object on which it is invoked. JavaScript invokes this method of an object whenever it needs to convert the object to a string. This occurs, for example, when you use the + operator to concatenate a string with an object or when you pass an object to a method that expects a string.

The default t oSt r i ng( )  method is not very informative (though it is useful for determining the class of an object, as we will see in §14.4.3). For example, the following line of code simply evaluates to the string “[object Object]”:

l et   s   =   {    x:	1,	y:	1   } . t oSt r i ng( ) ;	/ /   s   ==   " [ obj ec t   Obj ec t ] "

Because this default method does not display much useful information, many classes define their own versions of t oSt r i ng( ) . For example, when an array is converted to a string, you obtain a list of the array elements, themselves each converted to a string, and when a function is converted to a string, you obtain the source code for the function. You might define your own t oSt r i ng( )  method like this:


l et   poi nt   =   { x:    1, y:    2,
t oSt r i ng:	f unc t i on( )    {    r et ur n   ` ( ${ t hi s . x} ,	${ t hi s . y} ) ` ;	} } ;
St r i ng( poi nt )	/ /   =>   " ( 1,	2) " :	t oSt r i ng( )    i s   us ed   f or   s t r i ng c onver s i ons


6.9.2 The toLocaleString() Method

In addition to the basic t oSt r i ng( )  method, objects all have a t oLocal eSt r i ng( ) . The purpose of this method is to return a localized string representation of the object. The default
t oLocal eSt r i ng( )  method defined by Object doesn’t do any localization itself: it simply calls t oSt r i ng( )  and returns that value. The Date and Number classes define customized versions of
t oLocal eSt r i ng( )  that attempt to format numbers, dates, and times according to local conventions. Array defines a t oLocal eSt r i ng( ) method that works like t oSt r i ng( )  except that it formats array elements by calling their t oLocal eSt r i ng( )  methods instead of their t oSt r i ng( )  methods. You might do the same thing with a poi nt object like this:

l et   poi nt   =   { x:	1000, y:	2000,

t oSt r i ng:	f unc t i on( )    {    r et ur n   ` ( ${ t hi s . x} ,	${ t hi s . y} ) ` ;	} , t oL oc al eSt r i ng:	f unc t i on( )    {
r et ur n   ` ( ${ t hi s . x. t oL oc al eSt r i ng( ) } , ${ t hi s . y. t oL oc al eSt r i ng( ) } ) ` ;
} } ;
poi nt . t oSt r i ng( )	/ /   =>   " ( 1000,	2000) "
poi nt . t oL oc al eSt r i ng( )	/ /   =>   " ( 1, 000,	2, 000) " :	not e   t hous ands s epar at or s


The internationalization classes documented in §11.7 can be useful when implementing a t oLocal eSt r i ng( )  method.


6.9.3 The valueOf() Method

The val ueOf ( )  method is much like the t oSt r i ng( )  method, but it is called when JavaScript needs to convert an object to some primitive type other than a string—typically, a number. JavaScript calls this method automatically if an object is used in a context where a primitive value is required. The default val ueOf ( )  method does nothing interesting, but some of the built-in classes define their own val ueOf ( )  method. The Date class defines val ueOf ( )  to convert dates to numbers, and this allows Date objects to be chronologically compared with < and >. You could do something similar with a point object, defining a val ueOf ( ) method that returns the distance from the origin to the point:

l et   poi nt   =   { x:    3, y:    4,
val ueOf :	f unc t i on( )    {    r et ur n   Mat h. hypot ( t hi s . x,	t hi s . y) ;	} } ;
Number ( poi nt )	/ /   =>   5:	val ueOf ( )    i s   us ed   f or   c onver s i ons   t o

number s poi nt   >   4 poi nt   >   5 poi nt   <   6


/ /   =>   t r ue / /   =>   f al s e / /   =>   t r ue

6.9.4 The toJ SON() Method

Obj ect . pr ot ot ype does not actually define a t oJ SON( )  method, but the J SON. s t r i ngi f y( )  method (see §6.8) looks for a t oJ SON( ) method on any object it is asked to serialize. If this method exists on the object to be serialized, it is invoked, and the return value is serialized, instead of the original object. The Date class (§11.4) defines a t oJ SON( ) method that returns a serializable string representation of the date. We could do the same for our Point object like this:

l et   poi nt   =   { x:    1, y:    2,
t oSt r i ng:	f unc t i on( )    {    r et ur n   ` ( ${ t hi s . x} ,	${ t hi s . y} ) ` ;	} , t oJ SON:	f unc t i on( )    {    r et ur n   t hi s . t oSt r i ng( ) ;	}
} ;
J SON. s t r i ngi f y( [ poi nt ] )	/ /   =>   ' [ " ( 1,	2) " ] '



6.10 Extended Object Literal Syntax

Recent versions of JavaScript have extended the syntax for object literals in a number of useful ways. The following subsections explain these extensions.


6.10.1 Shorthand Properties

Suppose you have values stored in variables x and y and want to create an object with properties named x and y that hold those values. With basic object literal syntax, you’d end up repeating each identifier twice:

l et   x   =   1,	y   =   2; l et   o   =   {
x:	x, y:	y

} ;


In ES6 and later, you can drop the colon and one copy of the identifier and end up with much simpler code:

l et   x   =   1,    y   =   2; l et   o   =   {    x,    y   } ;
o. x   +   o. y	/ /   =>   3


6.10.2 Computed Property Names

Sometimes you need to create an object with a specific property, but the name of that property is not a compile-time constant that you can type literally in your source code. Instead, the property name you need is stored in a variable or is the return value of a function that you invoke. You can’t use a basic object literal for this kind of property. Instead, you have to create an object and then add the desired properties as an extra step:

c ons t   PROPERTY_NAME   =   " p1" ;
f unc t i on   c omput ePr oper t yName( )    {    r et ur n   " p"   +   2;	}

l et   o   =   { } ;
o[ PROPERTY_NAME]    =   1;
o[ c omput ePr oper t yName( ) ]    =   2;


It is much simpler to set up an object like this with an ES6 feature known as computed properties that lets you take the square brackets from the preceding code and move them directly into the object literal:

c ons t   PROPERTY_NAME   =   " p1" ;
f unc t i on   c omput ePr oper t yName( )    {    r et ur n   " p"   +   2;	}

l et   p   =   {
[ PROPERTY_NAME] :	1,
[ c omput ePr oper t yName( ) ] :	2 } ;


p. p1   +   p. p2   / /   =>   3


With this new syntax, the square brackets delimit an arbitrary JavaScript expression. That expression is evaluated, and the resulting value (converted to a string, if necessary) is used as the property name.


One situation where you might want to use computed properties is when you have a library of JavaScript code that expects to be passed objects with a particular set of properties, and the names of those properties are defined as constants in that library. If you are writing code to create the objects that will be passed to that library, you could hardcode the property names, but you’d risk bugs if you type the property name wrong anywhere, and you’d risk version mismatch issues if a new version of the library changes the required property names. Instead, you might find that it makes your code more robust to use computed property syntax with the property name constants defined by the library.


6.10.3 Symbols as Property Names

The computed property syntax enables one other very important object literal feature. In ES6 and later, property names can be strings or symbols. If you assign a symbol to a variable or constant, then you can use that symbol as a property name using the computed property syntax:

c ons t   ext ens i on   =   Symbol ( " my   ext ens i on   s ymbol " ) ; l et   o   =   {
[ ext ens i on] :	{    / *   ext ens i on   dat a   s t or ed   i n   t hi s   obj ec t   */   } } ;
o[ ext ens i on] . x   =   0;	/ /   Thi s   won' t   c onf l i c t   wi t h   ot her   pr oper t i es of    o


As explained in §3.6, Symbols are opaque values. You can’t do anything

with them other than use them as property names. Every Symbol is different from every other Symbol, however, which means that Symbols are good for creating unique property names. Create a new Symbol by calling the Symbol ( )  factory function. (Symbols are primitive values, not objects, so Symbol ( )  is not a constructor function that you invoke with new.) The value returned by Symbol ( )  is not equal to any other Symbol or other value. You can pass a string to Symbol ( ) , and this string is used when your Symbol is converted to a string. But this is a debugging aid only: two Symbols created with the same string argument are still different from one another.

The point of Symbols is not security, but to define a safe extension mechanism for JavaScript objects. If you get an object from third-party code that you do not control and need to add some of your own properties to that object but want to be sure that your properties will not conflict with any properties that may already exist on the object, you can safely use Symbols as your property names. If you do this, you can also be confident that the third-party code will not accidentally alter your symbolically named properties. (That third-party code could, of course, use
Obj ect . get OwnPr oper t ySymbol s ( )  to discover the Symbols you’re using and could then alter or delete your properties. This is why Symbols are not a security mechanism.)


6.10.4 Spread Operator

In ES2018 and later, you can copy the properties of an existing object into a new object using the “spread operator” . . .  inside an object literal:


l et   pos i t i on   =   {    x:	0,	y:	0   } ;
l et   di mens i ons   =   {    wi dt h:	100,	hei ght :	75   } ; l et   r ec t   =   {    . . . pos i t i on,	. . . di mens i ons   } ;

r ec t . x   +   r ec t . y   +   r ec t . wi dt h   +   r ec t . hei ght   / /   =>   175


In this code, the properties of the pos i t i on and di mens i ons  objects are “spread out” into the r ect  object literal as if they had been written literally inside those curly braces. Note that this . . .  syntax is often called a spread operator but is not a true JavaScript operator in any sense. Instead, it is a special-case syntax available only within object literals. (Three dots are used for other purposes in other JavaScript contexts, but object literals are the only context where the three dots cause this kind of interpolation of one object into another one.)

If the object that is spread and the object it is being spread into both have a property with the same name, then the value of that property will be the one that comes last:

l et   o   =   {    x:	1   } ;
l et   p   =   {    x:	0,	. . . o   } ;
p. x	/ /   =>   1:	t he   val ue   f r om obj ec t   o   over r i des   t he   i ni t i al val ue
l et   q   =   {    . . . o,	x:	2   } ;
q. x	/ /   =>   2:	t he   val ue   2   over r i des   t he   pr evi ous   val ue   f r om o.


Also note that the spread operator only spreads the own properties of an object, not any inherited ones:

l et   o   =   Obj ec t . c r eat e( { x:	1} ) ;	/ /   o   i nher i t s   t he   pr oper t y   x l et   p   =   {    . . . o   } ;
p. x	/ /   =>   undef i ned


Finally, it is worth noting that, although the spread operator is just three little dots in your code, it can represent a substantial amount of work to the JavaScript interpreter. If an object has n properties, the process of spreading those properties into another object is likely to be an O(n)

operation. This means that if you find yourself using . . .  within a loop or recursive function as a way to accumulate data into one large object, you may be writing an inefficient O(n2) algorithm that will not scale well as n gets larger.


6.10.5 Shorthand Methods

When a function is defined as a property of an object, we call that function a method (we’ll have a lot more to say about methods in Chapters 8 and 9). Prior to ES6, you would define a method in an object literal using a function definition expression just as you would define any other property of an object:

l et   s quar e   =   {
ar ea:	f unc t i on( )    {    r et ur n   t hi s . s i de   *   t hi s . s i de;	} , s i de:	10
} ;
s quar e. ar ea( )    / /   =>   100


In ES6, however, the object literal syntax (and also the class definition syntax we’ll see in Chapter 9) has been extended to allow a shortcut where the f unct i on keyword and the colon are omitted, resulting in code like this:


l et   s quar e
ar ea( )

=   {
{    r et ur n   t hi s . s i de   *   t hi s . s i de;	} ,

s i de:	10 } ;
s quar e. ar ea( )    / /   =>   100


Both forms of the code are equivalent: both add a property named ar ea to the object literal, and both set the value of that property to the specified function. The shorthand syntax makes it clearer that ar ea( )  is a method and not a data property like s i de.

When you write a method using this shorthand syntax, the property name can take any of the forms that are legal in an object literal: in addition to a regular JavaScript identifier like the name ar ea above, you can also use string literals and computed property names, which can include Symbol property names:

c ons t   METHOD_NAME   =   " m" ; c ons t   s ymbol	=   Symbol ( ) ; l et   wei r dMet hods   =   {
" met hod   Wi t h   Spac es " ( x)    {    r et ur n   x   +   1;	} , [ METHOD_NAME] ( x)    {    r et ur n   x   +   2;	} ,
[ s ymbol ] ( x)    {    r et ur n   x   +   3;	} } ;
wei r dMet hods [ " met hod   Wi t h   Spac es " ] ( 1)	/ /   =>   2 wei r dMet hods [ METHOD_NAME] ( 1)	/ /   =>   3 wei r dMet hods [ s ymbol ] ( 1)	/ /   =>   4


Using a Symbol as a method name is not as strange as it seems. In order to make an object iterable (so it can be used with a f or / of  loop), you must define a method with the symbolic name Symbol . i t er at or , and there are examples of doing exactly that in Chapter 12.


6.10.6 Property Getters and Setters

All of the object properties we’ve discussed so far in this chapter have been data properties with a name and an ordinary value. JavaScript also supports accessor properties, which do not have a single value but instead have one or two accessor methods: a getter and/or a setter.


When a program queries the value of an accessor property, JavaScript invokes the getter method (passing no arguments). The return value of this method becomes the value of the property access expression. When a program sets the value of an accessor property, JavaScript invokes the

setter method, passing the value of the righthand side of the assignment. This method is responsible for “setting,” in some sense, the property value. The return value of the setter method is ignored.


If a property has both a getter and a setter method, it is a read/write property. If it has only a getter method, it is a read-only property. And if it has only a setter method, it is a write-only property (something that is not possible with data properties), and attempts to read it always evaluate to undef i ned.


Accessor properties can be defined with an extension to the object literal syntax (unlike the other ES6 extensions we’ve seen here, getters and setters were introduced in ES5):

l et   o   =   {
/ /   An   or di nar y   dat a   pr oper t y dat aPr op:	val ue,

/ /   An   ac c es s or   pr oper t y   def i ned   as   a   pai r   of    f unc t i ons . get   ac c es s or Pr op( )    {    r et ur n   t hi s . dat aPr op;	} ,
s et   ac c es s or Pr op( val ue)    {    t hi s . dat aPr op   =   val ue;	} } ;


Accessor properties are defined as one or two methods whose name is the same as the property name. These look like ordinary methods defined using the ES6 shorthand except that getter and setter definitions are prefixed with get  or s et . (In ES6, you can also use computed property names when defining getters and setters. Simply replace the property name after get  or s et  with an expression in square brackets.)


The accessor methods defined above simply get and set the value of a data property, and there is no reason to prefer the accessor property over the data property. But as a more interesting example, consider the following

object that represents a 2D Cartesian point. It has ordinary data properties to represent the x and y coordinates of the point, and it has accessor properties that give the equivalent polar coordinates of the point:

l et   p   =   {
/ /   x   and   y   ar e   r egul ar   r ead- wr i t e   dat a   pr oper t i es . x:	1. 0,
y:	1. 0,

/ /   r   i s   a   r ead- wr i t e   ac c es s or   pr oper t y   wi t h   get t er   and s et t er .
/ /   Don' t   f or get   t o   put   a   c omma   af t er   ac c es s or   met hods . get   r ( )    {    r et ur n   Mat h. hypot ( t hi s . x,	t hi s . y) ;	} ,
s et   r ( newval ue)    {
l et   ol dval ue   =   Mat h. hypot ( t hi s . x,	t hi s . y) ; l et   r at i o   =   newval ue/ ol dval ue;
t hi s . x   *=   r at i o; t hi s . y   *=   r at i o;
} ,

/ /   t het a   i s   a   r ead- onl y   ac c es s or   pr oper t y   wi t h   get t er   onl y. get   t het a( )    {    r et ur n   Mat h. at an2( t hi s . y,	t hi s . x) ;	}
} ;
p. r	/ /   =>   Mat h. SQRT2 p. t het a   / /   =>   Mat h. PI	/   4


Note the use of the keyword t hi s  in the getters and setter in this example. JavaScript invokes these functions as methods of the object on which they are defined, which means that within the body of the function, t hi s  refers to the point object p. So the getter method for the r  property can refer to the x and y properties as t hi s . x and t hi s . y. Methods and the t hi s  keyword are covered in more detail in §8.2.2.


Accessor properties are inherited, just as data properties are, so you can use the object p defined above as a prototype for other points. You can give the new objects their own x and y properties, and they’ll inherit the r

and t het a properties:


l et   q   =   Obj ec t . c r eat e( p) ;	/ /   A  new  obj ec t   t hat   i nher i t s   get t er s and   s et t er s
q. x   =   3;	q. y   =   4;	/ /   Cr eat e   q' s   own   dat a   pr oper t i es q. r                                                               / /   =>   5:	t he   i nher i t ed   ac c es s or
pr oper t i es   wor k
q. t het a	/ /   =>   Mat h. at an2( 4,	3)


The code above uses accessor properties to define an API that provides two representations (Cartesian coordinates and polar coordinates) of a single set of data. Other reasons to use accessor properties include sanity checking of property writes and returning different values on each property read:

/ /   Thi s   obj ec t   gener at es   s t r i c t l y   i nc r eas i ng   s er i al	number s c ons t   s er i al num =   {

/ /   Thi s   dat a   pr oper t y   hol ds   t he   next   s er i al / /   The   _   i n   t he   pr oper t y   name   hi nt s   t hat   i t
us e   onl y.

number .
i s   f or   i nt er nal

_n:	0,

/ /   Ret ur n   t he   c ur r ent   val ue   and   i nc r ement   i t get   next ( )    {    r et ur n   t hi s . _n++;	} ,

/ /   Set   a   new  val ue   of    n,	but   onl y   i f    i t   i s   l ar ger   t han c ur r ent
s et   next ( n)    {
i f    ( n   >   t hi s . _n)    t hi s . _n   =   n;
el s e   t hr ow  new  Er r or ( " s er i al	number   c an   onl y   be   s et   t o   a l ar ger   val ue" ) ;
} } ;
s er i al num. next   =   10;	/ /   Set   t he   s t ar t i ng   s er i al	number

s er i al num. next
s er i al num. next

/ /   =>   10
/ /   =>   11:	di f f er ent   val ue   eac h   t i me   we

get   next


Finally, here is one more example that uses a getter method to implement a

property with “magical” behavior:


/ /   Thi s   obj ec t   has   ac c es s or   pr oper t i es   t hat   r et ur n   r andom number s .
/ /   The   expr es s i on   " r andom. oc t et " ,	f or   exampl e,	yi el ds   a   r andom number
/ /   bet ween   0   and   255   eac h   t i me   i t   i s   eval uat ed. c ons t   r andom =   {
get   oc t et ( )    {    r et ur n   Mat h. f l oor ( Mat h. r andom( ) *256) ;	} ,
get   ui nt 16( )    {    r et ur n   Mat h. f l oor ( Mat h. r andom( ) *65536) ;	} , get   i nt 16( )    {    r et ur n   Mat h. f l oor ( Mat h. r andom( ) *65536) - 32768;
}
} ;



6.11 Summary

This chapter has documented JavaScript objects in great detail, covering topics that include:

Basic object terminology, including the meaning of terms like enumerable and own property.

Object literal syntax, including the many new features in ES6 and later.

How to read, write, delete, enumerate, and check for the presence of the properties of an object.

How prototype-based inheritance works in JavaScript and how to create an object that inherits from another object with
Obj ect . cr eat e( ) .

How to copy properties from one object into another with Obj ect . as s i gn( ) .

All JavaScript values that are not primitive values are objects. This includes both arrays and functions, which are the topics of the next two chapters.




1

Remember; almost all objects have a prototype but most do not have a property named pr ot ot ype. JavaScript inheritance works even if you can’t access the prototype object directly. But see §14.3 if you want to learn how to do that.



Chapter 7. Arrays




This chapter documents arrays, a fundamental datatype in JavaScript and in most other programming languages. An array is an ordered collection of values. Each value is called an element, and each element has a numeric position in the array, known as its index. JavaScript arrays are untyped: an array element may be of any type, and different elements of the same array may be of different types. Array elements may even be objects or other arrays, which allows you to create complex data structures, such as arrays of objects and arrays of arrays. JavaScript arrays are zero-based and use 32-bit indexes: the index of the first element is 0, and the highest possible index is 4294967294 (232−2), for a maximum array size of 4,294,967,295 elements. JavaScript arrays are dynamic: they grow or shrink as needed, and there is no need to declare a fixed size for the array when you create it or to reallocate it when the size changes. JavaScript arrays may be sparse: the elements need not have contiguous indexes, and there may be gaps. Every JavaScript array has a l engt h property. For nonsparse arrays, this property specifies the number of elements in the array. For sparse arrays,
l engt h is larger than the highest index of any element.


JavaScript arrays are a specialized form of JavaScript object, and array indexes are really little more than property names that happen to be integers. We’ll talk more about the specializations of arrays elsewhere in this chapter. Implementations typically optimize arrays so that access to numerically indexed array elements is generally significantly faster than access to regular object properties.

Arrays inherit properties from Ar r ay. pr ot ot ype, which defines a rich set of array manipulation methods, covered in §7.8. Most of these methods are generic, which means that they work correctly not only for true arrays, but for any “array-like object.” We’ll discuss array-like objects in §7.9. Finally, JavaScript strings behave like arrays of characters, and we’ll discuss this in §7.10.

ES6 introduces a set of new array classes known collectively as “typed arrays.” Unlike regular JavaScript arrays, typed arrays have a fixed length and a fixed numeric element type. They offer high performance and byte-level access to binary data and are covered in §11.2.


7.1 Creating Arrays

There are several ways to create arrays. The subsections that follow explain how to create arrays with:

Array literals

The . . .  spread operator on an iterable object

The Ar r ay( )  constructor

The Ar r ay. of ( )  and Ar r ay. f r om( )  factory methods


7.1.1 Array Literals

By far the simplest way to create an array is with an array literal, which is simply a comma-separated list of array elements within square brackets. For example:

l et   empt y   =   [ ] ;	/ /   An   ar r ay   wi t h   no   el ement s l et   pr i mes   =   [ 2,    3,    5,    7,    11] ;	/ /   An   ar r ay   wi t h   5   numer i c
el ement s

l et   mi s c   =   [    1. 1,	t r ue,	" a" ,	] ;	/ /   3   el ement s   of    var i ous   t ypes   + t r ai l i ng   c omma


The values in an array literal need not be constants; they may be arbitrary expressions:

l et   bas e   =   1024;
l et   t abl e   =   [ bas e,	bas e+1,	bas e+2,	bas e+3] ;


Array literals can contain object literals or other array literals:


l et   b   =   [ [ 1,	{ x:	1,	y:	2} ] ,	[ 2,	{ x:	3,	y:	4} ] ] ;


If an array literal contains multiple commas in a row, with no value between, the array is sparse (see §7.3). Array elements for which values are omitted do not exist but appear to be undef i ned if you query them:


l et   c ount   =   [ 1, , 3] ;	/ /   El ement s   at   i ndexes   0   and   2.	No   el ement at   i ndex   1
l et   undef s   =   [ , , ] ;	/ /   An   ar r ay   wi t h   no   el ement s   but   a   l engt h   of 2


Array literal syntax allows an optional trailing comma, so [ , , ]  has a length of 2, not 3.


7.1.2 The Spread Operator

In ES6 and later, you can use the “spread operator,” . . . , to include the elements of one array within an array literal:

l et   a   =   [ 1,	2,	3] ;
l et   b   =   [ 0,	. . . a,	4] ;	/ /   b   ==   [ 0,	1,	2,	3,	4]


The three dots “spread” the array a so that its elements become elements within the array literal that is being created. It is as if the . . . a was

replaced by the elements of the array a, listed literally as part of the enclosing array literal. (Note that, although we call these three dots a spread operator, this is not a true operator because it can only be used in array literals and, as we’ll see later in the book, function invocations.)

The spread operator is a convenient way to create a (shallow) copy of an array:

l et   or i gi nal	=   [ 1, 2, 3] ;
l et   c opy   =   [ . . . or i gi nal ] ;
c opy[ 0]    =   0;	/ /   Modi f yi ng   t he   c opy   does   not   c hange   t he   or i gi nal or i gi nal [ 0]	/ /   =>   1


The spread operator works on any iterable object. (Iterable objects are what the f or / of  loop iterates over; we first saw them in §5.4.4, and we’ll see much more about them in Chapter 12.) Strings are iterable, so you can use a spread operator to turn any string into an array of single-character strings:

l et   di gi t s   =   [ . . . " 0123456789ABCDEF" ] ; di gi t s   / /   =>
[ " 0" , " 1" , " 2" , " 3" , " 4" , " 5" , " 6" , " 7" , " 8" , " 9" , " A" , " B" , " C" , " D" , " E" , " F" ]


Set objects (§11.1.1) are iterable, so an easy way to remove duplicate elements from an array is to convert the array to a set and then immediately convert the set back to an array using the spread operator:

l et   l et t er s   =   [ . . . " hel l o   wor l d" ] ;
[ . . . new  Set ( l et t er s ) ]	/ /   =>   [ " h" , " e" , " l " , " o" , "   " , " w" , " r " , " d" ]


7.1.3 The Array() Constructor

Another way to create an array is with the Ar r ay( )  constructor. You can

invoke this constructor in three distinct ways:


Call it with no arguments:


l et   a   =   new Ar r ay( ) ;


This method creates an empty array with no elements and is equivalent to the array literal [ ] .

Call it with a single numeric argument, which specifies a length:


l et   a   =   new Ar r ay( 10) ;


This technique creates an array with the specified length. This form of the Ar r ay( )  constructor can be used to preallocate an array when you know in advance how many elements will be required. Note that no values are stored in the array, and the array index properties “0”, “1”, and so on are not even defined for the array.

Explicitly specify two or more array elements or a single non-numeric element for the array:


l et   a   =   new Ar r ay( 5,	4,	3,	2,	1,	" t es t i ng, t es t i ng" ) ;

In this form, the constructor arguments become the elements of the new array. Using an array literal is almost always simpler than this usage of the Ar r ay( )  constructor.


7.1.4 Array.of()

When the Ar r ay( )  constructor function is invoked with one numeric argument, it uses that argument as an array length. But when invoked with more than one numeric argument, it treats those arguments as elements for

the array to be created. This means that the Ar r ay( )  constructor cannot be used to create an array with a single numeric element.

In ES6, the Ar r ay. of ( )  function addresses this problem: it is a factory method that creates and returns a new array, using its argument values (regardless of how many of them there are) as the array elements:

Ar r ay. of ( )	/ /   =>   [ ] ;	r et ur ns   empt y   ar r ay   wi t h   no ar gument s
Ar r ay. of ( 10)	/ /   =>   [ 10] ;	c an   c r eat e   ar r ays   wi t h   a   s i ngl e numer i c   ar gument
Ar r ay. of ( 1, 2, 3)	/ /   =>   [ 1,	2,	3]


7.1.5 Array.from()

Ar r ay. f r omis another array factory method introduced in ES6. It expects an iterable or array-like object as its first argument and returns a new array that contains the elements of that object. With an iterable argument, Ar r ay. f r om( i t er abl e)  works like the spread operator [ . . . i t er abl e]  does. It is also a simple way to make a copy of an array:

l et   c opy   =   Ar r ay. f r om( or i gi nal ) ;


Ar r ay. f r om( )  is also important because it defines a way to make a true-array copy of an array-like object. Array-like objects are non-array objects that have a numeric length property and have values stored with properties whose names happen to be integers. When working with client-side JavaScript, the return values of some web browser methods are array-like, and it can be easier to work with them if you first convert them to true arrays:

l et   t r uear r ay   =   Ar r ay. f r om( ar r ayl i ke) ;

Ar r ay. f r om( )  also accepts an optional second argument. If you pass a function as the second argument, then as the new array is being built, each element from the source object will be passed to the function you specify, and the return value of the function will be stored in the array instead of the original value. (This is very much like the array map( )  method that will be introduced later in the chapter, but it is more efficient to perform the mapping while the array is being built than it is to build the array and then map it to another new array.)


7.2 Reading and Writing Array Elements

You access an element of an array using the [ ]  operator. A reference to the array should appear to the left of the brackets. An arbitrary expression that has a non-negative integer value should be inside the brackets. You can use this syntax to both read and write the value of an element of an array. Thus, the following are all legal JavaScript statements:

l et   a   =   [ " wor l d" ] ;	/ /   St ar t   wi t h   a   one- el ement   ar r ay l et   val ue   =   a[ 0] ;	/ /   Read   el ement   0
a[ 1]    =   3. 14;	/ /   Wr i t e   el ement   1 l et   i	=   2;
a[ i ]    =   3;                                       / /   Wr i t e   el ement   2 a[ i    +   1]    =   " hel l o" ;            / /   Wr i t e   el ement   3
a[ a[ i ] ]    =   a[ 0] ;	/ /   Read   el ement s   0   and   2,	wr i t e   el ement   3


What is special about arrays is that when you use property names that are non-negative integers less than 232–1, the array automatically maintains the value of the l engt h property for you. In the preceding, for example, we created an array a with a single element. We then assigned values at indexes 1, 2, and 3. The l engt h property of the array changed as we did, so:

a. l engt h	/ /   =>   4


Remember that arrays are a specialized kind of object. The square brackets used to access array elements work just like the square brackets used to access object properties. JavaScript converts the numeric array index you specify to a string—the index 1 becomes the string " 1" —then uses that string as a property name. There is nothing special about the conversion of the index from a number to a string: you can do that with regular objects, too:

l et   o   =   { } ;	/ /   Cr eat e   a   pl ai n   obj ec t
o[ 1]    =   " one" ;	/ /   I ndex   i t   wi t h   an   i nt eger
o[ " 1" ]	/ /   =>   " one" ;	numer i c   and   s t r i ng   pr oper t y   names ar e   t he   s ame


It is helpful to clearly distinguish an array index from an object property name. All indexes are property names, but only property names that are integers between 0 and 232–2 are indexes. All arrays are objects, and you can create properties of any name on them. If you use properties that are array indexes, however, arrays have the special behavior of updating their l engt h property as needed.


Note that you can index an array using numbers that are negative or that are not integers. When you do this, the number is converted to a string, and that string is used as the property name. Since the name is not a non-negative integer, it is treated as a regular object property, not an array index. Also, if you index an array with a string that happens to be a non-negative integer, it behaves as an array index, not an object property. The same is true if you use a floating-point number that is the same as an integer:

a[ - 1. 23]    =   t r ue;	/ /   Thi s   c r eat es   a   pr oper t y   named   " - 1. 23"

a[ " 1000" ]    =   0;	/ /   Thi s   t he   1001s t   el ement   of    t he   ar r ay a[ 1. 000]    =   1;	/ /   Ar r ay   i ndex   1.	Same   as   a[ 1]    =   1;


The fact that array indexes are simply a special type of object property name means that JavaScript arrays have no notion of an “out of bounds” error. When you try to query a nonexistent property of any object, you don’t get an error; you simply get undef i ned. This is just as true for arrays as it is for objects:

l et   a   =   [ t r ue,	f al s e] ;	/ /   Thi s   ar r ay   has   el ement s   at   i ndexes   0 and   1
a[ 2]	/ /   =>   undef i ned;	no   el ement   at   t hi s i ndex.
a[ - 1]	/ /   =>   undef i ned;	no   pr oper t y   wi t h   t hi s name.


7.3 Sparse Arrays

A sparse array is one in which the elements do not have contiguous indexes starting at 0. Normally, the l engt h property of an array specifies the number of elements in the array. If the array is sparse, the value of the l engt h property is greater than the number of elements. Sparse arrays
can be created with the Ar r ay( )  constructor or simply by assigning to an array index larger than the current array l engt h.

l et   a   =   new  Ar r ay( 5) ;	/ /   No   el ement s ,	but   a. l engt h   i s   5.
a   =   [ ] ;	/ /   Cr eat e   an   ar r ay   wi t h   no   el ement s   and l engt h   =   0.
a[ 1000]    =   0;	/ /   As s i gnment   adds   one   el ement   but   s et s l engt h   t o   1001.


We’ll see later that you can also make an array sparse with the del et e operator.

Arrays that are sufficiently sparse are typically implemented in a slower, more memory-efficient way than dense arrays are, and looking up elements in such an array will take about as much time as regular object property lookup.


Note that when you omit a value in an array literal (using repeated commas as in [ 1, , 3] ), the resulting array is sparse, and the omitted elements simply do not exist:

l et   a1   =   [ , ] ;	/ /   Thi s   ar r ay   has   no   el ement s   and   l engt h 1
l et   a2   =   [ undef i ned] ;	/ /   Thi s   ar r ay   has   one   undef i ned   el ement

0   i n   a1 i ndex   0 0   i n   a2
at   i ndex   0

/ /   =>   f al s e:	a1   has   no

/ /   =>   t r ue:	a2   has   t he

el ement   wi t h

undef i ned   val ue



Understanding sparse arrays is an important part of understanding the true nature of JavaScript arrays. In practice, however, most JavaScript arrays you will work with will not be sparse. And, if you do have to work with a sparse array, your code will probably treat it just as it would treat a nonsparse array with undef i ned elements.


7.4 Array Length

Every array has a l engt h property, and it is this property that makes arrays different from regular JavaScript objects. For arrays that are dense (i.e., not sparse), the l engt h property specifies the number of elements in the array. Its value is one more than the highest index in the array:

[ ] . l engt h	/ /   =>   0:	t he   ar r ay   has   no   el ement s
[ " a" , " b" , " c " ] . l engt h	/ /   =>   3:	hi ghes t   i ndex   i s   2,	l engt h   i s   3

When an array is sparse, the l engt h property is greater than the number of elements, and all we can say about it is that l engt h is guaranteed to be larger than the index of every element in the array. Or, put another way, an array (sparse or not) will never have an element whose index is greater than or equal to its l engt h. In order to maintain this invariant, arrays have two special behaviors. The first we described above: if you assign a value to an array element whose index i  is greater than or equal to the array’s current l engt h, the value of the l engt h property is set to i +1.


The second special behavior that arrays implement in order to maintain the length invariant is that, if you set the l engt h property to a non-negative integer n smaller than its current value, any array elements whose index is greater than or equal to n are deleted from the array:

a   =   [ 1, 2, 3, 4, 5] ;	/ /   St ar t   wi t h   a   5- el ement   ar r ay. a. l engt h   =   3;	/ /   a   i s   now  [ 1, 2, 3] .
a. l engt h   =   0;	/ /   Del et e   al l	el ement s .	a   i s   [ ] .
a. l engt h   =   5;	/ /   L engt h   i s   5,	but   no   el ement s ,	l i ke   new Ar r ay( 5)


You can also set the l engt h property of an array to a value larger than its current value. Doing this does not actually add any new elements to the array; it simply creates a sparse area at the end of the array.


7.5 Adding and Deleting Array Elements

We’ve already seen the simplest way to add elements to an array: just assign values to new indexes:

l et   a   =   [ ] ;	/ /   St ar t   wi t h   an   empt y   ar r ay. a[ 0]    =   " z er o" ;	/ /   And   add   el ement s   t o   i t .
a[ 1]    =   " one" ;

You can also use the pus h( )  method to add one or more values to the end of an array:

l et   a   =   [ ] ;	/ /   St ar t   wi t h   an   empt y   ar r ay
a. pus h( " z er o" ) ;	/ /   Add   a   val ue   at   t he   end.	a   =   [ " z er o" ] a. pus h( " one" ,	" t wo" ) ;	/ /   Add   t wo   mor e   val ues .	a   =   [ " z er o" ,
" one" ,	" t wo" ]


Pushing a value onto an array a is the same as assigning the value to a[ a. l engt h] . You can use the uns hi f t ( )  method (described in §7.8) to insert a value at the beginning of an array, shifting the existing
array elements to higher indexes. The pop( )  method is the opposite of pus h( ) : it removes the last element of the array and returns it, reducing the length of an array by 1. Similarly, the s hi f t ( )  method removes and returns the first element of the array, reducing the length by 1 and shifting all elements down to an index one lower than their current index. See §7.8 for more on these methods.

You can delete array elements with the del et e operator, just as you can delete object properties:

l et   a   =   [ 1, 2, 3] ;
del et e   a[ 2] ;	/ /   a   now  has   no   el ement   at   i ndex   2
2   i n   a	/ /   =>   f al s e:	no   ar r ay   i ndex   2   i s   def i ned
a. l engt h	/ /   =>   3:	del et e   does   not   af f ec t   ar r ay   l engt h


Deleting an array element is similar to (but subtly different than) assigning undef i ned to that element. Note that using del et e on an array element does not alter the l engt h property and does not shift elements with higher indexes down to fill in the gap that is left by the deleted property. If you delete an element from an array, the array becomes sparse.

As we saw above, you can also remove elements from the end of an array

simply by setting the l engt h property to the new desired length.


Finally, s pl i ce( )  is the general-purpose method for inserting, deleting, or replacing array elements. It alters the l engt h property and shifts array elements to higher or lower indexes as needed. See §7.8 for details.


7.6 Iterating Arrays

As of ES6, the easiest way to loop through each of the elements of an array (or any iterable object) is with the f or / of  loop, which was covered in detail in §5.4.4:

l et   l et t er s   =   [ . . . " Hel l o   wor l d" ] ;	/ /   An   ar r ay   of    l et t er s l et   s t r i ng   =   " " ;
f or ( l et   l et t er   of    l et t er s )    { s t r i ng   +=   l et t er ;
}
s t r i ng	/ /   =>   " Hel l o   wor l d" ;	we   r eas s embl ed   t he   or i gi nal	t ext


The built-in array iterator that the f or / of  loop uses returns the elements of an array in ascending order. It has no special behavior for sparse arrays and simply returns undef i ned for any array elements that do not exist.


If you want to use a f or / of  loop for an array and need to know the index of each array element, use the ent r i es ( )  method of the array, along with destructuring assignment, like this:

l et   ever yot her   =   " " ;
f or ( l et   [ i ndex,	l et t er ]    of    l et t er s . ent r i es ( ) )    {
i f    ( i ndex   %  2   ===   0)    ever yot her   +=   l et t er ;	/ /   l et t er s   at even   i ndexes
}
ever yot her	/ /   =>   " Hl owr d"

Another good way to iterate arrays is with f or Each( ) . This is not a new form of the f or  loop, but an array method that offers a functional approach to array iteration. You pass a function to the f or Each( ) method of an array, and f or Each( )  invokes your function once on each element of the array:

l et   upper c as e   =   " " ;
l et t er s . f or Eac h( l et t er   =>   {	/ /   Not e   ar r ow  f unc t i on   s ynt ax   her e upper c as e   +=   l et t er . t oUpper Cas e( ) ;
} ) ;
upper c as e	/ /   =>   " HEL L O  WORL D"


As you would expect, f or Each( )  iterates the array in order, and it actually passes the array index to your function as a second argument, which is occasionally useful. Unlike the f or / of  loop, the f or Each( ) is aware of sparse arrays and does not invoke your function for elements that are not there.

§7.8.1 documents the f or Each( )  method in more detail. That section also covers related methods such as map( )  and f i l t er ( )  that perform specialized kinds of array iteration.

You can also loop through the elements of an array with a good old-fashioned f or  loop (§5.4.3):


l et   vowel s   =   " " ;
f or ( l et   i	=   0;	i	<   l et t er s . l engt h;	i ++)    {    / /   For   eac h   i ndex   i n t he   ar r ay
l et   l et t er   =   l et t er s [ i ] ;	/ /   Get   t he   el ement   at t hat   i ndex
i f    ( / [ aei ou] / . t es t ( l et t er ) )    {	/ /   Us e   a   r egul ar expr es s i on   t es t
vowel s   +=   l et t er ;	/ /   I f    i t   i s   a   vowel , r emember   i t
}

}
vowel s	/ /   =>   " eoo"


In nested loops, or other contexts where performance is critical, you may sometimes see this basic array iteration loop written so that the array length is only looked up once rather than on each iteration. Both of the following f or  loop forms are idiomatic, though not particularly common, and with modern JavaScript interpreters, it is not at all clear that they have any performance impact:

/ /   Save   t he   ar r ay   l engt h   i nt o   a   l oc al	var i abl e
f or ( l et   i	=   0,	l en   =   l et t er s . l engt h;	i	<   l en;	i ++)    { / /   l oop   body   r emai ns   t he   s ame
}

/ /   I t er at e   bac kwar ds   f r om t he   end   of    t he   ar r ay   t o   t he   s t ar t f or ( l et   i	=   l et t er s . l engt h- 1;	i	>=   0;	i - - )    {
/ /   l oop   body   r emai ns   t he   s ame }


These examples assume that the array is dense and that all elements contain valid data. If this is not the case, you should test the array elements before using them. If you want to skip undefined and nonexistent elements, you might write:

f or ( l et   i	=   0;	i	<   a. l engt h;	i ++)    {
i f    ( a[ i ]    ===   undef i ned)    c ont i nue;	/ /   Ski p   undef i ned   +

nonexi s t ent / /   l oop
}

el ement s body   her e




7.7 Multidimensional Arrays

JavaScript does not support true multidimensional arrays, but you can approximate them with arrays of arrays. To access a value in an array of arrays, simply use the [ ]  operator twice. For example, suppose the

variable mat r i x is an array of arrays of numbers. Every element in
mat r i x[ x]  is an array of numbers. To access a particular number within this array, you would write mat r i x[ x] [ y] . Here is a concrete example that uses a two-dimensional array as a multiplication table:

/ /   Cr eat e   a   mul t i di mens i onal	ar r ay
l et   t abl e   =   new  Ar r ay( 10) ;	/ /   10   r ows   of    t he   t abl e f or ( l et   i	=   0;	i	<   t abl e. l engt h;    i ++)    {
t abl e[ i ]    =   new  Ar r ay( 10) ;	/ /   Eac h   r ow  has   10 c ol umns
}

/ /   I ni t i al i z e   t he   ar r ay
f or ( l et   r ow  =   0;	r ow  <   t abl e. l engt h;	r ow++)    {
f or ( l et   c ol	=   0;	c ol	<   t abl e[ r ow] . l engt h;	c ol ++)    { t abl e[ r ow] [ c ol ]    =   r ow*c ol ;
} }

/ /   Us e   t he   mul t i di mens i onal	ar r ay   t o   c omput e   5*7 t abl e[ 5] [ 7]	/ /   =>   35


7.8 Array Methods

The preceding sections have focused on basic JavaScript syntax for working with arrays. In general, though, it is the methods defined by the Array class that are the most powerful. The next sections document these methods. While reading about these methods, keep in mind that some of them modify the array they are called on and some of them leave the array unchanged. A number of the methods return an array: sometimes, this is a new array, and the original is unchanged. Other times, a method will modify the array in place and will also return a reference to the modified array.


Each of the subsections that follows covers a group of related array

methods:


Iterator methods loop over the elements of an array, typically invoking a function that you specify on each of those elements.

Stack and queue methods add and remove array elements to and from the beginning and the end of an array.

Subarray methods are for extracting, deleting, inserting, filling, and copying contiguous regions of a larger array.

Searching and sorting methods are for locating elements within an array and for sorting the elements of an array.

The following subsections also cover the static methods of the Array class and a few miscellaneous methods for concatenating arrays and converting arrays to strings.


7.8.1 Array Iterator Methods

The methods described in this section iterate over arrays by passing array elements, in order, to a function you supply, and they provide convenient ways to iterate, map, filter, test, and reduce arrays.


Before we explain the methods in detail, however, it is worth making some generalizations about them. First, all of these methods accept a function as their first argument and invoke that function once for each element (or some elements) of the array. If the array is sparse, the function you pass is not invoked for nonexistent elements. In most cases, the function you supply is invoked with three arguments: the value of the array element, the index of the array element, and the array itself. Often, you only need the first of these argument values and can ignore the second and third values.


Most of the iterator methods described in the following subsections accept

an optional second argument. If specified, the function is invoked as if it is a method of this second argument. That is, the second argument you pass becomes the value of the t hi s  keyword inside of the function you pass as the first argument. The return value of the function you pass is usually important, but different methods handle the return value in different ways. None of the methods described here modify the array on which they are invoked (though the function you pass can modify the array, of course).

Each of these functions is invoked with a function as its first argument, and it is very common to define that function inline as part of the method invocation expression instead of using an existing function that is defined elsewhere. Arrow function syntax (see §8.1.3) works particularly well with these methods, and we will use it in the examples that follow.

FOREACH()

The f or Each( )  method iterates through an array, invoking a function you specify for each element. As we’ve described, you pass the function as the first argument to f or Each( ) . f or Each( )  then invokes your function with three arguments: the value of the array element, the index of the array element, and the array itself. If you only care about the value of the array element, you can write a function with only one parameter—the additional arguments will be ignored:

l et   dat a   =   [ 1, 2, 3, 4, 5] ,	s um =   0;
/ /   Comput e   t he   s um of    t he   el ement s   of    t he   ar r ay
dat a. f or Eac h( val ue   =>   {    s um +=   val ue;	} ) ;	/ /   s um ==   15

/ /   Now  i nc r ement   eac h   ar r ay   el ement
dat a. f or Eac h( f unc t i on( v,	i ,	a)    {    a[ i ]    =   v   +   1;	} ) ;	/ /   dat a   == [ 2, 3, 4, 5, 6]


Note that f or Each( )  does not provide a way to terminate iteration

before all elements have been passed to the function. That is, there is no equivalent of the br eak statement you can use with a regular f or  loop.

MAP()

The map( )  method passes each element of the array on which it is invoked to the function you specify and returns an array containing the values returned by your function. For example:

l et   a   =   [ 1,	2,	3] ;
a. map( x   =>   x*x)	/ /   =>   [ 1,	4,	9] :	t he   f unc t i on   t akes   i nput   x and   r et ur ns   x*x


The function you pass to map( )  is invoked in the same way as a function passed to f or Each( ) . For the map( )  method, however, the function you pass should return a value. Note that map( )  returns a new array: it does not modify the array it is invoked on. If that array is sparse, your function will not be called for the missing elements, but the returned array will be sparse in the same way as the original array: it will have the same length and the same missing elements.

FILTER()

The f i l t er ( )  method returns an array containing a subset of the elements of the array on which it is invoked. The function you pass to it should be predicate: a function that returns t r ue or f al s e. The predicate is invoked just as for f or Each( )  and map( ) . If the return value is t r ue, or a value that converts to t r ue, then the element passed to the predicate is a member of the subset and is added to the array that will become the return value. Examples:

l et   a   =   [ 5,	4,	3,	2,	1] ;
a. f i l t er ( x   =>   x   <   3)	/ /   =>   [ 2,	1] ;	val ues   l es s   t han   3

a. f i l t er ( ( x, i )    =>   i %2   ===   0)    / /   =>   [ 5,	3,	1] ;	ever y   ot her   val ue


Note that f i l t er ( )  skips missing elements in sparse arrays and that its return value is always dense. To close the gaps in a sparse array, you can do this:

l et   dens e   =   s par s e. f i l t er ( ( )    =>   t r ue) ;


And to close gaps and remove undefined and null elements, you can use f i l t er , like this:


a   =   a. f i l t er ( x   =>   x   ! ==   undef i ned   &&  x   ! ==   nul l ) ;


FIND() AND FINDINDEX()

The f i nd( )  and f i ndI ndex( )  methods are like f i l t er ( )  in that they iterate through your array looking for elements for which your predicate function returns a truthy value. Unlike f i l t er ( ) , however, these two methods stop iterating the first time the predicate finds an element. When that happens, f i nd( )  returns the matching element, and
f i ndI ndex( )  returns the index of the matching element. If no matching element is found, f i nd( )  returns undef i ned and f i ndI ndex( ) returns - 1:

l et   a   =   [ 1, 2, 3, 4, 5] ;
a. f i ndI ndex( x   =>   x   ===   3)	/ /   =>   2;	t he   val ue   3   appear s   at   i ndex 2
a. f i ndI ndex( x   =>   x   <   0)	/ /   =>   - 1;	no   negat i ve   number s   i n   t he ar r ay
a. f i nd( x   =>   x   %  5   ===   0)	/ /   =>   5:	t hi s   i s   a   mul t i pl e   of    5
a. f i nd( x   =>   x   %  7   ===   0)	/ /   =>   undef i ned:	no   mul t i pl es   of    7   i n t he   ar r ay

EVERY() AND SOME()

The ever y( )  and s ome( )  methods are array predicates: they apply a predicate function you specify to the elements of the array, then return
t r ue or f al s e.


The ever y( )  method is like the mathematical “for all” quantifier ∀: it returns t r ue if and only if your predicate function returns t r ue for all elements in the array:

l et   a   =   [ 1, 2, 3, 4, 5] ;
a. ever y( x   =>   x   <   10)	/ /   =>   t r ue:	al l	val ues   ar e   <   10.
a. ever y( x   =>   x   %  2   ===   0)    / /   =>   f al s e:	not   al l	val ues   ar e   even.


The s ome( )  method is like the mathematical “there exists” quantifier ∃: it returns t r ue if there exists at least one element in the array for which the predicate returns t r ue and returns f al s e if and only if the predicate returns f al s e for all elements of the array:

l et   a   =   [ 1, 2, 3, 4, 5] ;
a. s ome( x   =>   x%2===0)	/ /   =>   t r ue;	a   has   s ome   even   number s . a. s ome( i s NaN)	/ /   =>   f al s e;    a   has   no   non- number s .


Note that both ever y( )  and s ome( )  stop iterating array elements as soon as they know what value to return. s ome( )  returns t r ue the first time your predicate returns <code>true</code> and only iterates through the entire array if your predicate always returns f al s e. ever y( )  is the opposite: it returns f al s e the first time your predicate returns f al s e and only iterates all elements if your predicate always returns t r ue. Note also that, by mathematical convention, ever y( )  returns t r ue and s ome returns f al s e when invoked on an empty array.

REDUCE() AND REDUCERIGHT()

The r educe( )  and r educeRi ght ( )  methods combine the elements of an array, using the function you specify, to produce a single value. This is a common operation in functional programming and also goes by the names “inject” and “fold.” Examples help illustrate how it works:

l et   a   =   [ 1, 2, 3, 4, 5] ;
a. r educ e( ( x, y)    =>   x+y,	0)	/ /   =>   15;	t he   s um of    t he val ues
a. r educ e( ( x, y)    =>   x*y,	1)	/ /   =>   120;	t he   pr oduc t   of    t he val ues
a. r educ e( ( x, y)    =>   ( x   >   y)    ?   x   :	y)    / /   =>   5;	t he   l ar ges t   of    t he val ues


r educe( )  takes two arguments. The first is the function that performs the reduction operation. The task of this reduction function is to somehow combine or reduce two values into a single value and to return that reduced value. In the examples we’ve shown here, the functions combine two values by adding them, multiplying them, and choosing the largest. The second (optional) argument is an initial value to pass to the function.

Functions used with r educe( )  are different than the functions used with f or Each( )  and map( ) . The familiar value, index, and array values are passed as the second, third, and fourth arguments. The first argument is the accumulated result of the reduction so far. On the first call to the function, this first argument is the initial value you passed as the second argument to r educe( ) . On subsequent calls, it is the value returned by the previous invocation of the function. In the first example, the reduction function is first called with arguments 0 and 1. It adds these and returns 1. It is then called again with arguments 1 and 2 and returns 3. Next, it computes 3+3=6, then 6+4=10, and finally 10+5=15. This final value, 15, becomes the return value of r educe( ) .

You may have noticed that the third call to r educe( )  in this example has only a single argument: there is no initial value specified. When you invoke r educe( )  like this with no initial value, it uses the first element of the array as the initial value. This means that the first call to the reduction function will have the first and second array elements as its first and second arguments. In the sum and product examples, we could have omitted the initial value argument.

Calling r educe( )  on an empty array with no initial value argument causes a TypeError. If you call it with only one value—either an array with one element and no initial value or an empty array and an initial value—it simply returns that one value without ever calling the reduction function.

r educeRi ght ( )  works just like r educe( ) , except that it processes the array from highest index to lowest (right-to-left), rather than from lowest to highest. You might want to do this if the reduction operation has right-to-left associativity, for example:

/ /   Comput e   2^( 3^4) .	Exponent i at i on   has   r i ght - t o- l ef t   pr ec edenc e l et   a   =   [ 2,	3,	4] ;
a. r educ eRi ght ( ( ac c , val )    =>   Mat h. pow( val , ac c ) )    / /   => 2. 4178516392292583e+24


Note that neither r educe( )  nor r educeRi ght ( )  accepts an optional argument that specifies the t hi s  value on which the reduction function is to be invoked. The optional initial value argument takes its place. See the Funct i on. bi nd( )  method (§8.7.5) if you need your reduction function invoked as a method of a particular object.

The examples shown so far have been numeric for simplicity, but

r educe( )  and r educeRi ght ( )  are not intended solely for mathematical computations. Any function that can combine two values (such as two objects) into one value of the same type can be used as a reduction function. On the other hand, algorithms expressed using array reductions can quickly become complex and hard to understand, and you may find that it is easier to read, write, and reason about your code if you use regular looping constructs to process your arrays.


7.8.2 Flattening arrays with flat() and flatMap()

In ES2019, the f l at ( )  method creates and returns a new array that contains the same elements as the array it is called on, except that any elements that are themselves arrays are “flattened” into the returned array. For example:


[ 1,	[ 2,	3] ] . f l at ( )
[ 1,	[ 2,	[ 3] ] ] . f l at ( )

/ /   =>   [ 1,	2,	3]
/ /   =>   [ 1,	2,	[ 3] ]



When called with no arguments, f l at ( )  flattens one level of nesting. Elements of the original array that are themselves arrays are flattened, but array elements of those arrays are not flattened. If you want to flatten more levels, pass a number to f l at ( ) :


l et   a   =   [ 1,	[ 2,	[ 3,	[ 4] ] ] ] ;
a. f l at ( 1)	/ /   =>   [ 1,	2,	[ 3,	[ 4] ] ]

a. f l at ( 2) a. f l at ( 3)
a. f l at ( 4)

/ /   =>   [ 1,	2,	3,	[ 4] ] / /   =>   [ 1,	2,	3,	4]
/ /   =>   [ 1,	2,	3,	4]



The f l at Map( )  method works just like the map( )  method (see “map()”) except that the returned array is automatically flattened as if passed to f l at ( ) . That is, calling a. f l at Map( f )  is the same as (but

more efficient than) a. map( f ) . f l at ( ) :


l et   phr as es   =   [ " hel l o   wor l d" ,	" t he   def i ni t i ve   gui de" ] ;
l et   wor ds   =   phr as es . f l at Map( phr as e   =>   phr as e. s pl i t ( "   " ) ) ;
wor ds   / /   =>   [ " hel l o" ,	" wor l d" ,	" t he" ,	" def i ni t i ve" ,	" gui de" ] ;


You can think of f l at Map( )  as a generalization of map( )  that allows each element of the input array to map to any number of elements of the output array. In particular, f l at Map( )  allows you to map input elements to an empty array, which flattens to nothing in the output array:

/ /   Map   non- negat i ve   number s   t o   t hei r   s quar e   r oot s
[ - 2,	- 1,	1,	2] . f l at Map( x   =>   x   <   0   ?   [ ]    :	Mat h. s qr t ( x) )    / /   =>   [ 1, 2**0. 5]


7.8.3 Adding arrays with concat()

The concat ( )  method creates and returns a new array that contains the elements of the original array on which concat ( )  was invoked, followed by each of the arguments to concat ( ) . If any of these arguments is itself an array, then it is the array elements that are concatenated, not the array itself. Note, however, that concat ( )  does not recursively flatten arrays of arrays. concat ( )  does not modify the array on which it is invoked:

l et   a   =   [ 1, 2, 3] ;
a. c onc at ( 4,	5)	/ /   =>   [ 1, 2, 3, 4, 5]
a. c onc at ( [ 4, 5] , [ 6, 7] )	/ /   =>   [ 1, 2, 3, 4, 5, 6, 7] ;	ar r ays   ar e f l at t ened
a. c onc at ( 4,	[ 5, [ 6, 7] ] )	/ /   =>   [ 1, 2, 3, 4, 5, [ 6, 7] ] ;	but   not   nes t ed
ar r ays
a	/ /   =>   [ 1, 2, 3] ;	t he   or i gi nal	ar r ay   i s unmodi f i ed


Note that concat ( )  makes a new copy of the array it is called on. In

many cases, this is the right thing to do, but it is an expensive operation. If you find yourself writing code like a   =   a. concat ( x) , then you should think about modifying your array in place with pus h( )  or
s pl i ce( )  instead of creating a new one.


7.8.4 Stacks and Queues with push(), pop(), shift(), and unshift()

The pus h( )  and pop( )  methods allow you to work with arrays as if they were stacks. The pus h( )  method appends one or more new elements to the end of an array and returns the new length of the array. Unlike concat ( ) , pus h( )  does not flatten array arguments. The pop( )  method does the reverse: it deletes the last element of an array, decrements the array length, and returns the value that it removed. Note
that both methods modify the array in place. The combination of pus h( ) and pop( )  allows you to use a JavaScript array to implement a first-in, last-out stack. For example:

l et   s t ac k   =   [ ] ;	/ /   s t ac k   ==   [ ]
s t ac k. pus h( 1, 2) ;	/ /   s t ac k   ==   [ 1, 2] ;
s t ac k. pop( ) ;	/ /   s t ac k   ==   [ 1] ;	r et ur ns   2 s t ac k. pus h( 3) ;	/ /   s t ac k   ==   [ 1, 3]
s t ac k. pop( ) ;	/ /   s t ac k   ==   [ 1] ;	r et ur ns   3 s t ac k. pus h( [ 4, 5] ) ;	/ /   s t ac k   ==   [ 1, [ 4, 5] ]
s t ac k. pop( )	/ /   s t ac k   ==   [ 1] ;	r et ur ns   [ 4, 5] s t ac k. pop( ) ;	/ /   s t ac k   ==   [ ] ;    r et ur ns   1


The pus h( )  method does not flatten an array you pass to it, but if you want to push all of the elements from one array onto another array, you can use the spread operator (§8.3.4) to flatten it explicitly:

a. pus h( . . . val ues ) ;

The uns hi f t ( )  and s hi f t ( )  methods behave much like pus h( )  and pop( ) , except that they insert and remove elements from the beginning of an array rather than from the end. uns hi f t ( )  adds an element or
elements to the beginning of the array, shifts the existing array elements up to higher indexes to make room, and returns the new length of the array.
s hi f t ( )  removes and returns the first element of the array, shifting all subsequent elements down one place to occupy the newly vacant space at the start of the array. You could use uns hi f t ( )  and s hi f t ( )  to implement a stack, but it would be less efficient than using pus h( )  and pop( )  because the array elements need to be shifted up or down every time an element is added or removed at the start of the array. Instead, though, you can implement a queue data structure by using pus h( )  to add elements at the end of an array and s hi f t ( )  to remove them from the start of the array:

l et   q   =   [ ] ;	/ /   q   ==   [ ]
q. pus h( 1, 2) ;	/ /   q   ==   [ 1, 2]
q. s hi f t ( ) ;	/ /   q   ==   [ 2] ;	r et ur ns   1 q. pus h( 3)	/ /   q   ==   [ 2,    3]
q. s hi f t ( )	/ /   q   ==   [ 3] ;	r et ur ns   2 q. s hi f t ( )	/ /   q   ==   [ ] ;    r et ur ns   3


There is one feature of uns hi f t ( )  that is worth calling out because you may find it surprising. When passing multiple arguments to uns hi f t ( ) , they are inserted all at once, which means that they end up in the array in a different order than they would be if you inserted them one at a time:

l et   a   =   [ ] ;	/ /   a   ==   [ ]

a. uns hi f t ( 1)
a. uns hi f t ( 2)

/ /   a   ==   [ 1]
/ /   a   ==   [ 2,	1]

a   =   [ ] ;	/ /   a   ==   [ ]
a. uns hi f t ( 1, 2)	/ /   a   ==   [ 1,	2]

7.8.5 Subarrays with slice(), splice(), fill(), and copyWithin()

Arrays define a number of methods that work on contiguous regions, or subarrays or “slices” of an array. The following sections describe methods for extracting, replacing, filling, and copying slices.

SLICE()

The s l i ce( )  method returns a slice, or subarray, of the specified array. Its two arguments specify the start and end of the slice to be returned. The returned array contains the element specified by the first argument and all subsequent elements up to, but not including, the element specified by the second argument. If only one argument is specified, the returned array contains all elements from the start position to the end of the array. If either argument is negative, it specifies an array element relative to the length of the array. An argument of –1, for example, specifies the last element in the array, and an argument of –2 specifies the element before that one. Note that s l i ce( )  does not modify the array on which it is invoked. Here are some examples:

l et   a   =   [ 1, 2, 3, 4, 5] ;

a. s l i c e( 0, 3) ; a. s l i c e( 3) ;
a. s l i c e( 1, - 1) ;
a. s l i c e( - 3, - 2) ;

/ /   Ret ur ns / /   Ret ur ns / /   Ret ur ns
/ /   Ret ur ns

[ 1, 2, 3] [ 4, 5]
[ 2, 3, 4]
[ 3]



SPLICE()

s pl i ce( )  is a general-purpose method for inserting or removing elements from an array. Unlike s l i ce( )  and concat ( ) , s pl i ce( ) modifies the array on which it is invoked. Note that s pl i ce( )  and
s l i ce( )  have very similar names but perform substantially different

operations.


s pl i ce( )  can delete elements from an array, insert new elements into an array, or perform both operations at the same time. Elements of the array that come after the insertion or deletion point have their indexes increased or decreased as necessary so that they remain contiguous with the rest of the array. The first argument to s pl i ce( )  specifies the array position at which the insertion and/or deletion is to begin. The second argument specifies the number of elements that should be deleted from (spliced out of) the array. (Note that this is another difference between these two methods. The second argument to s l i ce( )  is an end position. The second argument to s pl i ce( )  is a length.) If this second argument is omitted, all array elements from the start element to the end of the array are removed. s pl i ce( )  returns an array of the deleted elements, or an empty array if no elements were deleted. For example:

l et   a   =   [ 1, 2, 3, 4, 5, 6, 7, 8] ;
a. s pl i c e( 4)	/ /   =>   [ 5, 6, 7, 8] ;	a   i s   now  [ 1, 2, 3, 4] a. s pl i c e( 1, 2)	/ /   =>   [ 2, 3] ;	a   i s   now  [ 1, 4]
a. s pl i c e( 1, 1)	/ /   =>   [ 4] ;	a   i s   now  [ 1]


The first two arguments to s pl i ce( )  specify which array elements are to be deleted. These arguments may be followed by any number of additional arguments that specify elements to be inserted into the array, starting at the position specified by the first argument. For example:

l et   a   =   [ 1, 2, 3, 4, 5] ;
a. s pl i c e( 2, 0, " a" , " b" )	/ /   =>   [ ] ;	a   i s   now  [ 1, 2, " a" , " b" , 3, 4, 5] a. s pl i c e( 2, 2, [ 1, 2] , 3)	/ /   =>   [ " a" , " b" ] ;	a   i s   now  [ 1, 2,
[ 1, 2] , 3, 3, 4, 5]


Note that, unlike concat ( ) , s pl i ce( )  inserts arrays themselves, not

the elements of those arrays.


FILL()

The f i l l ( )  method sets the elements of an array, or a slice of an array, to a specified value. It mutates the array it is called on, and also returns the modified array:

l et   a   =   new  Ar r ay( 5) ;	/ /   St ar t   wi t h   no   el ement s   and   l engt h   5 a. f i l l ( 0)	/ /   =>   [ 0, 0, 0, 0, 0] ;	f i l l	t he   ar r ay   wi t h z er os
a. f i l l ( 9,	1)	/ /   =>   [ 0, 9, 9, 9, 9] ;	f i l l	wi t h   9   s t ar t i ng at   i ndex   1
a. f i l l ( 8,	2,	- 1)	/ /   =>   [ 0, 9, 8, 8, 9] ;	f i l l	wi t h   8   at i ndexes   2,    3

The first argument to f i l l ( )  is the value to set array elements to. The optional second argument specifies the starting index. If omitted, filling starts at index 0. The optional third argument specifies the ending index— array elements up to, but not including, this index will be filled. If this argument is omitted, then the array is filled from the start index to the end. You can specify indexes relative to the end of the array by passing negative numbers, just as you can for s l i ce( ) .

COPYWITHIN()

copyWi t hi n( )  copies a slice of an array to a new position within the array. It modifies the array in place and returns the modified array, but it will not change the length of the array. The first argument specifies the destination index to which the first element will be copied. The second argument specifies the index of the first element to be copied. If this second argument is omitted, 0 is used. The third argument specifies the end of the slice of elements to be copied. If omitted, the length of the array is used. Elements from the start index up to, but not including, the end

index will be copied. You can specify indexes relative to the end of the array by passing negative numbers, just as you can for s l i ce( ) :


l et   a   =   [ 1, 2, 3, 4, 5] ;
a. c opyWi t hi n( 1)	/ /   =>   [ 1, 1, 2, 3, 4] :	c opy   ar r ay   el ement s   up one
a. c opyWi t hi n( 2,	3,	5)    / /   =>   [ 1, 1, 3, 4, 4] :	c opy   l as t   2   el ement s   t o i ndex   2
a. c opyWi t hi n( 0,	- 2)	/ /   =>   [ 4, 4, 3, 4, 4] :	negat i ve   of f s et s   wor k, t oo


copyWi t hi n( )  is intended as a high-performance method that is particularly useful with typed arrays (see §11.2). It is modeled after the memmove( )  function from the C standard library. Note that the copy will work correctly even if there is overlap between the source and destination regions.


7.8.6 Array Searching and Sorting Methods

Arrays implement i ndexOf ( ) , l as t I ndexOf ( ) , and i ncl udes ( ) methods that are similar to the same-named methods of strings. There are also s or t ( )  and r ever s e( )  methods for reordering the elements of an array. These methods are described in the subsections that follow.

INDEXOF() AND LASTINDEXOF()

i ndexOf ( )  and l as t I ndexOf ( )  search an array for an element with a specified value and return the index of the first such element found, or
- 1 if none is found. i ndexOf ( )  searches the array from beginning to end, and l as t I ndexOf ( )  searches from end to beginning:

l et   a   =   [ 0, 1, 2, 1, 0] ;

a. i ndexOf ( 1)
a. l as t I ndexOf ( 1)

/ /   =>   1:	a[ 1]    i s   1
/ /   =>   3:	a[ 3]    i s   1

a. i ndexOf ( 3)	/ /   =>   - 1:	no   el ement   has   val ue   3

i ndexOf ( )  and l as t I ndexOf ( )  compare their argument to the array elements using the equivalent of the === operator. If your array contains objects instead of primitive values, these methods check to see if two references both refer to exactly the same object. If you want to actually look at the content of an object, try using the f i nd( )  method with your own custom predicate function instead.

i ndexOf ( )  and l as t I ndexOf ( )  take an optional second argument that specifies the array index at which to begin the search. If this argument is omitted, i ndexOf ( )  starts at the beginning and l as t I ndexOf ( ) starts at the end. Negative values are allowed for the second argument and are treated as an offset from the end of the array, as they are for the
s l i ce( )  method: a value of –1, for example, specifies the last element of the array.

The following function searches an array for a specified value and returns an array of all matching indexes. This demonstrates how the second argument to i ndexOf ( )  can be used to find matches beyond the first.

/ /   Fi nd   al l	oc c ur r enc es   of    a   val ue   x   i n   an   ar r ay   a   and   r et ur n   an ar r ay
/ /   of    mat c hi ng   i ndexes
f unc t i on   f i ndal l ( a,	x)    {
l et   r es ul t s   =   [ ] ,	/ /   The   ar r ay   of    i ndexes   we' l l r et ur n
l en   =   a. l engt h,	/ /   The   l engt h   of    t he   ar r ay   t o be   s ear c hed
pos   =   0;	/ /   The   pos i t i on   t o   s ear c h   f r om whi l e( pos   <   l en)    {	/ /   Whi l e   mor e   el ement s   t o
s ear c h. . .
pos   =   a. i ndexOf ( x,	pos ) ;	/ /   Sear c h
i f    ( pos   ===   - 1)    br eak;	/ /   I f    not hi ng   f ound,	we' r e done.
r es ul t s . pus h( pos ) ;	/ /   Ot her wi s e,	s t or e   i ndex   i n ar r ay

pos   =   pos   +   1;	/ /   And   s t ar t   next   s ear c h   at next   el ement
}
r et ur n   r es ul t s ;	/ /   Ret ur n   ar r ay   of    i ndexes }


Note that strings have i ndexOf ( )  and l as t I ndexOf ( )  methods that work like these array methods, except that a negative second argument is treated as zero.

INCLUDES()

The ES2016 i ncl udes ( )  method takes a single argument and returns
t r ue if the array contains that value or f al s e otherwise. It does not tell you the index of the value, only whether it exists. The i ncl udes ( ) method is effectively a set membership test for arrays. Note, however, that arrays are not an efficient representation for sets, and if you are working with more than a few elements, you should use a real Set object (§11.1.1).

The i ncl udes ( )  method is slightly different than the i ndexOf ( ) method in one important way. i ndexOf ( )  tests equality using the same algorithm that the === operator does, and that equality algorithm considers the not-a-number value to be different from every other value, including itself. i ncl udes ( )  uses a slightly different version of equality that does consider NaN to be equal to itself. This means that i ndexOf ( ) will not detect the NaN value in an array, but i ncl udes ( )  will:

l et   a   =   [ 1, t r ue, 3, NaN] ;

a. i nc l udes ( t r ue) a. i nc l udes ( 2)
a. i nc l udes ( NaN)

/ /   =>   t r ue / /   =>   f al s e
/ /   =>   t r ue

a. i ndexOf ( NaN)	/ /   =>   - 1;	i ndexOf    c an' t   f i nd   NaN


SORT()

s or t ( )  sorts the elements of an array in place and returns the sorted array. When s or t ( )  is called with no arguments, it sorts the array elements in alphabetical order (temporarily converting them to strings to perform the comparison, if necessary):

l et   a   =   [ " banana" ,	" c her r y" ,	" appl e" ] ;
a. s or t ( ) ;	/ /   a   ==   [ " appl e" ,	" banana" ,	" c her r y" ]


If an array contains undefined elements, they are sorted to the end of the array.


To sort an array into some order other than alphabetical, you must pass a comparison function as an argument to s or t ( ) . This function decides which of its two arguments should appear first in the sorted array. If the first argument should appear before the second, the comparison function should return a number less than zero. If the first argument should appear after the second in the sorted array, the function should return a number greater than zero. And if the two values are equivalent (i.e., if their order is irrelevant), the comparison function should return 0. So, for example, to sort array elements into numerical rather than alphabetical order, you might do this:

l et   a   =   [ 33,	4,	1111,	222] ;
a. s or t ( ) ;	/ /   a   ==   [ 1111,	222,	33,	4] ;	al phabet i c al or der
a. s or t ( f unc t i on( a, b)    {	/ /   Pas s   a   c ompar at or   f unc t i on
r et ur n   a- b;	/ /   Ret ur ns   <   0,	0,	or   >   0,	dependi ng   on or der
} ) ;	/ /   a   ==   [ 4,	33,	222,	1111] ;	numer i c al or der
a. s or t ( ( a, b)    =>   b- a) ;	/ /   a   ==   [ 1111,	222,	33,	4] ;	r ever s e numer i c al	or der


As another example of sorting array items, you might perform a case-

insensitive alphabetical sort on an array of strings by passing a comparison function that converts both of its arguments to lowercase (with the
t oLower Cas e( )  method) before comparing them:


l et   a   =   [ " ant " ,	" Bug" ,	" c at " ,	" Dog" ] ;
a. s or t ( ) ;	/ /   a   ==   [ " Bug" , " Dog" , " ant " , " c at " ] ;	c as e- s ens i t i ve s or t
a. s or t ( f unc t i on( s , t )    {
l et   a   =   s . t oL ower Cas e( ) ; l et   b   =   t . t oL ower Cas e( ) ;

i f    ( a   <   b)
i f    ( a   >   b)

r et ur n   - 1;
r et ur n   1;

r et ur n   0;
} ) ;	/ /   a   ==   [ " ant " , " Bug" , " c at " , " Dog" ] ;	c as e- i ns ens i t i ve   s or t


REVERSE()

The r ever s e( )  method reverses the order of the elements of an array and returns the reversed array. It does this in place; in other words, it doesn’t create a new array with the elements rearranged but instead rearranges them in the already existing array:

l et   a   =   [ 1, 2, 3] ;
a. r ever s e( ) ;	/ /   a   ==   [ 3, 2, 1]


7.8.7 Array to String Conversions

The Array class defines three methods that can convert arrays to strings, which is generally something you might do when creating log and error messages. (If you want to save the contents of an array in textual form for later reuse, serialize the array with J SON. s t r i ngi f y( )  [§6.8] instead of using the methods described here.)

The j oi n( )  method converts all the elements of an array to strings and concatenates them, returning the resulting string. You can specify an

optional string that separates the elements in the resulting string. If no separator string is specified, a comma is used:

l et   a   =   [ 1,	2,	3] ;
a. j oi n( )	/ /   =>   " 1, 2, 3" a. j oi n( "   " )	/ /   =>   " 1   2   3" a. j oi n( " " )	/ /   =>   " 123"
l et   b   =   new  Ar r ay( 10) ;	/ /   An   ar r ay   of    l engt h   10   wi t h   no   el ement s b. j oi n( " - " )	/ /   =>   " - - - - - - - - - " :	a   s t r i ng   of    9   hyphens


The j oi n( )  method is the inverse of the St r i ng. s pl i t ( )  method, which creates an array by breaking a string into pieces.

Arrays, like all JavaScript objects, have a t oSt r i ng( )  method. For an array, this method works just like the j oi n( )  method with no arguments:

[ 1, 2, 3] . t oSt r i ng( )	/ /   =>   " 1, 2, 3" [ " a" ,	" b" ,	" c " ] . t oSt r i ng( )	/ /   =>   " a, b, c " [ 1,	[ 2, " c " ] ] . t oSt r i ng( )	/ /   =>   " 1, 2, c "


Note that the output does not include square brackets or any other sort of delimiter around the array value.


t oLocal eSt r i ng( )  is the localized version of t oSt r i ng( ) . It converts each array element to a string by calling the
t oLocal eSt r i ng( )  method of the element, and then it concatenates the resulting strings using a locale-specific (and implementation-defined) separator string.


7.8.8 Static Array Functions

In addition to the array methods we’ve already documented, the Array class also defines three static functions that you can invoke through the

Ar r ay constructor rather than on arrays. Ar r ay. of ( )  and
Ar r ay. f r om( )  are factory methods for creating new arrays. They were documented in §7.1.4 and §7.1.5.

The one other static array function is Ar r ay. i s Ar r ay( ) , which is useful for determining whether an unknown value is an array or not:


Ar r ay. i s Ar r ay( [ ] )
Ar r ay. i s Ar r ay( { } )

/ /   =>   t r ue
/ /   =>   f al s e




7.9 Array-Like Objects

As we’ve seen, JavaScript arrays have some special features that other objects do not have:

The l engt h property is automatically updated as new elements are added to the list.

Setting l engt h to a smaller value truncates the array.

Arrays inherit useful methods from Ar r ay. pr ot ot ype.

Ar r ay. i s Ar r ay( )  returns t r ue for arrays.

These are the features that make JavaScript arrays distinct from regular objects. But they are not the essential features that define an array. It is often perfectly reasonable to treat any object with a numeric l engt h property and corresponding non-negative integer properties as a kind of array.

These “array-like” objects actually do occasionally appear in practice, and although you cannot directly invoke array methods on them or expect special behavior from the l engt h property, you can still iterate through them with the same code you’d use for a true array. It turns out that many

array algorithms work just as well with array-like objects as they do with real arrays. This is especially true if your algorithms treat the array as read-only or if they at least leave the array length unchanged.


The following code takes a regular object, adds properties to make it an array-like object, and then iterates through the “elements” of the resulting pseudo-array:

l et   a   =   { } ;	/ /   St ar t   wi t h   a   r egul ar   empt y   obj ec t

/ /   Add   pr oper t i es   t o   make   i t   " ar r ay- l i ke" l et   i	=   0;
whi l e( i	<   10)    {
a[ i ]    =   i	*   i ; i ++;
}
a. l engt h   =   i ;

/ /   Now  i t er at e   t hr ough   i t   as   i f    i t   wer e   a   r eal	ar r ay l et   t ot al	=   0;
f or ( l et   j	=   0;	j	<   a. l engt h;	j ++)    { t ot al	+=   a[ j ] ;
}


In client-side JavaScript, a number of methods for working with HTML documents (such as document . quer ySel ect or Al l ( ) , for example) return array-like objects. Here’s a function you might use to test for objects that work like arrays:

/ /   Det er mi ne   i f    o   i s   an   ar r ay- l i ke   obj ec t .
/ /   St r i ngs   and   f unc t i ons   have   numer i c   l engt h   pr oper t i es ,	but   ar e / /   exc l uded   by   t he   t ypeof    t es t .	I n   c l i ent - s i de   J avaSc r i pt ,	DOM
t ext
/ /   nodes   have   a   numer i c   l engt h   pr oper t y,	and   may   need   t o   be exc l uded
/ /   wi t h   an   addi t i onal	o. nodeType   ! ==   3   t es t . f unc t i on   i s Ar r ayL i ke( o)    {
i f    ( o   &&	/ /   o   i s   not   nul l ,

undef i ned,	et c .
t ypeof    o   ===   " obj ec t "   &&	/ /   o   i s   an   obj ec t
Number . i s Fi ni t e( o. l engt h)    &&	/ /   o. l engt h   i s   a   f i ni t e number
o. l engt h   >=   0   &&	/ /   o. l engt h   i s   non-negat i ve
Number . i s I nt eger ( o. l engt h)    &&	/ /   o. l engt h   i s   an i nt eger
o. l engt h   <   4294967295)    {	/ /   o. l engt h   <   2^32   -    1
r et ur n   t r ue;	/ /   Then   o   i s   ar r ay- l i ke. }    el s e   {
r et ur n   f al s e;	/ /   Ot her wi s e   i t   i s   not . }
}


We’ll see in a later section that strings behave like arrays. Nevertheless, tests like this one for array-like objects typically return f al s e for strings —they are usually best handled as strings, not as arrays.

Most JavaScript array methods are purposely defined to be generic so that they work correctly when applied to array-like objects in addition to true arrays. Since array-like objects do not inherit from Ar r ay. pr ot ot ype, you cannot invoke array methods on them directly. You can invoke them indirectly using the Funct i on. cal l  method, however (see §8.7.4 for details):

l et   a   =   { " 0" :	" a" ,	" 1" :	" b" ,	" 2" :	" c " ,	l engt h:	3} ;	/ /   An   ar r ay-l i ke   obj ec t
Ar r ay. pr ot ot ype. j oi n. c al l ( a,	" +" )	/ /   =>   " a+b+c " Ar r ay. pr ot ot ype. map. c al l ( a,    x   =>   x. t oUpper Cas e( ) )	/ /   =>
[ " A" , " B" , " C" ]
Ar r ay. pr ot ot ype. s l i c e. c al l ( a,	0)	/ /   =>   [ " a" , " b" , " c " ] :	t r ue ar r ay   c opy
Ar r ay. f r om( a)	/ /   =>   [ " a" , " b" , " c " ] :	eas i er ar r ay   c opy


The second-to-last line of this code invokes the Array s l i ce( )  method

on an array-like object in order to copy the elements of that object into a true array object. This is an idiomatic trick that exists in much legacy code, but is now much easier to do with Ar r ay. f r om( ) .


7.10 Strings as Arrays

JavaScript strings behave like read-only arrays of UTF-16 Unicode characters. Instead of accessing individual characters with the char At ( ) method, you can use square brackets:

l et   s   =   " t es t " ;

s . c har At ( 0)
s [ 1]

/ /   =>   " t "
/ /   =>   " e"



The t ypeof  operator still returns “string” for strings, of course, and the Ar r ay. i s Ar r ay( )  method returns f al s e if you pass it a string.


The primary benefit of indexable strings is simply that we can replace calls to char At ( )  with square brackets, which are more concise and readable, and potentially more efficient. The fact that strings behave like arrays also means, however, that we can apply generic array methods to them. For example:

Ar r ay. pr ot ot ype. j oi n. c al l ( " J avaSc r i pt " ,	"   " )	/ /   =>   " J    a   v   a   S   c r   i	p   t "


Keep in mind that strings are immutable values, so when they are treated as arrays, they are read-only arrays. Array methods like pus h( ) ,
s or t ( ) , r ever s e( ) , and s pl i ce( )  modify an array in place and do not work on strings. Attempting to modify a string using an array method does not, however, cause an error: it simply fails silently.

7.11 Summary

This chapter has covered JavaScript arrays in depth, including esoteric details about sparse arrays and array-like objects. The main points to take from this chapter are:

Array literals are written as comma-separated lists of values within square brackets.

Individual array elements are accessed by specifying the desired array index within square brackets.

The f or / of  loop and . . .  spread operator introduced in ES6 are particularly useful ways to iterate arrays.

The Array class defines a rich set of methods for manipulating arrays, and you should be sure to familiarize yourself with the Array API.



Chapter 8. Functions




This chapter covers JavaScript functions. Functions are a fundamental building block for JavaScript programs and a common feature in almost all programming languages. You may already be familiar with the concept of a function under a name such as subroutine or procedure.


A function is a block of JavaScript code that is defined once but may be executed, or invoked, any number of times. JavaScript functions are parameterized: a function definition may include a list of identifiers, known as parameters, that work as local variables for the body of the function. Function invocations provide values, or arguments, for the function’s parameters. Functions often use their argument values to compute a return value that becomes the value of the function-invocation expression. In addition to the arguments, each invocation has another value—the invocation context—that is the value of the t hi s  keyword.


If a function is assigned to a property of an object, it is known as a method of that object. When a function is invoked on or through an object, that object is the invocation context or t hi s  value for the function. Functions designed to initialize a newly created object are called constructors. Constructors were described in §6.2 and will be covered again in
Chapter 9.


In JavaScript, functions are objects, and they can be manipulated by programs. JavaScript can assign functions to variables and pass them to other functions, for example. Since functions are objects, you can set

properties on them and even invoke methods on them.


JavaScript function definitions can be nested within other functions, and they have access to any variables that are in scope where they are defined. This means that JavaScript functions are closures, and it enables important and powerful programming techniques.


8.1 Defining Functions

The most straightforward way to define a JavaScript function is with the f unct i on keyword, which can be used as a declaration or as an
expression. ES6 defines an important new way to define functions without the f unct i on keyword: “arrow functions” have a particularly compact syntax and are useful when passing one function as an argument to another function. The subsections that follow cover these three ways of defining functions. Note that some details of function definition syntax involving function parameters are deferred to §8.3.

In object literals and class definitions, there is a convenient shorthand syntax for defining methods. This shorthand syntax was covered in §6.10.5 and is equivalent to using a function definition expression and assigning it to an object property using the basic name: val ue object literal syntax. In another special case, you can use keywords get  and s et in object literals to define special property getter and setter methods. This function definition syntax was covered in §6.10.6.

Note that functions can also be defined with the Funct i on( ) constructor, which is the subject of §8.7.7. Also, JavaScript defines some specialized kinds of functions. f unct i on* defines generator functions (see Chapter 12) and as ync   f unct i on defines asynchronous functions

(see Chapter 13).


8.1.1 Function Declarations

Function declarations consist of the f unct i on keyword, followed by these components:

An identifier that names the function. The name is a required part of function declarations: it is used as the name of a variable, and the newly defined function object is assigned to the variable.

A pair of parentheses around a comma-separated list of zero or more identifiers. These identifiers are the parameter names for the function, and they behave like local variables within the body of the function.

A pair of curly braces with zero or more JavaScript statements inside. These statements are the body of the function: they are executed whenever the function is invoked.

Here are some example function declarations:


/ /   Pr i nt   t he   name   and   val ue   of    eac h   pr oper t y   of    o.	Ret ur n undef i ned.
f unc t i on   pr i nt pr ops ( o)    {
f or ( l et   p   i n   o)    {
c ons ol e. l og( ` ${ p} :	${ o[ p] } \ n` ) ; }
}

/ /   Comput e   t he   di s t anc e   bet ween   Car t es i an   poi nt s   ( x1, y1)    and ( x2, y2) .
f unc t i on   di s t anc e( x1,	y1,	x2,	y2)    {
l et   dx   =   x2   -    x1; l et   dy   =   y2   -    y1;
r et ur n   Mat h. s qr t ( dx*dx   +   dy*dy) ; }

/ /   A  r ec ur s i ve   f unc t i on   ( one   t hat   c al l s   i t s el f )    t hat   c omput es f ac t or i al s

/ /   Rec al l	t hat   x!   i s   t he   pr oduc t   of    x   and   al l	pos i t i ve   i nt eger s l es s   t han   i t .
f unc t i on   f ac t or i al ( x)    {
i f    ( x   <=   1)    r et ur n   1;
r et ur n   x   *   f ac t or i al ( x- 1) ; }


One of the important things to understand about function declarations is that the name of the function becomes a variable whose value is the function itself. Function declaration statements are “hoisted” to the top of the enclosing script, function, or block so that functions defined in this way may be invoked from code that appears before the definition. Another way to say this is that all of the functions declared in a block of JavaScript code will be defined throughout that block, and they will be defined before the JavaScript interpreter begins to execute any of the code in that block.


The di s t ance( )  and f act or i al ( )  functions we’ve described are designed to compute a value, and they use r et ur n to return that value to their caller. The r et ur n statement causes the function to stop executing and to return the value of its expression (if any) to the caller. If the
r et ur n statement does not have an associated expression, the return value of the function is undef i ned.

The pr i nt pr ops ( )  function is different: its job is to output the names and values of an object’s properties. No return value is necessary, and the function does not include a r et ur n statement. The value of an invocation of the pr i nt pr ops ( )  function is always undef i ned. If a function does not contain a r et ur n statement, it simply executes each statement in the function body until it reaches the end, and returns the undef i ned value to the caller.

Prior to ES6, function declarations were only allowed at the top level

within a JavaScript file or within another function. While some implementations bent the rule, it was not technically legal to define functions inside the body of loops, conditionals, or other blocks. In the strict mode of ES6, however, function declarations are allowed within blocks. A function defined within a block only exists within that block, however, and is not visible outside the block.


8.1.2 Function Expressions

Function expressions look a lot like function declarations, but they appear within the context of a larger expression or statement, and the name is optional. Here are some example function expressions:

/ /   Thi s   f unc t i on   expr es s i on   def i nes   a   f unc t i on   t hat   s quar es   i t s ar gument .
/ /   Not e   t hat   we   as s i gn   i t   t o   a   var i abl e
c ons t   s quar e   =   f unc t i on( x)    {    r et ur n   x*x;	} ;

/ /   Func t i on   expr es s i ons   c an   i nc l ude   names ,	whi c h   i s   us ef ul	f or r ec ur s i on.
c ons t   f    =   f unc t i on   f ac t ( x)    {    i f    ( x   <=   1)    r et ur n   1;	el s e   r et ur n
x*f ac t ( x- 1) ;	} ;

/ /   Func t i on   expr es s i ons   c an   al s o   be   us ed   as   ar gument s   t o   ot her f unc t i ons :
[ 3, 2, 1] . s or t ( f unc t i on( a, b)    {    r et ur n   a- b;	} ) ;

/ /   Func t i on   expr es s i ons   ar e   s omet i mes   def i ned   and   i mmedi at el y i nvoked:
l et   t ens quar ed   =   ( f unc t i on( x)    { r et ur n   x*x; } ( 10) ) ;


Note that the function name is optional for functions defined as expressions, and most of the preceding function expressions we’ve shown omit it. A function declaration actually declares a variable and assigns a function object to it. A function expression, on the other hand, does not declare a variable: it is up to you to assign the newly defined function object to a constant or variable if you are going to need to refer to it

multiple times. It is a good practice to use cons t  with function expressions so you don’t accidentally overwrite your functions by assigning new values.

A name is allowed for functions, like the factorial function, that need to refer to themselves. If a function expression includes a name, the local function scope for that function will include a binding of that name to the function object. In effect, the function name becomes a local variable within the function. Most functions defined as expressions do not need names, which makes their definition more compact (though not nearly as compact as arrow functions, described below).


There is an important difference between defining a function f ( )  with a function declaration and assigning a function to the variable f  after creating it as an expression. When you use the declaration form, the function objects are created before the code that contains them starts to run, and the definitions are hoisted so that you can call these functions from code that appears above the definition statement. This is not true for functions defined as expressions, however: these functions do not exist until the expression that defines them are actually evaluated. Furthermore, in order to invoke a function, you must be able to refer to it, and you can’t refer to a function defined as an expression until it is assigned to a variable, so functions defined with expressions cannot be invoked before they are defined.


8.1.3 Arrow Functions

In ES6, you can define functions using a particularly compact syntax known as “arrow functions.” This syntax is reminiscent of mathematical notation and uses an => “arrow” to separate the function parameters from

the function body. The f unct i on keyword is not used, and, since arrow functions are expressions instead of statements, there is no need for a function name, either. The general form of an arrow function is a comma-separated list of parameters in parentheses, followed by the => arrow, followed by the function body in curly braces:

c ons t   s um =   ( x,	y)    =>   {    r et ur n   x   +   y;	} ;


But arrow functions support an even more compact syntax. If the body of the function is a single r et ur n statement, you can omit the r et ur n keyword, the semicolon that goes with it, and the curly braces, and write the body of the function as the expression whose value is to be returned:

c ons t   s um =   ( x,	y)    =>   x   +   y;


Furthermore, if an arrow function has exactly one parameter, you can omit the parentheses around the parameter list:

c ons t   pol ynomi al	=   x   =>   x*x   +   2*x   +   3;


Note, however, that an arrow function with no arguments at all must be written with an empty pair of parentheses:

c ons t   c ons t ant Func   =   ( )    =>   42;


Note that, when writing an arrow function, you must not put a new line between the function parameters and the => arrow. Otherwise, you could end up with a line like cons t   pol ynomi al	=   x, which is a syntactically valid assignment statement on its own.

Also, if the body of your arrow function is a single r et ur n statement but the expression to be returned is an object literal, then you have to put the

object literal inside parentheses to avoid syntactic ambiguity between the curly braces of a function body and the curly braces of an object literal:

c ons t   f    =   x   =>   {    r et ur n   {    val ue:	x   } ;	} ;	/ /   Good:	f ( )    r et ur ns an   obj ec t
c ons t   g   =   x   =>   ( {    val ue:	x   } ) ;	/ /   Good:	g( )    r et ur ns an   obj ec t
c ons t   h   =   x   =>   {    val ue:	x   } ;	/ /   Bad:	h( )    r et ur ns not hi ng
c ons t   i	=   x   =>   {    v:	x,	w:	x   } ;	/ /   Bad:	Synt ax   Er r or


In the third line of this code, the function h( )  is truly ambiguous: the code you intended as an object literal can be parsed as a labeled statement, so a function that returns undefined is created. On the fourth line, however, the more complicated object literal is not a valid statement, and this illegal code causes a syntax error.

The concise syntax of arrow functions makes them ideal when you need to pass one function to another function, which is a common thing to do with array methods like map( ) , f i l t er ( ) , and r educe( )  (see §7.8.1), for example:

/ /   Make   a   c opy   of    an   ar r ay   wi t h   nul l	el ement s   r emoved.
l et   f i l t er ed   =   [ 1, nul l , 2, 3] . f i l t er ( x   =>   x   ! ==   nul l ) ;	/ /   f i l t er ed ==   [ 1, 2, 3]
/ /   Squar e   s ome   number s :
l et   s quar es   =   [ 1, 2, 3, 4] . map( x   =>   x*x) ;	/ /   s quar es ==   [ 1, 4, 9, 16]


Arrow functions differ from functions defined in other ways in one critical way: they inherit the value of the t hi s  keyword from the environment in which they are defined rather than defining their own invocation context as functions defined in other ways do. This is an important and very useful feature of arrow functions, and we’ll return to it again later in this chapter. Arrow functions also differ from other functions in that they do not have a

pr ot ot ype property, which means that they cannot be used as constructor functions for new classes (see §9.2).


8.1.4 Nested Functions

In JavaScript, functions may be nested within other functions. For example:

f unc t i on   hypot enus e( a,	b)    {
f unc t i on   s quar e( x)    {    r et ur n   x*x;	}
r et ur n   Mat h. s qr t ( s quar e( a)    +   s quar e( b) ) ; }


The interesting thing about nested functions is their variable scoping rules: they can access the parameters and variables of the function (or functions) they are nested within. In the code shown here, for example, the inner function s quar e( )  can read and write the parameters a and b defined by the outer function hypot enus e( ) . These scope rules for nested functions are very important, and we will consider them again in §8.6.


8.2 Invoking Functions

The JavaScript code that makes up the body of a function is not executed when the function is defined, but rather when it is invoked. JavaScript functions can be invoked in five ways:

As functions

As methods

As constructors

Indirectly through their cal l ( )  and appl y( )  methods

Implicitly, via JavaScript language features that do not appear like

normal function invocations


8.2.1 Function Invocation

Functions are invoked as functions or as methods with an invocation expression (§4.5). An invocation expression consists of a function expression that evaluates to a function object followed by an open parenthesis, a comma-separated list of zero or more argument expressions, and a close parenthesis. If the function expression is a property-access expression—if the function is the property of an object or an element of an array—then it is a method invocation expression. That case will be explained in the following example. The following code includes a number of regular function invocation expressions:

pr i nt pr ops ( { x:	1} ) ;
l et   t ot al	=   di s t anc e( 0, 0, 2, 1)    +   di s t anc e( 2, 1, 3, 5) ; l et   pr obabi l i t y   =   f ac t or i al ( 5) / f ac t or i al ( 13) ;


In an invocation, each argument expression (the ones between the parentheses) is evaluated, and the resulting values become the arguments to the function. These values are assigned to the parameters named in the function definition. In the body of the function, a reference to a parameter evaluates to the corresponding argument value.


For regular function invocation, the return value of the function becomes the value of the invocation expression. If the function returns because the interpreter reaches the end, the return value is undef i ned. If the function returns because the interpreter executes a r et ur n statement, then the return value is the value of the expression that follows the
r et ur n or is undef i ned if the r et ur n statement has no value.


CONDITIONAL INVOCATION

In ES2020 you can insert ?.  after the function expression and before the open parenthesis in a function invocation in order to invoke the function only if it is not nul l  or undef i ned. That is, the expression f ?. ( x)  is equivalent (assuming no side effects) to:

( f    ! ==   nul l    &&  f    ! ==   undef i ned)    ?   f ( x)    :    undef i ned


Full details on this conditional invocation syntax are in §4.5.1.



For function invocation in non-strict mode, the invocation context (the
t hi s  value) is the global object. In strict mode, however, the invocation context is undef i ned. Note that functions defined using the arrow syntax behave differently: they always inherit the t hi s  value that is in effect where they are defined.

Functions written to be invoked as functions (and not as methods) do not typically use the t hi s  keyword at all. The keyword can be used, however, to determine whether strict mode is in effect:

/ /   Def i ne   and   i nvoke   a   f unc t i on   t o   det er mi ne   i f    we' r e   i n   s t r i c t mode.
c ons t   s t r i c t   =   ( f unc t i on( )    {    r et ur n   ! t hi s ;	} ( ) ) ;



RECURSIVE FUNCTIONS AND THE STACK

A recursive function is one, like the f act or i al ( )  function at the start of this chapter, that calls itself. Some algorithms, such as those involving tree-based data structures, can be implemented particularly elegantly with recursive functions. When writing a recursive function, however, it is important to think about memory constraints. When a function A calls function B, and then function B calls function C, the JavaScript interpreter needs to keep track of the execution contexts for all three functions. When function C completes, the interpreter needs to know where to resume executing function B, and when function B completes, it needs to know where to resume executing function A. You can imagine these execution contexts as a stack. When a function calls another function, a new execution context is pushed onto the stack. When that function returns, its execution context object is popped off the stack. If a function calls itself recursively 100 times, the stack will have 100 objects pushed onto it, and then have those 100 objects popped off. This call stack takes memory. On modern hardware, it is typically fine to write recursive functions that call themselves hundreds of times. But if a function calls itself ten thousand times, it is likely to fail with an error such as “Maximum call-stack size exceeded.”



8.2.2 Method Invocation

A method is nothing more than a JavaScript function that is stored in a property of an object. If you have a function f  and an object o, you can define a method named mof o with the following line:

o. m =   f ;


Having defined the method m( )  of the object o, invoke it like this:


o. m( ) ;


Or, if m( )  expects two arguments, you might invoke it like this:


o. m( x,	y) ;


The code in this example is an invocation expression: it includes a function expression o. mand two argument expressions, x and y. The function expression is itself a property access expression, and this means that the function is invoked as a method rather than as a regular function.

The arguments and return value of a method invocation are handled exactly as described for regular function invocation. Method invocations differ from function invocations in one important way, however: the invocation context. Property access expressions consist of two parts: an object (in this case o) and a property name (m). In a method-invocation expression like this, the object o becomes the invocation context, and the function body can refer to that object by using the keyword t hi s . Here is a concrete example:

l et   c al c ul at or   =   {    / /   An   obj ec t   l i t er al

oper and1:    1, oper and2:    1,
add( )    {	/ /   We' r e   us i ng   met hod   s hor t hand   s ynt ax   f or
t hi s   f unc t i on
/ /   Not e   t he   us e   of    t he   t hi s   keywor d   t o   r ef er   t o   t he c ont ai ni ng   obj ec t .
t hi s . r es ul t   =   t hi s . oper and1   +   t hi s . oper and2;
} } ;
c al c ul at or . add( ) ;	/ /   A  met hod   i nvoc at i on   t o   c omput e   1+1. c al c ul at or . r es ul t	/ /   =>   2


Most method invocations use the dot notation for property access, but property access expressions that use square brackets also cause method invocation. The following are both method invocations, for example:

o[ " m" ] ( x, y) ;	/ /   Anot her   way   t o   wr i t e   o. m( x, y) .
a[ 0] ( z )	/ /   Al s o   a   met hod   i nvoc at i on   ( as s umi ng   a[ 0]    i s   a f unc t i on) .


Method invocations may also involve more complex property access expressions:


c us t omer . s ur name. t oUpper Cas e( ) ; c us t omer . s ur name
f ( ) . m( ) ;

/ /   I nvoke

/ /   I nvoke

met hod   on

met hod   m( )    on   r et ur n

val ue   of    f ( )


Methods and the t hi s  keyword are central to the object-oriented programming paradigm. Any function that is used as a method is effectively passed an implicit argument—the object through which it is invoked. Typically, a method performs some sort of operation on that object, and the method-invocation syntax is an elegant way to express the fact that a function is operating on an object. Compare the following two lines:

r ec t . s et Si z e( wi dt h,	hei ght ) ;
s et Rec t Si z e( r ec t ,	wi dt h,	hei ght ) ;


The hypothetical functions invoked in these two lines of code may perform exactly the same operation on the (hypothetical) object r ect , but the method-invocation syntax in the first line more clearly indicates the idea that it is the object r ect  that is the primary focus of the operation.



METHOD CHAINING

When methods return objects, you can use the return value of one method invocation as part of a subsequent invocation. This results in a series (or “chain”) of method invocations as a single expression. When working with Promise-based asynchronous operations (see Chapter 13), for example, it is common to write code structured like this:

/ /   Run   t hr ee   as ync hr onous   oper at i ons   i n   s equenc e,    handl i ng   er r or s . doSt epOne( ) . t hen( doSt epTwo) . t hen( doSt epThr ee) . c at c h( handl eEr r or s ) ;


When you write a method that does not have a return value of its own, consider having the method return t hi s . If you do this consistently throughout your API, you will enable a style of programming known as method chaining1  in which an object can be named once and then multiple methods can be invoked on it:

new  Squar e( ) . x( 100) . y( 100) . s i z e( 50) . out l i ne( " r ed" ) . f i l l ( " bl ue" ) . dr aw( ) ;




Note that t hi s  is a keyword, not a variable or property name. JavaScript syntax does not allow you to assign a value to t hi s .


The t hi s  keyword is not scoped the way variables are, and, except for arrow functions, nested functions do not inherit the t hi s  value of the containing function. If a nested function is invoked as a method, its t hi s value is the object it was invoked on. If a nested function (that is not an arrow function) is invoked as a function, then its t hi s  value will be either the global object (non-strict mode) or undef i ned (strict mode). It is a common mistake to assume that a nested function defined within a method and invoked as a function can use t hi s  to obtain the invocation context

of the method. The following code demonstrates the problem:


l et   o   =   {	/ /   An   obj ec t   o.
m:	f unc t i on( )    {	/ /   Met hod   m of    t he   obj ec t .
l et   s el f    =   t hi s ;	/ /   Save   t he   " t hi s "   val ue   i n   a
var i abl e.
t hi s   ===   o	/ /   =>   t r ue:	" t hi s "   i s   t he   obj ec t   o.
f ( ) ;	/ /   Now  c al l	t he   hel per   f unc t i on   f ( ) .

f unc t i on   f ( )    {	/ /   A  nes t ed   f unc t i on   f


undef i ned

val ue.
} }
} ;

t hi s   ===   o

s el f    ===   o

/ /   =>   f al s e:	" t hi s "

/ /   =>   t r ue:	s el f    i s

i s   gl obal	or

t he   out er   " t hi s "

o. m( ) ;	/ /   I nvoke   t he   met hod   m on   t he   obj ec t o.


Inside the nested function f ( ) , the t hi s  keyword is not equal to the object o. This is widely considered to be a flaw in the JavaScript language, and it is important to be aware of it. The code above demonstrates one common workaround. Within the method m, we assign the t hi s  value to a variable s el f , and within the nested function f , we can use s el f instead of t hi s  to refer to the containing object.


In ES6 and later, another workaround to this issue is to convert the nested function f  into an arrow function, which will properly inherit the t hi s value:

c ons t   f    =   ( )    =>   {
t hi s   ===   o	/ /   t r ue,	s i nc e   ar r ow  f unc t i ons   i nher i t   t hi s } ;


Functions defined as expressions instead of statements are not hoisted, so in order to make this code work, the function definition for f  will need to

be moved within the method mso that it appears before it is invoked.


Another workaround is to invoke the bi nd( )  method of the nested function to define a new function that is implicitly invoked on a specified object:

c ons t   f    =   ( f unc t i on( )    {
t hi s   ===   o	/ /   t r ue,	s i nc e   we   bound   t hi s   f unc t i on   t o   t he out er   t hi s
} ) . bi nd( t hi s ) ;


We’ll talk more about bi nd( )  in §8.7.5.


8.2.3 Constructor Invocation

If a function or method invocation is preceded by the keyword new, then it is a constructor invocation. (Constructor invocations were introduced in §4.6 and §6.2.2, and constructors will be covered in more detail in Chapter 9.) Constructor invocations differ from regular function and method invocations in their handling of arguments, invocation context, and return value.

If a constructor invocation includes an argument list in parentheses, those argument expressions are evaluated and passed to the function in the same way they would be for function and method invocations. It is not common practice, but you can omit a pair of empty parentheses in a constructor invocation. The following two lines, for example, are equivalent:

o   =   new  Obj ec t ( ) ; o   =   new  Obj ec t ;


A constructor invocation creates a new, empty object that inherits from the object specified by the pr ot ot ype property of the constructor.

Constructor functions are intended to initialize objects, and this newly created object is used as the invocation context, so the constructor function can refer to it with the t hi s  keyword. Note that the new object is used as the invocation context even if the constructor invocation looks like a method invocation. That is, in the expression new  o. m( ) , o is not used as the invocation context.

Constructor functions do not normally use the r et ur n keyword. They typically initialize the new object and then return implicitly when they reach the end of their body. In this case, the new object is the value of the constructor invocation expression. If, however, a constructor explicitly uses the r et ur n statement to return an object, then that object becomes the value of the invocation expression. If the constructor uses r et ur n with no value, or if it returns a primitive value, that return value is ignored and the new object is used as the value of the invocation.


8.2.4 Indirect Invocation

JavaScript functions are objects, and like all JavaScript objects, they have methods. Two of these methods, cal l ( )  and appl y( ) , invoke the function indirectly. Both methods allow you to explicitly specify the t hi s value for the invocation, which means you can invoke any function as a method of any object, even if it is not actually a method of that object. Both methods also allow you to specify the arguments for the invocation. The cal l ( )  method uses its own argument list as arguments to the function, and the appl y( )  method expects an array of values to be used as arguments. The cal l ( )  and appl y( )  methods are described in detail in §8.7.4.


8.2.5 Implicit Function Invocation

There are various JavaScript language features that do not look like function invocations but that cause functions to be invoked. Be extra careful when writing functions that may be implicitly invoked, because bugs, side effects, and performance issues in these functions are harder to diagnose and fix than in regular functions for the simple reason that it may not be obvious from a simple inspection of your code when they are being called.


The language features that can cause implicit function invocation include:


If an object has getters or setters defined, then querying or setting the value of its properties may invoke those methods. See §6.10.6 for more information.

When an object is used in a string context (such as when it is concatenated with a string), its t oSt r i ng( )  method is called. Similarly, when an object is used in a numeric context, its
val ueOf ( )  method is invoked. See §3.9.3 for details.

When you loop over the elements of an iterable object, there are a number of method calls that occur. Chapter 12 explains how iterators work at the function call level and demonstrates how to write these methods so that you can define your own iterable types.

A tagged template literal is a function invocation in disguise. §14.5 demonstrates how to write functions that can be used in conjunction with template literal strings.

Proxy objects (described in §14.7) have their behavior completely controlled by functions. Just about any operation on one of these objects will cause a function to be invoked.


8.3 Function Arguments and Parameters

JavaScript function definitions do not specify an expected type for the function parameters, and function invocations do not do any type checking on the argument values you pass. In fact, JavaScript function invocations do not even check the number of arguments being passed. The subsections that follow describe what happens when a function is invoked with fewer arguments than declared parameters or with more arguments than declared parameters. They also demonstrate how you can explicitly test the type of function arguments if you need to ensure that a function is not invoked with inappropriate arguments.


8.3.1 Optional Parameters and Defaults

When a function is invoked with fewer arguments than declared parameters, the additional parameters are set to their default value, which is normally undef i ned. It is often useful to write functions so that some arguments are optional. Following is an example:


/ /   Append   t he   names   of    t he t he
/ /   ar r ay   a,	and   r et ur n   a. new  ar r ay.

enumer abl e   pr oper t i es   of    obj ec t   o   t o

I f    a   i s   omi t t ed,	c r eat e   and   r et ur n   a

f unc t i on   get Pr oper t yNames ( o,	a)    {
i f    ( a   ===   undef i ned)    a   =   [ ] ;	/ /   I f    undef i ned,	us e   a   new ar r ay
f or ( l et   pr oper t y   i n   o)    a. pus h( pr oper t y) ; r et ur n   a;
}

/ /   get Pr oper t yNames ( )    c an   be   i nvoked   wi t h   one   or   t wo   ar gument s : l et   o   =   { x:	1} ,	p   =   { y:	2,	z :	3} ;	/ /   Two   obj ec t s   f or   t es t i ng
l et   a   =   get Pr oper t yNames ( o) ;	/ /   a   ==   [ " x" ] ;	get   o' s   pr oper t i es i n   a   new  ar r ay
get Pr oper t yNames ( p,	a) ;	/ /   a   ==   [ " x" , " y" , " z " ] ;	add   p' s pr oper t i es   t o   i t


Instead of using an i f  statement in the first line of this function, you can

use the || operator in this idiomatic way:


a   =   a   ||   [ ] ;


Recall from §4.10.2 that the || operator returns its first argument if that argument is truthy and otherwise returns its second argument. In this case, if any object is passed as the second argument, the function will use that object. But if the second argument is omitted (or nul l  or another falsy value is passed), a newly created empty array will be used instead.

Note that when designing functions with optional arguments, you should be sure to put the optional ones at the end of the argument list so that they can be omitted. The programmer who calls your function cannot omit the first argument and pass the second: they would have to explicitly pass undef i ned as the first argument.


In ES6 and later, you can define a default value for each of your function parameters directly in the parameter list of your function. Simply follow the parameter name with an equals sign and the default value to use when no argument is supplied for that parameter:


/ /   Append   t he   names   of    t he t he
/ /   ar r ay   a,	and   r et ur n   a. new  ar r ay.

enumer abl e   pr oper t i es   of    obj ec t   o   t o

I f    a   i s   omi t t ed,	c r eat e   and   r et ur n   a

f unc t i on   get Pr oper t yNames ( o,	a   =   [ ] )    {
f or ( l et   pr oper t y   i n   o)    a. pus h( pr oper t y) ; r et ur n   a;
}


Parameter default expressions are evaluated when your function is called, not when it is defined, so each time this get Pr oper t yNames ( ) function is invoked with one argument, a new empty array is created and

passed.2 It is probably easiest to reason about functions if the parameter defaults are constants (or literal expressions like [ ]  and { } ). But this is not required: you can use variables, or function invocations, for example, to compute the default value of a parameter. One interesting case is that, for functions with multiple parameters, you can use the value of a previous parameter to define the default value of the parameters that follow it:


/ /   Thi s   f unc t i on di mens i ons .
/ /   I f    onl y   wi dt h wi de.

r et ur ns   an   obj ec t

i s   s uppl i ed,	make

r epr es ent i ng   a   r ec t angl e' s

i t   t wi c e   as   hi gh   as   i t   i s

c ons t   r ec t angl e   =   ( wi dt h,	hei ght =wi dt h*2)    =>   ( { wi dt h,	hei ght } ) ; r ec t angl e( 1)	/ /   =>   {    wi dt h:	1,	hei ght :	2   }


This code demonstrates that parameter defaults work with arrow functions. The same is true for method shorthand functions and all other forms of function definitions.


8.3.2 Rest Parameters and Variable-Length Argument Lists

Parameter defaults enable us to write functions that can be invoked with fewer arguments than parameters. Rest parameters enable the opposite case: they allow us to write functions that can be invoked with arbitrarily more arguments than parameters. Here is an example function that expects one or more numeric arguments and returns the largest one:

f unc t i on   max( f i r s t =- I nf i ni t y,	. . . r es t )    {
l et   maxVal ue   =   f i r s t ;	/ /   St ar t   by   as s umi ng   t he   f i r s t   ar g   i s
bi gges t
/ /   Then   l oop   t hr ough   t he   r es t   of    t he   ar gument s ,	l ooki ng   f or bi gger
f or ( l et   n   of    r es t )    {
i f    ( n   >   maxVal ue)    { maxVal ue   =   n;
}

}
/ /   Ret ur n   t he   bi gges t r et ur n   maxVal ue;
}

max( 1,	10,	100,	2,	3,	1000,	4,	5,	6)	/ /   =>   1000


A rest parameter is preceded by three periods, and it must be the last parameter in a function declaration. When you invoke a function with a rest parameter, the arguments you pass are first assigned to the non-rest parameters, and then any remaining arguments (i.e., the “rest” of the arguments) are stored in an array that becomes the value of the rest parameter. This last point is important: within the body of a function, the value of a rest parameter will always be an array. The array may be empty, but a rest parameter will never be undef i ned. (It follows from this that it is never useful—and not legal—to define a parameter default for a rest parameter.)

Functions like the previous example that can accept any number of arguments are called variadic functions, variable arity functions, or vararg functions. This book uses the most colloquial term, varargs, which dates to the early days of the C programming language.


Don’t confuse the . . .  that defines a rest parameter in a function definition with the . . .  spread operator, described in §8.3.4, which can be used in function invocations.


8.3.3 The Arguments Object

Rest parameters were introduced into JavaScript in ES6. Before that version of the language, varargs functions were written using the Arguments object: within the body of any function, the identifier

ar gument s  refers to the Arguments object for that invocation. The Arguments object is an array-like object (see §7.9) that allows the argument values passed to the function to be retrieved by number, rather than by name. Here is the max( )  function from earlier, rewritten to use the Arguments object instead of a rest parameter:

f unc t i on   max( x)    {
l et   maxVal ue   =   - I nf i ni t y;
/ /   L oop   t hr ough   t he   ar gument s ,	l ooki ng   f or ,	and   r emember i ng, t he   bi gges t .
f or ( l et   i	=   0;	i	<   ar gument s . l engt h;	i ++)    {
i f    ( ar gument s [ i ]    >   maxVal ue)    maxVal ue   =   ar gument s [ i ] ; }
/ /   Ret ur n   t he   bi gges t r et ur n   maxVal ue;
}

max( 1,	10,	100,	2,	3,	1000,	4,	5,	6)	/ /   =>   1000


The Arguments object dates back to the earliest days of JavaScript and carries with it some strange historical baggage that makes it inefficient and hard to optimize, especially outside of strict mode. You may still encounter code that uses the Arguments object, but you should avoid using it in any new code you write. When refactoring old code, if you encounter a function that uses ar gument s , you can often replace it with a
. . . ar gs  rest parameter. Part of the unfortunate legacy of the Arguments object is that, in strict mode, ar gument s  is treated as a reserved word, and you cannot declare a function parameter or a local variable with that name.


8.3.4 The Spread Operator for Function Calls

The spread operator . . .  is used to unpack, or “spread out,” the elements of an array (or any other iterable object, such as strings) in a context where

individual values are expected. We’ve seen the spread operator used with array literals in §7.1.2. The operator can be used, in the same way, in function invocations:

l et   number s   =   [ 5,	2,	10,	- 1,	9,	100,	1] ; Mat h. mi n( . . . number s )      / /   =>   - 1


Note that . . .  is not a true operator in the sense that it cannot be evaluated to produce a value. Instead, it is a special JavaScript syntax that can be used in array literals and function invocations.

When we use the same . . .  syntax in a function definition rather than a function invocation, it has the opposite effect to the spread operator. As we saw in §8.3.2, using . . .  in a function definition gathers multiple function arguments into an array. Rest parameters and the spread operator are often useful together, as in the following function, which takes a function argument and returns an instrumented version of the function for testing:

/ /   Thi s   f unc t i on   t akes   a   f unc t i on   and   r et ur ns   a   wr apped   ver s i on f unc t i on   t i med( f )    {
r et ur n   f unc t i on( . . . ar gs )    {	/ /   Col l ec t   ar gs   i nt o   a   r es t par amet er   ar r ay
c ons ol e. l og( ` Ent er i ng   f unc t i on   ${ f . name} ` ) ; l et   s t ar t Ti me   =   Dat e. now( ) ;
t r y   {
/ /   Pas s   al l	of    our   ar gument s   t o   t he   wr apped   f unc t i on r et ur n   f ( . . . ar gs ) ;	/ /   Spr ead   t he   ar gs   bac k   out
agai n
}
f i nal l y   {
/ /   Bef or e   we   r et ur n   t he   wr apped   r et ur n   val ue,	pr i nt el aps ed   t i me.
c ons ol e. l og( ` Exi t i ng   ${ f . name}    af t er   ${ Dat e. now( ) -
s t ar t Ti me} ms ` ) ; }
} ;

}

/ /   Comput e   t he   s um of    t he   number s   bet ween   1   and   n   by   br ut e   f or c e f unc t i on   benc hmar k( n)    {
l et   s um =   0;
f or ( l et   i	=   1;	i	<=   n;	i ++)    s um +=   i ; r et ur n   s um;
}

/ /   Now  i nvoke   t he   t i med   ver s i on   of    t hat   t es t   f unc t i on
t i med( benc hmar k) ( 1000000)    / /   =>   500000500000;	t hi s   i s   t he   s um of t he   number s


8.3.5 Destructuring Function Arguments into Parameters

When you invoke a function with a list of argument values, those values end up being assigned to the parameters declared in the function definition. This initial phase of function invocation is a lot like variable assignment. So it should not be surprising that we can use the techniques of destructuring assignment (see §3.10.3) with functions.


If you define a function that has parameter names within square brackets, you are telling the function to expect an array value to be passed for each pair of square brackets. As part of the invocation process, the array arguments will be unpacked into the individually named parameters. As an example, suppose we are representing 2D vectors as arrays of two numbers, where the first element is the X coordinate and the second element is the Y coordinate. With this simple data structure, we could write the following function to add two vectors:

f unc t i on   vec t or Add( v1,	v2)    {
r et ur n   [ v1[ 0]    +   v2[ 0] ,	v1[ 1]    +   v2[ 1] ] ; }
vec t or Add( [ 1, 2] ,	[ 3, 4] )	/ /   =>   [ 4, 6]

The code would be easier to understand if we destructured the two vector arguments into more clearly named parameters:

f unc t i on   vec t or Add( [ x1, y1] ,	[ x2, y2] )    {    / /   Unpac k   2   ar gument s i nt o   4   par amet er s
r et ur n   [ x1   +   x2,	y1   +   y2] ; }
vec t or Add( [ 1, 2] ,	[ 3, 4] )	/ /   =>   [ 4, 6]


Similarly, if you are defining a function that expects an object argument, you can destructure parameters of that object. Let’s use a vector example again, except this time, let’s suppose that we represent vectors as objects with x and y parameters:

/ /   Mul t i pl y   t he   vec t or   { x, y}    by   a   s c al ar   val ue f unc t i on   vec t or Mul t i pl y( { x,	y} ,	s c al ar )    {
r et ur n   {    x:	x*s c al ar ,	y:	y*s c al ar   } ; }
vec t or Mul t i pl y( { x:	1,	y:	2} ,	2)	/ /   =>   { x:	2,	y:	4}


This example of destructuring a single object argument into two parameters is a fairly clear one because the parameter names we use match the property names of the incoming object. The syntax is more verbose and more confusing when you need to destructure properties with one name into parameters with different names. Here’s the vector addition example, implemented for object-based vectors:

f unc t i on   vec t or Add(

{ x:	x1,	y:	y1} , { x:	x2,	y:	y2}
)
{

/ /   Unpac k
/ /   Unpac k

1s t   obj ec t
2nd   obj ec t

i nt o   x1   and   y1   par ams
i nt o   x2   and   y2   par ams

r et ur n   {    x:	x1   +   x2,	y:	y1   +   y2   } ; }
vec t or Add( { x:	1,	y:	2} ,	{ x:	3,	y:	4} )	/ /   =>   { x:	4,	y:	6}

The tricky thing about destructuring syntax like { x: x1,	y: y1}  is remembering which are the property names and which are the parameter names. The rule to keep in mind for destructuring assignment and destructuring function calls is that the variables or parameters being declared go in the spots where you’d expect values to go in an object literal. So property names are always on the lefthand side of the colon, and the parameter (or variable) names are on the right.

You can define parameter defaults with destructured parameters. Here’s vector multiplication that works with 2D or 3D vectors:

/ /   Mul t i pl y   t he   vec t or   { x, y}    or   { x, y, z }    by   a   s c al ar   val ue f unc t i on   vec t or Mul t i pl y( { x,	y,	z =0} ,	s c al ar )    {
r et ur n   {    x:	x*s c al ar ,	y:	y*s c al ar ,	z :	z *s c al ar   } ; }
vec t or Mul t i pl y( { x:	1,	y:	2} ,	2)	/ /   =>   { x:	2,	y:	4,	z :	0}


Some languages (like Python) allow the caller of a function to invoke a function with arguments specified in name=val ue form, which is convenient when there are many optional arguments or when the parameter list is long enough that it is hard to remember the correct order. JavaScript does not allow this directly, but you can approximate it by destructuring an object argument into your function parameters. Consider a function that copies a specified number of elements from one array into another array with optionally specified starting offsets for each array. Since there are five possible parameters, some of which have defaults, and it would be hard for a caller to remember which order to pass the arguments in, we can define and invoke the ar r aycopy( )  function like this:

f unc t i on   ar r ayc opy( { f r om,	t o=f r om,	n=f r om. l engt h,	f r omI ndex=0, t oI ndex=0} )    {

l et   val ues ToCopy   =   f r om. s l i c e( f r omI ndex,	f r omI ndex   +   n) ; t o. s pl i c e( t oI ndex,	0,	. . . val ues ToCopy) ;
r et ur n   t o; }
l et   a   =   [ 1, 2, 3, 4, 5] ,	b   =   [ 9, 8, 7, 6, 5] ;
ar r ayc opy( { f r om:	a,	n:	3,	t o:	b,	t oI ndex:	4} )    / /   => [ 9, 8, 7, 6, 1, 2, 3, 5]


When you destructure an array, you can define a rest parameter for extra values within the array that is being unpacked. That rest parameter within the square brackets is completely different than the true rest parameter for the function:

/ /   Thi s   f unc t i on   expec t s   an   ar r ay   ar gument .	The   f i r s t   t wo el ement s   of    t hat
/ /   ar r ay   ar e   unpac ked   i nt o   t he   x   and   y   par amet er s .	Any   r emai ni ng el ement s
/ /   ar e   s t or ed   i n   t he   c oor ds   ar r ay.	And   any   ar gument s   af t er   t he f i r s t   ar r ay
/ /   ar e   pac ked   i nt o   t he   r es t   ar r ay.
f unc t i on   f ( [ x,	y,	. . . c oor ds ] ,	. . . r es t )    {
r et ur n   [ x+y,	. . . r es t ,	. . . c oor ds ] ;	/ /   Not e:	s pr ead   oper at or her e
}
f ( [ 1,	2,	3,	4] ,	5,	6)	/ /   =>   [ 3,	5,	6,	3,	4]


In ES2018, you can also use a rest parameter when you destructure an object. The value of that rest parameter will be an object that has any properties that did not get destructured. Object rest parameters are often useful with the object spread operator, which is also a new feature of ES2018:

/ /   Mul t i pl y   t he   vec t or   { x, y}    or   { x, y, z }    by   a   s c al ar   val ue, r et ai n   ot her   pr ops
f unc t i on   vec t or Mul t i pl y( { x,	y,	z =0,	. . . pr ops } ,	s c al ar )    {
r et ur n   {    x:	x*s c al ar ,	y:	y*s c al ar ,	z :	z *s c al ar ,	. . . pr ops   } ; }
vec t or Mul t i pl y( { x:	1,	y:	2,	w:	- 1} ,	2)	/ /   =>   { x:	2,	y:	4,	z :	0, w:	- 1}

Finally, keep in mind that, in addition to destructuring argument objects and arrays, you can also destructure arrays of objects, objects that have array properties, and objects that have object properties, to essentially any depth. Consider graphics code that represents circles as objects with x, y, r adi us , and col or  properties, where the col or  property is an array of red, green, and blue color components. You might define a function that expects a single circle object to be passed to it but destructures that circle object into six separate parameters:

f unc t i on   dr awCi r c l e( { x,	y,	r adi us ,	c ol or :	[ r ,	g,	b] } )    { / /   Not   yet   i mpl ement ed
}


If function argument destructuring is any more complicated than this, I find that the code becomes harder to read, rather than simpler. Sometimes, it is clearer to be explicit about your object property access and array indexing.


8.3.6 Argument Types

JavaScript method parameters have no declared types, and no type checking is performed on the values you pass to a function. You can help make your code self-documenting by choosing descriptive names for function arguments and by documenting them carefully in the comments for each function. (Alternatively, see §17.8 for a language extension that allows you to layer type checking on top of regular JavaScript.)


As described in §3.9, JavaScript performs liberal type conversion as needed. So if you write a function that expects a string argument and then call that function with a value of some other type, the value you passed will simply be converted to a string when the function tries to use it as a

string. All primitive types can be converted to strings, and all objects have t oSt r i ng( )  methods (if not necessarily useful ones), so an error never occurs in this case.

This is not always true, however. Consider again the ar r aycopy( ) method shown earlier. It expects one or two array arguments and will fail if these arguments are of the wrong type. Unless you are writing a private function that will only be called from nearby parts of your code, it may be worth adding code to check the types of arguments like this. It is better for a function to fail immediately and predictably when passed bad values than to begin executing and fail later with an error message that is likely to be unclear. Here is an example function that performs type-checking:


/ /   Ret ur n   t he   s um of / /   The   el ement s   of    a

t he   el ement s   an   i t er abl e   obj ec t   a. mus t   al l	be   number s .

f unc t i on   s um( a)    {
l et   t ot al	=   0;
f or ( l et   el ement   of    a)    {    / /   Thr ows   TypeEr r or   i f    a   i s   not i t er abl e
i f    ( t ypeof    el ement   ! ==   " number " )    {
t hr ow  new  TypeEr r or ( " s um( ) :	el ement s   mus t   be number s " ) ;
}
t ot al	+=   el ement ; }
r et ur n   t ot al ; }
s um( [ 1, 2, 3] )	/ /   =>   6
s um( 1,	2,	3) ;	/ /   ! TypeEr r or :	1   i s   not   i t er abl e
s um( [ 1, 2, " 3" ] ) ;	/ /   ! TypeEr r or :	el ement   2   i s   not   a   number



8.4 Functions as Values

The most important features of functions are that they can be defined and invoked. Function definition and invocation are syntactic features of

JavaScript and of most other programming languages. In JavaScript, however, functions are not only syntax but also values, which means they can be assigned to variables, stored in the properties of objects or the elements of arrays, passed as arguments to functions, and so on.3


To understand how functions can be JavaScript data as well as JavaScript syntax, consider this function definition:

f unc t i on   s quar e( x)    {    r et ur n   x*x;	}


This definition creates a new function object and assigns it to the variable s quar e. The name of a function is really immaterial; it is simply the name of a variable that refers to the function object. The function can be assigned to another variable and still work the same way:

l et   s   =   s quar e;	/ /   Now  s   r ef er s   t o   t he   s ame   f unc t i on   t hat s quar e   does
s quar e( 4)                       / /   =>   16 s ( 4)                                    / /   =>   16


Functions can also be assigned to object properties rather than variables. As we’ve already discussed, we call the functions “methods” when we do this:

l et   o   =   { s quar e:	f unc t i on( x)    {    r et ur n   x*x;	} } ;	/ /   An   obj ec t l i t er al
l et   y   =   o. s quar e( 16) ;	/ /   y   ==   256


Functions don’t even require names at all, as when they’re assigned to array elements:

l et   a   =   [ x   =>   x*x,	20] ;	/ /   An   ar r ay   l i t er al a[ 0] ( a[ 1] )                                       / /   =>   400

The syntax of this last example looks strange, but it is still a legal function invocation expression!


As an example of how useful it is to treat functions as values, consider the Ar r ay. s or t ( )  method. This method sorts the elements of an array. Because there are many possible orders to sort by (numerical order, alphabetical order, date order, ascending, descending, and so on), the
s or t ( )  method optionally takes a function as an argument to tell it how to perform the sort. This function has a simple job: for any two values it is passed, it returns a value that specifies which element would come first in a sorted array. This function argument makes Ar r ay. s or t ( )  perfectly general and infinitely flexible; it can sort any type of data into any conceivable order. Examples are shown in §7.8.6.

Example 8-1 demonstrates the kinds of things that can be done when functions are used as values. This example may be a little tricky, but the comments explain what is going on.

Example 8-1. Using functions as data
/ /   We   def i ne   s ome   s i mpl e   f unc t i ons   her e f unc t i on   add( x, y)    {    r et ur n   x   +   y;	}

f unc t i on
f unc t i on

s ubt r ac t ( x, y)
mul t i pl y( x, y)

{    r et ur n   x   -    y;	}
{    r et ur n   x   *   y;	}

f unc t i on   di vi de( x, y)    {    r et ur n   x   /   y;	}


/ /   Her e' s   a   f unc t i on   t hat   t akes   one / /   as   an   ar gument   and   i nvokes   i t   on

of    t he   pr ec edi ng   f unc t i ons t wo   oper ands

f unc t i on   oper at e( oper at or ,	oper and1,	oper and2)    { r et ur n   oper at or ( oper and1,	oper and2) ;
}

/ /   We   c oul d   i nvoke   t hi s   f unc t i on   l i ke   t hi s   t o   c omput e   t he   val ue ( 2+3)    +   ( 4*5) :
l et   i	=   oper at e( add,	oper at e( add,	2,	3) ,	oper at e( mul t i pl y,	4,	5) ) ;

/ /   For   t he   s ake   of    t he   exampl e,	we   i mpl ement   t he   s i mpl e   f unc t i ons

agai n,
/ /   t hi s   t i me   wi t hi n   an   obj ec t   l i t er al ; c ons t   oper at or s   =   {

add:
s ubt r ac t : mul t i pl y:
di vi de:

( x, y)    =>   x+y, ( x, y)    =>   x- y, ( x, y)    =>   x*y,
( x, y)    =>   x/ y,

pow:	Mat h. pow	/ /   Thi s   wor ks   f or   pr edef i ned   f unc t i ons   t oo } ;


/ /   Thi s   f unc t i on   t akes   t he   name   of    an   oper at or ,	l ooks oper at or
/ /   i n   t he   obj ec t ,	and   t hen   i nvokes   i t   on   t he   s uppl i ed Not e
/ /   t he   s ynt ax   us ed   t o   i nvoke   t he   oper at or   f unc t i on.

up   t hat

oper ands .

f unc t i on   oper at e2( oper at i on,	oper and1,	oper and2)    {
i f    ( t ypeof    oper at or s [ oper at i on]    ===   " f unc t i on" )    {
r et ur n   oper at or s [ oper at i on] ( oper and1,	oper and2) ; }
el s e   t hr ow  " unknown   oper at or " ; }

oper at e2( " add" ,	" hel l o" ,	oper at e2( " add" ,	"   " ,	" wor l d" ) )    / /   => " hel l o   wor l d"
oper at e2( " pow" ,	10,	2)	/ /   =>   100


8.4.1 Defining Your Own Function Properties

Functions are not primitive values in JavaScript, but a specialized kind of object, which means that functions can have properties. When a function needs a “static” variable whose value persists across invocations, it is often convenient to use a property of the function itself. For example, suppose you want to write a function that returns a unique integer whenever it is invoked. The function must never return the same value twice. In order to manage this, the function needs to keep track of the values it has already returned, and this information must persist across function invocations. You could store this information in a global variable, but that is unnecessary, because the information is used only by the

function itself. It is better to store the information in a property of the Function object. Here is an example that returns a unique integer whenever it is called:

/ /   I ni t i al i z e   t he   c ount er   pr oper t y   of    t he   f unc t i on   obj ec t . / /   Func t i on   dec l ar at i ons   ar e   hoi s t ed   s o   we   r eal l y   c an
/ /   do   t hi s   as s i gnment   bef or e   t he   f unc t i on   dec l ar at i on. uni queI nt eger . c ount er   =   0;


/ /   Thi s   f unc t i on   r et ur ns c al l ed.
/ /   I t   us es   a   pr oper t y   of r et ur ned.

a   di f f er ent   i nt eger   eac h   t i me   i t   i s

i t s el f    t o   r emember   t he   next   val ue   t o   be

f unc t i on   uni queI nt eger ( )    {
r et ur n   uni queI nt eger . c ount er ++;	/ /   Ret ur n   and   i nc r ement c ount er   pr oper t y
}
uni queI nt eger ( )      / /   =>   0 uni queI nt eger ( )      / /   =>   1


As another example, consider the following f act or i al ( )  function that uses properties of itself (treating itself as an array) to cache previously computed results:

/ /   Comput e   f ac t or i al s   and   c ac he   r es ul t s   as   pr oper t i es   of    t he f unc t i on   i t s el f .
f unc t i on   f ac t or i al ( n)    {
i f    ( Number . i s I nt eger ( n)    &&  n   >   0)    {	/ /   Pos i t i ve i nt eger s   onl y
i f    ( ! ( n   i n   f ac t or i al ) )    {	/ /   I f    no c ac hed   r es ul t
f ac t or i al [ n]    =   n   *   f ac t or i al ( n- 1) ;	/ /   Comput e   and c ac he   i t
}
r et ur n   f ac t or i al [ n] ;	/ /   Ret ur n   t he c ac hed   r es ul t
}    el s e   {
r et ur n   NaN;	/ /   I f    i nput was   bad
} }

f ac t or i al [ 1]    =   1;	/ /   I ni t i al i z e   t he   c ac he   t o   hol d   t hi s   bas e c as e.

f ac t or i al ( 6)
f ac t or i al [ 5]

/ /   =>   720
/ /   =>   120;	t he   c al l	above   c ac hes   t hi s   val ue




8.5 Functions as Namespaces

Variables declared within a function are not visible outside of the function. For this reason, it is sometimes useful to define a function simply to act as a temporary namespace in which you can define variables without cluttering the global namespace.


Suppose, for example, you have a chunk of JavaScript code that you want to use in a number of different JavaScript programs (or, for client-side JavaScript, on a number of different web pages). Assume that this code, like most code, defines variables to store the intermediate results of its computation. The problem is that since this chunk of code will be used in many different programs, you don’t know whether the variables it creates will conflict with variables created by the programs that use it. The solution is to put the chunk of code into a function and then invoke the function. This way, variables that would have been global become local to the function:

f unc t i on   c hunkNames pac e( )    {

/ /   Chunk   of    c ode   goes   her e
/ /   Any   var i abl es   def i ned   i n   t he f unc t i on
/ /   i ns t ead   of    c l ut t er i ng   up   t he }


c hunk   ar e   l oc al	t o   t hi s

gl obal	names pac e.

c hunkNames pac e( ) ;	/ /   But   don' t   f or get   t o   i nvoke   t he   f unc t i on!


This code defines only a single global variable: the function name chunkNames pace. If defining even a single property is too much, you can define and invoke an anonymous function in a single expression:

( f unc t i on( )    {	/ /   c hunkNames pac e( )    f unc t i on   r ewr i t t en   as   an unnamed   expr es s i on.
/ /   Chunk   of    c ode   goes   her e
} ( ) ) ;	/ /   End   t he   f unc t i on   l i t er al	and   i nvoke   i t   now.


This technique of defining and invoking a function in a single expression is used frequently enough that it has become idiomatic and has been given the name “immediately invoked function expression.” Note the use of parentheses in the previous code example. The open parenthesis before
f unct i on is required because without it, the JavaScript interpreter tries to parse the f unct i on keyword as a function declaration statement. With the parenthesis, the interpreter correctly recognizes this as a function definition expression. The leading parenthesis also helps human readers recognize when a function is being defined to be immediately invoked instead of defined for later use.

This use of functions as namespaces becomes really useful when we define one or more functions inside the namespace function using variables within that namesapce, but then pass them back out as the return value of the namespace function. Functions like this are known as closures, and they’re the topic of the next section.


8.6 Closures

Like most modern programming languages, JavaScript uses lexical scoping. This means that functions are executed using the variable scope that was in effect when they were defined, not the variable scope that is in effect when they are invoked. In order to implement lexical scoping, the internal state of a JavaScript function object must include not only the code of the function but also a reference to the scope in which the function definition appears. This combination of a function object and a scope (a

set of variable bindings) in which the function’s variables are resolved is called a closure in the computer science literature.


Technically, all JavaScript functions are closures, but because most functions are invoked from the same scope that they were defined in, it normally doesn’t really matter that there is a closure involved. Closures become interesting when they are invoked from a different scope than the one they were defined in. This happens most commonly when a nested function object is returned from the function within which it was defined. There are a number of powerful programming techniques that involve this kind of nested function closures, and their use has become relatively common in JavaScript programming. Closures may seem confusing when you first encounter them, but it is important that you understand them well enough to use them comfortably.


The first step to understanding closures is to review the lexical scoping rules for nested functions. Consider the following code:

l et   s c ope   =   " gl obal	s c ope" ;	/ /   A  gl obal	var i abl e f unc t i on   c hec ks c ope( )    {
l et   s c ope   =   " l oc al	s c ope" ;	/ /   A  l oc al	var i abl e
f unc t i on   f ( )    {    r et ur n   s c ope;	}	/ /   Ret ur n   t he   val ue   i n s c ope   her e
r et ur n   f ( ) ; }
c hec ks c ope( )	/ /   =>   " l oc al	s c ope"


The checks cope( )  function declares a local variable and then defines and invokes a function that returns the value of that variable. It should be clear to you why the call to checks cope( )  returns “local scope”. Now, let’s change the code just slightly. Can you tell what this code will return?

l et   s c ope   =   " gl obal	s c ope" ;	/ /   A  gl obal	var i abl e

f unc t i on   c hec ks c ope( )    {
l et   s c ope   =   " l oc al	s c ope" ;	/ /   A  l oc al	var i abl e
f unc t i on   f ( )    {    r et ur n   s c ope;	}	/ /   Ret ur n   t he   val ue   i n s c ope   her e
r et ur n   f ; }
l et   s   =   c hec ks c ope( ) ( ) ;	/ /   What   does   t hi s   r et ur n?


In this code, a pair of parentheses has moved from inside
checks cope( )  to outside of it. Instead of invoking the nested function and returning its result, checks cope( )  now just returns the nested function object itself. What happens when we invoke that nested function (with the second pair of parentheses in the last line of code) outside of the function in which it was defined?

Remember the fundamental rule of lexical scoping: JavaScript functions are executed using the scope they were defined in. The nested function
f ( )  was defined in a scope where the variable s cope was bound to the value “local scope”. That binding is still in effect when f  is executed, no matter where it is executed from. So the last line of the preceding code example returns “local scope”, not “global scope”. This, in a nutshell, is the surprising and powerful nature of closures: they capture the local variable (and parameter) bindings of the outer function within which they are defined.

In §8.4.1, we defined a uni queI nt eger ( )  function that used a property of the function itself to keep track of the next value to be returned. A shortcoming of that approach is that buggy or malicious code could reset the counter or set it to a noninteger, causing the
uni queI nt eger ( )  function to violate the “unique” or the “integer” part of its contract. Closures capture the local variables of a single function invocation and can use those variables as private state. Here is

how we could rewrite the uni queI nt eger ( )  using an immediately invoked function expression to define a namespace and a closure that uses that namespace to keep its state private:

l et   uni queI nt eger   =   ( f unc t i on( )    {	/ /   Def i ne   and   i nvoke
l et   c ount er   =   0;	/ /   Pr i vat e   s t at e   of    f unc t i on bel ow
r et ur n   f unc t i on( )    {    r et ur n   c ount er ++;	} ; } ( ) ) ;
uni queI nt eger ( )      / /   =>   0 uni queI nt eger ( )      / /   =>   1


In order to understand this code, you have to read it carefully. At first glance, the first line of code looks like it is assigning a function to the variable uni queI nt eger . In fact, the code is defining and invoking (as hinted by the open parenthesis on the first line) a function, so it is the return value of the function that is being assigned to uni queI nt eger . Now, if we study the body of the function, we see that its return value is another function. It is this nested function object that gets assigned to
uni queI nt eger . The nested function has access to the variables in its scope and can use the count er  variable defined in the outer function. Once that outer function returns, no other code can see the count er variable: the inner function has exclusive access to it.

Private variables like count er  need not be exclusive to a single closure: it is perfectly possible for two or more nested functions to be defined within the same outer function and share the same scope. Consider the following code:

f unc t i on   c ount er ( )    { l et   n   =   0;
r et ur n   {
c ount :	f unc t i on( )    {    r et ur n   n++;	} ,

r es et :	f unc t i on( )    {    n   =   0;	} } ;
}

l et   c   =   c ount er ( ) ,	d   =   c ount er ( ) ;	/ /   Cr eat e   t wo   c ount er s

c . c ount ( ) d. c ount ( )
i ndependent l y

/ /   =>   0
/ /   =>   0:	t hey   c ount

c . r es et ( ) ;	/ /   r es et ( )    and   c ount ( ) met hods   s har e   s t at e
c . c ount ( )	/ /   =>   0:	bec aus e   we   r es et   c d. c ount ( )	/ /   =>   1:	d   was   not   r es et


The count er ( )  function returns a “counter” object. This object has two methods: count ( )  returns the next integer, and r es et ( )  resets the internal state. The first thing to understand is that the two methods share access to the private variable n. The second thing to understand is that each invocation of count er ( )  creates a new scope—independent of the scopes used by previous invocations—and a new private variable within that scope. So if you call count er ( )  twice, you get two counter objects with different private variables. Calling count ( )  or r es et ( )  on one counter object has no effect on the other.

It is worth noting here that you can combine this closure technique with property getters and setters. The following version of the count er ( ) function is a variation on code that appeared in §6.10.6, but it uses closures for private state rather than relying on a regular object property:

f unc t i on   c ount er ( n)    {	/ /   Func t i on   ar gument   n   i s   t he   pr i vat e var i abl e
r et ur n   {
/ /   Pr oper t y   get t er   met hod   r et ur ns   and   i nc r ement s   pr i vat e c ount er   var .
get   c ount ( )    {    r et ur n   n++;	} ,
/ /   Pr oper t y   s et t er   does n' t   al l ow  t he   val ue   of    n   t o dec r eas e

s et   c ount ( m)    {
i f    ( m >   n)    n   =   m;
el s e   t hr ow  Er r or ( " c ount   c an   onl y   be   s et   t o   a   l ar ger val ue" ) ;
} } ;
}

l et   c   =   c ount er ( 1000) ;

c . c ount c . c ount
c . c ount   =   2000;
c . c ount

/ /   =>   1000 / /   =>   1001

/ /   =>   2000

c . c ount   =   2000;	/ /   ! Er r or :	c ount   c an   onl y   be   s et   t o   a   l ar ger val ue


Note that this version of the count er ( )  function does not declare a local variable but just uses its parameter n to hold the private state shared by the property accessor methods. This allows the caller of count er ( )  to specify the initial value of the private variable.

Example 8-2 is a generalization of the shared private state through the closures technique we’ve been demonstrating here. This example defines an addPr i vat ePr oper t y( )  function that defines a private variable and two nested functions to get and set the value of that variable. It adds these nested functions as methods of the object you specify.

Example 8-2. Private property accessor methods using closures
/ /   Thi s   f unc t i on   adds   pr oper t y   ac c es s or   met hods   f or   a   pr oper t y wi t h
/ /   t he   s pec i f i ed   name   t o   t he   obj ec t   o.	The   met hods   ar e   named get <name>
/ /   and   s et <name>.	I f    a   pr edi c at e   f unc t i on   i s   s uppl i ed,	t he   s et t er
/ /   met hod   us es   i t   t o   t es t   i t s   ar gument   f or   val i di t y   bef or e   s t or i ng i t .
/ /   I f    t he   pr edi c at e   r et ur ns   f al s e,	t he   s et t er   met hod   t hr ows   an exc ept i on.
/ /
/ /   The   unus ual	t hi ng   about   t hi s   f unc t i on   i s   t hat   t he   pr oper t y

val ue
/ /   t hat   i s   mani pul at ed   by   t he   get t er   and   s et t er   met hods   i s   not s t or ed   i n
/ /   t he   obj ec t   o.	I ns t ead,	t he   val ue   i s   s t or ed   onl y   i n   a   l oc al var i abl e
/ /   i n   t hi s   f unc t i on.	The   get t er   and   s et t er   met hods   ar e   al s o def i ned
/ /   l oc al l y   t o   t hi s   f unc t i on   and   t her ef or e   have   ac c es s   t o   t hi s l oc al	var i abl e.
/ /   Thi s   means   t hat   t he   val ue   i s   pr i vat e   t o   t he   t wo   ac c es s or met hods ,	and   i t
/ /   c annot   be   s et   or   modi f i ed   exc ept   t hr ough   t he   s et t er   met hod. f unc t i on   addPr i vat ePr oper t y( o,	name,	pr edi c at e)    {
l et   val ue;	/ /   Thi s   i s   t he   pr oper t y   val ue

/ /   The   get t er   met hod   s i mpl y   r et ur ns   t he   val ue. o[ ` get ${ name} ` ]    =   f unc t i on( )    {    r et ur n   val ue;	} ;

/ /   The   s et t er   met hod   s t or es   t he   val ue   or   t hr ows   an   exc ept i on i f
/ /   t he   pr edi c at e   r ej ec t s   t he   val ue. o[ ` s et ${ name} ` ]    =   f unc t i on( v)    {
i f    ( pr edi c at e   &&  ! pr edi c at e( v) )    {
t hr ow  new  TypeEr r or ( ` s et ${ name} :	i nval i d   val ue   ${ v} ` ) ; }    el s e   {
val ue   =   v; }
} ; }

/ /   The   f ol l owi ng   c ode   demons t r at es   t he   addPr i vat ePr oper t y( ) met hod.
l et   o   =   { } ;	/ /   Her e   i s   an   empt y   obj ec t

/ /   Add   pr oper t y   ac c es s or   met hods   get Name   and   s et Name( ) / /   Ens ur e   t hat   onl y   s t r i ng   val ues   ar e   al l owed
addPr i vat ePr oper t y( o,	" Name" ,	x   =>   t ypeof    x   ===   " s t r i ng" ) ;

o. s et Name( " Fr ank" ) ;	/ /   Set   t he   pr oper t y   val ue o. get Name( )	/ /   =>   " Fr ank"
o. s et Name( 0) ;	/ /   ! TypeEr r or :	t r y   t o   s et   a   val ue   of    t he wr ong   t ype

We’ve now seen a number of examples in which two closures are defined in the same scope and share access to the same private variable or

variables. This is an important technique, but it is just as important to recognize when closures inadvertently share access to a variable that they should not share. Consider the following code:

/ /   Thi s   f unc t i on   r et ur ns   a   f unc t i on   t hat   al ways   r et ur ns   v f unc t i on   c ons t f unc ( v)    {    r et ur n   ( )    =>   v;	}

/ /   Cr eat e   an   ar r ay   of    c ons t ant   f unc t i ons : l et   f unc s   =   [ ] ;
f or ( var   i	=   0;	i	<   10;	i ++)    f unc s [ i ]    =   c ons t f unc ( i ) ;

/ /   The   f unc t i on   at   ar r ay   el ement   5   r et ur ns   t he   val ue   5. f unc s [ 5] ( )	/ /   =>   5


When working with code like this that creates multiple closures using a loop, it is a common error to try to move the loop within the function that defines the closures. Think about the following code, for example:

/ /   Ret ur n   an   ar r ay   of    f unc t i ons   t hat   r et ur n   t he   val ues   0- 9 f unc t i on   c ons t f unc s ( )    {
l et   f unc s   =   [ ] ;
f or ( var   i	=   0;	i	<   10;	i ++)    { f unc s [ i ]    =   ( )    =>   i ;
}
r et ur n   f unc s ; }

l et   f unc s   =   c ons t f unc s ( ) ;
f unc s [ 5] ( )	/ /   =>   10;	Why   does n' t   t hi s   r et ur n   5?


This code creates 10 closures and stores them in an array. The closures are all defined within the same invocation of the function, so they share access to the variable i . When cons t f uncs ( )  returns, the value of the variable i  is 10, and all 10 closures share this value. Therefore, all the functions in the returned array of functions return the same value, which is not what we wanted at all. It is important to remember that the scope

associated with a closure is “live.” Nested functions do not make private copies of the scope or make static snapshots of the variable bindings. Fundamentally, the problem here is that variables declared with var  are defined throughout the function. Our f or  loop declares the loop variable with var   i , so the variable i  is defined throughout the function rather than being more narrowly scoped to the body of the loop. The code demonstrates a common category of bugs in ES5 and before, but the introduction of block-scoped variables in ES6 addresses the issue. If we just replace the var  with a l et  or a cons t , then the problem goes away. Because l et  and cons t  are block scoped, each iteration of the loop defines a scope that is independent of the scopes for all other iterations, and each of these scopes has its own independent binding of i .


Another thing to remember when writing closures is that t hi s  is a JavaScript keyword, not a variable. As discussed earlier, arrow functions inherit the t hi s  value of the function that contains them, but functions defined with the f unct i on keyword do not. So if you’re writing a closure that needs to use the t hi s  value of its containing function, you should use an arrow function, or call bi nd( ) , on the closure before returning it, or assign the outer t hi s  value to a variable that your closure will inherit:

c ons t   s el f    =   t hi s ;	/ /   Make   t he   t hi s   val ue   avai l abl e   t o   nes t ed f unc t i ons


8.7 Function Properties, Methods, and Constructor

We’ve seen that functions are values in JavaScript programs. The t ypeof operator returns the string “function” when applied to a function, but

functions are really a specialized kind of JavaScript object. Since functions are objects, they can have properties and methods, just like any other object. There is even a Funct i on( )  constructor to create new function objects. The subsections that follow document the l engt h, name, and pr ot ot ype properties; the cal l ( ) , appl y( ) , bi nd( ) , and t oSt r i ng( )  methods; and the Funct i on( )  constructor.


8.7.1 The length Property

The read-only l engt h property of a function specifies the arity of the function—the number of parameters it declares in its parameter list, which is usually the number of arguments that the function expects. If a function has a rest parameter, that parameter is not counted for the purposes of this l engt h property.


8.7.2 The name Property

The read-only name property of a function specifies the name that was used when the function was defined, if it was defined with a name, or the name of the variable or property that an unnamed function expression was assigned to when it was first created. This property is primarily useful when writing debugging or error messages.


8.7.3 The prototype Property

All functions, except arrow functions, have a pr ot ot ype property that refers to an object known as the prototype object. Every function has a different prototype object. When a function is used as a constructor, the newly created object inherits properties from the prototype object. Prototypes and the pr ot ot ype property were discussed in §6.2.3 and will be covered again in Chapter 9.

8.7.4 The call() and apply() Methods

cal l ( )  and appl y( )  allow you to indirectly invoke (§8.2.4) a function as if it were a method of some other object. The first argument to both
cal l ( )  and appl y( )  is the object on which the function is to be invoked; this argument is the invocation context and becomes the value of the t hi s  keyword within the body of the function. To invoke the function f ( )  as a method of the object o (passing no arguments), you could use either cal l ( )  or appl y( ) :

f . c al l ( o) ;
f . appl y( o) ;


Either of these lines of code are similar to the following (which assume that o does not already have a property named m):


o. m =   f ;	/ /   Make   f    a   t empor ar y   met hod   of    o. o. m( ) ;	/ /   I nvoke   i t ,	pas s i ng   no   ar gument s . del et e   o. m;	/ /   Remove   t he   t empor ar y   met hod.


Remember that arrow functions inherit the t hi s  value of the context where they are defined. This cannot be overridden with the cal l ( )  and appl y( )  methods. If you call either of those methods on an arrow function, the first argument is effectively ignored.

Any arguments to cal l ( )  after the first invocation context argument are the values that are passed to the function that is invoked (and these arguments are not ignored for arrow functions). For example, to pass two numbers to the function f ( )  and invoke it as if it were a method of the object o, you could use code like this:

f . c al l ( o,	1,	2) ;

The appl y( )  method is like the cal l ( )  method, except that the arguments to be passed to the function are specified as an array:

f . appl y( o,	[ 1, 2] ) ;


If a function is defined to accept an arbitrary number of arguments, the appl y( )  method allows you to invoke that function on the contents of an array of arbitrary length. In ES6 and later, we can just use the spread operator, but you may see ES5 code that uses appl y( )  instead. For example, to find the largest number in an array of numbers without using the spread operator, you could use the appl y( )  method to pass the elements of the array to the Mat h. max( )  function:

l et   bi gges t   =   Mat h. max. appl y( Mat h,	ar r ayOf Number s ) ;


The t r ace( )  function defined in the following is similar to the
t i med( )  function defined in §8.3.4, but it works for methods instead of functions. It uses the appl y( )  method instead of a spread operator, and by doing that, it is able to invoke the wrapped method with the same arguments and the same t hi s  value as the wrapper method:


/ /   Repl ac e   t he   met hod   named   m of    t he   obj ec t   o   wi t h t hat   l ogs
/ /   mes s ages   bef or e   and   af t er   i nvoki ng   t he   or i gi nal

a   ver s i on

met hod.

f unc t i on   t r ac e( o,	m)    {
l et   or i gi nal	=   o[ m] ;	/ /   Remember   or i gi nal	met hod   i n t he   c l os ur e.
o[ m]    =   f unc t i on( . . . ar gs )    {	/ /   Now  def i ne   t he   new  met hod. c ons ol e. l og( new  Dat e( ) ,    " Ent er i ng: " ,	m) ;	/ /   L og
mes s age.
l et   r es ul t   =   or i gi nal . appl y( t hi s ,	ar gs ) ;	/ /   I nvoke or i gi nal .
c ons ol e. l og( new  Dat e( ) ,	" Exi t i ng: " ,	m) ;	/ /   L og mes s age.
r et ur n   r es ul t ;	/ /   Ret ur n r es ul t .

} ; }


8.7.5 The bind() Method

The primary purpose of bi nd( )  is to bind a function to an object. When you invoke the bi nd( )  method on a function f  and pass an object o, the method returns a new function. Invoking the new function (as a function) invokes the original function f  as a method of o. Any arguments you pass to the new function are passed to the original function. For example:

f unc t i on   f ( y)    {    r et ur n   t hi s . x   +   y;	}    / /   Thi s   f unc t i on   needs   t o be   bound
l et   o   =   {    x:	1   } ;	/ /   An   obj ec t   we' l l	bi nd   t o l et   g   =   f . bi nd( o) ;	/ /   Cal l i ng   g( x)    i nvokes   f ( ) on   o
g( 2)	/ /   =>   3
l et   p   =   {    x:	10,	g   } ;	/ /   I nvoke   g( )    as   a   met hod of    t hi s   obj ec t
p. g( 2)	/ /   =>   3:	g   i s   s t i l l	bound t o   o,    not   p.


Arrow functions inherit their t hi s  value from the environment in which they are defined, and that value cannot be overridden with bi nd( ) , so if the function f ( )  in the preceding code was defined as an arrow function, the binding would not work. The most common use case for calling
bi nd( )  is to make non-arrow functions behave like arrow functions, however, so this limitation on binding arrow functions is not a problem in practice.

The bi nd( )  method does more than just bind a function to an object, however. It can also perform partial application: any arguments you pass to bi nd( )  after the first are bound along with the t hi s  value. This partial application feature of bi nd( )  does work with arrow functions.

Partial application is a common technique in functional programming and is sometimes called currying. Here are some examples of the bi nd( ) method used for partial application:

l et   s um =   ( x, y)    =>   x   +   y;	/ /   Ret ur n   t he   s um of    2   ar gs
l et   s uc c   =   s um. bi nd( nul l ,	1) ;	/ /   Bi nd   t he   f i r s t   ar gument   t o   1 s uc c ( 2)	/ /   =>   3:	x   i s   bound   t o   1,	and   we   pas s   2   f or   t he   y
ar gument

f unc t i on   f ( y, z )    {    r et ur n   t hi s . x   +   y   +   z ;	}
l et   g   =   f . bi nd( { x:	1} ,	2) ;	/ /   Bi nd   t hi s   and   y
g( 3)	/ /   =>   6:	t hi s . x   i s   bound   t o   1,	y   i s   bound   t o   2   and   z   i s 3


The name property of the function returned by bi nd( )  is the name property of the function that bi nd( )  was called on, prefixed with the word “bound”.


8.7.6 The toString() Method

Like all JavaScript objects, functions have a t oSt r i ng( )  method. The ECMAScript spec requires this method to return a string that follows the syntax of the function declaration statement. In practice, most (but not all) implementations of this t oSt r i ng( )  method return the complete source code for the function. Built-in functions typically return a string that includes something like “[native code]” as the function body.


8.7.7 The Function() Constructor

Because functions are objects, there is a Funct i on( )  constructor that can be used to create new functions:

c ons t   f    =   new  Func t i on( " x" ,	" y" ,	" r et ur n   x*y; " ) ;

This line of code creates a new function that is more or less equivalent to a function defined with the familiar syntax:

c ons t   f    =   f unc t i on( x,	y)    {    r et ur n   x*y;	} ;


The Funct i on( )  constructor expects any number of string arguments. The last argument is the text of the function body; it can contain arbitrary JavaScript statements, separated from each other by semicolons. All other arguments to the constructor are strings that specify the parameter names for the function. If you are defining a function that takes no arguments, you would simply pass a single string—the function body—to the constructor.

Notice that the Funct i on( )  constructor is not passed any argument that specifies a name for the function it creates. Like function literals, the Funct i on( )  constructor creates anonymous functions.


There are a few points that are important to understand about the Funct i on( )  constructor:

The Funct i on( )  constructor allows JavaScript functions to be dynamically created and compiled at runtime.

The Funct i on( )  constructor parses the function body and creates a new function object each time it is called. If the call to the constructor appears within a loop or within a frequently called function, this process can be inefficient. By contrast, nested functions and function expressions that appear within loops are not recompiled each time they are encountered.

A last, very important point about the Funct i on( )  constructor is that the functions it creates do not use lexical scoping; instead, they are always compiled as if they were top-level functions, as the following code demonstrates:



l et   s cope   =   " gl obal " ;
f unct i on  cons t r uct Funct i on( )   { l et   s cope   =   " l ocal " ;
r et ur n  new Funct i on( " r et ur n  s cope" ) ; / /   Does n' t   c apt ur e   l oc al	s c ope!
}
/ /   Thi s   l i ne   r et ur ns   " gl obal "   bec aus e   t he f unc t i on   r et ur ned   by   t he
/ /   Func t i on( )   c ons t r uc t or   does   not   us e   t he l oc al	s c ope.
cons t r uct Funct i on( ) ( )	/ /   =>   " gl obal "


The Funct i on( )  constructor is best thought of as a globally scoped version of eval ( )  (see §4.12.2) that defines new variables and functions in its own private scope. You will probably never need to use this constructor in your code.


8.8 Functional Programming

JavaScript is not a functional programming language like Lisp or Haskell, but the fact that JavaScript can manipulate functions as objects means that we can use functional programming techniques in JavaScript. Array methods such as map( )  and r educe( )  lend themselves particularly well to a functional programming style. The sections that follow demonstrate techniques for functional programming in JavaScript. They are intended as a mind-expanding exploration of the power of JavaScript’s functions, not as a prescription for good programming style.


8.8.1 Processing Arrays with Functions

Suppose we have an array of numbers and we want to compute the mean and standard deviation of those values. We might do that in nonfunctional style like this:

l et   dat a   =   [ 1, 1, 3, 5, 5] ;	/ /   Thi s   i s   our   ar r ay   of    number s

/ /   The   mean   i s   t he   s um of    t he   el ement s   di vi ded   by   t he   number   of el ement s
l et   t ot al	=   0;
f or ( l et   i	=   0;	i	<   dat a. l engt h;	i ++)    t ot al	+=   dat a[ i ] ;
l et   mean   =   t ot al / dat a. l engt h;	/ /   mean   ==   3;	The   mean   of    our dat a   i s   3

/ /   To   c omput e   t he   s t andar d   devi at i on,	we   f i r s t   s um t he   s quar es of
/ /   t he   devi at i on   of    eac h   el ement   f r om t he   mean. t ot al	=   0;
f or ( l et   i	=   0;	i	<   dat a. l engt h;	i ++)    { l et   devi at i on   =   dat a[ i ]    -    mean;
t ot al	+=   devi at i on   *   devi at i on; }
l et   s t ddev   =   Mat h. s qr t ( t ot al / ( dat a. l engt h- 1) ) ;	/ /   s t ddev   ==   2


We can perform these same computations in concise functional style using the array methods map( )  and r educe( )  like this (see §7.8.1 to review these methods):

/ /   Fi r s t ,	def i ne   t wo   s i mpl e   f unc t i ons c ons t   s um =   ( x, y)    =>   x+y;
c ons t   s quar e   =   x   =>   x*x;

/ /   Then   us e   t hos e   f unc t i ons   wi t h   Ar r ay   met hods   t o   c omput e   mean and   s t ddev

l et   dat a   =
l et   mean   =

[ 1, 1, 3, 5, 5] ;
dat a. r educ e( s um) / dat a. l engt h;	/ /   mean   ==   3

l et   devi at i ons   =   dat a. map( x   =>   x- mean) ; l et   s t ddev   =
Mat h. s qr t ( devi at i ons . map( s quar e) . r educ e( s um) / ( dat a. l engt h- 1) ) ; s t ddev	/ /   =>   2

This new version of the code looks quite different than the first one, but it is still invoking methods on objects, so it has some object-oriented conventions remaining. Let’s write functional versions of the map( )  and r educe( )  methods:


c ons t   map   =   f unc t i on( a,	. . . ar gs )    {    r et ur n   a. map( . . . ar gs ) ;	} ;
c ons t   r educ e   =   f unc t i on( a,	. . . ar gs )    {    r et ur n   a. r educ e( . . . ar gs ) ; } ;


With these map( )  and r educe( )  functions defined, our code to compute the mean and standard deviation now looks like this:

c ons t   s um =   ( x, y)    =>   x+y; c ons t   s quar e   =   x   =>   x*x;


l et   dat a   =
l et   mean   =

[ 1, 1, 3, 5, 5] ;
r educ e( dat a,	s um) / dat a. l engt h;

l et   devi at i ons   =   map( dat a,	x   =>   x- mean) ;
l et   s t ddev   =   Mat h. s qr t ( r educ e( map( devi at i ons ,	s quar e) , s um) / ( dat a. l engt h- 1) ) ;
s t ddev	/ /   =>   2


8.8.2 Higher-Order Functions

A higher-order function is a function that operates on functions, taking one or more functions as arguments and returning a new function. Here is an example:


/ /   Thi s   hi gher - or der   f unc t i on i t s
/ /   ar gument s   t o   f    and   r et ur ns val ue;

r et ur ns   a   new  f unc t i on   t hat   pas s es

t he   l ogi c al	negat i on   of    f ' s   r et ur n

f unc t i on   not ( f )    {
r et ur n   f unc t i on( . . . ar gs )    {	/ /   Ret ur n   a   new f unc t i on
l et   r es ul t   =   f . appl y( t hi s ,	ar gs ) ;	/ /   t hat   c al l s   f
r et ur n   ! r es ul t ;	/ /   and   negat es   i t s r es ul t .

} ; }

c ons t   even   =   x   =>   x   %  2   ===   0;	/ /   A  f unc t i on   t o   det er mi ne   i f    a number   i s   even
c ons t   odd   =   not ( even) ;	/ /   A  new  f unc t i on   t hat   does   t he oppos i t e
[ 1, 1, 3, 5, 5] . ever y( odd)	/ /   =>   t r ue:	ever y   el ement   of    t he ar r ay   i s   odd


This not ( )  function is a higher-order function because it takes a function argument and returns a new function. As another example, consider the mapper ( )  function that follows. It takes a function argument and returns a new function that maps one array to another using that function. This function uses the map( )  function defined earlier, and it is important that you understand how the two functions are different:

/ /   Ret ur n   a   f unc t i on   t hat   expec t s   an   ar r ay   ar gument   and   appl i es f    t o
/ /   eac h   el ement ,	r et ur ni ng   t he   ar r ay   of    r et ur n   val ues . / /   Cont r as t   t hi s   wi t h   t he   map( )    f unc t i on   f r om ear l i er . f unc t i on   mapper ( f )    {
r et ur n   a   =>   map( a,	f ) ; }

c ons t   i nc r ement   =   x   =>   x+1;
c ons t   i nc r ement Al l	=   mapper ( i nc r ement ) ; i nc r ement Al l ( [ 1, 2, 3] )	/ /   =>   [ 2, 3, 4]


Here is another, more general, example that takes two functions, f  and g, and returns a new function that computes f ( g( ) ) :

/ /   Ret ur n   a   new  f unc t i on   t hat   c omput es   f ( g( . . . ) ) .
/ /   The   r et ur ned   f unc t i on   h   pas s es   al l	of    i t s   ar gument s   t o   g, t hen   pas s es
/ /   t he   r et ur n   val ue   of    g   t o   f ,	t hen   r et ur ns   t he   r et ur n   val ue   of f .
/ /   Bot h   f    and   g   ar e   i nvoked   wi t h   t he   s ame   t hi s   val ue   as   h   was i nvoked   wi t h.
f unc t i on   c ompos e( f ,	g)    {

r et ur n   f unc t i on( . . . ar gs )    {

/ / val ue   and
/ /

We   us e   c al l

appl y   f or   g

f or   f    bec aus e

bec aus e   we' r e

we' r e   pas s i ng   a   s i ngl e

pas s i ng   an   ar r ay   of    val ues .

r et ur n   f . c al l ( t hi s ,	g. appl y( t hi s ,	ar gs ) ) ; } ;
}

c ons t   s um =   ( x, y)    =>   x+y; c ons t   s quar e   =   x   =>   x*x;
c ompos e( s quar e,	s um) ( 2, 3)	/ /   =>   25;	t he   s quar e   of    t he   s um


The par t i al ( )  and memoi z e( )  functions defined in the sections that follow are two more important higher-order functions.


8.8.3 Partial Application of Functions

The bi nd( )  method of a function f  (see §8.7.5) returns a new function that invokes f  in a specified context and with a specified set of arguments. We say that it binds the function to an object and partially applies the arguments. The bi nd( )  method partially applies arguments on the left— that is, the arguments you pass to bi nd( )  are placed at the start of the argument list that is passed to the original function. But it is also possible to partially apply arguments on the right:

/ /   The   ar gument s   t o   t hi s   f unc t i on   ar e   pas s ed   on   t he   l ef t f unc t i on   par t i al L ef t ( f ,	. . . out er Ar gs )    {
r et ur n   f unc t i on( . . . i nner Ar gs )    {    / /   Ret ur n   t hi s   f unc t i on
l et   ar gs   =   [ . . . out er Ar gs ,	. . . i nner Ar gs ] ;	/ /   Bui l d   t he ar gument   l i s t
r et ur n   f . appl y( t hi s ,	ar gs ) ;	/ /   Then   i nvoke f    wi t h   i t
} ; }

/ /   The   ar gument s   t o   t hi s   f unc t i on   ar e   pas s ed   on   t he   r i ght f unc t i on   par t i al Ri ght ( f ,	. . . out er Ar gs )    {
r et ur n   f unc t i on( . . . i nner Ar gs )    {	/ /   Ret ur n   t hi s   f unc t i on

l et   ar gs   =   [ . . . i nner Ar gs ,	. . . out er Ar gs ] ;	/ /   Bui l d   t he ar gument   l i s t
r et ur n   f . appl y( t hi s ,	ar gs ) ;	/ /   Then   i nvoke f    wi t h   i t
} ; }


/ /   The   ar gument s   t o   t hi s   f unc t i on   s er ve   as val ues
/ /   i n   t he   ar gument   l i s t   ar e   f i l l ed   i n   wi t h s et .

a   t empl at e.	Undef i ned

val ues   f r om t he   i nner

f unc t i on   par t i al ( f ,    . . . out er Ar gs )    { r et ur n   f unc t i on( . . . i nner Ar gs )    {
l et   ar gs   =   [ . . . out er Ar gs ] ;	/ /   l oc al	c opy   of    out er   ar gs t empl at e
l et   i nner I ndex=0;	/ /   whi c h   i nner   ar g   i s   next

/ / f r om i nner

L oop   t hr ough   t he   ar gs ,	f i l l i ng   i n   undef i ned   val ues ar gs

f or ( l et   i	=   0;	i	<   ar gs . l engt h;	i ++)    {
i f    ( ar gs [ i ]    ===   undef i ned)    ar gs [ i ]    = i nner Ar gs [ i nner I ndex++] ;
}
/ /   Now  append   any   r emai ni ng   i nner   ar gument s ar gs . pus h( . . . i nner Ar gs . s l i c e( i nner I ndex) ) ;
r et ur n   f . appl y( t hi s ,	ar gs ) ; } ;
}

/ /   Her e   i s   a   f unc t i on   wi t h   t hr ee   ar gument s
c ons t   f    =   f unc t i on( x, y, z )    {    r et ur n   x   *   ( y   -    z ) ;	} ;
/ /   Not i c e   how  t hes e   t hr ee   par t i al	appl i c at i ons   di f f er
par t i al L ef t ( f ,	2) ( 3, 4)	/ /   =>   - 2:	Bi nd   f i r s t   ar gument :	2 *   ( 3   -    4)
par t i al Ri ght ( f ,	2) ( 3, 4)	/ /   =>	6:	Bi nd   l as t   ar gument :	3   * ( 4   -    2)
par t i al ( f ,	undef i ned,	2) ( 3, 4)	/ /   =>   - 6:	Bi nd   mi ddl e   ar gument :	3 *   ( 2   -    4)


These partial application functions allow us to easily define interesting functions out of functions we already have defined. Here are some examples:

c ons t   i nc r ement   =   par t i al L ef t ( s um,	1) ;
c ons t   c uber oot   =   par t i al Ri ght ( Mat h. pow,	1/ 3) ; c uber oot ( i nc r ement ( 26) )	/ /   =>   3


Partial application becomes even more interesting when we combine it with other higher-order functions. Here, for example, is a way to define the preceding not ( )  function just shown using composition and partial application:

c ons t   not   =   par t i al L ef t ( c ompos e,	x   =>   ! x) ; c ons t   even   =   x   =>   x   %  2   ===   0;
c ons t   odd   =   not ( even) ;
c ons t   i s Number   =   not ( i s NaN) ;
odd( 3)    &&  i s Number ( 2)	/ /   =>   t r ue


We can also use composition and partial application to redo our mean and standard deviation calculations in extreme functional style:

/ /   s um( )    and   s quar e( )    f unc t i ons   ar e   def i ned   above.	Her e   ar e   s ome mor e:
c ons t   pr oduc t   =   ( x, y)    =>   x*y;
c ons t   neg   =   par t i al ( pr oduc t ,	- 1) ;
c ons t   s qr t   =   par t i al ( Mat h. pow,	undef i ned,	. 5) ;
c ons t   r ec i pr oc al	=   par t i al ( Mat h. pow,	undef i ned,	neg( 1) ) ;

/ /   Now  c omput e   t he   mean   and   s t andar d   devi at i on. l et   dat a   =   [ 1, 1, 3, 5, 5] ;	/ /   Our   dat a
l et   mean   =   pr oduc t ( r educ e( dat a,	s um) ,	r ec i pr oc al ( dat a. l engt h) ) ; l et   s t ddev   =   s qr t ( pr oduc t ( r educ e( map( dat a,
c ompos e( s quar e,
par t i al ( s um, neg( mean) ) ) ) ,
s um) ,
r ec i pr oc al ( s um( dat a. l engt h, neg( 1) ) ) ) ) ; [ mean,	s t ddev]	/ /   =>   [ 3,	2]


Notice that this code to compute mean and standard deviation is entirely function invocations; there are no operators involved, and the number of

parentheses has grown so large that this JavaScript is beginning to look like Lisp code. Again, this is not a style that I advocate for JavaScript programming, but it is an interesting exercise to see how deeply functional JavaScript code can be.


8.8.4 Memoization

In §8.4.1, we defined a factorial function that cached its previously computed results. In functional programming, this kind of caching is called memoization. The code that follows shows a higher-order function, memoi z e( ) , that accepts a function as its argument and returns a memoized version of the function:

/ /   Ret ur n   a   memoi z ed   ver s i on   of    f .
/ /   I t   onl y   wor ks   i f    ar gument s   t o   f    al l	have   di s t i nc t   s t r i ng r epr es ent at i ons .
f unc t i on   memoi z e( f )    {
c ons t   c ac he   =   new  Map( ) ;	/ /   Val ue   c ac he   s t or ed   i n   t he c l os ur e.

r et ur n   f unc t i on( . . . ar gs )    {
/ /   Cr eat e   a   s t r i ng   ver s i on   of    t he   ar gument s   t o   us e   as   a c ac he   key.
l et   key   =   ar gs . l engt h   +   ar gs . j oi n( " +" ) ;
i f    ( c ac he. has ( key) )    {
r et ur n   c ac he. get ( key) ; }    el s e   {
l et   r es ul t   =   f . appl y( t hi s ,	ar gs ) ; c ac he. s et ( key,	r es ul t ) ;
r et ur n   r es ul t ; }
} ; }


The memoi z e( )  function creates a new object to use as the cache and assigns this object to a local variable so that it is private to (in the closure of) the returned function. The returned function converts its arguments

array to a string and uses that string as a property name for the cache object. If a value exists in the cache, it returns it directly. Otherwise, it calls the specified function to compute the value for these arguments, caches that value, and returns it. Here is how we might use memoi z e( ) :


/ /   Ret ur n   t he Euc l i di an
/ /   al gor i t hm:

Gr eat es t   Common   Di vi s or   of    t wo   i nt eger s   us i ng   t he

ht t p: / / en. wi ki pedi a. or g/ wi ki / Euc l i dean_al gor i t hm

f unc t i on   gc d( a, b)    {	/ /   Type   c hec ki ng   f or   a   and   b   has   been omi t t ed
i f    ( a   <   b)    {	/ /   Ens ur e   t hat   a   >=   b   when   we   s t ar t [ a,	b]    =   [ b,    a] ;	/ /   Des t r uc t ur i ng   as s i gnment   t o   s wap
var i abl es }
whi l e( b   ! ==   0)    {	/ /   Thi s   i s   Euc l i d' s   al gor i t hm f or   GCD [ a,	b]    =   [ b,    a%b] ;
}
r et ur n   a; }

c ons t   gc dmemo   =   memoi z e( gc d) ; gc dmemo( 85,	187)	/ /   =>   17


/ /   Not e   t hat   when   we memoi z i ng,
/ /   we   t ypi c al l y   want or i gi nal .

wr i t e   a   r ec ur s i ve

t o   r ec ur s e   t o   t he

f unc t i on

memoi z ed

t hat   we   wi l l	be

ver s i on,	not   t he

c ons t   f ac t or i al	=   memoi z e( f unc t i on( n)    {
r et ur n   ( n   <=   1)    ?   1   :	n   *   f ac t or i al ( n- 1) ; } ) ;
f ac t or i al ( 5)	/ /   =>   120:	al s o   c ac hes   val ues   f or   4,	3,	2   and 1.


8.9 Summary

Some key points to remember about this chapter are as follows:


You can define functions with the f unct i on keyword and with the ES6 => arrow syntax.

You can invoke functions, which can be used as methods and constructors.

Some ES6 features allow you to define default values for optional function parameters, to gather multiple arguments into an array using a rest parameter, and to destructure object and array arguments into function parameters.

You can use the . . .  spread operator to pass the elements of an array or other iterable object as arguments in a function invocation.

A function defined inside of and returned by an enclosing function retains access to its lexical scope and can therefore read and write the variables defined inside the outer function. Functions used in this way are called closures, and this is a technique that is worth understanding.

Functions are objects that can be manipulated by JavaScript, and this enables a functional style of programming.





1


2


3

The term was coined by Martin Fowler. See http://martinfowler.com/dslCatalog/methodChaining.html.

If you are familiar with Python, note that this is different than Python, in which every invocation shares the same default value.

This may not seem like a particularly interesting point unless you are familiar with more static languages, in which functions are part of a program but cannot be manipulated by the program.



Chapter 9. Classes




JavaScript objects were covered in Chapter 6. That chapter treated each object as a unique set of properties, different from every other object. It is often useful, however, to define a class of objects that share certain properties. Members, or instances, of the class have their own properties to hold or define their state, but they also have methods that define their behavior. These methods are defined by the class and shared by all instances. Imagine a class named Complex that represents and performs arithmetic on complex numbers, for example. A Complex instance would have properties to hold the real and imaginary parts (the state) of the complex number. And the Complex class would define methods to perform addition and multiplication (the behavior) of those numbers.


In JavaScript, classes use prototype-based inheritance: if two objects inherit properties (generally function-valued properties, or methods) from the same prototype, then we say that those objects are instances of the same class. That, in a nutshell, is how JavaScript classes work. JavaScript prototypes and inheritance were covered in §6.2.3 and §6.3.2, and you will need to be familiar with the material in those sections to understand this chapter. This chapter covers prototypes in §9.1.


If two objects inherit from the same prototype, this typically (but not necessarily) means that they were created and initialized by the same constructor function or factory function. Constructors have been covered in §4.6, §6.2.2, and §8.2.3, and this chapter has more in §9.2.


JavaScript has always allowed the definition of classes. ES6 introduced a

brand-new syntax (including a cl as s  keyword) that makes it even easier to create classes. These new JavaScript classes work in the same way that old-style classes do, and this chapter starts by explaining the old way of creating classes because that demonstrates more clearly what is going on behind the scenes to make classes work. Once we’ve explained those fundamentals, we’ll shift and start using the new, simplified class definition syntax.

If you’re familiar with strongly typed object-oriented programming languages like Java or C++, you’ll notice that JavaScript classes are quite different from classes in those languages. There are some syntactic similarities, and you can emulate many features of “classical” classes in JavaScript, but it is best to understand up front that JavaScript’s classes and prototype-based inheritance mechanism are substantially different from the classes and class-based inheritance mechanism of Java and similar languages.


9.1 Classes and Prototypes

In JavaScript, a class is a set of objects that inherit properties from the same prototype object. The prototype object, therefore, is the central feature of a class. Chapter 6 covered the Obj ect . cr eat e( )  function that returns a newly created object that inherits from a specified prototype object. If we define a prototype object and then use Obj ect . cr eat e( ) to create objects that inherit from it, we have defined a JavaScript class. Usually, the instances of a class require further initialization, and it is common to define a function that creates and initializes the new object. Example 9-1 demonstrates this: it defines a prototype object for a class that represents a range of values and also defines a factory function that creates and initializes a new instance of the class.

Example 9-1. A simple JavaScript class
/ /   Thi s   i s   a   f ac t or y   f unc t i on   t hat   r et ur ns   a   new  r ange   obj ec t . f unc t i on   r ange( f r om,	t o)    {

/ /   Us e   Obj ec t . c r eat e( )    t o   c r eat e   an t he
/ /   pr ot ot ype   obj ec t   def i ned   bel ow. s t or ed   as
/ /   a   pr oper t y   of    t hi s   f unc t i on,	and ( behavi or )
/ /   f or   al l	r ange   obj ec t s .

obj ec t   t hat   i nher i t s   f r om

The   pr ot ot ype   obj ec t   i s

def i nes   t he   s har ed   met hods

l et   r   =   Obj ec t . c r eat e( r ange. met hods ) ;


/ /   St or e obj ec t .
/ /   Thes e obj ec t .

t he   s t ar t   and   end   poi nt s   ( s t at e)

ar e   noni nher i t ed   pr oper t i es   t hat

of    t hi s   new  r ange

ar e   uni que   t o   t hi s

r . f r om =   f r om; r . t o   =   t o;

/ /   Fi nal l y   r et ur n   t he   new  obj ec t r et ur n   r ;
}

/ /   Thi s   pr ot ot ype   obj ec t   def i nes   met hods   i nher i t ed   by   al l	r ange obj ec t s .
r ange. met hods   =   {

/ /   Ret ur n   t r ue / /   Thi s   met hod
numer i c .

i f    x   i s   i n   t he   r ange, wor ks   f or   t ext ual    and

f al s e   ot her wi s e
Dat e   r anges   as   wel l	as

i nc l udes ( x)    {    r et ur n   t hi s . f r om <=   x   &&  x   <=   t hi s . t o;	} ,

/ /   A  gener at or   f unc t i on   t hat   makes   i ns t anc es   of    t he   c l as s i t er abl e.
/ /   Not e   t hat   i t   onl y   wor ks   f or   numer i c   r anges . *[ Symbol . i t er at or ] ( )    {
f or ( l et   x   =   Mat h. c ei l ( t hi s . f r om) ;	x   <=   t hi s . t o;	x++)    yi el d x;
} ,

/ /   Ret ur n   a   s t r i ng   r epr es ent at i on   of    t he   r ange
t oSt r i ng( )    {    r et ur n   " ( "   +   t hi s . f r om +   " . . . "   +   t hi s . t o   +   " ) " ;	} } ;

/ /   Her e   ar e   exampl e   us es   of    a   r ange   obj ec t .
l et   r   =   r ange( 1, 3) ;	/ /   Cr eat e   a   r ange   obj ec t

r . i nc l udes ( 2)	/ /   =>   t r ue:	2   i s   i n   t he   r ange r . t oSt r i ng( )	/ /   =>   " ( 1. . . 3) "
[ . . . r ]	/ /   =>   [ 1,	2,	3] ;	c onver t   t o   an   ar r ay   vi a i t er at or

There are a few things worth noting in the code of Example 9-1:


This code defines a factory function r ange( )  for creating new Range objects.

It uses the met hods  property of this r ange( )  function as a convenient place to store the prototype object that defines the class. There is nothing special or idiomatic about putting the prototype object here.

The r ange( )  function defines f r omand t o properties on each Range object. These are the unshared, noninherited properties that define the unique state of each individual Range object.

The r ange. met hods  object uses the ES6 shorthand syntax for defining methods, which is why you don’t see the f unct i on keyword anywhere. (See §6.10.5 to review object literal shorthand method syntax.)

One of the methods in the prototype has the computed name (§6.10.2) Symbol . i t er at or , which means that it is defining an iterator for Range objects. The name of this method is prefixed with *, which indicates that it is a generator function instead of a regular function. Iterators and generators are covered in detail in Chapter 12. For now, the upshot is that instances of this Range class can be used with the f or / of  loop and with the . . .  spread operator.

The shared, inherited methods defined in r ange. met hods  all use the f r omand t o properties that were initialized in the
r ange( )  factory function. In order to refer to them, they use the t hi s  keyword to refer to the object through which they were invoked. This use of t hi s  is a fundamental characteristic of the

methods of any class.


9.2 Classes and Constructors

Example 9-1 demonstrates a simple way to define a JavaScript class. It is not the idiomatic way to do so, however, because it did not define a constructor. A constructor is a function designed for the initialization of newly created objects. Constructors are invoked using the newkeyword as described in §8.2.3. Constructor invocations using newautomatically create the new object, so the constructor itself only needs to initialize the state of that new object. The critical feature of constructor invocations is that the pr ot ot ype property of the constructor is used as the prototype of the new object. §6.2.3 introduced prototypes and emphasized that while almost all objects have a prototype, only a few objects have a
pr ot ot ype property. Finally, we can clarify this: it is function objects that have a pr ot ot ype property. This means that all objects created with the same constructor function inherit from the same object and are therefore members of the same class. Example 9-2 shows how we could alter the Range class of Example 9-1 to use a constructor function instead of a factory function. Example 9-2 demonstrates the idiomatic way to create a class in versions of JavaScript that do not support the ES6 cl as s keyword. Even though cl as s  is well supported now, there is still lots of older JavaScript code around that defines classes like this, and you should be familiar with the idiom so that you can read old code and so that you understand what is going on “under the hood” when you use the cl as s keyword.

Example 9-2. A Range class using a constructor

/ /   Thi s   i s   a obj ec t s .
/ /   Not e   t hat

c ons t r uc t or

i t   does   not

f unc t i on   t hat   i ni t i al i z es   new  Range

c r eat e   or   r et ur n   t he   obj ec t .	I t   j us t

i ni t i al i z es   t hi s .
f unc t i on   Range( f r om,	t o)    {

/ /   St or e obj ec t .
/ /   Thes e obj ec t .

t he   s t ar t   and   end   poi nt s   ( s t at e)

ar e   noni nher i t ed   pr oper t i es   t hat

of    t hi s   new  r ange

ar e   uni que   t o   t hi s

t hi s . f r om =   f r om; t hi s . t o   =   t o;
}


/ /   Al l	Range / /   Not e   t hat wor k.

obj ec t s   i nher i t   f r om t hi s t he   pr oper t y   name   mus t   be

obj ec t .
" pr ot ot ype"   f or   t hi s   t o

Range. pr ot ot ype   =   {

/ /   Ret ur n   t r ue / /   Thi s   met hod
numer i c .

i f    x   i s   i n   t he   r ange, wor ks   f or   t ext ual    and

f al s e   ot her wi s e
Dat e   r anges   as   wel l	as

i nc l udes :	f unc t i on( x)    {    r et ur n   t hi s . f r om <=   x   &&  x   <=   t hi s . t o; } ,

/ /   A  gener at or   f unc t i on   t hat   makes   i ns t anc es   of    t he   c l as s i t er abl e.
/ /   Not e   t hat   i t   onl y   wor ks   f or   numer i c   r anges . [ Symbol . i t er at or ] :	f unc t i on*( )    {
f or ( l et   x   =   Mat h. c ei l ( t hi s . f r om) ;	x   <=   t hi s . t o;	x++)    yi el d x;
} ,

/ /   Ret ur n   a   s t r i ng   r epr es ent at i on   of    t he   r ange
t oSt r i ng:	f unc t i on( )    {    r et ur n   " ( "   +   t hi s . f r om +   " . . . "   + t hi s . t o   +   " ) " ;    }
} ;

/ /   Her e   ar e   exampl e   us es   of    t hi s   new  Range   c l as s
l et   r   =   new  Range( 1, 3) ;	/ /   Cr eat e   a   Range   obj ec t ;	not e   t he   us e of    new
r . i nc l udes ( 2)	/ /   =>   t r ue:	2   i s   i n   t he   r ange r . t oSt r i ng( )	/ /   =>   " ( 1. . . 3) "
[ . . . r ]	/ /   =>   [ 1,	2,	3] ;	c onver t   t o   an   ar r ay   vi a i t er at or

It is worth comparing Examples 9-1 and 9-2 fairly carefully and noting the differences between these two techniques for defining classes. First, notice that we renamed the r ange( )  factory function to Range( )  when we

converted it to a constructor. This is a very common coding convention: constructor functions define, in a sense, classes, and classes have names that (by convention) begin with capital letters. Regular functions and methods have names that begin with lowercase letters.


Next, notice that the Range( )  constructor is invoked (at the end of the example) with the newkeyword while the r ange( )  factory function was invoked without it. Example 9-1 uses regular function invocation (§8.2.1) to create the new object, and Example 9-2 uses constructor invocation (§8.2.3). Because the Range( )  constructor is invoked with new, it does not have to call Obj ect . cr eat e( )  or take any action to create a new object. The new object is automatically created before the constructor is called, and it is accessible as the t hi s  value. The Range( )  constructor merely has to initialize t hi s . Constructors do not even have to return the newly created object. Constructor invocation automatically creates a new object, invokes the constructor as a method of that object, and returns the new object. The fact that constructor invocation is so different from regular function invocation is another reason that we give constructors names that start with capital letters. Constructors are written to be invoked as constructors, with the newkeyword, and they usually won’t work properly if they are invoked as regular functions. A naming convention that keeps constructor functions distinct from regular functions helps programmers know when to use new.



CONSTRUCTORS AND NEW.TARGET

Within a function body, you can tell whether the function has been invoked as a constructor with the special expression new. t ar get . If the value of that expression is defined, then you know that the function was invoked as a constructor, with the newkeyword. When we discuss subclasses in §9.5, we’ll see that
new. t ar get  is not always a reference to the constructor it is used in: it might also refer to the constructor function of a subclass.

If new. t ar get  is undef i ned, then the containing function was invoked as a function, without the new

keyword. JavaScript’s various error constructors can be invoked without new, and if you want to emulate this feature in your own constructors, you can write them like this:

f unc t i on  C( )    {
i f   ( ! new. t ar get )    r et ur n  new  C( ) ; / /   i ni t i al i z at i on   c ode   goes   her e
}


This technique only works for constructors defined in this old-fashioned way. Classes created with the cl as s  keyword do not allow their constructors to be invoked without new.



Another critical difference between Examples 9-1 and 9-2 is the way the prototype object is named. In the first example, the prototype was
r ange. met hods . This was a convenient and descriptive name, but arbitrary. In the second example, the prototype is Range. pr ot ot ype, and this name is mandatory. An invocation of the Range( )  constructor automatically uses Range. pr ot ot ype as the prototype of the new Range object.

Finally, also note the things that do not change between Examples 9-1 and 9-2 : the range methods are defined and invoked in the same way for both classes. Because Example 9-2 demonstrates the idiomatic way to create classes in versions of JavaScript before ES6, it does not use the ES6 shorthand method syntax in the prototype object and explicitly spells out the methods with the f unct i on keyword. But you can see that the implementation of the methods is the same in both examples.

Importantly, note that neither of the two range examples uses arrow functions when defining constructors or methods. Recall from §8.1.3 that functions defined in this way do not have a pr ot ot ype property and so cannot be used as constructors. Also, arrow functions inherit the t hi s keyword from the context in which they are defined rather than setting it based on the object through which they are invoked, and this makes them

useless for methods because the defining characteristic of methods is that they use t hi s  to refer to the instance on which they were invoked.


Fortunately, the new ES6 class syntax doesn’t allow the option of defining methods with arrow functions, so this is not a mistake that you can accidentally make when using that syntax. We will cover the ES6 cl as s keyword soon, but first, there are more details to cover about constructors.


9.2.1 Constructors, Class Identity, and instanceof

As we’ve seen, the prototype object is fundamental to the identity of a class: two objects are instances of the same class if and only if they inherit from the same prototype object. The constructor function that initializes the state of a new object is not fundamental: two constructor functions may have pr ot ot ype properties that point to the same prototype object. Then, both constructors can be used to create instances of the same class.

Even though constructors are not as fundamental as prototypes, the constructor serves as the public face of a class. Most obviously, the name of the constructor function is usually adopted as the name of the class. We say, for example, that the Range( )  constructor creates Range objects. More fundamentally, however, constructors are used as the righthand operand of the i ns t anceof  operator when testing objects for membership in a class. If we have an object r  and want to know if it is a Range object, we can write:

r   i ns t anc eof    Range	/ /   =>   t r ue:	r   i nher i t s   f r om Range. pr ot ot ype


The i ns t anceof  operator was described in §4.9.4. The lefthand operand should be the object that is being tested, and the righthand operand should be a constructor function that names a class. The

expression o  i ns t anceof   C evaluates to t r ue if o inherits from
C. pr ot ot ype. The inheritance need not be direct: if o inherits from an object that inherits from an object that inherits from C. pr ot ot ype, the expression will still evaluate to t r ue.


Technically speaking, in the previous code example, the i ns t anceof operator is not checking whether r  was actually initialized by the Range constructor. Instead, it is checking whether r  inherits from
Range. pr ot ot ype. If we define a function St r ange( )  and set its prototype to be the same as Range. pr ot ot ype, then objects created with new  St r ange( )  will count as Range objects as far as
i ns t anceof  is concerned (they won’t actually work as Range objects, however, because their f r omand t o properties have not been initialized):

f unc t i on   St r ange( )    { }
St r ange. pr ot ot ype   =   Range. pr ot ot ype;
new  St r ange( )    i ns t anc eof    Range	/ /   =>   t r ue


Even though i ns t anceof  cannot actually verify the use of a constructor, it still uses a constructor function as its righthand side because constructors are the public identity of a class.

If you want to test the prototype chain of an object for a specific prototype and do not want to use the constructor function as an intermediary, you can use the i s Pr ot ot ypeOf ( )  method. In Example 9-1, for example, we defined a class without a constructor function, so there is no way to use i ns t anceof  with that class. Instead, however, we could test whether an object r  was a member of that constructor-less class with this code:


r ange. met hods . i s Pr ot ot ypeOf ( r ) ;	/ /   r ange. met hods   i s   t he pr ot ot ype   obj ec t .

9.2.2 The constructor Property

In Example 9-2, we set Range. pr ot ot ype to a new object that contained the methods for our class. Although it was convenient to express those methods as properties of a single object literal, it was not actually necessary to create a new object. Any regular JavaScript function (excluding arrow functions, generator functions, and async functions) can be used as a constructor, and constructor invocations need a pr ot ot ype property. Therefore, every regular JavaScript function1 automatically has a pr ot ot ype property. The value of this property is an object that has a single, non-enumerable cons t r uct or  property. The value of the
cons t r uct or  property is the function object:


l et   F   =   f unc t i on( )    { } ;	/ /   Thi s   i s   a   f unc t i on   obj ec t .
l et   p   =   F. pr ot ot ype;	/ /   Thi s   i s   t he   pr ot ot ype   obj ec t as s oc i at ed   wi t h   F.
l et   c   =   p. c ons t r uc t or ;	/ /   Thi s   i s   t he   f unc t i on   as s oc i at ed   wi t h
t he   pr ot ot ype.
c   ===   F	/ /   =>   t r ue:	F. pr ot ot ype. c ons t r uc t or   ===   F f or   any   F


The existence of this predefined prototype object with its cons t r uct or property means that objects typically inherit a cons t r uct or  property that refers to their constructor. Since constructors serve as the public identity of a class, this constructor property gives the class of an object:

l et   o   =   new  F( ) ;	/ /   Cr eat e   an   obj ec t   o   of    c l as s   F
o. c ons t r uc t or   ===   F	/ /   =>   t r ue:	t he   c ons t r uc t or   pr oper t y s pec i f i es   t he   c l as s


Figure 9-1 illustrates this relationship between the constructor function, its prototype object, the back reference from the prototype to the constructor, and the instances created with the constructor.


















Figure 9-1. A constructor function, its prototype, and instances

Notice that Figure 9-1 uses our Range( )  constructor as an example. In fact, however, the Range class defined in Example 9-2 overwrites the predefined Range. pr ot ot ype object with an object of its own. And the new prototype object it defines does not have a cons t r uct or property. So instances of the Range class, as defined, do not have a cons t r uct or  property. We can remedy this problem by explicitly adding a constructor to the prototype:

Range. pr ot ot ype   =   {
c ons t r uc t or :	Range,	/ /   Expl i c i t l y   s et   t he   c ons t r uc t or   bac k-r ef er enc e

/ *   met hod   def i ni t i ons   go   her e   */ } ;


Another common technique that you are likely to see in older JavaScript code is to use the predefined prototype object with its cons t r uct or property and add methods to it one at a time with code like this:

/ /   Ext end   t he   pr edef i ned   Range. pr ot ot ype   obj ec t   s o   we   don' t over wr i t e
/ /   t he   aut omat i c al l y   c r eat ed   Range. pr ot ot ype. c ons t r uc t or pr oper t y.

Range. pr ot ot ype. i nc l udes   =   f unc t i on( x)    {
r et ur n   t hi s . f r om <=   x   &&  x   <=   t hi s . t o; } ;
Range. pr ot ot ype. t oSt r i ng   =   f unc t i on( )    {
r et ur n   " ( "   +   t hi s . f r om +   " . . . "   +   t hi s . t o   +   " ) " ; } ;


9.3 Classes with the class Keyword

Classes have been part of JavaScript since the very first version of the language, but in ES6, they finally got their own syntax with the introduction of the cl as s  keyword. Example 9-3 shows what our Range class looks like when written with this new syntax.

Example 9-3. The Range class rewritten using class c l as s   Range   {
c ons t r uc t or ( f r om,	t o)    {

/ /   St or e   t he r ange   obj ec t .
/ /   Thes e   ar e t hi s   obj ec t .

s t ar t   and   end   poi nt s   ( s t at e)

noni nher i t ed   pr oper t i es   t hat

of    t hi s   new

ar e   uni que   t o

t hi s . f r om =   f r om; t hi s . t o   =   t o;
}


/ /   Ret ur n   t r ue / /   Thi s   met hod
numer i c .

i f    x   i s   i n   t he   r ange, wor ks   f or   t ext ual    and

f al s e   ot her wi s e
Dat e   r anges   as   wel l	as

i nc l udes ( x)    {    r et ur n   t hi s . f r om <=   x   &&  x   <=   t hi s . t o;	}

/ /   A  gener at or   f unc t i on   t hat   makes   i ns t anc es   of    t he   c l as s i t er abl e.
/ /   Not e   t hat   i t   onl y   wor ks   f or   numer i c   r anges . *[ Symbol . i t er at or ] ( )    {
f or ( l et   x   =   Mat h. c ei l ( t hi s . f r om) ;	x   <=   t hi s . t o;	x++)    yi el d x;
}

/ /   Ret ur n   a   s t r i ng   r epr es ent at i on   of    t he   r ange
t oSt r i ng( )    {    r et ur n   ` ( ${ t hi s . f r om} . . . ${ t hi s . t o} ) ` ;	}

}

/ /   Her e   ar e   exampl e   us es   of    t hi s   new  Range   c l as s
l et   r   =   new  Range( 1, 3) ;	/ /   Cr eat e   a   Range   obj ec t
r . i nc l udes ( 2)	/ /   =>   t r ue:	2   i s   i n   t he   r ange r . t oSt r i ng( )	/ /   =>   " ( 1. . . 3) "
[ . . . r ]	/ /   =>   [ 1,	2,	3] ;	c onver t   t o   an   ar r ay   vi a i t er at or

It is important to understand that the classes defined in Examples 9-2 and 9-3 work in exactly the same way. The introduction of the cl as s keyword to the language does not alter the fundamental nature of JavaScript’s prototype-based classes. And although Example 9-3 uses the cl as s  keyword, the resulting Range object is a constructor function, just like the version defined in Example 9-2. The new cl as s  syntax is clean and convenient but is best thought of as “syntactic sugar” for the more fundamental class definition mechanism shown in Example 9-2.

Note the following things about the class syntax in Example 9-3:


The class is declared with the cl as s  keyword, which is followed by the name of class and a class body in curly braces.

The class body includes method definitions that use object literal method shorthand (which we also used in Example 9-1), where the f unct i on keyword is omitted. Unlike object literals, however, no commas are used to separate the methods from each other. (Although class bodies are superficially similar to object literals, they are not the same thing. In particular, they do not support the definition of properties with name/value pairs.)

The keyword cons t r uct or  is used to define the constructor function for the class. The function defined is not actually named “constructor”, however. The cl as s  declaration statement defines a new variable Range and assigns the value of this special
cons t r uct or  function to that variable.

If your class does not need to do any initialization, you can omit the cons t r uct or  keyword and its body, and an empty constructor function will be implicitly created for you.

If you want to define a class that subclasses—or inherits from—another class, you can use the ext ends  keyword with the cl as s  keyword:


/ /   A  Span   i s   l i ke / /   a   s t ar t   and   an l engt h

a   Range,	but   i ns t ead   of    i ni t i al i z i ng   i t   wi t h end,	we   i ni t i al i z e   i t   wi t h   a   s t ar t   and   a

c l as s   Span   ext ends   Range   {
c ons t r uc t or ( s t ar t ,	l engt h)    { i f    ( l engt h   >=   0)    {
s uper ( s t ar t ,	s t ar t   +   l engt h) ; }    el s e   {
s uper ( s t ar t   +   l engt h,	s t ar t ) ; }
} }


Creating subclasses is a whole topic of its own. We’ll return to it, and explain the ext ends  and s uper  keywords shown here, in §9.5.


Like function declarations, class declarations have both statement and expression forms. Just as we can write:

l et   s quar e   =   f unc t i on( x)    {    r et ur n   x   *   x;	} ; s quar e( 3)	/ /   =>   9


we can also write:


l et   Squar e   =   c l as s   {    c ons t r uc t or ( x)    {    t hi s . ar ea   =   x   *   x;	}    } ; new  Squar e( 3) . ar ea	/ /   =>   9


As with function definition expressions, class definition expressions can include an optional class name. If you provide such a name, that name is

only defined within the class body itself.


Although function expressions are quite common (particularly with the arrow function shorthand), in JavaScript programming, class definition expressions are not something that you are likely to use much unless you find yourself writing a function that takes a class as its argument and returns a subclass.


We’ll conclude this introduction to the cl as s  keyword by mentioning a couple of important things you should know that are not apparent from cl as s  syntax:

All code within the body of a cl as s  declaration is implicitly in strict mode (§5.6.3), even if no " us e   s t r i ct " directive appears. This means, for example, that you can’t use octal integer literals or the wi t h statement within class bodies and that you are more likely to get syntax errors if you forget to declare a variable before using it.

Unlike function declarations, class declarations are not “hoisted.” Recall from §8.1.1 that function definitions behave as if they had been moved to the top of the enclosing file or enclosing function, meaning that you can invoke a function in code that comes before the actual definition of the function. Although class declarations are like function declarations in some ways, they do not share this hoisting behavior: you cannot instantiate a class before you declare it.


9.3.1 Static Methods

You can define a static method within a cl as s  body by prefixing the method declaration with the s t at i c keyword. Static methods are defined as properties of the constructor function rather than properties of the

prototype object.


For example, suppose we added the following code to Example 9-3:


s t at i c   par s e( s )    {
l et   mat c hes   =   s . mat c h( / ^\ ( ( \ d+) \ . \ . \ . ( \ d+) \ ) $/ ) ; i f    ( ! mat c hes )    {
t hr ow  new  TypeEr r or ( ` Cannot   par s e   Range   f r om " ${ s } " . ` ) }
r et ur n   new  Range( par s eI nt ( mat c hes [ 1] ) , par s eI nt ( mat c hes [ 2] ) ) ;
}


The method defined by this code is Range. par s e( ) , not
Range. pr ot ot ype. par s e( ) , and you must invoke it through the constructor, not through an instance:

l et   r   =   Range. par s e( ' ( 1. . . 10) ' ) ;	/ /   Ret ur ns   a   new  Range   obj ec t
r . par s e( ' ( 1. . . 10) ' ) ;	/ /   TypeEr r or :	r . par s e   i s   not   a f unc t i on


You’ll sometimes see static methods called class methods because they are invoked using the name of the class/constructor. When this term is used, it is to contrast class methods with the regular instance methods that are invoked on instances of the class. Because static methods are invoked on the constructor rather than on any particular instance, it almost never makes sense to use the t hi s  keyword in a static method.


We’ll see examples of static methods in Example 9-4.


9.3.2 Getters, Setters, and other Method Forms

Within a cl as s  body, you can define getter and setter methods (§6.10.6) just as you can in object literals. The only difference is that in class bodies,

you don’t put a comma after the getter or setter. Example 9-4 includes a practical example of a getter method in a class.


In general, all of the shorthand method definition syntaxes allowed in object literals are also allowed in class bodies. This includes generator methods (marked with *) and methods whose names are the value of an expression in square brackets. In fact, you’ve already seen (in Example 9-3) a generator method with a computed name that makes the Range class iterable:

*[ Symbol . i t er at or ] ( )    {
f or ( l et   x   =   Mat h. c ei l ( t hi s . f r om) ;	x   <=   t hi s . t o;	x++)    yi el d x;
}


9.3.3 Public, Private, and Static Fields

In the discussion here of classes defined with the cl as s  keyword, we have only described the definition of methods within the class body. The ES6 standard only allows the creation of methods (including getters, setters, and generators) and static methods; it does not include syntax for defining fields. If you want to define a field (which is just an object-oriented synonym for “property”) on a class instance, you must do that in the constructor function or in one of the methods. And if you want to define a static field for a class, you must do that outside the class body, after the class has been defined. Example 9-4 includes examples of both kinds of fields.

Standardization is underway, however, for extended class syntax that allows the definition of instance and static fields, in both public and private forms. The code shown in the rest of this section is not yet standard JavaScript as of early 2020 but is already supported in Chrome

and partially supported (public instance fields only) in Firefox. The syntax for public instance fields is in common use by JavaScript programmers using the React framework and the Babel transpiler.


Suppose you’re writing a class like this one, with a constructor that initializes three fields:

c l as s   Buf f er   {
c ons t r uc t or ( )    {
t hi s . s i z e   =   0;
t hi s . c apac i t y   =   4096;
t hi s . buf f er   =   new  Ui nt 8Ar r ay( t hi s . c apac i t y) ; }
}


With the new instance field syntax that is likely to be standardized, you could instead write:

c l as s   Buf f er   { s i z e   =   0;
c apac i t y   =   4096;
buf f er   =   new  Ui nt 8Ar r ay( t hi s . c apac i t y) ; }


The field initialization code has moved out of the constructor and now appears directly in the class body. (That code is still run as part of the constructor, of course. If you do not define a constructor, the fields are initialized as part of the implicitly created constructor.) The t hi s . prefixes that appeared on the lefthand side of the assignments are gone, but note that you still must use t hi s .  to refer to these fields, even on the righthand side of the initializer assignments. The advantage of initializing your instance fields in this way is that this syntax allows (but does not require) you to put the initializers up at the top of the class definition,

making it clear to readers exactly what fields will hold the state of each instance. You can declare fields without an initializer by just writing the name of the field followed by a semicolon. If you do that, the initial value of the field will be undef i ned. It is better style to always make the initial value explicit for all of your class fields.

Before the addition of this field syntax, class bodies looked a lot like object literals using shortcut method syntax, except that the commas had been removed. This field syntax—with equals signs and semicolons instead of colons and commas—makes it clear that class bodies are not at all the same as object literals.


The same proposal that seeks to standardize these instance fields also defines private instance fields. If you use the instance field initialization syntax shown in the previous example to define a field whose name begins with # (which is not normally a legal character in JavaScript identifiers), that field will be usable (with the # prefix) within the class body but will be invisible and inaccessible (and therefore immutable) to any code outside of the class body. If, for the preceding hypothetical Buffer class, you wanted to ensure that users of the class could not inadvertently modify the s i z e field of an instance, you could use a private #s i z e field instead, then define a getter function to provide read-only access to the value:

c l as s   Buf f er   { #s i z e   =   0;
get   s i z e( )    {    r et ur n   t hi s . #s i z e;	} }


Note that private fields must be declared using this new field syntax before they can be used. You can’t just write t hi s . #s i z e   =   0;  in the

constructor of a class unless you include a “declaration” of the field directly in the class body.


Finally, a related proposal seeks to standardize the use of the s t at i c keyword for fields. If you add s t at i c before a public or private field declaration, those fields will be created as properties of the constructor function instead of properties of instances. Consider the static
Range. par s e( )  method we’ve defined. It included a fairly complex regular expression that might be good to factor out into its own static field. With the proposed new static field syntax, we could do that like this:

s t at i c   i nt eger RangePat t er n   =   / ^\ ( ( \ d+) \ . \ . \ . ( \ d+) \ ) $/ ; s t at i c   par s e( s )    {
l et   mat c hes   =   s . mat c h( Range. i nt eger RangePat t er n) ; i f    ( ! mat c hes )    {
t hr ow  new  TypeEr r or ( ` Cannot   par s e   Range   f r om " ${ s } " . ` ) }
r et ur n   new  Range( par s eI nt ( mat c hes [ 1] ) ,	mat c hes [ 2] ) ; }


If we wanted this static field to be accessible only within the class, we could make it private using a name like #pat t er n.


9.3.4 Example: A Complex Number Class

Example 9-4 defines a class to represent complex numbers. The class is a relatively simple one, but it includes instance methods (including getters), static methods, instance fields, and static fields. It includes some commented-out code demonstrating how we might use the not-yet-standard syntax for defining instance fields and static fields within the class body.

Example 9-4. Complex.js: a complex number class

/ **
*   I ns t anc es   of    t hi s   Compl ex   c l as s   r epr es ent   c ompl ex   number s .
*   Rec al l	t hat   a   c ompl ex   number   i s   t he   s um of    a   r eal	number   and   an *   i magi nar y   number   and   t hat   t he   i magi nar y   number   i    i s   t he   s quar e
r oot   of    - 1. */
c l as s   Compl ex   {
/ /   Onc e   c l as s   f i el d   dec l ar at i ons   ar e   s t andar di z ed,	we   c oul d dec l ar e
/ /   pr i vat e   f i el ds   t o   hol d   t he   r eal	and   i magi nar y   par t s   of    a c ompl ex   number
/ /   her e,	wi t h   c ode   l i ke   t hi s : / /
/ /   #r   =   0; / /   #i    =   0;

/ /   Thi s   c ons t r uc t or   f unc t i on   def i nes   t he   i ns t anc e   f i el ds   r   and i	on   ever y
/ /   i ns t anc e   i t   c r eat es .	Thes e   f i el ds   hol d   t he   r eal	and i magi nar y   par t s   of
/ /   t he   c ompl ex   number :	t hey   ar e   t he   s t at e   of    t he   obj ec t . c ons t r uc t or ( r eal ,	i magi nar y)    {
t hi s . r   =   r eal ;	/ /   Thi s   f i el d   hol ds   t he   r eal	par t   of t he   number .
t hi s . i	=   i magi nar y;	/ /   Thi s   f i el d   hol ds   t he   i magi nar y par t .
}

/ /   Her e   ar e   t wo   i ns t anc e   met hods   f or   addi t i on   and mul t i pl i c at i on
/ /   of    c ompl ex   number s .	I f    c   and   d   ar e   i ns t anc es   of    t hi s   c l as s , we
/ /   mi ght   wr i t e   c . pl us ( d)    or   d. t i mes ( c )

pl us ( t hat ) r et ur n
}

{
new  Compl ex( t hi s . r   +   t hat . r ,	t hi s . i	+   t hat . i ) ;

t i mes ( t hat )    {

r et ur n   new  Compl ex( t hi s . r t hi s . r
}

*   t hat . r
*   t hat . i

-    t hi s . i
+   t hi s . i

*   t hat . i ,
*   t hat . r ) ;



/ /   And   her e met hods .
/ /   We   c oul d

ar e   s t at i c   var i ant s   of

wr i t e   Compl ex. s um( c , d)

t he   c ompl ex   ar i t hmet i c

and   Compl ex. pr oduc t ( c , d)

s t at i c   s um( c ,	d)    {    r et ur n   c . pl us ( d) ;	}
s t at i c   pr oduc t ( c ,	d)    {    r et ur n   c . t i mes ( d) ;	}


/ /   Thes e   ar e   s ome   i ns t anc e   met hods   t hat   ar e   def i ned   as   get t er s / /   s o   t hey' r e   us ed   l i ke   f i el ds .    The   r eal    and   i magi nar y   get t er s
woul d
/ /   be   us ef ul	i f    we   wer e   us i ng   pr i vat e   f i el ds   t hi s . #r   and t hi s . #i
get   r eal ( )    {    r et ur n   t hi s . r ;	}
get   i magi nar y( )    {    r et ur n   t hi s . i ;	}
get   magni t ude( )    {    r et ur n   Mat h. hypot ( t hi s . r ,	t hi s . i ) ;	}

/ /   Cl as s es   s houl d   al mos t   al ways   have   a   t oSt r i ng( )    met hod t oSt r i ng( )    {    r et ur n   ` { ${ t hi s . r } , ${ t hi s . i } } ` ;	}


/ /   I t   i s   of t en   us ef ul    t o / /   t wo   i ns t anc es   of    your

def i ne   a   met hod   f or c l as s   r epr es ent   t he

t es t i ng   whet her s ame   val ue

equal s ( t hat )    {
r et ur n   t hat   i ns t anc eof    Compl ex   && t hi s . r   ===   t hat . r   &&
t hi s . i	===   t hat . i ; }

/ /   Onc e   s t at i c   f i el ds   ar e   s uppor t ed   i ns i de   c l as s   bodi es ,	we c oul d
/ /   def i ne   a   us ef ul	Compl ex. ZERO  c ons t ant   l i ke   t hi s : / /   s t at i c   ZERO  =   new  Compl ex( 0, 0) ;
}

/ /   Her e   ar e   s ome   c l as s   f i el ds   t hat   hol d   us ef ul	pr edef i ned   c ompl ex number s .
Compl ex. ZERO  =   new  Compl ex( 0, 0) ;
Compl ex. ONE   =   new  Compl ex( 1, 0) ; Compl ex. I	=   new  Compl ex( 0, 1) ;

With the Complex class of Example 9-4 defined, we can use the constructor, instance fields, instance methods, class fields, and class methods with code like this:

l et   c   =   new  Compl ex( 2,	3) ;	/ /   Cr eat e   a   new  obj ec t   wi t h   t he c ons t r uc t or
l et   d   =   new  Compl ex( c . i ,	c . r ) ;	/ /   Us e   i ns t anc e   f i el ds   of    c c . pl us ( d) . t oSt r i ng( )                               / /   =>   " { 5, 5} " ;	us e   i ns t anc e met hods
c . magni t ude	/ /   =>   Mat h. hypot ( 2, 3) ;	us e   a get t er   f unc t i on

Compl ex. pr oduc t ( c ,	d)	/ /   =>   new  Compl ex( 0,	13) ;	a s t at i c   met hod
Compl ex. ZERO. t oSt r i ng( )	/ /   =>   " { 0, 0} " ;	a   s t at i c   pr oper t y



9.4 Adding Methods to Existing Classes

JavaScript’s prototype-based inheritance mechanism is dynamic: an object inherits properties from its prototype, even if the properties of the prototype change after the object is created. This means that we can augment JavaScript classes simply by adding new methods to their prototype objects.


Here, for example, is code that adds a method for computing the complex conjugate to the Complex class of Example 9-4:

/ /   Ret ur n   a   c ompl ex   number   t hat   i s   t he   c ompl ex   c onj ugat e   of    t hi s one.
Compl ex. pr ot ot ype. c onj	=   f unc t i on( )    {    r et ur n   new  Compl ex( t hi s . r ,
- t hi s . i ) ;	} ;


The prototype object of built-in JavaScript classes is also open like this, which means that we can add methods to numbers, strings, arrays, functions, and so on. This is useful for implementing new language features in older versions of the language:

/ /   I f    t he   new  St r i ng   met hod   s t ar t s Wi t h( )    i s   not   al r eady def i ned. . .
i f    ( ! St r i ng. pr ot ot ype. s t ar t s Wi t h)    {
/ /   . . . t hen   def i ne   i t   l i ke   t hi s   us i ng   t he   ol der   i ndexOf ( ) met hod.
St r i ng. pr ot ot ype. s t ar t s Wi t h   =   f unc t i on( s )    {
r et ur n   t hi s . i ndexOf ( s )    ===   0; } ;
}


Here is another example:

/ /   I nvoke   t he   f unc t i on   f    t hi s   many   t i mes ,	pas s i ng   t he   i t er at i on number
/ /   For   exampl e,	t o   pr i nt   " hel l o"   3   t i mes : / /	l et   n   =   3;
/ /	n. t i mes ( i	=>   {    c ons ol e. l og( ` hel l o   ${ i } ` ) ;	} ) ; Number . pr ot ot ype. t i mes   =   f unc t i on( f ,	c ont ext )    {
l et   n   =   t hi s . val ueOf ( ) ;
f or ( l et   i	=   0;	i	<   n;	i ++)    f . c al l ( c ont ext ,	i ) ; } ;


Adding methods to the prototypes of built-in types like this is generally considered to be a bad idea because it will cause confusion and compatibility problems in the future if a new version of JavaScript defines a method with the same name. It is even possible to add methods to
Obj ect . pr ot ot ype, making them available for all objects. But this is never a good thing to do because properties added to
Obj ect . pr ot ot ype are visible to f or / i n loops (though you can avoid this by using Obj ect . def i nePr oper t y( )  [§14.1] to make the new property non-enumerable).


9.5 Subclasses

In object-oriented programming, a class B can extend or subclass another class A. We say that A is the superclass and B is the subclass. Instances of B inherit the methods of A. The class B can define its own methods, some of which may override methods of the same name defined by class A. If a method of B overrides a method of A, the overriding method in B often needs to invoke the overridden method in A. Similarly, the subclass constructor B( )  must typically invoke the superclass constructor A( )  in order to ensure that instances are completely initialized.

This section starts by showing how to define subclasses the old, pre-ES6 way, and then quickly moves on to demonstrate subclassing using the

cl as s  and ext ends  keywords and superclass constructor method invocation with the s uper  keyword. Next is a subsection about avoiding subclasses and relying on object composition instead of inheritance. The section ends with an extended example that defines a hierarchy of Set classes and demonstrates how abstract classes can be used to separate interface from implementation.


9.5.1 Subclasses and Prototypes

Suppose we wanted to define a Span subclass of the Range class from Example 9-2. This subclass will work just like a Range, but instead of initializing it with a start and an end, we’ll instead specify a start and a distance, or span. An instance of this Span class is also an instance of the Range superclass. A span instance inherits a customized t oSt r i ng( ) method from Span. pr ot ot ype, but in order to be a subclass of Range, it must also inherit methods (such as i ncl udes ( ) ) from
Range. pr ot ot ype.


Example 9-5. Span.js: a simple subclass of Range
/ /   Thi s   i s   t he   c ons t r uc t or   f unc t i on   f or   our   s ubc l as s f unc t i on   Span( s t ar t ,	s pan)    {
i f    ( s pan   >=   0)    {
t hi s . f r om =   s t ar t ;
t hi s . t o   =   s t ar t   +   s pan; }    el s e   {
t hi s . t o   =   s t ar t ;
t hi s . f r om =   s t ar t   +   s pan; }
}

/ /   Ens ur e   t hat   t he   Span   pr ot ot ype   i nher i t s   f r om t he   Range pr ot ot ype
Span. pr ot ot ype   =   Obj ec t . c r eat e( Range. pr ot ot ype) ;

/ /   We   don' t   want   t o   i nher i t   Range. pr ot ot ype. c ons t r uc t or ,	s o   we / /   def i ne   our   own   c ons t r uc t or   pr oper t y.

Span. pr ot ot ype. c ons t r uc t or   =   Span;

/ /   By   def i ni ng   i t s   own   t oSt r i ng( )    met hod,	Span   over r i des   t he
/ /   t oSt r i ng( )    met hod   t hat   i t   woul d   ot her wi s e   i nher i t   f r om Range. Span. pr ot ot ype. t oSt r i ng   =   f unc t i on( )    {
r et ur n   ` ( ${ t hi s . f r om} . . .	+${ t hi s . t o   -    t hi s . f r om} ) ` ; } ;

In order to make Span a subclass of Range, we need to arrange for Span. pr ot ot ype to inherit from Range. pr ot ot ype. The key line
of code in the preceding example is this one, and if it makes sense to you, you understand how subclasses work in JavaScript:

Span. pr ot ot ype   =   Obj ec t . c r eat e( Range. pr ot ot ype) ;


Objects created with the Span( )  constructor will inherit from the Span. pr ot ot ype object. But we created that object to inherit from Range. pr ot ot ype, so Span objects will inherit from both
Span. pr ot ot ype and Range. pr ot ot ype.


You may notice that our Span( )  constructor sets the same f r omand t o properties that the Range( )  constructor does and so does not need to invoke the Range( )  constructor to initialize the new object. Similarly, Span’s t oSt r i ng( )  method completely re-implements the string conversion without needing to call Range’s version of t oSt r i ng( ) . This makes Span a special case, and we can only really get away with this kind of subclassing because we know the implementation details of the superclass. A robust subclassing mechanism needs to allow classes to invoke the methods and constructor of their superclass, but prior to ES6, JavaScript did not have a simple way to do these things.

Fortunately, ES6 solves these problems with the s uper  keyword as part of the cl as s  syntax. The next section demonstrates how it works.

9.5.2 Subclasses with extends and super

In ES6 and later, you can create a superclass simply by adding an
ext ends  clause to a class declaration, and you can do this even for built-in classes:

/ /   A  t r i vi al	Ar r ay   s ubc l as s   t hat   adds   get t er s   f or   t he   f i r s t   and l as t   el ement s .
c l as s   EZAr r ay   ext ends   Ar r ay   {
get   f i r s t ( )    {    r et ur n   t hi s [ 0] ;	}
get   l as t ( )    {    r et ur n   t hi s [ t hi s . l engt h- 1] ;	} }

l et   a   =   new  EZAr r ay( ) ;

a   i ns t anc eof a   i ns t anc eof i ns t anc e.

EZAr r ay Ar r ay

/ /   =>   t r ue: / /   =>   t r ue:

a   i s   s ubc l as s   i ns t anc e a   i s   al s o   a   s uper c l as s

a. pus h( 1, 2, 3, 4) ;	/ /   a. l engt h   ==   4;	we   c an   us e   i nher i t ed met hods
a. pop( )	/ /   =>   4:	anot her   i nher i t ed   met hod
a. f i r s t	/ /   =>   1:	f i r s t   get t er   def i ned   by   s ubc l as s a. l as t	/ /   =>   3:	l as t   get t er   def i ned   by   s ubc l as s a[ 1]	/ /   =>   2:	r egul ar   ar r ay   ac c es s   s ynt ax   s t i l l wor ks .

Ar r ay. i s Ar r ay( a) ar r ay
EZAr r ay. i s Ar r ay( a)

/ /   =>   t r ue:

/ /   =>   t r ue:

s ubc l as s

s ubc l as s

i ns t anc e   r eal l y   i s   an

i nher i t s   s t at i c

met hods ,	t oo!


This EZArray subclass defines two simple getter methods. Instances of EZArray behave like ordinary arrays, and we can use inherited methods and properties like pus h( ) , pop( ) , and l engt h. But we can also use the f i r s t  and l as t  getters defined in the subclass. Not only are instance methods like pop( )  inherited, but static methods like
Ar r ay. i s Ar r ay are also inherited. This is a new feature enabled by ES6 class syntax: EZAr r ay( )  is a function, but it inherits from
Ar r ay( ) :

/ /   EZAr r ay   i nher i t s   i ns t anc e   met hods   bec aus e   EZAr r ay. pr ot ot ype / /   i nher i t s   f r om Ar r ay. pr ot ot ype
Ar r ay. pr ot ot ype. i s Pr ot ot ypeOf ( EZAr r ay. pr ot ot ype)    / /   =>   t r ue

/ /   And   EZAr r ay   i nher i t s   s t at i c   met hods   and   pr oper t i es   bec aus e
/ /   EZAr r ay   i nher i t s   f r om Ar r ay.	Thi s   i s   a   s pec i al	f eat ur e   of    t he / /   ext ends   keywor d   and   i s   not   pos s i bl e   bef or e   ES6.
Ar r ay. i s Pr ot ot ypeOf ( EZAr r ay)    / /   =>   t r ue


Our EZArray subclass is too simple to be very instructive. Example 9-6 is a more fully fleshed-out example. It defines a TypedMap subclass of the built-in Map class that adds type checking to ensure that the keys and values of the map are of the specified types (according to t ypeof ). Importantly, this example demonstrates the use of the s uper  keyword to invoke the constructor and methods of the superclass.

Example 9-6. TypedMap.js: a subclass of Map that checks key and value types

c l as s   TypedMap   ext ends   Map   {
c ons t r uc t or ( keyType,	val ueType,	ent r i es )    {
/ /   I f    ent r i es   ar e   s pec i f i ed,	c hec k   t hei r   t ypes i f    ( ent r i es )    {
f or ( l et   [ k,	v]    of    ent r i es )    {
i f    ( t ypeof    k   ! ==   keyType   ||   t ypeof    v   ! == val ueType)    {
t hr ow  new  TypeEr r or ( ` Wr ong   t ype   f or   ent r y [ ${ k} ,	${ v} ] ` ) ;
} }
}

/ /   I ni t i al i z e   t he   s uper c l as s   wi t h   t he   ( t ype- c hec ked) i ni t i al	ent r i es
s uper ( ent r i es ) ;

/ /   And   t hen   i ni t i al i z e   t hi s   s ubc l as s   by   s t or i ng   t he   t ypes t hi s . keyType   =   keyType;
t hi s . val ueType   =   val ueType; }

/ /   Now  r edef i ne   t he   s et ( )    met hod   t o   add   t ype   c hec ki ng   f or   any / /   new  ent r i es   added   t o   t he   map.
s et ( key,	val ue)    {
/ /   Thr ow  an   er r or   i f    t he   key   or   val ue   ar e   of    t he   wr ong t ype
i f    ( t hi s . keyType   &&  t ypeof    key   ! ==   t hi s . keyType)    {
t hr ow  new  TypeEr r or ( ` ${ key}    i s   not   of    t ype ${ t hi s . keyType} ` ) ;
}
i f    ( t hi s . val ueType   &&  t ypeof    val ue   ! ==   t hi s . val ueType)    { t hr ow  new  TypeEr r or ( ` ${ val ue}    i s   not   of    t ype
${ t hi s . val ueType} ` ) ; }


/ / ver s i on   of
/ / And   we
/ /

I f    t he   t ypes   ar e   c or r ec t ,	we   i nvoke   t he   s uper c l as s ' s

t he   s et ( )    met hod,	t o   ac t ual l y   add   t he   ent r y   t o   t he   map.

r et ur n   what ever   t he   s uper c l as s   met hod   r et ur ns .

r et ur n   s uper . s et ( key,	val ue) ; }
}

The first two arguments to the TypedMap( )  constructor are the desired key and value types. These should be strings, such as “number” and “boolean”, that the t ypeof  operator returns. You can also specify a third argument: an array (or any iterable object) of [ key, val ue]  arrays that specify the initial entries in the map. If you specify any initial entries, then the first thing the constructor does is verify that their types are correct. Next, the constructor invokes the superclass constructor, using the s uper keyword as if it was a function name. The Map( )  constructor takes one optional argument: an iterable object of [ key, val ue]  arrays. So the optional third argument of the TypedMap( )  constructor is the optional first argument to the Map( )  constructor, and we pass it to that superclass constructor with s uper ( ent r i es ) .


After invoking the superclass constructor to initialize superclass state, the

TypedMap( )  constructor next initializes its own subclass state by setting t hi s . keyType and t hi s . val ueType to the specified types. It needs to set these properties so that it can use them again in the s et ( )  method.


There are a few important rules that you will need to know about using s uper ( )  in constructors:

If you define a class with the ext ends  keyword, then the constructor for your class must use s uper ( )  to invoke the superclass constructor.

If you don’t define a constructor in your subclass, one will be defined automatically for you. This implicitly defined constructor simply takes whatever values are passed to it and passes those values to s uper ( ) .

You may not use the t hi s  keyword in your constructor until after you have invoked the superclass constructor with s uper ( ) . This enforces a rule that superclasses get to initialize themselves before subclasses do.

The special expression new. t ar get  is undefined in functions that are invoked without the newkeyword. In constructor functions, however, new. t ar get  is a reference to the constructor that was invoked. When a subclass constructor is invoked and uses s uper ( )  to invoke the superclass constructor, that superclass constructor will see the subclass constructor as the value of new. t ar get . A well-designed superclass should not need to know whether it has been subclassed, but it might be useful to be able to use new. t ar get . name in logging messages, for example.

After the constructor, the next part of Example 9-6 is a method named s et ( ) . The Map superclass defines a method named s et ( )  to add a new entry to the map. We say that this s et ( )  method in TypedMap

overrides the s et ( )  method of its superclass. This simple TypedMap subclass doesn’t know anything about adding new entries to map, but it does know how to check types, so that is what it does first, verifying that the key and value to be added to the map have the correct types and throwing an error if they do not. This s et ( )  method doesn’t have any way to add the key and value to the map itself, but that is what the superclass s et ( )  method is for. So we use the s uper  keyword again to invoke the superclass’s version of the method. In this context, s uper works much like the t hi s  keyword does: it refers to the current object but allows access to overridden methods defined in the superclass.

In constructors, you are required to invoke the superclass constructor before you can access t hi s  and initialize the new object yourself. There are no such rules when you override a method. A method that overrides a superclass method is not required to invoke the superclass method. If it does use s uper  to invoke the overridden method (or any method) in the superclass, it can do that at the beginning or the middle or the end of the overriding method.

Finally, before we leave the TypedMap example behind, it is worth noting that this class is an ideal candidate for the use of private fields. As the class is written now, a user could change the keyType or val ueType properties to subvert the type checking. Once private fields are supported, we could change these properties to #keyType and #val ueType so that they could not be altered from the outside.


9.5.3 Delegation Instead of Inheritance

The ext ends  keyword makes it easy to create subclasses. But that does not mean that you should create lots of subclasses. If you want to write a

class that shares the behavior of some other class, you can try to inherit that behavior by creating a subclass. But it is often easier and more flexible to get that desired behavior into your class by having your class create an instance of the other class and simply delegating to that instance as needed. You create a new class not by subclassing, but instead by wrapping or “composing” other classes. This delegation approach is often called “composition,” and it is an oft-quoted maxim of object-oriented programming that one should “favor composition over inheritance.”2


Suppose, for example, we wanted a Histogram class that behaves something like JavaScript’s Set class, except that instead of just keeping track of whether a value has been added to set or not, it instead maintains a count of the number of times the value has been added. Because the API for this Histogram class is similar to Set, we might consider subclassing Set and adding a count ( )  method. On the other hand, once we start thinking about how we might implement this count ( )  method, we might realize that the Histogram class is more like a Map than a Set because it needs to maintain a mapping between values and the number of times they have been added. So instead of subclassing Set, we can create a class that defines a Set-like API but implements those methods by delegating to an internal Map object. Example 9-7 shows how we could do this.

Example 9-7. Histogram.js: a Set-like class implemented with delegation
/ **
*   A  Set - l i ke   c l as s   t hat   keeps   t r ac k   of    how  many   t i mes   a   val ue   has *   been   added.	Cal l	add( )    and   r emove( )    l i ke   you   woul d   f or   a   Set ,
and
*   c al l	c ount ( )    t o   f i nd   out   how  many   t i mes   a   gi ven   val ue   has   been added.
*   The   def aul t   i t er at or   yi el ds   t he   val ues   t hat   have   been   added   at l eas t
*   onc e.	Us e   ent r i es ( )    i f    you   want   t o   i t er at e   [ val ue,	c ount ] pai r s .
*/

c l as s   Hi s t ogr am {
/ /   To   i ni t i al i z e,	we   j us t   c r eat e   a   Map   obj ec t   t o   del egat e   t o c ons t r uc t or ( )    {    t hi s . map   =   new  Map( ) ;	}

/ /   For   any   gi ven   key,	t he   c ount   i s   t he   val ue   i n   t he   Map,	or z er o
/ /   i f    t he   key   does   not   appear   i n   t he   Map.
c ount ( key)    {    r et ur n   t hi s . map. get ( key)    ||   0;	}

/ /   The   Set - l i ke   met hod   has ( )    r et ur ns   t r ue   i f    t he   c ount   i s   non-z er o
has ( key)    {    r et ur n   t hi s . c ount ( key)    >   0;	}

/ /   The   s i z e   of    t he   hi s t ogr am i s   j us t   t he   number   of    ent r i es   i n t he   Map.
get   s i z e( )    {    r et ur n   t hi s . map. s i z e;	}

/ /   To   add   a   key,	j us t   i nc r ement   i t s   c ount   i n   t he   Map. add( key)    {    t hi s . map. s et ( key,	t hi s . c ount ( key)    +   1) ;	}


/ /   Del et i ng   a   key   i s   a   l i t t l e   t r i c ki er   bec aus e del et e
/ /   t he   key   f r om t he   Map   i f    t he   c ount   goes   bac k

we   have   t o

down   t o   z er o.

del et e( key)    {
l et   c ount   =   t hi s . c ount ( key) ; i f    ( c ount   ===   1)    {
t hi s . map. del et e( key) ; }    el s e   i f    ( c ount   >   1)    {
t hi s . map. s et ( key,	c ount   -    1) ; }
}

/ /   I t er at i ng   a   Hi s t ogr am j us t   r et ur ns   t he   keys   s t or ed   i n   i t [ Symbol . i t er at or ] ( )    {    r et ur n   t hi s . map. keys ( ) ;	}

/ /   Thes e   ot her   i t er at or   met hods   j us t   del egat e   t o   t he   Map obj ec t
keys ( )    {    r et ur n   t hi s . map. keys ( ) ;	}
val ues ( )    {    r et ur n   t hi s . map. val ues ( ) ;	} ent r i es ( )    {    r et ur n   t hi s . map. ent r i es ( ) ;	}
}

All the Hi s t ogr am( )  constructor does in Example 9-7 is create a Map object. And most of the methods are one-liners that just delegate to a

method of the map, making the implementation quite simple. Because we used delegation rather than inheritance, a Histogram object is not an instance of Set or Map. But Histogram implements a number of commonly used Set methods, and in an untyped language like JavaScript, that is often good enough: a formal inheritance relationship is sometimes nice, but often optional.


9.5.4 Class Hierarchies and Abstract Classes

Example 9-6 demonstrated how we can subclass Map. Example 9-7 demonstrated how we can instead delegate to a Map object without actually subclassing anything. Using JavaScript classes to encapsulate data and modularize your code is often a great technique, and you may find yourself using the cl as s  keyword frequently. But you may find that you prefer composition to inheritance and that you rarely need to use
ext ends  (except when you’re using a library or framework that requires you to extend its base classes).

There are some circumstances when multiple levels of subclassing are appropriate, however, and we’ll end this chapter with an extended example that demonstrates a hierarchy of classes representing different kinds of sets. (The set classes defined in Example 9-8 are similar to, but not completely compatible with, JavaScript’s built-in Set class.)


Example 9-8 defines lots of subclasses, but it also demonstrates how you can define abstract classes—classes that do not include a complete implementation—to serve as a common superclass for a group of related subclasses. An abstract superclass can define a partial implementation that all subclasses inherit and share. The subclasses, then, only need to define their own unique behavior by implementing the abstract methods defined

—but not implemented—by the superclass. Note that JavaScript does not have any formal definition of abstract methods or abstract classes; I’m simply using that name here for unimplemented methods and incompletely implemented classes.


Example 9-8 is well commented and stands on its own. I encourage you to read it as a capstone example for this chapter on classes. The final class in Example 9-8 does a lot of bit manipulation with the &, |, and ~ operators, which you can review in §4.8.3.

Example 9-8. Sets.js: a hierarchy of abstract and concrete set classes
/ **
*   The   Abs t r ac t Set   c l as s   def i nes   a   s i ngl e   abs t r ac t   met hod,	has ( ) . */
c l as s   Abs t r ac t Set   {

/ /   Thr ow  an   er r or   her e / /   t o   def i ne   t hei r   own

s o   t hat wor ki ng

s ubc l as s es ver s i on   of

ar e   f or c ed
t hi s   met hod.

has ( x)    {    t hr ow  new  Er r or ( " Abs t r ac t   met hod" ) ;	} }

/ **
*   Not Set   i s   a   c onc r et e   s ubc l as s   of    Abs t r ac t Set .
*   The   member s   of    t hi s   s et   ar e   al l	val ues   t hat   ar e   not   member s   of s ome
*   ot her   s et .	Bec aus e   i t   i s   def i ned   i n   t er ms   of    anot her   s et   i t   i s not
*   wr i t abl e,	and   bec aus e   i t   has   i nf i ni t e   member s ,	i t   i s   not enumer abl e.
*   Al l	we   c an   do   wi t h   i t   i s   t es t   f or   member s hi p   and   c onver t   i t   t o a
*   s t r i ng   us i ng   mat hemat i c al	not at i on. */
c l as s   Not Set   ext ends   Abs t r ac t Set   {
c ons t r uc t or ( s et )    { s uper ( ) ;
t hi s . s et   =   s et ; }

/ /   Our   i mpl ement at i on   of    t he   abs t r ac t   met hod   we   i nher i t ed has ( x)    {    r et ur n   ! t hi s . s et . has ( x) ;	}
/ /   And   we   al s o   over r i de   t hi s   Obj ec t   met hod

t oSt r i ng( )    {    r et ur n   ` {    x|   x   ∉  ${ t hi s . s et . t oSt r i ng( ) }    } ` ;	} }

/ **
*   Range   s et   i s   a   c onc r et e   s ubc l as s   of    Abs t r ac t Set .	I t s   member s ar e
*   al l	val ues   t hat   ar e   bet ween   t he   f r om and   t o   bounds ,	i nc l us i ve. *   Si nc e   i t s   member s   c an   be   f l oat i ng   poi nt   number s ,	i t   i s   not
*   enumer abl e   and   does   not   have   a   meani ngf ul	s i z e. */
c l as s   RangeSet   ext ends   Abs t r ac t Set   {
c ons t r uc t or ( f r om,	t o)    { s uper ( ) ;
t hi s . f r om =   f r om; t hi s . t o   =   t o;
}

has ( x)    {    r et ur n   x   >=   t hi s . f r om &&  x   <=   t hi s . t o;	}
t oSt r i ng( )    {    r et ur n   ` {    x|   ${ t hi s . f r om}    ≤   x   ≤   ${ t hi s . t o}    } ` ;	} }

/ *
*   Abs t r ac t Enumer abl eSet   i s   an   abs t r ac t   s ubc l as s   of    Abs t r ac t Set . I t   def i nes
*   an   abs t r ac t   get t er   t hat   r et ur ns   t he   s i z e   of    t he   s et   and   al s o def i nes   an
*   abs t r ac t   i t er at or .	And   i t   t hen   i mpl ement s   c onc r et e   i s Empt y( ) , t oSt r i ng( ) ,
*   and   equal s ( )    met hods   on   t op   of    t hos e.	Subc l as s es   t hat   i mpl ement t he
*   i t er at or ,	t he   s i z e   get t er ,	and   t he   has ( )    met hod   get   t hes e c onc r et e
*   met hods   f or   f r ee. */
c l as s   Abs t r ac t Enumer abl eSet   ext ends   Abs t r ac t Set   {
get   s i z e( )    {    t hr ow  new  Er r or ( " Abs t r ac t   met hod" ) ;	}
[ Symbol . i t er at or ] ( )    {    t hr ow  new  Er r or ( " Abs t r ac t   met hod" ) ;	}

i s Empt y( )    {    r et ur n   t hi s . s i z e   ===   0;	}
t oSt r i ng( )    {    r et ur n   ` { ${ Ar r ay. f r om( t hi s ) . j oi n( " ,	" ) } } ` ;	} equal s ( s et )    {
/ /   I f    t he   ot her   s et   i s   not   al s o   Enumer abl e,	i t   i s n' t   equal t o   t hi s   one
i f    ( ! ( s et   i ns t anc eof    Abs t r ac t Enumer abl eSet ) )    r et ur n   f al s e;

/ /   I f    t hey   don' t   have   t he   s ame   s i z e,	t hey' r e   not   equal

i f    ( t hi s . s i z e   ! ==   s et . s i z e)    r et ur n   f al s e;

/ /   L oop   t hr ough   t he   el ement s   of    t hi s   s et f or ( l et   el ement   of    t hi s )    {
/ /   I f    an   el ement   i s n' t   i n   t he   ot her   s et ,	t hey   ar en' t equal
i f    ( ! s et . has ( el ement ) )    r et ur n   f al s e;
}

/ /   The   el ement s   mat c hed,	s o   t he   s et s   ar e   equal r et ur n   t r ue;
} }


/ *
*   Si ngl et onSet   i s *   A  s i ngl et on   s et */


a   c onc r et e   s ubc l as s   of    Abs t r ac t Enumer abl eSet . i s   a   r ead- onl y   s et   wi t h   a   s i ngl e   member .

c l as s   Si ngl et onSet   ext ends   Abs t r ac t Enumer abl eSet   { c ons t r uc t or ( member )    {
s uper ( ) ;
t hi s . member   =   member ; }


/ /   We   i mpl ement   t hes e   t hr ee   met hods ,	and   i nher i t equal s ( )
/ /   and   t oSt r i ng( )    i mpl ement at i ons   bas ed   on   t hes e

i s Empt y,

met hods .

has ( x)    {    r et ur n   x   ===   t hi s . member ;	} get   s i z e( )    {    r et ur n   1;	}
*[ Symbol . i t er at or ] ( )    {    yi el d   t hi s . member ;	} }

/ *
*   Abs t r ac t Wr i t abl eSet   i s   an   abs t r ac t   s ubc l as s   of Abs t r ac t Enumer abl eSet .
*   I t   def i nes   t he   abs t r ac t   met hods   i ns er t ( )    and   r emove( )    t hat i ns er t   and
*   r emove   i ndi vi dual	el ement s   f r om t he   s et ,	and   t hen   i mpl ement s c onc r et e
*   add( ) ,	s ubt r ac t ( ) ,	and   i nt er s ec t ( )    met hods   on   t op   of    t hos e. Not e   t hat
*   our   API	di ver ges   her e   f r om t he   s t andar d   J avaSc r i pt   Set   c l as s . */
c l as s   Abs t r ac t Wr i t abl eSet   ext ends	Abs t r ac t Enumer abl eSet   {
i ns er t ( x)    {    t hr ow  new  Er r or ( " Abs t r ac t   met hod" ) ;	}

r emove( x)    {    t hr ow  new  Er r or ( " Abs t r ac t   met hod" ) ;	}

add( s et )    {
f or ( l et   el ement   of    s et )    { t hi s . i ns er t ( el ement ) ;
} }

s ubt r ac t ( s et )    {
f or ( l et   el ement   of    s et )    { t hi s . r emove( el ement ) ;
} }

i nt er s ec t ( s et )    {
f or ( l et   el ement   of    t hi s )    {
i f    ( ! s et . has ( el ement ) )    { t hi s . r emove( el ement ) ;
} }
} }

/ **
*   A  Bi t Set   i s   a   c onc r et e   s ubc l as s   of    Abs t r ac t Wr i t abl eSet   wi t h   a *   ver y   ef f i c i ent   f i xed- s i z e   s et   i mpl ement at i on   f or   s et s   whos e
*   el ement s   ar e   non- negat i ve   i nt eger s   l es s   t han   s ome   maxi mum s i z e. */
c l as s   Bi t Set   ext ends   Abs t r ac t Wr i t abl eSet   {
c ons t r uc t or ( max)    { s uper ( ) ;
t hi s . max   =   max;	/ /   The   maxi mum i nt eger   we   c an   s t or e. t hi s . n   =   0;	/ /   How  many   i nt eger s   ar e   i n   t he   s et
t hi s . numByt es   =   Mat h. f l oor ( max   /   8)    +   1;	/ /   How  many byt es   we   need
t hi s . dat a   =   new  Ui nt 8Ar r ay( t hi s . numByt es ) ;	/ /   The   byt es }

/ /   I nt er nal	met hod   t o   c hec k   i f    a   val ue   i s   a   l egal	member   of t hi s   s et
_val i d( x)    {    r et ur n   Number . i s I nt eger ( x)    &&  x   >=   0   &&  x   <=
t hi s . max;	}


/ /   Tes t s   whet her our
/ /   dat a   ar r ay   i s

t he   s pec i f i ed   bi t   of    t he

s et   or   not .	Ret ur ns   t r ue

s pec i f i ed   byt e   of

or   f al s e.

_has ( byt e,	bi t )    {    r et ur n   ( t hi s . dat a[ byt e]    &  Bi t Set . bi t s [ bi t ] ) ! ==   0;	}

/ /   I s   t he   val ue   x   i n   t hi s   Bi t Set ? has ( x)    {
i f    ( t hi s . _val i d( x) )    {
l et   byt e   =   Mat h. f l oor ( x   /   8) ; l et   bi t   =   x   %  8;
r et ur n   t hi s . _has ( byt e,	bi t ) ; }    el s e   {
r et ur n   f al s e; }
}

/ /   I ns er t   t he   val ue   x   i nt o   t he   Bi t Set i ns er t ( x)    {
i f    ( t hi s . _val i d( x) )    {	/ /   I f    t he   val ue   i s val i d
l et   byt e   =   Mat h. f l oor ( x   /   8) ;	/ /   c onver t   t o   byt e   and bi t
l et   bi t   =   x   %  8;
i f    ( ! t hi s . _has ( byt e,	bi t ) )    {	/ /   I f    t hat   bi t   i s   not s et   yet


i t

i nc r ement

t hi s . dat a[ byt e]    |=   Bi t Set . bi t s [ bi t ] ;

t hi s . n++; s et   s i z e
}

/ /   t hen   s et

/ /   and

}    el s e   {
t hr ow  new  TypeEr r or ( " I nval i d   s et   el ement :	"   +   x   ) ; }
}

r emove( x)    {
i f    ( t hi s . _val i d( x) )    {	/ /   I f    t he   val ue   i s val i d
l et   byt e   =   Mat h. f l oor ( x   /   8) ;	/ /   c omput e   t he   byt e   and bi t
l et   bi t   =   x   %  8;
i f    ( t hi s . _has ( byt e,	bi t ) )    {	/ /   I f    t hat   bi t   i s

al r eady   s et
t hi s . dat a[ byt e]    &=   Bi t Set . mas ks [ bi t ] ;	/ /   t hen uns et   i t
t hi s . n- - ;	/ /   and dec r ement   s i z e
}
}    el s e   {
t hr ow  new  TypeEr r or ( " I nval i d   s et   el ement :	"   +   x   ) ; }
}

/ /   A  get t er   t o   r et ur n   t he   s i z e   of    t he   s et get   s i z e( )    {    r et ur n   t hi s . n;	}


/ /   I t er at e   t he   s et   by / /   ( We   c oul d   be   a   l ot
s ubs t ant i al l y)

j us t   c hec ki ng   eac h   bi t   i n   t ur n. mor e   c l ever   and   opt i mi z e   t hi s

*[ Symbol . i t er at or ] ( )    {
f or ( l et   i	=   0;	i	<=   t hi s . max;	i ++)    { i f    ( t hi s . has ( i ) )    {
yi el d   i ; }
} }
}

/ /   Some   pr e- c omput ed   val ues   us ed   by   t he   has ( ) ,	i ns er t ( )    and r emove( )    met hods
Bi t Set . bi t s   =   new  Ui nt 8Ar r ay( [ 1,	2,	4,	8,	16,	32,	64,	128] ) ;
Bi t Set . mas ks   =   new  Ui nt 8Ar r ay( [ ~1,	~2,	~4,	~8,	~16,	~32,	~64, ~128] ) ;


9.6 Summary

This chapter has explained the key features of JavaScript classes:


Objects that are members of the same class inherit properties from the same prototype object. The prototype object is the key feature of JavaScript classes, and it is possible to define classes with nothing more than the Obj ect . cr eat e( )  method.

Prior to ES6, classes were more typically defined by first defining a constructor function. Functions created with the f unct i on keyword have a pr ot ot ype property, and the value of this property is an object that is used as the prototype of all objects created when the function is invoked with newas a constructor. By initializing this prototype object, you can define the shared methods of your class. Although the prototype object is the key feature of the class, the constructor function is the public identity of the class.

ES6 introduces a cl as s  keyword that makes it easier to define classes, but under the hood, constructor and prototype mechanism remains the same.

Subclasses are defined using the ext ends  keyword in a class declaration.

Subclasses can invoke the constructor of their superclass or overridden methods of their superclass with the s uper  keyword.





1



2

Except functions returned by the ES5 Func t i on. bi nd( )  method. Bound functions have no prototype property of their own, but they use the prototype of the underlying function if they are invoked as constructors.

See Design Patterns (Addison-Wesley Professional) by Erich Gamma et al. or Effective Java (Addison-Wesley Professional) by Joshua Bloch, for example.



Chapter 10. Modules




The goal of modular programming is to allow large programs to be assembled using modules of code from disparate authors and sources and for all of that code to run correctly even in the presence of code that the various module authors did not anticipate. As a practical matter, modularity is mostly about encapsulating or hiding private implementation details and keeping the global namespace tidy so that modules cannot accidentally modify the variables, functions, and classes defined by other modules.


Until recently, JavaScript had no built-in support for modules, and programmers working on large code bases did their best to use the weak modularity available through classes, objects, and closures. Closure-based modularity, with support from code-bundling tools, led to a practical form of modularity based on a r equi r e( )  function, which was adopted by Node. r equi r e( ) -based modules are a fundamental part of the Node programming environment but were never adopted as an official part of the JavaScript language. Instead, ES6 defines modules using i mpor t  and expor t  keywords. Although i mpor t  and expor t  have been part of the language for years, they were only implemented by web browsers and Node relatively recently. And, as a practical matter, JavaScript modularity still depends on code-bundling tools.

The sections that follow cover:


Do-it-yourself modules with classes, objects, and closures

Node modules using r equi r e( )

ES6 modules using expor t , i mpor t , and i mpor t ( )


10.1 Modules with Classes, Objects, and Closures

Though it may be obvious, it is worth pointing out that one of the important features of classes is that they act as modules for their methods. Think back to Example 9-8. That example defined a number of different classes, all of which had a method named has ( ) . But you would have no problem writing a program that used multiple set classes from that example: there is no danger that the implementation of has ( )  from SingletonSet will overwrite the has ( )  method of BitSet, for example.


The reason that the methods of one class are independent of the methods of other, unrelated classes is that the methods of each class are defined as properties of independent prototype objects. The reason that classes are modular is that objects are modular: defining a property in a JavaScript object is a lot like declaring a variable, but adding properties to objects does not affect the global namespace of a program, nor does it affect the properties of other objects. JavaScript defines quite a few mathematical functions and constants, but instead of defining them all globally, they are grouped as properties of a single global Math object. This same technique could have been used in Example 9-8. Instead of defining global classes with names like SingletonSet and BitSet, that example could have been written to define only a single global Sets object, with properties referencing the various classes. Users of this Sets library could then refer to the classes with names like Set s . Si ngl et on and Set s . Bi t .


Using classes and objects for modularity is a common and useful

technique in JavaScript programming, but it doesn’t go far enough. In particular, it doesn’t offer us any way to hide internal implementation details inside the module. Consider Example 9-8 again. If we were writing that example as a module, maybe we would have wanted to keep the various abstract classes internal to the module, only making the concrete subclasses available to users of the module. Similarly, in the BitSet class, the _val i d( )  and _has ( )  methods are internal utilities that should not really be exposed to users of the class. And Bi t Set . bi t s  and
Bi t Set . mas ks  are implementation details that would be better off hidden.

As we saw in §8.6, local variables and nested functions declared within a function are private to that function. This means that we can use immediately invoked function expressions to achieve a kind of modularity by leaving the implementation details and utility functions hidden within the enclosing function but making the public API of the module the return value of the function. In the case of the BitSet class, we might structure the module like this:

c ons t   Bi t Set   =   ( f unc t i on( )    {    / /   Set   Bi t Set   t o   t he   r et ur n   val ue of    t hi s   f unc t i on
/ /   Pr i vat e   i mpl ement at i on   det ai l s   her e f unc t i on   i s Val i d( s et ,	n)    {    . . .	}
f unc t i on   has ( s et ,	byt e,	bi t )    {    . . .	}
c ons t   BI TS   =   new  Ui nt 8Ar r ay( [ 1,	2,	4,	8,	16,	32,	64,	128] ) ; c ons t   MASKS   =   new  Ui nt 8Ar r ay( [ ~1,    ~2,	~4,    ~8,    ~16,	~32,	~64,
~128] ) ;

/ /   The   publ i c   API	of    t he   modul e   i s   j us t   t he   Bi t Set   c l as s , whi c h   we   def i ne
/ /   and   r et ur n   her e.	The   c l as s   c an   us e   t he   pr i vat e   f unc t i ons and   c ons t ant s
/ /   def i ned   above,	but   t hey   wi l l	be   hi dden   f r om us er s   of    t he c l as s
r et ur n   c l as s   Bi t Set   ext ends   Abs t r ac t Wr i t abl eSet   { / /   . . .	i mpl ement at i on   omi t t ed   . . .

} ; } ( ) ) ;


This approach to modularity becomes a little more interesting when the module has more than one item in it. The following code, for example, defines a mini statistics module that exports mean( )  and s t ddev( ) functions while leaving the implementation details hidden:

/ /   Thi s   i s   how  we   c oul d   def i ne   a   s t at s   modul e c ons t   s t at s   =   ( f unc t i on( )    {
/ /   Ut i l i t y   f unc t i ons   pr i vat e   t o   t he   modul e c ons t   s um =   ( x,	y)    =>   x   +   y;
c ons t   s quar e   =   x   =>   x   *   x;

/ /   A  publ i c   f unc t i on   t hat   wi l l	be   expor t ed f unc t i on   mean( dat a)    {
r et ur n   dat a. r educ e( s um) / dat a. l engt h; }

/ /   A  publ i c   f unc t i on   t hat   we   wi l l	expor t f unc t i on   s t ddev( dat a)    {
l et   m =   mean( dat a) ; r et ur n   Mat h. s qr t (
dat a. map( x   =>   x   -
m) . map( s quar e) . r educ e( s um) / ( dat a. l engt h- 1) ) ;
}

/ /   We   expor t   t he   publ i c   f unc t i on   as   pr oper t i es   of    an   obj ec t r et ur n   {    mean,	s t ddev   } ;
} ( ) ) ;

/ /   And   her e   i s   how  we   mi ght   us e   t he   modul e s t at s . mean( [ 1,	3,	5,	7,	9] )	/ /   =>   5
s t at s . s t ddev( [ 1,	3,	5,	7,	9] )    / /   =>   Mat h. s qr t ( 10)


10.1.1 Automating Closure-Based Modularity

Note that it is a fairly mechanical process to transform a file of JavaScript

code into this kind of module by inserting some text at the beginning and end of the file. All that is needed is some convention for the file of JavaScript code to indicate which values are to be exported and which are not.


Imagine a tool that takes a set of files, wraps the content of each of those files within an immediately invoked function expression, keeps track of the return value of each function, and concatenates everything into one big file. The result might look something like this:

c ons t   modul es   =   { } ;
f unc t i on   r equi r e( modul eName)    {    r et ur n   modul es [ modul eName] ;	}

modul es [ " s et s . j s " ]    =   ( f unc t i on( )    { c ons t   expor t s   =   { } ;

/ /   The   c ont ent s   of    t he   s et s . j s   f i l e   go   her e: expor t s . Bi t Set   =   c l as s   Bi t Set   {    . . .	} ;

r et ur n   expor t s ; } ( ) ) ;

modul es [ " s t at s . j s " ]    =   ( f unc t i on( )    { c ons t   expor t s   =   { } ;

/ /   The   c ont ent s   of    t he   s t at s . j s   f i l e   go   her e: c ons t   s um =   ( x,	y)    =>   x   +   y;
c ons t   s quar e   =   x   =   >   x   *   x;
expor t s . mean   =   f unc t i on( dat a)    {    . . .	} ; expor t s . s t ddev   =   f unc t i on( dat a)    {    . . .	} ;

r et ur n   expor t s ; } ( ) ) ;


With modules bundled up into a single file like the one shown in the preceding example, you can imagine writing code like the following to make use of those modules:

/ /   Get   r ef er enc es   t o   t he   modul es   ( or   t he   modul e   c ont ent )    t hat   we need
c ons t   s t at s   =   r equi r e( " s t at s . j s " ) ;
c ons t   Bi t Set   =   r equi r e( " s et s . j s " ) . Bi t Set ;

/ /   Now  wr i t e   c ode   us i ng   t hos e   modul es l et   s   =   new  Bi t Set ( 100) ;
s . i ns er t ( 10) ; s . i ns er t ( 20) ; s . i ns er t ( 30) ;
l et   aver age   =   s t at s . mean( [ . . . s ] ) ;	/ /   aver age   i s   20


This code is a rough sketch of how code-bundling tools (such as webpack and Parcel) for web browsers work, and it’s also a simple introduction to the r equi r e( )  function like the one used in Node programs.


10.2 Modules in Node

In Node programming, it is normal to split programs into as many files as seems natural. These files of JavaScript code are assumed to all live on a fast filesystem. Unlike web browsers, which have to read files of JavaScript over a relatively slow network connection, there is no need or benefit to bundling a Node program into a single JavaScript file.


In Node, each file is an independent module with a private namespace. Constants, variables, functions, and classes defined in one file are private to that file unless the file exports them. And values exported by one module are only visible in another module if that module explicitly imports them.


Node modules import other modules with the r equi r e( )  function and export their public API by setting properties of the Exports object or by replacing the modul e. expor t s object entirely.

10.2.1 Node Exports

Node defines a global expor t s  object that is always defined. If you are writing a Node module that exports multiple values, you can simply assign them to the properties of this object:

c ons t   s um =   ( x,	y)    =>   x   +   y; c ons t   s quar e   =   x   =>   x   *   x;

expor t s . mean   =   dat a   =>   dat a. r educ e( s um) / dat a. l engt h; expor t s . s t ddev   =   f unc t i on( d)    {
l et   m =   expor t s . mean( d) ;
r et ur n   Mat h. s qr t ( d. map( x   =>   x   -
m) . map( s quar e) . r educ e( s um) / ( d. l engt h- 1) ) ; } ;


Often, however, you want to define a module that exports only a single function or class rather than an object full of functions or classes. To do this, you simply assign the single value you want to export to
modul e. expor t s :


modul e. expor t s   =   c l as s   Bi t Set   ext ends   Abs t r ac t Wr i t abl eSet   { / /   i mpl ement at i on   omi t t ed
} ;


The default value of modul e. expor t s  is the same object that
expor t s  refers to. In the previous stats module, we could have assigned the mean function to modul e. expor t s . mean instead of
expor t s . mean. Another approach with modules like the stats module is to export a single object at the end of the module rather than exporting functions one by one as you go:

/ /   Def i ne   al l	t he   f unc t i ons ,	publ i c   and   pr i vat e c ons t   s um =   ( x,	y)    =>   x   +   y;
c ons t   s quar e   =   x   =>   x   *   x;

c ons t   mean   =   dat a   =>   dat a. r educ e( s um) / dat a. l engt h; c ons t   s t ddev   =   d   =>   {
l et   m =   mean( d) ;
r et ur n   Mat h. s qr t ( d. map( x   =>   x   -
m) . map( s quar e) . r educ e( s um) / ( d. l engt h- 1) ) ; } ;

/ /   Now  expor t   onl y   t he   publ i c   ones modul e. expor t s   =   {    mean,    s t ddev   } ;


10.2.2 Node Imports

A Node module imports another module by calling the r equi r e( ) function. The argument to this function is the name of the module to be imported, and the return value is whatever value (typically a function, class, or object) that module exports.

If you want to import a system module built in to Node or a module that you have installed on your system via a package manager, then you simply use the unqualified name of the module, without any “/” characters that would turn it into a filesystem path:

/ /   Thes e   modul es   ar e   bui l t   i n   t o   Node
c ons t   f s   =   r equi r e( " f s " ) ;	/ /   The   bui l t - i n   f i l es ys t em modul e
c ons t   ht t p   =   r equi r e( " ht t p" ) ;	/ /   The   bui l t - i n   HTTP   modul e

/ /   The   Expr es s   HTTP   s er ver   f r amewor k   i s   a   t hi r d- par t y   modul e. / /   I t   i s   not   par t   of    Node   but   has   been   i ns t al l ed   l oc al l y
c ons t   expr es s   =   r equi r e( " expr es s " ) ;


When you want to import a module of your own code, the module name should be the path to the file that contains that code, relative to the current module’s file. It is legal to use absolute paths that begin with a / character, but typically, when importing modules that are part of your own program, the module names will begin with ./ or sometimes ../ to indicate that they

are relative to the current directory or the parent directory. For example:


c ons t   s t at s   =   r equi r e( ' . / s t at s . j s ' ) ;
c ons t   Bi t Set   =   r equi r e( ' . / ut i l s / bi t s et . j s ' ) ;


(You can also omit the .js suffix on the files you’re importing and Node will still find the files, but it is common to see these file extensions explicitly included.)


When a module exports just a single function or class, all you have to do is require it. When a module exports an object with multiple properties, you have a choice: you can import the entire object, or just import the specific properties (using destructuring assignment) of the object that you plan to use. Compare these two approaches:

/ /   I mpor t   t he   ent i r e   s t at s   obj ec t ,	wi t h   al l	of    i t s   f unc t i ons c ons t   s t at s   =   r equi r e( ' . / s t at s . j s ' ) ;


/ /   We' ve   got   mor e / /   or gani z ed   i nt o

f unc t i ons   t han   we   need,	but   t hey' r e   neat l y a   c onveni ent   " s t at s "   names pac e.

l et   aver age   =   s t at s . mean( dat a) ;


/ /   Al t er nat i vel y,	we   c an t o   i mpor t
/ /   exac t l y   t he   f unc t i ons names pac e:

us e   i di omat i c   des t r uc t ur i ng   as s i gnment

we   want   di r ec t l y   i nt o   t he   l oc al

c ons t   {    s t ddev   }    =   r equi r e( ' . / s t at s . j s ' ) ;


/ /   Thi s   i s / /   wi t hout f unc t i on.

ni c e   and   s uc c i nc t , t he   ' s t at s '    pr ef i x

t hough   we   l os e   a   bi t   of    c ont ext as   a   nams pac e   f or   t he   s t ddev( )

l et   s d   =   s t ddev( dat a) ;


10.2.3 Node-Style Modules on the Web

Modules with an Exports object and a r equi r e( )  function are built in to Node. But if you’re willing to process your code with a bundling tool like webpack, then it is also possible to use this style of modules for code that

is intended to run in web browsers. Until recently, this was a very common thing to do, and you may see lots of web-based code that still does it.


Now that JavaScript has its own standard module syntax, however, developers who use bundlers are more likely to use the official JavaScript modules with i mpor t  and expor t  statements.


10.3 Modules in ES6

ES6 adds i mpor t  and expor t  keywords to JavaScript and finally supports real modularity as a core language feature. ES6 modularity is conceptually the same as Node modularity: each file is its own module, and constants, variables, functions, and classes defined within a file are private to that module unless they are explicitly exported. Values that are exported from one module are available for use in modules that explicitly import them. ES6 modules differ from Node modules in the syntax used for exporting and importing and also in the way that modules are defined in web browsers. The sections that follow explain these things in detail.

First, though, note that ES6 modules are also different from regular JavaScript “scripts” in some important ways. The most obvious difference is the modularity itself: in regular scripts, top-level declarations of variables, functions, and classes go into a single global context shared by all scripts. With modules, each file has its own private context and can use the i mpor t  and expor t  statements, which is the whole point, after all. But there are other differences between modules and scripts as well. Code inside an ES6 module (like code inside any ES6 cl as s  definition) is automatically in strict mode (see §5.6.3). This means that, when you start using ES6 modules, you’ll never have to write " us e   s t r i ct " again. And it means that code in modules cannot use the wi t h statement or the

ar gument s  object or undeclared variables. ES6 modules are even slightly stricter than strict mode: in strict mode, in functions invoked as functions, t hi s  is undef i ned. In modules, t hi s  is undef i ned even in top-level code. (By contrast, scripts in web browsers and Node set
t hi s  to the global object.)



ES6 MODULES ON THE WEB AND IN NODE

ES6 modules have been in use on the web for years with the help of code bundlers like webpack, which combine independent modules of JavaScript code into large, non-modular bundles suitable for inclusion into web pages. At the time of this writing, however, ES6 modules are finally supported natively by all web browsers other than Internet Explorer. When used natively, ES6 modules are added into HTML pages with a special <s c r i pt   t ype=" modul e" > tag, described later in this chapter.

And meanwhile, having pioneered JavaScript modularity, Node finds itself in the awkward position of having to support two not entirely compatible module systems. Node 13 supports ES6 modules, but for now, the vast majority of Node programs still use Node modules.




10.3.1 ES6 Exports

To export a constant, variable, function, or class from an ES6 module, simply add the keyword expor t  before the declaration:


expor t   c ons t   PI	=   Mat h. PI ;

expor t   f unc t i on   degr ees ToRadi ans ( d)    {    r et ur n   d   *   PI	/   180;	}

expor t   c l as s   Ci r c l e   {
c ons t r uc t or ( r )    {    t hi s . r   =   r ;	}
ar ea( )    {    r et ur n   PI	*   t hi s . r   *   t hi s . r ;	} }


As an alternative to scattering expor t  keywords throughout your

module, you can define your constants, variables, functions, and classes as you normally would, with no expor t  statement, and then (typically at the end of your module) write a single expor t  statement that declares exactly what is exported in a single place. So instead of writing three individual exports in the preceding code, we could have equivalently written a single line at the end:

expor t   {    Ci r c l e,	degr ees ToRadi ans ,	PI	} ;


This syntax looks like the expor t  keyword followed by an object literal (using shorthand notation). But in this case, the curly braces do not actually define an object literal. This export syntax simply requires a comma-separated list of identifiers within curly braces.

It is common to write modules that export only one value (typically a function or class), and in this case, we usually use expor t   def aul t instead of expor t :

expor t   def aul t   c l as s   Bi t Set   { / /   i mpl ement at i on   omi t t ed
}


Default exports are slightly easier to import than non-default exports, so when there is only one exported value, using expor t   def aul t  makes things easier for the modules that use your exported value.

Regular exports with expor t  can only be done on declarations that have a name. Default exports with expor t   def aul t  can export any expression including anonymous function expressions and anonymous class expressions. This means that if you use expor t   def aul t , you can export object literals. So unlike the expor t  syntax, if you see curly

braces after expor t   def aul t , it really is an object literal that is being exported.

It is legal, but somewhat uncommon, for modules to have a set of regular exports and also a default export. If a module has a default export, it can only have one.


Finally, note that the expor t  keyword can only appear at the top level of your JavaScript code. You may not export a value from within a class, function, loop, or conditional. (This is an important feature of the ES6 module system and enables static analysis: a modules export will be the same on every run, and the symbols exported can be determined before the module is actually run.)


10.3.2 ES6 Imports

You import values that have been exported by other modules with the
i mpor t  keyword. The simplest form of import is used for modules that define a default export:

i mpor t   Bi t Set   f r om ' . / bi t s et . j s ' ;


This is the i mpor t  keyword, followed by an identifier, followed by the f r omkeyword, followed by a string literal that names the module whose default export we are importing. The default export value of the specified module becomes the value of the specified identifier in the current module.

The identifier to which the imported value is assigned is a constant, as if it had been declared with the cons t  keyword. Like exports, imports can only appear at the top level of a module and are not allowed within

classes, functions, loops, or conditionals. By near-universal convention, the imports needed by a module are placed at the start of the module. Interestingly, however, this is not required: like function declarations, imports are “hoisted” to the top, and all imported values are available for any of the module’s code runs.


The module from which a value is imported is specified as a constant string literal in single quotes or double quotes. (You may not use a variable or other expression whose value is a string, and you may not use a string within backticks because template literals can interpolate variables and do not always have constant values.) In web browsers, this string is interpreted as a URL relative to the location of the module that is doing the importing. (In Node, or when using a bundling tool, the string is interpreted as a filename relative to the current module, but this makes little difference in practice.) A module specifier string must be an absolute path starting with “/”, or a relative path starting with “./” or “../”, or a complete URL a with protocol and hostname. The ES6 specification does not allow unqualified module specifier strings like “util.js” because it is ambiguous whether this is intended to name a module in the same directory as the current one or some kind of system module that is installed in some special location. (This restriction against “bare module specifiers” is not honored by code-bundling tools like webpack, which can easily be configured to find bare modules in a library directory that you specify.) A future version of the language may allow “bare module specifiers,” but for now, they are not allowed. If you want to import a module from the same directory as the current one, simply place “./” before the module name and import from “./util.js” instead of “util.js”.


So far, we’ve only considered the case of importing a single value from a module that uses expor t   def aul t . To import values from a module

that exports multiple values, we use a slightly different syntax:


i mpor t   {    mean,	s t ddev   }    f r om " . / s t at s . j s " ;


Recall that default exports do not need to have a name in the module that defines them. Instead, we provide a local name when we import those values. But non-default exports of a module do have names in the exporting module, and when we import those values, we refer to them by those names. The exporting module can export any number of named value. An i mpor t  statement that references that module can import any subset of those values simply by listing their names within curly braces. The curly braces make this kind of i mpor t  statement look something like a destructuring assignment, and destructuring assignment is actually a good analogy for what this style of import is doing. The identifiers within curly braces are all hoisted to the top of the importing module and behave like constants.

Style guides sometimes recommend that you explicitly import every symbol that your module will use. When importing from a module that defines many exports, however, you can easily import everything with an i mpor t  statement like this:


i mpor t   *   as   s t at s   f r om " . / s t at s . j s " ;


An i mpor t  statement like this creates an object and assigns it to a constant named s t at s . Each of the non-default exports of the module being imported becomes a property of this s t at s  object. Non-default exports always have names, and those are used as property names within the object. Those properties are effectively constants: they cannot be overwritten or deleted. With the wildcard import shown in the previous example, the importing module would use the imported mean( )  and

s t ddev( )  functions through the s t at s  object, invoking them as s t at s . mean( )  and s t at s . s t ddev( ) .


Modules typically define either one default export or multiple named exports. It is legal, but somewhat uncommon, for a module to use both expor t  and expor t   def aul t . But when a module does that, you can import both the default value and the named values with an i mpor t statement like this:

i mpor t   Hi s t ogr am,	{    mean,	s t ddev   }    f r om " . / hi s t ogr am- s t at s . j s " ;


So far, we’ve seen how to import from modules with a default export and from modules with non-default or named exports. But there is one other form of the i mpor t  statement that is used with modules that have no exports at all. To include a no-exports module into your program, simply use the i mpor t  keyword with the module specifier:


i mpor t   " . / anal yt i c s . j s " ;


A module like this runs the first time it is imported. (And subsequent imports do nothing.) A module that just defines functions is only useful if it exports at least one of those functions. But if a module runs some code, then it can be useful to import even without symbols. An analytics module for a web application might run code to register various event handlers and then use those event handlers to send telemetry data back to the server at appropriate times. The module is self-contained and does not need to export anything, but we still need to i mpor t  it so that it does actually run as part of our program.

Note that you can use this import-nothing i mpor t  syntax even with modules that do have exports. If a module defines useful behavior

independent of the values it exports, and if your program does not need any of those exported values, you can still import the module . just for that default behavior.


10.3.3 Imports and Exports with Renaming

If two modules export two different values using the same name and you want to import both of those values, you will have to rename one or both of the values when you import it. Similarly, if you want to import a value whose name is already in use in your module, you will need to rename the imported value. You can use the as  keyword with named imports to rename them as you import them:

i mpor t   {    r ender   as   r ender I mage   }    f r om " . / i mageut i l s . j s " ; i mpor t   {    r ender   as   r ender UI	}    f r om " . / ui . j s " ;


These lines import two functions into the current module. The functions are both named r ender ( )  in the modules that define them but are imported with the more descriptive and disambiguating names
r ender I mage( )  and r ender UI ( ) .


Recall that default exports do not have a name. The importing module always chooses the name when importing a default export. So there is no need for a special syntax for renaming in that case.


Having said that, however, the possibility of renaming on import provides another way of importing from modules that define both a default export and named exports. Recall the “./histogram-stats.js” module from the previous section. Here is another way to import both the default and named exports of that module:

i mpor t   {    def aul t   as   Hi s t ogr am,	mean,	s t ddev   }    f r om " . / hi s t ogr am-

s t at s . j s " ;


In this case, the JavaScript keyword def aul t  serves as a placeholder and allows us to indicate that we want to import and provide a name for the default export of the module.

It is also possible to rename values as you export them, but only when using the curly brace variant of the expor t  statement. It is not common to need to do this, but if you chose short, succinct names for use inside your module, you might prefer to export your values with more descriptive names that are less likely to conflict with other modules. As with imports, you use the as  keyword to do this:


expor t   {

l ayout   as r ender   as
} ;

c al c ul at eL ayout , r ender L ayout



Keep in mind that, although the curly braces look something like object literals, they are not, and the expor t  keyword expects a single identifier before the as , not an expression. This means, unfortunately, that you cannot use export renaming like this:

expor t   {    Mat h. s i n   as   s i n,	Mat h. c os   as   c os   } ;	/ /   Synt axEr r or


10.3.4 Re-Exports

Throughout this chapter, we’ve discussed a hypothetical “./stats.js” module that exports mean( )  and s t ddev( )  functions. If we were writing such a module and we thought that many users of the module would want only one function or the other, then we might want to define mean( )  in a “./stats/mean.js” module and define s t ddev( )  in

“./stats/stddev.js”. That way, programs only need to import exactly the functions they need and are not bloated by importing code they do not need.


Even if we had defined these statistical functions in individual modules, however, we might expect that there would be plenty of programs that want both functions and would appreciate a convenient “./stats.js” module from which they could import both on one line.


Given that the implementations are now in separate files, defining this “./stat.js” module is simple:

i mpor t   {    mean   }    f r om " . / s t at s / mean. j s " ;
i mpor t   {    s t ddev   }    f r om " . / s t at s / s t ddev. j s " ; expor t   {    mean,	s t dev   } ;


ES6 modules anticipate this use case and provide a special syntax for it. Instead of importing a symbol simply to export it again, you can combine the import and the export steps into a single “re-export” statement that uses the expor t  keyword and the f r omkeyword:


expor t   {    mean   }    f r om " . / s t at s / mean. j s " ; expor t   {    s t ddev   }    f r om " . / s t at s / s t ddev. j s " ;


Note that the names mean and s t ddev are not actually used in this code. If we are not being selective with a re-export and simply want to export all of the named values from another module, we can use a wildcard:


expor t   *
expor t   *

f r om " . / s t at s / mean. j s " ;
f r om " . / s t at s / s t ddev. j s " ;



Re-export syntax allows renaming with as  just as regular i mpor t  and expor t  statements do. Suppose we wanted to re-export the mean( )

function but also define aver age( )  as another name for the function. We could do that like this:

expor t   {    mean,	mean   as   aver age   }    f r om " . / s t at s / mean. j s " ; expor t   {    s t ddev   }    f r om " . / s t at s / s t ddev. j s " ;


All of the re-exports in this example assume that the “./stats/mean.js” and “./stats/stddev.js” modules export their functions using expor t  instead of expor t   def aul t . In fact, however, since these are modules with only a single export, it would have made sense to define them with expor t def aul t . If we had done so, then the re-export syntax is a little more complicated because it needs to define a name for the unnamed default exports. We can do that like this:

expor t   {    def aul t   as   mean   }    f r om " . / s t at s / mean. j s " ; expor t   {    def aul t   as   s t ddev   }    f r om " . / s t at s / s t ddev. j s " ;


If you want to re-export a named symbol from another module as the default export of your module, you could do an i mpor t  followed by an expor t   def aul t , or you could combine the two statements like this:


/ /   I mpor t   t he   mean( ) / /   def aul t   expor t   of

f unc t i on   f r om . / s t at s . j s   and   make   i t   t he t hi s   modul e

expor t   {    mean   as   def aul t   }    f r om " . / s t at s . j s "


And finally, to re-export the default export of another module as the default export of your module (though it is unclear why you would want to do this, since users could simply import the other module directly), you can write:

/ /   The   aver age. j s   modul e   s i mpl y   r e- expor t s   t he   s t at s / mean. j s def aul t   expor t
expor t   {    def aul t   }    f r om " . / s t at s / mean. j s "

10.3.5 J avaScript Modules on the Web

The preceding sections have described ES6 modules and their i mpor t and expor t  declarations in a somewhat abstract manner. In this section and the next, we’ll be discussing how they actually work in web browsers, and if you are not already an experienced web developer, you may find the rest of this chapter easier to understand after you have read Chapter 15.

As of early 2020, production code using ES6 modules is still generally bundled with a tool like webpack. There are trade-offs to doing this,1 but on the whole, code bundling tends to give better performance. That may well change in the future as network speeds grow and browser vendors continue to optimize their ES6 module implementations.


Even though bundling tools may still be desirable in production, they are no longer required in development since all current browsers provide native support for JavaScript modules. Recall that modules use strict mode by default, t hi s  does not refer to a global object, and top-level declarations are not shared globally by default. Since modules must be executed differently than legacy non-module code, their introduction requires changes to HTML as well as JavaScript. If you want to natively use i mpor t  directives in a web browser, you must tell the web browser that your code is a module by using a <s cr i pt   t ype=" modul e" > tag.

One of the nice features of ES6 modules is that each module has a static set of imports. So given a single starting module, a web browser can load all of its imported modules and then load all of the modules imported by that first batch of modules, and so on, until a complete program has been loaded. We’ve seen that the module specifier in an i mpor t  statement can

be treated as a relative URL. A <s cr i pt   t ype=" modul e" > tag marks the starting point of a modular program. None of the modules it imports are expected to be in <s cr i pt > tags, however: instead, they are loaded on demand as regular JavaScript files and are executed in strict mode as regular ES6 modules. Using a <s cr i pt   t ype=" modul e" > tag to define the main entry point for a modular JavaScript program can be as simple as this:

<s c r i pt   t ype=" modul e" >i mpor t   " . / mai n. j s " ; </s c r i pt >


Code inside an inline <s cr i pt   t ype=" modul e" > tag is an ES6 module, and as such can use the expor t  statement. There is not any point in doing so, however, because the HTML <s cr i pt > tag syntax does not provide any way to define a name for inline modules, so even if such a module does export a value, there is no way for another module to import it.

Scripts with the t ype=" modul e" attribute are loaded and executed like scripts with the def er  attribute. Loading of the code begins as soon as the HTML parser encounters the <s cr i pt > tag (in the case of modules, this code-loading step may be a recursive process that loads multiple JavaScript files). But code execution does not begin until HTML parsing is complete. And once HTML parsing is complete, scripts (both modular and non) are executed in the order in which they appear in the HTML document.

You can modify the execution time of modules with the as ync attribute, which works the same way for modules that it does for regular scripts. An as ync module will execute as soon as the code is loaded, even if HTML parsing is not complete and even if this changes the relative ordering of

the scripts.


Web browsers that support <s cr i pt   t ype=" modul e" > must also support <s cr i pt   nomodul e>. Browsers that are module-aware ignore any script with the nomodul e attribute and will not execute it. Browsers that do not support modules will not recognize the nomodul e attribute, so they will ignore it and run the script. This provides a powerful technique for dealing with browser compatibility issues. Browsers that support ES6 modules also support other modern JavaScript features like classes, arrow functions, and the f or / of  loop. If you write modern JavaScript and load it with <s cr i pt   t ype=" modul e" >, you know that it will only be loaded by browsers that can support it. And as a fallback for IE11 (which, in 2020, is effectively the only remaining browser that does not support ES6), you can use tools like Babel and webpack to transform your code into non-modular ES5 code, then load that less-efficient transformed code via <s cr i pt   nomodul e>.


Another important difference between regular scripts and module scripts has to do with cross-origin loading. A regular <s cr i pt > tag will load a file of JavaScript code from any server on the internet, and the internet’s infrastructure of advertising, analytics, and tracking code depends on that fact. But <s cr i pt   t ype=" modul e" > provides an opportunity to tighten this up, and modules can only be loaded from the same origin as the containing HTML document or when proper CORS headers are in place to securely allow cross-origin loads. An unfortunate side effect of this new security restriction is that it makes it difficult to test ES6 modules in development mode using f i l e:  URLs. When using ES6 modules, you will likely need to set up a static web server for testing.

Some programmers like to use the filename extension . mj s  to distinguish

their modular JavaScript files from their regular, non-modular JavaScript files with the traditional . j s  extension. For the purposes of web browsers and <s cr i pt > tags, the file extension is actually irrelevant. (The MIME type is relevant, however, so if you use . mj s  files, you may need to configure your web server to serve them with the same MIME type as
. j s  files.) Node’s support for ES6 does use the filename extension as a hint to distinguish which module system is used by each file it loads. So if you are writing ES6 modules and want them to be usable with Node, then it may be helpful to adopt the . mj s  naming convention.


10.3.6 Dynamic Imports with import()

We’ve seen that the ES6 i mpor t  and expor t  directives are completely static and enable JavaScript interpreters and other JavaScript tools to determine the relationships between modules with simple text analysis while the modules are being loaded without having to actually execute any of the code in the modules. With statically imported modules, you are guaranteed that the values you import into a module will be ready for use before any of the code in your module begins to run.

On the web, code has to be transferred over a network instead of being read from the filesystem. And once transfered, that code is often executed on mobile devices with relatively slow CPUs. This is not the kind of environment where static module imports—which require an entire program to be loaded before any of it runs—make a lot of sense.


It is common for web applications to initially load only enough of their code to render the first page displayed to the user. Then, once the user has some preliminary content to interact with, they can begin to load the often much larger amount of code needed for the rest of the web app. Web

browsers make it easy to dynamically load code by using the DOM API to inject a new <s cr i pt > tag into the current HTML document, and web apps have been doing this for many years.

Although dynamic loading has been possible for a long time, it has not been part of the language itself. That changes with the introduction of
i mpor t ( )  in ES2020 (as of early 2020, dynamic import is supported by all browsers that support ES6 modules). You pass a module specifier to
i mpor t ( )  and it returns a Promise object that represents the asynchronous process of loading and running the specified module. When the dynamic import is complete, the Promise is “fulfilled” (see Chapter 13 for complete details on asynchronous programming and Promises) and produces an object like the one you would get with the i mpor t   *   as form of the static import statement.

So instead of importing the “./stats.js” module statically, like this:


i mpor t   *   as   s t at s   f r om " . / s t at s . j s " ;


we might import it and use it dynamically, like this:


i mpor t ( " . / s t at s . j s " ) . t hen( s t at s   =>   { l et   aver age   =   s t at s . mean( dat a) ;
} )


Or, in an as ync function (again, you may need to read Chapter 13 before you’ll understand this code), we can simplify the code with awai t :

as ync   anal yz eDat a( dat a)    {
l et   s t at s   =   awai t   i mpor t ( " . / s t at s . j s " ) ; r et ur n   {
aver age:    s t at s . mean( dat a) , s t ddev:    s t at s . s t ddev( dat a)

} ; }


The argument to i mpor t ( )  should be a module specifier, exactly like one you’d use with a static i mpor t  directive. But with i mpor t ( ) , you are not constrained to use a constant string literal: any expression that evaluates to a string in the proper form will do.

Dynamic i mpor t ( )  looks like a function invocation, but it actually is not. Instead, i mpor t ( )  is an operator and the parentheses are a required part of the operator syntax. The reason for this unusual bit of syntax is that i mpor t ( )  needs to be able to resolve module specifiers as URLs relative to the currently running module, and this requires a bit of implementation magic that would not be legal to put in a JavaScript function. The function versus operator distinction rarely makes a difference in practice, but you’ll notice it if you try writing code like cons ol e. l og( i mpor t ) ;  or l et r equi r e   =   i mpor t ; .


Finally, note that dynamic i mpor t ( )  is not just for web browsers. Code-packaging tools like webpack can also make good use of it. The most straightforward way to use a code bundler is to tell it the main entry point for your program and let it find all the static i mpor t  directives and assemble everything into one large file. By strategically using dynamic
i mpor t ( )  calls, however, you can break that one monolithic bundle up into a set of smaller bundles that can be loaded on demand.


10.3.7 import.meta.url

There is one final feature of the ES6 module system to discuss. Within an ES6 module (but not within a regular <s cr i pt > or a Node module loaded with r equi r e( ) ), the special syntax i mpor t . met a refers to an

object that contains metadata about the currently executing module. The ur l  property of this object is the URL from which the module was loaded. (In Node, this will be a f i l e: / /  URL.)


The primary use case of i mpor t . met a. ur l  is to be able to refer to images, data files, or other resources that are stored in the same directory as (or relative to) the module. The URL( )  constructor makes it easy to resolve a relative URL against an absolute URL like
i mpor t . met a. ur l . Suppose, for example, that you have written a module that includes strings that need to be localized and that the localization files are stored in an l 10n/  directory, which is in the same directory as the module itself. Your module could load its strings using a URL created with a function, like this:

f unc t i on   l oc al St r i ngs URL ( l oc al e)    {
r et ur n   new  URL ( ` l 10n/ ${ l oc al e} . j s on` ,	i mpor t . met a. ur l ) ; }


10.4 Summary

The goal of modularity is to allow programmers to hide the implementation details of their code so that chunks of code from various sources can be assembled into large programs without worrying that one chunk will overwrite functions or variables of another. This chapter has explained three different JavaScript module systems:

In the early days of JavaScript, modularity could only be achieved through the clever use of immediately invoked function expressions.

Node added its own module system on top of the JavaScript language. Node modules are imported with r equi r e( )  and

define their exports by setting properties of the Exports object, or by setting the modul e. expor t s  property.

In ES6, JavaScript finally got its own module system with
i mpor t  and expor t  keywords, and ES2020 is adding support for dynamic imports with i mpor t ( ) .





1

For example: web apps that have frequent incremental updates and users who make frequent return visits may find that using small modules instead of large bundles can result in better average load times because of better utilization of the user’s browser cache.



Chapter 11. The J avaScript Standard Library




Some datatypes, such as numbers and strings (Chapter 3), objects (Chapter 6), and arrays (Chapter 7) are so fundamental to JavaScript that we can consider them to be part of the language itself. This chapter covers other important but less fundamental APIs that can be thought of as defining the “standard library” for JavaScript: these are useful classes and functions that are built in to JavaScript and available to all JavaScript programs in both web browsers and in Node.1


The sections of this chapter are independent of one another, and you can read them in any order. They cover:

The Set and Map classes for representing sets of values and mappings from one set of values to another set of values.

Array-like objects known as TypedArrays that represent arrays of binary data, along with a related class for extracting values from non-array binary data.

Regular expressions and the RegExp class, which define textual patterns and are useful for text processing. This section also covers regular expression syntax in detail.

The Date class for representing and manipulating dates and times.

The Error class and its various subclasses, instances of which are thrown when errors occur in JavaScript programs.

The JSON object, whose methods support serialization and deserialization of JavaScript data structures composed of objects,

arrays, strings, numbers, and booleans.

The Intl object and the classes it defines that can help you localize your JavaScript programs.

The Console object, whose methods output strings in ways that are particularly useful for debugging programs and logging the behavior of those programs.

The URL class, which simplifies the task of parsing and manipulating URLs. This section also covers global functions for encoding and decoding URLs and their component parts.

s et Ti meout ( )  and related functions for specifying code to be executed after a specified interval of time has elapsed.

Some of the sections in this chapter—notably, the sections on typed arrays and regular expressions—are quite long because there is significant background information you need to understand before you can use those types effectively. Many of the other sections, however, are short: they simply introduce a new API and show some examples of its use.


11.1 Sets and Maps

JavaScript’s Object type is a versatile data structure that can be used to map strings (the object’s property names) to arbitrary values. And when the value being mapped to is something fixed like t r ue, then the object is effectively a set of strings.

Objects are actually used as maps and sets fairly routinely in JavaScript programming, but this is limited by the restriction to strings and complicated by the fact that objects normally inherit properties with names like “toString”, which are not typically intended to be part of the map or set.

For this reason, ES6 introduces true Set and Map classes, which we’ll cover in the sub-sections that follow.


11.1.1 The Set Class

A set is a collection of values, like an array is. Unlike arrays, however, sets are not ordered or indexed, and they do not allow duplicates: a value is either a member of a set or it is not a member; it is not possible to ask how many times a value appears in a set.


Create a Set object with the Set ( )  constructor:


l et   s   =   new  Set ( ) ;	/ /   A  new,	empt y   s et
l et   t   =   new  Set ( [ 1,	s ] ) ;	/ /   A  new  s et   wi t h   t wo   member s


The argument to the Set ( )  constructor need not be an array: any iterable object (including other Set objects) is allowed:

l et   t   =   new  Set ( s ) ;	/ /   A  new  s et   t hat   c opi es t he   el ement s   of    s .
l et   uni que   =   new  Set ( " Mi s s i s s i ppi " ) ;	/ /   4   el ement s :	" M" ,	" i " , " s " ,	and   " p"


The s i z e property of a set is like the l engt h property of an array: it tells you how many values the set contains:

uni que. s i z e	/ /   =>   4


Sets don’t need to be initialized when you create them. You can add and remove elements at any time with add( ) , del et e( ) , and cl ear ( ) . Remember that sets cannot contain duplicates, so adding a value to a set when it already contains that value has no effect:

l et   s   =   new  Set ( ) ;	/ /   St ar t   empt y

s . s i z e	/ /   =>   0
s . add( 1) ;	/ /   Add   a   number
s . s i z e	/ /   =>   1;	now  t he   s et   has   one   member s . add( 1) ;	/ /   Add   t he   s ame   number   agai n
s . s i z e	/ /   =>   1;	t he   s i z e   does   not   c hange
s . add( t r ue) ;	/ /   Add   anot her   val ue;	not e   t hat   i t   i s   f i ne t o   mi x   t ypes
s . s i z e	/ /   =>   2
s . add( [ 1, 2, 3] ) ;	/ /   Add   an   ar r ay   val ue
s . s i z e	/ /   =>   3;	t he   ar r ay   was   added,	not   i t s el ement s
s . del et e( 1)	/ /   =>   t r ue:	s uc c es s f ul l y   del et ed   el ement   1 s . s i z e	/ /   =>   2:	t he   s i z e   i s   bac k   down   t o   2
s . del et e( " t es t " )	/ /   =>   f al s e:	" t es t "   was   not   a   member , del et i on   f ai l ed
s . del et e( t r ue)	/ /   =>   t r ue:	del et e   s uc c eeded
s . del et e( [ 1, 2, 3] )	/ /   =>   f al s e:	t he   ar r ay   i n   t he   s et   i s di f f er ent
s . s i z e	/ /   =>   1:	t her e   i s   s t i l l	t hat   one   ar r ay   i n t he   s et
s . c l ear ( ) ;	/ /   Remove   ever yt hi ng   f r om t he   s et s . s i z e	/ /   =>   0


There are a few important points to note about this code:


The add( )  method takes a single argument; if you pass an array, it adds the array itself to the set, not the individual array elements. add( )  always returns the set it is invoked on, however, so if you want to add multiple values to a set, you can used chained method calls like s . add( ' a' ) . add( ' b' ) . add( ' c' ) ; .

The del et e( )  method also only deletes a single set element at a time. Unlike add( ) , however, del et e( )  returns a boolean value. If the value you specify was actually a member of the set, then del et e( )  removes it and returns t r ue. Otherwise, it does nothing and returns f al s e.

Finally, it is very important to understand that set membership is based on strict equality checks, like the === operator performs. A

set can contain both the number 1 and the string " 1" , because it considers them to be distinct values. When the values are objects (or arrays or functions), they are also compared as if with ===. This is why we were unable to delete the array element from the set in this code. We added an array to the set and then tried to remove that array by passing a different array (albeit with the same elements) to the del et e( )  method. In order for this to work, we would have had to pass a reference to exactly the same array.



NOTE

Python programmers take note: this is a significant difference between JavaScript and Python sets. Python sets compare members for equality, not identity, but the trade-off is that Python sets only allow immutable members, like tuples, and do not allow lists and dicts to be added to sets.




In practice, the most important thing we do with sets is not to add and remove elements from them, but to check to see whether a specified value is a member of the set. We do this with the has ( )  method:


l et   oneDi gi t Pr i mes   =   new  Set ( [ 2, 3, 5, 7] ) ;
oneDi gi t Pr i mes . has ( 2)	/ /   =>   t r ue:	2   i s   a   one- di gi t   pr i me number
oneDi gi t Pr i mes . has ( 3)	/ /   =>   t r ue:	s o   i s   3
oneDi gi t Pr i mes . has ( 4)	/ /   =>   f al s e:	4   i s   not   a   pr i me
oneDi gi t Pr i mes . has ( " 5" )	/ /   =>   f al s e:	" 5"   i s   not   even   a   number


The most important thing to understand about sets is that they are optimized for membership testing, and no matter how many members the set has, the has ( )  method will be very fast. The i ncl udes ( )  method of an array also performs membership testing, but the time it takes is proportional to the size of the array, and using an array as a set can be

much, much slower than using a real Set object.


The Set class is iterable, which means that you can use a f or / of  loop to enumerate all of the elements of a set:

l et   s um =   0;
f or ( l et   p   of    oneDi gi t Pr i mes )    {    / /   L oop   t hr ough   t he   one- di gi t pr i mes
s um +=   p;	/ /   and   add   t hem up }
s um	/ /   =>   17:	2   +   3   +   5   +   7


Because Set objects are iterable, you can convert them to arrays and argument lists with the . . .  spread operator:


[ . . . oneDi gi t Pr i mes ]	/ /   =>   [ 2, 3, 5, 7] :	t he   s et   c onver t ed t o   an   Ar r ay
Mat h. max( . . . oneDi gi t Pr i mes )    / /   =>   7:	s et   el ement s   pas s ed   as f unc t i on   ar gument s


Sets are often described as “unordered collections.” This isn’t exactly true for the JavaScript Set class, however. A JavaScript set is unindexed: you can’t ask for the first or third element of a set the way you can with an array. But the JavaScript Set class always remembers the order that elements were inserted in, and it always uses this order when you iterate a set: the first element inserted will be the first one iterated (assuming you haven’t deleted it first), and the most recently inserted element will be the last one iterated.2


In addition to being iterable, the Set class also implements a f or Each( ) method that is similar to the array method of the same name:

l et   pr oduc t   =   1;
oneDi gi t Pr i mes . f or Eac h( n   =>   {    pr oduc t   *=   n;	} ) ; pr oduc t	/ /   =>   210:	2   *   3   *   5   *   7

The f or Each( )  of an array passes array indexes as the second argument to the function you specify. Sets don’t have indexes, so the Set class’s version of this method simply passes the element value as both the first and second argument.


11.1.2 The Map Class

A Map object represents a set of values known as keys, where each key has another value associated with (or “mapped to”) it. In a sense, a map is like an array, but instead of using a set of sequential integers as the keys, maps allow us to use arbitrary values as “indexes.” Like arrays, maps are fast: looking up the value associated with a key will be fast (though not as fast as indexing an array) no matter how large the map is.


Create a new map with the Map( )  constructor:


l et   m =   new  Map( ) ;	/ /   Cr eat e   a   new,	empt y   map
l et   n   =   new  Map( [	/ /   A  new  map   i ni t i al i z ed   wi t h   s t r i ng   keys mapped   t o   number s
[ " one" ,	1] , [ " t wo" ,	2]
] ) ;


The optional argument to the Map( )  constructor should be an iterable object that yields two element [ key,	val ue]  arrays. In practice, this means that if you want to initialize a map when you create it, you’ll typically write out the desired keys and associated values as an array of arrays. But you can also use the Map( )  constructor to copy other maps or to copy the property names and values from an existing object:

l et   c opy   =   new  Map( n) ;	/ /   A  new  map   wi t h   t he   s ame   keys   and val ues   as   map   n
l et   o   =   {    x:	1,	y:	2} ;	/ /   An   obj ec t   wi t h   t wo   pr oper t i es
l et   p   =   new  Map( Obj ec t . ent r i es ( o) ) ;	/ /   Same   as   new  map( [ [ " x" ,

1] ,	[ " y" ,	2] ] )


Once you have created a Map object, you can query the value associated with a given key with get ( )  and can add a new key/value pair with
s et ( ) . Remember, though, that a map is a set of keys, each of which has an associated value. This is not quite the same as a set of key/value pairs. If you call s et ( )  with a key that already exists in the map, you will change the value associated with that key, not add a new key/value mapping. In addition to get ( )  and s et ( ) , the Map class also defines methods that are like Set methods: use has ( )  to check whether a map includes the specified key; use del et e( )  to remove a key (and its associated value) from the map; use cl ear ( )  to remove all key/value pairs from the map; and use the s i z e property to find out how many keys a map contains.

l et   m =   new  Map( ) ;	/ /   St ar t   wi t h   an   empt y   map
m. s i z e	/ /   =>   0:	empt y   maps   have   no   keys

m. s et ( " one" ,	1) ;
m. s et ( " t wo" ,	2) ;

/ /   Map   t he   key   " one"
/ /   And   t he   key   " t wo"

t o   t he   val ue   1
t o   t he   val ue   2.

m. s i z e	/ /   =>   2:	t he   map   now  has   t wo   keys
m. get ( " t wo" )	/ /   =>   2:	r et ur n   t he   val ue   as s oc i at ed   wi t h key   " t wo"
m. get ( " t hr ee" )	/ /   =>   undef i ned:	t hi s   key   i s   not   i n   t he   s et m. s et ( " one" ,	t r ue) ;	/ /   Change   t he   val ue   as s oc i at ed   wi t h   an
exi s t i ng   key
m. s i z e	/ /   =>   2:	t he   s i z e   does n' t   c hange
m. has ( " one" )	/ /   =>   t r ue:	t he   map   has   a   key   " one"
m. has ( t r ue)	/ /   =>   f al s e:	t he   map   does   not   have   a   key t r ue

m. del et e( " one" ) s uc c eeded
m. s i z e

/ /   =>   t r ue:	t he   key   exi s t ed   and   del et i on

/ /   =>   1

m. del et e( " t hr ee" )	/ /   =>   f al s e:	f ai l ed   t o   del et e   a   nonexi s t ent key
m. c l ear ( ) ;	/ /   Remove   al l	keys   and   val ues   f r om t he   map

Like the add( )  method of Set, the s et ( )  method of Map can be chained, which allows maps to be initialized without using arrays of arrays:

l et   m =   new  Map( ) . s et ( " one" ,	1) . s et ( " t wo" ,	2) . s et ( " t hr ee" ,	3) ; m. s i z e	/ /   =>   3
m. get ( " t wo" )	/ /   =>   2


As with Set, any JavaScript value can be used as a key or a value in a Map. This includes nul l , undef i ned, and NaN, as well as reference types like objects and arrays. And as with the Set class, Map compares keys by identity, not by equality, so if you use an object or array as a key, it will be considered different from every other object and array, even those with exactly the same properties or elements:

l et   m =   new  Map( ) ;	/ /   St ar t   wi t h   an   empt y   map.
m. s et ( { } ,	1) ;	/ /   Map   one   empt y   obj ec t   t o   t he   number   1. m. s et ( { } ,	2) ;	/ /   Map   a   di f f er ent   empt y   obj ec t   t o   t he number   2.
m. s i z e	/ /   =>   2:	t her e   ar e   t wo   keys   i n   t hi s   map
m. get ( { } )	/ /   =>   undef i ned:	but   t hi s   empt y   obj ec t   i s not   a   key
m. s et ( m,	undef i ned) ;	/ /   Map   t he   map   i t s el f    t o   t he   val ue undef i ned.
m. has ( m)	/ /   =>   t r ue:	m i s   a   key   i n   i t s el f
m. get ( m)	/ /   =>   undef i ned:	s ame   val ue   we' d   get   i f    m was n' t   a   key


Map objects are iterable, and each iterated value is a two-element array where the first element is a key and the second element is the value associated with that key. If you use the spread operator with a Map object, you’ll get an array of arrays like the ones that we passed to the Map( ) constructor. And when iterating a map with a f or / of  loop, it is idiomatic to use destructuring assignment to assign the key and value to separate variables:

l et   m =   new  Map( [ [ " x" ,	1] ,	[ " y" ,	2] ] ) ; [ . . . m]	/ /   =>   [ [ " x" ,	1] ,	[ " y" ,	2] ]

f or ( l et   [ key,	val ue]    of    m)    {

/ /   On   t he 1
/ /   On   t he be   2
}

f i r s t   i t er at i on,	key   wi l l	be   " x"   and   val ue   wi l l	be

s ec ond   i t er at i on,	key   wi l l	be   " y"   and   val ue   wi l l



Like the Set class, the Map class iterates in insertion order. The first key/value pair iterated will be the one least recently added to the map, and the last pair iterated will be the one most recently added.


If you want to iterate just the keys or just the associated values of a map, use the keys ( )  and val ues ( )  methods: these return iterable objects that iterate keys and values, in insertion order. (The ent r i es ( )  method returns an iterable object that iterates key/value pairs, but this is exactly the same as iterating the map directly.)

[ . . . m. keys ( ) ]	/ /   =>   [ " x" ,	" y" ] :	j us t   t he   keys [ . . . m. val ues ( ) ]	/ /   =>   [ 1,	2] :	j us t   t he   val ues
[ . . . m. ent r i es ( ) ]	/ /   =>   [ [ " x" ,	1] ,	[ " y" ,	2] ] :	s ame   as   [ . . . m]


Map objects can also be iterated using the f or Each( )  method that was first implemented by the Array class.

m. f or Eac h( ( val ue,	key)    =>   {	/ /   not e   val ue,	key   NOT   key,	val ue

/ /   On   t he " x"
/ /   On   t he " y"
} ) ;

f i r s t   i nvoc at i on,	val ue   wi l l	be   1   and   key   wi l l	be

s ec ond   i nvoc at i on,	val ue   wi l l	be   2   and   key   wi l l	be



It may seem strange that the value parameter comes before the key parameter in the code above, since with f or / of  iteration, the key comes

first. As noted at the start of this section, you can think of a map as a generalized array in which integer array indexes are replaced with arbitrary key values. The f or Each( )  method of arrays passes the array element first and the array index second, so, by analogy, the f or Each( ) method of a map passes the map value first and the map key second.


11.1.3 WeakMap and WeakSet

The WeakMap class is a variant (but not an actual subclass) of the Map class that does not prevent its key values from being garbage collected. Garbage collection is the process by which the JavaScript interpreter reclaims the memory of objects that are no longer “reachable” and cannot be used by the program. A regular map holds “strong” references to its key values, and they remain reachable through the map, even if all other references to them are gone. The WeakMap, by contrast, keeps “weak” references to its key values so that they are not reachable through the WeakMap, and their presence in the map does not prevent their memory from being reclaimed.


The WeakMap( )  constructor is just like the Map( )  constructor, but there are some significant differences between WeakMap and Map:

WeakMap keys must be objects or arrays; primitive values are not subject to garbage collection and cannot be used as keys.

WeakMap implements only the get ( ) , s et ( ) , has ( ) , and del et e( )  methods. In particular, WeakMap is not iterable and does not define keys ( ) , val ues ( ) , or f or Each( ) . If WeakMap was iterable, then its keys would be reachable and it wouldn’t be weak.

Similarly, WeakMap does not implement the s i z e property because the size of a WeakMap could change at any time as

objects are garbage collected.

The intended use of WeakMap is to allow you to associate values with objects without causing memory leaks. Suppose, for example, that you are writing a function that takes an object argument and needs to perform some time-consuming computation on that object. For efficiency, you’d like to cache the computed value for later reuse. If you use a Map object to implement the cache, you will prevent any of the objects from ever being reclaimed, but by using a WeakMap, you avoid this problem. (You can often achieve a similar result using a private Symbol property to cache the computed value directly on the object. See §6.10.3.)


WeakSet implements a set of objects that does not prevent those objects from being garbage collected. The WeakSet ( )  constructor works like the Set ( )  constructor, but WeakSet objects differ from Set objects in the same ways that WeakMap objects differ from Map objects:

WeakSet does not allow primitive values as members.

WeakSet implements only the add( ) , has ( ) , and del et e( ) methods and is not iterable.

WeakSet does not have a s i z e property.

WeakSet is not frequently used: its use cases are like those for WeakMap. If you want to mark (or “brand”) an object as having some special property or type, for example, you could add it to a WeakSet. Then, elsewhere, when you want to check for that property or type, you can test for membership in that WeakSet. Doing this with a regular set would prevent all marked objects from being garbage collected, but this is not a concern when using WeakSet.

11.2 Typed Arrays and Binary Data

Regular JavaScript arrays can have elements of any type and can grow or shrink dynamically. JavaScript implementations perform lots of optimizations so that typical uses of JavaScript arrays are very fast. Nevertheless, they are still quite different from the array types of lower-level languages like C and Java. Typed arrays, which are new in ES6,3 are much closer to the low-level arrays of those languages. Typed arrays are not technically arrays (Ar r ay. i s Ar r ay( )  returns f al s e for them), but they implement all of the array methods described in §7.8 plus a few more of their own. They differ from regular arrays in some very important ways, however:

The elements of a typed array are all numbers. Unlike regular JavaScript numbers, however, typed arrays allow you to specify the type (signed and unsigned integers and IEEE-754 floating point) and size (8 bits to 64 bits) of the numbers to be stored in the array.

You must specify the length of a typed array when you create it, and that length can never change.

The elements of a typed array are always initialized to 0 when the array is created.


11.2.1 Typed Array Types

JavaScript does not define a TypedArray class. Instead, there are 11 kinds of typed arrays, each with a different element type and constructor:



Constructor

I nt 8Ar r ay( )

Ui nt 8Ar r ay( )

Numeric type

signed bytes

unsigned bytes



Ui nt 8Cl ampedAr r ay( )


I nt 16Ar r ay( )

Ui nt 16Ar r ay( )

I nt 32Ar r ay( )

Ui nt 32Ar r ay( )

Bi gI nt 64Ar r ay( )

Bi gUi nt 64Ar r ay( )

Fl oat 32Ar r ay( )

Fl oat 64Ar r ay( )


unsigned bytes without rollover


signed 16-bit short integers

unsigned 16-bit short integers

signed 32-bit integers

unsigned 32-bit integers

signed 64-bit BigInt values (ES2020)

unsigned 64-bit BigInt values (ES2020)

32-bit floating-point value

64-bit floating-point value: a regular JavaScript number




The types whose names begin with I nt  hold signed integers, of 1, 2, or 4 bytes (8, 16, or 32 bits). The types whose names begin with Ui nt  hold unsigned integers of those same lengths. The “BigInt” and “BigUint” types hold 64-bit integers, represented in JavaScript as BigInt values (see §3.2.5). The types that begin with Fl oat  hold floating-point numbers. The elements of a Fl oat 64Ar r ay are of the same type as regular JavaScript numbers. The elements of a Fl oat 32Ar r ay have lower precision and a smaller range but require only half the memory. (This type is called f l oat  in C and Java.)


Ui nt 8Cl ampedAr r ay is a special-case variant on Ui nt 8Ar r ay. Both of these types hold unsigned bytes and can represent numbers between 0 and 255. With Ui nt 8Ar r ay, if you store a value larger than 255 or less than zero into an array element, it “wraps around,” and you get some other value. This is how computer memory works at a low level, so this is very fast. Ui nt 8Cl ampedAr r ay does some extra type checking so that, if

you store a value greater than 255 or less than 0, it “clamps” to 255 or 0 and does not wrap around. (This clamping behavior is required by the HTML <canvas > element’s low-level API for manipulating pixel colors.)

Each of the typed array constructors has a BYTES_PER_ELEMENT property with the value 1, 2, 4, or 8, depending on the type.


11.2.2 Creating Typed Arrays

The simplest way to create a typed array is to call the appropriate constructor with one numeric argument that specifies the number of elements you want in the array:

l et   byt es   =   new  Ui nt 8Ar r ay( 1024) ;	/ /   1024   byt es
l et   mat r i x   =   new  Fl oat 64Ar r ay( 9) ;	/ /   A  3x3   mat r i x
l et   poi nt   =   new  I nt 16Ar r ay( 3) ;	/ /   A  poi nt   i n   3D  s pac e l et   r gba   =   new  Ui nt 8Cl ampedAr r ay( 4) ;	/ /   A  4- byt e   RGBA  pi xel val ue
l et   s udoku   =   new  I nt 8Ar r ay( 81) ;	/ /   A  9x9   s udoku   boar d


When you create typed arrays in this way, the array elements are all guaranteed to be initialized to 0, 0n, or 0. 0. But if you know the values you want in your typed array, you can also specify those values when you create the array. Each of the typed array constructors has static f r om( ) and of ( )  factory methods that work like Ar r ay. f r om( )  and
Ar r ay. of ( ) :


l et   whi t e   =   Ui nt 8Cl ampedAr r ay. of ( 255,	255,	255,	0) ;	/ /   RGBA opaque   whi t e


Recall that the Ar r ay. f r om( )  factory method expects an array-like or iterable object as its first argument. The same is true for the typed array

variants, except that the iterable or array-like object must also have numeric elements. Strings are iterable, for example, but it would make no sense to pass them to the f r om( )  factory method of a typed array.


If you are just using the one-argument version of f r om( ) , you can drop the . f r omand pass your iterable or array-like object directly to the constructor function, which behaves exactly the same. Note that both the constructor and the f r om( )  factory method allow you to copy existing typed arrays, while possibly changing the type:

l et   i nt s   =   Ui nt 32Ar r ay. f r om( whi t e) ;	/ /   The   s ame   4   number s ,	but as   i nt s


When you create a new typed array from an existing array, iterable, or array-like object, the values may be truncated in order to fit the type constraints of your array. There are no warnings or errors when this happens:

/ /   Fl oat s   t r unc at ed   t o   i nt s ,	l onger   i nt s   t r unc at ed   t o   8   bi t s Ui nt 8Ar r ay. of ( 1. 23,	2. 99,	45000)    / /   =>   new  Ui nt 8Ar r ay( [ 1,	2, 200] )


Finally, there is one more way to create typed arrays that involves the ArrayBuffer type. An ArrayBuffer is an opaque reference to a chunk of memory. You can create one with the constructor; just pass in the number of bytes of memory you’d like to allocate:

l et   buf f er   =   new  Ar r ayBuf f er ( 1024*1024) ;
buf f er . byt eL engt h	/ /   =>   1024*1024;	one   megabyt e   of    memor y


The ArrayBuffer class does not allow you to read or write any of the bytes that you have allocated. But you can create typed arrays that use the buffer’s memory and that do allow you to read and write that memory. To

do this, call the typed array constructor with an ArrayBuffer as the first argument, a byte offset within the array buffer as the second argument, and the array length (in elements, not in bytes) as the third argument. The second and third arguments are optional. If you omit both, then the array will use all of the memory in the array buffer. If you omit only the length argument, then your array will use all of the available memory between the start position and the end of the array. One more thing to bear in mind about this form of the typed array constructor: arrays must be memory aligned, so if you specify a byte offset, the value should be a multiple of the size of your type. The I nt 32Ar r ay( )  constructor requires a multiple of four, for example, and the Fl oat 64Ar r ay( )  requires a multiple of eight.

Given the ArrayBuffer created earlier, you could create typed arrays like these:

l et   as byt es   =   new  Ui nt 8Ar r ay( buf f er ) ;	/ /   Vi ewed   as byt es
l et   as i nt s   =   new  I nt 32Ar r ay( buf f er ) ;	/ /   Vi ewed   as   32-bi t   s i gned   i nt s
l et   l as t K   =   new  Ui nt 8Ar r ay( buf f er ,	1023*1024) ;	/ /   L as t   ki l obyt e as   byt es
l et   i nt s 2   =   new  I nt 32Ar r ay( buf f er ,	1024,	256) ;	/ /   2nd   ki l obyt e as   256   i nt eger s


These four typed arrays offer four different views into the memory represented by the ArrayBuffer. It is important to understand that all typed arrays have an underlying ArrayBuffer, even if you do not explicitly specify one. If you call a typed array constructor without passing a buffer object, a buffer of the appropriate size will be automatically created. As described later, the buf f er  property of any typed array refers to its underlying ArrayBuffer object. The reason to work directly with ArrayBuffer objects is that sometimes you may want to have multiple

typed array views of a single buffer.


11.2.3 Using Typed Arrays

Once you have created a typed array, you can read and write its elements with regular square-bracket notation, just as you would with any other array-like object:

/ /   Ret ur n   t he   l ar ges t   pr i me   s mal l er   t han   n,	us i ng   t he   s i eve   of Er at os t henes
f unc t i on   s i eve( n)    {
l et   a   =   new  Ui nt 8Ar r ay( n+1) ;	/ /   a[ x]    wi l l	be   1   i f    x i s   c ompos i t e
l et   max   =   Mat h. f l oor ( Mat h. s qr t ( n) ) ;	/ /   Don' t   do   f ac t or s hi gher   t han   t hi s
l et   p   =   2;                                                                           / /   2   i s   t he   f i r s t   pr i me whi l e( p   <=   max)    {                                                       / /   For   pr i mes   l es s   t han
max
f or ( l et   i	=   2*p;	i	<=   n;	i	+=   p)    / /   Mar k   mul t i pl es   of    p as   c ompos i t e
a[ i ]    =   1;
whi l e( a[ ++p] )    / *   empt y   */ ;	/ /   The   next   unmar ked i ndex   i s   pr i me
}
whi l e( a[ n] )    n- - ;	/ /   L oop   bac kwar d   t o f i nd   t he   l as t   pr i me
r et ur n   n;	/ /   And   r et ur n   i t }


The function here computes the largest prime number smaller than the number you specify. The code is exactly the same as it would be with a regular JavaScript array, but using Ui nt 8Ar r ay( )  instead of Ar r ay( ) makes the code run more than four times faster and use eight times less memory in my testing.

Typed arrays are not true arrays, but they re-implement most array methods, so you can use them pretty much just like you’d use regular

arrays:


l et   i nt s   =   new  I nt 16Ar r ay( 10) ;	/ /   10   s hor t   i nt eger s i nt s . f i l l ( 3) . map( x=>x*x) . j oi n( " " )	/ /   =>   " 9999999999"


Remember that typed arrays have fixed lengths, so the l engt h property is read-only, and methods that change the length of the array (such as pus h( ) , pop( ) , uns hi f t ( ) , s hi f t ( ) , and s pl i ce( ) ) are not implemented for typed arrays. Methods that alter the contents of an array without changing the length (such as s or t ( ) , r ever s e( ) , and
f i l l ( ) ) are implemented. Methods like map( )  and s l i ce( )  that return new arrays return a typed array of the same type as the one they are called on.


11.2.4 Typed Array Methods and Properties

In addition to standard array methods, typed arrays also implement a few methods of their own. The s et ( )  method sets multiple elements of a typed array at once by copying the elements of a regular or typed array into a typed array:

l et   byt es   =   new  Ui nt 8Ar r ay( 1024) ;	/ /   A  1K   buf f er
l et   pat t er n   =   new  Ui nt 8Ar r ay( [ 0, 1, 2, 3] ) ;	/ /   An   ar r ay   of    4   byt es byt es . s et ( pat t er n) ;	/ /   Copy   t hem t o   t he   s t ar t   of    anot her byt e   ar r ay
byt es . s et ( pat t er n,	4) ;	/ /   Copy   t hem agai n   at   a   di f f er ent of f s et
byt es . s et ( [ 0, 1, 2, 3] ,	8) ;	/ /   Or   j us t   c opy   val ues   di r ec t   f r om a r egul ar   ar r ay
byt es . s l i c e( 0,	12)	/ /   =>   new
Ui nt 8Ar r ay( [ 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3] )


The s et ( )  method takes an array or typed array as its first argument and an element offset as its optional second argument, which defaults to 0 if

left unspecified. If you are copying values from one typed array to another, the operation will likely be extremely fast.


Typed arrays also have a s ubar r ay method that returns a portion of the array on which it is called:

l et   i nt s   =   new  I nt 16Ar r ay( [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9] ) ;	/ /   10 s hor t   i nt eger s
l et   l as t 3   =   i nt s . s ubar r ay( i nt s . l engt h- 3,	i nt s . l engt h) ;	/ /   L as t 3   of    t hem
l as t 3[ 0]	/ /   =>   7:	t hi s   i s   t he   s ame   as   i nt s [ 7]


s ubar r ay( )  takes the same arguments as the s l i ce( )  method and seems to work the same way. But there is an important difference.
s l i ce( )  returns the specified elements in a new, independent typed array that does not share memory with the original array. s ubar r ay( ) does not copy any memory; it just returns a new view of the same underlying values:

i nt s [ 9]    =   - 1;	/ /   Change   a   val ue   i n   t he   or i gi nal	ar r ay   and. . . l as t 3[ 2]	/ /   =>   - 1:	i t   al s o   c hanges   i n   t he   s ubar r ay


The fact that the s ubar r ay( )  method returns a new view of an existing array brings us back to the topic of ArrayBuffers. Every typed array has three properties that relate to the underlying buffer:

l as t 3. buf f er	/ /   The   Ar r ayBuf f er   obj ec t   f or   a t yped   ar r ay
l as t 3. buf f er   ===   i nt s . buf f er   / /   =>   t r ue:	bot h   ar e   vi ews   of    t he s ame   buf f er
l as t 3. byt eOf f s et	/ /   =>   14:	t hi s   vi ew  s t ar t s   at   byt e 14   of    t he   buf f er
l as t 3. byt eL engt h	/ /   =>   6:	t hi s   vi ew  i s   6   byt es   ( 3 16- bi t   i nt s )    l ong
l as t 3. buf f er . byt eL engt h	/ /   =>   20:	but   t he   under l yi ng   buf f er has   20   byt es

The buf f er  property is the ArrayBuffer of the array. byt eOf f s et  is the starting position of the array’s data within the underlying buffer. And byt eLengt h is the length of the array’s data in bytes. For any typed array, a, this invariant should always be true:

a. l engt h   *   a. BYTES_PER_EL EMENT   ===   a. byt eL engt h	/ /   =>   t r ue


ArrayBuffers are just opaque chunks of bytes. You can access those bytes with typed arrays, but an ArrayBuffer is not itself a typed array. Be careful, however: you can use numeric array indexing with ArrayBuffers just as you can with any JavaScript object. Doing so does not give you access to the bytes in the buffer, but it can cause confusing bugs:

l et   byt es   =   new  Ui nt 8Ar r ay( 8) ;
byt es [ 0]    =   1;	/ /   Set   t he   f i r s t   byt e   t o   1
byt es . buf f er [ 0]	/ /   =>   undef i ned:	buf f er   does n' t   have i ndex   0
byt es . buf f er [ 1]    =   255;	/ /   Tr y   i nc or r ec t l y   t o   s et   a   byt e   i n   t he buf f er
byt es . buf f er [ 1]	/ /   =>   255:	t hi s   j us t   s et s   a   r egul ar   J S pr oper t y
byt es [ 1]	/ /   =>   0:	t he   l i ne   above   di d   not   s et   t he byt e


We saw previously that you can create an ArrayBuffer with the
Ar r ayBuf f er ( )  constructor and then create typed arrays that use that buffer. Another approach is to create an initial typed array, then use the buffer of that array to create other views:

l et   byt es   =   new  Ui nt 8Ar r ay( 1024) ;	/ /   1024   byt es
l et   i nt s   =   new  Ui nt 32Ar r ay( byt es . buf f er ) ;	/ /   or   256   i nt eger s l et   f l oat s   =   new  Fl oat 64Ar r ay( byt es . buf f er ) ;	/ /   or   128   doubl es


11.2.5 DataView and Endianness

Typed arrays allow you to view the same sequence of bytes in chunks of 8, 16, 32, or 64 bits. This exposes the “endianness”: the order in which bytes are arranged into longer words. For efficiency, typed arrays use the native endianness of the underlying hardware. On little-endian systems, the bytes of a number are arranged in an ArrayBuffer from least significant to most significant. On big-endian platforms, the bytes are arranged from most significant to least significant. You can determine the endianness of the underlying platform with code like this:


/ /   I f    t he   i nt eger   0x00000001   i s   ar r anged 00,	t hen
/ /   we' r e   on   a   l i t t l e- endi an   pl at f or m.	On we' d   get
/ /   byt es   00   00   00   01   i ns t ead.

i n   memor y   as

a   bi g- endi an

01   00   00

pl at f or m,

l et   l i t t l eEndi an   =   new  I nt 8Ar r ay( new  I nt 32Ar r ay( [ 1] ) . buf f er ) [ 0] ===   1;


Today, the most common CPU architectures are little-endian. Many network protocols, and some binary file formats, require big-endian byte ordering, however. If you’re using typed arrays with data that came from the network or from a file, you can’t just assume that the platform endianness matches the byte order of the data. In general, when working with external data, you can use Int8Array and Uint8Array to view the data as an array of individual bytes, but you should not use the other typed arrays with multibyte word sizes. Instead, you can use the DataView class, which defines methods for reading and writing values from an ArrayBuffer with explicitly specified byte ordering:


/ /   As s ume   we   have   a   t yped   ar r ay   of    byt es pr oc es s .	Fi r s t ,
/ /   we   c r eat e   a   Dat aVi ew  obj ec t   s o   we   c an / /   val ues   f r om t hos e   byt es

of    bi nar y   dat a   t o

f l exi bl y   r ead   and   wr i t e

l et   vi ew  =   new  Dat aVi ew( byt es . buf f er ,
byt es . byt eOf f s et , byt es . byt eL engt h) ;


l et   i nt   =   vi ew. get I nt 32( 0) ;	/ /   Read   bi g- endi an   s i gned   i nt f r om byt e   0
i nt   =   vi ew. get I nt 32( 4,	f al s e) ;	/ /   Next   i nt   i s   al s o   bi g- endi an
i nt   =   vi ew. get Ui nt 32( 8,	t r ue) ;	/ /   Next   i nt   i s   l i t t l e- endi an   and uns i gned
vi ew. s et Ui nt 32( 8,	i nt ,	f al s e) ;	/ /   Wr i t e   i t   bac k   i n   bi g- endi an f or mat


DataView defines 10 get  methods for each of the 10 typed array classes (excluding Uint8ClampedArray). They have names like get I nt 16( ) , get Ui nt 32( ) , get Bi gI nt 64( ) , and get Fl oat 64( ) . The first argument is the byte offset within the ArrayBuffer at which the value begins. All of these getter methods, other than get I nt 8( )  and
get Ui nt 8( ) , accept an optional boolean value as their second argument. If the second argument is omitted or is f al s e, big-endian byte ordering is used. If the second argument is t r ue, little-endian ordering is used.

DataView also defines 10 corresponding Set methods that write values into the underlying ArrayBuffer. The first argument is the offset at which the value begins. The second argument is the value to write. Each of the methods, except s et I nt 8( )  and s et Ui nt 8( ) , accepts an optional third argument. If the argument is omitted or is f al s e, the value is written in big-endian format with the most significant byte first. If the argument is t r ue, the value is written in little-endian format with the least significant byte first.

Typed arrays and the DataView class give you all the tools you need to process binary data and enable you to write JavaScript programs that do things like decompressing ZIP files or extracting metadata from JPEG files.

11.3 Pattern Matching with Regular Expressions

A regular expression is an object that describes a textual pattern. The JavaScript RegExp class represents regular expressions, and both String and RegExp define methods that use regular expressions to perform powerful pattern-matching and search-and-replace functions on text. In order to use the RegExp API effectively, however, you must also learn how to describe patterns of text using the regular expression grammar, which is essentially a mini programming language of its own. Fortunately, the JavaScript regular expression grammar is quite similar to the grammar used by many other programming languages, so you may already be familiar with it. (And if you are not, the effort you invest in learning JavaScript regular expressions will probably be useful to you in other programming contexts as well.)


The subsections that follow describe the regular expression grammar first, and then, after explaining how to write regular expressions, they explain how you can use them with methods of the String and RegExp classes.


11.3.1 Defining Regular Expressions

In JavaScript, regular expressions are represented by RegExp objects. RegExp objects may be created with the RegExp( )  constructor, of course, but they are more often created using a special literal syntax. Just as string literals are specified as characters within quotation marks, regular expression literals are specified as characters within a pair of slash (/ ) characters. Thus, your JavaScript code may contain lines like this:

l et   pat t er n   =   / s $/ ;

This line creates a new RegExp object and assigns it to the variable pat t er n. This particular RegExp object matches any string that ends
with the letter “s.” This regular expression could have equivalently been defined with the RegExp( )  constructor, like this:


l et   pat t er n   =   new  RegExp( " s $" ) ;


Regular-expression pattern specifications consist of a series of characters. Most characters, including all alphanumeric characters, simply describe characters to be matched literally. Thus, the regular expression / j ava/ matches any string that contains the substring “java”. Other characters in regular expressions are not matched literally but have special significance. For example, the regular expression / s $/  contains two characters. The first, “s”, matches itself literally. The second, “$”, is a special meta-character that matches the end of a string. Thus, this regular expression matches any string that contains the letter “s” as its last character.

As we’ll see, regular expressions can also have one or more flag characters that affect how they work. Flags are specified following the second slash character in RegExp literals, or as a second string argument to the RegExp( )  constructor. If we wanted to match strings that end with “s” or “S”, for example, we could use the i  flag with our regular expression to indicate that we want case-insensitive matching:

l et   pat t er n   =   / s $/ i ;


The following sections describe the various characters and meta-characters used in JavaScript regular expressions.

LITERAL CHARACTERS

All alphabetic characters and digits match themselves literally in regular

expressions. JavaScript regular expression syntax also supports certain nonalphabetic characters through escape sequences that begin with a backslash (\ ). For example, the sequence \ n matches a literal newline character in a string. Table 11-1 lists these characters.


Table 11-1. Regular-expression literal characters


Chara cter

Alphan umeric charact er

\ 0

\ t

\ n

\ v

\ f

\ r

\ xnn


\ uxxxx


\ u{ n}



\ c X


Matches

Itself





The NUL character (\ u0000)

Tab (\ u0009)

Newline (\ u000A)

Vertical tab (\ u000B)

Form feed (\ u000C)

Carriage return (\ u000D)

The Latin character specified by the hexadecimal number nn; for example, \ x0 A is the same as \ n.

The Unicode character specified by the hexadecimal number xxxx; for example, \ u0009 is the same as \ t .

The Unicode character specified by the codepoint n, where n is one to six hexadecimal digits between 0 and 10FFFF. Note that this syntax is only supported in regular expressions that use the u flag.

The control character ^X; for example, \ c J  is equivalent to the newline character \ n.




A number of punctuation characters have special meanings in regular

expressions. They are:


^   $   .	*   +   ?   =   !   :	|   \   /   (    )    [    ]    {    }


The meanings of these characters are discussed in the sections that follow. Some of these characters have special meaning only within certain contexts of a regular expression and are treated literally in other contexts. As a general rule, however, if you want to include any of these punctuation characters literally in a regular expression, you must precede them with a \ . Other punctuation characters, such as quotation marks and @, do not have special meaning and simply match themselves literally in a regular expression.

If you can’t remember exactly which punctuation characters need to be escaped with a backslash, you may safely place a backslash before any punctuation character. On the other hand, note that many letters and numbers have special meaning when preceded by a backslash, so any letters or numbers that you want to match literally should not be escaped with a backslash. To include a backslash character literally in a regular expression, you must escape it with a backslash, of course. For example, the following regular expression matches any string that includes a backslash: / \ \ / . (And if you use the RegExp( )  constructor, keep in mind that any backslashes in your regular expression need to be doubled, since strings also use backslashes as an escape character.)

CHARACTER CLASSES

Individual literal characters can be combined into character classes by placing them within square brackets. A character class matches any one character that is contained within it. Thus, the regular expression
/ [ abc] /  matches any one of the letters a, b, or c. Negated character

classes can also be defined; these match any character except those contained within the brackets. A negated character class is specified by placing a caret (^) as the first character inside the left bracket. The RegExp / [ ^abc] /  matches any one character other than a, b, or c. Character classes can use a hyphen to indicate a range of characters. To match any one lowercase character from the Latin alphabet, use / [ a-
z ] / , and to match any letter or digit from the Latin alphabet, use / [ a-z A- Z0- 9] / . (And if you want to include an actual hyphen in your
character class, simply make it the last character before the right bracket.)


Because certain character classes are commonly used, the JavaScript regular-expression syntax includes special characters and escape sequences to represent these common classes. For example, \ s  matches the space character, the tab character, and any other Unicode whitespace character; \ S matches any character that is not Unicode whitespace. Table 11-2 lists these characters and summarizes character-class syntax. (Note that several of these character-class escape sequences match only ASCII characters and have not been extended to work with Unicode characters. You can, however, explicitly define your own Unicode character classes; for example, / [ \ u0400- \ u04FF] /  matches any one Cyrillic character.)


Table 11-2. Regular expression character classes

Ch ara cte
r	Matches

[ .	Any one character between the brackets. . .
]

[ ^	Any one character not between the brackets.

. . . ]

.	Any character except newline or another Unicode line terminator. Or, if the RegExp uses the s  flag, then a period matches any character, including line terminators.

\ w	Any ASCII word character. Equivalent to [ a- z A- Z0- 9_] .

\ W	Any character that is not an ASCII word character. Equivalent to [ ^a- z A- Z0- 9_ ] .

\ s	Any Unicode whitespace character.

\ S	Any character that is not Unicode whitespace.

\ d	Any ASCII digit. Equivalent to [ 0- 9] .

\ D	Any character other than an ASCII digit. Equivalent to [ ^0- 9] .

[ \	A literal backspace (special case). b]



Note that the special character-class escapes can be used within square brackets. \ s  matches any whitespace character, and \ d matches any digit, so / [ \ s \ d] /  matches any one whitespace character or digit. Note that there is one special case. As you’ll see later, the \ b escape has a special meaning. When used within a character class, however, it represents the backspace character. Thus, to represent a backspace character literally in a regular expression, use the character class with one element: / [ \ b] / .



UNICODE CHARACTER CLASSES

In ES2018, if a regular expression uses the u flag, then character classes \ p{ . . . }  and its negation
\ P{ . . . }  are supported. (As of early 2020, this is implemented by Node, Chrome, Edge, and Safari, but not Firefox.) These character classes are based on properties defined by the Unicode standard, and the set of characters they represent may change as Unicode evolves.

The \ d character class matches only ASCII digits. If you want to match one decimal digit from any of the world’s writing systems, you can use / \ p{ Deci mal _Number } / u. And if you want to match any one character that is not a decimal digit in any language, you can capitalize the p and write
\ P{ Deci mal _Number } . If you want to match any number-like character, including fractions and roman

numerals, you can use \ p{ Number } . Note that “Decimal_Number” and “Number” are not specific to JavaScript or to regular expression grammar: it is the name of a category of characters defined by the Unicode standard.

The \ wcharacter class only works for ASCII text, but with \ p, we can approximate an internationalized version like this:

/ [ \ p{ Al phabet i c} \ p{ Deci mal _Number } \ p{ Mar k} ] / u


(Though to be fully compatible with the complexity of the world’s languages, we really need to add in the categories “Connector_Punctuation” and “Join_Control” as well.)

As a final example, the \ p syntax also allows us to define regular expressions that match characters from a particular alphabet or script:

l et   gr eekL et t er   =   / \ p{ Scr i pt =Gr eek} / u;
l et   cyr i l l i cL et t er   =   / \ p{ Scr i pt =Cyr i l l i c} / u;




REPETITION

With the regular expression syntax you’ve learned so far, you can describe a two-digit number as / \ d\ d/  and a four-digit number as / \ d\ d\ d\ d/ . But you don’t have any way to describe, for example, a number that can have any number of digits or a string of three letters followed by an optional digit. These more complex patterns use regular expression syntax that specifies how many times an element of a regular expression may be repeated.

The characters that specify repetition always follow the pattern to which they are being applied. Because certain types of repetition are quite commonly used, there are special characters to represent these cases. For example, + matches one or more occurrences of the previous pattern.


Table 11-3 summarizes the repetition syntax.


Table 11-3. Regular expression repetition characters

Chara
cter	Meaning

{ n, m	Match the previous item at least n times but no more than m times. }

{ n, }	Match the previous item n or more times.

{ n}	Match exactly n occurrences of the previous item.

?	Match zero or one occurrences of the previous item. That is, the previous item is optional. Equivalent to { 0, 1} .

+	Match one or more occurrences of the previous item. Equivalent to { 1, } .

*	Match zero or more occurrences of the previous item. Equivalent to { 0, } .



The following lines show some examples:


l et   r   =   / \ d{ 2, 4} / ;	/ /   Mat c h   bet ween   t wo   and   f our   di gi t s
r   =   / \ w{ 3} \ d?/ ;	/ /   Mat c h   exac t l y   t hr ee   wor d   c har ac t er s   and   an opt i onal	di gi t
r   =   / \ s +j ava\ s +/ ;	/ /   Mat c h   " j ava"   wi t h   one   or   mor e   s pac es bef or e   and   af t er
r   =   / [ ^( ] */ ;	/ /   Mat c h   z er o   or   mor e   c har ac t er s   t hat   ar e   not open   par ens


Note that in all of these examples, the repetition specifiers apply to the single character or character class that precedes them. If you want to match repetitions of more complicated expressions, you’ll need to define a group with parentheses, which are explained in the following sections.


Be careful when using the * and ? repetition characters. Since these characters may match zero instances of whatever precedes them, they are allowed to match nothing. For example, the regular expression / a*/ actually matches the string “bbbb” because the string contains zero occurrences of the letter a!

NON-GREEDY REPETITION

The repetition characters listed in Table 11-3 match as many times as possible while still allowing any following parts of the regular expression to match. We say that this repetition is “greedy.” It is also possible to specify that repetition should be done in a non-greedy way. Simply follow the repetition character or characters with a question mark: ??, +?, *?, or even { 1, 5} ?. For example, the regular expression / a+/  matches one or more occurrences of the letter a. When applied to the string “aaa”, it matches all three letters. But / a+?/  matches one or more occurrences of the letter a, matching as few characters as necessary. When applied to the same string, this pattern matches only the first letter a.

Using non-greedy repetition may not always produce the results you expect. Consider the pattern / a+b/ , which matches one or more a’s, followed by the letter b. When applied to the string “aaab”, it matches the entire string. Now let’s use the non-greedy version: / a+?b/ . This should match the letter b preceded by the fewest number of a’s possible. When applied to the same string “aaab”, you might expect it to match only one a and the last letter b. In fact, however, this pattern matches the entire string, just like the greedy version of the pattern. This is because regular expression pattern matching is done by finding the first position in the string at which a match is possible. Since a match is possible starting at the first character of the string, shorter matches starting at subsequent characters are never even considered.

ALTERNATION, GROUPING, AND REFERENCES

The regular expression grammar includes special characters for specifying alternatives, grouping subexpressions, and referring to previous subexpressions. The | character separates alternatives. For example,

/ ab|cd|ef /  matches the string “ab” or the string “cd” or the string “ef”. And / \ d{ 3} |[ a- z ] { 4} /  matches either three digits or four lowercase letters.

Note that alternatives are considered left to right until a match is found. If the left alternative matches, the right alternative is ignored, even if it would have produced a “better” match. Thus, when the pattern / a|ab/  is applied to the string “ab”, it matches only the first letter.

Parentheses have several purposes in regular expressions. One purpose is to group separate items into a single subexpression so that the items can be treated as a single unit by |, *, +, ?, and so on. For example,
/ j ava( s cr i pt ) ?/  matches “java” followed by the optional “script”. And / ( ab|cd) +|ef /  matches either the string “ef” or one or more repetitions of either of the strings “ab” or “cd”.

Another purpose of parentheses in regular expressions is to define subpatterns within the complete pattern. When a regular expression is successfully matched against a target string, it is possible to extract the portions of the target string that matched any particular parenthesized subpattern. (You’ll see how these matching substrings are obtained later in this section.) For example, suppose you are looking for one or more lowercase letters followed by one or more digits. You might use the pattern / [ a- z ] +\ d+/ . But suppose you only really care about the digits at the end of each match. If you put that part of the pattern in parentheses
( / [ a- z ] +( \ d+) / ) , you can extract the digits from any matches you find, as explained later.

A related use of parenthesized subexpressions is to allow you to refer back to a subexpression later in the same regular expression. This is done by

following a \  character by a digit or digits. The digits refer to the position of the parenthesized subexpression within the regular expression. For example, \ 1 refers back to the first subexpression, and \ 3 refers to the third. Note that, because subexpressions can be nested within others, it is the position of the left parenthesis that is counted. In the following regular expression, for example, the nested subexpression ( [ Ss ] cr i pt )  is referred to as \ 2:

/ ( [ J j ] ava( [ Ss ] c r i pt ) ?) \ s i s \ s ( f un\ w*) /


A reference to a previous subexpression of a regular expression does not refer to the pattern for that subexpression but rather to the text that matched the pattern. Thus, references can be used to enforce a constraint that separate portions of a string contain exactly the same characters. For example, the following regular expression matches zero or more characters within single or double quotes. However, it does not require the opening and closing quotes to match (i.e., both single quotes or both double quotes):

/ [ ' " ] [ ^' " ] *[ ' " ] /


To require the quotes to match, use a reference:


/ ( [ ' " ] ) [ ^' " ] *\ 1/


The \ 1 matches whatever the first parenthesized subexpression matched. In this example, it enforces the constraint that the closing quote match the opening quote. This regular expression does not allow single quotes within double-quoted strings or vice versa. (It is not legal to use a reference within a character class, so you cannot write: / ( [ ' " ] ) [ ^\ 1] *\ 1/ .)


When we cover the RegExp API later, you’ll see that this kind of reference

to a parenthesized subexpression is a powerful feature of regular-expression search-and-replace operations.


It is also possible to group items in a regular expression without creating a numbered reference to those items. Instead of simply grouping the items within (  and ) , begin the group with ( ?:  and end it with ) . Consider the following pattern:

/ ( [ J j ] ava( ?: [ Ss ] c r i pt ) ?) \ s i s \ s ( f un\ w*) /


In this example, the subexpression ( ?: [ Ss ] cr i pt )  is used simply for grouping, so the ? repetition character can be applied to the group. These modified parentheses do not produce a reference, so in this regular expression, \ 2 refers to the text matched by ( f un\ w*) .


Table 11-4 summarizes the regular expression alternation, grouping, and referencing operators.


Table 11-4. Regular expression alternation, grouping, and reference characters

C h a r a c t e
r	Meaning

|	Alternation: match either the subexpression to the left or the subexpression to the right.

(	Grouping: group items into a single unit that can be used with *, +, ?, |, and so on. .	Also remember the characters that match this group for use with later references.
. .

)

(	Grouping only: group items into a single unit, but do not remember the characters that ?	match this group.
: . . . )

\	Match the same characters that were matched when group number n was first
n	matched. Groups are subexpressions within (possibly nested) parentheses. Group numbers are assigned by counting left parentheses from left to right. Groups formed with ( ?:  are not numbered.




NAMED CAPTURE GROUPS

ES2018 standardizes a new feature that can make regular expressions more self-documenting and easier to understand. This new feature is known as “named capture groups” and it allows us to associate a name with each left parenthesis in a regular expression so that we can refer to the matching text by name rather than by number. Equally important: using names allows someone reading the code to more easily understand the purpose of that portion of the regular expression. As of early 2020, this feature is implemented in Node, Chrome, Edge, and Safari, but not yet by Firefox.

To name a group, use ( ?<. . . > instead of (  and put the name between the angle brackets. For example, here is a regular expression that might be used to check the formatting of the final line of a US mailing address:

/ ( ?<ci t y>\ w+)    ( ?<s t at e>[ A- Z] { 2} )    ( ?<z i pcode>\ d{ 5} ) ( ?<z i p9>- \ d{ 4} ) ?/


Notice how much context the group names provide to make the regular expression easier to understand. In §11.3.2, when we discuss the String r epl ace( )  and mat ch( )  methods and the RegExp exec( )  method, you’ll see how the RegExp API allows you to refer to the text that matches each of these groups by name rather than by position.

If you want to refer back to a named capture group within a regular expression, you can do that by name as well. In the preceding example, we were able to use a regular expression “backreference” to write a
RegExp that would match a single- or double-quoted string where the open and close quotes had to match. We could rewrite this RegExp using a named capturing group and a named backreference like this:

/ ( ?<quot e>[ ' " ] ) [ ^' " ] *\ k<quot e>/


The \ k<quot e> is a named backreference to the named group that captures the open quotation mark.



SPECIFYING MATCH POSITION

As described earlier, many elements of a regular expression match a single character in a string. For example, \ s  matches a single character of whitespace. Other regular expression elements match the positions between characters instead of actual characters. \ b, for example, matches an ASCII word boundary—the boundary between a \ w(ASCII word character) and a \ W(nonword character), or the boundary between an ASCII word character and the beginning or end of a string.4 Elements such as \ b do not specify any characters to be used in a matched string; what they do specify, however, are legal positions at which a match can occur. Sometimes these elements are called regular expression anchors because they anchor the pattern to a specific position in the search string. The most commonly used anchor elements are ^, which ties the pattern to the beginning of the string, and $, which anchors the pattern to the end of the string.

For example, to match the word “JavaScript” on a line by itself, you can use the regular expression / ^J avaScr i pt $/ . If you want to search for “Java” as a word by itself (not as a prefix, as it is in “JavaScript”), you can try the pattern / \ s J ava\ s / , which requires a space before and after the word. But there are two problems with this solution. First, it does not match “Java” at the beginning or the end of a string, but only if it appears with space on either side. Second, when this pattern does find a match, the matched string it returns has leading and trailing spaces, which is not quite what’s needed. So instead of matching actual space characters with \ s , match (or anchor to) word boundaries with \ b. The resulting expression is / \ bJ ava\ b/ . The element \ B anchors the match to a location that is not a word boundary. Thus, the pattern / \ B[ Ss ] cr i pt /  matches “JavaScript” and “postscript”, but not “script” or “Scripting”.

You can also use arbitrary regular expressions as anchor conditions. If you include an expression within ( ?= and )  characters, it is a lookahead assertion, and it specifies that the enclosed characters must match, without actually matching them. For example, to match the name of a common programming language, but only if it is followed by a colon, you could use / [ J j ] ava( [ Ss ] cr i pt ) ?( ?=\ : ) / . This pattern matches the word “JavaScript” in “JavaScript: The Definitive Guide”, but it does not match “Java” in “Java in a Nutshell” because it is not followed by a colon.

If you instead introduce an assertion with ( ?! , it is a negative lookahead assertion, which specifies that the following characters must not match. For example, / J ava( ?! Scr i pt ) ( [ A- Z] \ w*) /  matches “Java” followed by a capital letter and any number of additional ASCII word characters, as long as “Java” is not followed by “Script”. It matches “JavaBeans” but not “Javanese”, and it matches “JavaScrip” but not “JavaScript” or “JavaScripter”. Table 11-5 summarizes regular expression anchors.


Table 11-5. Regular expression anchor characters

C h ar ac te
r	Meaning

^	Match the beginning of the string or, with the mflag, the beginning of a line.

$	Match the end of the string and, with the mflag, the end of a line.

\	Match a word boundary. That is, match the position between a \ wcharacter and a \ W b	character or between a \ wcharacter and the beginning or end of a string. (Note,
however, that [ \ b]  matches backspace.)

\	Match a position that is not a word boundary.

B

(	A positive lookahead assertion. Require that the following characters match the ?	pattern p, but do not include those characters in the match.
=p )

(	A negative lookahead assertion. Require that the following characters do not match ?!	the pattern p.
p)




LOOKBEHIND ASSERTIONS

ES2018 extends regular expression syntax to allow “lookbehind” assertions. These are like lookahead assertions but refer to text before the current match position. As of early 2020, these are implemented in Node, Chrome, and Edge, but not Firefox or Safari.

Specify a positive lookbehind assertion with ( ?<=. . . )  and a negative lookbehind assertion with ( ?
<! . . . ) . For example, if you were working with US mailing addresses, you could match a 5-digit zip code, but only when it follows a two-letter state abbreviation, like this:

/ ( ?<=   [ A- Z] { 2}   ) \ d{ 5} /


And you could match a string of digits that is not preceded by a Unicode currency symbol with a negative lookbehind assertion like this:

/ ( ?<! [ \ p{ Cur r ency_Symbol } \ d. ] ) \ d+( \ . \ d+) ?/ u




FLAGS

Every regular expression can have one or more flags associated with it to alter its matching behavior. JavaScript defines six possible flags, each of which is represented by a single letter. Flags are specified after the second /  character of a regular expression literal or as a string passed as the second argument to the RegExp( )  constructor. The supported flags and their meanings are:


g

The g flag indicates that the regular expression is “global”—that is, that we intend to use it to find all matches within a string rather than just finding the first match. This flag does not alter the way that pattern matching is done, but, as we’ll see later, it does alter the behavior of the String mat ch( )  method and the RegExp exec( )  method in important ways.

i

The i  flag specifies that pattern matching should be case-insensitive.

m

The mflag specifies that matching should be done in “multiline” mode. It says that the RegExp will be used with multiline strings and that the ^ and $ anchors should match both the beginning and end of the string and also the beginning and end of individual lines within the string.

s

Like the mflag, the s  flag is also useful when working with text that includes newlines. Normally, a “.” in a regular expression matches any character except a line terminator. When the s  flag is used, however, “.” will match any character, including line terminators. The s  flag was added to JavaScript in ES2018 and, as of early 2020, is supported in Node, Chrome, Edge, and Safari, but not Firefox.

u

The u flag stands for Unicode, and it makes the regular expression match full Unicode codepoints rather than matching 16-bit values. This flag was introduced in ES6, and you should make a habit of using it on all regular expressions unless you have some reason not to. If you do not use this flag, then your RegExps will not work well with text that includes emoji and other characters (including many Chinese characters) that require more than 16 bits. Without the u flag, the “.” character matches any 1 UTF-16 16-bit value. With the flag, however, “.” matches one Unicode codepoint, including those that have more

than 16 bits. Setting the u flag on a RegExp also allows you to use the new \ u{ . . . }  escape sequence for Unicode character and also enables the \ p{ . . . }  notation for Unicode character classes.

y

The y flag indicates that the regular expression is “sticky” and should match at the beginning of a string or at the first character following the previous match. When used with a regular expression that is designed to find a single match, it effectively treats that regular expression as if it begins with ^ to anchor it to the beginning of the string. This flag is more useful with regular expressions that are used repeatedly to find all matches within a string. In this case, it causes special behavior of the String mat ch( )  method and the RegExp exec( )  method to enforce that each subsequent match is anchored to the string position at which the last one ended.


These flags may be specified in any combination and in any order. For example, if you want your regular expression to be Unicode-aware to do case-insensitive matching and you intend to use it to find multiple matches within a string, you would specify the flags ui g, gui , or any other permutation of these three letters.


11.3.2 String Methods for Pattern Matching

Until now, we have been describing the grammar used to define regular expressions, but not explaining how those regular expressions can actually be used in JavaScript code. We are now switching to cover the API for using RegExp objects. This section begins by explaining the string methods that use regular expressions to perform pattern matching and search-and-replace operations. The sections that follow this one continue the discussion of pattern matching with JavaScript regular expressions by discussing the RegExp object and its methods and properties.

SEARCH()

Strings support four methods that use regular expressions. The simplest is s ear ch( ) . This method takes a regular expression argument and returns either the character position of the start of the first matching substring or −1 if there is no match:

" J avaSc r i pt " . s ear c h( / s c r i pt / ui )	/ /   =>   4 " Pyt hon" . s ear c h( / s c r i pt / ui )	/ /   =>   - 1


If the argument to s ear ch( )  is not a regular expression, it is first converted to one by passing it to the RegExp constructor. s ear ch( ) does not support global searches; it ignores the g flag of its regular expression argument.

REPLACE()

The r epl ace( )  method performs a search-and-replace operation. It takes a regular expression as its first argument and a replacement string as its second argument. It searches the string on which it is called for matches with the specified pattern. If the regular expression has the g flag set, the
r epl ace( )  method replaces all matches in the string with the replacement string; otherwise, it replaces only the first match it finds. If the first argument to r epl ace( )  is a string rather than a regular expression, the method searches for that string literally rather than converting it to a regular expression with the RegExp( )  constructor, as s ear ch( )  does. As an example, you can use r epl ace( )  as follows to provide uniform capitalization of the word “JavaScript” throughout a string of text:

/ /   No   mat t er   how  i t   i s   c api t al i z ed,	r epl ac e   i t   wi t h   t he   c or r ec t c api t al i z at i on
t ext . r epl ac e( / j avas c r i pt / gi ,	" J avaSc r i pt " ) ;

r epl ace( )  is more powerful than this, however. Recall that parenthesized subexpressions of a regular expression are numbered from left to right and that the regular expression remembers the text that each subexpression matches. If a $ followed by a digit appears in the replacement string, r epl ace( )  replaces those two characters with the text that matches the specified subexpression. This is a very useful feature. You can use it, for example, to replace quotation marks in a string with other characters:


/ /   A  quot e   i s   a   quot at i on   mar k, / /   nonquot at i on   mar k   c har ac t er s / /   by   anot her   quot at i on   mar k.

f ol l owed   by   any   number   of
( whi c h   we   c apt ur e) ,	f ol l owed

l et   quot e   =   / " ( [ ^" ] *) " / g;

/ /   Repl ac e   t he / /   l eavi ng   t he

s t r ai ght   quot at i on   mar ks   wi t h   gui l l emet s quot ed   t ext   ( s t or ed   i n   $1)    unc hanged.

' He   s ai d   " s t op" ' . r epl ac e( quot e,	' «$1»' )	/ /   =>   ' He   s ai d   «s t op»'


If your RegExp uses named capture groups, then you can refer to the matching text by name rather than by number:

l et   quot e   =   / " ( ?<quot edText >[ ^" ] *) " / g;
' He   s ai d   " s t op" ' . r epl ac e( quot e,	' «$<quot edText >»' )	/ /   =>   ' He s ai d   «s t op»'


Instead of passing a replacement string as the second argument to r epl ace( ) , you can also pass a function that will be invoked to
compute the replacement value. The replacement function is invoked with a number of arguments. First is the entire matched text. Next, if the RegExp has capturing groups, then the substrings that were captured by those groups are passed as arguments. The next argument is the position within the string at which the match was found. After that, the entire string that r epl ace( )  was called on is passed. And finally, if the RegExp contained any named capture groups, the last argument to the replacement

function is an object whose property names match the capture group names and whose values are the matching text. As an example, here is code that uses a replacement function to convert decimal integers in a string to hexadecimal:

l et   s   =   " 15   t i mes   15   i s   225" ;
s . r epl ac e( / \ d+/ gu,	n   =>   par s eI nt ( n) . t oSt r i ng( 16) )	/ /   =>   " f t i mes   f    i s   e1"

MATCH()

The mat ch( )  method is the most general of the String regular expression methods. It takes a regular expression as its only argument (or converts its argument to a regular expression by passing it to the RegExp( ) constructor) and returns an array that contains the results of the match, or nul l  if no match is found. If the regular expression has the g flag set, the method returns an array of all matches that appear in the string. For example:

" 7   pl us   8   equal s   15" . mat c h( / \ d+/ g)	/ /   =>   [ " 7" ,	" 8" ,	" 15" ]


If the regular expression does not have the g flag set, mat ch( )  does not do a global search; it simply searches for the first match. In this nonglobal case, mat ch( )  still returns an array, but the array elements are completely different. Without the g flag, the first element of the returned array is the matching string, and any remaining elements are the substrings matching the parenthesized capturing groups of the regular expression. Thus, if mat ch( )  returns an array a, a[ 0]  contains the complete match, a[ 1]  contains the substring that matched the first parenthesized expression, and so on. To draw a parallel with the r epl ace( )  method, a[ 1]  is the same string as $1, a[ 2]  is the same as $2, and so on.

For example, consider parsing a URL5 with the following code:


/ /   A  ver y   s i mpl e   URL   par s i ng   RegExp
l et   ur l	=   / ( \ w+) : \ / \ / ( [ \ w. ] +) \ / ( \ S*) / ;
l et   t ext   =   " Vi s i t   my   bl og   at   ht t p: / / www. exampl e. c om/ ~davi d" ; l et   mat c h   =   t ext . mat c h( ur l ) ;
l et   f ul l ur l ,	pr ot oc ol ,	hos t ,	pat h; i f    ( mat c h   ! ==   nul l )    {
f ul l ur l	=   mat c h[ 0] ;	/ /   f ul l ur l	== " ht t p: / / www. exampl e. c om/ ~davi d"
pr ot oc ol	=   mat c h[ 1] ;	/ /   pr ot oc ol	==   " ht t p"

hos t   =   mat c h[ 2] ; pat h   =   mat c h[ 3] ;
}

/ /   hos t   ==
/ /   pat h   ==

" www. exampl e. c om"
" ~davi d"



In this non-global case, the array returned by mat ch( )  also has some object properties in addition to the numbered array elements. The i nput property refers to the string on which mat ch( )  was called. The i ndex property is the position within that string at which the match starts. And if the regular expression contains named capture groups, then the returned array also has a gr oups  property whose value is an object. The properties of this object match the names of the named groups, and the values are the matching text. We could rewrite the previous URL parsing example, for example, like this:

l et   ur l	=   / ( ?<pr ot oc ol >\ w+) : \ / \ / ( ?<hos t >[ \ w. ] +) \ / ( ?<pat h>\ S*) / ; l et   t ext   =   " Vi s i t   my   bl og   at   ht t p: / / www. exampl e. c om/ ~davi d" ;
l et   mat c h   =   t ext . mat c h( ur l ) ;

mat c h[ 0]
mat c h. i nput mat c h. i ndex
mat c h. gr oups . pr ot oc ol mat c h. gr oups . hos t
mat c h. gr oups . pat h

/ /   =>   " ht t p: / / www. exampl e. c om/ ~davi d" / /   =>   t ext
/ /   =>   17
/ /   =>   " ht t p"
/ /   =>   " www. exampl e. c om"
/ /   =>   " ~davi d"



We’ve seen that mat ch( )  behaves quite differently depending on

whether the RegExp has the g flag set or not. There are also important but less dramatic differences in behavior when the y flag is set. Recall that the y flag makes a regular expression “sticky” by constraining where in the string matches can begin. If a RegExp has both the g and y flags set, then mat ch( )  returns an array of matched strings, just as it does when g is set without y. But the first match must begin at the start of the string, and each subsequent match must begin at the character immediately following the previous match.

If the y flag is set without g, then mat ch( )  tries to find a single match, and, by default, this match is constrained to the start of the string. You can change this default match start position, however, by setting the
l as t I ndex property of the RegExp object at the index at which you want to match at. If a match is found, then this l as t I ndex will be automatically updated to the first character after the match, so if you call mat ch( )  again, in this case, it will look for a subsequent match.
(l as t I ndex may seem like a strange name for a property that specifies the position at which to begin the next match. We will see it again when we cover the RegExp exec( )  method, and its name may make more sense in that context.)

l et   vowel	=   / [ aei ou] / y;	/ /   St i c ky   vowel	mat c h
" t es t " . mat c h( vowel )	/ /   =>   nul l :	" t es t "   does   not   begi n   wi t h a   vowel
vowel . l as t I ndex   =   1;	/ /   Spec i f y   a   di f f er ent   mat c h   pos i t i on
" t es t " . mat c h( vowel ) [ 0]	/ /   =>   " e" :	we   f ound   a   vowel	at   pos i t i on 1
vowel . l as t I ndex	/ /   =>   2:	l as t I ndex   was   aut omat i c al l y updat ed
" t es t " . mat c h( vowel )	/ /   =>   nul l :	no   vowel	at   pos i t i on   2 vowel . l as t I ndex	/ /   =>   0:	l as t I ndex   get s   r es et   af t er f ai l ed   mat c h

It is worth noting that passing a non-global regular expression to the mat ch( )  method of a string is the same as passing the string to the exec( )  method of the regular expression: the returned array and its properties are the same in both cases.

MATCHALL()

The mat chAl l ( )  method is defined in ES2020, and as of early 2020 is implemented by modern web browsers and Node. mat chAl l ( )  expects a RegExp with the g flag set. Instead of returning an array of matching substrings like mat ch( )  does, however, it returns an iterator that yields the kind of match objects that mat ch( )  returns when used with a non-global RegExp. This makes mat chAl l ( )  the easiest and most general way to loop through all matches within a string.

You might use mat chAl l ( )  to loop through the words in a string of text like this:


/ /   One   or   mor e   Uni c ode   al phabet i c   c har ac t er s boundar i es
c ons t   wor ds   =   / \ b\ p{ Al phabet i c } +\ b/ gu;	/ /   \ p Fi r ef ox   yet

bet ween   wor d

i s   not   s uppor t ed   i n

c ons t   t ext   =   " Thi s   i s   a   naï ve   t es t   of    t he   mat c hAl l ( )    met hod. " ; f or ( l et   wor d   of    t ext . mat c hAl l ( wor ds ) )    {
c ons ol e. l og( ` Found   ' ${ wor d[ 0] } '	at   i ndex   ${ wor d. i ndex} . ` ) ; }


You can set the l as t I ndex property of a RegExp object to tell
mat chAl l ( )  what index in the string to begin matching at. Unlike the other pattern-matching methods, however, mat chAl l ( )  never modifies the l as t I ndex property of the RegExp you call it on, and this makes it much less likely to cause bugs in your code.

SPLIT()

The last of the regular expression methods of the String object is
s pl i t ( ) . This method breaks the string on which it is called into an array of substrings, using the argument as a separator. It can be used with a string argument like this:

" 123, 456, 789" . s pl i t ( " , " )	/ /   =>   [ " 123" ,	" 456" ,	" 789" ]


The s pl i t ( )  method can also take a regular expression as its argument, and this allows you to specify more general separators. Here we call it with a separator that includes an arbitrary amount of whitespace on either side:

" 1,	2,	3, \ n4,	5" . s pl i t ( / \ s *, \ s */ )	/ /   =>   [ " 1" ,	" 2" ,	" 3" ,	" 4" , " 5" ]


Surprisingly, if you call s pl i t ( )  with a RegExp delimiter and the regular expression includes capturing groups, then the text that matches the capturing groups will be included in the returned array. For example:

c ons t   ht ml Tag   =   / <( [ ^>] +) >/ ;	/ /   <   f ol l owed   by   one   or   mor e   non->,	f ol l owed   by   >
" Tes t i ng<br / >1, 2, 3" . s pl i t ( ht ml Tag)	/ /   =>   [ " Tes t i ng" ,	" br / " , " 1, 2, 3" ]


11.3.3 The RegExp Class

This section documents the RegExp( )  constructor, the properties of RegExp instances, and two important pattern-matching methods defined by the RegExp class.

The RegExp( )  constructor takes one or two string arguments and creates a new RegExp object. The first argument to this constructor is a string that

contains the body of the regular expression—the text that would appear within slashes in a regular-expression literal. Note that both string literals and regular expressions use the \  character for escape sequences, so when you pass a regular expression to RegExp( )  as a string literal, you must replace each \  character with \ \ . The second argument to RegExp( )  is optional. If supplied, it indicates the regular expression flags. It should be g, i , m, s , u, y, or any combination of those letters.


For example:


/ /   Fi nd   al l	f i ve- di gi t   number s   i n   a   s t r i ng.	Not e   t he   doubl e   \ \ i n   t hi s   c as e.
l et   z i pc ode   =   new  RegExp( " \ \ d{ 5} " ,	" g" ) ;


The RegExp( )  constructor is useful when a regular expression is being dynamically created and thus cannot be represented with the regular expression literal syntax. For example, to search for a string entered by the user, a regular expression must be created at runtime with RegExp( ) .


Instead of passing a string as the first argument to RegExp( ) , you can also pass a RegExp object. This allows you to copy a regular expression and change its flags:

l et   exac t Mat c h   =   / J avaSc r i pt / ;
l et   c as eI ns ens i t i ve   =   new  RegExp( exac t Mat c h,	" i " ) ;


REGEXP PROPERTIES

RegExp objects have the following properties:


s our c e

This read-only property is the source text of the regular expression: the characters that appear between the slashes in a RegExp literal.


f l ags

This read-only property is a string that specifies the set of letters that represent the flags for the RegExp.

gl obal

A read-only boolean property that is true if the g flag is set.

i gnor eCas e

A read-only boolean property that is true if the i  flag is set.

mul t i l i ne

A read-only boolean property that is true if the mflag is set.

dot Al l

A read-only boolean property that is true if the s  flag is set.

uni c ode

A read-only boolean property that is true if the u flag is set.

s t i c ky

A read-only boolean property that is true if the y flag is set.

l as t I ndex

This property is a read/write integer. For patterns with the g or y flags, it specifies the character position at which the next search is to begin. It is used by the exec( )  and t es t ( )  methods, described in the next two subsections.


TEST()

The t es t ( )  method of the RegExp class is the simplest way to use a regular expression. It takes a single string argument and returns t r ue if the string matches the pattern or f al s e if it does not match.



t es t ( )  works by simply calling the (much more complicated) exec( ) method described in the next section and returning t r ue if exec( ) returns a non-null value. Because of this, if you use t es t ( )  with a RegExp that uses the g or y flags, then its behavior depends on the value of the l as t I ndex property of the RegExp object, which can change unexpectedly. See “The lastIndex Property and RegExp Reuse” for more details.

EXEC()

The RegExp exec( )  method is the most general and powerful way to use regular expressions. It takes a single string argument and looks for a match in that string. If no match is found, it returns nul l . If a match is found, however, it returns an array just like the array returned by the mat ch( ) method for non-global searches. Element 0 of the array contains the string that matched the regular expression, and any subsequent array elements contain the substrings that matched any capturing groups. The returned array also has named properties: the i ndex property contains the character position at which the match occurred, and the i nput  property specifies the string that was searched, and the gr oups  property, if defined, refers to an object that holds the substrings matching the any named capturing groups.

Unlike the String mat ch( )  method, exec( )  returns the same kind of array whether or not the regular expression has the global g flag. Recall that mat ch( )  returns an array of matches when passed a global regular expression. exec( ) , by contrast, always returns a single match and provides complete information about that match. When exec( )  is called on a regular expression that has either the global g flag or the sticky y flag

set, it consults the l as t I ndex property of the RegExp object to determine where to start looking for a match. (And if the y flag is set, it also constrains the match to begin at that position.) For a newly created RegExp object, l as t I ndex is 0, and the search begins at the start of the string. But each time exec( )  successfully finds a match, it updates the
l as t I ndex property to the index of the character immediately after the matched text. If exec( )  fails to find a match, it resets l as t I ndex to 0. This special behavior allows you to call exec( )  repeatedly in order to loop through all the regular expression matches in a string. (Although, as we’ve described, in ES2020 and later, the mat chAl l ( )  method of String is an easier way to loop through all matches.) For example, the loop in the following code will run twice:

l et   pat t er n   =   / J ava/ g;
l et   t ext   =   " J avaSc r i pt   >   J ava" ; l et   mat c h;
whi l e( ( mat c h   =   pat t er n. exec ( t ext ) )    ! ==   nul l )    {
c ons ol e. l og( ` Mat c hed   ${ mat c h[ 0] }    at   ${ mat c h. i ndex} ` ) ;
c ons ol e. l og( ` Next   s ear c h   begi ns   at   ${ pat t er n. l as t I ndex} ` ) ; }



THE LASTINDEX PROPERTY AND REGEXP REUSE

As you have seen already, JavaScript’s regular expression API is complicated. The use of the l as t I ndex property with the g and y flags is a particularly awkward part of this API. When you use these flags, you need to be particularly careful when calling the mat ch( ) , exec( ) , or t es t ( )  methods because the behavior of these methods depends on l as t I ndex, and the value of l as t I ndex depends on what you have previously done with the RegExp object. This makes it easy to write buggy code.

Suppose, for example, that we wanted to find the index of all <p> tags within a string of HTML text. We might write code like this:

l et   mat ch,    pos i t i ons   =   [ ] ;
whi l e( ( mat ch   =   / <p>/ g. exec( ht ml ) )    ! ==   nul l )    {   / /   POSSI BL E   I NFI NI TE   L OOP pos i t i ons . pus h( mat ch. i ndex) ;
}


This code does not do what we want it to. If the ht ml  string contains at least one <p> tag, then it will loop

forever. The problem is that we use a RegExp literal in the whi l e loop condition. For each iteration of the loop, we’re creating a new RegExp object with l as t I ndex set to 0, so exec( )  always begins at the start of the string, and if there is a match, it will keep matching over and over. The solution, of course, is to define the RegExp once, and save it to a variable so that we’re using the same RegExp object for each iteration of the loop.

On the other hand, sometimes reusing a RegExp object is the wrong thing to do. Suppose, for example, that we want to loop through all of the words in a dictionary to find words that contain pairs of double letters:

l et   di ct i onar y   =   [    " appl e" ,    " book" ,    " cof f ee"   ] ; l et   doubl eL et t er Wor ds   =   [ ] ;
l et   doubl eL et t er   =   / ( \ w) \ 1/ g;

f or ( l et   wor d   of   di ct i onar y)    {
i f   ( doubl eL et t er . t es t ( wor d) )    { doubl eL et t er Wor ds . pus h( wor d) ;
} }
doubl eL et t er Wor ds	/ /   =>   [ " appl e" ,    " c of f ee" ] :    " book"   i s   mi s s i ng!


Because we set the g flag on the RegExp, the l as t I ndex property is changed after successful matches, and the t es t ( )  method (which is based on exec( ) ) starts searching for a match at the position specified by l as t I ndex. After matching the “pp” in “apple”, l as t I ndex is 3, and so we start searching the word “book” at position 3 and do not see the “oo” that it contains.

We could fix this problem by removing the g flag (which is not actually necessary in this particular example), or by moving the RegExp literal into the body of the loop so that it is re-created on each iteration, or by explicitly resetting l as t I ndex to zero before each call to t es t ( ) .

The moral here is that l as t I ndex makes the RegExp API error prone. So be extra careful when using the g or y flags and looping. And in ES2020 and later, use the String mat chAl l ( )  method instead of exec( ) to sidestep this problem since mat chAl l ( )  does not modify l as t I ndex.




11.4 Dates and Times

The Date class is JavaScript’s API for working with dates and times. Create a Date object with the Dat e( )  constructor. With no arguments, it returns a Date object that represents the current date and time:

l et   now  =   new  Dat e( ) ;	/ /   The   c ur r ent   t i me


If you pass one numeric argument, the Dat e( )  constructor interprets that

argument as the number of milliseconds since the 1970 epoch:


l et   epoc h   =   new  Dat e( 0) ;	/ /   Mi dni ght ,	J anuar y   1s t ,	1970,	GMT


If you specify two or more integer arguments, they are interpreted as the year, month, day-of-month, hour, minute, second, and millisecond in your local time zone, as in the following:

l et   c ent ur y   =   new  Dat e( 2100,	/ /   Year   2100

0, 1,
2,	3,	4,	5) ;

/ /   J anuar y / /   1s t
/ /   02: 03: 04. 005,	l oc al	t i me



One quirk of the Date API is that the first month of a year is number 0, but the first day of a month is number 1. If you omit the time fields, the
Dat e( )  constructor defaults them all to 0, setting the time to midnight.


Note that when invoked with multiple numbers, the Dat e( )  constructor interprets them using whatever time zone the local computer is set to. If you want to specify a date and time in UTC (Universal Coordinated Time, aka GMT), then you can use the Dat e. UTC( ) . This static method takes the same arguments as the Dat e( )  constructor, interprets them in UTC, and returns a millisecond timestamp that you can pass to the Dat e( ) constructor:

/ /   Mi dni ght   i n   Engl and,	J anuar y   1,	2100
l et   c ent ur y   =   new  Dat e( Dat e. UTC( 2100,	0,	1) ) ;


If you print a date (with cons ol e. l og( cent ur y) , for example), it will, by default, be printed in your local time zone. If you want to display a date in UTC, you should explicitly convert it to a string with
t oUTCSt r i ng( )  or t oI SOSt r i ng( ) .

Finally, if you pass a string to the Dat e( )  constructor, it will attempt to parse that string as a date and time specification. The constructor can parse dates specified in the formats produced by the t oSt r i ng( ) ,
t oUTCSt r i ng( ) , and t oI SOSt r i ng( )  methods:


l et   c ent ur y   =   new  Dat e( " 2100- 01- 01T00: 00: 00Z" ) ;	/ /   An   I SO f or mat   dat e


Once you have a Date object, various get and set methods allow you to query and modify the year, month, day-of-month, hour, minute, second, and millisecond fields of the Date. Each of these methods has two forms: one that gets or sets using local time and one that gets or sets using UTC time. To get or set the year of a Date object, for example, you would use get Ful l Year ( ) , get UTCFul l Year ( ) , s et Ful l Year ( ) , or
s et UTCFul l Year ( ) :


l et   d   =   new  Dat e( ) ;	/ /   St ar t   wi t h   t he   c ur r ent dat e
d. s et Ful l Year ( d. get Ful l Year ( )    +   1) ;	/ /   I nc r ement   t he   year


To get or set the other fields of a Date, replace “FullYear” in the method name with “Month”, “Date”, “Hours”, “Minutes”, “Seconds”, or “Milliseconds”. Some of the date set methods allow you to set more than one field at a time. s et Ful l Year ( )  and s et UTCFul l Year ( )  also optionally allow you to set the month and day-of-month as well. And
s et Hour s ( )  and s et UTCHour s ( )  allow you to specify the minutes, seconds, and milliseconds fields in addition to the hours field.

Note that the methods for querying the day-of-month are get Dat e( ) and get UTCDat e( ) . The more natural-sounding functions get Day( ) and get UTCDay( )  return the day-of-week (0 for Sunday through 6 for Saturday). The day-of-week is read-only, so there is not a corresponding

s et Day( )  method.


11.4.1 Timestamps

JavaScript represents dates internally as integers that specify the number of milliseconds since (or before) midnight on January 1, 1970, UTC time. Integers as large as 8,640,000,000,000,000 are supported, so JavaScript won’t be running out of milliseconds for more than 270,000 years.


For any Date object, the get Ti me( )  method returns this internal value, and the s et Ti me( )  method sets it. So you can add 30 seconds to a Date with code like this, for example:

d. s et Ti me( d. get Ti me( )    +   30000) ;


These millisecond values are sometimes called timestamps, and it is sometimes useful to work with them directly rather than with Date objects. The static Dat e. now( )  method returns the current time as a timestamp and is helpful when you want to measure how long your code takes to run:

l et   s t ar t Ti me   =   Dat e. now( ) ;
r et i c ul at eSpl i nes ( ) ;	/ /   Do   s ome   t i me- c ons umi ng   oper at i on l et   endTi me   =   Dat e. now( ) ;
c ons ol e. l og( ` Spl i ne   r et i c ul at i on   t ook   ${ endTi me   -s t ar t Ti me} ms . ` ) ;



HIGH-RESOLUTION TIMESTAMPS

The timestamps returned by Dat e. now( )  are measured in milliseconds. A millisecond is actually a relatively long time for a computer, and sometimes you may want to measure elapsed time with higher precision. The per f or mance. now( )  function allows this: it also returns a millisecond-based timestamp, but the return value is not an integer, so it includes fractions of a millisecond. The value returned by
per f or mance. now( )  is not an absolute timestamp like the Dat e. now( )  value is. Instead, it simply indicates how much time has elapsed since a web page was loaded or since the Node process started.

The per f or mance object is part of a larger Performance API that is not defined by the ECMAScript standard but is implemented by web browsers and by Node. In order to use the per f or mance object in

Node, you must import it with:


c ons t   {   per f or mance   }   =   r equi r e( " per f _hooks " ) ;


Allowing high-precision timing on the web may allow unscrupulous websites to fingerprint visitors, so browsers (notably Firefox) may reduce the precision of per f or mance. now( )  by default. As a web developer, you should be able to re-enable high-precision timing somehow (such as by setting
pr i vacy. r educeTi mer Pr eci s i on to false in Firefox).




11.4.2 Date Arithmetic

Date objects can be compared with JavaScript’s standard <, <=, >, and >= comparison operators. And you can subtract one Date object from another to determine the number of milliseconds between the two dates. (This works because the Date class defines a val ueOf ( )  method that returns a timestamp.)

If you want to add or subtract a specified number of seconds, minutes, or hours from a Date, it is often easiest to simply modify the timestamp as demonstrated in the previous example, when we added 30 seconds to a date. This technique becomes more cumbersome if you want to add days, and it does not work at all for months and years since they have varying numbers of days. To do date arithmetic involving days, months, and years, you can use s et Dat e( ) , s et Mont h( ) , and s et Year ( ) . Here, for example, is code that adds three months and two weeks to the current date:

l et   d   =   new  Dat e( ) ;
d. s et Mont h( d. get Mont h( )    +   3,	d. get Dat e( )    +   14) ;


Date setting methods work correctly even when they overflow. When we add three months to the current month, we can end up with a value greater than 11 (which represents December). The s et Mont h( )  handles this by incrementing the year as needed. Similarly, when we set the day of the

month to a value larger than the number of days in the month, the month gets incremented appropriately.


11.4.3 Formatting and Parsing Date Strings

If you are using the Date class to actually keep track of dates and times (as opposed to just measuring time intervals), then you are likely to need to display dates and times to the users of your code. The Date class defines a number of different methods for converting Date objects to strings. Here are some examples:

l et   d   =   new  Dat e( 2020,	0,	1,	17,	10,	30) ;	/ /   5: 10: 30pm on   New Year ' s   Day   2020
d. t oSt r i ng( )	/ /   =>   " Wed   J an   01   2020   17: 10: 30   GMT- 0800   ( Pac i f i c St andar d   Ti me) "
d. t oUTCSt r i ng( )	/ /   =>   " Thu,	02   J an   2020   01: 10: 30   GMT" d. t oL oc al eDat eSt r i ng( )	/ /   =>   " 1/ 1/ 2020" :	' en- US'	l oc al e
d. t oL oc al eTi meSt r i ng( )	/ /   =>   " 5: 10: 30   PM" :	' en- US'	l oc al e d. t oI SOSt r i ng( )	/ /   =>   " 2020- 01- 02T01: 10: 30. 000Z"


This is a full list of the string formatting methods of the Date class:


t oSt r i ng( )

This method uses the local time zone but does not format the date and time in a locale-aware way.

t oUTCSt r i ng( )

This method uses the UTC time zone but does not format the date in a locale-aware way.

t oI SOSt r i ng( )

This method prints the date and time in the standard year-month-day hours:minutes:seconds.ms format of the ISO-8601 standard. The letter “T” separates the date portion of the output from the time portion of

the output. The time is expressed in UTC, and this is indicated with the letter “Z” as the last letter of the output.

t oLoc al eSt r i ng( )

This method uses the local time zone and a format that is appropriate for the user’s locale.

t oDat eSt r i ng( )

This method formats only the date portion of the Date and omits the time. It uses the local time zone and does not do locale-appropriate formatting.

t oLoc al eDat eSt r i ng( )

This method formats only the date. It uses the local time zone and a locale-appropriate date format.

t oTi meSt r i ng( )

This method formats only the time and omits the date. It uses the local time zone but does not format the time in a locale-aware way.

t oLoc al eTi meSt r i ng( )

This method formats the time in a locale-aware way and uses the local time zone.


None of these date-to-string methods is ideal when formatting dates and times to be displayed to end users. See §11.7.2 for a more general-purpose and locale-aware date- and time-formatting technique.


Finally, in addition to these methods that convert a Date object to a string, there is also a static Dat e. par s e( )  method that takes a string as its argument, attempts to parse it as a date and time, and returns a timestamp representing that date. Dat e. par s e( )  is able to parse the same strings that the Dat e( )  constructor can and is guaranteed to be able to parse the

output of t oI SOSt r i ng( ) , t oUTCSt r i ng( ) , and t oSt r i ng( ) .



11.5 Error Classes

The JavaScript t hr owand cat ch statements can throw and catch any JavaScript value, including primitive values. There is no exception type that must be used to signal errors. JavaScript does define an Error class, however, and it is traditional to use instances of Error or a subclass when signaling an error with t hr ow. One good reason to use an Error object is that, when you create an Error, it captures the state of the JavaScript stack, and if the exception is uncaught, the stack trace will be displayed with the error message, which will help you debug the issue. (Note that the stack trace shows where the Error object was created, not where the t hr ow statement throws it. If you always create the object right before throwing it with t hr ow  new  Er r or ( ) , this will not cause any confusion.)


Error objects have two properties: mes s age and name, and a
t oSt r i ng( )  method. The value of the mes s age property is the value you passed to the Er r or ( )  constructor, converted to a string if necessary. For error objects created with Er r or ( ) , the name property is always “Error”. The t oSt r i ng( )  method simply returns the value of the name property followed by a colon and space and the value of the mes s age property.

Although it is not part of the ECMAScript standard, Node and all modern browsers also define a s t ack property on Error objects. The value of this property is a multi-line string that contains a stack trace of the JavaScript call stack at the moment that the Error object was created. This can be useful information to log when an unexpected error is caught.

In addition to the Error class, JavaScript defines a number of subclasses that it uses to signal particular types of errors defined by ECMAScript. These subclasses are EvalError, RangeError, ReferenceError, SyntaxError, TypeError, and URIError. You can use these error classes in your own code if they seem appropriate. Like the base Error class, each of these subclasses has a constructor that takes a single message argument. And instances of each of these subclasses have a name property whose value is the same as the constructor name.

You should feel free to define your own Error subclasses that best encapsulate the error conditions of your own program. Note that you are not limited to the name and mes s age properties. If you create a subclass, you can define new properties to provide error details. If you are writing a parser, for example, you might find it useful to define a ParseError class with l i ne and col umn properties that specify the exact location of the parsing failure. Or if you are working with HTTP requests, you might want to define an HTTPError class that has a s t at us  property that holds the HTTP status code (such as 404 or 500) of the failed request.

For example:


c l as s   HTTPEr r or   ext ends   Er r or   {
c ons t r uc t or ( s t at us ,	s t at us Text ,	ur l )    {
s uper ( ` ${ s t at us }    ${ s t at us Text } :	${ ur l } ` ) ; t hi s . s t at us   =   s t at us ;
t hi s . s t at us Text   =   s t at us Text ; t hi s . ur l	=   ur l ;
}

get   name( )    {    r et ur n   " HTTPEr r or " ;	} }

l et   er r or   =   new  HTTPEr r or ( 404,	" Not   Found" , " ht t p: / / exampl e. c om/ " ) ;


er r or . s t at us
er r or . mes s age

/ /   =>   404
/ /   =>   " 404   Not   Found:	ht t p: / / exampl e. c om/ "

er r or . name	/ /   =>   " HTTPEr r or "



11.6 J SON Serialization and Parsing

When a program needs to save data or needs to transmit data across a network connection to another program, it must to convert its in-memory data structures into a string of bytes or characters than can be saved or transmitted and then later be parsed to restore the original in-memory data structures. This process of converting data structures into streams of bytes or characters is known as serialization (or marshaling or even pickling).


The easiest way to serialize data in JavaScript uses a serialization format known as JSON. This acronym stands for “JavaScript Object Notation” and, as the name implies, the format uses JavaScript object and array literal syntax to convert data structures consisting of objects and arrays into strings. JSON supports primitive numbers and strings and also the values t r ue, f al s e, and nul l , as well as arrays and objects built up from those primitive values. JSON does not support other JavaScript types like Map, Set, RegExp, Date, or typed arrays. Nevertheless, it has proved to be a remarkably versatile data format and is in common use even with non-JavaScript-based programs.

JavaScript supports JSON serialization and deserialization with the two functions J SON. s t r i ngi f y( )  and J SON. par s e( ) , which were covered briefly in §6.8. Given an object or array (nested arbitrarily deeply) that does not contain any nonserializable values like RegExp objects or typed arrays, you can serialize the object simply by passing it to
J SON. s t r i ngi f y( ) . As the name implies, the return value of this function is a string. And given a string returned by

J SON. s t r i ngi f y( ) , you can re-create the original data structure by passing the string to J SON. par s e( ) :

l et   o   =   { s :	" " ,	n:	0,	a:	[ t r ue,	f al s e,	nul l ] } ;
l et   s   =   J SON. s t r i ngi f y( o) ;	/ /   s   ==   ' { " s " : " " , " n" : 0, " a" : [ t r ue, f al s e, nul l ] } '
l et   c opy   =   J SON. par s e( s ) ;	/ /   c opy   ==   { s :	" " ,	n:	0,	a:	[ t r ue, f al s e,	nul l ] }


If we leave out the part where serialized data is saved to a file or sent over the network, we can use this pair of functions as a somewhat inefficient way of creating a deep copy of an object:

/ /   Make   a   deep   c opy   of    any   s er i al i z abl e   obj ec t   or   ar r ay f unc t i on   deepc opy( o)    {
r et ur n   J SON. par s e( J SON. s t r i ngi f y( o) ) ; }



J SON IS A SUBSET OF J AVASCRIPT

When data is serialized to JSON format, the result is valid JavaScript source code for an expression that evaluates to a copy of the original data structure. If you prefix a JSON string with var   dat a   = and pass the result to eval ( ) , you’ll get a copy of the original data structure assigned to the variable dat a. You should never do this, however, because it is a huge security hole—if an attacker could inject arbitrary JavaScript code into a JSON file, they could make your program run their code. It is faster and safer to just use J SON. par s e( )  to decode JSON-formatted data.

JSON is sometimes used as a human-readable configuration file format. If you find yourself hand-editing a JSON file, note that the JSON format is a very strict subset of JavaScript. Comments are not allowed and property names must be enclosed in double quotes even when JavaScript would not require this.




Typically, you pass only a single argument to J SON. s t r i ngi f y( )  and J SON. par s e( ) . Both functions accept an optional second argument that

allows us to extend the JSON format, and these are described next.
J SON. s t r i ngi f y( )  also takes an optional third argument that we’ll discuss first. If you would like your JSON-formatted string to be human-readable (if it is being used as a configuration file, for example), then you should pass nul l  as the second argument and pass a number or string as the third argument. This third argument tells J SON. s t r i ngi f y( )  that it should format the data on multiple indented lines. If the third argument is a number, then it will use that number of spaces for each indentation level. If the third argument is a string of whitespace (such as ' \ t ' ), it will use that string for each level of indent.

l et   o   =   { s :	" t es t " ,	n:	0} ;
J SON. s t r i ngi f y( o,	nul l ,	2)	/ /   =>   ' { \ n	" s " :	" t es t " , \ n	" n" : 0\ n} '


J SON. par s e( )  ignores whitespace, so passing a third argument to
J SON. s t r i ngi f y( )  has no impact on our ability to convert the string back into a data structure.


11.6.1 J SON Customizations

If J SON. s t r i ngi f y( )  is asked to serialize a value that is not natively supported by the JSON format, it looks to see if that value has a
t oJ SON( )  method, and if so, it calls that method and then stringifies the return value in place of the original value. Date objects implement
t oJ SON( ) : it returns the same string that t oI SOSt r i ng( )  method does. This means that if you serialize an object that includes a Date, the date will automatically be converted to a string for you. When you parse the serialized string, the re-created data structure will not be exactly the same as the one you started with because it will have a string where the original object had a Date.

If you need to re-create Date objects (or modify the parsed object in any other way), you can pass a “reviver” function as the second argument to
J SON. par s e( ) . If specified, this “reviver” function is invoked once for each primitive value (but not the objects or arrays that contain those primitive values) parsed from the input string. The function is invoked with two arguments. The first is a property name—either an object property name or an array index converted to a string. The second argument is the primitive value of that object property or array element. Furthermore, the function is invoked as a method of the object or array that contains the primitive value, so you can refer to that containing object with the t hi s  keyword.


The return value of the reviver function becomes the new value of the named property. If it returns its second argument, the property will remain unchanged. If it returns undef i ned, then the named property will be deleted from the object or array before J SON. par s e( )  returns to the user.

As an example, here is a call to J SON. par s e( )  that uses a reviver function to filter some properties and to re-create Date objects:

l et   dat a   =   J SON. par s e( t ext ,	f unc t i on( key,	val ue)    {
/ /   Remove   any   val ues   whos e   pr oper t y   name   begi ns   wi t h   an under s c or e
i f    ( key[ 0]    ===   " _" )    r et ur n   undef i ned;

/ /   I f    t he   val ue   i s   a   s t r i ng   i n   I SO  8601   dat e   f or mat   c onver t i t   t o   a   Dat e.
i f    ( t ypeof    val ue   ===   " s t r i ng"   && / ^\ d\ d\ d\ d- \ d\ d-
\ d\ dT\ d\ d: \ d\ d: \ d\ d. \ d\ d\ dZ$/ . t es t ( val ue) )    {
r et ur n   new  Dat e( val ue) ; }

/ /   Ot her wi s e,	r et ur n   t he   val ue   unc hanged

r et ur n   val ue; } ) ;


In addition to its use of t oJ SON( )  described earlier,
J SON. s t r i ngi f y( )  also allows its output to be customized by passing an array or a function as the optional second argument.

If an array of strings (or numbers—they are converted to strings) is passed instead as the second argument, these are used as the names of object properties (or array elements). Any property whose name is not in the array will be omitted from stringification. Furthermore, the returned string will include properties in the same order that they appear in the array (which can be very useful when writing tests).


If you pass a function, it is a replacer function—effectively the inverse of the optional reviver function you can pass to J SON. par s e( ) . If specified, the replacer function is invoked for each value to be stringified. The first argument to the replacer function is the object property name or array index of the value within that object, and the second argument is the value itself. The replacer function is invoked as a method of the object or array that contains the value to be stringified. The return value of the replacer function is stringified in place of the original value. If the replacer returns undef i ned or returns nothing at all, then that value (and its array element or object property) is omitted from the stringification.

/ /   Spec i f y   what   f i el ds   t o   s er i al i z e,	and   what   or der   t o   s er i al i z e t hem i n
l et   t ext   =   J SON. s t r i ngi f y( addr es s ,	[ " c i t y" , " s t at e" , " c ount r y" ] ) ;

/ /   Spec i f y   a   r epl ac er   f unc t i on   t hat   omi t s   RegExp- val ue pr oper t i es
l et   j s on   =   J SON. s t r i ngi f y( o,	( k,	v)    =>   v   i ns t anc eof    RegExp   ?
undef i ned   :	v) ;

The two J SON. s t r i ngi f y( )  calls here use the second argument in a benign way, producing serialized output that can be deserialized without requiring a special reviver function. In general, though, if you define a
t oJ SON( )  method for a type, or if you use a replacer function that actually replaces nonserializable values with serializable ones, then you will typically need to use a custom reviver function with
J SON. par s e( )  to get your original data structure back. If you do this, you should understand that you are defining a custom data format and sacrificing portability and compatibility with a large ecosystem of JSON-compatible tools and languages.


11.7 The Internationalization API

The JavaScript internationalization API consists of the three classes Intl.NumberFormat, Intl.DateTimeFormat, and Intl.Collator that allow us to format numbers (including monetary amounts and percentages), dates, and times in locale-appropriate ways and to compare strings in locale-appropriate ways. These classes are not part of the ECMAScript standard but are defined as part of the ECMA402 standard and are well-supported by web browsers. The Intl API is also supported in Node, but at the time of this writing, prebuilt Node binaries do not ship with the localization data required to make them work with locales other than US English. So in order to use these classes with Node, you may need to download a separate data package or use a custom build of Node.


One of the most important parts of internationalization is displaying text that has been translated into the user’s language. There are various ways to achieve this, but none of them are within the scope of the Intl API described here.

11.7.1 Formatting Numbers

Users around the world expect numbers to be formatted in different ways. Decimal points can be periods or commas. Thousands separators can be commas or periods, and they aren’t used every three digits in all places. Some currencies are divided into hundredths, some into thousandths, and some have no subdivisions. Finally, although the so-called “Arabic numerals” 0 through 9 are used in many languages, this is not universal, and users in some countries will expect to see numbers written using the digits from their own scripts.


The Intl.NumberFormat class defines a f or mat ( )  method that takes all of these formatting possibilities into account. The constructor takes two arguments. The first argument specifies the locale that the number should be formatted for and the second is an object that specifies more details about how the number should be formatted. If the first argument is omitted or undef i ned, then the system locale (which we assume to be the user’s preferred locale) will be used. If the first argument is a string, it specifies a desired locale, such as " en- US" (English as used in the United States),
" f r " (French), or " z h- Hans - CN" (Chinese, using the simplified Han writing system, in China). The first argument can also be an array of locale strings, and in this case, Intl.NumberFormat will choose the most specific one that is well supported.

The second argument to the I nt l . Number For mat ( )  constructor, if specified, should be an object that defines one or more of the following properties:


s t yl e

Specifies the kind of number formatting that is required. The default is

" deci mal " . Specify " per cent " to format a number as a percentage or specify " cur r ency" to specify a number as an amount of money.

c ur r enc y

If style is " cur r ency" , then this property is required to specify the three-letter ISO currency code (such as " USD" for US dollars or
" GBP" for British pounds) of the desired currency.

c ur r enc yDi s pl ay

If style is " cur r ency" , then this property specifies how the currency is displayed. The default value " s ymbol " uses a currency symbol if the currency has one. The value " code" uses the three-letter ISO code, and the value " name" spells out the name of the currency in long form.

us eGr oupi ng

Set this property to f al s e if you do not want numbers to have thousands separators (or their locale-appropriate equivalents).

mi ni mumI nt eger Di gi t s

The minimum number of digits to use to display the integer part of the number. If the number has fewer digits than this, it will be padded on the left with zeros. The default value is 1, but you can use values as high as 21.

mi ni mumFr ac t i onDi gi t s , maxi mumFr ac t i onDi gi t s

These two properties control the formatting of the fractional part of the number. If a number has fewer fractional digits than the minimum, it will be padded with zeros on the right. If it has more than the maximum, then the fractional part will be rounded. Legal values for both properties are between 0 and 20. The default minimum is 0 and the default maximum is 3, except when formatting monetary amounts, when the length of the fractional part varies depending on the specified

currency.

mi ni mumSi gni f i c ant Di gi t s , maxi mumSi gni f i c ant Di gi t s

These properties control the number of significant digits used when formatting a number, making them suitable when formatting scientific data, for example. If specified, these properties override the integer and fractional digit properties listed previously. Legal values are between 1 and 21.


Once you have created an Intl.NumberFormat object with the desired locale and options, you use it by passing a number to its f or mat ( ) method, which returns an appropriately formatted string. For example:

l et   eur os   =   I nt l . Number For mat ( " es " ,	{ s t yl e:	" c ur r enc y" , c ur r enc y:	" EUR" } ) ;
eur os . f or mat ( 10)	/ /   =>   " 10, 00   €" :	t en   eur os ,	Spani s h f or mat t i ng

l et   pounds   =   I nt l . Number For mat ( " en" ,	{ s t yl e:	" c ur r enc y" , c ur r enc y:	" GBP" } ) ;
pounds . f or mat ( 1000)    / /   =>   " £1, 000. 00" :	One   t hous and   pounds , Engl i s h   f or mat t i ng


A useful feature of I nt l . Number For mat  (and the other Intl classes as well) is that its f or mat ( )  method is bound to the NumberFormat object to which it belongs. So instead of defining a variable that refers to the formatting object and then invoking the f or mat ( )  method on that, you can just assign the f or mat ( )  method to a variable and use it as if it were a standalone function, as in this example:

l et   dat a   =   [ 0. 05,	. 75,	1] ;
l et   f or mat Dat a   =   I nt l . Number For mat ( undef i ned,	{ s t yl e:	" per c ent " ,
mi ni mumFr ac t i onDi gi t s :	1, maxi mumFr ac t i onDi gi t s :	1
} ) . f or mat ;


dat a. map( f or mat Dat a)	/ /   =>   [ " 5. 0%" ,	" 75. 0%" ,	" 100. 0%" ] :	i n   en-US   l oc al e


Some languages, such as Arabic, use their own script for decimal digits:


l et   ar abi c   =   I nt l . Number For mat ( " ar " ,	{ us eGr oupi ng: f al s e} ) . f or mat ;
ar abi c ( 1234567890)	/ /   =>   "	"


Other languages, such as Hindi, use a script that has its own set of digits, but tend to use the ASCII digits 0–9 by default. If you want to override the default script used for digits, add - u- nu-  to the locale and follow it with an abbreviated script name. You can format numbers with Indian-style grouping and Devanagari digits like this, for example:

l et   hi ndi	=   I nt l . Number For mat ( " hi - I N- u- nu- deva" ) . f or mat ; hi ndi ( 1234567890)	/ /   =>   "   ,	,	,	,	"


- u-  in a locale specifies that what comes next is a Unicode extension. nu is the extension name for the numbering system, and deva is short for Devanagari. The Intl API standard defines names for a number of other numbering systems, mostly for the Indic languages of South and Southeast Asia.


11.7.2 Formatting Dates and Times

The Intl.DateTimeFormat class is a lot like the Intl.NumberFormat class. The I nt l . Dat eTi meFor mat ( )  constructor takes the same two arguments that I nt l . Number For mat ( )  does: a locale or array of locales and an object of formatting options. And the way you use an Intl.DateTimeFormat instance is by calling its f or mat ( )  method to convert a Date object to a string.

As mentioned in §11.4, the Date class defines simple
t oLocal eDat eSt r i ng( )  and t oLocal eTi meSt r i ng( )  methods that produce locale-appropriate output for the user’s locale. But these methods don’t give you any control over what fields of the date and time are displayed. Maybe you want to omit the year but add a weekday to the date format. Do you want the month to be represented numerically or spelled out by name? The Intl.DateTimeFormat class provides fine-grained control over what is output based on the properties in the options object that is passed as the second argument to the constructor. Note, however, that Intl.DateTimeFormat cannot always display exactly what you ask for. If you specify options to format hours and seconds but omit minutes, you’ll find that the formatter displays the minutes anyway. The idea is that you use the options object to specify what date and time fields you’d like to present to the user and how you’d like those formatted (by name or by number, for example), then the formatter will look for a locale-appropriate format that most closely matches what you have asked for.


The available options are the following. Only specify properties for date and time fields that you would like to appear in the formatted output.


year

Use " numer i c" for a full, four-digit year or " 2- di gi t " for a two-digit abbreviation.

mont h

Use " numer i c" for a possibly short number like “1”, or " 2-
di gi t " for a numeric representation that always has two digits, like “01”. Use " l ong" for a full name like “January”, " s hor t " for an abbreviated name like “Jan”, and " nar r ow" for a highly abbreviated name like “J” that is not guaranteed to be unique.


day

Use " numer i c" for a one- or two-digit number or " 2- di gi t " for a two-digit number for the day-of-month.

weekday

Use " l ong" for a full name like “Monday”, " s hor t " for an abbreviated name like “Mon”, and " nar r ow" for a highly abbreviated name like “M” that is not guaranteed to be unique.

er a

This property specifies whether a date should be formatted with an era, such as CE or BCE. This may be useful if you are formatting dates from very long ago or if you are using a Japanese calendar. Legal values are " l ong" , " s hor t " , and " nar r ow" .

hour , mi nut e, s ec ond

These properties specify how you would like time displayed. Use " numer i c" for a one- or two-digit field or " 2- di gi t " to force single-digit numbers to be padded on the left with a 0.

t i meZone

This property specifies the desired time zone for which the date should be formatted. If omitted, the local time zone is used. Implementations always recognize “UTC” and may also recognize Internet Assigned Numbers Authority (IANA) time zone names, such as “America/Los_Angeles”.

t i meZoneName

This property specifies how the time zone should be displayed in a formatted date or time. Use " l ong" for a fully spelled-out time zone name and " s hor t " for an abbreviated or numeric time zone.

hour 12

This boolean property specifies whether or not to use 12-hour time. The default is locale dependent, but you can override it with this property.

hour Cyc l e

This property allows you to specify whether midnight is written as 0 hours, 12 hours, or 24 hours. The default is locale dependent, but you can override the default with this property. Note that hour 12 takes precedence over this property. Use the value " h11" to specify that midnight is 0 and the hour before midnight is 11pm. Use " h12" to specify that midnight is 12. Use " h23" to specify that midnight is 0 and the hour before midnight is 23. And use " h24" to specify that midnight is 24.


Here are some examples:


l et   d   =   new  Dat e( " 2020- 01- 02T13: 14: 15Z" ) ;	/ /   J anuar y   2nd,	2020, 13: 14: 15   UTC

/ /   Wi t h   no   opt i ons ,	we   get   a   bas i c   numer i c   dat e   f or mat

I nt l . Dat eTi meFor mat ( " en- US" ) . f or mat ( d)
I nt l . Dat eTi meFor mat ( " f r - FR" ) . f or mat ( d)

/ /   =>   " 1/ 2/ 2020"
/ /   =>   " 02/ 01/ 2020"


/ /   Spel l ed   out   weekday   and   mont h
l et   opt s   =   {    weekday:	" l ong" ,	mont h:	" l ong" ,	year :	" numer i c " , day:	" numer i c "   } ;
I nt l . Dat eTi meFor mat ( " en- US" ,	opt s ) . f or mat ( d)    / /   =>   " Thur s day, J anuar y   2,	2020"
I nt l . Dat eTi meFor mat ( " es - ES" ,	opt s ) . f or mat ( d)    / /   =>   " j ueves ,	2   de ener o   de   2020"

/ /   The   t i me   i n   New  Yor k,	f or   a   Fr enc h- s peaki ng   Canadi an opt s   =   {    hour :	" numer i c " ,    mi nut e:	" 2- di gi t " ,	t i meZone:
" Amer i c a/ New_Yor k"   } ;
I nt l . Dat eTi meFor mat ( " f r - CA" ,	opt s ) . f or mat ( d)    / /   =>   " 8   h   14"


Intl.DateTimeFormat can display dates using calendars other than the default Julian calendar based on the Christian era. Although some locales

may use a non-Christian calendar by default, you can always explicitly specify the calendar to use by adding - u- ca-  to the locale and following that with the name of the calendar. Possible calendar names include “buddhist”, “chinese”, “coptic”, “ethiopic”, “gregory”, “hebrew”, “indian”, “islamic”, “iso8601”, “japanese”, and “persian”. Continuing the preceding example, we can determine the year in various non-Christian calendars:

l et   opt s   =   {    year :	" numer i c " ,	er a:	" s hor t "   } ;
I nt l . Dat eTi meFor mat ( " en" ,	opt s ) . f or mat ( d)	/ /   => " 2020   AD"
I nt l . Dat eTi meFor mat ( " en- u- c a- i s o8601" ,	opt s ) . f or mat ( d)	/ /   => " 2020   AD"
I nt l . Dat eTi meFor mat ( " en- u- c a- hebr ew" ,	opt s ) . f or mat ( d)	/ /   => " 5780   AM"
I nt l . Dat eTi meFor mat ( " en- u- c a- buddhi s t " ,	opt s ) . f or mat ( d)	/ /   => " 2563   BE"
I nt l . Dat eTi meFor mat ( " en- u- c a- i s l ami c " ,	opt s ) . f or mat ( d)	/ /   => " 1441   AH"
I nt l . Dat eTi meFor mat ( " en- u- c a- per s i an" ,	opt s ) . f or mat ( d)	/ /   => " 1398   AP"
I nt l . Dat eTi meFor mat ( " en- u- c a- i ndi an" ,	opt s ) . f or mat ( d)	/ /   => " 1941   Saka"
I nt l . Dat eTi meFor mat ( " en- u- c a- c hi nes e" ,	opt s ) . f or mat ( d)	/ /   => " 36   78"
I nt l . Dat eTi meFor mat ( " en- u- c a- j apanes e" ,	opt s ) . f or mat ( d)	/ /   => " 2   Rei wa"


11.7.3 Comparing Strings

The problem of sorting strings into alphabetical order (or some more general “collation order” for nonalphabetical scripts) is more challenging than English speakers often realize. English uses a relatively small alphabet with no accented letters, and we have the benefit of a character encoding (ASCII, since incorporated into Unicode) whose numerical values perfectly match our standard string sort order. Things are not so simple in other languages. Spanish, for example treats ñ as a distinct letter

that comes after n and before o. Lithuanian alphabetizes Y before J, and Welsh treats digraphs like CH and DD as single letters with CH coming after C and DD sorting after D.


If you want to display strings to a user in an order that they will find natural, it is not enough use the s or t ( )  method on an array of strings. But if you create an Intl.Collator object, you can pass the compar e( ) method of that object to the s or t ( )  method to perform locale-appropriate sorting of the strings. Intl.Collator objects can be configured so that the compar e( )  method performs case-insensitive comparisons or even comparisons that only consider the base letter and ignore accents and other diacritics.

Like I nt l . Number For mat ( )  and I nt l . Dat eTi meFor mat ( ) , the I nt l . Col l at or ( )  constructor takes two arguments. The first specifies a locale or an array of locales, and the second is an optional object whose properties specify exactly what kind of string comparison is to be done. The supported properties are these:


us age

This property specifies how the collator object is to be used. The default value is " s or t " , but you can also specify " s ear ch" . The idea is that, when sorting strings, you typically want a collator that differentiates as many strings as possible to produce a reliable ordering. But when comparing two strings, some locales may want a less strict comparison that ignores accents, for example.

s ens i t i vi t y

This property specifies whether the collator is sensitive to letter case and accents when comparing strings. The value " bas e" causes comparisons that ignore case and accents, considering only the base

letter for each character. (Note, however, that some languages consider certain accented characters to be distinct base letters.) " accent " considers accents in comparisons but ignores case. " cas e" considers case and ignores accents. And " var i ant " performs strict comparisons that consider both case and accents. The default value for this property is " var i ant " when us age is " s or t " . If us age is
" s ear ch" , then the default sensitivity depends on the locale.

i gnor ePunc t uat i on

Set this property to t r ue to ignore spaces and punctuation when comparing strings. With this property set to t r ue, the strings “any one” and “anyone”, for example, will be considered equal.

numer i c

Set this property to t r ue if the strings you are comparing are integers or contain integers and you want them to be sorted into numerical order instead of alphabetical order. With this option set, the string “Version 9” will be sorted before “Version 10”, for example.

c as eFi r s t

This property specifies which letter case should come first. If you specify " upper " , then “A” will sort before “a”. And if you specify " l ower " , then “a” will sort before “A”. In either case, note that the upper- and lowercase variants of the same letter will be next to one another in sort order, which is different than Unicode lexicographic
ordering (the default behavior of the Array s or t ( )  method) in which all ASCII uppercase letters come before all ASCII lowercase letters. The default for this property is locale dependent, and implementations may ignore this property and not allow you to override the case sort order.


Once you have created an Intl.Collator object for the desired locale and options, you can use its compar e( )  method to compare two strings. This method returns a number. If the returned value is less than zero, then the

first string comes before the second string. If it is greater than zero, then the first string comes after the second string. And if compar e( )  returns zero, then the two strings are equal as far as this collator is concerned.

This compar e( )  method that takes two strings and returns a number less than, equal to, or greater than zero is exactly what the Array s or t ( ) method expects for its optional argument. Also, Intl.Collator automatically binds the compar e( )  method to its instance, so you can pass it directly to s or t ( )  without having to write a wrapper function and invoke it through the collator object. Here are some examples:


/ /   A  bas i c   c ompar at or   f or   s or t i ng   i n / /   Never   s or t   human- r eadabl e   s t r i ngs l i ke   t hi s :

t he   us er ' s   l oc al e.
wi t hout   pas s i ng   s omet hi ng

c ons t   c ol l at or   =   new  I nt l . Col l at or ( ) . c ompar e;
[ " a" ,	" z " ,	" A" ,	" Z" ] . s or t ( c ol l at or )	/ /   =>   [ " a" ,	" A" ,	" z " , " Z" ]

/ /   Fi l enames   of t en   i nc l ude   number s ,	s o   we   s houl d   s or t   t hos e s pec i al l y
c ons t   f i l enameOr der   =   new  I nt l . Col l at or ( undef i ned,	{    numer i c :
t r ue   } ) . c ompar e;
[ " page10" ,	" page9" ] . s or t ( f i l enameOr der )	/ /   =>   [ " page9" , " page10" ]

/ /   Fi nd   al l	s t r i ngs   t hat   l oos el y   mat c h   a   t ar get   s t r i ng c ons t   f uz z yMat c her   =   new  I nt l . Col l at or ( undef i ned,	{
s ens i t i vi t y:	" bas e" ,
i gnor ePunc t uat i on:	t r ue } ) . c ompar e;
l et   s t r i ngs   =   [ " f ood" ,	" f ool " ,	" Føø   Bar " ] ;
s t r i ngs . f i ndI ndex( s   =>   f uz z yMat c her ( s ,	" f oobar " )    ===   0)	/ /   =>   2


Some locales have more than one possible collation order. In Germany, for example, phone books use a slightly more phonetic sort order than dictionaries do. In Spain, before 1994, “ch” and “ll” were treated as separate letters, so that country now has a modern sort order and a

traditional sort order. And in China, collation order can be based on character encodings, the base radical and strokes of each character, or on the Pinyin romanization of characters. These collation variants cannot be selected through the Intl.Collator options argument, but they can be selected by adding - u- co-  to the locale string and adding the name of the desired variant. Use " de- DE- u- co- phonebk" for phone book ordering in Germany, for example, and " z h- TW- u- co- pi nyi n" for Pinyin ordering in Taiwan.

/ /   Bef or e   1994,	CH  and   L L   wer e   t r eat ed   as   s epar at e   l et t er s   i n Spai n
c ons t   moder nSpani s h   =   I nt l . Col l at or ( " es - ES" ) . c ompar e;
c ons t   t r adi t i onal Spani s h   =   I nt l . Col l at or ( " es - ES- u- c o-t r ad" ) . c ompar e;
l et   pal abr as   =   [ " l uz " ,	" l l ama" ,	" c omo" ,	" c hi c o" ] ;
pal abr as . s or t ( moder nSpani s h)	/ /   =>   [ " c hi c o" ,	" c omo" , " l l ama" ,	" l uz " ]
pal abr as . s or t ( t r adi t i onal Spani s h)    / /   =>   [ " c omo" ,	" c hi c o" ,	" l uz " , " l l ama" ]


11.8 The Console API

You’ve seen the cons ol e. l og( )  function used throughout this book: in web browsers, it prints a string in the “Console” tab of the browser’s developer tools pane, which can be very helpful when debugging. In Node, cons ol e. l og( )  is a general-purpose output function and prints its arguments to the process’s stdout stream, where it typically appears to the user in a terminal window as program output.

The Console API defines a number of useful functions in addition to cons ol e. l og( ) . The API is not part of any ECMAScript standard, but it is supported by browsers and by Node and has been formally written up and standardized at https://console.spec.whatwg.org.

The Console API defines the following functions:


c ons ol e. l og( )

This is the most well-known of the console functions. It converts its arguments to strings and outputs them to the console. It includes spaces between the arguments and starts a new line after outputting all arguments.

c ons ol e. debug( ) , c ons ol e. i nf o( ) , c ons ol e. war n( ) , c ons ol e. er r or ( )

These functions are almost identical to cons ol e. l og( ) . In Node, cons ol e. er r or ( )  sends its output to the stderr stream rather than the stdout stream, but the other functions are aliases of
cons ol e. l og( ) . In browsers, output messages generated by each of these functions may be prefixed by an icon that indicates its level or severity, and the developer console may also allow developers to filter console messages by level.

c ons ol e. as s er t ( )

If the first argument is truthy (i.e., if the assertion passes), then this function does nothing. But if the first argument is f al s e or another falsy value, then the remaining arguments are printed as if they had been passed to cons ol e. er r or ( )  with an “Assertion failed” prefix. Note that, unlike typical as s er t ( )  functions,
cons ol e. as s er t ( )  does not throw an exception when an assertion fails.

c ons ol e. c l ear ( )

This function clears the console when that is possible. This works in browsers and in Node when Node is displaying its output to a terminal. If Node’s output has been redirected to a file or a pipe, however, then calling this function has no effect.

c ons ol e. t abl e( )

This function is a remarkably powerful but little-known feature for producing tabular output, and it is particularly useful in Node programs that need to produce output that summarizes data.
cons ol e. t abl e( )  attempts to display its argument in tabular form (although, if it can’t do that, it displays it using regular
cons ol e. l og( )  formatting). This works best when the argument is a relatively short array of objects, and all of the objects in the array have the same (relatively small) set of properties. In this case, each object in the array is formatted as a row of the table, and each property is a column of the table. You can also pass an array of property names as an optional second argument to specify the desired set of columns. If you pass an object instead of an array of objects, then the output will be a table with one column for property names and one column for property values. Or, if those property values are themselves objects, their property names will become columns in the table.

c ons ol e. t r ac e( )

This function logs its arguments like cons ol e. l og( )  does, and, in addition, follows its output with a stack trace. In Node, the output goes to stderr instead of stdout.

c ons ol e. c ount ( )

This function takes a string argument and logs that string, followed by the number of times it has been called with that string. This can be useful when debugging an event handler, for example, if you need to keep track of how many times the event handler has been triggered.

c ons ol e. c ount Res et ( )

This function takes a string argument and resets the counter for that string.

c ons ol e. gr oup( )

This function prints its arguments to the console as if they had been passed to cons ol e. l og( ) , then sets the internal state of the console so that all subsequent console messages (until the next

cons ol e. gr oupEnd( )  call) will be indented relative to the message that it just printed. This allows a group of related messages to be visually grouped with indentation. In web browsers, the developer console typically allows grouped messages to be collapsed and expanded as a group. The arguments to cons ol e. gr oup( )  are typically used to provide an explanatory name for the group.

c ons ol e. gr oupCol l aps ed( )

This function works like cons ol e. gr oup( )  except that in web browsers, the group will be “collapsed” by default and the messages it contains will be hidden unless the user clicks to expand the group. In Node, this function is a synonym for cons ol e. gr oup( ) .

c ons ol e. gr oupEnd( )

This function takes no arguments. It produces no output of its own but ends the indentation and grouping caused by the most recent call to cons ol e. gr oup( )  or cons ol e. gr oupCol l aps ed( ) .

c ons ol e. t i me( )

This function takes a single string argument, makes a note of the time it was called with that string, and produces no output.

c ons ol e. t i meLog( )

This function takes a string as its first argument. If that string had previously been passed to cons ol e. t i me( ) , then it prints that string followed by the elapsed time since the cons ol e. t i me( )  call. If there are any additional arguments to cons ol e. t i meLog( ) , they are printed as if they had been passed to cons ol e. l og( ) .

c ons ol e. t i meEnd( )

This function takes a single string argument. If that argument had previously been passed to cons ol e. t i me( ) , then it prints that argument and the elapsed time. After calling cons ol e. t i meEnd( ) , it is no longer legal to call cons ol e. t i meLog( )  without first

calling cons ol e. t i me( )  again.


11.8.1 Formatted Output with Console

Console functions that print their arguments like cons ol e. l og( )  have a little-known feature: if the first argument is a string that includes %s , %i , %d, %f , %o, %O, or %c, then this first argument is treated as format string,6 and the values of subsequent arguments are substituted into the string in place of the two-character %sequences.


The meanings of the sequences are as follows:


%s

The argument is converted to a string.

%i  and %d

The argument is converted to a number and then truncated to an integer.

%f

The argument is converted to a number

%o and %O

The argument is treated as an object, and property names and values are displayed. (In web browsers, this display is typically interactive, and users can expand and collapse properties to explore a nested data structure.) %o and %O both display object details. The uppercase variant uses an implementation-dependent output format that is judged to be most useful for software developers.

%c

In web browsers, the argument is interpreted as a string of CSS styles

and used to style any text that follows (until the next %c sequence or the end of the string). In Node, the %c sequence and its corresponding argument are simply ignored.


Note that it is not often necessary to use a format string with the console functions: it is usually easy to obtain suitable output by simply passing one or more values (including objects) to the function and allowing the implementation to display them in a useful way. As an example, note that, if you pass an Error object to cons ol e. l og( ) , it is automatically printed along with its stack trace.


11.9 URL APIs

Since JavaScript is so commonly used in web browsers and web servers, it is common for JavaScript code to need to manipulate URLs. The URL class parses URLs and also allows modification (adding search parameters or altering paths, for example) of existing URLs. It also properly handles the complicated topic of escaping and unescaping the various components of a URL.


The URL class is not part of any ECMAScript standard, but it works in Node and all internet browsers other than Internet Explorer. It is standardized at https://url.spec.whatwg.org.


Create a URL object with the URL( )  constructor, passing an absolute URL string as the argument. Or pass a relative URL as the first argument and the absolute URL that it is relative to as the second argument. Once you have created the URL object, its various properties allow you to query unescaped versions of the various parts of the URL:

l et   ur l	=   new  URL ( " ht t ps : / / exampl e. c om: 8000/ pat h/ name?

q=t er m#f r agment " ) ;
ur l . hr ef	/ /   =>   " ht t ps : / / exampl e. c om: 8000/ pat h/ name? q=t er m#f r agment "

ur l . or i gi n ur l . pr ot oc ol ur l . hos t
ur l . hos t name ur l . por t
ur l . pat hname ur l . s ear c h
ur l . has h

/ /   =>   " ht t ps : / / exampl e. c om: 8000" / /   =>   " ht t ps : "
/ /   =>   " exampl e. c om: 8000" / /   =>   " exampl e. c om"
/ /   =>   " 8000"
/ /   =>   " / pat h/ name" / /   =>   " ?q=t er m"
/ /   =>   " #f r agment "



Although it is not commonly used, URLs can include a username or a username and password, and the URL class can parse these URL components, too:

l et   ur l	=   new  URL ( " f t p: / / admi n: 1337! @f t p. exampl e. c om/ " ) ;

ur l . hr ef
ur l . or i gi n
ur l . us er name
ur l . pas s wor d

/ /   =>   " f t p: / / admi n: 1337! @f t p. exampl e. c om/ " / /   =>   " f t p: / / f t p. exampl e. c om"
/ /   =>   " admi n"
/ /   =>   " 1337! "



The or i gi n property here is a simple combination of the URL protocol and host (including the port if one is specified). As such, it is a read-only property. But each of the other properties demonstrated in the previous example is read/write: you can set any of these properties to set the corresponding part of the URL:

l et   ur l	=   new  URL ( " ht t ps : / / exampl e. c om" ) ;	/ /   St ar t   wi t h   our s er ver
ur l . pat hname   =   " api / s ear c h" ;	/ /   Add   a   pat h   t o   an API	endpoi nt
ur l . s ear c h   =   " q=t es t " ;	/ /   Add   a   quer y par amet er
ur l . t oSt r i ng( )	/ /   =>   " ht t ps : / / exampl e. c om/ api / s ear c h?q=t es t "


One of the important features of the URL class is that it correctly adds

punctuation and escapes special characters in URLs when that is needed:


l et   ur l	=   new  URL ( " ht t ps : / / exampl e. c om" ) ; ur l . pat hname   =   " pat h   wi t h   s pac es " ;
ur l . s ear c h   =   " q=f oo#bar " ;

ur l . pat hname ur l . s ear c h
ur l . hr ef
q=f oo%23bar "

/ /   =>   " / pat h%20wi t h%20s pac es " / /   =>   " ?q=f oo%23bar "
/ /   =>   " ht t ps : / / exampl e. c om/ pat h%20wi t h%20s pac es ?



The hr ef  property in these examples is a special one: reading hr ef  is equivalent to calling t oSt r i ng( ) : it reassembles all parts of the URL into the canonical string form of the URL. And setting hr ef  to a new string reruns the URL parser on the new string as if you had called the URL( )  constructor again.


In the previous examples, we’ve been using the s ear ch property to refer to the entire query portion of a URL, which consists of the characters from a question mark to the end of the URL or to the first hash character. Sometimes, it is sufficient to just treat this as a single URL property. Often, however, HTTP requests encode the values of multiple form fields or multiple API parameters into the query portion of a URL using the appl i cat i on/ x- www- f or m- ur l encoded format. In this format, the query portion of the URL is a question mark followed by one or more name/value pairs, which are separated from one another by ampersands. The same name can appear more than once, resulting in a named search parameter with more than one value.

If you want to encode these kinds of name/value pairs into the query portion of a URL, then the s ear chPar ams  property will be more useful than the s ear ch property. The s ear ch property is a read/write string that lets you get and set the entire query portion of the URL. The

s ear chPar ams  property is a read-only reference to a URLSearchParams object, which has an API for getting, setting, adding, deleting, and sorting the parameters encoded into the query portion of the URL:

l et   ur l	=   new  URL ( " ht t ps : / / exampl e. c om/ s ear c h" ) ;
ur l . s ear c h	/ /   =>   " " :	no   quer y   yet
ur l . s ear c hPar ams . append( " q" ,	" t er m" ) ;	/ /   Add   a   s ear c h   par amet er ur l . s ear c h                                                                            / /   =>   " ?q=t er m"
ur l . s ear c hPar ams . s et ( " q" ,	" x" ) ;	/ /   Change   t he   val ue   of t hi s   par amet er
ur l . s ear c h	/ /   =>   " ?q=x"
ur l . s ear c hPar ams . get ( " q" )	/ /   =>   " x" :	quer y   t he par amet er   val ue
ur l . s ear c hPar ams . has ( " q" )	/ /   =>   t r ue:	t her e   i s   a   q par amet er
ur l . s ear c hPar ams . has ( " p" )	/ /   =>   f al s e:	t her e   i s   no   p par amet er
ur l . s ear c hPar ams . append( " opt s " ,	" 1" ) ;	/ /   Add   anot her   s ear c h par amet er
ur l . s ear c h	/ /   =>   " ?q=x&opt s =1"
ur l . s ear c hPar ams . append( " opt s " ,	" &" ) ;	/ /   Add   anot her   val ue   f or s ame   name
ur l . s ear c h	/ /   =>   " ? q=x&opt s =1&opt s =%26" :    not e   es c ape
ur l . s ear c hPar ams . get ( " opt s " )	/ /   =>   " 1" :	t he   f i r s t   val ue ur l . s ear c hPar ams . get Al l ( " opt s " )	/ /   =>   [ " 1" ,    " &" ] :	al l
val ues
ur l . s ear c hPar ams . s or t ( ) ;	/ /   Put   par ams   i n al phabet i c al	or der
ur l . s ear c h	/ /   =>   " ? opt s =1&opt s =%26&q=x"
ur l . s ear c hPar ams . s et ( " opt s " ,	" y" ) ;	/ /   Change   t he   opt s   par am ur l . s ear c h                                                                            / /   =>   " ?opt s =y&q=x"
/ /   s ear c hPar ams   i s   i t er abl e
[ . . . ur l . s ear c hPar ams ]	/ /   =>   [ [ " opt s " ,	" y" ] , [ " q" ,	" x" ] ]
ur l . s ear c hPar ams . del et e( " opt s " ) ;	/ /   Del et e   t he   opt s   par am

ur l . s ear c h ur l . hr ef
" ht t ps : / / exampl e. c om/ s ear c h?q=x"

/ /   =>   " ?q=x"
/ /   =>

The value of the s ear chPar ams  property is a URLSearchParams object. If you want to encode URL parameters into a query string, you can create a URLSearchParams object, append parameters, then convert it to a string and set it on the s ear ch property of a URL:


l et   ur l	=   new  URL ( " ht t p: / / exampl e. c om" ) ; l et   par ams   =   new  URL Sear c hPar ams ( ) ;
par ams . append( " q" ,	" t er m" ) ;

par ams . append( " opt s " ,
par ams . t oSt r i ng( )

" exac t " ) ;
/ /   =>   " q=t er m&opt s =exac t "

ur l . s ear c h   =   par ams ;
ur l . hr ef	/ /   =>   " ht t p: / / exampl e. c om/ ? q=t er m&opt s =exac t "


11.9.1 Legacy URL Functions

Prior to the definition of the URL API described previously, there have been multiple attempts to support URL escaping and unescaping in the core JavaScript language. The first attempt was the globally defined
es cape( )  and unes cape( )  functions, which are now deprecated but still widely implemented. They should not be used.

When es cape( )  and unes cape( )  were deprecated, ECMAScript introduced two pairs of alternative global functions:


enc odeURI ( )  and dec odeURI ( )

encodeURI ( )  takes a string as its argument and returns a new string in which non-ASCII characters plus certain ASCII characters (such as space) are escaped. decodeURI ( )  reverses the process. Characters that need to be escaped are first converted to their UTF-8 encoding, then each byte of that encoding is replaced with a %xx escape sequence, where xx is two hexadecimal digits. Because
encodeURI ( )  is intended for encoding entire URLs, it does not

escape URL separator characters such as / , ?, and #. But this means that encodeURI ( )  cannot work correctly for URLs that have those characters within their various components.

enc odeURI Component ( )  and dec odeURI Component ( )

This pair of functions works just like encodeURI ( )  and decodeURI ( )  except that they are intended to escape individual components of a URI, so they also escape characters like / , ?, and # that are used to separate those components. These are the most useful of the legacy URL functions, but be aware that
encodeURI Component ( )  will escape /  characters in a path name that you probably do not want escaped. And it will convert spaces in a query parameter to %20, even though spaces are supposed to be escaped with a + in that portion of a URL.


The fundamental problem with all of these legacy functions is that they seek to apply a single encoding scheme to all parts of a URL when the fact is that different portions of a URL use different encodings. If you want a properly formatted and encoded URL, the solution is simply to use the URL class for all URL manipulation you do.


11.10 Timers

Since the earliest days of JavaScript, web browsers have defined two functions—s et Ti meout ( )  and s et I nt er val ( ) —that allow programs to ask the browser to invoke a function after a specified amount of time has elapsed or to invoke the function repeatedly at a specified interval. These functions have never been standardized as part of the core language, but they work in all browsers and in Node and are a de facto part of the JavaScript standard library.

The first argument to s et Ti meout ( )  is a function, and the second

argument is a number that specifies how many milliseconds should elapse before the function is invoked. After the specified amount of time (and maybe a little longer if the system is busy), the function will be invoked with no arguments. Here, for example, are three s et Ti meout ( )  calls that print console messages after one second, two seconds, and three seconds:

s et Ti meout ( ( )    =>   {    c ons ol e. l og( " Ready. . . " ) ;	} ,	1000) ; s et Ti meout ( ( )    =>   {    c ons ol e. l og( " s et . . . " ) ;	} ,    2000) ;
s et Ti meout ( ( )    =>   {    c ons ol e. l og( " go! " ) ;	} ,	3000) ;


Note that s et Ti meout ( )  does not wait for the time to elapse before returning. All three lines of code in this example run almost instantly, but then nothing happens until 1,000 milliseconds elapse.

If you omit the second argument to s et Ti meout ( ) , it defaults to 0. That does not mean, however, that the function you specify is invoked immediately. Instead, the function is registered to be called “as soon as possible.” If a browser is particularly busy handling user input or other events, it may take 10 milliseconds or more before the function is invoked.

s et Ti meout ( )  registers a function to be invoked once. Sometimes, that function will itself call s et Ti meout ( )  to schedule another invocation at a future time. If you want to invoke a function repeatedly, however, it is often simpler to use s et I nt er val ( ) . s et I nt er val ( )  takes the same two arguments as s et Ti meout ( )  but invokes the function repeatedly every time the specified number of milliseconds (approximately) have elapsed.

Both s et Ti meout ( )  and s et I nt er val ( )  return a value. If you save this value in a variable, you can then use it later to cancel the execution of

the function by passing it to cl ear Ti meout ( )  or
cl ear I nt er val ( ) . The returned value is typically a number in web browsers and is an object in Node. The actual type doesn’t matter, and you should treat it as an opaque value. The only thing you can do with this value is pass it to cl ear Ti meout ( )  to cancel the execution of a function registered with s et Ti meout ( )  (assuming it hasn’t been invoked yet) or to stop the repeating execution of a function registered with s et I nt er val ( ) .


Here is an example that demonstrates the use of s et Ti meout ( ) ,
s et I nt er val ( ) , and cl ear I nt er val ( )  to display a simple digital clock with the Console API:

/ /   Onc e   a   s ec ond:	c l ear   t he   c ons ol e   and   pr i nt   t he   c ur r ent   t i me l et   c l oc k   =   s et I nt er val ( ( )    =>   {
c ons ol e. c l ear ( ) ;
c ons ol e. l og( new  Dat e( ) . t oL oc al eTi meSt r i ng( ) ) ; } ,	1000) ;

/ /   Af t er   10   s ec onds :    s t op   t he   r epeat i ng   c ode   above. s et Ti meout ( ( )    =>   {    c l ear I nt er val ( c l oc k) ;    } ,    10000) ;


We’ll see s et Ti meout ( )  and s et I nt er val ( )  again when we cover asynchronous programming in Chapter 13.


11.11 Summary

Learning a programming language is not just about mastering the grammar. It is equally important to study the standard library so that you are familiar with all the tools that are shipped with the language. This chapter has documented JavaScript’s standard library, which includes:

Important data structures, such as Set, Map, and typed arrays.

The Date and URL classes for working with dates and URLs.

JavaScript’s regular expression grammar and its RegExp class for textual pattern matching.

JavaScript’s internationalization library for formatting dates, time, and numbers and for sorting strings.

The J SON object for serializing and deserializing simple data structures and the cons ol e object for logging messages.





1



2


3



4

5


6

Not everything documented here is defined by the JavaScript language specification: some of the classes and functions documented here were first implemented in web browsers and then adopted by Node, making them de facto members of the JavaScript standard library.

This predictable iteration order is another thing about JavaScript sets that Python programmers may find surprising.

Typed arrays were first introduced to client-side JavaScript when web browsers added support for WebGL graphics. What is new in ES6 is that they have been elevated to a core language feature.

Except within a character class (square brackets), where \ b matches the backspace character.

Parsing URLs with regular expressions is not a good idea. See §11.9 for a more robust URL parser.

C programmers will recognize many of these character sequences from the pr i nt f ( ) function.



Chapter 12. Iterators and Generators




Iterable objects and their associated iterators are a feature of ES6 that we’ve seen several times throughout this book. Arrays (including TypedArrays) are iterable, as are strings and Set and Map objects. This means that the contents of these data structures can be iterated—looped over—with the f or / of  loop, as we saw in §5.4.4:


l et   s um =   0;
f or ( l et   i	of    [ 1, 2, 3] )    {    / /   L oop   onc e   f or   eac h   of    t hes e   val ues s um +=   i ;
}
s um	/ /   =>   6


Iterators can also be used with the . . .  operator to expand or “spread” an iterable object into an array initializer or function invocation, as we saw in §7.1.2:

l et   c har s   =   [ . . . " abc d" ] ;	/ /   c har s   ==   [ " a" ,	" b" ,	" c " ,	" d" ] l et   dat a   =   [ 1,	2,	3,	4,    5] ;
Mat h. max( . . . dat a)	/ /   =>   5


Iterators can be used with destructuring assignment:


l et   pur pl eHaz e   =   Ui nt 8Ar r ay. of ( 255,	0,	255,	128) ; l et   [ r ,	g,	b,	a]    =   pur pl eHaz e;	/ /   a   ==   128


When you iterate a Map object, the returned values are [ key,	val ue] pairs, which work well with destructuring assignment in a f or / of  loop:

l et   m =   new  Map( [ [ " one" ,	1] ,	[ " t wo" ,	2] ] ) ;
f or ( l et   [ k, v]    of    m)    c ons ol e. l og( k,	v) ;	/ /   L ogs   ' one   1'	and   ' t wo 2'


If you want to iterate just the keys or just the values rather than the pairs, you can use the keys ( )  and val ues ( )  methods:



[ . . . m]
i t er at i on
[ . . . m. ent r i es ( ) ]

/ /   =>   [ [ " one" ,	1] ,

/ /   =>   [ [ " one" ,	1] ,

[ " t wo" ,

[ " t wo" ,

2] ] :	def aul t

2] ] :	ent r i es ( )

met hod   i s   t he   s ame
[ . . . m. keys ( ) ]	/ /   =>   [ " one" ,	" t wo" ] :	keys ( )    met hod   i t er at es j us t   map   keys
[ . . . m. val ues ( ) ]	/ /   =>   [ 1,	2] :	val ues ( )    met hod   i t er at es   j us t map   val ues


Finally, a number of built-in functions and constructors that are commonly used with Array objects are actually written (in ES6 and later) to accept arbitrary iterators instead. The Set ( )  constructor is one such API:

/ /   St r i ngs   ar e   i t er abl e,	s o   t he   t wo   s et s   ar e   t he   s ame: new  Set ( " abc " )    / /   =>   new  Set ( [ " a" ,	" b" ,	" c " ] )


This chapter explains how iterators work and demonstrates how to create your own data structures that are iterable. After explaining basic iterators, this chapter covers generators, a powerful new feature of ES6 that is primarily used as a particularly easy way to create iterators.


12.1 How Iterators Work

The f or / of  loop and spread operator work seamlessly with iterable objects, but it is worth understanding what is actually happening to make the iteration work. There are three separate types that you need to understand to understand iteration in JavaScript. First, there are the iterable objects: these are types like Array, Set, and Map that can be

iterated. Second, there is the iterator object itself, which performs the iteration. And third, there is the iteration result object that holds the result of each step of the iteration.


An iterable object is any object with a special iterator method that returns an iterator object. An iterator is any object with a next ( )  method that returns an iteration result object. And an iteration result object is an object with properties named val ue and done. To iterate an iterable object, you first call its iterator method to get an iterator object. Then, you call the next ( )  method of the iterator object repeatedly until the returned value has its done property set to t r ue. The tricky thing about this is that the iterator method of an iterable object does not have a conventional name but uses the Symbol Symbol . i t er at or  as its name. So a simple
f or / of  loop over an iterable object i t er abl e could also be written the hard way, like this:


l et   i t er abl e
l et   i t er at or

=   [ 99] ;
=   i t er abl e[ Symbol . i t er at or ] ( ) ;

f or ( l et   r es ul t   =   i t er at or . next ( ) ;	! r es ul t . done;	r es ul t   = i t er at or . next ( ) )    {
c ons ol e. l og( r es ul t . val ue)	/ /   r es ul t . val ue   ==   99 }


The iterator object of the built-in iterable datatypes is itself iterable. (That is, it has a method named Symbol . i t er at or  that just returns itself.) This is occasionally useful in code like the following when you want to iterate though a “partially used” iterator:


l et   l i s t
l et   i t er

=   [ 1, 2, 3, 4, 5] ;
=   l i s t [ Symbol . i t er at or ] ( ) ;



l et   head   =
l et   t ai l	=

i t er . next ( ) . val ue;
[ . . . i t er ] ;

/ /   head   ==
/ /   t ai l	==

1
[ 2, 3, 4, 5]

12.2 Implementing Iterable Objects

Iterable objects are so useful in ES6 that you should consider making your own datatypes iterable whenever they represent something that can be iterated. The Range classes shown in Examples 9-2 and 9-3 in Chapter 9 were iterable. Those classes used generator functions to make themselves iterable. We’ll document generators later in this chapter, but first, we will implement the Range class one more time, making it iterable without relying on a generator.


In order to make a class iterable, you must implement a method whose name is the Symbol Symbol . i t er at or . That method must return an iterator object that has a next ( )  method. And the next ( )  method must return an iteration result object that has a val ue property and/or a boolean done property. Example 12-1 implements an iterable Range class and demonstrates how to create iterable, iterator, and iteration result objects.


Example 12-1. An iterable numeric Range class
/ *
*   A  Range   obj ec t   r epr es ent s   a   r ange   of    number s   { x: t o}
*   Range   def i nes   a   has ( )    met hod   f or   t es t i ng   whet her i s   a   member
*   of    t he   r ange.	Range   i s   i t er abl e   and   i t er at es   al l wi t hi n   t he   r ange.
*/




f r om <=   x   <=

a   gi ven   number

i nt eger s

c l as s   Range   {
c ons t r uc t or   ( f r om,	t o)    { t hi s . f r om =   f r om;
t hi s . t o   =   t o; }

/ /   Make   a   Range   ac t   l i ke   a   Set   of    number s
has ( x)    {    r et ur n   t ypeof    x   ===   " number "   &&  t hi s . f r om <=   x   &&  x <=   t hi s . t o;	}


/ /   Ret ur n   s t r i ng   r epr es ent at i on   of    t he   r ange   us i ng   s et not at i on
t oSt r i ng( )    {    r et ur n   ` {    x   |   ${ t hi s . f r om}    ≤   x   ≤   ${ t hi s . t o}    } ` ;	}


/ /   Make / /   Not e
a   s t r i ng.

a   Range   i t er abl e t hat   t he   name   of

by   r et ur ni ng   an   i t er at or t hi s   met hod   i s   a   s pec i al

obj ec t .
s ymbol ,	not

[ Symbol . i t er at or ] ( )    {

/ /   Eac h   i t er at or i ndependent l y   of
/ /   ot her s .	So   we l oc at i on   i n   t he
/ /   i t er at i on.	We

i ns t anc e   mus t   i t er at e   t he   r ange

need   a   s t at e   var i abl e   t o   t r ac k   our

s t ar t   at   t he   f i r s t   i nt eger   >=   f r om.

l et   next   =   Mat h. c ei l ( t hi s . f r om) ;	/ /   Thi s   i s   t he   next val ue   we   r et ur n
l et   l as t   =   t hi s . t o;	/ /   We   won' t   r et ur n anyt hi ng   >   t hi s
r et ur n   {	/ /   Thi s   i s   t he   i t er at or

obj ec t

obj ec t .


/ /   Thi s   next ( )    met hod   i s   what

/ /   I t   mus t   r et ur n   an   i t er at or


makes   t hi s   an   i t er at or

r es ul t   obj ec t .

next ( )    {
r et ur n   ( next   <=   l as t )	/ /   I f    we   haven' t   r et ur ned l as t   val ue   yet
?   {    val ue:	next ++   }    / /   r et ur n   next   val ue   and i nc r ement   i t
:	{    done:	t r ue   } ;	/ /   ot her wi s e   i ndi c at e   t hat we' r e   done.
} ,

/ /   As   a   c onveni enc e,	we   make   t he   i t er at or   i t s el f i t er abl e.
[ Symbol . i t er at or ] ( )    {    r et ur n   t hi s ;	}
} ; }
}

f or ( l et   x   of    new  Range( 1, 10) )    c ons ol e. l og( x) ;	/ /   L ogs   number s   1   t o 10
[ . . . new  Range( - 2, 2) ]	/ /   =>   [ - 2,	- 1,	0,	1, 2]

In addition to making your classes iterable, it can be quite useful to define

functions that return iterable values. Consider these iterable-based alternatives to the map( )  and f i l t er ( )  methods of JavaScript arrays:

/ /   Ret ur n   an   i t er abl e   obj ec t   t hat   i t er at es   t he   r es ul t   of appl yi ng   f ( )
/ /   t o   eac h   val ue   f r om t he   s our c e   i t er abl e f unc t i on   map( i t er abl e,	f )    {
l et   i t er at or   =   i t er abl e[ Symbol . i t er at or ] ( ) ;
r et ur n   {	/ /   Thi s   obj ec t   i s   bot h   i t er at or   and   i t er abl e [ Symbol . i t er at or ] ( )    {    r et ur n   t hi s ;	} ,
next ( )    {
l et   v   =   i t er at or . next ( ) ; i f    ( v. done)    {
r et ur n   v; }    el s e   {
r et ur n   {    val ue:	f ( v. val ue)    } ; }
} } ;
}

/ /   Map   a   r ange   of    i nt eger s   t o   t hei r   s quar es   and   c onver t   t o   an ar r ay
[ . . . map( new  Range( 1, 4) ,	x   =>   x*x) ]	/ /   =>   [ 1,	4,	9,	16]


/ /   Ret ur n   an i t er abl e,
/ /   i t er at i ng t r ue

i t er abl e   obj ec t   t hat   f i l t er s   t he   s pec i f i ed

onl y   t hos e   el ement s   f or   whi c h   t he   pr edi c at e   r et ur ns

f unc t i on   f i l t er ( i t er abl e,	pr edi c at e)    {
l et   i t er at or   =   i t er abl e[ Symbol . i t er at or ] ( ) ;
r et ur n   {    / /   Thi s   obj ec t   i s   bot h   i t er at or   and   i t er abl e [ Symbol . i t er at or ] ( )    {    r et ur n   t hi s ;	} ,
next ( )    {

f or ( ; ; )
l et

{
v   =   i t er at or . next ( ) ;

i f    ( v. done   ||   pr edi c at e( v. val ue) )    { r et ur n   v;
} }
} } ;

}

/ /   Fi l t er   a   r ange   s o   we' r e   l ef t   wi t h   onl y   even   number s [ . . . f i l t er ( new  Range( 1, 10) ,	x   =>   x   %  2   ===   0) ]	/ /   => [ 2, 4, 6, 8, 10]


One key feature of iterable objects and iterators is that they are inherently lazy: when computation is required to compute the next value, that computation can be deferred until the value is actually needed. Suppose, for example, that you have a very long string of text that you want to tokenize into space-separated words. You could simply use the s pl i t ( ) method of your string, but if you do this, then the entire string has to be processed before you can use even the first word. And you end up allocating lots of memory for the returned array and all of the strings within it. Here is a function that allows you to lazily iterate the words of a string without keeping them all in memory at once (in ES2020, this function would be much easier to implement using the iterator-returning mat chAl l ( )  method described in §11.3.2):


f unc t i on   wor ds ( s )    {
var   r   =   / \ s +|$/ g;	/ /   Mat c h   one   or   mor e s pac es   or   end
r . l as t I ndex   =   s . mat c h( / [ ^   ] / ) . i ndex;	/ /   St ar t   mat c hi ng   at f i r s t   nons pac e
r et ur n   {	/ /   Ret ur n   an   i t er abl e i t er at or   obj ec t
[ Symbol . i t er at or ] ( )    {	/ /   Thi s   makes   us i t er abl e
r et ur n   t hi s ; } ,
next ( )    {	/ /   Thi s   makes   us   an i t er at or
l et   s t ar t   =   r . l as t I ndex;	/ /   Res ume   wher e   t he l as t   mat c h   ended
i f    ( s t ar t   <   s . l engt h)    {	/ /   I f    we' r e   not   done
l et   mat c h   =   r . exec ( s ) ;	/ /   Mat c h   t he   next   wor d boundar y
i f    ( mat c h)    {	/ /   I f    we   f ound   one,

r et ur n   t he   wor d
r et ur n   {    val ue:	s . s ubs t r i ng( s t ar t , mat c h. i ndex)    } ;
}




we' r e   done }

}
r et ur n   {    done:	t r ue   } ;	/ /   Ot her wi s e,	s ay   t hat

} ; }

[ . . . wor ds ( "   abc   def	ghi !   " ) ]    / /   =>   [ " abc " ,	" def " ,	" ghi ! " ]


12.2.1 “Closing” an Iterator: The Return Method

Imagine a (server-side) JavaScript variant of the wor ds ( )  iterator that, instead of taking a source string as its argument, takes the name of a file, opens the file, reads lines from it, and iterates the words from those lines. In most operating systems, programs that open files to read from them need to remember to close those files when they are done reading, so this hypothetical iterator would be sure to close the file after the next ( ) method returns the last word in it.

But iterators don’t always run all the way to the end: a f or / of  loop might be terminated with a br eak or r et ur n or by an exception. Similarly, when an iterator is used with destructuring assignment, the next ( )  method is only called enough times to obtain values for each of the specified variables. The iterator may have many more values it could return, but they will never be requested.

If our hypothetical words-in-a-file iterator never runs all the way to the end, it still needs to close the file it opened. For this reason, iterator objects may implement a r et ur n( )  method to go along with the next ( )  method. If iteration stops before next ( )  has returned an

iteration result with the done property set to t r ue (most commonly because you left a f or / of  loop early via a br eak statement), then the interpreter will check to see if the iterator object has a r et ur n( ) method. If this method exists, the interpreter will invoke it with no arguments, giving the iterator the chance to close files, release memory,
and otherwise clean up after itself. The r et ur n( )  method must return an iterator result object. The properties of the object are ignored, but it is an error to return a non-object value.

The f or / of  loop and the spread operator are really useful features of JavaScript, so when you are creating APIs, it is a good idea to use them when possible. But having to work with an iterable object, its iterator object, and the iterator’s result objects makes the process somewhat complicated. Fortunately, generators can dramatically simplify the creation of custom iterators, as we’ll see in the rest of this chapter.


12.3 Generators

A generator is a kind of iterator defined with powerful new ES6 syntax; it’s particularly useful when the values to be iterated are not the elements of a data structure, but the result of a computation.


To create a generator, you must first define a generator function. A generator function is syntactically like a regular JavaScript function but is defined with the keyword f unct i on* rather than f unct i on. (Technically, this is not a new keyword, just a * after the keyword
f unct i on and before the function name.) When you invoke a generator function, it does not actually execute the function body, but instead returns a generator object. This generator object is an iterator. Calling its next ( ) method causes the body of the generator function to run from the start (or

whatever its current position is) until it reaches a yi el d statement.
yi el d is new in ES6 and is something like a r et ur n statement. The value of the yi el d statement becomes the value returned by the next ( ) call on the iterator. An example makes this clearer:

/ /   A  gener at or   f unc t i on   t hat   yi el ds   t he   s et   of    one   di gi t   ( bas e-10)    pr i mes .
f unc t i on*   oneDi gi t Pr i mes ( )    {    / /   I nvoki ng   t hi s   f unc t i on   does   not r un   t he   c ode
yi el d   2;	/ /   but   j us t   r et ur ns   a   gener at or obj ec t .	Cal l i ng
yi el d   3;	/ /   t he   next ( )    met hod   of    t hat gener at or   r uns
yi el d   5;	/ /   t he   c ode   unt i l	a   yi el d   s t at ement pr ovi des
yi el d   7;	/ /   t he   r et ur n   val ue   f or   t he   next ( ) met hod.
}

/ /   When   we   i nvoke   t he   gener at or   f unc t i on,	we   get   a   gener at or l et   pr i mes   =   oneDi gi t Pr i mes ( ) ;

/ /   A  gener at or   i s   an   i t er at or   obj ec t   t hat   i t er at es   t he   yi el ded val ues

pr i mes . next ( ) . val ue pr i mes . next ( ) . val ue pr i mes . next ( ) . val ue pr i mes . next ( ) . val ue
pr i mes . next ( ) . done

/ /   =>   2 / /   =>   3 / /   =>   5 / /   =>   7
/ /   =>   t r ue


/ /   Gener at or s   have   a   Symbol . i t er at or   met hod   t o   make   t hem i t er abl e
pr i mes [ Symbol . i t er at or ] ( )	/ /   =>   pr i mes

/ /   We   c an   us e   gener at or s   l i ke   ot her   i t er abl e   t ypes [ . . . oneDi gi t Pr i mes ( ) ]	/ /   =>   [ 2, 3, 5, 7]
l et   s um =   0;
f or ( l et   pr i me   of    oneDi gi t Pr i mes ( ) )    s um +=   pr i me; s um	/ /   =>   17


In this example, we used a f unct i on* statement to define a generator.

Like regular functions, however, we can also define generators in expression form. Once again, we just put an asterisk after the f unct i on keyword:

c ons t   s eq   =   f unc t i on*( f r om, t o)    {
f or ( l et   i	=   f r om;	i	<=   t o;	i ++)    yi el d   i ; } ;
[ . . . s eq( 3, 5) ]	/ /   =>   [ 3,	4,	5]


In classes and object literals, we can use shorthand notation to omit the f unct i on keyword entirely when we define methods. To define a generator in this context, we simply use an asterisk before the method name where the f unct i on keyword would have been, had we used it:


l et   o   =   {
x:	1,	y:	2,	z :	3,
/ /   A  gener at or   t hat   yi el ds   eac h   of    t he   keys   of    t hi s   obj ec t *g( )    {
f or ( l et   key   of    Obj ec t . keys ( t hi s ) )    { yi el d   key;
} }
} ;
[ . . . o. g( ) ]    / /   =>   [ " x" ,	" y" ,	" z " ,	" g" ]


Note that there is no way to write a generator function using arrow function syntax.


Generators often make it particularly easy to define iterable classes. We can replace the [ Symbol . i t er at or ] ( )  method show in Example 12-1 with a much shorter *[ Symbol . i t er at or &r br ack; ( )  generator function that looks like this:

*[ Symbol . i t er at or ] ( )    {
f or ( l et   x   =   Mat h. c ei l ( t hi s . f r om) ;	x   <=   t hi s . t o;	x++)    yi el d

x; }


See Example 9-3 in Chapter 9 to see this generator-based iterator function in context.


12.3.1 Generator Examples

Generators are more interesting if they actually generate the values they yield by doing some kind of computation. Here, for example, is a generator function that yields Fibonacci numbers:

f unc t i on*   f i bonac c i Sequenc e( )    { l et   x   =   0,	y   =   1;
f or ( ; ; )    {
yi el d   y;
[ x,	y]    =   [ y,	x+y] ;	/ /   Not e:	des t r uc t ur i ng   as s i gnment }
}


Note that the f i bonacci Sequence( )  generator function here has an infinite loop and yields values forever without returning. If this generator is used with the . . .  spread operator, it will loop until memory is exhausted and the program crashes. With care, it is possible to use it in a f or / of  loop, however:

/ /   Ret ur n   t he   nt h   Fi bonac c i	number f unc t i on   f i bonac c i ( n)    {
f or ( l et   f    of    f i bonac c i Sequenc e( ) )    { i f    ( n- -    <=   0)    r et ur n   f ;
} }
f i bonac c i ( 20)	/ /   =>   10946


This kind of infinite generator becomes more useful with a t ake( )

generator like this:


/ /   Yi el d   t he   f i r s t   n   el ement s   of    t he   s pec i f i ed   i t er abl e   obj ec t f unc t i on*   t ake( n,	i t er abl e)    {
l et   i t   =   i t er abl e[ Symbol . i t er at or ] ( ) ;	/ /   Get   i t er at or   f or i t er abl e   obj ec t
whi l e( n- -    >   0)    {	/ /   L oop   n   t i mes :
l et   next   =   i t . next ( ) ;	/ /   Get   t he   next   i t em f r om t he i t er at or .
i f    ( next . done)    r et ur n;	/ /   I f    t her e   ar e   no   mor e   val ues , r et ur n   ear l y
el s e   yi el d   next . val ue;	/ /   ot her wi s e,	yi el d   t he   val ue }
}

/ /   An   ar r ay   of    t he   f i r s t   5   Fi bonac c i	number s
[ . . . t ake( 5,	f i bonac c i Sequenc e( ) ) ]	/ /   =>   [ 1,	1,	2,	3,	5]


Here is another useful generator function that interleaves the elements of multiple iterable objects:


/ /   Gi ven   an i nt er l eaved

ar r ay   of    i t er abl es ,	yi el d   t hei r   el ement s   i n or der .

f unc t i on*   z i p( . . . i t er abl es )    {
/ /   Get   an   i t er at or   f or   eac h   i t er abl e
l et   i t er at or s   =   i t er abl es . map( i	=>   i [ Symbol . i t er at or ] ( ) ) ; l et   i ndex   =   0;
whi l e( i t er at or s . l engt h   >   0)    {	/ /   Whi l e   t her e   ar e   s t i l l s ome   i t er at or s
i f    ( i ndex   >=   i t er at or s . l engt h)    {	/ /   I f    we   r eac hed   t he l as t   i t er at or
i ndex   =   0;	/ /   go   bac k   t o   t he f i r s t   one.
}
l et   i t em =   i t er at or s [ i ndex] . next ( ) ;	/ /   Get   next   i t em f r om next   i t er at or .
i f    ( i t em. done)    {	/ /   I f    t hat   i t er at or i s   done
i t er at or s . s pl i c e( i ndex,	1) ;	/ /   t hen   r emove   i t f r om t he   ar r ay.
}
el s e   {	/ /   Ot her wi s e,

yi el d   i t em. val ue;	/ /   yi el d   t he i t er at ed   val ue
i ndex++;	/ /   and   move   on   t o t he   next   i t er at or .
} }
}

/ /   I nt er l eave   t hr ee   i t er abl e   obj ec t s
[ . . . z i p( oneDi gi t Pr i mes ( ) , " ab" , [ 0] ) ]	/ /   => [ 2, " a" , 0, 3, " b" , 5, 7]


12.3.2 yield* and Recursive Generators

In addition to the z i p( )  generator defined in the preceding example, it might be useful to have a similar generator function that yields the elements of multiple iterable objects sequentially rather than interleaving them. We could write that generator like this:

f unc t i on*   s equenc e( . . . i t er abl es )    {
f or ( l et   i t er abl e   of    i t er abl es )    { f or ( l et   i t em of    i t er abl e)    {
yi el d   i t em; }
} }

[ . . . s equenc e( " abc " , oneDi gi t Pr i mes ( ) ) ]	/ /   => [ " a" , " b" , " c " , 2, 3, 5, 7]


This process of yielding the elements of some other iterable object is common enough in generator functions that ES6 has special syntax for it. The yi el d* keyword is like yi el d except that, rather than yielding a single value, it iterates an iterable object and yields each of the resulting values. The s equence( )  generator function that we’ve used can be simplified with yi el d* like this:

f unc t i on*   s equenc e( . . . i t er abl es )    {
f or ( l et   i t er abl e   of    i t er abl es )    { yi el d*   i t er abl e;
} }

[ . . . s equenc e( " abc " , oneDi gi t Pr i mes ( ) ) ]	/ /   => [ " a" , " b" , " c " , 2, 3, 5, 7]


The array f or Each( )  method is often an elegant way to loop over the elements of an array, so you might be tempted to write the s equence( ) function like this:

f unc t i on*   s equenc e( . . . i t er abl es )    {
i t er abl es . f or Eac h( i t er abl e   =>   yi el d*   i t er abl e   ) ;	/ /   Er r or }


This does not work, however. yi el d and yi el d* can only be used within generator functions, but the nested arrow function in this code is a regular function, not a f unct i on* generator function, so yi el d is not allowed.

yi el d* can be used with any kind of iterable object, including iterables implemented with generators. This means that yi el d* allows us to define recursive generators, and you might use this feature to allow simple non-recursive iteration over a recursively defined tree structure, for example.


12.4 Advanced Generator Features

The most common use of generator functions is to create iterators, but the fundamental feature of generators is that they allow us to pause a computation, yield intermediate results, and then resume the computation

later. This means that generators have features beyond those of iterators, and we explore those features in the following sections.


12.4.1 The Return Value of a Generator Function

The generator functions we’ve seen so far have not had r et ur n statements, or if they have, they have been used to cause an early return, not to return a value. Like any function, though, a generator function can return a value. In order to understand what happens in this case, recall how iteration works. The return value of the next ( )  function is an object that has a val ue property and/or a done property. With typical iterators and generators, if the val ue property is defined, then the done property is undefined or is f al s e. And if done is t r ue, then val ue is undefined. But in the case of a generator that returns a value, the final call to next returns an object that has both val ue and done defined. The val ue property holds the return value of the generator function, and the done property is t r ue, indicating that there are no more values to iterate. This final value is ignored by the f or / of  loop and by the spread operator, but it is available to code that manually iterates with explicit calls to next ( ) :

f unc t i on   *oneAndDone( )    { yi el d   1;
r et ur n   " done" ; }

/ /   The   r et ur n   val ue   does   not   appear   i n   nor mal	i t er at i on. [ . . . oneAndDone( ) ]	/ /   =>   [ 1]

/ /   But   i t   i s   avai l abl e   i f    you   expl i c i t l y   c al l	next ( ) l et   gener at or   =   oneAndDone( ) ;
gener at or . next ( )	/ /   =>   {    val ue:	1,	done:	f al s e}
gener at or . next ( )	/ /   =>   {    val ue:	" done" ,	done:	t r ue   }
/ /   I f    t he   gener at or   i s   al r eady   done,	t he   r et ur n   val ue   i s   not r et ur ned   agai n
gener at or . next ( )	/ /   =>   {    val ue:	undef i ned,	done:	t r ue

}


12.4.2 The Value of a yield Expression

In the preceding discussion, we’ve treated yi el d as a statement that takes a value but has no value of its own. In fact, however, yi el d is an expression, and it can have a value.

When the next ( )  method of a generator is invoked, the generator function runs until it reaches a yi el d expression. The expression that follows the yi el d keyword is evaluated, and that value becomes the return value of the next ( )  invocation. At this point, the generator function stops executing right in the middle of evaluating the yi el d expression. The next time the next ( )  method of the generator is called, the argument passed to next ( )  becomes the value of the yi el d expression that was paused. So the generator returns values to its caller with yi el d, and the caller passes values in to the generator with
next ( ) . The generator and caller are two separate streams of execution passing values (and control) back and forth. The following code illustrates:

f unc t i on*   s mal l Number s ( )    {
c ons ol e. l og( " next ( )    i nvoked   t he   f i r s t   t i me;	ar gument di s c ar ded" ) ;
l et   y1   =   yi el d   1;	/ /   y1   ==   " b"
c ons ol e. l og( " next ( )    i nvoked   a   s ec ond   t i me   wi t h   ar gument " , y1) ;
l et   y2   =   yi el d   2;	/ /   y2   ==   " c "
c ons ol e. l og( " next ( )    i nvoked   a   t hi r d   t i me   wi t h   ar gument " , y2) ;
l et   y3   =   yi el d   3;	/ /   y3   ==   " d"
c ons ol e. l og( " next ( )    i nvoked   a   f our t h   t i me   wi t h   ar gument " , y3) ;
r et ur n   4;

}

l et   g   =   s mal l Number s ( ) ;
c ons ol e. l og( " gener at or   c r eat ed;	no   c ode   r uns   yet " ) ; l et   n1   =   g. next ( " a" ) ;	/ /   n1. val ue   ==   1
c ons ol e. l og( " gener at or   yi el ded" ,	n1. val ue) ; l et   n2   =   g. next ( " b" ) ;	/ /   n2. val ue   ==   2
c ons ol e. l og( " gener at or   yi el ded" ,	n2. val ue) ; l et   n3   =   g. next ( " c " ) ;	/ /   n3. val ue   ==   3
c ons ol e. l og( " gener at or   yi el ded" ,	n3. val ue) ;
l et   n4   =   g. next ( " d" ) ;	/ /   n4   ==   {    val ue:	4,	done:	t r ue   } c ons ol e. l og( " gener at or   r et ur ned" ,	n4. val ue) ;


When this code runs, it produces the following output that demonstrates the back-and-forth between the two blocks of code:

gener at or   c r eat ed;	no   c ode   r uns   yet
next ( )    i nvoked   t he   f i r s t   t i me;	ar gument   di s c ar ded gener at or   yi el ded   1
next ( )    i nvoked   a   s ec ond   t i me   wi t h   ar gument   b gener at or   yi el ded   2
next ( )    i nvoked   a   t hi r d   t i me   wi t h   ar gument   c gener at or   yi el ded   3
next ( )    i nvoked   a   f our t h   t i me   wi t h   ar gument   d gener at or   r et ur ned   4


Note the asymmetry in this code. The first invocation of next ( )  starts the generator, but the value passed to that invocation is not accessible to the generator.


12.4.3 The return() and throw() Methods of a Generator

We’ve seen that you can receive values yielded by or returned by a generator function. And you can pass values to a running generator by passing those values when you call the next ( )  method of the generator.


In addition to providing input to a generator with next ( ) , you can also alter the flow of control inside the generator by calling its r et ur n( )  and

t hr ow( )  methods. As the names suggest, calling these methods on a generator causes it to return a value or throw an exception as if the next statement in the generator was a r et ur n or t hr ow.


Recall from earlier in the chapter that, if an iterator defines a r et ur n( ) method and iteration stops early, then the interpreter automatically calls the r et ur n( )  method to give the iterator a chance to close files or do other cleanup. In the case of generators, you can’t define a custom
r et ur n( )  method to handle cleanup, but you can structure the generator code to use a t r y/ f i nal l y statement that ensures the necessary cleanup is done (in the f i nal l y block) when the generator returns. By forcing the generator to return, the generator’s built-in r et ur n( )  method ensures that the cleanup code is run when the generator will no longer be used.

Just as the next ( )  method of a generator allows us to pass arbitrary values into a running generator, the t hr ow( )  method of a generator gives us a way to send arbitrary signals (in the form of exceptions) into a generator. Calling the t hr ow( )  method always causes an exception inside the generator. But if the generator function is written with appropriate exception-handling code, the exception need not be fatal but can instead be a means of altering the behavior of the generator. Imagine, for example, a counter generator that yields an ever-increasing sequence of integers. This could be written so that an exception sent with t hr ow( ) would reset the counter to zero.

When a generator uses yi el d* to yield values from some other iterable object, then a call to the next ( )  method of the generator causes a call to the next ( )  method of the iterable object. The same is true of the

r et ur n( )  and t hr ow( )  methods. If a generator uses yi el d* on an iterable object that has these methods defined, then calling r et ur n( )  or t hr ow( )  on the generator causes the iterator’s r et ur n( )  or t hr ow( ) method to be called in turn. All iterators must have a next ( )  method. Iterators that need to clean up after incomplete iteration should define a
r et ur n( )  method. And any iterator may define a t hr ow( )  method, though I don’t know of any practical reason to do so.


12.4.4 A Final Note About Generators

Generators are a very powerful generalized control structure. They give us the ability to pause a computation with yi el d and restart it again at some arbitrary later time with an arbitrary input value. It is possible to use generators to create a kind of cooperative threading system within single-threaded JavaScript code. And it is possible to use generators to mask asynchronous parts of your program so that your code appears sequential and synchronous, even though some of your function calls are actually asynchronous and depend on events from the network.

Trying to do these things with generators leads to code that is mind-bendingly hard to understand or to explain. It has been done, however, and the only really practical use case has been for managing asynchronous code. JavaScript now has as ync and awai t  keywords (see Chapter 13) for this very purpose, however, and there is no longer any reason to abuse generators in this way.


12.5 Summary

In this chapter, you have learned:

The f or / of  loop and the . . .  spread operator work with iterable objects.

An object is iterable if it has a method with the symbolic name [ Symbol . i t er at or ]  that returns an iterator object.

An iterator object has a next ( )  method that returns an iteration result object.

An iteration result object has a val ue property that holds the next iterated value, if there is one. If the iteration has completed, then the result object must have a done property set to t r ue.

You can implement your own iterable objects by defining a
[ Symbol . i t er at or ] ( )  method that returns an object with a next ( )  method that returns iteration result objects. You can also implement functions that accept iterator arguments and return iterator values.

Generator functions (functions defined with f unct i on* instead of f unct i on) are another way to define iterators.

When you invoke a generator function, the body of the function does not run right away; instead, the return value is an iterable iterator object. Each time the next ( )  method of the iterator is called, another chunk of the generator function runs.

Generator functions can use the yi el d operator to specify the values that are returned by the iterator. Each call to next ( ) causes the generator function to run up to the next yi el d expression. The value of that yi el d expression then becomes the value returned by the iterator. When there are no more yi el d expressions, then the generator function returns, and the iteration is complete.



Chapter 13. Asynchronous J avaScript




Some computer programs, such as scientific simulations and machine learning models, are compute-bound: they run continuously, without pause, until they have computed their result. Most real-world computer programs, however, are significantly asynchronous. This means that they often have to stop computing while waiting for data to arrive or for some event to occur. JavaScript programs in a web browser are typically event-driven, meaning that they wait for the user to click or tap before they actually do anything. And JavaScript-based servers typically wait for client requests to arrive over the network before they do anything.


This kind of asynchronous programming is commonplace in JavaScript, and this chapter documents three important language features that help make it easier to work with asynchronous code. Promises, new in ES6, are objects that represent the not-yet-available result of an asynchronous operation. The keywords as ync and awai t  were introduced in ES2017 and provide new syntax that simplifies asynchronous programming by allowing you to structure your Promise-based code as if it was synchronous. Finally, asynchronous iterators and the f or / awai t  loop were introduced in ES2018 and allow you to work with streams of asynchronous events using simple loops that appear synchronous.

Ironically, even though JavaScript provides these powerful features for working with asynchronous code, there are no features of the core language that are themselves asynchronous. In order to demonstrate

Promises, as ync, awai t , and f or / awai t , therefore, we will first take a detour into client-side and server-side JavaScript to explain some of the asynchronous features of web browsers and Node. (You can learn more about client-side and server-side JavaScript in Chapters 15 and 16.)


13.1 Asynchronous Programming with Callbacks

At its most fundamental level, asynchronous programming in JavaScript is done with callbacks. A callback is a function that you write and then pass to some other function. That other function then invokes (“calls back”) your function when some condition is met or some (asynchronous) event occurs. The invocation of the callback function you provide notifies you of the condition or event, and sometimes, the invocation will include function arguments that provide additional details. This is easier to understand with some concrete examples, and the subsections that follow demonstrate various forms of callback-based asynchronous programming using both client-side JavaScript and Node.


13.1.1 Timers

One of the simplest kinds of asynchrony is when you want to run some code after a certain amount of time has elapsed. As we saw in §11.10, you can do this with the s et Ti meout ( )  function:


s et Ti meout ( c hec kFor Updat es ,	60000) ;


The first argument to s et Ti meout ( )  is a function and the second is a time interval measured in milliseconds. In the preceding code, a hypothetical checkFor Updat es ( )  function will be called 60,000 milliseconds (1 minute) after the s et Ti meout ( )  call.

checkFor Updat es ( )  is a callback function that your program might define, and s et Ti meout ( )  is the function that you invoke to register your callback function and specify under what asynchronous conditions it should be invoked.

s et Ti meout ( )  calls the specified callback function one time, passing no arguments, and then forgets about it. If you are writing a function that really does check for updates, you probably want it to run repeatedly. You can do this by using s et I nt er val ( )  instead of s et Ti meout ( ) :

/ /   Cal l	c hec kFor Updat es   i n   one   mi nut e   and   t hen   agai n   ever y mi nut e   af t er   t hat
l et   updat eI nt er val I d   =   s et I nt er val ( c hec kFor Updat es ,	60000) ;

/ /   s et I nt er val ( )    r et ur ns   a   val ue   t hat   we   c an   us e   t o   s t op   t he r epeat ed
/ /   i nvoc at i ons   by   c al l i ng   c l ear I nt er val ( ) .	( Si mi l ar l y, s et Ti meout ( )
/ /   r et ur ns   a   val ue   t hat   you   c an   pas s   t o   c l ear Ti meout ( ) ) f unc t i on   s t opChec ki ngFor Updat es ( )    {
c l ear I nt er val ( updat eI nt er val I d) ; }


13.1.2 Events

Client-side JavaScript programs are almost universally event driven: rather than running some kind of predetermined computation, they typically wait for the user to do something and then respond to the user’s actions. The web browser generates an event when the user presses a key on the keyboard, moves the mouse, clicks a mouse button, or touches a touchscreen device. Event-driven JavaScript programs register callback functions for specified types of events in specified contexts, and the web browser invokes those functions whenever the specified events occur. These callback functions are called event handlers or event listeners, and they are registered with addEvent Li s t ener ( ) :


/ /   As k   t he   web   br ows er   t o   r et ur n / /   <but t on>   el ement   t hat   mat c hes

an   obj ec t   r epr es ent i ng   t he   HTML t hi s   CSS   s el ec t or

l et   okay   =   doc ument . quer ySel ec t or ( ' #c onf i r mUpdat eDi al og but t on. okay' ) ;


/ /   Now  r egi s t er   a / /   c l i c ks   on   t hat

c al l bac k   f unc t i on   t o   be   i nvoked   when   t he   us er but t on.

okay. addEvent L i s t ener ( ' c l i c k' ,	appl yUpdat e) ;


In this example, appl yUpdat e( )  is a hypothetical callback function that we assume is implemented somewhere else. The call to document . quer ySel ect or ( )  returns an object that represents a single specified element in the web page. We call
addEvent Li s t ener ( )  on that element to register our callback. Then the first argument to addEvent Li s t ener ( )  is a string that specifies the kind of event we’re interested in—a mouse click or touchscreen tap, in this case. If the user clicks or taps on that specific element of the web page, then the browser will invoke our appl yUpdat e( )  callback function, passing an object that includes details (such as the time and the mouse pointer coordinates) about the event.


13.1.3 Network Events

Another common source of asynchrony in JavaScript programming is network requests. JavaScript running in the browser can fetch data from a web server with code like this:

f unc t i on   get Cur r ent Ver s i onNumber ( ver s i onCal l bac k)    {    / /   Not e c al l bac k   ar gument
/ /   Make   a   s c r i pt ed   HTTP   r eques t   t o   a   bac kend   ver s i on   API l et   r eques t   =   new  XML Ht t pReques t ( ) ;
r eques t . open( " GET" ,	" ht t p: / / www. exampl e. c om/ api / ver s i on" ) ; r eques t . s end( ) ;

/ /   Regi s t er   a   c al l bac k   t hat   wi l l	be   i nvoked   when   t he r es pons e   ar r i ves

r eques t . onl oad   =   f unc t i on( )    {
i f    ( r eques t . s t at us   ===   200)    {
/ /   I f    HTTP   s t at us   i s   good,	get   ver s i on   number   and c al l	c al l bac k.
l et   c ur r ent Ver s i on   = par s eFl oat ( r eques t . r es pons eText ) ;
ver s i onCal l bac k( nul l ,	c ur r ent Ver s i on) ; }    el s e   {
/ /   Ot her wi s e   r epor t   an   er r or   t o   t he   c al l bac k ver s i onCal l bac k( r es pons e. s t at us Text ,	nul l ) ;
} } ;
/ /   Regi s t er   anot her   c al l bac k   t hat   wi l l	be   i nvoked   f or net wor k   er r or s
r eques t . oner r or   =   r eques t . ont i meout   =   f unc t i on( e)    {
ver s i onCal l bac k( e. t ype,	nul l ) ; } ;
}


Client-side JavaScript code can use the XMLHttpRequest class plus callback functions to make HTTP requests and asynchronously handle the server’s response when it arrives.1 The
get Cur r ent Ver s i onNumber ( )  function defined here (we can imagine that it is used by the hypothetical checkFor Updat es ( ) function we discussed in §13.1.1) makes an HTTP request and defines event handlers that will be invoked when the server’s response is received or when a timeout or other error causes the request to fail.

Notice that the code example above does not call
addEvent Li s t ener ( )  as our previous example did. For most web APIs (including this one), event handlers can be defined by invoking addEvent Li s t ener ( )  on the object generating the event and passing the name of the event of interest along with the callback function. Typically, though, you can also register a single event listener by assigning it directly to a property of the object. That is what we do in this example

code, assigning functions to the onl oad, oner r or , and ont i meout properties. By convention, event listener properties like these always have names that begin with on. addEvent Li s t ener ( )  is the more flexible technique because it allows for multiple event handlers. But in cases where you are sure that no other code will need to register a listener for the same object and event type, it can be simpler to simply set the appropriate property to your callback.

Another thing to note about the get Cur r ent Ver s i onNumber ( ) function in this example code is that, because it makes an asynchronous request, it cannot synchronously return the value (the current version number) that the caller is interested in. Instead, the caller passes a callback function, which is invoked when the result is ready or when an error occurs. In this case, the caller supplies a callback function that expects two arguments. If the XMLHttpRequest works correctly, then
get Cur r ent Ver s i onNumber ( )  invokes the callback with a nul l first argument and the version number as the second argument. Or, if an error occurs, then get Cur r ent Ver s i onNumber ( )  invokes the callback with error details in the first argument and nul l  as the second argument.


13.1.4 Callbacks and Events in Node

The Node.js server-side JavaScript environment is deeply asynchronous and defines many APIs that use callbacks and events. The default API for reading the contents of a file, for example, is asynchronous and invokes a callback function when the contents of the file have been read:

c ons t   f s   =   r equi r e( " f s " ) ;	/ /   The   " f s "   modul e   has   f i l es ys t em-r el at ed   API s
l et   opt i ons   =   {	/ /   An   obj ec t   t o   hol d   opt i ons   f or   our pr ogr am

/ /   def aul t   opt i ons   woul d   go   her e } ;

/ /   Read   a   c onf i gur at i on   f i l e,	t hen   c al l	t he   c al l bac k   f unc t i on f s . r eadFi l e( " c onf i g. j s on" ,	" ut f - 8" ,	( er r ,	t ext )    =>   {
i f    ( er r )    {
/ /   I f    t her e   was   an   er r or ,	di s pl ay   a   war ni ng,	but c ont i nue
c ons ol e. war n( " Coul d   not   r ead   c onf i g   f i l e: " ,	er r ) ;
}    el s e   {
/ /   Ot her wi s e,	par s e   t he   f i l e   c ont ent s   and   as s i gn   t o   t he opt i ons   obj ec t
Obj ec t . as s i gn( opt i ons ,	J SON. par s e( t ext ) ) ;
}

/ /   I n   ei t her   c as e,	we   c an   now  s t ar t   r unni ng   t he   pr ogr am s t ar t Pr ogr am( opt i ons ) ;
} ) ;


Node’s f s . r eadFi l e( )  function takes a two-parameter callback as its last argument. It reads the specified file asynchronously and then invokes the callback. If the file was read successfully, it passes the file contents as the second callback argument. If there was an error, it passes the error as the first callback argument. In this example, we express the callback as an arrow function, which is a succinct and natural syntax for this kind of simple operation.

Node also defines a number of event-based APIs. The following function shows how to make an HTTP request for the contents of a URL in Node. It has two layers of asynchronous code handled with event listeners. Notice that Node uses an on( )  method to register event listeners instead of addEvent Li s t ener ( ) :


c ons t   ht t ps   =   r equi r e( " ht t ps " ) ;

/ /   Read   t he   t ext   c ont ent   of    t he   URL   and   as ync hr onous l y   pas s   i t t o   t he   c al l bac k.
f unc t i on   get Text ( ur l ,	c al l bac k)    {

/ /   St ar t   an   HTTP   GET   r eques t   f or   t he   URL r eques t   =   ht t ps . get ( ur l ) ;

/ /   Regi s t er   a   f unc t i on   t o   handl e   t he   " r es pons e"   event . r eques t . on( " r es pons e" ,	r es pons e   =>   {
/ /   The   r es pons e   event   means   t hat   r es pons e   header s   have been   r ec ei ved
l et   ht t pSt at us   =   r es pons e. s t at us Code;


/ /   The   body   of    t he   HTTP   r es pons e   has   not yet .
/ /   So   we   r egi s t er   mor e   event   handl er s   t o when   i t   ar r i ves .

been   r ec ei ved

t o   be   c al l ed

r es pons e. s et Enc odi ng( " ut f - 8" ) ;	/ /   We' r e   expec t i ng Uni c ode   t ext
l et   body   =   " " ;	/ /   whi c h   we   wi l l ac c umul at e   her e.

/ /   Thi s   event   handl er   i s   c al l ed   when   a   c hunk   of    t he   body i s   r eady
r es pons e. on( " dat a" ,	c hunk   =>   {    body   +=   c hunk;	} ) ;

/ /   Thi s   event   handl er   i s   c al l ed   when   t he   r es pons e   i s c ompl et e
r es pons e. on( " end" ,	( )    =>   {
i f    ( ht t pSt at us   ===   200)    {	/ /   I f    t he   HTTP   r es pons e was   good
c al l bac k( nul l ,	body) ;	/ /   Pas s   r es pons e   body   t o t he   c al l bac k
}    el s e   {	/ /   Ot her wi s e   pas s   an er r or
c al l bac k( ht t pSt at us ,	nul l ) ; }
} ) ; } ) ;

/ /   We   al s o   r egi s t er   an   event   handl er   f or   l ower - l evel	net wor k er r or s
r eques t . on( " er r or " ,	( er r )    =>   {
c al l bac k( er r ,	nul l ) ; } ) ;
}

13.2 Promises

Now that we’ve seen examples of callback and event-based asynchronous programming in client-side and server-side JavaScript environments, we can introduce Promises, a core language feature designed to simplify asynchronous programming.


A Promise is an object that represents the result of an asynchronous computation. That result may or may not be ready yet, and the Promise API is intentionally vague about this: there is no way to synchronously get the value of a Promise; you can only ask the Promise to call a callback function when the value is ready. If you are defining an asynchronous API like the get Text ( )  function in the previous section, but want to make it Promise-based, omit the callback argument, and instead return a Promise object. The caller can then register one or more callbacks on this Promise object, and they will be invoked when the asynchronous computation is done.

So, at the simplest level, Promises are just a different way of working with callbacks. However, there are practical benefits to using them. One real problem with callback-based asynchronous programming is that it is common to end up with callbacks inside callbacks inside callbacks, with lines of code so highly indented that it is difficult to read. Promises allow this kind of nested callback to be re-expressed as a more linear Promise chain that tends to be easier to read and easier to reason about.


Another problem with callbacks is that they can make handling errors difficult. If an asynchronous function (or an asynchronously invoked callback) throws an exception, there is no way for that exception to propagate back to the initiator of the asynchronous operation. This is a

fundamental fact about asynchronous programming: it breaks exception handling. The alternative is to meticulously track and propagate errors with callback arguments and return values, but this is tedious and difficult to get right. Promises help here by standardizing a way to handle errors and providing a way for errors to propagate correctly through a chain of promises.


Note that Promises represent the future results of single asynchronous computations. They cannot be used to represent repeated asynchronous computations, however. Later in this chapter, we’ll write a Promise-based alternative to the s et Ti meout ( )  function, for example. But we can’t use Promises to replace s et I nt er val ( )  because that function invokes a callback function repeatedly, which is something that Promises are just not designed to do. Similarly, we could use a Promise instead of the “load” event handler of an XMLHttpRequest object, since that callback is only ever called once. But we typically would not use a Promise in place of a “click” event handler of an HTML button object, since we normally want to allow the user to click a button multiple times.

The subsections that follow will:


Explain Promise terminology and show basic Promise usage

Show how promises can be chained

Demonstrate how to create your own Promise-based APIs



IMPORTANT

Promises seem simple at first, and the basic use case for Promises is, in fact, straightforward and simple. But they can become surprisingly confusing for anything beyond the simplest use cases. Promises are a powerful idiom for asynchronous programming, but you need to understand them deeply to use them correctly and

confidently. It is worth taking the time to develop that deep understanding, however, and I urge you to study this long chapter carefully.




13.2.1 Using Promises

With the advent of Promises in the core JavaScript language, web browsers have begun to implement Promise-based APIs. In the previous section, we implemented a get Text ( )  function that made an asynchronous HTTP request and passed the body of the HTTP response to a specified callback function as a string. Imagine a variant of this function, get J SON( ) , which parses the body of the HTTP response as JSON and returns a Promise instead of accepting a callback argument. We will implement a get J SON( )  function later in this chapter, but for now, let’s look at how we would use this Promise-returning utility function:

get J SON( ur l ) . t hen( j s onDat a   =>   {

/ /   Thi s   i s / /   i nvoked
avai l abl e. } ) ;

a   c al l bac k   f unc t i on   t hat   wi l l	be   as ync hr onous l y wi t h   t he   par s ed   J SON  val ue   when   i t   bec omes



get J SON( )  starts an asynchronous HTTP request for the URL you specify and then, while that request is pending, it returns a Promise object. The Promise object defines a t hen( )  instance method. Instead of passing our callback function directly to get J SON( ) , we instead pass it to the
t hen( )  method. When the HTTP response arrives, the body of that response is parsed as JSON, and the resulting parsed value is passed to the function that we passed to t hen( ) .


You can think of the t hen( )  method as a callback registration method like the addEvent Li s t ener ( )  method used for registering event

handlers in client-side JavaScript. If you call the t hen( )  method of a Promise object multiple times, each of the functions you specify will be called when the promised computation is complete.

Unlike many event listeners, though, a Promise represents a single computation, and each function registered with t hen( )  will be invoked only once. It is worth noting that the function you pass to t hen( )  is invoked asynchronously, even if the asynchronous computation is already complete when you call t hen( ) .


At a simple syntactical level, the t hen( )  method is the distinctive feature of Promises, and it is idiomatic to append . t hen( )  directly to the function invocation that returns the Promise, without the intermediate step of assigning the Promise object to a variable.

It is also idiomatic to name functions that return Promises and functions that use the results of Promises with verbs, and these idioms lead to code that is particularly easy to read:

/ /   Suppos e   you   have   a   f unc t i on   l i ke   t hi s   t o   di s pl ay   a   us er pr of i l e
f unc t i on   di s pl ayUs er Pr of i l e( pr of i l e)    {    / *   i mpl ement at i on   omi t t ed
*/   }


/ /   Her e' s / /   Not i c e s ent enc e:

how  you   mi ght how  t hi s   l i ne

us e   t hat   f unc t i on   wi t h   a   Pr omi s e.
of    c ode   r eads   al mos t   l i ke   an   Engl i s h

get J SON( " / api / us er / pr of i l e" ) . t hen( di s pl ayUs er Pr of i l e) ;


HANDLING ERRORS WITH PROMISES

Asynchronous operations, particularly those that involve networking, can typically fail in a number of ways, and robust code has to be written to handle the errors that will inevitably occur.

For Promises, we can do this by passing a second function to the t hen( ) method:

get J SON( " / api / us er / pr of i l e" ) . t hen( di s pl ayUs er Pr of i l e, handl ePr of i l eEr r or ) ;


A Promise represents the future result of an asynchronous computation that occurs after the Promise object is created. Because the computation is performed after the Promise object is returned to us, there is no way that the computation can traditionally return a value or throw an exception that we can catch. The functions that we pass to t hen( )  provide alternatives. When a synchronous computation completes normally, it simply returns its result to its caller. When a Promise-based asynchronous computation completes normally, it passes its result to the function that is the first argument to t hen( ) .


When something goes wrong in a synchronous computation, it throws an exception that propagates up the call stack until there is a cat ch clause to handle it. When an asynchronous computation runs, its caller is no longer on the stack, so if something goes wrong, it is simply not possible to throw an exception back to the caller.

Instead, Promise-based asynchronous computations pass the exception (typically as an Error object of some kind, though this is not required) to the second function passed to t hen( ) . So, in the code above, if
get J SON( )  runs normally, it passes its result to
di s pl ayUs er Pr of i l e( ) . If there is an error (the user is not logged in, the server is down, the user’s internet connection dropped, the request timed out, etc.), then get J SON( )  passes an Error object to
handl ePr of i l eEr r or ( ) .

In practice, it is rare to see two functions passed to t hen( ) . There is a better and more idiomatic way of handling errors when working with Promises. To understand it, first consider what happens if get J SON( ) completes normally but an error occurs in di s pl ayUs er Pr of i l e( ) . That callback function is invoked asynchronously when get J SON( ) returns, so it is also asynchronous and cannot meaningfully throw an exception (because there is no code on the call stack to handle it).

The more idiomatic way to handle errors in this code looks like this:


get J SON( " / api / us er / pr of i l e" ) . t hen( di s pl ayUs er Pr of i l e) . c at c h( hand l ePr of i l eEr r or ) ;


With this code, a normal result from get J SON( )  is still passed to di s pl ayUs er Pr of i l e( ) , but any error in get J SON( )  or in di s pl ayUs er Pr of i l e( )  (including any exceptions thrown by
di s pl ayUs er Pr of i l e) get passed to handl ePr of i l eEr r or ( ) . The cat ch( )  method is just a shorthand for calling t hen( )  with a
nul l  first argument and the specified error handler function as the second argument.

We’ll have more to say about cat ch( )  and this error-handling idiom when we discuss Promise chains in the next section.



PROMISE TERMINOLOGY

Before we discuss Promises further, it is worth pausing to define some terms. When we are not programming and we talk about human promises, we say that a promise is “kept” or “broken.” When discussing JavaScript Promises, the equivalent terms are “fulfilled” and “rejected.” Imagine that you have called the t hen( )  method of a Promise and have passed two callback functions to it. We say that the promise has been fulfilled if and when the first callback is called. And we say that the Promise has been rejected if and when the second callback is called. If a Promise is neither fulfilled nor rejected, then it is pending. And once a promise is fulfilled or rejected, we say that it is settled. Note that a Promise can never be both fulfilled and rejected. Once a Promise settles, it will never change from fulfilled to rejected or vice versa.

Remember how we defined Promises at the start of this section: “a Promise is an object that represents the result of an asynchronous operation.” It is important to remember that Promises are not just abstract ways registering callbacks to run when some async code finishes—they represent the results of that async code. If the async code runs normally (and the Promise is fulfilled), then that result is essentially the return value of the code. And if the async code does not complete normally (and the Promise is rejected), then the result is an Error object or some other value that the code might have thrown if it was not asynchronous. Any Promise that has settled has a value associated with it, and that value will not change. If the Promise is fulfilled, then the value is a return value that gets passed to any callback functions registered as the first argument of t hen( ) . If the Promise is rejected, then the value is an error of some sort that is passed to any callback functions registered with cat ch( )  or as the second argument of t hen( ) .

The reason that I want to be precise about Promise terminology is that Promises can also be resolved. It is easy to confuse this resolved state with the fulfilled state or with settled state, but it is not precisely the same as either. Understanding the resolved state is one of the keys to a deep understanding of Promises, and I’ll come back to it after we’ve discussed Promise chains below.



13.2.2 Chaining Promises

One of the most important benefits of Promises is that they provide a natural way to express a sequence of asynchronous operations as a linear chain of t hen( )  method invocations, without having to nest each operation within the callback of the previous one. Here, for example, is a hypothetical Promise chain:

f et c h( doc ument URL )	/ /   Make   an   HTTP   r eques t
. t hen( r es pons e   =>   r es pons e. j s on( ) )	/ /   As k   f or   t he   J SON  body of    t he   r es pons e
. t hen( doc ument   =>   {	/ /   When   we   get   t he par s ed   J SON
r et ur n   r ender ( doc ument ) ;	/ /   di s pl ay   t he   doc ument t o   t he   us er
} )
. t hen( r ender ed   =>   {	/ /   When   we   get   t he r ender ed   doc ument
c ac heI nDat abas e( r ender ed) ;	/ /   c ac he   i t   i n   t he   l oc al dat abas e.
} )
. c at c h( er r or   =>   handl e( er r or ) ) ;	/ /   Handl e   any   er r or s t hat   oc c ur


This code illustrates how a chain of Promises can make it easy to express a

sequence of asynchronous operations. We’re not going to discuss this particular Promise chain at all, however. We will continue to explore the idea of using Promise chains to make HTTP requests, however.

Earlier in this chapter, we saw the XMLHttpRequest object used to make an HTTP request in JavaScript. That strangely named object has an old and awkward API, and it has largely been replaced by the newer, Promise-based Fetch API (§15.11.1). In its simplest form, this new HTTP API is just the function f et ch( ) . You pass it a URL, and it returns a Promise. That promise is fulfilled when the HTTP response begins to arrive and the HTTP status and headers are available:

f et c h( " / api / us er / pr of i l e" ) . t hen( r es pons e   =>   {
/ /   When   t he   pr omi s e   r es ol ves ,	we   have   s t at us   and   header s i f    ( r es pons e. ok   &&
r es pons e. header s . get ( " Cont ent - Type" )    === " appl i c at i on/ j s on" )    {
/ /   What   c an   we   do   her e?   We   don' t   ac t ual l y   have   t he r es pons e   body   yet .
}
} ) ;


When the Promise returned by f et ch( )  is fulfilled, it passes a Response object to the function you passed to its t hen( )  method. This response object gives you access to request status and headers, and it also defines methods like t ext ( )  and j s on( ) , which give you access to the body of the response in text and JSON-parsed forms, respectively. But although the initial Promise is fulfilled, the body of the response may not yet have arrived. So these t ext ( )  and j s on( )  methods for accessing the body of the response themselves return Promises. Here’s a naive way of using
f et ch( )  and the r es pons e. j s on( )  method to get the body of an HTTP response:

f et c h( " / api / us er / pr of i l e" ) . t hen( r es pons e   =>   {
r es pons e. j s on( ) . t hen( pr of i l e   =>   {	/ /   As k   f or   t he   J SON-
par s ed   body
/ /   When   t he   body   of    t he   r es pons e   ar r i ves ,	i t   wi l l	be aut omat i c al l y
/ /   par s ed   as   J SON  and   pas s ed   t o   t hi s   f unc t i on. di s pl ayUs er Pr of i l e( pr of i l e) ;
} ) ; } ) ;


This is a naive way to use Promises because we nested them, like callbacks, which defeats the purpose. The preferred idiom is to use Promises in a sequential chain with code like this:

f et c h( " / api / us er / pr of i l e" ) . t hen( r es pons e   =>   {
r et ur n   r es pons e. j s on( ) ; } )
. t hen( pr of i l e   =>   {
di s pl ayUs er Pr of i l e( pr of i l e) ; } ) ;


Let’s look at the method invocations in this code, ignoring the arguments that are passed to the methods:

f et c h( ) . t hen( ) . t hen( )


When more than one method is invoked in a single expression like this, we call it a method chain. We know that the f et ch( )  function returns a Promise object, and we can see that the first . t hen( )  in this chain invokes a method on that returned Promise object. But there is a second
. t hen( )  in the chain, which means that the first invocation of the t hen( )  method must itself return a Promise.

Sometimes, when an API is designed to use this kind of method chaining,

there is just a single object, and each method of that object returns the object itself in order to facilitate chaining. That is not how Promises work, however. When we write a chain of . t hen( )  invocations, we are not registering multiple callbacks on a single Promise object. Instead, each invocation of the t hen( )  method returns a new Promise object. That new Promise object is not fulfilled until the function passed to t hen( )  is complete.

Let’s return to a simplified form of the original f et ch( )  chain above. If we define the functions passed to the t hen( )  invocations elsewhere, we might refactor the code to look like this:


f et c h( t heURL )
. t hen( c al l bac k1)
. t hen( c al l bac k2) ;

/ /   t as k   1; / /   t as k   2;
/ /   t as k   3;

r et ur ns r et ur ns
r et ur ns

pr omi s e   1 pr omi s e   2
pr omi s e   3



Let’s walk through this code in detail:


1.  On the first line, f et ch( )  is invoked with a URL. It initiates an HTTP GET request for that URL and returns a Promise. We’ll call this HTTP request “task 1” and we’ll call the Promise “promise 1”.

2.  On the second line, we invoke the t hen( )  method of promise 1, passing the cal l back1 function that we want to be invoked when promise 1 is fulfilled. The t hen( )  method stores our callback somewhere, then returns a new Promise. We’ll call the new Promise returned at this step “promise 2”, and we’ll say that “task 2” begins when cal l back1 is invoked.

3.  On the third line, we invoke the t hen( )  method of promise 2, passing the cal l back2 function we want invoked when promise 2 is fulfilled. This t hen( )  method remembers our callback and returns yet another Promise. We’ll say that “task 3”

begins when cal l back2 is invoked. We can call this latest Promise “promise 3”, but we don’t really need a name for it because we won’t be using it at all.

4.  The previous three steps all happen synchronously when the expression is first executed. Now we have an asynchronous pause while the HTTP request initiated in step 1 is sent out across the internet.

5.  Eventually, the HTTP response starts to arrive. The asynchronous part of the f et ch( )  call wraps the HTTP status and headers in a Response object and fulfills promise 1 with that Response object as the value.

6.  When promise 1 is fulfilled, its value (the Response object) is passed to our cal l back1( )  function, and task 2 begins. The job of this task, given a Response object as input, is to obtain the response body as a JSON object.

7.  Let’s assume that task 2 completes normally and is able to parse the body of the HTTP response to produce a JSON object. This JSON object is used to fulfill promise 2.

8.  The value that fulfills promise 2 becomes the input to task 3 when it is passed to the cal l back2( )  function. This third task now displays the data to the user in some unspecified way. When task 3 is complete (assuming it completes normally), then promise 3 will be fulfilled. But because we never did anything with promise 3, nothing happens when that Promise settles, and the chain of asynchronous computation ends at this point.


13.2.3 Resolving Promises

While explaining the URL-fetching Promise chain with the list in the last section, we talked about promises 1, 2, and 3. But there is actually a fourth Promise object involved as well, and this brings us to our important discussion of what it means for a Promise to be “resolved.”

Remember that f et ch( )  returns a Promise object which, when fulfilled, passes a Response object to the callback function we register. This Response object has . t ext ( ) , . j s on( ) , and other methods to request the body of the HTTP response in various forms. But since the body may not yet have arrived, these methods must return Promise objects. In the example we’ve been studying, “task 2” calls the . j s on( )  method and returns its value. This is the fourth Promise object, and it is the return value of the cal l back1( )  function.


Let’s rewrite the URL-fetching code one more time in a verbose and nonidiomatic way that makes the callbacks and promises explicit:

f unc t i on   c 1( r es pons e)    {	/ /   c al l bac k   1 l et   p4   =   r es pons e. j s on( ) ;
r et ur n   p4;	/ /   r et ur ns   pr omi s e   4 }

f unc t i on   c 2( pr of i l e)    {	/ /   c al l bac k   2 di s pl ayUs er Pr of i l e( pr of i l e) ;
}


l et   p1   =   f et c h( " / api / us er / pr of i l e" ) ; l et   p2   =   p1. t hen( c 1) ;
l et   p3   =   p2. t hen( c 2) ;

/ /   pr omi s e   1,    t as k   1 / /   pr omi s e   2,    t as k   2
/ /   pr omi s e   3,	t as k   3



In order for Promise chains to work usefully, the output of task 2 must become the input to task 3. And in the example we’re considering here, the input to task 3 is the body of the URL that was fetched, parsed as a JSON object. But, as we’ve just discussed, the return value of callback c1 is not a JSON object, but Promise p4 for that JSON object. This seems like a contradiction, but it is not: when p1 is fulfilled, c1 is invoked, and task 2 begins. And when p2 is fulfilled, c2 is invoked, and task 3 begins. But just because task 2 begins when c1 is invoked, it does not mean that

task 2 must end when c1 returns. Promises are about managing asynchronous tasks, after all, and if task 2 is asynchronous (which it is, in this case), then that task will not be complete by the time the callback returns.

We are now ready to discuss the final detail that you need to understand to really master Promises. When you pass a callback c to the t hen( ) method, t hen( )  returns a Promise p and arranges to asynchronously invoke c at some later time. The callback performs some computation and returns a value v. When the callback returns, p is resolved with the value v. When a Promise is resolved with a value that is not itself a Promise, it is immediately fulfilled with that value. So if c returns a non-Promise, that return value becomes the value of p, p is fulfilled and we are done. But if the return value v is itself a Promise, then p is resolved but not yet fulfilled. At this stage, p cannot settle until the Promise v settles. If v is fulfilled, then p will be fulfilled to the same value. If v is rejected, then p will be rejected for the same reason. This is what the “resolved” state of a Promise means: the Promise has become associated with, or “locked onto,” another Promise. We don’t know yet whether p will be fulfilled or rejected, but our callback c no longer has any control over that. p is “resolved” in the sense that its fate now depends entirely on what happens to Promise v.


Let’s bring this back to our URL-fetching example. When c1 returns p4, p2 is resolved. But being resolved is not the same as being fulfilled, so task 3 does not begin yet. When the full body of the HTTP response becomes available, then the . j s on( )  method can parse it and use that parsed value to fulfill p4. When p4 is fulfilled, p2 is automatically fulfilled as well, with the same parsed JSON value. At this point, the

parsed JSON object is passed to c2, and task 3 begins.


This can be one of the trickiest parts of JavaScript to understand, and you may need to read this section more than once. Figure 13-1 presents the process in visual form and may help clarify it for you.


Figure 13-1. Fetching a URL with Promises


13.2.4 More on Promises and Errors

Earlier in the chapter, we saw that you can pass a second callback function to the . t hen( )  method and that this second function will be invoked if the Promise is rejected. When that happens, the argument to this second callback function is a value—typically an Error object—that represents the reason for the rejection. We also learned that it is uncommon (and even unidiomatic) to pass two callbacks to a . t hen( )  method. Instead, Promise-related errors are typically handled by adding a . cat ch( ) method invocation to a Promise chain. Now that we have examined Promise chains, we can return to error handling and discuss it in more detail. To preface the discussion, I’d like to stress that careful error handling is really important when doing asynchronous programming. With synchronous code, if you leave out error-handling code, you’ll at least get an exception and a stack trace that you can use to figure out what is going wrong. With asynchronous code, unhandled exceptions will often go unreported, and errors can occur silently, making them much harder to debug. The good news is that the . cat ch( )  method makes it easy to handle errors when working with Promises.

THE CATCH AND FINALLY METHODS

The . cat ch( )  method of a Promise is simply a shorthand way to call
. t hen( )  with nul l  as the first argument and an error-handling callback as the second argument. Given any Promise p and a callback c, the following two lines are equivalent:

p. t hen( nul l ,	c ) ; p. c at c h( c ) ;

The . cat ch( )  shorthand is preferred because it is simpler and because the name matches the cat ch clause in a t r y/ cat ch exception-handling statement. As we’ve discussed, normal exceptions don’t work with asynchronous code. The . cat ch( )  method of Promises is an alternative that does work for asynchronous code. When something goes wrong in synchronous code, we can speak of an exception “bubbling up the call stack” until it finds a cat ch block. With an asynchronous chain of Promises, the comparable metaphor might be of an error “trickling down the chain” until it finds a . cat ch( )  invocation.


In ES2018, Promise objects also define a . f i nal l y( )  method whose purpose is similar to the f i nal l y clause in a t r y/ cat ch/ f i nal l y statement. If you add a . f i nal l y( )  invocation to your Promise chain, then the callback you pass to . f i nal l y( )  will be invoked when the Promise you called it on settles. Your callback will be invoked if the Promise fulfills or rejects, and it will not be passed any arguments, so you can’t find out whether it fulfilled or rejected. But if you need to run some kind of cleanup code (such as closing open files or network connections) in either case, a . f i nal l y( )  callback is the ideal way to do that. Like
. t hen( )  and . cat ch( ) , . f i nal l y( )  returns a new Promise object. The return value of a . f i nal l y( )  callback is generally ignored, and the Promise returned by . f i nal l y( )  will typically resolve or reject with the same value that the Promise that . f i nal l y( )  was invoked on resolves or rejects with. If a . f i nal l y( )  callback throws an exception, however, then the Promise returned by . f i nal l y( )  will reject with that value.

The URL-fetching code that we studied in the previous sections did not do any error handling. Let’s correct that now with a more realistic version of

the code:


f et c h( " / api / us er / pr of i l e" )	/ /   St ar t   t he   HTTP   r eques t
. t hen( r es pons e   =>   {	/ /   Cal l	t hi s   when   s t at us   and header s   ar e   r eady
i f    ( ! r es pons e. ok)    {	/ /   I f    we   got   a   404   Not   Found   or s i mi l ar   er r or
r et ur n   nul l ;	/ /   Maybe   us er   i s   l ogged   out ; r et ur n   nul l	pr of i l e
}


/ / us   J SON.
/ / er r or !

Now  c hec k   t he   header s

I f    not ,	our   s er ver   i s

t o   ens ur e   t hat   t he   s er ver   s ent

br oken,	and   t hi s   i s   a   s er i ous

l et   t ype   =   r es pons e. header s . get ( " c ont ent - t ype" ) ; i f    ( t ype   ! ==   " appl i c at i on/ j s on" )    {
t hr ow  new  TypeEr r or ( ` Expec t ed   J SON,	got   ${ t ype} ` ) ; }


/ /   I f    we   get c ont ent - t ype
/ /   s o   we   c an r es pons e
/ /   body   as   a

her e,	t hen   we   got   a   2xx   s t at us   and   a   J SON

c onf i dent l y   r et ur n   a   Pr omi s e   f or   t he

J SON  obj ec t .

r et ur n   r es pons e. j s on( ) ; } )
. t hen( pr of i l e   =>   {	/ /   Cal l ed   wi t h   t he   par s ed   r es pons e body   or   nul l
i f    ( pr of i l e)    {
di s pl ayUs er Pr of i l e( pr of i l e) ; }
el s e   {    / /   I f    we   got   a   404   er r or   above   and   r et ur ned   nul l

we   end   up

}
} )

her e
di s pl ayL oggedOut Pr of i l ePage( ) ;

. c at c h( e   =>   {
i f    ( e   i ns t anc eof    Net wor kEr r or )    {
/ /   f et c h( )    c an   f ai l	t hi s   way   i f    t he   i nt er net c onnec t i on   i s   down
di s pl ayEr r or Mes s age( " Chec k   your   i nt er net
c onnec t i on. " ) ;

}
el s e   i f    ( e   i ns t anc eof    TypeEr r or )    {
/ /   Thi s   happens   i f    we   t hr ow  TypeEr r or   above
di s pl ayEr r or Mes s age( " Somet hi ng   i s   wr ong   wi t h   our s er ver ! " ) ;
}
el s e   {
/ /   Thi s   mus t   be   s ome   ki nd   of    unant i c i pat ed   er r or c ons ol e. er r or ( e) ;
} } ) ;


Let’s analyze this code by looking at what happens when things go wrong. We’ll use the naming scheme we used before: p1 is the Promise returned by the f et ch( )  call. p2 is the Promise returned by the first . t hen( ) call, and c1 is the callback that we pass to that . t hen( )  call. p3 is the Promise returned by the second . t hen( )  call, and c2 is the callback we pass to that call. Finally, c3 is the callback that we pass to the . cat ch( ) call. (That call returns a Promise, but we don’t need to refer to it by name.)

The first thing that could fail is the f et ch( )  request itself. If the network connection is down (or for some other reason an HTTP request cannot be made), then Promise p1 will be rejected with a NetworkError object. We didn’t pass an error-handling callback function as the second argument to the . t hen( )  call, so p2 rejects as well with the same NetworkError object. (If we had passed an error handler to that first . t hen( )  call, the error handler would be invoked, and if it returned normally, p2 would be resolved and/or fulfilled with the return value from that handler.) Without a handler, though, p2 is rejected, and then p3 is rejected for the same reason. At this point, the c3 error-handling callback is called, and the NetworkError-specific code within it runs.

Another way our code could fail is if our HTTP request returns a 404 Not

Found or another HTTP error. These are valid HTTP responses, so the
f et ch( )  call does not consider them errors. f et ch( )  encapsulates a 404 Not Found in a Response object and fulfills p1 with that object, causing c1 to be invoked. Our code in c1 checks the ok property of the Response object to detect that it has not received a normal HTTP response and handles that case by simply returning nul l . Because this return value is not a Promise, it fulfills p2 right away, and c2 is invoked with this value. Our code in c2 explicitly checks for and handles falsy values by displaying a different result to the user. This is a case where we treat an abnormal condition as a nonerror and handle it without actually using an error handler.

A more serious error occurs in c1 if the we get a normal HTTP response code but the Content-Type header is not set appropriately. Our code expects a JSON-formatted response, so if the server is sending us HTML, XML, or plain text instead, we’re going to have a problem. c1 includes code to check the Content-Type header. If the header is wrong, it treats this as a nonrecoverable problem and throws a TypeError. When a callback passed to . t hen( )  (or . cat ch( ) ) throws a value, the Promise that was the return value of the . t hen( )  call is rejected with that thrown value. In this case, the code in c1 that raises a TypeError causes p2 to be rejected with that TypeError object. Since we did not specify an error handler for p2, p3 will be rejected as well. c2 will not be called, and the TypeError will be passed to c3, which has code to explicitly check for and handle this type of error.

There are a couple of things worth noting about this code. First, notice that the error object thrown with a regular, synchronous t hr owstatement ends up being handled asynchronously with a . cat ch( )  method invocation in

a Promise chain. This should make it clear why this shorthand method is preferred over passing a second argument to . t hen( ) , and also why it is so idiomatic to end Promise chains with a . cat ch( )  call.


Before we leave the topic of error handling, I want to point out that, although it is idiomatic to end every Promise chain with a . cat ch( )  to clean up (or at least log) any errors that occurred in the chain, it is also perfectly valid to use . cat ch( )  elsewhere in a Promise chain. If one of the stages in your Promise chain can fail with an error, and if the error is some kind of recoverable error that should not stop the rest of the chain from running, then you can insert a . cat ch( )  call in the chain, resulting in code that might look like this:

s t ar t As ync Oper at i on( ) . t hen( doSt ageTwo)
. c at c h( r ec over Fr omSt ageTwoEr r or ) . t hen( doSt ageThr ee)
. t hen( doSt ageFour )
. c at c h( l ogSt ageThr eeAndFour Er r or s ) ;


Remember that the callback you pass to . cat ch( )  will only be invoked if the callback at a previous stage throws an error. If the callback returns normally, then the . cat ch( )  callback will be skipped, and the return value of the previous callback will become the input to the next . t hen( ) callback. Also remember that . cat ch( )  callbacks are not just for reporting errors, but for handling and recovering from errors. Once an error has been passed to a . cat ch( )  callback, it stops propagating down the Promise chain. A . cat ch( )  callback can throw a new error, but if it returns normally, than that return value is used to resolve and/or fulfill the associated Promise, and the error stops propagating.

Let’s be concrete about this: in the preceding code example, if either
s t ar t As yncOper at i on( )  or doSt ageTwo( )  throws an error, then the r ecover Fr omSt ageTwoEr r or ( )  function will be invoked. If
r ecover Fr omSt ageTwoEr r or ( )  returns normally, then its return value will be passed to doSt ageThr ee( )  and the asynchronous operation continues normally. On the other hand, if
r ecover Fr omSt ageTwoEr r or ( )  was unable to recover, it will itself throw an error (or it will rethrow the error that it was passed). In this case, neither doSt ageThr ee( )  nor doSt ageFour ( )  will be invoked, and the error thrown by r ecover Fr omSt ageTwoEr r or ( )  would be passed to l ogSt ageThr eeAndFour Er r or s ( ) .

Sometimes, in complex network environments, errors can occur more or less at random, and it can be appropriate to handle those errors by simply retrying the asynchronous request. Imagine you’ve written a Promise-based operation to query a database:

quer yDat abas e( )
. t hen( di s pl ayTabl e)
. c at c h( di s pl ayDat abas eEr r or ) ;


Now suppose that transient network load issues are causing this to fail about 1% of the time. A simple solution might be to retry the query with a . cat ch( )  call:


quer yDat abas e( )
. c at c h( e   =>   wai t ( 500) . t hen( quer yDat abas e) )	/ /   On   f ai l ur e, wai t   and   r et r y
. t hen( di s pl ayTabl e)
. c at c h( di s pl ayDat abas eEr r or ) ;


If the hypothetical failures are truly random, then adding this one line of

code should reduce your error rate from 1% to .01%.



RETURNING FROM A PROMISE CALLBACK

Let’s return one last time to the earlier URL-fetching example, and consider the c1 callback that we passed to the first . t hen( )  invocation. Notice that there are three ways that c1 can terminate. It can return normally with the Promise returned by the . j s on( )  call. This causes p2 to be resolved, but whether that Promise is fulfilled or rejected depends on what happens with the newly returned Promise. c1 can also return normally with the value nul l , which causes p2 to be fulfilled immediately. Finally, c1 can terminate by throwing an error, which causes p2 to be rejected. These are the three possible outcomes for a Promise, and the code in c1 demonstrates how the callback can cause each outcome.

In a Promise chain, the value returned (or thrown) at one stage of the chain becomes the input to the next stage of the chain, so it is critical to get this right. In practice, forgetting to return a value from a callback function is actually a common source of Promise-related bugs, and this is exacerbated by JavaScript’s arrow function shortcut syntax. Consider this line of code that we saw earlier:

. c at c h( e   =>   wai t ( 500) . t hen( quer yDat abas e) )


Recall from Chapter 8 that arrow functions allow a lot of shortcuts. Since there is exactly one argument (the error value), we can omit the parentheses. Since the body of the function is a single expression, we can omit the curly braces around the function body, and the value of the expression becomes the return value of the function. Because of these shortcuts, the preceding code is correct. But consider this innocuous-seeming change:

. c at c h( e   =>   {   wai t ( 500) . t hen( quer yDat abas e)    } )


By adding the curly braces, we no longer get the automatic return. This function now returns undef i ned instead of returning a Promise, which means that the next stage in this Promise chain will be invoked with undef i ned as its input rather than the result of the retried query. It is a subtle error that may not be easy to debug.




13.2.5 Promises in Parallel

We’ve spent a lot of time talking about Promise chains for sequentially running the asynchronous steps of a larger asynchronous operation. Sometimes, though, we want to execute a number of asynchronous operations in parallel. The function Pr omi s e. al l ( )  can do this.
Pr omi s e. al l ( )  takes an array of Promise objects as its input and returns a Promise. The returned Promise will be rejected if any of the input

Promises are rejected. Otherwise, it will be fulfilled with an array of the fulfillment values of each of the input Promises. So, for example, if you want to fetch the text content of multiple URLs, you could use code like this:

/ /   We   s t ar t   wi t h   an   ar r ay   of    URL s
c ons t   ur l s   =   [    / *   z er o   or   mor e   URL s   her e   */   ] ;
/ /   And   c onver t   i t   t o   an   ar r ay   of    Pr omi s e   obj ec t s
pr omi s es   =   ur l s . map( ur l	=>   f et c h( ur l ) . t hen( r   =>   r . t ext ( ) ) ) ; / /   Now  get   a   Pr omi s e   t o   r un   al l	t hos e   Pr omi s es   i n   par al l el Pr omi s e. al l ( pr omi s es )
. t hen( bodi es   =>   {    / *   do   s omet hi ng   wi t h   t he   ar r ay   of    s t r i ngs */   } )
. c at c h( e   =>   c ons ol e. er r or ( e) ) ;


Pr omi s e. al l ( )  is slightly more flexible than described before. The input array can contain both Promise objects and non-Promise values. If an element of the array is not a Promise, it is treated as if it is the value of an already fulfilled Promise and is simply copied unchanged into the output array.

The Promise returned by Pr omi s e. al l ( )  rejects when any of the input Promises is rejected. This happens immediately upon the first rejection and can happen while other input Promises are still pending. In ES2020, Pr omi s e. al l Set t l ed( )  takes an array of input Promises and returns a Promise, just like Pr omi s e. al l ( )  does. But
Pr omi s e. al l Set t l ed( )  never rejects the returned Promise, and it does not fulfill that Promise until all of the input Promises have settled. The Promise resolves to an array of objects, with one object for each input Promise. Each of these returned objects has a s t at us  property set to “fulfilled” or “rejected.” If the status is “fulfilled”, then the object will also have a val ue property that gives the fulfillment value. And if the status is “rejected”, then the object will also have a r eas on property that gives the

error or rejection value of the corresponding Promise:


Pr omi s e. al l Set t l ed( [ Pr omi s e. r es ol ve( 1) ,	Pr omi s e. r ej ec t ( 2) , 3] ) . t hen( r es ul t s   =>   {
r es ul t s [ 0]	/ /   =>   {    s t at us :	" f ul f i l l ed" ,	val ue:	1   } r es ul t s [ 1]	/ /   =>   {    s t at us :	" r ej ec t ed" ,    r eas on:	2   } r es ul t s [ 2]	/ /   =>   {    s t at us :	" f ul f i l l ed" ,	val ue:	3   }
} ) ;


Occasionally, you may want to run a number of Promises at once but may only care about the value of the first one to fulfill. In that case, you can use Pr omi s e. r ace( )  instead of Pr omi s e. al l ( ) . It returns a Promise that is fulfilled or rejected when the first of the Promises in the input array is fulfilled or rejected. (Or, if there are any non-Promise values in the input array, it simply returns the first of those.)


13.2.6 Making Promises

We’ve used the Promise-returning function f et ch( )  in many of the previous examples because it is one of the simplest functions built in to web browsers that returns a Promise. Our discussion of Promises has also relied on hypothetical Promise-returning functions get J SON( )  and
wai t ( ) . Functions written to return Promises really are quite useful, and this section shows how you can create your own Promise-based APIs. In particular, we’ll show implementations of get J SON( )  and wai t ( ) .

PROMISES BASED ON OTHER PROMISES

It is easy to write a function that returns a Promise if you have some other Promise-returning function to start with. Given a Promise, you can always create (and return) a new one by calling . t hen( ) . So if we use the existing f et ch( )  function as a starting point, we can write get J SON( ) like this:

f unc t i on   get J SON( ur l )    {
r et ur n   f et c h( ur l ) . t hen( r es pons e   =>   r es pons e. j s on( ) ) ; }


The code is trivial because the Response object of the f et ch( )  API has a predefined j s on( )  method. The j s on( )  method returns a Promise, which we return from our callback (the callback is an arrow function with a single-expression body, so the return is implicit), so the Promise returned by get J SON( )  resolves to the Promise returned by
r es pons e. j s on( ) . When that Promise fulfills, the Promise returned by get J SON( )  fulfills to the same value. Note that there is no error handling in this get J SON( )  implementation. Instead of checking
r es pons e. ok and the Content-Type header, we instead just allow the
j s on( )  method to reject the Promise it returned with a SyntaxError if the response body cannot be parsed as JSON.

Let’s write another Promise-returning function, this time using get J SON( )  as the source of the initial Promise:


f unc t i on   get Hi ghSc or e( )    {
r et ur n   get J SON( " / api / us er / pr of i l e" ) . t hen( pr of i l e   => pr of i l e. hi ghSc or e) ;
}


We’re assuming that this function is part of some sort of web-based game and that the URL “/api/user/profile” returns a JSON-formatted data structure that includes a hi ghScor e property.

PROMISES BASED ON SYNCHRONOUS VALUES

Sometimes, you may need to implement an existing Promise-based API and return a Promise from a function, even though the computation to be performed does not actually require any asynchronous operations. In that

case, the static methods Pr omi s e. r es ol ve( )  and
Pr omi s e. r ej ect ( )  will do what you want. Pr omi s e. r es ol ve( ) takes a value as its single argument and returns a Promise that will immediately (but asynchronously) be fulfilled to that value. Similarly,
Pr omi s e. r ej ect ( )  takes a single argument and returns a Promise that will be rejected with that value as the reason. (To be clear: the Promises returned by these static methods are not already fulfilled or rejected when they are returned, but they will fulfill or reject immediately after the current synchronous chunk of code has finished running. Typically, this happens within a few milliseconds unless there are many pending asynchronous tasks waiting to run.)

Recall from §13.2.3 that a resolved Promise is not the same thing as a fulfilled Promise. When we call Pr omi s e. r es ol ve( ) , we typically pass the fulfillment value to create a Promise object that will very soon fulfill to that value. The method is not named Pr omi s e. f ul f i l l ( ) , however. If you pass a Promise p1 to Pr omi s e. r es ol ve( ) , it will return a new Promise p2, which is immediately resolved, but which will not be fulfilled or rejected until p1 is fulfilled or rejected.


It is possible, but unusual, to write a Promise-based function where the value is computed synchronously and returned asynchronously with Pr omi s e. r es ol ve( ) . It is fairly common, however, to have
synchronous special cases within an asynchronous function, and you can handle these special cases with Pr omi s e. r es ol ve( )  and
Pr omi s e. r ej ect ( ) . In particular, if you detect error conditions (such as bad argument values) before beginning an asynchronous operation, you can report that error by returning a Promise created with
Pr omi s e. r ej ect ( ) . (You could also just throw an error

synchronously in that case, but that is considered poor form because then the caller of your function needs to write both a synchronous cat ch clause and use an asynchronous . cat ch( )  method to handle errors.) Finally, Pr omi s e. r es ol ve( )  is sometimes useful to create the initial Promise in a chain of Promises. We’ll see a couple of examples that use it this way.

PROMISES FROM SCRATCH

For both get J SON( )  and get Hi ghScor e( ) , we started off by calling an existing function to get an initial Promise, and created and returned a new Promise by calling the . t hen( )  method of that initial Promise. But what about writing a Promise-returning function when you can’t use another Promise-returning function as the starting point? In that case, you use the Pr omi s e( )  constructor to create a new Promise object that you have complete control over. Here’s how it works: you invoke the
Pr omi s e( )  constructor and pass a function as its only argument. The function you pass should be written to expect two parameters, which, by convention, should be named r es ol ve and r ej ect . The constructor synchronously calls your function with function arguments for the
r es ol ve and r ej ect  parameters. After calling your function, the
Pr omi s e( )  constructor returns the newly created Promise. That returned Promise is under the control of the function you passed to the constructor. That function should perform some asynchronous operation and then call the r es ol ve function to resolve or fulfill the returned Promise or call the r ej ect  function to reject the returned Promise. Your function does not have to be asynchronous: it can call r es ol ve or r ej ect  synchronously, but the Promise will still be resolved, fulfilled, or rejected asynchronously if you do this.

It can be hard to understand the functions passed to a function passed to a constructor by just reading about it, but hopefully some examples will make this clear. Here’s how to write the Promise-based wai t ( )  function that we used in various examples earlier in the chapter:

f unc t i on   wai t ( dur at i on)    {
/ /   Cr eat e   and   r et ur n   a   new  Pr omi s e
r et ur n   new  Pr omi s e( ( r es ol ve,	r ej ec t )    =>   {    / /   Thes e   c ont r ol t he   Pr omi s e
/ /   I f    t he   ar gument   i s   i nval i d,	r ej ec t   t he   Pr omi s e i f    ( dur at i on   <   0)    {
r ej ec t ( new  Er r or ( " Ti me   t r avel	not   yet i mpl ement ed" ) ) ;
}
/ /   Ot her wi s e,	wai t   as ync hr onous l y   and   t hen   r es ol ve   t he Pr omi s e.
/ /   s et Ti meout   wi l l	i nvoke   r es ol ve( )    wi t h   no   ar gument s , whi c h   means
/ /   t hat   t he   Pr omi s e   wi l l	f ul f i l l	wi t h   t he   undef i ned val ue.
s et Ti meout ( r es ol ve,	dur at i on) ;
} ) ; }


Note that the pair of functions that you use to control the fate of a Promise created with the Pr omi s e( )  constructor are named r es ol ve( )  and
r ej ect ( ) , not f ul f i l l ( )  and r ej ect ( ) . If you pass a Promise to r es ol ve( ) , the returned Promise will resolve to that new Promise. Often, however, you will pass a non-Promise value, which fulfills the returned Promise with that value.

Example 13-1 is another example of using the Pr omi s e( )  constructor. This one implements our get J SON( )  function for use in Node, where the f et ch( )  API is not built in. Remember that we started this chapter with a discussion of asynchronous callbacks and events. This example uses both callbacks and event handlers and is a good demonstration,

therefore, of how we can implement Promise-based APIs on top of other styles of asynchronous programming.

Example 13-1. An asynchronous getJSON() function c ons t   ht t p   =   r equi r e( " ht t p" ) ;

f unc t i on   get J SON( ur l )    {
/ /   Cr eat e   and   r et ur n   a   new  Pr omi s e
r et ur n   new  Pr omi s e( ( r es ol ve,	r ej ec t )    =>   {
/ /   St ar t   an   HTTP   GET   r eques t   f or   t he   s pec i f i ed   URL
r eques t   =   ht t p. get ( ur l ,	r es pons e   =>   {    / /   c al l ed   when r es pons e   s t ar t s
/ /   Rej ec t   t he   Pr omi s e   i f    t he   HTTP   s t at us   i s   wr ong i f    ( r es pons e. s t at us Code   ! ==   200)    {
r ej ec t ( new  Er r or ( ` HTTP   s t at us ${ r es pons e. s t at us Code} ` ) ) ;
r es pons e. r es ume( ) ;	/ /   s o   we   don' t   l eak   memor y }
/ /   And   r ej ec t   i f    t he   r es pons e   header s   ar e   wr ong el s e   i f    ( r es pons e. header s [ " c ont ent - t ype" ]    ! ==
" appl i c at i on/ j s on" )    {
r ej ec t ( new  Er r or ( " I nval i d   c ont ent - t ype" ) ) ; r es pons e. r es ume( ) ;	/ /   don' t   l eak   memor y
}
el s e   {
/ /   Ot her wi s e,	r egi s t er   event s   t o   r ead   t he   body   of t he   r es pons e
l et   body   =   " " ;
r es pons e. s et Enc odi ng( " ut f - 8" ) ;
r es pons e. on( " dat a" ,	c hunk   =>   {    body   +=   c hunk;	} ) ; r es pons e. on( " end" ,    ( )    =>   {
/ /   When   t he   r es pons e   body   i s   c ompl et e,	t r y   t o par s e   i t
t r y   {
l et   par s ed   =   J SON. par s e( body) ;
/ /   I f    i t   par s ed   s uc c es s f ul l y,	f ul f i l l	t he Pr omi s e
r es ol ve( par s ed) ;
}    c at c h( e)    {
/ /   I f    par s i ng   f ai l ed,	r ej ec t   t he   Pr omi s e r ej ec t ( e) ;
}

} ) ; }
} ) ;

/ /   We   al s o   r ej ec t   t he   Pr omi s e   i f    t he we
/ /   even   get   a   r es pons e   ( s uc h   as   when

r eques t   f ai l s   bef or e

t he   net wor k   i s   down)

r eques t . on( " er r or " ,	er r or   =>   { r ej ec t ( er r or ) ;
} ) ; } ) ;
}


13.2.7 Promises in Sequence

Pr omi s e. al l ( )  makes it easy to run an arbitrary number of Promises in parallel. And Promise chains make it easy to express a sequence of a fixed number of Promises. Running an arbitrary number of Promises in sequence is trickier, however. Suppose, for example, that you have an array of URLs to fetch, but that to avoid overloading your network, you want to fetch them one at a time. If the array is of arbitrary length and unknown content, you can’t write out a Promise chain in advance, so you need to build one dynamically, with code like this:

f unc t i on   f et c hSequent i al l y( ur l s )    {
/ /   We' l l	s t or e   t he   URL   bodi es   her e   as   we   f et c h   t hem c ons t   bodi es   =   [ ] ;

/ /   Her e' s   a   Pr omi s e- r et ur ni ng   f unc t i on   t hat   f et c hes   one   body f unc t i on   f et c hOne( ur l )    {
r et ur n   f et c h( ur l )
. t hen( r es pons e   =>   r es pons e. t ext ( ) ) . t hen( body   =>   {


pur pos el y

undef i ned)

/ /   We   s ave   t he   body   t o   t he

/ /   omi t t i ng   a   r et ur n   val ue

ar r ay,	and   we' r e

her e   ( r et ur ni ng

bodi es . pus h( body) ; } ) ;
}


/ /   St ar t   wi t h   a   Pr omi s e   t hat   wi l l	f ul f i l l	r i ght   away   ( wi t h val ue   undef i ned)
l et   p   =   Pr omi s e. r es ol ve( undef i ned) ;


/ /   Now  l oop   t hr ough   t he c hai n
/ /   of    ar bi t r ar y   l engt h, t he   c hai n

des i r ed   URL s ,	bui l di ng   a

f et c hi ng   one   URL   at   eac h

Pr omi s e

s t age   of

f or ( ur l	of    ur l s )    {
p   =   p. t hen( ( )    =>   f et c hOne( ur l ) ) ; }

/ /   When   t he   l as t   Pr omi s e   i n   t hat   c hai n   i s   f ul f i l l ed,	t hen t he
/ /   bodi es   ar r ay   i s   r eady.	So   l et ' s   r et ur n   a   Pr omi s e   f or   t hat / /   bodi es   ar r ay.	Not e   t hat   we   don' t   i nc l ude   any   er r or
handl er s :
/ /   we   want   t o   al l ow  er r or s   t o   pr opagat e   t o   t he   c al l er . r et ur n   p. t hen( ( )    =>   bodi es ) ;
}


With this f et chSequent i al l y( )  function defined, we could fetch the URLs one at a time with code much like the fetch-in-parallel code we used earlier to demonstrate Pr omi s e. al l ( ) :

f et c hSequent i al l y( ur l s )
. t hen( bodi es   =>   {    / *   do   s omet hi ng   wi t h   t he   ar r ay   of    s t r i ngs */   } )
. c at c h( e   =>   c ons ol e. er r or ( e) ) ;


The f et chSequent i al l y( )  function starts by creating a Promise that will fulfill immediately after it returns. It then builds a long, linear Promise chain off of that initial Promise and returns the last Promise in the chain. It is like setting up a row of dominoes and then knocking the first one over.

There is another (possibly more elegant) approach that we can take. Rather than creating the Promises in advance, we can have the callback for each

Promise create and return the next Promise. That is, instead of creating and chaining a bunch of Promises, we instead create Promises that resolve to other Promises. Rather than creating a domino-like chain of Promises, we are instead creating a sequence of Promises nested one inside the other like a set of matryoshka dolls. With this approach, our code can return the first (outermost) Promise, knowing that it will eventually fulfill (or reject!) to the same value that the last (innermost) Promise in the sequence does. The pr omi s eSequence( )  function that follows is written to be generic and is not specific to URL fetching. It is here at the end of our discussion of Promises because it is complicated. If you’ve read this chapter carefully, however, I hope you’ll be able to understand how it works. In particular, note that the nested function inside pr omi s eSequence( ) appears to call itself recursively, but because the “recursive” call is through a t hen( )  method, there is not actually any traditional recursion happening:

/ /   Thi s   f unc t i on   t akes   an   ar r ay   of    i nput   val ues   and   a " pr omi s eMaker "   f unc t i on.
/ /   For   any   i nput   val ue   x   i n   t he   ar r ay,	pr omi s eMaker ( x)    s houl d r et ur n   a   Pr omi s e
/ /   t hat   wi l l	f ul f i l l	t o   an   out put   val ue.	Thi s   f unc t i on   r et ur ns   a Pr omi s e
/ /   t hat   f ul f i l l s   t o   an   ar r ay   of    t he   c omput ed   out put   val ues . / /
/ /   Rat her   t han   c r eat i ng   t he   Pr omi s es   al l	at   onc e   and   l et t i ng t hem r un   i n
/ /   par al l el ,	however ,	pr omi s eSequenc e( )    onl y   r uns   one   Pr omi s e   at a   t i me
/ /   and   does   not   c al l	pr omi s eMaker ( )    f or   a   val ue   unt i l	t he pr evi ous   Pr omi s e
/ /   has   f ul f i l l ed.
f unc t i on   pr omi s eSequenc e( i nput s ,	pr omi s eMaker )    {
/ /   Make   a   pr i vat e   c opy   of    t he   ar r ay   t hat   we   c an   modi f y i nput s   =   [ . . . i nput s ] ;

/ /   Her e' s   t he   f unc t i on   t hat   we' l l	us e   as   a   Pr omi s e   c al l bac k / /   Thi s   i s   t he   ps eudor ec ur s i ve   magi c   t hat   makes   t hi s   al l
wor k.

f unc t i on   handl eNext I nput ( out put s )    { i f    ( i nput s . l engt h   ===   0)    {
/ /   I f    t her e   ar e   no   mor e   i nput s   l ef t ,	t hen   r et ur n   t he ar r ay
/ /   of    out put s ,	f i nal l y   f ul f i l l i ng   t hi s   Pr omi s e   and al l	t he
/ /   pr evi ous   r es ol ved- but - not - f ul f i l l ed   Pr omi s es . r et ur n   out put s ;

}

we' l l

Pr omi s e

el s e   {
/ /   I f    t her e

/ /   r et ur n   a

/ /   wi t h   t he


ar e   s t i l l	i nput   val ues   t o   pr oc es s ,	t hen

Pr omi s e   obj ec t ,	r es ol vi ng   t he   c ur r ent

f ut ur e   val ue   f r om a   new  Pr omi s e.

l et   next I nput   =   i nput s . s hi f t ( ) ;	/ /   Get   t he   next i nput   val ue,
r et ur n   pr omi s eMaker ( next I nput )	/ /   c omput e   t he   next out put   val ue,
/ /   Then   c r eat e   a   new  out put s   ar r ay   wi t h   t he   new out put   val ue
. t hen( out put   =>   out put s . c onc at ( out put ) )
/ /   Then   " r ec ur s e" ,	pas s i ng   t he   new,	l onger , out put s   ar r ay
. t hen( handl eNext I nput ) ;
} }


/ /   St ar t   wi t h   a us e
/ /   t he   f unc t i on

Pr omi s e   t hat

above   as   i t s

f ul f i l l s   t o   an   empt y   ar r ay   and

c al l bac k.

r et ur n   Pr omi s e. r es ol ve( [ ] ) . t hen( handl eNext I nput ) ; }


This pr omi s eSequence( )  function is intentionally generic. We can use it to fetch URLs with code like this:

/ /   Gi ven   a   URL ,	r et ur n   a   Pr omi s e   t hat   f ul f i l l s   t o   t he   URL   body t ext
f unc t i on   f et c hBody( ur l )    {    r et ur n   f et c h( ur l ) . t hen( r   =>   r . t ext ( ) ) ;
}
/ /   Us e   i t   t o   s equent i al l y   f et c h   a   bunc h   of    URL   bodi es pr omi s eSequenc e( ur l s ,	f et c hBody)
. t hen( bodi es   =>   {    / *   do   s omet hi ng   wi t h   t he   ar r ay   of    s t r i ngs */   } )

. c at c h( c ons ol e. er r or ) ;



13.3 async and await

ES2017 introduces two new keywords—as ync and awai t —that represent a paradigm shift in asynchronous JavaScript programming. These new keywords dramatically simplify the use of Promises and allow us to write Promise-based, asynchronous code that looks like synchronous code that blocks while waiting for network responses or other asynchronous events. Although it is still important to understand how Promises work, much of their complexity (and sometimes even their very presence!) vanishes when you use them with as ync and awai t .


As we discussed earlier in the chapter, asynchronous code can’t return a value or throw an exception the way that regular synchronous code can. And this is why Promises are designed the way the are. The value of a fulfilled Promise is like the return value of a synchronous function. And the value of a rejected Promise is like a value thrown by a synchronous function. This latter similarity is made explicit by the naming of the
. cat ch( )  method. as ync and awai t  take efficient, Promise-based code and hide the Promises so that your asynchronous code can be as easy to read and as easy to reason about as inefficient, blocking, synchronous code.


13.3.1 await Expressions

The awai t  keyword takes a Promise and turns it back into a return value or a thrown exception. Given a Promise object p, the expression awai t
p waits until p settles. If p fulfills, then the value of awai t   p is the fulfillment value of p. On the other hand, if p is rejected, then the awai t

p expression throws the rejection value of p. We don’t usually use awai t with a variable that holds a Promise; instead, we use it before the invocation of a function that returns a Promise:

l et   r es pons e   =   awai t   f et c h( " / api / us er / pr of i l e" ) ; l et   pr of i l e   =   awai t   r es pons e. j s on( ) ;


It is critical to understand right away that the awai t  keyword does not cause your program to block and literally do nothing until the specified Promise settles. The code remains asynchronous, and the awai t  simply disguises this fact. This means that any code that uses awai t  is itself asynchronous.


13.3.2 async Functions

Because any code that uses awai t  is asynchronous, there is one critical rule: you can only use the awai t  keyword within functions that have been declared with the as ync keyword. Here’s a version of the
get Hi ghScor e( )  function from earlier in the chapter, rewritten to use as ync and awai t :

as ync   f unc t i on   get Hi ghSc or e( )    {
l et   r es pons e   =   awai t   f et c h( " / api / us er / pr of i l e" ) ; l et   pr of i l e   =   awai t   r es pons e. j s on( ) ;
r et ur n   pr of i l e. hi ghSc or e; }


Declaring a function as ync means that the return value of the function will be a Promise even if no Promise-related code appears in the body of the function. If an as ync function appears to return normally, then the Promise object that is the real return value of the function will resolve to that apparent return value. And if an as ync function appears to throw an

exception, then the Promise object that it returns will be rejected with that exception.


The get Hi ghScor e( )  function is declared as ync, so it returns a Promise. And because it returns a Promise, we can use the awai t keyword with it:

di s pl ayHi ghSc or e( awai t   get Hi ghSc or e( ) ) ;


But remember, that line of code will only work if it is inside another as ync function! You can nest awai t  expressions within as ync functions as deeply as you want. But if you’re at the top level2 or are
inside a function that is not as ync for some reason, then you can’t use awai t  and have to deal with a returned Promise in the regular way:

get Hi ghSc or e( ) . t hen( di s pl ayHi ghSc or e) . c at c h( c ons ol e. er r or ) ;


You can use the as ync keyword with any kind of function. It works with the f unct i on keyword as a statement or as an expression. It works with arrow functions and with the method shortcut form in classes and object literals. (See Chapter 8 for more about the various ways to write functions.)


13.3.3 Awaiting Multiple Promises

Suppose that we’ve written our get J SON( )  function using as ync:


as ync   f unc t i on   get J SON( ur l )    {
l et   r es pons e   =   awai t   f et c h( ur l ) ;
l et   body   =   awai t   r es pons e. j s on( ) ; r et ur n   body;
}

And now suppose that we want to fetch two JSON values with this function:


l et   val ue1   =   awai t
l et   val ue2   =   awai t

get J SON( ur l 1) ;
get J SON( ur l 2) ;



The problem with this code is that it is unnecessarily sequential: the fetch of the second URL will not begin until the first fetch is complete. If the second URL does not depend on the value obtained from the first URL, then we should probably try to fetch the two values at the same time. This is a case where the Promise-based nature of as ync functions shows. In order to await a set of concurrently executing as ync functions, we use Pr omi s e. al l ( )  just as we would if working with Promises directly:


l et   [ val ue1,	val ue2]    =   awai t   Pr omi s e. al l ( [ get J SON( ur l 1) , get J SON( ur l 2) ] ) ;


13.3.4 Implementation Details

Finally, in order to understand how as ync functions work, it may help to think about what is going on under the hood.

Suppose you write an as ync function like this:


as ync   f unc t i on   f ( x)    {    / *   body   */   }


You can think about this as a Promise-returning function wrapped around the body of your original function:

f unc t i on   f ( x)    {
r et ur n   new  Pr omi s e( f unc t i on( r es ol ve,	r ej ec t )    { t r y   {
r es ol ve( ( f unc t i on( x)    {    / *   body   */   } ) ( x) ) ; }

c at c h( e)    {
r ej ec t ( e) ; }
} ) ; }


It is harder to express the awai t  keyword in terms of a syntax transformation like this one. But think of the awai t  keyword as a marker that breaks a function body up into separate, synchronous chunks. An ES2017 interpreter can break the function body up into a sequence of separate subfunctions, each of which gets passed to the t hen( )  method of the awai t -marked Promise that precedes it.


13.4 Asynchronous Iteration

We began this chapter with a discussion of callback- and event-based asynchrony, and when we introduced Promises, we noted that they were useful for single-shot asynchronous computations but were not suitable for use with sources of repetitive asynchronous events, such as
s et I nt er val ( ) , the “click” event in a web browser, or the “data” event on a Node stream. Because single Promises do not work for sequences of asynchronous events, we also cannot use regular as ync functions and the awai t  statements for these things.


ES2018 provides a solution, however. Asynchronous iterators are like the iterators described in Chapter 12, but they are Promise-based and are meant to be used with a new form of the f or / of  loop: f or / awai t .


13.4.1 The for/await Loop

Node 12 makes its readable streams asynchronously iterable. This means you can read successive chunks of data from a stream with a f or / awai t

loop like this one:


c ons t   f s   =   r equi r e( " f s " ) ;

as ync   f unc t i on   par s eFi l e( f i l ename)    {
l et   s t r eam =   f s . c r eat eReadSt r eam( f i l ename,	{    enc odi ng:	" ut f -8" } ) ;
f or   awai t   ( l et   c hunk   of    s t r eam)    {
par s eChunk( c hunk) ;	/ /   As s ume   par s eChunk( )    i s   def i ned el s ewher e
} }


Like a regular awai t  expression, the f or / awai t  loop is Promise-based. Roughly speaking, the asynchronous iterator produces a Promise and the f or / awai t  loop waits for that Promise to fulfill, assigns the fulfillment value to the loop variable, and runs the body of the loop. And then it starts over, getting another Promise from the iterator and waiting for that new Promise to fulfill.

Suppose you have an array of URLs:


c ons t   ur l s   =   [ ur l 1,	ur l 2,	ur l 3] ;


You can call f et ch( )  on each URL to get an array of Promises:


c ons t   pr omi s es   =   ur l s . map( ur l	=>   f et c h( ur l ) ) ;


We saw earlier in the chapter that we could now use Pr omi s e. al l ( )  to wait for all the Promises in the array to be fulfilled. But suppose we want the results of the first fetch as soon as they become available and don’t want to wait for all the URLs to be fetched. (Of course, the first fetch might take longer than any of the others, so this is not necessarily faster than using Pr omi s e. al l ( ) .) Arrays are iterable, so we can iterate

through the array of promises with a regular f or / of  loop:


f or ( c ons t   pr omi s e   of    pr omi s es )    { r es pons e   =   awai t   pr omi s e; handl e( r es pons e) ;
}


This example code uses a regular f or / of  loop with a regular iterator. But because this iterator returns Promises, we can also use the new
f or / awai t  for slightly simpler code:


f or   awai t   ( c ons t   r es pons e   of    pr omi s es )    { handl e( r es pons e) ;
}


In this case, the f or / awai t  loop just builds the awai t  call into the loop and makes our code slightly more compact, but the two examples do exactly the same thing. Importantly, both examples will only work if they are within functions declared as ync; a f or / awai t  loop is no different than a regular awai t  expression in that way.


It is important to realize, however, that we’re using f or / awai t  with a regular iterator in this example. Things are more interesting with fully asynchronous iterators.


13.4.2 Asynchronous Iterators

Let’s review some terminology from Chapter 12. An iterable object is one that can be used with a f or / of  loop. It defines a method with the symbolic name Symbol . i t er at or . This method returns an iterator object. The iterator object has a next ( )  method, which can be called repeatedly to obtain the values of the iterable object. The next ( )  method

of the iterator object returns iteration result objects. The iteration result object has a val ue property and/or a done property.


Asynchronous iterators are quite similar to regular iterators, but there are two important differences. First, an asynchronously iterable object implements a method with the symbolic name
Symbol . as yncI t er at or  instead of Symbol . i t er at or . (As we saw earlier, f or / awai t  is compatible with regular iterable objects but it prefers asynchronously iterable objects, and tries the
Symbol . as yncI t er at or  method before it tries the
Symbol . i t er at or  method.) Second, the next ( )  method of an asynchronous iterator returns a Promise that resolves to an iterator result object instead of returning an iterator result object directly.


NOTE

In the previous section, when we used f or / awai t  on a regular, synchronously
iterable array of Promises, we were working with synchronous iterator result objects in which the val ue property was a Promise object but the done property was synchronous. True asynchronous iterators return Promises for iteration result objects, and both the val ue and the done properties are asynchronous. The difference is a subtle one: with asynchronous iterators, the choice about when iteration ends can be made asynchronously.




13.4.3 Asynchronous Generators

As we saw in Chapter 12, the easiest way to implement an iterator is often to use a generator. The same is true for asynchronous iterators, which we can implement with generator functions that we declare as ync. An async generator has the features of async functions and the features of generators: you can use awai t  as you would in a regular async function,

and you can use yi el d as you would in a regular generator. But values that you yi el d are automatically wrapped in Promises. Even the syntax for async generators is a combination: as ync   f unct i on and
f unct i on  * combine into as ync   f unct i on  *. Here is an example that shows how you might use an async generator and a f or / awai t  loop to repetitively run code at fixed intervals using loop syntax instead of a
s et I nt er val ( )  callback function:


/ /   A  Pr omi s e- bas ed   wr apper   ar ound   s et Ti meout ( )    t hat   we   c an   us e awai t   wi t h.
/ /   Ret ur ns   a   Pr omi s e   t hat   f ul f i l l s   i n   t he   s pec i f i ed   number   of mi l l i s ec onds
f unc t i on   el aps edTi me( ms )    {
r et ur n   new  Pr omi s e( r es ol ve   =>   s et Ti meout ( r es ol ve,	ms ) ) ; }


/ /   An   as ync   gener at or   f unc t i on   t hat yi el ds   i t
/ /   a   s pec i f i ed   ( or   i nf i ni t e)    number i nt er val .

i nc r ement s   a   c ount er   and

of    t i mes   at   a   s pec i f i ed

as ync   f unc t i on*   c l oc k( i nt er val ,	max=I nf i ni t y)    {
f or ( l et   c ount   =   1;	c ount   <=   max;	c ount ++)    {    / /   r egul ar   f or l oop
awai t   el aps edTi me( i nt er val ) ;	/ /   wai t   f or   t i me t o   pas s
yi el d   c ount ;	/ /   yi el d   t he c ount er
} }

/ /   A  t es t   f unc t i on   t hat   us es   t he   as ync   gener at or   wi t h   f or / awai t as ync   f unc t i on   t es t ( )    {	/ /   As ync   s o   we   c an us e   f or / awai t
f or   awai t   ( l et   t i c k   of    c l oc k( 300,	100) )    {    / /   L oop   100   t i mes ever y   300ms
c ons ol e. l og( t i c k) ; }
}


13.4.4 Implementing Asynchronous Iterators

Instead of using async generators to implement asynchronous iterators, it is also possible to implement them directly by defining an object with a Symbol . as yncI t er at or ( )  method that returns an object with a next ( )  method that returns a Promise that resolves to an iterator result object. In the following code, we re-implement the cl ock( )  function from the preceding example so that it is not a generator and instead just returns an asynchronously iterable object. Notice that the next ( )  method in this example does not explicitly return a Promise; instead, we just declare next ( )  to be async:

f unc t i on   c l oc k( i nt er val ,	max=I nf i ni t y)    {

/ /   A  Pr omi s e- i f i ed   ver s i on awai t   wi t h.
/ /   Not e   t hat   t hi s   t akes   an i nt er val .

of    s et Ti meout

abs ol ut e   t i me

t hat   we   c an   us e

i ns t ead   of    an

f unc t i on   unt i l ( t i me)    {
r et ur n   new  Pr omi s e( r es ol ve   =>   s et Ti meout ( r es ol ve,	t i me   -Dat e. now( ) ) ) ;
}

/ /   Ret ur n   an   as ync hr onous l y   i t er abl e   obj ec t r et ur n   {
s t ar t Ti me:    Dat e. now( ) ,       / /   Remember   when   we   s t ar t ed c ount :    1,                                          / /   Remember   whi c h   i t er at i on
we' r e   on
as ync   next ( )    {	/ /   The   next ( )    met hod   makes   t hi s an   i t er at or
i f    ( t hi s . c ount   >   max)    {	/ /   Ar e   we   done?
r et ur n   {    done:	t r ue   } ;	/ /   I t er at i on   r es ul t i ndi c at i ng   done
}
/ /   Fi gur e   out   when   t he   next   i t er at i on   s houl d   begi n, l et   t ar get Ti me   =   t hi s . s t ar t Ti me   +   t hi s . c ount   *
i nt er val ;
/ /   wai t   unt i l    t hat   t i me, awai t   unt i l ( t ar get Ti me) ;
/ /   and   r et ur n   t he   c ount   val ue   i n   an   i t er at i on   r es ul t obj ec t .
r et ur n   {    val ue:	t hi s . c ount ++   } ;

} ,
/ /   Thi s   met hod   means   t hat   t hi s   i t er at or   obj ec t   i s   al s o an   i t er abl e.
[ Symbol . as ync I t er at or ] ( )    {    r et ur n   t hi s ;	}
} ; }


This iterator-based version of the cl ock( )  function fixes a flaw in the generator-based version. Note that, in this newer code, we target the absolute time at which each iteration should begin and subtract the current time from that in order to compute the interval that we pass to
s et Ti meout ( ) . If we use cl ock( )  with a f or / awai t  loop, this version will run loop iterations more precisely at the specified interval because it accounts for the time required to actually run the body of the loop. But this fix isn’t just about timing accuracy. The f or / awai t  loop always waits for the Promise returned by one iteration to be fulfilled before it begins the next iteration. But if you use an asynchronous iterator without a f or / awai t  loop, there is nothing to prevent you from calling the next ( )  method whenever you want. With the generator-based version of cl ock( ) , if you call the next ( )  method three times sequentially, you’ll get three Promises that will all fulfill at almost exactly the same time, which is probably not what you want. The iterator-based version we’ve implemented here does not have that problem.

The benefit of asynchronous iterators is that they allow us to represent streams of asynchronous events or data. The cl ock( )  function discussed previously was fairly simple to write because the source of the asynchrony was the s et Ti meout ( )  calls we were making ourselves. But when we are trying to work with other asynchronous sources, such as the triggering of event handlers, it becomes substantially harder to implement asynchronous iterators—we typically have a single event handler function

that responds to events, but each call to the iterator’s next ( )  method must return a distinct Promise object, and multiple calls to next ( )  may occur before the first Promise resolves. This means that any asynchronous iterator method must be able to maintain an internal queue of Promises that it resolves in order as asynchronous events are occurring. If we encapsulate this Promise-queueing behavior into an AsyncQueue class, then it becomes much easier to write asynchronous iterators based on AsyncQueue.3


The AsyncQueue class that follows has enqueue( )  and dequeue( ) methods as you’d expect for a queue class. The dequeue( )  method returns a Promise rather than an actual value, however, which means that it is OK to call dequeue( )  before enqueue( )  has ever been called. The AsyncQueue class is also an asynchronous iterator, and is intended to be used with a f or / awai t  loop whose body runs once each time a new value is asynchronously enqueued. (AsyncQueue has a cl os e( )  method. Once called, no more values can be enqueued. When a closed queue is empty, the f or / awai t  loop will stop looping.)


Note that the implementation of AsyncQueue does not use as ync or awai t  and instead works directly with Promises. The code is somewhat complicated, and you can use it to test your understanding of the material we’ve covered in this long chapter. Even if you don’t fully understand the AsyncQueue implementation, do take a look at the shorter example that follows it: it implements a simple but very interesting asynchronous iterator on top of AsyncQueue.

/ **
*   An   as ync hr onous l y   i t er abl e   queue   c l as s .	Add   val ues   wi t h enqueue( )
*   and   r emove   t hem wi t h   dequeue( ) .	dequeue( )    r et ur ns   a   Pr omi s e, whi c h

*   means   t hat   val ues   c an   be   dequeued   bef or e   t hey   ar e   enqueued. The
*   c l as s   i mpl ement s   [ Symbol . as ync I t er at or ]    and   next ( )    s o   t hat   i t c an
*   be   us ed   wi t h   t he   f or / awai t   l oop   ( whi c h   wi l l	not   t er mi nat e unt i l
*   t he   c l os e( )    met hod   i s   c al l ed. ) */
c l as s   As ync Queue   {
c ons t r uc t or ( )    {
/ /   Val ues   t hat   have   been   queued   but   not   dequeued   yet   ar e s t or ed   her e
t hi s . val ues   =   [ ] ;
/ /   When   Pr omi s es   ar e   dequeued   bef or e   t hei r   c or r es pondi ng val ues   ar e
/ /   queued,	t he   r es ol ve   met hods   f or   t hos e   Pr omi s es   ar e s t or ed   her e.
t hi s . r es ol ver s   =   [ ] ;
/ /   Onc e   c l os ed,	no   mor e   val ues   c an   be   enqueued,	and   no mor e   unf ul f i l l ed
/ /   Pr omi s es   r et ur ned. t hi s . c l os ed   =   f al s e;
}

enqueue( val ue)    {
i f    ( t hi s . c l os ed)    {
t hr ow  new  Er r or ( " As ync Queue   c l os ed" ) ; }
i f    ( t hi s . r es ol ver s . l engt h   >   0)    {
/ /   I f    t hi s   val ue   has   al r eady   been   pr omi s ed,	r es ol ve t hat   Pr omi s e
c ons t   r es ol ve   =   t hi s . r es ol ver s . s hi f t ( ) ;
r es ol ve( val ue) ; }
el s e   {
/ /   Ot her wi s e,	queue   i t   up t hi s . val ues . pus h( val ue) ;
} }

dequeue( )    {
i f    ( t hi s . val ues . l engt h   >   0)    {
/ /   I f    t her e   i s   a   queued   val ue,	r et ur n   a   r es ol ved Pr omi s e   f or   i t
c ons t   val ue   =   t hi s . val ues . s hi f t ( ) ;

r et ur n   Pr omi s e. r es ol ve( val ue) ; }
el s e   i f    ( t hi s . c l os ed)    {

/ / r es ol ved
/ /

I f    no   queued   val ues   and   we' r e   c l os ed,	r et ur n   a

Pr omi s e   f or   t he   " end- of - s t r eam"   mar ker

r et ur n   Pr omi s e. r es ol ve( As ync Queue. EOS) ; }
el s e   {

/ /   Ot her wi s e,    r et ur n   an / /   queui ng   t he   r es ol ver

unr es ol ved   Pr omi s e,
f unc t i on   f or   l at er   us e

r et ur n   new  Pr omi s e( ( r es ol ve)    =>   { t hi s . r es ol ver s . pus h( r es ol ve) ;	} ) ;
} }

c l os e( )    {

/ /   Onc e   t he   queue enqueued.
/ /   So   r es ol ve   any s t r eam mar ker

i s   c l os ed,	no   mor e   val ues

pendi ng   Pr omi s es   wi t h   t he

wi l l	be

end- of -

whi l e( t hi s . r es ol ver s . l engt h   >   0)    {
t hi s . r es ol ver s . s hi f t ( ) ( As ync Queue. EOS) ; }
t hi s . c l os ed   =   t r ue; }

/ /   Def i ne   t he   met hod   t hat   makes   t hi s   c l as s   as ync hr onous l y i t er abl e
[ Symbol . as ync I t er at or ] ( )    {    r et ur n   t hi s ;	}

/ /   Def i ne   t he   met hod   t hat   makes   t hi s   an   as ync hr onous i t er at or .	The
/ /   dequeue( )    Pr omi s e   r es ol ves   t o   a   val ue   or   t he   EOS   s ent i nel i f    we' r e
/ /   c l os ed.	Her e,	we   need   t o   r et ur n   a   Pr omi s e   t hat   r es ol ves t o   an
/ /   i t er at or   r es ul t   obj ec t . next ( )    {
r et ur n   t hi s . dequeue( ) . t hen( val ue   =>   ( val ue   === As ync Queue. EOS)
?   {    val ue:	undef i ned,	done: t r ue   }
:	{    val ue:	val ue,	done:	f al s e

} ) ;
} }

/ /   A  s ent i nel	val ue   r et ur ned   by   dequeue( )    t o   mar k   " end   of s t r eam"   when   c l os ed
As ync Queue. EOS   =   Symbol ( " end- of - s t r eam" ) ;


Because this AsyncQueue class defines the asynchronous iteration basics, we can create our own, more interesting asynchronous iterators simply by asynchronously queueing values. Here’s an example that uses AsyncQueue to produce a stream of web browser events that can be handled with a f or / awai t  loop:


/ /   Pus h   event s   of    t he el ement
/ /   ont o   an   As ync Queue event   s t r eam

s pec i f i ed   t ype   on   t he   s pec i f i ed   doc ument

obj ec t ,	and   r et ur n   t he   queue   f or   us e   as   an

f unc t i on   event St r eam( el t ,	t ype)    {
c ons t   q   =   new  As ync Queue( ) ;	/ /   Cr eat e   a queue
el t . addEvent L i s t ener ( t ype,	e=>q. enqueue( e) ) ;	/ /   Enqueue event s
r et ur n   q; }

as ync   f unc t i on   handl eKeys ( )    {
/ /   Get   a   s t r eam of    keypr es s   event s   and   l oop   onc e   f or   eac h one
f or   awai t   ( c ons t   event   of    event St r eam( doc ument ,	" keypr es s " ) )
{
c ons ol e. l og( event . key) ; }
}



13.5 Summary

In this chapter, you have learned:

Most real-world JavaScript programming is asynchronous.

Traditionally, asynchrony has been handled with events and callback functions. This can get complicated, however, because you can end up with multiple levels of callbacks nested inside other callbacks, and because it is difficult to do robust error handling.

Promises provide a new way of structuring callback functions. If used correctly (and unfortunately, Promises are easy to use incorrectly), they can convert asynchronous code that would have been nested into linear chains of t hen( )  calls where one asynchronous step of a computation follows another. Also, Promises allow you to centralize your error-handling code into a single cat ch( )  call at the end of a chain of t hen( )  calls.

The as ync and awai t  keywords allow us to write asynchronous code that is Promise-based under the hood but that looks like synchronous code. This makes the code easier to understand and reason about. If a function is declared as ync, it will implicitly return a Promise. Inside an as ync function, you can awai t  a Promise (or a function that returns a Promise) as if the Promise value was synchronously computed.

Objects that are asynchronously iterable can be used with a f or / awai t  loop. You can create asynchronously iterable
objects by implementing a [ Symbol . as yncI t er at or ] ( ) method or by invoking an as ync   f unct i on  * generator function. Asynchronous iterators provide an alternative to “data” events on streams in Node and can be used to represent a stream of user input events in client-side JavaScript.





1

The XMLHttpRequest class has nothing in particular to do with XML. In modern client-side JavaScript, it has largely been replaced by the f et c h( )  API, which is covered in §15.11.1. The code example shown here is the last XMLHttpRequest-based example remaining in this book.



2


3

You can typically use awai t  at the top level in a browser’s developer console. And there is a pending proposal to allow top-level awai t  in a future version of JavaScript.

I learned about this approach to asynchronous iteration from the blog of Dr. Axel Rauschmayer, https://2ality.com.



Chapter 14. Metaprogramming




This chapter covers a number of advanced JavaScript features that are not commonly used in day-to-day programming but that may be valuable to programmers writing reusable libraries and of interest to anyone who wants to tinker with the details about how JavaScript objects behave.


Many of the features described here can loosely be described as “metaprogramming”: if regular programming is writing code to manipulate data, then metaprogramming is writing code to manipulate other code. In a dynamic language like JavaScript, the lines between programming and metaprogramming are blurry—even the simple ability to iterate over the properties of an object with a f or / i n loop might be considered “meta” by programmers accustomed to more static languages.

The metaprogramming topics covered in this chapter include:


§14.1 Controlling the enumerability, deleteability, and configurability of object properties

§14.2 Controlling the extensibility of objects, and creating “sealed” and “frozen” objects

§14.3 Querying and setting the prototypes of objects

§14.4 Fine-tuning the behavior of your types with well-known Symbols

§14.5 Creating DSLs (domain-specific languages) with template tag functions

§14.6 Probing objects with r ef l ect  methods

§14.7 Controlling object behavior with Proxy


14.1 Property Attributes

The properties of a JavaScript object have names and values, of course, but each property also has three associated attributes that specify how that property behaves and what you can do with it:

The writable attribute specifies whether or not the value of a property can change.

The enumerable attribute specifies whether the property is enumerated by the f or / i n loop and the Obj ect . keys ( ) method.

The configurable attribute specifies whether a property can be deleted and also whether the property’s attributes can be changed.

Properties defined in object literals or by ordinary assignment to an object are writable, enumerable, and configurable. But many of the properties defined by the JavaScript standard library are not.


This section explains the API for querying and setting property attributes. This API is particularly important to library authors because:

It allows them to add methods to prototype objects and make them non-enumerable, like built-in methods.

It allows them to “lock down” their objects, defining properties that cannot be changed or deleted.

Recall from §6.10.6 that, while “data properties” have a value, “accessor properties” have a getter and/or a setter method instead. For the purposes of this section, we are going to consider the getter and setter methods of an accessor property to be property attributes. Following this logic, we’ll

even say that the value of a data property is an attribute as well. Thus, we can say that a property has a name and four attributes. The four attributes of a data property are value, writable, enumerable, and configurable. Accessor properties don’t have a value attribute or a writable attribute: their writability is determined by the presence or absence of a setter. So the four attributes of an accessor property are get, set, enumerable, and configurable.


The JavaScript methods for querying and setting the attributes of a property use an object called a property descriptor to represent the set of four attributes. A property descriptor object has properties with the same names as the attributes of the property it describes. Thus, the property descriptor object of a data property has properties named val ue,
wr i t abl e, enumer abl e, and conf i gur abl e. And the descriptor for an accessor property has get  and s et  properties instead of val ue and wr i t abl e. The wr i t abl e, enumer abl e, and conf i gur abl e properties are boolean values, and the get  and s et  properties are function values.

To obtain the property descriptor for a named property of a specified object, call Obj ect . get OwnPr oper t yDes cr i pt or ( ) :

/ /   Ret ur ns   { val ue:	1,	wr i t abl e: t r ue,	enumer abl e: t r ue, c onf i gur abl e: t r ue}
Obj ec t . get OwnPr oper t yDes c r i pt or ( { x:	1} ,	" x" ) ;

/ /   Her e   i s   an   obj ec t   wi t h   a   r ead- onl y   ac c es s or   pr oper t y c ons t   r andom =   {
get   oc t et ( )    {    r et ur n   Mat h. f l oor ( Mat h. r andom( ) *256) ;	} , } ;

/ /   Ret ur ns   {    get :	/ *f unc */ ,	s et : undef i ned,	enumer abl e: t r ue, c onf i gur abl e: t r ue}
Obj ec t . get OwnPr oper t yDes c r i pt or ( r andom,	" oc t et " ) ;



/ /   Ret ur ns t hat   don' t

undef i ned   f or   i nher i t ed   pr oper t i es   and   pr oper t i es exi s t .

Obj ec t . get OwnPr oper t yDes c r i pt or ( { } ,	" x" )	/ /   =>   undef i ned; no   s uc h   pr op
Obj ec t . get OwnPr oper t yDes c r i pt or ( { } ,	" t oSt r i ng" )    / /   =>   undef i ned; i nher i t ed


As its name implies, Obj ect . get OwnPr oper t yDes cr i pt or ( ) works only for own properties. To query the attributes of inherited properties, you must explicitly traverse the prototype chain. (See
Obj ect . get Pr ot ot ypeOf ( )  in §14.3); see also the similar
Ref l ect . get OwnPr oper t yDes cr i pt or ( )  function in §14.6.)


To set the attributes of a property or to create a new property with the specified attributes, call Obj ect . def i nePr oper t y( ) , passing the object to be modified, the name of the property to be created or altered, and the property descriptor object:

l et   o   =   { } ;	/ /   St ar t   wi t h   no   pr oper t i es   at   al l
/ /   Add   a   non- enumer abl e   dat a   pr oper t y   x   wi t h   val ue   1. Obj ec t . def i nePr oper t y( o,	" x" ,	{
val ue:	1,
wr i t abl e:	t r ue, enumer abl e:	f al s e, c onf i gur abl e:	t r ue
} ) ;

/ /   Chec k   t hat   t he   pr oper t y   i s   t her e   but   i s   non- enumer abl e o. x	/ /   =>   1
Obj ec t . keys ( o)    / /   =>   [ ]

/ /   Now  modi f y   t he   pr oper t y   x   s o   t hat   i t   i s   r ead- onl y Obj ec t . def i nePr oper t y( o,	" x" ,	{    wr i t abl e:	f al s e   } ) ;

/ /   Tr y   t o   c hange   t he   val ue   of    t he   pr oper t y
o. x   =   2;	/ /   Fai l s   s i l ent l y   or   t hr ows   TypeEr r or   i n   s t r i c t mode
o. x	/ /   =>   1


/ /   The   pr oper t y   i s   s t i l l	c onf i gur abl e,	s o   we   c an   c hange   i t s val ue   l i ke   t hi s :
Obj ec t . def i nePr oper t y( o,	" x" ,	{    val ue:	2   } ) ;
o. x	/ /   =>   2

/ /   Now  c hange   x   f r om a   dat a   pr oper t y   t o   an   ac c es s or   pr oper t y Obj ec t . def i nePr oper t y( o,	" x" ,	{    get :	f unc t i on( )    {    r et ur n   0;	} } ) ;
o. x	/ /   =>   0


The property descriptor you pass to Obj ect . def i nePr oper t y( ) does not have to include all four attributes. If you’re creating a new property, then omitted attributes are taken to be f al s e or undef i ned. If you’re modifying an existing property, then the attributes you omit are simply left unchanged. Note that this method alters an existing own property or creates a new own property, but it will not alter an inherited property. See also the very similar function
Ref l ect . def i nePr oper t y( )  in §14.6.


If you want to create or modify more than one property at a time, use
Obj ect . def i nePr oper t i es ( ) . The first argument is the object that is to be modified. The second argument is an object that maps the names of the properties to be created or modified to the property descriptors for those properties. For example:

l et   p   =   Obj ec t . def i nePr oper t i es ( { } ,	{
x:	{    val ue:	1,	wr i t abl e:	t r ue,	enumer abl e:	t r ue, c onf i gur abl e:	t r ue   } ,
y:	{    val ue:	1,	wr i t abl e:	t r ue,	enumer abl e:	t r ue, c onf i gur abl e:	t r ue   } ,
r :	{
get ( )    {    r et ur n   Mat h. s qr t ( t hi s . x*t hi s . x   +   t hi s . y*t hi s . y) ; } ,
enumer abl e:	t r ue,
c onf i gur abl e:	t r ue

} } ) ;
p. r	/ /   =>   Mat h. SQRT2


This code starts with an empty object, then adds two data properties and one read-only accessor property to it. It relies on the fact that
Obj ect . def i nePr oper t i es ( )  returns the modified object (as does Obj ect . def i nePr oper t y( ) ).


The Obj ect . cr eat e( )  method was introduced in §6.2. We learned there that the first argument to that method is the prototype object for the newly created object. This method also accepts a second optional argument, which is the same as the second argument to
Obj ect . def i nePr oper t i es ( ) . If you pass a set of property descriptors to Obj ect . cr eat e( ) , then they are used to add properties to the newly created object.

Obj ect . def i nePr oper t y( )  and
Obj ect . def i nePr oper t i es ( )  throw TypeError if the attempt to create or modify a property is not allowed. This happens if you attempt to add a new property to a non-extensible (see §14.2) object. The other reasons that these methods might throw TypeError have to do with the attributes themselves. The writable attribute governs attempts to change the value attribute. And the configurable attribute governs attempts to change the other attributes (and also specifies whether a property can be deleted). The rules are not completely straightforward, however. It is possible to change the value of a nonwritable property if that property is configurable, for example. Also, it is possible to change a property from writable to nonwritable even if that property is nonconfigurable. Here are the complete rules. Calls to Obj ect . def i nePr oper t y( )  or
Obj ect . def i nePr oper t i es ( )  that attempt to violate them throw a

TypeError:


If an object is not extensible, you can edit its existing own properties, but you cannot add new properties to it.

If a property is not configurable, you cannot change its configurable or enumerable attributes.

If an accessor property is not configurable, you cannot change its getter or setter method, and you cannot change it to a data property.

If a data property is not configurable, you cannot change it to an accessor property.

If a data property is not configurable, you cannot change its writable attribute from f al s e to t r ue, but you can change it from t r ue to f al s e.

If a data property is not configurable and not writable, you cannot change its value. You can change the value of a property that is configurable but nonwritable, however (because that would be the same as making it writable, then changing the value, then converting it back to nonwritable).

§6.7 described the Obj ect . as s i gn( )  function that copies property values from one or more source objects into a target object.
Obj ect . as s i gn( )  only copies enumerable properties, and property values, not property attributes. This is normally what we want, but it does mean, for example, that if one of the source objects has an accessor property, it is the value returned by the getter function that is copied to the target object, not the getter function itself. Example 14-1 demonstrates how we can use Obj ect . get OwnPr oper t yDes cr i pt or ( )  and Obj ect . def i nePr oper t y( )  to create a variant of
Obj ect . as s i gn( )  that copies entire property descriptors rather than just copying property values.

Example 14-1. Copying properties and their attributes from one object to another
/ *
*   Def i ne   a   new  Obj ec t . as s i gnDes c r i pt or s ( )    f unc t i on   t hat   wor ks l i ke
*   Obj ec t . as s i gn( )    exc ept   t hat   i t   c opi es   pr oper t y   des c r i pt or s   f r om *   s our c e   obj ec t s   i nt o   t he   t ar get   obj ec t   i ns t ead   of    j us t   c opyi ng
*   pr oper t y   val ues .	Thi s   f unc t i on   c opi es   al l	own   pr oper t i es ,	bot h *   enumer abl e   and   non- enumer abl e.	And   bec aus e   i t   c opi es
des c r i pt or s ,
*   i t   c opi es   get t er   f unc t i ons   f r om s our c e   obj ec t s   and   over wr i t es s et t er
*   f unc t i ons   i n   t he   t ar get   obj ec t   r at her   t han   i nvoki ng   t hos e get t er s   and
*   s et t er s . *
*   Obj ec t . as s i gnDes c r i pt or s ( )    pr opagat es   any   TypeEr r or s   t hr own   by *   Obj ec t . def i nePr oper t y( ) .	Thi s   c an   oc c ur   i f    t he   t ar get   obj ec t   i s
s eal ed
*   or   f r oz en   or   i f    any   of    t he   s our c e   pr oper t i es   t r y   t o   c hange   an exi s t i ng
*   non- c onf i gur abl e   pr oper t y   on   t he   t ar get   obj ec t . *
*   Not e   t hat   t he   as s i gnDes c r i pt or s   pr oper t y   i s   added   t o   Obj ec t wi t h
*   Obj ec t . def i nePr oper t y( )    s o   t hat   t he   new  f unc t i on   c an   be   c r eat ed as
*   a   non- enumer abl e   pr oper t y   l i ke   Obj ec t . as s i gn( ) . */
Obj ec t . def i nePr oper t y( Obj ec t ,	" as s i gnDes c r i pt or s " ,	{ / /   Mat c h   t he   at t r i but es   of    Obj ec t . as s i gn( )
wr i t abl e:	t r ue,
enumer abl e:	f al s e, c onf i gur abl e:	t r ue,
/ /   The   f unc t i on   t hat   i s   t he   val ue   of    t he   as s i gnDes c r i pt or s pr oper t y.
val ue:	f unc t i on( t ar get ,	. . . s our c es )    {
f or ( l et   s our c e   of    s our c es )    {
f or ( l et   name   of    Obj ec t . get OwnPr oper t yNames ( s our c e) )    {
l et   des c   =   Obj ec t . get OwnPr oper t yDes c r i pt or ( s our c e, name) ;
Obj ec t . def i nePr oper t y( t ar get ,	name,	des c ) ; }

f or ( l et   s ymbol	of
Obj ec t . get OwnPr oper t ySymbol s ( s our c e) )    {

l et   des c   =   Obj ec t . get OwnPr oper t yDes c r i pt or ( s our c e, s ymbol ) ;
Obj ec t . def i nePr oper t y( t ar get ,	s ymbol ,	des c ) ; }
}
r et ur n   t ar get ; }
} ) ;

l et   o   =   { c :	1,	get   c ount ( )    { r et ur n   t hi s . c ++; } } ;	/ /   Def i ne   obj ec t wi t h   get t er
l et   p   =   Obj ec t . as s i gn( { } ,	o) ;	/ /   Copy   t he pr oper t y   val ues
l et   q   =   Obj ec t . as s i gnDes c r i pt or s ( { } ,	o) ;	/ /   Copy   t he pr oper t y   des c r i pt or s
p. c ount	/ /   =>   1:	Thi s   i s   now  j us t   a   dat a   pr oper t y   s o p. c ount	/ /   =>   1:	. . . t he   c ount er   does   not   i nc r ement .
q. c ount	/ /   =>   2:	I nc r ement ed   onc e   when   we   c opi ed   i t   t he   f i r s t t i me,
q. c ount	/ /   =>   3:	. . . but   we   c opi ed   t he   get t er   met hod   s o   i t i nc r ement s .


14.2 Object Extensibility

The extensible attribute of an object specifies whether new properties can be added to the object or not. Ordinary JavaScript objects are extensible by default, but you can change that with the functions described in this section.


To determine whether an object is extensible, pass it to
Obj ect . i s Ext ens i bl e( ) . To make an object non-extensible, pass it to Obj ect . pr event Ext ens i ons ( ) . Once you have done this, any attempt to add a new property to the object will throw a TypeError in strict mode and simply fail silently without an error in non-strict mode. In addition, attempting to change the prototype (see §14.3) of a non-extensible object will always throw a TypeError.

Note that there is no way to make an object extensible again once you have made it non-extensible. Also note that calling
Obj ect . pr event Ext ens i ons ( )  only affects the extensibility of the object itself. If new properties are added to the prototype of a non-extensible object, the non-extensible object will inherit those new properties.

Two similar functions, Ref l ect . i s Ext ens i bl e( )  and Ref l ect . pr event Ext ens i ons ( ) , are described in §14.6.


The purpose of the extensible attribute is to be able to “lock down” objects into a known state and prevent outside tampering. The extensible attribute of objects is often used in conjunction with the configurable and writable attributes of properties, and JavaScript defines functions that make it easy to set these attributes together:

Obj ect . s eal ( )  works like
Obj ect . pr event Ext ens i ons ( ) , but in addition to making the object non-extensible, it also makes all of the own properties of that object nonconfigurable. This means that new properties cannot be added to the object, and existing properties cannot be deleted or configured. Existing properties that are writable can still be set, however. There is no way to unseal a sealed object. You can use Obj ect . i s Seal ed( )  to determine whether an object is sealed.

Obj ect . f r eez e( )  locks objects down even more tightly. In addition to making the object non-extensible and its properties nonconfigurable, it also makes all of the object’s own data properties read-only. (If the object has accessor properties with setter methods, these are not affected and can still be invoked by assignment to the property.) Use Obj ect . i s Fr oz en( )  to determine if an object is frozen.

It is important to understand that Obj ect . s eal ( )  and
Obj ect . f r eez e( )  affect only the object they are passed: they have no effect on the prototype of that object. If you want to thoroughly lock down an object, you probably need to seal or freeze the objects in the prototype chain as well.

Obj ect . pr event Ext ens i ons ( ) , Obj ect . s eal ( ) , and
Obj ect . f r eez e( )  all return the object that they are passed, which means that you can use them in nested function invocations:

/ /   Cr eat e   a   s eal ed   obj ec t   wi t h   a   f r oz en   pr ot ot ype   and   a   non-enumer abl e   pr oper t y
l et   o   =   Obj ec t . s eal ( Obj ec t . c r eat e( Obj ec t . f r eez e( { x:	1} ) ,
{ y:	{ val ue:	2,	wr i t abl e: t r ue} } ) ) ;


If you are writing a JavaScript library that passes objects to callback functions written by the users of your library, you might use
Obj ect . f r eez e( )  on those objects to prevent the user’s code from modifying them. This is easy and convenient to do, but there are trade-offs: frozen objects can interfere with common JavaScript testing strategies, for example.


14.3 The prototype Attribute

An object’s pr ot ot ype attribute specifies the object from which it inherits properties. (Review §6.2.3 and §6.3.2 for more on prototypes and property inheritance.) This is such an important attribute that we usually simply say “the prototype of o" rather than “the pr ot ot ype attribute of o.” Remember also that when pr ot ot ype appears in code font, it refers to an ordinary object property, not to the pr ot ot ype attribute: Chapter 9

explained that the pr ot ot ype property of a constructor function specifies the pr ot ot ype attribute of the objects created with that constructor.

The pr ot ot ype attribute is set when an object is created. Objects created from object literals use Obj ect . pr ot ot ype as their prototype. Objects created with newuse the value of the pr ot ot ype property of their constructor function as their prototype. And objects created with
Obj ect . cr eat e( )  use the first argument to that function (which may be nul l ) as their prototype.

You can query the prototype of any object by passing that object to Obj ect . get Pr ot ot ypeOf ( ) :



Obj ec t . get Pr ot ot ypeOf ( { } ) Obj ec t . get Pr ot ot ypeOf ( [ ] )
Obj ec t . get Pr ot ot ypeOf ( ( ) =>{ } )

/ /   =>   Obj ec t . pr ot ot ype / /   =>   Ar r ay. pr ot ot ype
/ /   =>   Func t i on. pr ot ot ype



A very similar function, Ref l ect . get Pr ot ot ypeOf ( ) , is described in §14.6.

To determine whether one object is the prototype of (or is part of the prototype chain of) another object, use the i s Pr ot ot ypeOf ( )  method:


l et   p   =   { x:    1} ;                                                     / /   Def i ne   a   pr ot ot ype   obj ec t . l et   o   =   Obj ec t . c r eat e( p) ;                          / /   Cr eat e   an   obj ec t   wi t h   t hat

pr ot ot ype.
p. i s Pr ot ot ypeOf ( o)
Obj ec t . pr ot ot ype. i s Pr ot ot ypeOf ( p)
Obj ec t . pr ot ot ype


/ /   =>   t r ue:
/ /   =>   t r ue:


o   i nher i t s   f r om p
p   i nher i t s   f r om

Obj ec t . pr ot ot ype. i s Pr ot ot ypeOf ( o)    / /   =>   t r ue:	o   does   t oo


Note that i s Pr ot ot ypeOf ( )  performs a function similar to the

i ns t anceof  operator (see §4.9.4).


The pr ot ot ype attribute of an object is set when the object is created and normally remains fixed. You can, however, change the prototype of an object with Obj ect . s et Pr ot ot ypeOf ( ) :

l et   o   =   { x:    1} ; l et   p   =   { y:    2} ;
Obj ec t . s et Pr ot ot ypeOf ( o,	p) ;	/ /   Set   t he   pr ot ot ype   of    o   t o   p o. y	/ /   =>   2:	o   now  i nher i t s   t he   pr oper t y   y
l et   a   =   [ 1,	2,	3] ;
Obj ec t . s et Pr ot ot ypeOf ( a,	p) ;	/ /   Set   t he   pr ot ot ype   of    ar r ay   a   t o p
a. j oi n	/ /   =>   undef i ned:	a   no   l onger   has   a   j oi n( )    met hod


There is generally no need to ever use Obj ect . s et Pr ot ot ypeOf ( ) . JavaScript implementations may make aggressive optimizations based on the assumption that the prototype of an object is fixed and unchanging. This means that if you ever call Obj ect . s et Pr ot ot ypeOf ( ) , any code that uses the altered objects may run much slower than it would normally.

A similar function, Ref l ect . s et Pr ot ot ypeOf ( ) , is described in §14.6.

Some early browser implementations of JavaScript exposed the
pr ot ot ype attribute of an object through the __pr ot o__ property (written with two underscores at the start and end). This has long since been deprecated, but enough existing code on the web depends on
__pr ot o__ that the ECMAScript standard mandates it for all JavaScript implementations that run in web browsers. (Node supports it, too, though the standard does not require it for Node.) In modern JavaScript,

__pr ot o__ is readable and writeable, and you can (though you shouldn’t) use it as an alternative to Obj ect . get Pr ot ot ypeOf ( )  and Obj ect . s et Pr ot ot ypeOf ( ) . One interesting use of __pr ot o__, however, is to define the prototype of an object literal:

l et   p   =   { z :	3} ; l et   o   =   {
x:    1, y:    2,
__pr ot o__:	p } ;
o. z	/ /   =>   3:	o   i nher i t s   f r om p



14.4 Well-Known Symbols

The Symbol type was added to JavaScript in ES6, and one of the primary reasons for doing so was to safely add extensions to the language without breaking compatibility with code already deployed on the web. We saw an example of this in Chapter 12, where we learned that you can make a class iterable by implementing a method whose “name” is the Symbol
Symbol . i t er at or .


Symbol . i t er at or  is the best-known example of the “well-known Symbols.” These are a set of Symbol values stored as properties of the Symbol ( )  factory function that are used to allow JavaScript code to control certain low-level behaviors of objects and classes. The subsections that follow describe each of these well-known Symbols and explain how they can be used.


14.4.1 Symbol.iterator and Symbol.asyncIterator

The Symbol . i t er at or  and Symbol . as yncI t er at or  Symbols

allow objects or classes to make themselves iterable or asynchronously iterable. They were covered in detail in Chapter 12 and §13.4.2, respectively, and are mentioned again here only for completeness.


14.4.2 Symbol.hasInstance

When the i ns t anceof  operator was described in §4.9.4, we said that the righthand side must be a constructor function and that the expression o i ns t anceof   f  was evaluated by looking for the value f . pr ot ot ype within the prototype chain of o. That is still true, but in ES6 and beyond, Symbol . has I ns t ance provides an alternative. In ES6, if the righthand side of i ns t anceof  is any object with a
[ Symbol . has I ns t ance]  method, then that method is invoked with the lefthand side value as its argument, and the return value of the method, converted to a boolean, becomes the value of the i ns t anceof  operator. And, of course, if the value on the righthand side does not have a
[ Symbol . has I ns t ance]  method but is a function, then the i ns t anceof  operator behaves in its ordinary way.

Symbol . has I ns t ance means that we can use the i ns t anceof operator to do generic type checking with suitably defined pseudotype objects. For example:

/ /   Def i ne   an   obj ec t   as   a   " t ype"   we   c an   us e   wi t h   i ns t anc eof l et   ui nt 8   =   {
[ Symbol . has I ns t anc e] ( x)    {
r et ur n   Number . i s I nt eger ( x)    &&  x   >=   0   &&  x   <=   255; }
} ;

128   i ns t anc eof    ui nt 8 256   i ns t anc eof    ui nt 8

/ /   =>   t r ue
/ /   =>   f al s e:	t oo   bi g

Mat h. PI	i ns t anc eof    ui nt 8   / /   =>   f al s e:	not   an   i nt eger

Note that this example is clever but confusing because it uses a nonclass object where a class would normally be expected. It would be just as easy —and clearer to readers of your code—to write a i s Ui nt 8( )  function instead of relying on this Symbol . has I ns t ance behavior.


14.4.3 Symbol.toStringTag

If you invoke the t oSt r i ng( )  method of a basic JavaScript object, you get the string “[object Object]”:

{ } . t oSt r i ng( )	/ /   =>   " [ obj ec t   Obj ec t ] "


If you invoke this same Obj ect . pr ot ot ype. t oSt r i ng( )  function as a method of instances of built-in types, you get some interesting results:


Obj ec t . pr ot ot ype. t oSt r i ng. c al l ( [ ] ) Obj ec t . pr ot ot ype. t oSt r i ng. c al l ( / . / )
Obj ec t . pr ot ot ype. t oSt r i ng. c al l ( ( ) =>{ } ) Obj ec t . pr ot ot ype. t oSt r i ng. c al l ( " " )
Obj ec t . pr ot ot ype. t oSt r i ng. c al l ( 0)
Obj ec t . pr ot ot ype. t oSt r i ng. c al l ( f al s e)

/ /   =>   " [ obj ec t / /   =>   " [ obj ec t / /   =>   " [ obj ec t / /   =>   " [ obj ec t / /   =>   " [ obj ec t
/ /   =>   " [ obj ec t

Ar r ay] " RegExp] " Func t i on] " St r i ng] " Number ] "
Bool ean] "



It turns out that you can use this
Obj ect . pr ot ot ype. t oSt r i ng( ) . cal l ( )  technique with any JavaScript value to obtain the “class attribute” of an object that contains type information that is not otherwise available. The following
cl as s of ( )  function is arguably more useful than the t ypeof  operator, which makes no distinction between types of objects:

f unc t i on   c l as s of ( o)    {
r et ur n   Obj ec t . pr ot ot ype. t oSt r i ng. c al l ( o) . s l i c e( 8, - 1) ; }

c l as s of ( nul l )	/ /   =>   " Nul l "


c l as s of ( undef i ned) c l as s of ( 1)
c l as s of ( 10n**100n) c l as s of ( " " )
c l as s of ( f al s e)
c l as s of ( Symbol ( ) ) c l as s of ( { } )
c l as s of ( [ ] ) c l as s of ( / . / )
c l as s of ( ( ) =>{ } )
c l as s of ( new  Map( ) ) c l as s of ( new  Set ( ) )
c l as s of ( new  Dat e( ) )

/ /   =>   " Undef i ned" / /   =>   " Number "
/ /   =>   " Bi gI nt " / /   =>   " St r i ng" / /   =>   " Bool ean" / /   =>   " Symbol " / /   =>   " Obj ec t " / /   =>   " Ar r ay"
/ /   =>   " RegExp"
/ /   =>   " Func t i on" / /   =>   " Map"
/ /   =>   " Set "
/ /   =>   " Dat e"



Prior to ES6, this special behavior of the
Obj ect . pr ot ot ype. t oSt r i ng( )  method was available only to instances of built-in types, and if you called this cl as s of ( )  function on an instance of a class you had defined yourself, it would simply return “Object”. In ES6, however, Obj ect . pr ot ot ype. t oSt r i ng( )  looks for a property with the symbolic name Symbol . t oSt r i ngTag on its argument, and if such a property exists, it uses the property value in its output. This means that if you define a class of your own, you can easily make it work with functions like cl as s of ( ) :

c l as s   Range   {
get   [ Symbol . t oSt r i ngTag] ( )    {    r et ur n   " Range" ;	} / /   t he   r es t   of    t hi s   c l as s   i s   omi t t ed   her e
}
l et   r   =   new  Range( 1,	10) ;

Obj ec t . pr ot ot ype. t oSt r i ng. c al l ( r )
c l as s of ( r )

/ /   =>   " [ obj ec t   Range] "
/ /   =>   " Range"



14.4.4 Symbol.species

Prior to ES6, JavaScript did not provide any real way to create robust subclasses of built-in classes like Array. In ES6, however, you can extend

any built-in class simply by using the cl as s  and ext ends  keywords. §9.5.2 demonstrated that with this simple subclass of Array:

/ /   A  t r i vi al	Ar r ay   s ubc l as s   t hat   adds   get t er s   f or   t he   f i r s t   and l as t   el ement s .
c l as s   EZAr r ay   ext ends   Ar r ay   {
get   f i r s t ( )    {    r et ur n   t hi s [ 0] ;	}
get   l as t ( )    {    r et ur n   t hi s [ t hi s . l engt h- 1] ;	} }

l et   e   =   new  EZAr r ay( 1, 2, 3) ; l et   f    =   e. map( x   =>   x   *   x) ;
e. l as t	/ /   =>   3:	t he   l as t   el ement   of    EZAr r ay   e
f . l as t	/ /   =>   9:	f    i s   al s o   an   EZAr r ay   wi t h   a   l as t   pr oper t y


Array defines methods concat ( ) , f i l t er ( ) , map( ) , s l i ce( ) , and s pl i ce( ) , which return arrays. When we create an array subclass like EZArray that inherits these methods, should the inherited method return instances of Array or instances of EZArray? Good arguments can be made for either choice, but the ES6 specification says that (by default) the five array-returning methods will return instances of the subclass.

Here’s how it works:


In ES6 and later, the Ar r ay( )  constructor has a property with the symbolic name Symbol . s peci es . (Note that this Symbol is used as the name of a property of the constructor function. Most of the other well-known Symbols described here are used as the name of methods of a prototype object.)

When we create a subclass with ext ends , the resulting subclass constructor inherits properties from the superclass constructor. (This is in addition to the normal kind of inheritance, where instances of the subclass inherit methods of the superclass.) This means that the constructor for every subclass of Array also has an inherited property with name Symbol . s peci es . (Or a subclass

can define its own property with this name, if it wants.)

Methods like map( )  and s l i ce( )  that create and return new arrays are tweaked slightly in ES6 and later. Instead of just creating a regular Array, they (in effect) invoke new
t hi s . cons t r uct or [ Symbol . s peci es ] ( )  to create the new array.

Now here’s the interesting part. Suppose that
Ar r ay[ Symbol . s peci es ]  was just a regular data property, defined like this:

Ar r ay[ Symbol . s pec i es ]    =   Ar r ay;


In that case, then subclass constructors would inherit the Ar r ay( ) constructor as their “species,” and invoking map( )  on an array subclass would return an instance of the superclass rather than an instance of the subclass. That is not how ES6 actually behaves, however. The reason is that Ar r ay[ Symbol . s peci es ]  is a read-only accessor property whose getter function simply returns t hi s . Subclass constructors inherit this getter function, which means that by default, every subclass constructor is its own “species.”

Sometimes this default behavior is not what you want, however. If you wanted the array-returning methods of EZArray to return regular Array objects, you just need to set EZAr r ay[ Symbol . s peci es ]  to Ar r ay. But since the inherited property is a read-only accessor, you can’t just set it with an assignment operator. You can use def i nePr oper t y( ) , however:

EZAr r ay[ Symbol . s pec i es ]    =   Ar r ay;	/ /   At t empt   t o   s et   a   r ead- onl y pr oper t y   f ai l s

/ /   I ns t ead   we   c an   us e   def i nePr oper t y( ) :

Obj ec t . def i nePr oper t y( EZAr r ay,	Symbol . s pec i es ,	{ val ue:	Ar r ay} ) ;


The simplest option is probably to explicitly define your own
Symbol . s peci es  getter when creating the subclass in the first place:


c l as s   EZAr r ay   ext ends   Ar r ay   {
s t at i c   get   [ Symbol . s pec i es ] ( )    {    r et ur n   Ar r ay;	} get   f i r s t ( )    {    r et ur n   t hi s [ 0] ;	}
get   l as t ( )    {    r et ur n   t hi s [ t hi s . l engt h- 1] ;	} }

l et   e   =   new  EZAr r ay( 1, 2, 3) ; l et   f    =   e. map( x   =>   x   -    1) ;

e. l as t      / / f . l as t      / /
get t er

=>   3
=>   undef i ned:	f    i s   a   r egul ar   ar r ay   wi t h   no   l as t



Creating useful subclasses of Array was the primary use case that motivated the introduction of Symbol . s peci es , but it is not the only place that this well-known Symbol is used. Typed array classes use the Symbol in the same way that the Array class does. Similarly, the
s l i ce( )  method of ArrayBuffer looks at the Symbol . s peci es property of t hi s . cons t r uct or  instead of simply creating a new ArrayBuffer. And Promise methods like t hen( )  that return new Promise objects create those objects via this species protocol as well. Finally, if you find yourself subclassing Map (for example) and defining methods that return new Map objects, you might want to use Symbol . s peci es yourself for the benefit of subclasses of your subclass.


14.4.5 Symbol.isConcatSpreadable

The Array method concat ( )  is one of the methods described in the previous section that uses Symbol . s peci es  to determine what constructor to use for the returned array. But concat ( )  also uses

Symbol . i s Concat Spr eadabl e. Recall from §7.8.3 that the concat ( )  method of an array treats its t hi s  value and its array
arguments differently than its nonarray arguments: nonarray arguments are simply appended to the new array, but the t hi s  array and any array arguments are flattened or “spread” so that the elements of the array are concatenated rather than the array argument itself.

Before ES6, concat ( )  just used Ar r ay. i s Ar r ay( )  to determine whether to treat a value as an array or not. In ES6, the algorithm is changed slightly: if the argument (or the t hi s  value) to concat ( )  is an object and has a property with the symbolic name
Symbol . i s Concat Spr eadabl e, then the boolean value of that property is used to determine whether the argument should be “spread.” If no such property exists, then Ar r ay. i s Ar r ay( )  is used as in previous versions of the language.

There are two cases when you might want to use this Symbol:


If you create an Array-like (see §7.9) object and want it to behave like a real array when passed to concat ( ) , you can simply add the symbolic property to your object:


l et   ar r ayl i ke   =   { l engt h:	1,
0:	1,
[ Symbol . i s Concat Spr eadabl e] :	t r ue } ;
[ ] . concat ( ar r ayl i ke)	/ /   =>   [ 1] :	( woul d   be [ [ 1] ]   i f   not   s pr ead)

Array subclasses are spreadable by default, so if you are defining

an array subclass that you do not want to act like an array when used with concat ( ) , then you can1 add a getter like this to your subclass:


cl as s   NonSpr eadabl eAr r ay   ext ends   Ar r ay   { get   [ Symbol . i s Concat Spr eadabl e] ( )   {
r et ur n  f al s e;	} }
l et   a   =   new NonSpr eadabl eAr r ay( 1, 2, 3) ;
[ ] . concat ( a) . l engt h  / /   =>   1;	( woul d   be   3 el ement s   l ong   i f   a   was   s pr ead)


14.4.6 Pattern-Matching Symbols

§11.3.2 documented the String methods that perform pattern-matching operations using a RegExp argument. In ES6 and later, these methods have been generalized to work with RegExp objects or any object that defines pattern-matching behavior via properties with symbolic names. For each of the string methods mat ch( ) , mat chAl l ( ) , s ear ch( ) , r epl ace( ) , and s pl i t ( ) , there is a corresponding well-known Symbol: Symbol . mat ch, Symbol . s ear ch, and so on.


RegExps are a general and very powerful way to describe textual patterns, but they can be complicated and not well suited to fuzzy matching. With the generalized string methods, you can define your own pattern classes using the well-known Symbol methods to provide custom matching. For example, you could perform string comparisons using Intl.Collator (see §11.7.3) to ignore accents when matching. Or you could define a pattern class based on the Soundex algorithm to match words based on their approximate sounds or to loosely match strings up to a given Levenshtein distance.

In general, when you invoke one of these five String methods on a pattern object like this:

s t r i ng. met hod( pat t er n,	ar g)


that invocation turns into an invocation of a symbolically named method on your pattern object:

pat t er n[ s ymbol ] ( s t r i ng,	ar g)


As an example, consider the pattern-matching class in the next example, which implements pattern matching using the simple * and ? wildcards that you are probably familar with from filesystems. This style of pattern matching dates back to the very early days of the Unix operating system, and the patterns are often called globs:

c l as s   Gl ob   {
c ons t r uc t or ( gl ob)    {
t hi s . gl ob   =   gl ob;

/ /   We   i mpl ement   gl ob   mat c hi ng   us i ng   RegExp   i nt er nal l y. / /   ?   mat c hes   any   one   c har ac t er   exc ept   / ,    and   *   mat c hes
z er o   or   mor e
/ /   of    t hos e   c har ac t er s .	We   us e   c apt ur i ng   gr oups   ar ound eac h.
l et   r egexpText   =   gl ob. r epl ac e( " ?" ,	"
( [ ^/ ] ) " ) . r epl ac e( " *" ,	" ( [ ^/ ] *) " ) ;

/ /   We   us e   t he   u   f l ag   t o   get   Uni c ode- awar e   mat c hi ng.
/ /   Gl obs   ar e   i nt ended   t o   mat c h   ent i r e   s t r i ngs ,	s o   we   us e t he   ^   and   $
/ /   anc hor s   and   do   not   i mpl ement   s ear c h( )    or   mat c hAl l ( ) s i nc e   t hey
/ /   ar e   not   us ef ul	wi t h   pat t er ns   l i ke   t hi s .
t hi s . r egexp   =   new  RegExp( ` ^${ r egexpText } $` ,	" u" ) ;
}

t oSt r i ng( )    {    r et ur n   t hi s . gl ob;	}

[ Symbol . s ear c h] ( s )    {    r et ur n   s . s ear c h( t hi s . r egexp) ;	} [ Symbol . mat c h] ( s )	{    r et ur n   s . mat c h( t hi s . r egexp) ;    }
[ Symbol . r epl ac e] ( s ,	r epl ac ement )    {
r et ur n   s . r epl ac e( t hi s . r egexp,	r epl ac ement ) ; }
}

l et   pat t er n   =   new  Gl ob( " doc s / *. t xt " ) ;
" doc s / j s . t xt " . s ear c h( pat t er n)	/ /   =>   0:	mat c hes   at   c har ac t er   0 " doc s / j s . ht m" . s ear c h( pat t er n)	/ /   =>   - 1:    does   not   mat c h
l et   mat c h   =   " doc s / j s . t xt " . mat c h( pat t er n) ;

mat c h[ 0] mat c h[ 1]
mat c h. i ndex

/ /   =>   " doc s / j s . t xt " / /   =>   " j s "
/ /   =>   0

" doc s / j s . t xt " . r epl ac e( pat t er n,	" web/ $1. ht m" )	/ /   =>   " web/ j s . ht m"


14.4.7 Symbol.toPrimitive

§3.9.3 explained that JavaScript has three slightly different algorithms for converting objects to primitive values. Loosely speaking, for conversions where a string value is expected or preferred, JavaScript invokes an object’s t oSt r i ng( )  method first and falls back on the val ueOf ( ) method if t oSt r i ng( )  is not defined or does not return a primitive value. For conversions where a numeric value is preferred, JavaScript tries the val ueOf ( )  method first and falls back on t oSt r i ng( )  if
val ueOf ( )  is not defined or if it does not return a primitive value. And finally, in cases where there is no preference, it lets the class decide how to do the conversion. Date objects convert using t oSt r i ng( )  first, and all other types try val ueOf ( )  first.


In ES6, the well-known Symbol Symbol . t oPr i mi t i ve allows you to override this default object-to-primitive behavior and gives you complete control over how instances of your own classes will be converted to primitive values. To do this, define a method with this symbolic name. The

method must return a primitive value that somehow represents the object. The method you define will be invoked with a single string argument that tells you what kind of conversion JavaScript is trying to do on your object:

If the argument is " s t r i ng" , it means that JavaScript is doing the conversion in a context where it would expect or prefer (but not require) a string. This happens when you interpolate the object into a template literal, for example.

If the argument is " number " , it means that JavaScript is doing the conversion in a context where it would expect or prefer (but not require) a numeric value. This happens when you use the object with a < or > operator or with arithmetic operators like -and *.

If the argument is " def aul t " , it means that JavaScript is converting your object in a context where either a numeric or string value could work. This happens with the +, ==, and ! = operators.

Many classes can ignore the argument and simply return the same primitive value in all cases. If you want instances of your class to be comparable and sortable with < and >, then that is a good reason to define a [ Symbol . t oPr i mi t i ve]  method.


14.4.8 Symbol.unscopables

The final well-known Symbol that we’ll cover here is an obscure one that was introduced as a workaround for compatibility issues caused by the deprecated wi t h statement. Recall that the wi t h statement takes an object and executes its statement body as if it were in a scope where the properties of that object were variables. This caused compatibility problems when new methods were added to the Array class, and it broke some existing code. Symbol . uns copabl es  is the result. In ES6 and

later, the wi t h statement has been slightly modified. When used with an object o, a wi t h statement computes
Obj ect . keys ( o[ Symbol . uns copabl es ] ||{ } )  and ignores properties whose names are in the resulting array when creating the simulated scope in which to execute its body. ES6 uses this to add new methods to Ar r ay. pr ot ot ype without breaking existing code on the web. This means that you can find a list of the newest Array methods by evaluating:

l et   newAr r ayMet hods   =
Obj ec t . keys ( Ar r ay. pr ot ot ype[ Symbol . uns c opabl es ] ) ;



14.5 Template Tags

Strings within backticks are known as “template literals” and were covered in §3.3.4. When an expression whose value is a function is followed by a template literal, it turns into a function invocation, and we call it a “tagged template literal.” Defining a new tag function for use with tagged template literals can be thought of as metaprogramming, because tagged templates are often used to define DSLs—domain-specific languages—and defining a new tag function is like adding new syntax to JavaScript. Tagged template literals have been adopted by a number of frontend JavaScript packages. The GraphQL query language uses a
gql ` `  tag function to allow queries to be embedded within JavaScript code. And the Emotion library uses a cs s ` `  tag function to enable CSS styles to be embedded in JavaScript. This section demonstrates how to write your own tag functions like these.

There is nothing special about tag functions: they are ordinary JavaScript functions, and no special syntax is required to define them. When a

function expression is followed by a template literal, the function is invoked. The first argument is an array of strings, and this is followed by zero or more additional arguments, which can have values of any type.


The number of arguments depends on the number of values that are interpolated into the template literal. If the template literal is simply a constant string with no interpolations, then the tag function will be called with an array of that one string and no additional arguments. If the template literal includes one interpolated value, then the tag function is called with two arguments. The first is an array of two strings, and the second is the interpolated value. The strings in that initial array are the string to the left of the interpolated value and the string to its right, and either one of them may be the empty string. If the template literal includes two interpolated values, then the tag function is invoked with three arguments: an array of three strings and the two interpolated values. The three strings (any or all of which may be empty) are the text to the left of the first value, the text between the two values, and the text to the right of the second value. In the general case, if the template literal has n interpolated values, then the tag function will be invoked with n+1 arguments. The first argument will be an array of n+1 strings, and the remaining arguments are the n interpolated values, in the order that they appear in the template literal.

The value of a template literal is always a string. But the value of a tagged template literal is whatever value the tag function returns. This may be a string, but when the tag function is used to implement a DSL, the return value is typically a non-string data structure that is a parsed representation of the string.


As an example of a template tag function that returns a string, consider the

following ht ml ` `  template, which is useful when you want to safely interpolate values into a string of HTML. The tag performs HTML escaping on each of the values before using it to build the final string:

f unc t i on   ht ml ( s t r i ngs ,	. . . val ues )    {
/ /   Conver t   eac h   val ue   t o   a   s t r i ng   and   es c ape   s pec i al	HTML c har ac t er s

l et   es c aped   =   val ues . map( v   =>   St r i ng( v)
. r epl ac e( " &" , . r epl ac e( " <" , . r epl ac e( " >" , . r epl ac e( ' " ' ,
. r epl ac e( " ' " ,


" &amp; " ) " &l t ; " ) " &gt ; " )
" &quot ; " )
" &#39; " ) ) ;


/ /   Ret ur n   t he   c onc at enat ed   s t r i ngs   and   es c aped   val ues l et   r es ul t   =   s t r i ngs [ 0] ;
f or ( l et   i	=   0;	i	<   es c aped. l engt h;	i ++)    { r es ul t   +=   es c aped[ i ]    +   s t r i ngs [ i +1] ;
}
r et ur n   r es ul t ; }

l et   oper at or   =   " <" ;
ht ml ` <b>x   ${ oper at or }    y</ b>`	/ /   =>   " <b>x   &l t ;	y</ b>"

l et   ki nd   =   " game" ,	name   =   " D&D" ;
ht ml ` <di v   c l as s =" ${ ki nd} " >${ name} </ di v>`    / /   =>' <di v c l as s =" game" >D&amp; D</ di v>'


For an example of a tag function that does not return a string but instead a parsed representation of a string, think back to the Glob pattern class defined in §14.4.6. Since the Gl ob( )  constructor takes a single string argument, we can define a tag function for creating new Glob objects:

f unc t i on   gl ob( s t r i ngs ,	. . . val ues )    {
/ /   As s embl e   t he   s t r i ngs   and   val ues   i nt o   a   s i ngl e   s t r i ng l et   s   =   s t r i ngs [ 0] ;
f or ( l et   i	=   0;	i	<   val ues . l engt h;	i ++)    { s   +=   val ues [ i ]    +   s t r i ngs [ i +1] ;

}
/ /   Ret ur n   a   par s ed   r epr es ent at i on   of    t hat   s t r i ng r et ur n   new  Gl ob( s ) ;
}

l et   r oot   =   " / t mp" ;
l et   f i l ePat t er n   =   gl ob` ${ r oot } / *. ht ml ` ;	/ /   A  RegExp   al t er nat i ve " / t mp/ t es t . ht ml " . mat c h( f i l ePat t er n) [ 1]	/ /   =>   " t es t "


One of the features mentioned in passing in §3.3.4 is the St r i ng. r aw` ` tag function that returns a string in its “raw” form without interpreting any of the backslash escape sequences. This is implemented using a feature of tag function invocation that we have not discussed yet. When a tag function is invoked, we’ve seen that its first argument is an array of strings. But this array also has a property named r aw, and the value of that property is another array of strings, with the same number of elements. The argument array includes strings that have had escape sequences interpreted as usual. And the raw array includes strings in which escape sequences are not interpreted. This obscure feature is important if you want to define a DSL with a grammar that uses backslashes. For example, if we wanted our gl ob` `  tag function to support pattern matching on Windows-style paths (which use backslashes instead of forward slashes) and we did not want users of the tag to have to double every backslash, we could rewrite that function to use
s t r i ngs . r aw[ ]  instead of s t r i ngs [ ] . The downside, of course, would be that we could no longer use escapes like \ u in our glob literals.


14.6 The Reflect API

The Reflect object is not a class; like the Math object, its properties simply define a collection of related functions. These functions, added in ES6, define an API for “reflecting upon” objects and their properties. There is

little new functionality here: the Reflect object defines a convenient set of functions, all in a single namespace, that mimic the behavior of core language syntax and duplicate the features of various pre-existing Object functions.


Although the Ref l ect  functions do not provide any new features, they do group the features together in one convenient API. And, importantly, the set of Ref l ect  functions maps one-to-one with the set of Proxy handler methods that we’ll learn about in §14.7.

The Reflect API consists of the following functions:


Ref l ec t . appl y( f ,	o,	ar gs )

This function invokes the function f  as a method of o (or invokes it as a function with no t hi s  value if o is nul l ) and passes the values in the ar gs  array as arguments. It is equivalent to f . appl y( o,
ar gs ) .

Ref l ec t . c ons t r uc t ( c ,	ar gs ,	newTar get )

This function invokes the constructor c as if the newkeyword had been used and passes the elements of the array ar gs  as arguments. If the optional newTar get  argument is specified, it is used as the value of new. t ar get  within the constructor invocation. If not specified, then the new. t ar get  value will be c.

Ref l ec t . def i nePr oper t y( o,	name,	des c r i pt or )

This function defines a property on the object o, using name (a string or symbol) as the name of the property. The Descriptor object should define the value (or getter and/or setter) and attributes of the property. Ref l ect . def i nePr oper t y( )  is very similar to
Obj ect . def i nePr oper t y( )  but returns t r ue on success and f al s e on failures. (Obj ect . def i nePr oper t y( )  returns o on

success and throws TypeError on failure.)

Ref l ec t . del et ePr oper t y( o,	name)

This function deletes the property with the specified string or symbolic name from the object o, returning t r ue if successful (or if no such property existed) and f al s e if the property could not be deleted. Calling this function is similar to writing del et e   o[ name] .

Ref l ec t . get ( o,	name,	r ec ei ver )

This function returns the value of the property of o with the specified name (a string or symbol). If the property is an accessor method with a getter, and if the optional r ecei ver  argument is specified, then the getter function is called as a method of r ecei ver  instead of as a method of o. Calling this function is similar to evaluating o[ name] .

Ref l ec t . get OwnPr oper t yDes c r i pt or ( o,	name)

This function returns a property descriptor object that describes the attributes of the property named name of the object o, or returns undef i ned if no such property exists. This function is nearly identical to Obj ect . get OwnPr oper t yDes cr i pt or ( ) , except that the Reflect API version of the function requires that the first argument be an object and throws TypeError if it is not.

Ref l ec t . get Pr ot ot ypeOf ( o)

This function returns the prototype of object o or nul l  if the object has no prototype. It throws a TypeError if o is a primitive value instead of an object. This function is almost identical to
Obj ect . get Pr ot ot ypeOf ( )  except that
Obj ect . get Pr ot ot ypeOf ( )  only throws a TypeError for nul l and undef i ned arguments and coerces other primitive values to their wrapper objects.

Ref l ec t . has ( o,	name)

This function returns t r ue if the object o has a property with the

specified name (which must be a string or a symbol). Calling this function is similar to evaluating name   i n  o.

Ref l ec t . i s Ext ens i bl e( o)

This function returns t r ue if the object o is extensible (§14.2) and f al s e if it is not. It throws a TypeError if o is not an object.
Obj ect . i s Ext ens i bl e( )  is similar but simply returns f al s e when passed an argument that is not an object.

Ref l ec t . ownKeys ( o)

This function returns an array of the names of the properties of the object o or throws a TypeError if o is not an object. The names in the returned array will be strings and/or symbols. Calling this function is similar to calling Obj ect . get OwnPr oper t yNames ( )  and
Obj ect . get OwnPr oper t ySymbol s ( )  and combining their results.

Ref l ec t . pr event Ext ens i ons ( o)

This function sets the extensible attribute (§14.2) of the object o to
f al s e and returns t r ue to indicate success. It throws a TypeError if o is not an object. Obj ect . pr event Ext ens i ons ( )  has the same effect but returns o instead of t r ue and does not throw TypeError for nonobject arguments.

Ref l ec t . s et ( o,	name,	val ue,	r ec ei ver )

This function sets the property with the specified name of the object o to the specified val ue. It returns t r ue on success and f al s e on failure (which can happen if the property is read-only). It throws TypeError if o is not an object. If the specified property is an accessor property with a setter function, and if the optional r ecei ver argument is passed, then the setter will be invoked as a method of
r ecei ver  instead of being invoked as a method of o. Calling this function is usually the same as evaluating o[ name]   =   val ue.


Ref l ec t . s et Pr ot ot ypeOf ( o,	p)

This function sets the prototype of the object o to p, returning t r ue on success and f al s e on failure (which can occur if o is not extensible or if the operation would cause a circular prototype chain). It throws a TypeError if o is not an object or if p is neither an object nor nul l . Obj ect . s et Pr ot ot ypeOf ( )  is similar, but returns o on success and throws TypeError on failure. Remember that calling either of these functions is likely to make your code slower by disrupting JavaScript interpreter optimizations.


14.7 Proxy Objects

The Proxy class, available in ES6 and later, is JavaScript’s most powerful metaprogramming feature. It allows us to write code that alters the fundamental behavior of JavaScript objects. The Reflect API described in §14.6 is a set of functions that gives us direct access to a set of fundamental operations on JavaScript objects. What the Proxy class does is allows us a way to implement those fundamental operations ourselves and create objects that behave in ways that are not possible for ordinary objects.


When we create a Proxy object, we specify two other objects, the target object and the handlers object:

l et   pr oxy   =   new  Pr oxy( t ar get ,	handl er s ) ;


The resulting Proxy object has no state or behavior of its own. Whenever you perform an operation on it (read a property, write a property, define a new property, look up the prototype, invoke it as a function), it dispatches those operations to the handlers object or to the target object.

The operations supported by Proxy objects are the same as those defined by the Reflect API. Suppose that p is a Proxy object and you write
del et e   p. x. The Ref l ect . del et ePr oper t y( )  function has the same behavior as the del et e operator. And when you use the del et e operator to delete a property of a Proxy object, it looks for a
del et ePr oper t y( )  method on the handlers object. If such a method exists, it invokes it. And if no such method exists, then the Proxy object performs the property deletion on the target object instead.

Proxies work this way for all of the fundamental operations: if an appropriate method exists on the handlers object, it invokes that method to perform the operation. (The method names and signatures are the same as those of the Reflect functions covered in §14.6.) And if that method does not exist on the handlers object, then the Proxy performs the fundamental operation on the target object. This means that a Proxy can obtain its behavior from the target object or from the handlers object. If the handlers object is empty, then the proxy is essentially a transparent wrapper around the target object:

l et   t   =   {    x:	1,	y:	2   } ;
l et   p   =   new  Pr oxy( t ,	{ } ) ;

p. x
del et e   p. y

/ /   =>   1
/ /   =>   t r ue:	del et e   pr oper t y   y   of    t he   pr oxy

t . y	/ /   =>   undef i ned:	t hi s   del et es   i t   i n   t he   t ar get ,	t oo p. z   =   3;	/ /   Def i ni ng   a   new  pr oper t y   on   t he   pr oxy
t . z	/ /   =>   3:	def i nes   t he   pr oper t y   on   t he   t ar get


This kind of transparent wrapper proxy is essentially equivalent to the underlying target object, which means that there really isn’t a reason to use it instead of the wrapped object. Transparent wrappers can be useful, however, when created as “revocable proxies.” Instead of creating a Proxy with the Pr oxy( )  constructor, you can use the Pr oxy. r evocabl e( )

factory function. This function returns an object that includes a Proxy object and also a r evoke( )  function. Once you call the r evoke( ) function, the proxy immediately stops working:

f unc t i on   ac c es s TheDat abas e( )    {    / *   i mpl ement at i on   omi t t ed   */ r et ur n   42;	}
l et   { pr oxy,	r evoke}    =   Pr oxy. r evoc abl e( ac c es s TheDat abas e,	{ } ) ;

pr oxy( )	/ /   =>   42:	The   pr oxy   gi ves   ac c es s   t o   t he   under l yi ng t ar get   f unc t i on
r evoke( ) ;	/ /   But   t hat   ac c es s   c an   be   t ur ned   of f    whenever   we   want pr oxy( ) ;	/ /   ! TypeEr r or :	we   c an   no   l onger   c al l	t hi s   f unc t i on


Note that in addition to demonstrating revocable proxies, the preceding code also demonstrates that proxies can work with target functions as well as target objects. But the main point here is that revocable proxies are a building block for a kind of code isolation, and you might use them when dealing with untrusted third-party libraries, for example. If you have to pass a function to a library that you don’t control, you can pass a revocable proxy instead and then revoke the proxy when you are finished with the library. This prevents the library from keeping a reference to your function and calling it at unexpected times. This kind of defensive programming is not typical in JavaScript programs, but the Proxy class at least makes it possible.


If we pass a non-empty handlers object to the Pr oxy( )  constructor, then we are no longer defining a transparent wrapper object and are instead implementing custom behavior for our proxy. With the right set of handlers, the underlying target object essentially becomes irrelevant.

In the following code, for example, is how we could implement an object that appears to have an infinite number of read-only properties, where the value of each property is the same as the name of the property:




/ /   We   us e   a / /   pos s i bl e i t s   name

Pr oxy   t o   c r eat e   an pr oper t y,    wi t h   t he

obj ec t   t hat   appear s   t o val ue   of    eac h   pr oper t y

have   ever y equal	t o

l et   i dent i t y   =   new  Pr oxy( { } ,	{
/ /   Ever y   pr oper t y   has   i t s   own   name   as   i t s   val ue get ( o,	name,	t ar get )    {    r et ur n   name;	} ,
/ /   Ever y   pr oper t y   name   i s   def i ned has ( o,	name)    {    r et ur n   t r ue;	} ,
/ /   Ther e   ar e   t oo   many   pr oper t i es   t o   enumer at e,	s o   we   j us t t hr ow
ownKeys ( o)    {    t hr ow  new  RangeEr r or ( " I nf i ni t e   number   of
pr oper t i es " ) ;	} ,
/ /   Al l	pr oper t i es   exi s t   and   ar e   not   wr i t abl e,	c onf i gur abl e or   enumer abl e.
get OwnPr oper t yDes c r i pt or ( o,	name)    {
r et ur n   {
val ue:	name,
enumer abl e:	f al s e, wr i t abl e:	f al s e,
c onf i gur abl e:	f al s e } ;
} ,
/ /   Al l	pr oper t i es   ar e   r ead- onl y   s o   t hey   c an' t   be   s et s et ( o,	name,	val ue,	t ar get )    {    r et ur n   f al s e;	} ,
/ /   Al l	pr oper t i es   ar e   non- c onf i gur abl e,	s o   t hey   c an' t   be del et ed
del et ePr oper t y( o,	name)    {    r et ur n   f al s e;	} ,
/ /   Al l	pr oper t i es   exi s t   and   ar e   non- c onf i gur abl e   s o   we   c an' t def i ne   mor e
def i nePr oper t y( o,	name,	des c )    {    r et ur n   f al s e;	} ,
/ /   I n   ef f ec t ,	t hi s   means   t hat   t he   obj ec t   i s   not   ext ens i bl e i s Ext ens i bl e( o)    {    r et ur n   f al s e;	} ,
/ /   Al l	pr oper t i es   ar e   al r eady   def i ned   on   t hi s   obj ec t ,	s o   i t c oul dn' t
/ /   i nher i t   anyt hi ng   even   i f    i t   di d   have   a   pr ot ot ype   obj ec t . get Pr ot ot ypeOf ( o)    {    r et ur n   nul l ;	} ,
/ /   The   obj ec t   i s   not   ext ens i bl e,	s o   we   c an' t   c hange   t he pr ot ot ype
s et Pr ot ot ypeOf ( o,	pr ot o)    {    r et ur n   f al s e;	} ,
} ) ;


i dent i t y. x
i dent i t y. t oSt r i ng

/ /   =>   " x"
/ /   =>   " t oSt r i ng"

i dent i t y[ 0]	/ /   =>   " 0"
i dent i t y. x   =   1;	/ /   Set t i ng   pr oper t i es   has   no   ef f ec t i dent i t y. x	/ /   =>   " x"
del et e   i dent i t y. x	/ /   =>   f al s e:	c an' t   del et e   pr oper t i es ei t her
i dent i t y. x	/ /   =>   " x"
Obj ec t . keys ( i dent i t y) ;	/ /   ! RangeEr r or :	c an' t   l i s t   al l	t he keys
f or ( l et   p   of    i dent i t y)    ;	/ /   ! RangeEr r or


Proxy objects can derive their behavior from the target object and from the handlers object, and the examples we have seen so far have used one object or the other. But it is typically more useful to define proxies that use both objects.


The following code, for example, uses Proxy to create a read-only wrapper for a target object. When code tries to read values from the object, those reads are forwarded to the target object normally. But if any code tries to modify the object or its properties, methods of the handler object throw a TypeError. A proxy like this might be helpful for writing tests: suppose you’ve written a function that takes an object argument and want to ensure that your function does not make any attempt to modify the input argument. If your test passes in a read-only wrapper object, then any writes will throw exceptions that cause the test to fail:

f unc t i on   r eadOnl yPr oxy( o)    {
f unc t i on   r eadonl y( )    {    t hr ow  new  TypeEr r or ( " Readonl y" ) ;	} r et ur n   new  Pr oxy( o,	{
s et :	r eadonl y,

def i nePr oper t y: del et ePr oper t y: s et Pr ot ot ypeOf :
} ) ;
}

r eadonl y, r eadonl y,
r eadonl y,


l et   o   =   {    x:	1,	y:	2   } ;	/ /   Nor mal	wr i t abl e   obj ec t

l et   p   =   r eadOnl yPr oxy( o) ;	/ /   Readonl y   ver s i on   of    i t
p. x	/ /   =>   1:	r eadi ng   pr oper t i es   wor ks p. x   =   2;	/ /   ! TypeEr r or :	c an' t   c hange
pr oper t i es
del et e   p. y;	/ /   ! TypeEr r or :	c an' t   del et e pr oper t i es
p. z   =   3;	/ /   ! TypeEr r or :	c an' t   add   pr oper t i es p. __pr ot o__   =   { } ;	/ /   ! TypeEr r or :	c an' t   c hange   t he
pr ot ot ype


Another technique when writing proxies is to define handler methods that intercept operations on an object but still delegate the operations to the target object. The functions of the Reflect API (§14.6) have exactly the same signatures as the handler methods, so they make it easy to do that kind of delegation.


Here, for example, is a proxy that delegates all operations to the target object but uses handler methods to log the operations:

/ *
*   Ret ur n   a   Pr oxy   obj ec t   t hat   wr aps   o,	del egat i ng   al l	oper at i ons t o
*   t hat   obj ec t   af t er   l oggi ng   eac h   oper at i on.	obj name   i s   a   s t r i ng t hat
*   wi l l	appear   i n   t he   l og   mes s ages   t o   i dent i f y   t he   obj ec t .	I f    o has   own
*   pr oper t i es   whos e   val ues   ar e   obj ec t s   or   f unc t i ons ,	t hen   i f    you quer y
*   t he   val ue   of    t hos e   pr oper t i es ,	you' l l	get   a   l oggi ngPr oxy bac k,	s o   t hat
*   l oggi ng   behavi or   of    t hi s   pr oxy   i s   " c ont agi ous " . */
f unc t i on   l oggi ngPr oxy( o,	obj name)    {

/ /   Def i ne   handl er s   f or / /   Eac h   handl er   l ogs   a
t ar get   obj ec t .

our   l oggi ng mes s age   and

Pr oxy   obj ec t .
t hen   del egat es   t o   t he

c ons t   handl er s   =   {
/ /   Thi s   handl er   i s   a   s pec i al	c as e   bec aus e   f or   own pr oper t i es
/ /   whos e   val ue   i s   an   obj ec t   or   f unc t i on,	i t   r et ur ns   a pr oxy   r at her
/ /   t han   r et ur ni ng   t he   val ue   i t s el f .

get ( t ar get ,	pr oper t y,	r ec ei ver )    { / /   L og   t he   get   oper at i on
c ons ol e. l og( ` Handl er
get ( ${ obj name} , ${ pr oper t y. t oSt r i ng( ) } ) ` ) ;

/ /   Us e   t he   Ref l ec t   API	t o   get   t he   pr oper t y   val ue
l et   val ue   =   Ref l ec t . get ( t ar get ,	pr oper t y,	r ec ei ver ) ;



and

Pr oxy   f or

/ /   I f    t he   pr oper t y

/ /   t he   val ue   i s   an i t .

i s   an   own

obj ec t   or

pr oper t y

f unc t i on

of    t he   t ar get

t hen   r et ur n   a

i f    ( Ref l ec t . ownKeys ( t ar get ) . i nc l udes ( pr oper t y)    && ( t ypeof    val ue   ===   " obj ec t "   ||   t ypeof    val ue   ===
" f unc t i on" ) )    {
r et ur n   l oggi ngPr oxy( val ue, ` ${ obj name} . ${ pr oper t y. t oSt r i ng( ) } ` ) ;
}

/ /   Ot her wi s e   r et ur n   t he   val ue   unmodi f i ed. r et ur n   val ue;
} ,


/ /   Ther e   i s met hods :
/ /   t hey   l og obj ec t .
/ /   They   ar e l oggi ng   t he
/ /   r ec ei ver

not hi ng   s pec i al	about   t he   f ol l owi ng   t hr ee

t he   oper at i on   and   del egat e   t o   t he   t ar get

a   s pec i al	c as e   s i mpl y   s o   we   c an   avoi d

obj ec t   whi c h   c an   c aus e   i nf i ni t e   r ec ur s i on.

s et ( t ar get ,	pr op,	val ue,	r ec ei ver )    { c ons ol e. l og( ` Handl er
s et ( ${ obj name} , ${ pr op. t oSt r i ng( ) } , ${ val ue} ) ` ) ;
r et ur n   Ref l ec t . s et ( t ar get ,	pr op,	val ue,	r ec ei ver ) ; } ,
appl y( t ar get ,	r ec ei ver ,	ar gs )    {
c ons ol e. l og( ` Handl er   ${ obj name} ( ${ ar gs } ) ` ) ;
r et ur n   Ref l ec t . appl y( t ar get ,	r ec ei ver ,	ar gs ) ; } ,
c ons t r uc t ( t ar get ,	ar gs ,	r ec ei ver )    {
c ons ol e. l og( ` Handl er   ${ obj name} ( ${ ar gs } ) ` ) ;
r et ur n   Ref l ec t . c ons t r uc t ( t ar get ,	ar gs ,	r ec ei ver ) ; }
} ;


/ /   We   c an   aut omat i c al l y   gener at e   t he   r es t   of    t he   handl er s . / /   Met apr ogr ammi ng   FTW!
Ref l ec t . ownKeys ( Ref l ec t ) . f or Eac h( handl er Name   =>   {
i f    ( ! ( handl er Name   i n   handl er s ) )    {
handl er s [ handl er Name]    =   f unc t i on( t ar get ,	. . . ar gs )    { / /   L og   t he   oper at i on
c ons ol e. l og( ` Handl er   ${ handl er Name} ( ${ obj name} , ${ ar gs } ) ` ) ;
/ /   Del egat e   t he   oper at i on
r et ur n   Ref l ec t [ handl er Name] ( t ar get ,	. . . ar gs ) ; } ;
} } ) ;

/ /   Ret ur n   a   pr oxy   f or   t he   obj ec t   us i ng   t hes e   l oggi ng handl er s
r et ur n   new  Pr oxy( o,	handl er s ) ;
}


The l oggi ngPr oxy( )  function defined earlier creates proxies that log all of the ways they are used. If you are trying to understand how an undocumented function uses the objects you pass it, using a logging proxy can help.

Consider the following examples, which result in some genuine insights about array iteration:

/ /   Def i ne   an   ar r ay   of    dat a   and   an   obj ec t   wi t h   a   f unc t i on pr oper t y
l et   dat a   =   [ 10, 20] ;
l et   met hods   =   {    s quar e:	x   =>   x*x   } ;

/ /   Cr eat e   l oggi ng   pr oxi es   f or   t he   ar r ay   and   t he   obj ec t l et   pr oxyDat a   =   l oggi ngPr oxy( dat a,	" dat a" ) ;
l et   pr oxyMet hods   =   l oggi ngPr oxy( met hods ,	" met hods " ) ;

/ /   Suppos e   we   want   t o   under s t and   how  t he   Ar r ay. map( )    met hod wor ks
dat a. map( met hods . s quar e)	/ /   =>   [ 100,	400]

/ /   Fi r s t ,	l et ' s   t r y   i t   wi t h   a   l oggi ng   Pr oxy   ar r ay pr oxyDat a. map( met hods . s quar e)	/ /   =>   [ 100,	400]
/ /   I t   pr oduc es   t hi s   out put : / /   Handl er   get ( dat a, map)
/ /   Handl er   get ( dat a, l engt h)
/ /   Handl er   get ( dat a, c ons t r uc t or ) / /   Handl er   has ( dat a, 0)
/ /   Handl er   get ( dat a, 0) / /   Handl er   has ( dat a, 1) / /   Handl er   get ( dat a, 1)

/ /   Now  l et s   t r y   wi t h   a   pr oxy   met hods   obj ec t
dat a. map( pr oxyMet hods . s quar e)	/ /   =>   [ 100,	400] / /   L og   out put :
/ /   Handl er   get ( met hods , s quar e)
/ /   Handl er   met hods . s quar e( 10, 0, 10, 20) / /   Handl er   met hods . s quar e( 20, 1, 10, 20)

/ /   Fi nal l y,	l et ' s   us e   a   l oggi ng   pr oxy   t o   l ear n   about   t he i t er at i on   pr ot oc ol
f or ( l et   x   of    pr oxyDat a)    c ons ol e. l og( " Dat um" ,	x) ; / /   L og   out put :
/ /   Handl er   get ( dat a, Symbol ( Symbol . i t er at or ) ) / /   Handl er   get ( dat a, l engt h)
/ /   Handl er   get ( dat a, 0) / /   Dat um 10
/ /   Handl er   get ( dat a, l engt h) / /   Handl er   get ( dat a, 1)
/ /   Dat um 20
/ /   Handl er   get ( dat a, l engt h)


From the first chunk of logging output, we learn that the Ar r ay. map( ) method explicitly checks for the existence of each array element (causing the has ( )  handler to be invoked) before actually reading the element value (which triggers the get ( )  handler). This is presumably so that it can distinguish nonexistent array elements from elements that exist but are undefined.

The second chunk of logging output might remind us that the function we pass to Ar r ay. map( )  is invoked with three arguments: the element’s value, the element’s index, and the array itself. (There is a problem in our

logging output: the Ar r ay. t oSt r i ng( )  method does not include square brackets in its output, and the log messages would be clearer if they were included in the argument list ( 10, 0, [ 10, 20] ) .)


The third chunk of logging output shows us that the f or / of  loop works by looking for a method with symbolic name [ Symbol . i t er at or ] . It also demonstrates that the Array class’s implementation of this iterator method is careful to check the array length at every iteration and does not assume that the array length remains constant during the iteration.


14.7.1 Proxy Invariants

The r eadOnl yPr oxy( )  function defined earlier creates Proxy objects that are effectively frozen: any attempt to alter a property value or property attribute or to add or remove properties will throw an exception. But as long as the target object is not frozen, we’ll find that if we can query the proxy with Ref l ect . i s Ext ens i bl e( )  and
Ref l ect . get OwnPr oper t yDes cr i pt or ( ) , and it will tell us that we should be able to set, add, and delete properties. So
r eadOnl yPr oxy( )  creates objects in an inconsistent state. We could fix this by adding i s Ext ens i bl e( )  and
get OwnPr oper t yDes cr i pt or ( )  handlers, or we can just live with this kind of minor inconsistency.

The Proxy handler API allows us to define objects with major inconsistencies, however, and in this case, the Proxy class itself will prevent us from creating Proxy objects that are inconsistent in a bad way. At the start of this section, we described proxies as objects with no behavior of their own because they simply forward all operations to the handlers object and the target object. But this is not entirely true: after

forwarding an operation, the Proxy class performs some sanity checks on the result to ensure important JavaScript invariants are not being violated. If it detects a violation, the proxy will throw a TypeError instead of letting the operation proceed.


As an example, if you create a proxy for a non-extensible object, the proxy will throw a TypeError if the i s Ext ens i bl e( )  handler ever returns
t r ue:


l et   t ar get   =   Obj ec t . pr event Ext ens i ons ( { } ) ;
l et   pr oxy   =   new  Pr oxy( t ar get ,	{    i s Ext ens i bl e( )    {    r et ur n   t r ue; } } ) ;
Ref l ec t . i s Ext ens i bl e( pr oxy) ;	/ /   ! TypeEr r or :	i nvar i ant   vi ol at i on


Relatedly, proxy objects for non-extensible targets may not have a
get Pr ot ot ypeOf ( )  handler that returns anything other than the real prototype object of the target. Also, if the target object has nonwritable, nonconfigurable properties, then the Proxy class will throw a TypeError if the get ( )  handler returns anything other than the actual value:


l et   t ar get   =   Obj ec t . f r eez e( { x:	1} ) ;
l et   pr oxy   =   new  Pr oxy( t ar get ,	{    get ( )    {    r et ur n   99;	} } ) ;
pr oxy. x;	/ /   ! TypeEr r or :	val ue   r et ur ned   by   get ( )    does n' t mat c h   t ar get


Proxy enforces a number of additional invariants, almost all of them having to do with non-extensible target objects and nonconfigurable properties on the target object.


14.8 Summary

In this chapter, you have learned:

JavaScript objects have an extensible attribute and object properties have writable, enumerable, and configurable attributes, as well as a value and a getter and/or setter attribute. You can use these attributes to “lock down” your objects in various ways, including creating “sealed” and “frozen” objects.

JavaScript defines functions that allow you to traverse the prototype chain of an object and even to change the prototype of an object (though doing this can make your code slower).

The properties of the Symbol  object have values that are “well-known Symbols,” which you can use as property or method names for the objects and classes that you define. Doing so allows you to control how your object interacts with JavaScript language features and with the core library. For example, well-known Symbols allow you to make your classes iterable and control the string that is displayed when an instance is passed to
Obj ect . pr ot ot ype. t oSt r i ng( ) . Prior to ES6, this kind of customization was available only to the native classes that were built in to an implementation.

Tagged template literals are a function invocation syntax, and defining a new tag function is kind of like adding a new literal syntax to the language. Defining a tag function that parses its template string argument allows you to embed DSLs within JavaScript code. Tag functions also provide access to a raw, unescaped form of string literals where backslashes have no special meaning.

The Proxy class and the related Reflect API allow low-level control over the fundamental behaviors of JavaScript objects. Proxy objects can be used as optionally revocable wrappers to improve code encapsulation, and they can also be used to implement nonstandard object behaviors (like some of the special case APIs defined by early web browsers).


1   A bug in the V8 JavaScript engine means that this code does not work correctly in Node 13.



Chapter 15. J avaScript in Web Browsers




The JavaScript language was created in 1994 with the express purpose of enabling dynamic behavior in the documents displayed by web browsers. The language has evolved significantly since then, and at the same time, the scope and capabilities of the web platform have grown explosively. Today, JavaScript programmers can think of the web as a full-featured platform for application development. Web browsers specialize in the display of formatted text and images, but, like native operating systems, browsers also provide other services, including graphics, video, audio, networking, storage, and threading. JavaScript is the language that enables web applications to use the services provided by the web platform, and this chapter demonstrates how you can use the most important of these services.


The chapter begins with the web platform’s programming model, explaining how scripts are embedded within HTML pages (§15.1) and how JavaScript code is triggered asynchronously by events (§15.2). The sections that follow this introductory material document the core JavaScript APIs that enable your web applications to:

Control document content (§15.3) and style (§15.4)

Determine the on-screen position of document elements (§15.5)

Create reusable user interface components (§15.6)

Draw graphics (§15.7 and §15.8)

Play and generate sounds (§15.9)

Manage browser navigation and history (§15.10)

Exchange data over the network (§15.11)

Store data on the user’s computer (§15.12)

Perform concurrent computation with threads (§15.13)


CLIENT-SIDE J AVASCRIPT

In this book, and on the web, you’ll see the term “client-side JavaScript.” The term is simply a synonym for JavaScript written to run in a web browser, and it stands in contrast to “server-side” code, which runs in web servers.

The two “sides” refer to the two ends of the network connection that separate the web server and the web browser, and software development for the web typically requires code to be written on both “sides.” Client-side and server-side are also often called “frontend” and “backend.”



Previous editions of this book attempted to comprehensively cover all JavaScript APIs defined by web browsers, and as a result, this book was too long a decade ago. The number and complexity of web APIs has continued to grow, and I no longer think it makes sense to attempt to cover them all in one book. As of the seventh edition, my goal is to cover the JavaScript language definitively and to provide an in-depth introduction to using the language with Node and with web browsers. This chapter cannot cover all the web APIs, but it introduces the most important ones in enough detail that you can start using them right away. And, having learned about the core APIs covered here, you should be able to pick up new APIs (like those summarized in §15.15) when and if you need them.


Node has a single implementation and a single authoritative source for documentation. Web APIs, by contrast, are defined by consensus among the major web browser vendors, and the authoritative documentation takes the form of a specification intended for the C++ programmers who

implement the API, not for the JavaScript programmers who will use it. Fortunately, Mozilla’s “MDN web docs” project is a reliable and comprehensive source1 for web API documentation.



LEGACY APIS

In the 25 years since JavaScript was first released, browser vendors have been adding features and APIs for programmers to use. Many of those APIs are now obsolete. They include:

Proprietary APIs that were never standardized and/or never implemented by other browser vendors. Microsoft’s Internet Explorer defined a lot of these APIs. Some (like the i nner HTML property) proved useful and were eventually standardized. Others (like the at t achEvent ( ) method) have been obsolete for years.

Inefficient APIs (like the document . wr i t e( )  method) that have such a severe performance impact that their use is no longer considered acceptable.

Outdated APIs that have long since been replaced by new APIs for achieving the same thing. An example is document . bgCol or , which was defined to allow JavaScript to set the background color of a document. With the advent of CSS, document . bgCol or  became a quaint special case with no real purpose.

Poorly designed APIs that have been replaced by better ones. In the early days of the web, standards committees defined the key Document Object Model API in a language-agnostic way so that the same API could be used in Java programs to work with XML documents on and in JavaScript programs to work with HTML documents. This resulted in an API that was not well suited to the JavaScript language and that had features that web programmers didn’t particularly care about. It took decades to recover from those early design mistakes, but today’s web browsers support a much-improved Document Object Model.

Browser vendors may need to support these legacy APIs for the foreseeable future in order to ensure backward compatibility, but there is no longer any need for this book to document them or for you to learn about them. The web platform has matured and stabilized, and if you are a seasoned web developer who remembers the fourth or fifth edition of this book, then you may have as much outdated knowledge to forget as you have new material to learn.




15.1 Web Programming Basics

This section explains how JavaScript programs for the web are structured, how they are loaded into a web browser, how they obtain input, how they produce output, and how they run asynchronously by responding to events.

15.1.1 J avaScript in HTML <script> Tags

Web browsers display HTML documents. If you want a web browser to execute JavaScript code, you must include (or reference) that code from an HTML document, and this is what the HTML <s cr i pt > tag does.


JavaScript code can appear inline within an HTML file between
<s cr i pt > and </ s cr i pt > tags. Here, for example, is an HTML file that includes a script tag with JavaScript code that dynamically updates one element of the document to make it behave like a digital clock:


<! DOCTYPE   ht ml > <ht ml >
<head>
go   her e   - - >
<t i t l e>Di gi t al	Cl oc k</t i t l e> <s t yl e>
c l oc k   */

<! - -    Thi s   i s   an   HTML 5   f i l e   - - > <! - -    The   r oot   el ement   - - >
<! - -    Ti t l e,	s c r i pt s   &  s t yl es   c an


/ *   A  CSS   s t yl es heet   f or   t he

#c l oc k   {	/ *   St yl es   appl y   t o   el ement   wi t h i d=" c l oc k"   */
f ont :    bol d   24px   s ans - s er i f ;         / *   Us e   a   bi g   bol d   f ont   */ bac kgr ound:    #ddf ;                                     / *   on   a   l i ght   bl ui s h- gr ay
bac kgr ound.	*/
paddi ng:	15px;	/ *   Sur r ound   i t   wi t h   s ome   s pac e */
bor der :	s ol i d   bl ac k   2px;	/ *   and   a   s ol i d   bl ac k   bor der   */ bor der - r adi us :	10px;	/ *   wi t h   r ounded   c or ner s .	*/
}
</s t yl e> </head>
<body>	<! - -    The   body   hol ds   t he   c ont ent   of    t he doc ument .    - - >
<h1>Di gi t al	Cl oc k</h1>	<! - -    Di s pl ay   a   t i t l e.	- - >
<s pan   i d=" c l oc k" ></s pan>	<! - -    We   wi l l	i ns er t   t he   t i me   i nt o   t hi s el ement .	- - >
<s c r i pt >
/ /   Def i ne   a   f unc t i on   t o   di s pl ay   t he   c ur r ent   t i me f unc t i on   di s pl ayTi me( )    {
l et   c l oc k   =   doc ument . quer ySel ec t or ( " #c l oc k" ) ;	/ /   Get   el ement wi t h   i d=" c l oc k"
l et   now  =   new  Dat e( ) ;	/ /   Get   c ur r ent

t i me
c l oc k. t ext Cont ent   =   now. t oL oc al eTi meSt r i ng( ) ;	/ /   Di s pl ay t i me   i n   t he   c l oc k
}
di s pl ayTi me( )	/ /   Di s pl ay   t he   t i me   r i ght   away s et I nt er val ( di s pl ayTi me,    1000) ;	/ /   And   t hen   updat e   i t   ever y
s ec ond. </s c r i pt > </body> </ht ml >


Although JavaScript code can be embedded directly within a <s cr i pt > tag, it is more common to instead use the s r c attribute of the <s cr i pt > tag to specify the URL (an absolute URL or a URL relative to the URL of the HTML file being displayed) of a file containing JavaScript code. If we took the JavaScript code out of this HTML file and stored it in its own scripts/digital_clock.js file, then the <s cr i pt > tag might reference that file of code like this:

<s c r i pt   s r c =" s c r i pt s / di gi t al _c l oc k. j s " ></s c r i pt >


A JavaScript file contains pure JavaScript, without <s cr i pt > tags or any other HTML. By convention, files of JavaScript code have names that end with .js.

A <s cr i pt > tag with the a s r c attribute behaves exactly as if the contents of the specified JavaScript file appeared directly between the
<s cr i pt > and </ s cr i pt > tags. Note that the closing </ s cr i pt > tag is required in HTML documents even when the s r c attribute is specified: HTML does not support a <s cr i pt / > tag.

There are a number of advantages to using the s r c attribute:


It simplifies your HTML files by allowing you to remove large

blocks of JavaScript code from them—that is, it helps keep content and behavior separate.

When multiple web pages share the same JavaScript code, using the s r c attribute allows you to maintain only a single copy of that code, rather than having to edit each HTML file when the code changes.

If a file of JavaScript code is shared by more than one page, it only needs to be downloaded once, by the first page that uses it— subsequent pages can retrieve it from the browser cache.

Because the s r c attribute takes an arbitrary URL as its value, a JavaScript program or web page from one web server can employ code exported by other web servers. Much internet advertising relies on this fact.

MODULES

§10.3 documents JavaScript modules and covers their i mpor t  and expor t  directives. If you have written your JavaScript program using modules (and have not used a code-bundling tool to combine all your modules into a single nonmodular file of JavaScript), then you must load the top-level module of your program with a <s cr i pt > tag that has a
t ype=" modul e" attribute. If you do this, then the module you specify will be loaded, and all of the modules it imports will be loaded, and (recursively) all of the modules they import will be loaded. See §10.3.5 for complete details.

SPECIFYING SCRIPT TYPE

In the early days of the web, it was thought that browsers might some day implement languages other than JavaScript, and programmers added attributes like l anguage=" j avas cr i pt " and
t ype=" appl i cat i on/ j avas cr i pt " to their <s cr i pt > tags. This

is completely unnecessary. JavaScript is the default (and only) language of the web. The l anguage attribute is deprecated, and there are only two reasons to use a t ype attribute on a <s cr i pt > tag:

To specify that the script is a module

To embed data into a web page without displaying it (see §15.3.4)

WHEN SCRIPTS RUN: ASYNC AND DEFERRED

When JavaScript was first added to web browsers, there was no API for traversing and manipulating the structure and content of an already rendered document. The only way that JavaScript code could affect the content of a document was to generate that content on the fly while the document was in the process of loading. It did this by using the document . wr i t e( )  method to inject HTML text into the document at the location of the script.

The use of document . wr i t e( )  is no longer considered good style, but the fact that it is possible means that when the HTML parser encounters a <s cr i pt > element, it must, by default, run the script just to be sure that it doesn’t output any HTML before it can resume parsing and rendering the document. This can dramatically slow down parsing and rendering of the web page.

Fortunately, this default synchronous or blocking script execution mode is not the only option. The <s cr i pt > tag can have def er  and as ync attributes, which cause scripts to be executed differently. These are boolean attributes—they don’t have a value; they just need to be present on the <s cr i pt > tag. Note that these attributes are only meaningful when used in conjunction with the s r c attribute:


<s c r i pt <s c r i pt

def er   s r c =" def er r ed. j s " ></s c r i pt > as ync   s r c =" as ync . j s " ></s c r i pt >



Both the def er  and as ync attributes are ways of telling the browser that the linked script does not use document . wr i t e( )  to generate HTML output, and that the browser, therefore, can continue to parse and render the document while downloading the script. The def er  attribute causes the browser to defer execution of the script until after the document has been fully loaded and parsed and is ready to be manipulated. The as ync attribute causes the browser to run the script as soon as possible but does not block document parsing while the script is being downloaded. If a
<s cr i pt > tag has both attributes, the as ync attribute takes precedence.


Note that deferred scripts run in the order in which they appear in the document. Async scripts run as they load, which means that they may execute out of order.


Scripts with the t ype=" modul e" attribute are, by default, executed after the document has loaded, as if they had a def er  attribute. You can override this default with the as ync attribute, which will cause the code to be executed as soon as the module and all of its dependencies have loaded.

A simple alternative to the as ync and def er  attributes—especially for code that is included directly in the HTML—is to simply put your scripts at the end of the HTML file. That way, the script can run knowing that the document content before it has been parsed and is ready to be manipulated.

LOADING SCRIPTS ON DEMAND

Sometimes, you may have JavaScript code that is not used when a

document first loads and is only needed if the user takes some action like clicking on a button or opening a menu. If you are developing your code using modules, you can load a module on demand with i mpor t ( ) , as described in §10.3.6.

If you are not using modules, you can load a file of JavaScript on demand simply by adding a <s cr i pt > tag to your document when you want the script to load:


/ /   As ync hr onous l y   l oad   and   exec ut e / /   Ret ur ns   a   Pr omi s e   t hat   r es ol ves

a   s c r i pt when   t he

f r om a   s pec i f i ed   URL s c r i pt   has   l oaded.

f unc t i on   i mpor t Sc r i pt ( ur l )    {
r et ur n   new  Pr omi s e( ( r es ol ve,	r ej ec t )    =>   {
l et   s   =   doc ument . c r eat eEl ement ( " s c r i pt " ) ;	/ /   Cr eat e   a <s c r i pt >   el ement
s . onl oad   =   ( )    =>   {    r es ol ve( ) ;	} ;	/ /   Res ol ve pr omi s e   when   l oaded
s . oner r or   =   ( e)    =>   {    r ej ec t ( e) ;	} ;	/ /   Rej ec t   on f ai l ur e
s . s r c   =   ur l ;	/ /   Set   t he s c r i pt   URL
doc ument . head. append( s ) ;	/ /   Add <s c r i pt >   t o   doc ument
} ) ; }


This i mpor t Scr i pt ( )  function uses DOM APIs (§15.3) to create a new <s cr i pt > tag and add it to the document <head>. And it uses event handlers (§15.2) to determine when the script has loaded successfully or when loading has failed.


15.1.2 The Document Object Model

One of the most important objects in client-side JavaScript programming is the Document object—which represents the HTML document that is displayed in a browser window or tab. The API for working with HTML

documents is known as the Document Object Model, or DOM, and it is covered in detail in §15.3. But the DOM is so central to client-side JavaScript programming that it deserves to be introduced here.


HTML documents contain HTML elements nested within one another, forming a tree. Consider the following simple HTML document:

<ht ml > <head>
<t i t l e>Sampl e   Doc ument </t i t l e> </head>
<body>
<h1>An   HTML   Doc ument </h1>
<p>Thi s   i s   a   <i >s i mpl e</i >   doc ument . </body>
</ht ml >


The top-level <ht ml > tag contains <head> and <body> tags. The <head> tag contains a <t i t l e> tag. And the <body> tag contains <h1> and <p> tags. The <t i t l e> and <h1> tags contain strings of text, and the <p> tag contains two strings of text with an <i > tag between them.

The DOM API mirrors the tree structure of an HTML document. For each HTML tag in the document, there is a corresponding JavaScript Element object, and for each run of text in the document, there is a corresponding Text object. The Element and Text classes, as well as the Document class itself, are all subclasses of the more general Node class, and Node objects are organized into a tree structure that JavaScript can query and traverse using the DOM API. The DOM representation of this document is the tree pictured in Figure 15-1.

















































Figure 15-1. The tree representation of an HTML document

If you are not already familiar with tree structures in computer programming, it is helpful to know that they borrow terminology from

family trees. The node directly above a node is the parent of that node. The nodes one level directly below another node are the children of that node. Nodes at the same level, and with the same parent, are siblings. The set of nodes any number of levels below another node are the descendants of that node. And the parent, grandparent, and all other nodes above a node are the ancestors of that node.


The DOM API includes methods for creating new Element and Text nodes, and for inserting them into the document as children of other Element objects. There are also methods for moving elements within the document and for removing them entirely. While a server-side application might produce plain-text output by writing strings with
cons ol e. l og( ) , a client-side JavaScript application can produce formatted HTML output by building or manipulating the document tree document using the DOM API.

There is a JavaScript class corresponding to each HTML tag type, and each occurrence of the tag in a document is represented by an instance of the class. The <body> tag, for example, is represented by an instance of HTMLBodyElement, and a <t abl e> tag is represented by an instance of HTMLTableElement. The JavaScript element objects have properties that correspond to the HTML attributes of the tags. For example, instances of HTMLImageElement, which represent <i mg> tags, have a s r c property that corresponds to the s r c attribute of the tag. The initial value of the
s r c property is the attribute value that appears in the HTML tag, and setting this property with JavaScript changes the value of the HTML attribute (and causes the browser to load and display a new image). Most of the JavaScript element classes just mirror the attributes of an HTML tag, but some define additional methods. The HTMLAudioElement and HTMLVideoElement classes, for example, define methods like pl ay( )

and paus e( )  for controlling playback of audio and video files.


15.1.3 The Global Object in Web Browsers

There is one global object per browser window or tab (§3.7). All of the JavaScript code (except code running in worker threads; see §15.13) running in that window shares this single global object. This is true regardless of how many scripts or modules are in the document: all the scripts and modules of a document share a single global object; if one script defines a property on that object, that property is visible to all the other scripts as well.


The global object is where JavaScript’s standard library is defined—the par s eI nt ( )  function, the Math object, the Set class, and so on. In web browsers, the global object also contains the main entry points of various web APIs. For example, the document  property represents the currently displayed document, the f et ch( )  method makes HTTP network requests, and the Audi o( )  constructor allows JavaScript programs to play sounds.

In web browsers, the global object does double duty: in addition to defining built-in types and functions, it also represents the current web browser window and defines properties like hi s t or y (§15.10.2), which represent the window’s browsing history, and i nner Wi dt h, which holds the window’s width in pixels. One of the properties of this global object is named wi ndow, and its value is the global object itself. This means that you can simply type wi ndowto refer to the global object in your client-side code. When using window-specific features, it is often a good idea to include a wi ndow.  prefix: wi ndow. i nner Wi dt h is clearer than
i nner Wi dt h, for example.

15.1.4 Scripts Share a Namespace

With modules, the constants, variables, functions, and classes defined at the top level (i.e., outside of any function or class definition) of the module are private to the module unless they are explicitly exported, in which case, they can be selectively imported by other modules. (Note that this property of modules is honored by code-bundling tools as well.)


With non-module scripts, however, the situation is completely different. If the top-level code in a script defines a constant, variable, function, or class, that declaration will be visible to all other scripts in the same document. If one script defines a function f ( )  and another script defines a class c, then a third script can invoke the function and instantiate the class without having to take any action to import them. So if you are not using modules, the independent scripts in your document share a single namespace and behave as if they are all part of a single larger script. This can be convenient for small programs, but the need to avoid naming conflicts can become problematic for larger programs, especially when some of the scripts are third-party libraries.

There are some historical quirks with how this shared namespace works. var  and f unct i on declarations at the top level create properties in the shared global object. If one script defines a top-level function f ( ) , then another script in the same document can invoke that function as f ( )  or as wi ndow. f ( ) . On the other hand, the ES6 declarations cons t , l et , and cl as s , when used at the top level, do not create properties in the global object. They are still defined in a shared namespace, however: if one script defines a class C, other scripts will be able to create instances of that class with new  C( ) , but not with new  wi ndow. C( ) .

To summarize: in modules, top-level declarations are scoped to the module and can be explicitly exported. In nonmodule scripts, however, top-level declarations are scoped to the containing document, and the declarations are shared by all scripts in the document. Older var  and f unct i on declarations are shared via properties of the global object. Newer cons t ,
l et , and cl as s  declarations are also shared and have the same document scope, but they do not exist as properties of any object that JavaScript code has access to.


15.1.5 Execution of J avaScript Programs

There is no formal definition of a program in client-side JavaScript, but we can say that a JavaScript program consists of all the JavaScript code in, or referenced from, a document. These separate bits of code share a single global Window object, which gives them access to the same underlying Document object representing the HTML document. Scripts that are not modules additionally share a top-level namespace.


If a web page includes an embedded frame (using the <i f r ame> element), the JavaScript code in the embedded document has a different global object and Document object than the code in the embedding document, and it can be considered a separate JavaScript program. Remember, though, that there is no formal definition of what the boundaries of a JavaScript program are. If the container document and the contained document are both loaded from the same server, the code in one document can interact with the code in the other, and you can treat them as two interacting parts of a single program, if you wish. §15.13.6 explains how a JavaScript program can send and receive messages to and from JavaScript code running in an <i f r ame>.

You can think of JavaScript program execution as occurring in two phases. In the first phase, the document content is loaded, and the code from
<s cr i pt > elements (both inline scripts and external scripts) is run. Scripts generally run in the order in which they appear in the document, though this default order can be modified by the as ync and def er attributes we’ve described. The JavaScript code within any single script is run from top to bottom, subject, of course, to JavaScript’s conditionals, loops, and other control statements. Some scripts don’t really do anything during this first phase and instead just define functions and classes for use in the second phase. Other scripts might do significant work during the first phase and then do nothing in the second. Imagine a script at the very end of a document that finds all <h1> and <h2> tags in the document and modifies the document by generating and inserting a table of contents at the beginning of the document. This could be done entirely in the first phase. (See §15.3.6 for an example that does exactly this.)

Once the document is loaded and all scripts have run, JavaScript execution enters its second phase. This phase is asynchronous and event-driven. If a script is going to participate in this second phase, then one of the things it must have done during the first phase is to register at least one event handler or other callback function that will be invoked asynchronously. During this event-driven second phase, the web browser invokes event handler functions and other callbacks in response to events that occur asynchronously. Event handlers are most commonly invoked in response to user input (mouse clicks, keystrokes, etc.) but may also be triggered by network activity, document and resource loading, elapsed time, or errors in JavaScript code. Events and event handlers are described in detail in §15.2.


Some of the first events to occur during the event-driven phase are the

“DOMContentLoaded” and “load” events. “DOMContentLoaded” is triggered when the HTML document has been completely loaded and parsed. The “load” event is triggered when all of the document’s external resources—such as images—are also fully loaded. JavaScript programs often use one of these events as a trigger or starting signal. It is common to see programs whose scripts define functions but take no action other than registering an event handler function to be triggered by the “load” event at the beginning of the event-driven phase of execution. It is this “load” event handler that then manipulates the document and does whatever it is that the program is supposed to do. Note that it is common in JavaScript programming for an event handler function such as the “load” event handler described here to register other event handlers.


The loading phase of a JavaScript program is relatively short: ideally less than a second. Once the document is loaded, the event-driven phase lasts for as long as the document is displayed by the web browser. Because this phase is asynchronous and event-driven, there may be long periods of inactivity where no JavaScript is executed, punctuated by bursts of activity triggered by user or network events. We’ll cover these two phases in more detail next.

CLIENT-SIDE J AVASCRIPT THREADING MODEL

JavaScript is a single-threaded language, and single-threaded execution makes for much simpler programming: you can write code with the assurance that two event handlers will never run at the same time. You can manipulate document content knowing that no other thread is attempting to modify it at the same time, and you never need to worry about locks, deadlock, or race conditions when writing JavaScript code.


Single-threaded execution means that web browsers stop responding to

user input while scripts and event handlers are executing. This places a burden on JavaScript programmers: it means that JavaScript scripts and event handlers must not run for too long. If a script performs a computationally intensive task, it will introduce a delay into document loading, and the user will not see the document content until the script completes. If an event handler performs a computationally intensive task, the browser may become nonresponsive, possibly causing the user to think that it has crashed.


The web platform defines a controlled form of concurrency called a “web worker.” A web worker is a background thread for performing computationally intensive tasks without freezing the user interface. The code that runs in a web worker thread does not have access to document content, does not share any state with the main thread or with other workers, and can only communicate with the main thread and other workers through asynchronous message events, so the concurrency is not detectable to the main thread, and web workers do not alter the basic single-threaded execution model of JavaScript programs. See §15.13 for full details on the web’s safe threading mechanism.

CLIENT-SIDE J AVASCRIPT TIMELINE

We’ve already seen that JavaScript programs begin in a script-execution phase and then transition to an event-handling phase. These two phases can be further broken down into the following steps:

1.  The web browser creates a Document object and begins parsing the web page, adding Element objects and Text nodes to the document as it parses HTML elements and their textual content. The document . r eadySt at e property has the value “loading” at this stage.

2.  When the HTML parser encounters a <s cr i pt > tag that does not have any of the as ync, def er , or t ype=" modul e" attributes, it adds that script tag to the document and then executes the script. The script is executed synchronously, and the HTML parser pauses while the script downloads (if necessary) and runs. A script like this can use document . wr i t e( )  to insert text into the input stream, and that text will become part of the document when the parser resumes. A script like this often simply defines functions and registers event handlers for later use, but it can traverse and manipulate the document tree as it exists at that time. That is, non-module scripts that do not have an as ync or def er  attribute can see their own <s cr i pt > tag and document content that comes before it.

3.  When the parser encounters a <s cr i pt > element that has the as ync attribute set, it begins downloading the script text (and if the script is a module, it also recursively downloads all of the script’s dependencies) and continues parsing the document. The script will be executed as soon as possible after it has downloaded, but the parser does not stop and wait for it to download. Asynchronous scripts must not use the
document . wr i t e( )  method. They can see their own
<s cr i pt > tag and all document content that comes before it, and may or may not have access to additional document content.

4.  When the document is completely parsed, the
document . r eadySt at e property changes to “interactive.”

5.  Any scripts that had the def er  attribute set (along with any module scripts that do not have an as ync attribute) are executed in the order in which they appeared in the document. Async scripts may also be executed at this time. Deferred scripts have access to the complete document and they must not use the document . wr i t e( )  method.

6.  The browser fires a “DOMContentLoaded” event on the Document object. This marks the transition from synchronous

script-execution phase to the asynchronous, event-driven phase of program execution. Note, however, that there may still be as ync scripts that have not yet executed at this point.

7.  The document is completely parsed at this point, but the browser may still be waiting for additional content, such as images, to load. When all such content finishes loading, and when all
as ync scripts have loaded and executed, the
document . r eadySt at e property changes to “complete” and the web browser fires a “load” event on the Window object.

8.  From this point on, event handlers are invoked asynchronously in response to user input events, network events, timer expirations, and so on.


15.1.6 Program Input and Output

Like any program, client-side JavaScript programs process input data to produce output data. There are a variety of inputs available:

The content of the document itself, which JavaScript code can access with the DOM API (§15.3).

User input, in the form of events, such as mouse clicks (or touch-screen taps) on HTML <but t on> elements, or text entered into HTML <t ext ar ea> elements, for example. §15.2 demonstrates how JavaScript programs can respond to user events like these.

The URL of the document being displayed is available to client-side JavaScript as document . URL. If you pass this string to the URL( )  constructor (§11.9), you can easily access the path, query, and fragment sections of the URL.

The content of the HTTP “Cookie” request header is available to client-side code as document . cooki e. Cookies are usually used by server-side code for maintaining user sessions, but client-side code can also read (and write) them if necessary. See

§15.12.2 for further details.

The global navi gat or  property provides access to information about the web browser, the OS it’s running on top of, and the capabilities of each. For example, navi gat or . us er Agent  is a string that identifies the web browser,
navi gat or . l anguage is the user’s preferred language, and navi gat or . har dwar eConcur r ency returns the number of logical CPUs available to the web browser. Similarly, the global
s cr een property provides access to the user’s display size via the s cr een. wi dt h and s cr een. hei ght  properties. In a sense, these navi gat or  and s cr een objects are to web browsers what environment variables are to Node programs.

Client-side JavaScript typically produces output, when it needs to, by manipulating the HTML document with the DOM API (§15.3) or by using a higher-level framework such as React or Angular to manipulate the document. Client-side code can also use cons ol e. l og( )  and related methods (§11.8) to produce output. But this output is only visible in the web developer console, so it is useful when debugging, but not for user-visible output.


15.1.7 Program Errors

Unlike applications (such as Node applications) that run directly on top of the OS, JavaScript programs in a web browser can’t really “crash.” If an exception occurs while your JavaScript program is running, and if you do not have a cat ch statement to handle it, an error message will be displayed in the developer console, but any event handlers that have been registered keep running and responding to events.

If you would like to define an error handler of last resort to be invoked when this kind of uncaught exception occurs, set the oner r or  property

of the Window object to an error handler function. When an uncaught exception propagates all the way up the call stack and an error message is about to be displayed in the developer console, the wi ndow. oner r or function will be invoked with three string arguments. The first argument to wi ndow. oner r or  is a message describing the error. The second argument is a string that contains the URL of the JavaScript code that caused the error. The third argument is the line number within the document where the error occurred. If the oner r or  handler returns
t r ue, it tells the browser that the handler has handled the error and that no further action is necessary—in other words, the browser should not display its own error message.

When a Promise is rejected and there is no . cat ch( )  function to handle it, that is a situation much like an unhandled exception: an unanticipated error or a logic error in your program. You can detect this by defining a
wi ndow. onunhandl edr ej ect i on function or by using wi ndow. addEvent Li s t ener ( )  to register a handler for
“unhandledrejection” events. The event object passed to this handler will have a pr omi s e property whose value is the Promise object that rejected and a r eas on property whose value is what would have been passed to a . cat ch( )  function. As with the error handlers described earlier, if you call pr event Def aul t ( )  on the unhandled rejection event object, it will be considered handled and won’t cause an error message in the developer console.

It is not often necessary to define oner r or  or
onunhandl edr ej ect i on handlers, but it can be quite useful as a telemetry mechanism if you want to report client-side errors to the server (using the f et ch( )  function to make an HTTP POST request, for

example) so that you can get information about unexpected errors that happen in your users’browsers.


15.1.8 The Web Security Model

The fact that web pages can execute arbitrary JavaScript code on your personal device has clear security implications, and browser vendors have worked hard to balance two competing goals:

Defining powerful client-side APIs to enable useful web applications

Preventing malicious code from reading or altering your data, compromising your privacy, scamming you, or wasting your time

The subsections that follow give a quick overview of the security restrictions and issues that you, as a JavaScript programmer, should to be aware of.

WHAT J AVASCRIPT CAN’T DO

Web browsers’first line of defense against malicious code is that they simply do not support certain capabilities. For example, client-side JavaScript does not provide any way to write or delete arbitrary files or list arbitrary directories on the client computer. This means a JavaScript program cannot delete data or plant viruses.


Similarly, client-side JavaScript does not have general-purpose networking capabilities. A client-side JavaScript program can make HTTP requests (§15.11.1). And another standard, known as WebSockets (§15.11.3), defines a socket-like API for communicating with specialized servers. But neither of these APIs allows unmediated access to the wider network. General-purpose internet clients and servers cannot be written in client-

side JavaScript.


THE SAME-ORIGIN POLICY

The same-origin policy is a sweeping security restriction on what web content JavaScript code can interact with. It typically comes into play when a web page includes <i f r ame> elements. In this case, the same-origin policy governs the interactions of JavaScript code in one frame with the content of other frames. Specifically, a script can read only the properties of windows and documents that have the same origin as the document that contains the script.

The origin of a document is defined as the protocol, host, and port of the URL from which the document was loaded. Documents loaded from different web servers have different origins. Documents loaded through different ports of the same host have different origins. And a document loaded with the ht t p:  protocol has a different origin than one loaded with the ht t ps :  protocol, even if they come from the same web server. Browsers typically treat every f i l e:  URL as a separate origin, which means that if you’re working on a program that displays more than one document from the same server, you may not be able to test it locally using f i l e:  URLs and will have to run a static web server during development.

It is important to understand that the origin of the script itself is not relevant to the same-origin policy: what matters is the origin of the document in which the script is embedded. Suppose, for example, that a script hosted by host A is included (using the s r c property of a
<s cr i pt > element) in a web page served by host B. The origin of that script is host B, and the script has full access to the content of the

document that contains it. If the document contains an <i f r ame> that contains a second document from host B, then the script also has full access to the content of that second document. But if the top-level document contains another <i f r ame> that displays a document from host C (or even one from host A), then the same-origin policy comes into effect and prevents the script from accessing this nested document.

The same-origin policy also applies to scripted HTTP requests (see §15.11.1). JavaScript code can make arbitrary HTTP requests to the web server from which the containing document was loaded, but it does not allow scripts to communicate with other web servers (unless those web servers opt in with CORS, as we describe next).


The same-origin policy poses problems for large websites that use multiple subdomains. For example, scripts with origin orders.example.com might need to read properties from documents on example.com. To support multidomain websites of this sort, scripts can alter their origin by setting document . domai n to a domain suffix. So a script with origin https://orders.example.com can change its origin to https://example.com by setting document . domai n to “example.com.” But that script cannot set document . domai n to “orders.example”, “ample.com”, or “com”.


The second technique for relaxing the same-origin policy is Cross-Origin Resource Sharing, or CORS, which allows servers to decide which origins they are willing to serve. CORS extends HTTP with a new Or i gi n: request header and a new Acces s - Cont r ol - Al l ow- Or i gi n response header. It allows servers to use a header to explicitly list origins that may request a file or to use a wildcard and allow a file to be requested by any site. Browsers honor these CORS headers and do not relax same-origin restrictions unless they are present.

CROSS-SITE SCRIPTING

Cross-site scripting, or XSS, is a term for a category of security issues in which an attacker injects HTML tags or scripts into a target website. Client-side JavaScript programmers must be aware of, and defend against, cross-site scripting.


A web page is vulnerable to cross-site scripting if it dynamically generates document content and bases that content on user-submitted data without first “sanitizing” that data by removing any embedded HTML tags from it. As a trivial example, consider the following web page that uses JavaScript to greet the user by name:

<s c r i pt >
l et   name   =   new  URL ( doc ument . URL ) . s ear c hPar ams . get ( " name" ) ; doc ument . quer ySel ec t or ( ' h1' ) . i nner HTML   =   " Hel l o   "   +   name; </s c r i pt >

This two-line script extracts input from the “name” query parameter of the document URL. It then uses the DOM API to inject an HTML string into the first <h1> tag in the document. This page is intended to be invoked with a URL like this:

ht t p: / / www. exampl e. c om/ gr eet . ht ml ?name=Davi d


When used like this, it displays the text “Hello David.” But consider what happens when it is invoked with this query parameter:

name=%3Ci mg%20s r c =%22x. png%22%20onl oad=%22al er t ( %27hac ked%27) %22 / %3E


When the URL-escaped parameters are decoded, this URL causes the following HTML to be injected into the document:

Hel l o   <i mg   s r c =" x. png"   onl oad=" al er t ( ' hac ked' ) " / >


After the image loads, the string of JavaScript in the onl oad attribute is executed. The global al er t ( )  function displays a modal dialogue box. A single dialogue box is relatively benign but demonstrates that arbitrary code execution is possible on this site because it displays unsanitized HTML.

Cross-site scripting attacks are so called because more than one site is involved. Site B includes a specially crafted link (like the one in the previous example) to site A. If site B can convince users to click the link, they will be taken to site A, but that site will now be running code from site B. That code might deface the page or cause it to malfunction. More dangerously, the malicious code could read cookies stored by site A (perhaps account numbers or other personally identifying information) and send that data back to site B. The injected code could even track the user’s keystrokes and send that data back to site B.


In general, the way to prevent XSS attacks is to remove HTML tags from any untrusted data before using it to create dynamic document content. You can fix the greet.html file shown earlier by replacing special HTML characters in the untrusted input string with their equivalent HTML entities:

name   =   name

. r epl ac e( / &/ g, . r epl ac e( / </ g, . r epl ac e( / >/ g, . r epl ac e( / " / g,
. r epl ac e( / ' / g,

" &amp; " ) " &l t ; " ) " &gt ; " )
" &quot ; " )
" &#x27; " )

. r epl ac e( / \ / / g,	" &#x2F; " )


Another approach to the problem of XSS is to structure your web

applications so that untrusted content is always displayed in an
<i f r ame> with the s andbox attribute set to disable scripting and other capabilities.

Cross-site scripting is a pernicious vulnerability whose roots go deep into the architecture of the web. It is worth understanding this vulnerability in-depth, but further discussion is beyond the scope of this book. There are many online resources to help you defend against cross-site scripting.


15.2 Events

Client-side JavaScript programs use an asynchronous event-driven programming model. In this style of programming, the web browser generates an event whenever something interesting happens to the document or browser or to some element or object associated with it. For example, the web browser generates an event when it finishes loading a document, when the user moves the mouse over a hyperlink, or when the user strikes a key on the keyboard. If a JavaScript application cares about a particular type of event, it can register one or more functions to be invoked when events of that type occur. Note that this is not unique to web programming: all applications with graphical user interfaces are designed this way—they sit around waiting to be interacted with (i.e., they wait for events to occur), and then they respond.


In client-side JavaScript, events can occur on any element within an HTML document, and this fact makes the event model of web browsers significantly more complex than Node’s event model. We begin this section with some important definitions that help to explain that event model:


event type

This string specifies what kind of event occurred. The type “mousemove,” for example, means that the user moved the mouse. The type “keydown” means that the user pressed a key on the keyboard down. And the type “load” means that a document (or some other resource) has finished loading from the network. Because the type of an event is just a string, it’s sometimes called an event name, and indeed, we use this name to identify the kind of event we’re talking about.

event target

This is the object on which the event occurred or with which the event is associated. When we speak of an event, we must specify both the type and the target. A load event on a Window, for example, or a click event on a <but t on> Element. Window, Document, and Element objects are the most common event targets in client-side JavaScript applications, but some events are triggered on other kinds of objects. For example, a Worker object (a kind of thread, covered §15.13) is a target for “message” events that occur when the worker thread sends a message to the main thread.

event handler, or event listener

This function handles or responds to an event.2 Applications register their event handler functions with the web browser, specifying an event type and an event target. When an event of the specified type occurs on the specified target, the browser invokes the handler function. When event handlers are invoked for an object, we say that the browser has “fired,” “triggered,” or “dispatched” the event. There are a number of ways to register event handlers, and the details of handler registration and invocation are explained in §15.2.2 and §15.2.3.

event object

This object is associated with a particular event and contains details

about that event. Event objects are passed as an argument to the event handler function. All event objects have a t ype property that specifies the event type and a t ar get  property that specifies the event target. Each event type defines a set of properties for its associated event object. The object associated with a mouse event includes the coordinates of the mouse pointer, for example, and the object associated with a keyboard event contains details about the key that was pressed and the modifier keys that were held down. Many event types define only a few standard properties—such as t ype and
t ar get —and do not carry much other useful information. For those events, it is the simple occurrence of the event, not the event details, that matter.

event propagation

This is the process by which the browser decides which objects to trigger event handlers on. For events that are specific to a single object —such as the “load” event on the Window object or a “message” event on a Worker object—no propagation is required. But when certain kinds of events occur on elements within the HTML document, however, they propagate or “bubble” up the document tree. If the user moves the mouse over a hyperlink, the mousemove event is first fired on the <a> element that defines that link. Then it is fired on the containing elements: perhaps a <p> element, a <s ect i on> element, and the Document object itself. It is sometimes more convenient to register a single event handler on a Document or other container element than to register handlers on each individual element you’re interested in. An event handler can stop the propagation of an event so that it will not continue to bubble and will not trigger handlers on containing elements. Handlers do this by invoking a method of the event object. In another form of event propagation, known as event capturing, handlers specially registered on container elements have the opportunity to intercept (or “capture”) events before they are delivered to their actual target. Event bubbling and capturing are covered in detail in §15.2.4.

Some events have default actions associated with them. When a click event occurs on a hyperlink, for example, the default action is for the browser to follow the link and load a new page. Event handlers can prevent this default action by invoking a method of the event object. This is sometimes called “canceling” the event and is covered in §15.2.5.


15.2.1 Event Categories

Client-side JavaScript supports such a large number of event types that there is no way this chapter can cover them all. It can be useful, though, to group events into some general categories, to illustrate the scope and wide variety of supported events:


Device-dependent input events

These events are directly tied to a specific input device, such as the mouse or keyboard. They include event types such as “mousedown,” “mousemove,” “mouseup,” “touchstart,” “touchmove,” “touchend,” “keydown,” and “keyup.”

Device-independent input events

These input events are not directly tied to a specific input device. The “click” event, for example, indicates that a link or button (or other document element) has been activated. This is often done via a mouse click, but it could also be done by keyboard or (on touch-sensitive devices) with a tap. The “input” event is a device-independent alternative to the “keydown” event and supports keyboard input as well as alternatives such as cut-and-paste and input methods used for ideographic scripts. The “pointerdown,” “pointermove,” and “pointerup” event types are device-independent alternatives to mouse and touch events. They work for mouse-type pointers, for touch screens, and for pen- or stylus-style input as well.

User interface events

UI events are higher-level events, often on HTML form elements that define a user interface for a web application. They include the “focus” event (when a text input field gains keyboard focus), the “change” event (when the user changes the value displayed by a form element), and the “submit” event (when the user clicks a Submit button in a form).

State-change events

Some events are not triggered directly by user activity, but by network or browser activity, and indicate some kind of life-cycle or state-related change. The “load” and “DOMContentLoaded” events—fired on the Window and Document objects, respectively, at the end of document loading—are probably the most commonly used of these events (see “Client-side JavaScript timeline”). Browsers fire “online” and “offline” events on the Window object when network connectivity changes. The browser’s history management mechanism (§15.10.4) fires the “popstate” event in response to the browser’s Back button.

API-specific events

A number of web APIs defined by HTML and related specifications include their own event types. The HTML <vi deo> and <audi o> elements define a long list of associated event types such as “waiting,” “playing,” “seeking,” “volumechange,” and so on, and you can use them to customize media playback. Generally speaking, web platform APIs that are asynchronous and were developed before Promises were added to JavaScript are event-based and define API-specific events. The IndexedDB API, for example (§15.12.3), fires “success” and “error” events when database requests succeed or fail. And although the new f et ch( )  API (§15.11.1) for making HTTP requests is Promise-based, the XMLHttpRequest API that it replaces defines a number of API-specific event types.


15.2.2 Registering Event Handlers

There are two basic ways to register event handlers. The first, from the

early days of the web, is to set a property on the object or document element that is the event target. The second (newer and more general) technique is to pass the handler to the addEvent Li s t ener ( )  method of the object or element.

SETTING EVENT HANDLER PROPERTIES

The simplest way to register an event handler is by setting a property of the event target to the desired event handler function. By convention, event handler properties have names that consist of the word “on” followed by the event name: oncl i ck, onchange, onl oad, onmous eover , and so on. Note that these property names are case
sensitive and are written in all lowercase,3 even when the event type (such as “mousedown”) consists of multiple words. The following code includes two event handler registrations of this kind:

/ /   Set   t he   onl oad   pr oper t y   of    t he   Wi ndow  obj ec t   t o   a   f unc t i on. / /   The   f unc t i on   i s   t he   event   handl er :	i t   i s   i nvoked   when   t he doc ument   l oads .
wi ndow. onl oad   =   f unc t i on( )    {
/ /   L ook   up   a   <f or m>   el ement
l et   f or m =   doc ument . quer ySel ec t or ( " f or m#s hi ppi ng" ) ;
/ /   Regi s t er   an   event   handl er   f unc t i on   on   t he   f or m t hat   wi l l be   i nvoked
/ /   bef or e   t he   f or m i s   s ubmi t t ed.	As s ume   i s For mVal i d( )    i s def i ned   el s ewher e.
f or m. ons ubmi t   =   f unc t i on( event )    {    / /   When   t he   us er   s ubmi t s t he   f or m

i f i nput s   ar e

( ! i s For mVal i d( t hi s ) )    {	/ /   c hec k   whet her   f or m val i d

event . pr event Def aul t ( ) ;	/ /   and   i f    not ,	pr event f or m s ubmi s s i on.
} } ;
} ;


The shortcoming of event handler properties is that they are designed

around the assumption that event targets will have at most one handler for each type of event. It is often better to register event handlers using addEvent Li s t ener ( )  because that technique does not overwrite any previously registered handlers.

SETTING EVENT HANDLER ATTRIBUTES

The event handler properties of document elements can also be defined directly in the HTML file as attributes on the corresponding HTML tag. (Handlers that would be registered on the Window element with JavaScript can be defined with attributes on the <body> tag in HTML.) This technique is generally frowned upon in modern web development, but it is possible, and it’s documented here because you may still see it in existing code.

When defining an event handler as an HTML attribute, the attribute value should be a string of JavaScript code. That code should be the body of the event handler function, not a complete function declaration. That is, your HTML event handler code should not be surrounded by curly braces and prefixed with the f unct i on keyword. For example:

<but t on   onc l i c k=" c ons ol e. l og( ' Thank   you' ) ; " >Pl eas e Cl i c k</but t on>


If an HTML event handler attribute contains multiple JavaScript statements, you must remember to separate those statements with semicolons or break the attribute value across multiple lines.


When you specify a string of JavaScript code as the value of an HTML event handler attribute, the browser converts your string into a function that works something like this one:

f unc t i on( event )    {
wi t h( doc ument )    {
wi t h( t hi s . f or m ||   { } )    { wi t h( t hi s )    {
/ *   your   c ode   her e   */ }
} }
}


The event  argument means that your handler code can refer to the current event object as event . The wi t h statements mean that the code of your handler can refer to the properties of the target object, the containing <f or m> (if any), and the containing Document object directly, as if they were variables in scope. The wi t h statement is forbidden in strict mode (§5.6.3), but JavaScript code in HTML attributes is never strict. Event handlers defined in this way are executed in an environment in which unexpected variables are defined. This can be a source of confusing bugs and is a good reason to avoid writing event handlers in HTML.

ADDEVENTLISTENER()

Any object that can be an event target—this includes the Window and Document objects and all document Elements—defines a method named addEvent Li s t ener ( )  that you can use to register an event handler for that target. addEvent Li s t ener ( )  takes three arguments. The first is the event type for which the handler is being registered. The event type (or name) is a string that does not include the “on” prefix used when setting event handler properties. The second argument to
addEvent Li s t ener ( )  is the function that should be invoked when the specified type of event occurs. The third argument is optional and is explained below.

The following code registers two handlers for the “click” event on a <but t on> element. Note the differences between the two techniques used:

<but t on   i d=" mybut t on" >Cl i c k   me</but t on> <s c r i pt >
l et   b   =   doc ument . quer ySel ec t or ( " #mybut t on" ) ;
b. onc l i c k   =   f unc t i on( )    {    c ons ol e. l og( " Thanks   f or   c l i c ki ng   me! " ) ; } ;
b. addEvent L i s t ener ( " c l i c k" ,	( )    =>   {    c ons ol e. l og( " Thanks agai n! " ) ;	} ) ;
</s c r i pt >


Calling addEvent Li s t ener ( )  with “click” as its first argument does not affect the value of the oncl i ck property. In this code, a button click will log two messages to the developer console. And if we called addEvent Li s t ener ( )  first and then set oncl i ck, we would still log two messages, just in the opposite order. More importantly, you can call addEvent Li s t ener ( )  multiple times to register more than one handler function for the same event type on the same object. When an event occurs on an object, all of the handlers registered for that type of event are invoked in the order in which they were registered. Invoking addEvent Li s t ener ( )  more than once on the same object with the same arguments has no effect—the handler function remains registered only once, and the repeated invocation does not alter the order in which handlers are invoked.

addEvent Li s t ener ( )  is paired with a
r emoveEvent Li s t ener ( )  method that expects the same two arguments (plus an optional third) but removes an event handler function from an object rather than adding it. It is often useful to temporarily register an event handler and then remove it soon afterward. For example,

when you get a “mousedown” event, you might register temporary event handlers for “mousemove” and “mouseup” events so that you can see if the user drags the mouse. You’d then deregister these handlers when the “mouseup” event arrives. In such a situation, your event handler removal code might look like this:

doc ument . r emoveEvent L i s t ener ( " mous emove" ,	handl eMous eMove) ; doc ument . r emoveEvent L i s t ener ( " mous eup" ,	handl eMous eUp) ;


The optional third argument to addEvent Li s t ener ( )  is a boolean value or object. If you pass t r ue, then your handler function is registered as a capturing event handler and is invoked at a different phase of event dispatch. We’ll cover event capturing in §15.2.4. If you pass a third argument of t r ue when you register an event listener, then you must also pass t r ue as the third argument to r emoveEvent Li s t ener ( )  if you want to remove the handler.

Registering a capturing event handler is only one of the three options that addEvent Li s t ener ( )  supports, and instead of passing a single boolean value, you can also pass an object that explicitly specifies the options you want:

doc ument . addEvent L i s t ener ( " c l i c k" ,	handl eCl i c k,	{ c apt ur e:	t r ue,
onc e:	t r ue, pas s i ve:	t r ue
} ) ;


If the Options object has a capt ur e property set to t r ue, then the event handler will be registered as a capturing handler. If that property is f al s e or is omitted, then the handler will be non-capturing.

If the Options object has a once property set to t r ue, then the event listener will be automatically removed after it is triggered once. If this property is f al s e or is omitted, then the handler is never automatically removed.

If the Options object has a pas s i ve property set to t r ue, it indicates that the event handler will never call pr event Def aul t ( )  to cancel the default action (see §15.2.5). This is particularly important for touch events on mobile devices—if event handlers for “touchmove” events can prevent the browser’s default scrolling action, then the browser cannot implement smooth scrolling. This pas s i ve property provides a way to register a potentially disruptive event handler of this sort but lets the web browser know that it can safely begin its default behavior—such as scrolling— while the event handler is running. Smooth scrolling is so important for a good user experience that Firefox and Chrome make “touchmove” and “mousewheel” events passive by default. So if you actually want to register a handler that calls pr event Def aul t ( )  for one of these events, you should explicitly set the pas s i ve property to f al s e.


You can also pass an Options object to r emoveEvent Li s t ener ( ) , but the capt ur e property is the only one that is relevant. There is no need to specify once or pas s i ve when removing a listener, and these properties are ignored.


15.2.3 Event Handler Invocation

Once you’ve registered an event handler, the web browser will invoke it automatically when an event of the specified type occurs on the specified object. This section describes event handler invocation in detail, explaining event handler arguments, the invocation context (the t hi s

value), and the meaning of the return value of an event handler.


EVENT HANDLER ARGUMENT

Event handlers are invoked with an Event object as their single argument. The properties of the Event object provide details about the event:


t ype

The type of the event that occurred.

t ar get

The object on which the event occurred.

c ur r ent Tar get

For events that propagate, this property is the object on which the current event handler was registered.

t i meSt amp

A timestamp (in milliseconds) that represents when the event occurred but that does not represent an absolute time. You can determine the elapsed time between two events by subtracting the timestamp of the first event from the timestamp of the second.

i s Tr us t ed

This property will be t r ue if the event was dispatched by the web browser itself and f al s e if the event was dispatched by JavaScript code.


Specific kinds of events have additional properties. Mouse and pointer events, for example, have cl i ent X and cl i ent Y properties that specify the window coordinates at which the event occurred.

EVENT HANDLER CONTEXT

When you register an event handler by setting a property, it looks as if you are defining a new method on the target object:

t ar get . onc l i c k   =   f unc t i on( )    {    / *   handl er   c ode   */   } ;


It isn’t surprising, therefore, that event handlers are invoked as methods of the object on which they are defined. That is, within the body of an event handler, the t hi s  keyword refers to the object on which the event handler was registered.

Handlers are invoked with the target as their t hi s  value, even when registered using addEvent Li s t ener ( ) . This does not work for handlers defined as arrow functions, however: arrow functions always have the same t hi s  value as the scope in which they are defined.

HANDLER RETURN VALUE

In modern JavaScript, event handlers should not return anything. You may see event handlers that return values in older code, and the return value is typically a signal to the browser that it should not perform the default action associated with the event. If the oncl i ck handler of a Submit button in a form returns f al s e, for example, then the web browser will not submit the form (usually because the event handler determined that the user’s input fails client-side validation).

The standard and preferred way to prevent the browser from performing a default action is to call the pr event Def aul t ( )  method (§15.2.5) on the Event object.

INVOCATION ORDER

An event target may have more than one event handler registered for a

particular type of event. When an event of that type occurs, the browser invokes all of the handlers in the order in which they were registered. Interestingly, this is true even if you mix event handlers registered with addEvent Li s t ener ( )  with an event handler registered on an object property like oncl i ck.


15.2.4 Event Propagation

When the target of an event is the Window object or some other standalone object, the browser responds to an event simply by invoking the appropriate handlers on that one object. When the event target is a Document or document Element, however, the situation is more complicated.


After the event handlers registered on the target element are invoked, most events “bubble” up the DOM tree. The event handlers of the target’s parent are invoked. Then the handlers registered on the target’s grandparent are invoked. This continues up to the Document object, and then beyond to the Window object. Event bubbling provides an alternative to registering handlers on lots of individual document elements: instead, you can register a single handler on a common ancestor element and handle events there. You might register a “change” handler on a <f or m> element, for example, instead of registering a “change” handler for every element in the form.

Most events that occur on document elements bubble. Notable exceptions are the “focus,” “blur,” and “scroll” events. The “load” event on document elements bubbles, but it stops bubbling at the Document object and does not propagate on to the Window object. (The “load” event handlers of the Window object are triggered only when the entire document has loaded.)

Event bubbling is the third “phase” of event propagation. The invocation of the event handlers of the target object itself is the second phase. The first phase, which occurs even before the target handlers are invoked, is called the “capturing” phase. Recall that addEvent Li s t ener ( )  takes an optional third argument. If that argument is t r ue, or
{ capt ur e: t r ue} , then the event handler is registered as a capturing event handler for invocation during this first phase of event propagation. The capturing phase of event propagation is like the bubbling phase in reverse. The capturing handlers of the Window object are invoked first, then the capturing handlers of the Document object, then of the body object, and so on down the DOM tree until the capturing event handlers of the parent of the event target are invoked. Capturing event handlers registered on the event target itself are not invoked.

Event capturing provides an opportunity to peek at events before they are delivered to their target. A capturing event handler can be used for debugging, or it can be used along with the event cancellation technique described in the next section to filter events so that the target event handlers are never actually invoked. One common use for event capturing is handling mouse drags, where mouse motion events need to be handled by the object being dragged, not the document elements over which it is dragged.


15.2.5 Event Cancellation

Browsers respond to many user events, even if your code does not: when the user clicks the mouse on a hyperlink, the browser follows the link. If an HTML text input element has the keyboard focus and the user types a key, the browser will enter the user’s input. If the user moves their finger across a touch-screen device, the browser scrolls. If you register an event

handler for events like these, you can prevent the browser from performing its default action by invoking the pr event Def aul t ( ) method of the event object. (Unless you registered the handler with the pas s i ve option, which makes pr event Def aul t ( )  ineffective.)


Canceling the default action associated with an event is only one kind of event cancellation. We can also cancel the propagation of events by calling the s t opPr opagat i on( )  method of the event object. If there are other handlers defined on the same object, the rest of those handlers will still be invoked, but no event handlers on any other object will be invoked after
s t opPr opagat i on( )  is called. s t opPr opagat i on( )  works during the capturing phase, at the event target itself, and during the bubbling phase. s t opI mmedi at ePr opagat i on( )  works like s t opPr opagat i on( ) , but it also prevents the invocation of any subsequent event handlers registered on the same object.


15.2.6 Dispatching Custom Events

Client-side JavaScript’s event API is a relatively powerful one, and you can use it to define and dispatch your own events. Suppose, for example, that your program periodically needs to perform a long calculation or make a network request and that, while this operation is pending, other operations are not possible. You want to let the user know about this by displaying “spinners” to indicate that the application is busy. But the module that is busy should not need to know where the spinners should be displayed. Instead, that module might just dispatch an event to announce that it is busy and then dispatch another event when it is no longer busy. Then, the UI module can register event handlers for those events and take whatever UI actions are appropriate to notify the user.

If a JavaScript object has an addEvent Li s t ener ( )  method, then it is an “event target,” and this means it also has a di s pat chEvent ( ) method. You can create your own event object with the
Cus t omEvent ( )  constructor and pass it to di s pat chEvent ( ) . The first argument to Cus t omEvent ( )  is a string that specifies the type of your event, and the second argument is an object that specifies the properties of the event object. Set the det ai l  property of this object to a string, object, or other value that represents the content of your event. If you plan to dispatch your event on a document element and want it to bubble up the document tree, add bubbl es : t r ue to the second argument:

/ /   Di s pat c h   a   c us t om event   s o   t he   UI	knows   we   ar e   bus y
doc ument . di s pat c hEvent ( new  Cus t omEvent ( " bus y" ,	{    det ai l :	t r ue } ) ) ;

/ /   Per f or m a   net wor k   oper at i on f et c h( ur l )
. t hen( handl eNet wor kRes pons e) . c at c h( handl eNet wor kEr r or )
. f i nal l y( ( )    =>   {

/ / di s pat c h
/ / bus y.

Af t er   t he   net wor k   r eques t   has   s uc c eeded   or   f ai l ed,

anot her   event   t o   l et   t he   UI	know  t hat   we   ar e   no   l onger

doc ument . di s pat c hEvent ( new  Cus t omEvent ( " bus y" ,	{    det ai l : f al s e   } ) ) ;
} ) ;


/ /   El s ewher e, " bus y"   event s / /   and   us e   i t

i n   your   pr ogr am you

t o   s how  or   hi de   t he

c an   r egi s t er   a

s pi nner   t o   l et

handl er   f or

t he   us er   know.

doc ument . addEvent L i s t ener ( " bus y" ,	( e)    =>   { i f    ( e. det ai l )    {
s howSpi nner ( ) ; }    el s e   {
hi deSpi nner ( ) ; }

} ) ;



15.3 Scripting Documents

Client-side JavaScript exists to turn static HTML documents into interactive web applications. So scripting the content of web pages is really the central purpose of JavaScript.


Every Window object has a document  property that refers to a Document object. The Document object represents the content of the window, and it is the subject of this section. The Document object does not stand alone, however. It is the central object in the DOM for representing and manipulating document content.

The DOM was introduced in §15.1.2. This section explains the API in detail. It covers:

How to query or select individual elements from a document.

How to traverse a document, and how to find the ancestors, siblings, and descendants of any document element.

How to query and set the attributes of document elements.

How to query, set, and modify the content of a document.

How to modify the structure of a document by creating, inserting, and deleting nodes.


15.3.1 Selecting Document Elements

Client-side JavaScript programs often need to manipulate one or more elements within the document. The global document  property refers to the Document object, and the Document object has head and body

properties that refer to the Element objects for the <head> and <body> tags, respectively. But a program that wants to manipulate an element embedded more deeply in the document must somehow obtain or select the Element objects that refer to those document elements.

SELECTING ELEMENTS WITH CSS SELECTORS

CSS stylesheets have a very powerful syntax, known as selectors, for describing elements or sets of elements within a document. The DOM methods quer ySel ect or ( )  and quer ySel ect or Al l ( )  allow us to find the element or elements within a document that match a specified CSS selector. Before we cover the methods, we’ll start with a quick tutorial on CSS selector syntax.

CSS selectors can describe elements by tag name, the value of their i d attribute, or the words in their cl as s  attribute:


di v #nav
. war ni ng
c l as s   at t r i but e

/ /   Any   <di v>   el ement
/ /   The   el ement   wi t h   i d=" nav"
/ /   Any   el ement   wi t h   " war ni ng"   i n   i t s



The # character is used to match based on the i d attribute, and the . character is used to match based on the cl as s  attribute. Elements can also be selected based on more general attribute values:

p[ l ang=" f r " ]	/ /   A  par agr aph   wr i t t en   i n   Fr enc h:	<p l ang=" f r " >
*[ name=" x" ]	/ /   Any   el ement   wi t h   a   name=" x"   at t r i but e


Note that these examples combine a tag name selector (or the * tag name wildcard) with an attribute selector. More complex combinations are also possible:

s pan. f at al . er r or	/ /   Any   <s pan>   wi t h   " f at al "   and   " er r or " i n   i t s   c l as s
s pan[ l ang=" f r " ] . war ni ng   / /   Any   <s pan>   i n   Fr enc h   wi t h   c l as s " war ni ng"


Selectors can also specify document structure:



#l og   s pan	/ / wi t h   i d=" l og"
#l og>s pan	/ / i d=" l og"
body>h1: f i r s t - c hi l d	/ / i mg   +   p. c apt i on	/ / i mmedi at el y   af t er   an   <i mg> h2   ~   p	/ / s i bl i ng   of    i t

Any   <s pan>   des c endant   of    t he   el ement

Any   <s pan>   c hi l d   of    t he   el ement   wi t h

The   f i r s t   <h1>   c hi l d   of    t he   <body> A  <p>   wi t h   c l as s   " c apt i on"

Any   <p>   t hat   f ol l ows   an   <h2>   and   i s   a



If two selectors are separated by a comma, it means that we’ve selected elements that match either one of the selectors:

but t on,	i nput [ t ype=" but t on" ]    / /   Al l	<but t on>   and   <i nput t ype=" but t on" >   el ement s


As you can see, CSS selectors allow us to refer to elements within a document by type, ID, class, attributes, and position within the document. The quer ySel ect or ( )  method takes a CSS selector string as its argument and returns the first matching element in the document that it finds, or returns nul l  if none match:

/ /   Fi nd   t he   doc ument   el ement   f or   t he   HTML   t ag   wi t h   at t r i but e i d=" s pi nner "
l et   s pi nner   =   doc ument . quer ySel ec t or ( " #s pi nner " ) ;


quer ySel ect or Al l ( )  is similar, but it returns all matching elements in the document rather than just returning the first:

/ /   Fi nd   al l	El ement   obj ec t s   f or   <h1>,	<h2>,	and   <h3>   t ags l et   t i t l es   =   doc ument . quer ySel ec t or Al l ( " h1,	h2,	h3" ) ;

The return value of quer ySel ect or Al l ( )  is not an array of Element objects. Instead, it is an array-like object known as a NodeList. NodeList objects have a l engt h property and can be indexed like arrays, so you can loop over them with a traditional f or  loop. NodeLists are also iterable, so you can use them with f or / of  loops as well. If you want to convert a NodeList into a true array, simply pass it to Ar r ay. f r om( ) .


The NodeList returned by quer ySel ect or Al l ( )  will have a l engt h property set to 0 if there are not any elements in the document that match the specified selector.

quer ySel ect or ( )  and quer ySel ect or Al l ( )  are implemented by the Element class as well as by the Document class. When invoked on an element, these methods will only return elements that are descendants of that element.

Note that CSS defines : : f i r s t - l i ne and : : f i r s t - l et t er pseudoelements. In CSS, these match portions of text nodes rather than actual elements. They will not match if used with
quer ySel ect or Al l ( )  or quer ySel ect or ( ) . Also, many browsers will refuse to return matches for the : l i nk and : vi s i t ed pseudoclasses, as this could expose information about the user’s browsing history.

Another CSS-based element selection method is cl os es t ( ) . This method is defined by the Element class and takes a selector as its only argument. If the selector matches the element it is invoked on, it returns that element. Otherwise, it returns the closest ancestor element that the selector matches, or returns nul l  if none matched. In a sense,
cl os es t ( )  is the opposite of quer ySel ect or ( ) : cl os es t ( )

starts at an element and looks for a match above it in the tree, while
quer ySel ect or ( )  starts with an element and looks for a match below it in the tree. cl os es t ( )  can be useful when you have registered an event handler at a high level in the document tree. If you are handling a “click” event, for example, you might want to know whether it is a click a hyperlink. The event object will tell you what the target was, but that target might be the text inside a link rather than the hyperlink’s <a> tag itself. Your event handler could look for the nearest containing hyperlink like this:

/ /   Fi nd   t he   c l os es t   enc l os i ng   <a>   t ag   t hat   has   an   hr ef at t r i but e.
l et   hyper l i nk   =   event . t ar get . c l os es t ( " a[ hr ef ] " ) ;


Here is another way you might use cl os es t ( ) :


/ /   Ret ur n   t r ue   i f    t he   el ement   e   i s   i ns i de   of    an   HTML   l i s t el ement
f unc t i on   i ns i deL i s t ( e)    {
r et ur n   e. c l os es t ( " ul , ol , dl " )    ! ==   nul l ; }


The related method mat ches ( )  does not return ancestors or descendants: it simply tests whether an element is matched by a CSS selector and returns t r ue if so and f al s e otherwise:

/ /   Ret ur n   t r ue   i f    e   i s   an   HTML   headi ng   el ement f unc t i on   i s Headi ng( e)    {
r et ur n   e. mat c hes ( " h1, h2, h3, h4, h5, h6" ) ; }

OTHER ELEMENT SELECTION METHODS

In addition to quer ySel ect or ( )  and quer ySel ect or Al l ( ) , the DOM also defines a number of older element selection methods that are

more or less obsolete now. You may still see some of these methods (especially get El ement ByI d( ) ) in use, however:

/ /   L ook   up   an   el ement   by   i d.	The   ar gument   i s   j us t   t he   i d, wi t hout
/ /   t he   CSS   s el ec t or   pr ef i x   #.	Si mi l ar   t o doc ument . quer ySel ec t or ( " #s ec t 1" )
l et   s ec t 1   =   doc ument . get El ement ByI d( " s ec t 1" ) ;

/ /   L ook   up   al l	el ement s   ( s uc h   as   f or m c hec kboxes )    t hat   have   a name=" c ol or "
/ /   at t r i but e.	Si mi l ar   t o   doc ument . quer ySel ec t or Al l ( ' * [ name=" c ol or " ] ' ) ;
l et   c ol or s   =   doc ument . get El ement s ByName( " c ol or " ) ;


/ /   L ook   up / /   Si mi l ar

al l    <h1>   el ement s   i n   t he   doc ument . t o   doc ument . quer ySel ec t or Al l ( " h1" )

l et   headi ngs   =   doc ument . get El ement s ByTagName( " h1" ) ;


/ /   get El ement s ByTagName( )    i s   al s o   def i ned / /   Get   al l    <h2>   el ement s   wi t hi n   t he   s ec t 1

on   el ement s . el ement .

l et   s ubheads   =   s ec t 1. get El ement s ByTagName( " h2" ) ;


/ /   L ook   up / /   Si mi l ar

al l	el ement s   t hat   have   c l as s   " t ool t i p. " t o   doc ument . quer ySel ec t or Al l ( " . t ool t i p" )

l et   t ool t i ps   =   doc ument . get El ement s ByCl as s Name( " t ool t i p" ) ;


/ /   L ook   up / /   Si mi l ar

al l	des c endant s   of    s ec t 1   t hat   have   c l as s   " s i debar " t o   s ec t 1. quer ySel ec t or Al l ( " . s i debar " )

l et   s i debar s   =   s ec t 1. get El ement s ByCl as s Name( " s i debar " ) ;


Like quer ySel ect or Al l ( ) , the methods in this code return a NodeList (except for get El ement ByI d( ) , which returns a single Element object). Unlike quer ySel ect or Al l ( ) , however, the NodeLists returned by these older selection methods are “live,” which means that the length and content of the list can change if the document content or structure changes.

PRESELECTED ELEMENTS

For historical reasons, the Document class defines shortcut properties to

access certain kinds of nodes. The i mages , f or ms , and l i nks properties, for example, provide easy access to the <i mg>, <f or m>, and <a> elements (but only <a> tags that have an hr ef  attribute) of a document. These properties refer to HTMLCollection objects, which are much like NodeList objects, but they can additionally be indexed by element ID or name. With the document . f or ms  property, for example, you can access the <f or m i d=" addr es s " > tag as:

doc ument . f or ms . addr es s ;


An even more outdated API for selecting elements is the
document . al l  property, which is like an HTMLCollection for all elements in the document. document . al l  is deprecated, and you should no longer use it.


15.3.2 Document Structure and Traversal

Once you have selected an Element from a Document, you sometimes need to find structurally related portions (parent, siblings, children) of the document. When we are primarily interested in the Elements of a document instead of the text within them (and the whitespace between them, which is also text), there is a traversal API that allows us to treat a document as a tree of Element objects, ignoring Text nodes that are also part of the document. This traversal API does not involve any methods; it is simply a set of properties on Element objects that allow us to refer to the parent, children, and siblings of a given element:


par ent Node

This property of an element refers to the parent of the element, which will be another Element or a Document object.


c hi l dr en

This NodeList contains the Element children of an element, but excludes non-Element children like Text nodes (and Comment nodes).

c hi l dEl ement Count

The number of Element children. Returns the same value as chi l dr en. l engt h.

f i r s t El ement Chi l d, l as t El ement Chi l d

These properties refer to the first and last Element children of an Element. They are nul l  if the Element has no Element children.

next El ement Si bl i ng, pr evi ous El ement Si bl i ng

These properties refer to the sibling Elements immediately before or immediately after an Element, or nul l  if there is no such sibling.


Using these Element properties, the second child Element of the first child Element of the Document can be referred to with either of these expressions:

doc ument . c hi l dr en[ 0] . c hi l dr en[ 1]
doc ument . f i r s t El ement Chi l d. f i r s t El ement Chi l d. next El ement Si bl i ng


(In a standard HTML document, both of those expressions refer to the <body> tag of the document.)


Here are two functions that demonstrate how you can use these properties to recursively do a depth-first traversal of a document invoking a specified function for every element in the document:

/ /   Rec ur s i vel y   t r aver s e   t he   Doc ument   or   El ement   e,	i nvoki ng   t he f unc t i on
/ /   f    on   e   and   on   eac h   of    i t s   des c endant s

f unc t i on   t r aver s e( e,	f )    {
f ( e) ;	/ /   I nvoke   f ( )    on   e
f or ( l et   c hi l d   of    e. c hi l dr en)    {	/ /   I t er at e   over   t he c hi l dr en
t r aver s e( c hi l d,	f ) ;	/ /   And   r ec ur s e   on   eac h   one }
}

f unc t i on   t r aver s e2( e,	f )    {
f ( e) ;	/ /   I nvoke   f ( )    on   e
l et   c hi l d   =   e. f i r s t El ement Chi l d;	/ /   I t er at e   t he   c hi l dr en l i nked- l i s t   s t yl e
whi l e( c hi l d   ! ==   nul l )    {
t r aver s e2( c hi l d,	f ) ;	/ /   And   r ec ur s e c hi l d   =   c hi l d. next El ement Si bl i ng;
} }

DOCUMENTS AS TREES OF NODES

If you want to traverse a document or some portion of a document and do not want to ignore the Text nodes, you can use a different set of properties defined on all Node objects. This will allow you to see Elements, Text nodes, and even Comment nodes (which represent HTML comments in the document).


All Node objects define the following properties:


par ent Node

The node that is the parent of this one, or nul l  for nodes like the Document object that have no parent.

c hi l dNodes

A read-only NodeList that that contains all children (not just Element children) of the node.


f i r s t Chi l d, l as t Chi l d

The first and last child nodes of a node, or nul l  if the node has no children.

next Si bl i ng, pr evi ous Si bl i ng

The next and previous sibling nodes of a node. These properties connect nodes in a doubly linked list.

nodeType

A number that specifies what kind of node this is. Document nodes have value 9. Element nodes have value 1. Text nodes have value 3. Comment nodes have value 8.

nodeVal ue

The textual content of a Text or Comment node.

nodeName

The HTML tag name of an Element, converted to uppercase.


Using these Node properties, the second child node of the first child of the Document can be referred to with expressions like these:

doc ument . c hi l dNodes [ 0] . c hi l dNodes [ 1]
doc ument . f i r s t Chi l d. f i r s t Chi l d. next Si bl i ng


Suppose the document in question is the following:


<ht ml ><head><t i t l e>Tes t </t i t l e></head><body>Hel l o   Wor l d! </body> </ht ml >


Then the second child of the first child is the <body> element. It has a nodeType of 1 and a nodeName of “BODY”.

Note, however, that this API is extremely sensitive to variations in the document text. If the document is modified by inserting a single newline between the <ht ml > and the <head> tag, for example, the Text node that represents that newline becomes the first child of the first child, and the second child is the <head> element instead of the <body> element.


To demonstrate this Node-based traversal API, here is a function that returns all of the text within an element or document:

/ /   Ret ur n   t he   pl ai n- t ext   c ont ent   of    el ement   e,	r ec ur s i ng   i nt o c hi l d   el ement s .
/ /   Thi s   met hod   wor ks   l i ke   t he   t ext Cont ent   pr oper t y f unc t i on   t ext Cont ent ( e)    {
l et   s   =   " " ;	/ /   Ac c umul at e   t he   t ext her e
f or ( l et   c hi l d   =   e. f i r s t Chi l d;	c hi l d   ! ==   nul l ;	c hi l d   = c hi l d. next Si bl i ng)    {
l et   t ype   =   c hi l d. nodeType;
i f    ( t ype   ===   3)    {	/ /   I f    i t   i s   a   Text   node s   +=   c hi l d. nodeVal ue;	/ /   add   t he   t ext   c ont ent
t o   our   s t r i ng.
}    el s e   i f    ( t ype   ===   1)    {	/ /   And   i f    i t   i s   an

El ement



}

node
s   +=   t ext Cont ent ( c hi l d) ;	/ /   t hen   r ec ur s e.
}

r et ur n   s ; }


This function is a demonstration only—in practice, you would simply write e. t ext Cont ent  to obtain the textual content of the element e.


15.3.3 Attributes

HTML elements consist of a tag name and a set of name/value pairs known as attributes. The <a> element that defines a hyperlink, for

example, uses the value of its hr ef  attribute as the destination of the link.


The Element class defines general get At t r i but e( ) ,
s et At t r i but e( ) , has At t r i but e( ) , and r emoveAt t r i but e( ) methods for querying, setting, testing, and removing the attributes of an element. But the attribute values of HTML elements (for all standard attributes of standard HTML elements) are available as properties of the HTMLElement objects that represent those elements, and it is usually much easier to work with them as JavaScript properties than it is to call get At t r i but e( )  and related methods.

HTML ATTRIBUTES AS ELEMENT PROPERTIES

The Element objects that represent the elements of an HTML document usually define read/write properties that mirror the HTML attributes of the elements. Element defines properties for the universal HTML attributes such as i d, t i t l e, l ang, and di r  and event handler properties like oncl i ck. Element-specific subtypes define attributes specific to those elements. To query the URL of an image, for example, you can use the
s r c property of the HTMLElement that represents the <i mg> element:


l et   i mage   =   doc ument . quer ySel ec t or ( " #mai n_i mage" ) ;
l et   ur l	=   i mage. s r c ;	/ /   The   s r c   at t r i but e   i s   t he   URL   of t he   i mage
i mage. i d   ===   " mai n_i mage"	/ /   =>   t r ue;	we   l ooked   up   t he   i mage   by i d


Similarly, you might set the form-submission attributes of a <f or m> element with code like this:

l et   f    =   doc ument . quer ySel ec t or ( " f or m" ) ;	/ /   Fi r s t   <f or m>   i n t he   doc ument
f . ac t i on   =   " ht t ps : / / www. exampl e. c om/ s ubmi t " ;	/ /   Set   t he   URL   t o s ubmi t   i t   t o.

f . met hod   =   " POST" ;	/ /   Set   t he   HTTP r eques t   t ype.


For some elements, such as the <i nput > element, some HTML attribute names map to differently named properties. The HTML val ue attribute of an <i nput >, for example, is mirrored by the JavaScript
def aul t Val ue property. The JavaScript val ue property of the
<i nput > element contains the user’s current input, but changes to the val ue property do not affect the def aul t Val ue property nor the val ue attribute.


HTML attributes are not case sensitive, but JavaScript property names are. To convert an attribute name to the JavaScript property, write it in lowercase. If the attribute is more than one word long, however, put the first letter of each word after the first in uppercase: def aul t Checked and t abI ndex, for example. Event handler properties like oncl i ck are an exception, however, and are written in lowercase.

Some HTML attribute names are reserved words in JavaScript. For these, the general rule is to prefix the property name with “html”. The HTML
f or  attribute (of the <l abel > element), for example, becomes the JavaScript ht ml For  property. “class” is a reserved word in JavaScript, and the very important HTML cl as s  attribute is an exception to the rule: it becomes cl as s Name in JavaScript code.


The properties that represent HTML attributes usually have string values. But when the attribute is a boolean or numeric value (the
def aul t Checked and maxLengt h attributes of an <i nput > element, for example), the properties are booleans or numbers instead of strings. Event handler attributes always have functions (or nul l ) as their

values.


Note that this property-based API for getting and setting attribute values does not define any way to remove an attribute from an element. In particular, the del et e operator cannot be used for this purpose. If you need to delete an attribute, use the r emoveAt t r i but e( )  method.

THE CLASS ATTRIBUTE

The cl as s  attribute of an HTML element is a particularly important one. Its value is a space-separated list of CSS classes that apply to the element and affect how it is styled with CSS. Because cl as s  is a reserved word in JavaScript, the value of this attribute is available through the cl as s Name property on Element objects. The cl as s Name property can set and return the value of the cl as s  attribute as a string. But the cl as s  attribute is poorly named: its value is a list of CSS classes, not a single class, and it is common in client-side JavaScript programming to want to add and remove individual class names from this list rather than work with the list as a single string.

For this reason, Element objects define a cl as s Li s t  property that allows you to treat the cl as s  attribute as a list. The value of the
cl as s Li s t  property is an iterable Array-like object. Although the name of the property is cl as s Li s t , it behaves more like a set of classes, and defines add( ) , r emove( ) , cont ai ns ( ) , and t oggl e( )  methods:

/ /   When   we   want   t o   l et   t he   us er   know  t hat   we   ar e   bus y,	we di s pl ay
/ /   a   s pi nner .	To   do   t hi s   we   have   t o   r emove   t he   " hi dden"   c l as s and   add   t he
/ /   " ani mat ed"   c l as s   ( as s umi ng   t he   s t yl es heet s   ar e   c onf i gur ed c or r ec t l y) .
l et   s pi nner   =   doc ument . quer ySel ec t or ( " #s pi nner " ) ;

s pi nner . c l as s L i s t . r emove( " hi dden" ) ; s pi nner . c l as s L i s t . add( " ani mat ed" ) ;

DATASET ATTRIBUTES

It is sometimes useful to attach additional information to HTML elements, typically when JavaScript code will be selecting those elements and manipulating them in some way. In HTML, any attribute whose name is lowercase and begins with the prefix “data-” is considered valid, and you can use them for any purpose. These “dataset attributes” will not affect the presentation of the elements on which they appear, and they define a standard way to attach additional data without compromising document validity.


In the DOM, Element objects have a dat as et  property that refers to an object that has properties that correspond to the dat a-  attributes with their prefix removed. Thus, dat as et . x would hold the value of the dat a- x attribute. Hyphenated attributes map to camelCase property names: the attribute dat a- s ect i on- number  becomes the property dat as et . s ect i onNumber .


Suppose an HTML document contains this text:


<h2   i d=" t i t l e"   dat a- s ec t i on- number =" 16. 1" >At t r i but es </h2>


Then you could write JavaScript like this to access that section number:


l et   number   =
doc ument . quer ySel ec t or ( " #t i t l e" ) . dat as et . s ec t i onNumber ;


15.3.4 Element Content

Look again at the document tree pictured in Figure 15-1, and ask yourself

what the “content” of the <p> element is. There are two ways we might answer this question:

The content is the HTML string “This is a <i>simple</i> document”.

The content is the plain-text string “This is a simple document”.

Both of these are valid answers, and each answer is useful in its own way. The sections that follow explain how to work with the HTML representation and the plain-text representation of an element’s content.

ELEMENT CONTENT AS HTML

Reading the i nner HTML property of an Element returns the content of that element as a string of markup. Setting this property on an element invokes the web browser’s parser and replaces the element’s current content with a parsed representation of the new string. You can test this out by opening the developer console and typing:

doc ument . body. i nner HTML   =   " <h1>Oops </ h1>" ;


You will see that the entire web page disappears and is replaced with the single heading, “Oops”. Web browsers are very good at parsing HTML, and setting i nner HTML is usually fairly efficient. Note, however, that appending text to the i nner HTML property with the += operator is not efficient because it requires both a serialization step to convert element content to a string and then a parsing step to convert the new string back into element content.


WARNING

When using these HTML APIs, it is very important that you never insert user input into the document. If you do this, you allow malicious users to inject their own scripts

into your application. See “Cross-site scripting” for details.




The out er HTML property of an Element is like i nner HTML except that its value includes the element itself. When you query out er HTML, the value includes the opening and closing tags of the element. And when you set out er HTML on an element, the new content replaces the element itself.

A related Element method is i ns er t Adj acent HTML( ) , which allows you to insert a string of arbitrary HTML markup “adjacent” to the specified element. The markup is passed as the second argument to this method, and the precise meaning of “adjacent” depends on the value of the first argument. This first argument should be a string with one of the values “beforebegin,” “afterbegin,” “beforeend,” or “afterend.” These values correspond to insertion points that are illustrated in Figure 15-2.









Figure 15-2. Insertion points for insertAdjacentHTML()

ELEMENT CONTENT AS PLAIN TEXT

Sometimes you want to query the content of an element as plain text or to insert plain text into a document (without having to escape the angle brackets and ampersands used in HTML markup). The standard way to do this is with the t ext Cont ent  property:


l et   par a   =   doc ument . quer ySel ec t or ( " p" ) ;	/ /   Fi r s t   <p>   i n   t he

doc ument
l et   t ext   =   par a. t ext Cont ent ;	/ /   Get   t he   t ext   of    t he par agr aph
par a. t ext Cont ent   =   " Hel l o   Wor l d! " ;	/ /   Al t er   t he   t ext   of    t he par agr aph

The t ext Cont ent  property is defined by the Node class, so it works for Text nodes as well as Element nodes. For Element nodes, it finds and returns all text in all descendants of the element.

The Element class defines an i nner Text  property that is similar to
t ext Cont ent . i nner Text  has some unusual and complex behaviors, such as attempting to preserve table formatting. It is not well specified nor implemented compatibly between browsers, however, and should no longer be used.



TEXT IN <SCRIPT> ELEMENTS

Inline <s cr i pt > elements (i.e., those that do not have a s r c  attribute) have a t ext  property that you can use to retrieve their text. The content of a <s cr i pt > element is never displayed by the browser, and the HTML parser ignores angle brackets and ampersands within a script. This makes a <s cr i pt > element an ideal place to embed arbitrary textual data for use by your application. Simply set the t ype attribute of the element to some value (such as “text/x-custom-data”) that makes it clear that the script is not executable JavaScript code. If you do this, the JavaScript interpreter will ignore the script, but the element will exist in the document tree, and its t ext  property will return the data to you.




15.3.5 Creating, Inserting, and Deleting Nodes

We’ve seen how to query and alter document content using strings of HTML and of plain text. And we’ve also seen that we can traverse a Document to examine the individual Element and Text nodes that it is made of. It is also possible to alter a document at the level of individual nodes. The Document class defines methods for creating Element objects, and Element and Text objects have methods for inserting, deleting, and replacing nodes in the tree.

Create a new element with the cr eat eEl ement ( )  method of the Document class and append strings of text or other elements to it with its append( )  and pr epend( )  methods:

l et   par agr aph   =   doc ument . c r eat eEl ement ( " p" ) ;	/ /   Cr eat e   an   empt y <p>   el ement
l et   emphas i s   =   doc ument . c r eat eEl ement ( " em" ) ;	/ /   Cr eat e   an   empt y <em>   el ement
emphas i s . append( " Wor l d" ) ;	/ /   Add   t ext   t o   t he <em>   el ement
par agr aph. append( " Hel l o   " ,	emphas i s ,	" ! " ) ;	/ /   Add   t ext   and <em>   t o   <p>
par agr aph. pr epend( " ¡ " ) ;	/ /   Add   mor e   t ext   at s t ar t   of    <p>
par agr aph. i nner HTML	/ /   =>   " ¡ Hel l o <em>Wor l d</ em>! "


append( )  and pr epend( )  take any number of arguments, which can be Node objects or strings. String arguments are automatically converted to Text nodes. (You can create Text nodes explicitly with
document . cr eat eText Node( ) , but there is rarely any reason to do so.) append( )  adds the arguments to the element at the end of the child list. pr epend( )  adds the arguments at the start of the child list.

If you want to insert an Element or Text node into the middle of the containing element’s child list, then neither append( )  or pr epend( ) will work for you. In this case, you should obtain a reference to a sibling node and call bef or e( )  to insert the new content before that sibling or af t er ( )  to insert it after that sibling. For example:

/ /   Fi nd   t he   headi ng   el ement   wi t h   c l as s =" gr eet i ngs "
l et   gr eet i ngs   =   doc ument . quer ySel ec t or ( " h2. gr eet i ngs " ) ;

/ /   Now  i ns er t   t he   new  par agr aph   and   a   hor i z ont al	r ul e   af t er   t hat headi ng
gr eet i ngs . af t er ( par agr aph,	doc ument . c r eat eEl ement ( " hr " ) ) ;

Like append( )  and pr epend( ) , af t er ( )  and bef or e( )  take any number of string and element arguments and insert them all into the document after converting strings to Text nodes. append( )  and
pr epend( )  are only defined on Element objects, but af t er ( )  and bef or e( )  work on both Element and Text nodes: you can use them to insert content relative to a Text node.

Note that elements can only be inserted at one spot in the document. If an element is already in the document and you insert it somewhere else, it will be moved to the new location, not copied:

/ /   We   i ns er t ed   t he   par agr aph   af t er   t hi s   el ement ,	but   now  we / /   move   i t   s o   i t   appear s   bef or e   t he   el ement   i ns t ead
gr eet i ngs . bef or e( par agr aph) ;


If you do want to make a copy of an element, use the cl oneNode( ) method, passing t r ue to copy all of its content:


/ /   Make   a gr eet i ngs

c opy   of    t he   par agr aph   and   i ns er t   i t   af t er   t he el ement

gr eet i ngs . af t er ( par agr aph. c l oneNode( t r ue) ) ;


You can remove an Element or Text node from the document by calling its r emove( )  method, or you can replace it by calling r epl aceWi t h( ) instead. r emove( )  takes no arguments, and r epl aceWi t h( )  takes any number of strings and elements just like bef or e( )  and af t er ( ) do:

/ /   Remove   t he   gr eet i ngs   el ement   f r om t he   doc ument   and   r epl ac e   i t wi t h
/ /   t he   par agr aph   el ement   ( movi ng   t he   par agr aph   f r om i t s   c ur r ent l oc at i on
/ /   i f    i t   i s   al r eady   i ns er t ed   i nt o   t he   doc ument ) . gr eet i ngs . r epl ac eWi t h( par agr aph) ;

/ /   And   now  r emove   t he   par agr aph. par agr aph. r emove( ) ;


The DOM API also defines an older generation of methods for inserting and removing content. appendChi l d( ) , i ns er t Bef or e( ) ,
r epl aceChi l d( ) , and r emoveChi l d( )  are harder to use than the methods shown here and should never be needed.


15.3.6 Example: Generating a Table of Contents

Example 15-1 shows how to dynamically create a table of contents for a document. It demonstrates many of the document scripting techniques described in the previous sections. The example is well commented, and you should have no trouble following the code.

Example 15-1. Generating a table of contents with the DOM API
/ **
*   TOC. j s :	c r eat e   a   t abl e   of    c ont ent s   f or   a   doc ument . *
*   Thi s   s c r i pt   r uns   when   t he   DOMCont ent L oaded   event   i s   f i r ed   and *   aut omat i c al l y   gener at es   a   t abl e   of    c ont ent s   f or   t he   doc ument .
*   I t   does   not   def i ne   any   gl obal	s ymbol s   s o   i t   s houl d   not   c onf l i c t *   wi t h   ot her   s c r i pt s .
*
*   When   t hi s   s c r i pt   r uns ,	i t   f i r s t   l ooks   f or   a   doc ument   el ement wi t h
*   an   i d   of    " TOC" .	I f    t her e   i s   no   s uc h   el ement   i t   c r eat es   one   at t he
*   s t ar t   of    t he   doc ument .	Next ,	t he   f unc t i on   f i nds   al l	<h2> t hr ough
*   <h6>   t ags ,	t r eat s   t hem as   s ec t i on   t i t l es ,	and   c r eat es   a   t abl e of
*   c ont ent s   wi t hi n   t he   TOC   el ement .	The   f unc t i on   adds   s ec t i on number s
*   t o   eac h   s ec t i on   headi ng   and   wr aps   t he   headi ngs   i n   named   anc hor s s o
*   t hat   t he   TOC   c an   l i nk   t o   t hem.	The   gener at ed   anc hor s   have   names *   t hat   begi n   wi t h   " TOC" ,	s o   you   s houl d   avoi d   t hi s   pr ef i x   i n   your
own
*   HTML . *

*   The   ent r i es   i n   t he   gener at ed   TOC   c an   be   s t yl ed   wi t h   CSS.	Al l
*   ent r i es   have   a   c l as s   " TOCEnt r y" .	Ent r i es   al s o   have   a   c l as s   t hat *   c or r es ponds   t o   t he   l evel	of    t he   s ec t i on   headi ng.	<h1>   t ags
gener at e
*   ent r i es   of    c l as s   " TOCL evel 1" ,	<h2>   t ags   gener at e   ent r i es   of c l as s
*   " TOCL evel 2" ,	and   s o   on.	Sec t i on   number s   i ns er t ed   i nt o   headi ngs have
*   c l as s   " TOCSec t Num" . *
*   You   mi ght   us e   t hi s   s c r i pt   wi t h   a   s t yl es heet   l i ke   t hi s : *
*	#TOC   {    bor der :	s ol i d   bl ac k   1px;	mar gi n:	10px;	paddi ng:	10px; }
*	. TOCEnt r y   {    mar gi n:	5px   0px;	}
*	. TOCEnt r y   a   {    t ext - dec or at i on:	none;	}
*	. TOCL evel 1   {    f ont - s i z e:	16pt ;	f ont - wei ght :	bol d;	} *	. TOCL evel 2   {    f ont - s i z e:	14pt ;	mar gi n- l ef t :	. 25i n;    } *	. TOCL evel 3   {    f ont - s i z e:	12pt ;	mar gi n- l ef t :	. 5i n;	} *	. TOCSec t Num: af t er   {    c ont ent :    " :	" ;	}
*
*   To   hi de   t he   s ec t i on   number s ,	us e   t hi s : *
*	. TOCSec t Num {    di s pl ay:	none   } **/
doc ument . addEvent L i s t ener ( " DOMCont ent L oaded" ,	( )    =>   {

/ /   Fi nd   t he / /   I f    t her e
doc ument .

TOC   c ont ai ner   el ement .
i s n' t   one,	c r eat e   one   at   t he   s t ar t   of    t he

l et   t oc   =   doc ument . quer ySel ec t or ( " #TOC" ) ; i f    ( ! t oc )    {
t oc   =   doc ument . c r eat eEl ement ( " di v" ) ; t oc . i d   =   " TOC" ;
doc ument . body. pr epend( t oc ) ; }


/ /   Fi nd   al l	s ec t i on   headi ng t he
/ /   doc ument   t i t l e   us es   <h1> doc ument   ar e
/ /   mar ked   wi t h   <h2>   t hr ough

el ement s .	We' r e   as s umi ng   her e   t hat

and   t hat   s ec t i ons   wi t hi n   t he

<h6>.

l et   headi ngs   =   doc ument . quer ySel ec t or Al l ( " h2, h3, h4, h5, h6" ) ;

/ /   I ni t i al i z e   an   ar r ay   t hat   keeps   t r ac k   of    s ec t i on   number s . l et   s ec t i onNumber s   =   [ 0, 0, 0, 0, 0] ;

/ /   Now  l oop   t hr ough   t he   s ec t i on   header   el ement s   we   f ound.

f or ( l et   headi ng   of    headi ngs )    {
/ /   Ski p   t he   headi ng   i f    i t   i s   i ns i de   t he   TOC   c ont ai ner . i f    ( headi ng. par ent Node   ===   t oc )    {
c ont i nue; }


/ /   Fi gur e   out / /   Subt r ac t   1

what   l evel	headi ng   i t   i s .
bec aus e   <h2>   i s   a   l evel - 1   headi ng.

l et   l evel	=   par s eI nt ( headi ng. t agName. c har At ( 1) )    -    1;


/ /   I nc r ement / /   and   r es et

t he   s ec t i on   number   f or   t hi s   headi ng   l evel al l	l ower   headi ng   l evel	number s   t o   z er o.

s ec t i onNumber s [ l evel - 1] ++;
f or ( l et   i	=   l evel ;	i	<   s ec t i onNumber s . l engt h;	i ++)    { s ec t i onNumber s [ i ]    =   0;
}


/ /   Now  c ombi ne   s ec t i on   number s / /   t o   pr oduc e   a   s ec t i on   number

f or   al l	headi ng   l evel s l i ke   2. 3. 1.

l et   s ec t i onNumber   =   s ec t i onNumber s . s l i c e( 0, l evel ) . j oi n( " . " ) ;


/ /   Add   t he   s ec t i on   number / /   We   pl ac e   t he   number   i n

t o   t he   s ec t i on   header   t i t l e.
a   <s pan>   t o   make   i t   s t yl eabl e.

l et   s pan   =   doc ument . c r eat eEl ement ( " s pan" ) ; s pan. c l as s Name   =   " TOCSec t Num" ;
s pan. t ext Cont ent   =   s ec t i onNumber ; headi ng. pr epend( s pan) ;

/ /   Wr ap   t he   headi ng   i n   a   named   anc hor   s o   we   c an   l i nk   t o i t .
l et   anc hor   =   doc ument . c r eat eEl ement ( " a" ) ;
l et   f r agment Name   =   ` TOC${ s ec t i onNumber } ` ; anc hor . name   =   f r agment Name;
headi ng. bef or e( anc hor ) ;	/ /   I ns er t   anc hor   bef or e   headi ng anc hor . append( headi ng) ;	/ /   and   move   headi ng   i ns i de
anc hor

/ /   Now  c r eat e   a   l i nk   t o   t hi s   s ec t i on.
l et   l i nk   =   doc ument . c r eat eEl ement ( " a" ) ;
l i nk. hr ef    =   ` #${ f r agment Name} ` ;	/ /   L i nk   des t i nat i on

/ /   Copy   t he   headi ng   t ext   i nt o   t he   l i nk.	Thi s   i s   a   s af e   us e of
/ /   i nner HTML   bec aus e   we   ar e   not   i ns er t i ng   any   unt r us t ed

s t r i ngs .
l i nk. i nner HTML   =   headi ng. i nner HTML ;

/ /   Pl ac e   t he   l i nk   i n   a   di v   t hat   i s   s t yl eabl e   bas ed   on   t he l evel .
l et   ent r y   =   doc ument . c r eat eEl ement ( " di v" ) ;
ent r y. c l as s L i s t . add( " TOCEnt r y" ,	` TOCL evel ${ l evel } ` ) ; ent r y. append( l i nk) ;

/ /   And   add   t he   di v   t o   t he   TOC   c ont ai ner . t oc . append( ent r y) ;
} } ) ;


15.4 Scripting CSS

We’ve seen that JavaScript can control the logical structure and content of HTML documents. It can also control the visual appearance and layout of those documents by scripting CSS. The following subsections explain a few different techniques that JavaScript code can use to work with CSS.


This is a book about JavaScript, not about CSS, and this section assumes that you already have a working knowledge of how CSS is used to style HTML content. But it’s worth mentioning some of the CSS styles that are commonly scripted from JavaScript:

Setting the di s pl ay style to “none” hides an element. You can later show the element by setting di s pl ay to some other value.

You can dynamically position elements by setting the pos i t i on style to “absolute,” “relative,” or “fixed” and then setting the t op and l ef t  styles to the desired coordinates. This is important when using JavaScript to display dynamic content like modal dialogues and tooltips.

You can shift, scale, and rotate elements with the t r ans f or m style.

You can animate changes to other CSS styles with the
t r ans i t i on style. These animations are handled automatically by the web browser and do not require JavaScript, but you can use JavaScript to initiate the animations.


15.4.1 CSS Classes

The simplest way to use JavaScript to affect the styling of document content is to add and remove CSS class names from the cl as s  attribute of HTML tags. This is easy to do with the cl as s Li s t  property of Element objects, as explained in “The class attribute”.

Suppose, for example, that your document’s stylesheet includes a definition for a “hidden” class:

. hi dden   {
di s pl ay: none; }


With this style defined, you can hide (and then show) an element with code like this:


/ /   As s ume   t hat HTML   f i l e.
/ /   We   c an   make

t hi s   " t ool t i p"   el ement   has   c l as s =" hi dden"   i n   t he

i t   vi s i bl e   l i ke   t hi s :

doc ument . quer ySel ec t or ( " #t ool t i p" ) . c l as s L i s t . r emove( " hi dden" ) ;

/ /   And   we   c an   hi de   i t   agai n   l i ke   t hi s :
doc ument . quer ySel ec t or ( " #t ool t i p" ) . c l as s L i s t . add( " hi dden" ) ;


15.4.2 Inline Styles

To continue with the preceding tooltip example, suppose that the document is structured with only a single tooltip element, and we want to dynamically position it before displaying it. In general, we can’t create a

different stylesheet class for each possible position of the tooltip, so the cl as s Li s t  property won’t help us with positioning.


In this case, we need to script the s t yl e attribute of the tooltip element to set inline styles that are specific to that one element. The DOM defines a
s t yl e property on all Element objects that correspond to the s t yl e attribute. Unlike most such properties, however, the s t yl e property is not a string. Instead, it is a CSSStyleDeclaration object: a parsed representation of the CSS styles that appear in textual form in the s t yl e attribute. To display and set the position of our hypothetical tooltip with JavaScript, we might use code like this:

f unc t i on   di s pl ayAt ( t ool t i p,	x,	y)    { t ool t i p. s t yl e. di s pl ay   =   " bl oc k" ;
t ool t i p. s t yl e. pos i t i on   =   " abs ol ut e" ; t ool t i p. s t yl e. l ef t   =   ` ${ x} px` ;
t ool t i p. s t yl e. t op   =   ` ${ y} px` ; }



NAMING CONVENTIONS: CSS PROPERTIES IN J AVASCRIPT

Many CSS style properties, such as f ont - s i z e, contain hyphens in their names. In JavaScript, a hyphen is interpreted as a minus sign and is not allowed in property names or other identifiers. Therefore, the names of the properties of the CSSStyleDeclaration object are slightly different from the names of actual CSS properties. If a CSS property name contains one or more hyphens, the CSSStyleDeclaration property name is formed by removing the hyphens and capitalizing the letter immediately following each hyphen. The CSS property bor der - l ef t - wi dt h is accessed through the JavaScript bor der L ef t Wi dt h property, for example, and the CSS f ont - f ami l y property is written as f ont Fami l y in JavaScript.



When working with the style properties of the CSSStyleDeclaration object, remember that all values must be specified as strings. In a stylesheet or s t yl e attribute, you can write:


di s pl ay:	bl oc k;	f ont - f ami l y:	s ans - s er i f ;	bac kgr ound- c ol or : #f f f f f f ;

To accomplish the same thing for an element e with JavaScript, you have to quote all of the values:

e. s t yl e. di s pl ay   =   " bl oc k" ;
e. s t yl e. f ont Fami l y   =   " s ans - s er i f " ;
e. s t yl e. bac kgr oundCol or   =   " #f f f f f f " ;


Note that the semicolons go outside the strings. These are just normal JavaScript semicolons; the semicolons you use in CSS stylesheets are not required as part of the string values you set with JavaScript.


Furthermore, remember that many CSS properties require units such as “px” for pixels or “pt” for points. Thus, it is not correct to set the
mar gi nLef t  property like this:


e. s t yl e. mar gi nL ef t   =   300;	/ /   I nc or r ec t :	t hi s   i s   a   number ,	not a   s t r i ng
e. s t yl e. mar gi nL ef t   =   " 300" ;	/ /   I nc or r ec t :	t he   uni t s   ar e   mi s s i ng


Units are required when setting style properties in JavaScript, just as they are when setting style properties in stylesheets. The correct way to set the value of the mar gi nLef t  property of an element e to 300 pixels is:


e. s t yl e. mar gi nL ef t   =   " 300px" ;


If you want to set a CSS property to a computed value, be sure to append the units at the end of the computation:

e. s t yl e. l ef t   =   ` ${ x0   +   l ef t _bor der   +   l ef t _paddi ng} px` ;


Recall that some CSS properties, such as mar gi n, are shortcuts for other properties, such as mar gi n- t op, mar gi n- r i ght , mar gi n- bot t om, and mar gi n- l ef t . The CSSStyleDeclaration object has properties that

correspond to these shortcut properties. For example, you might set the mar gi n property like this:


e. s t yl e. mar gi n   =   ` ${ t op} px   ${ r i ght } px   ${ bot t om} px   ${ l ef t } px` ;


Sometimes, you may find it easier to set or query the inline style of an element as a single string value rather than as a CSSStyleDeclaration object. To do that, you can use the Element get At t r i but e( )  and
s et At t r i but e( )  methods, or you can use the cs s Text  property of the CSSStyleDeclaration object:

/ /   Copy   t he   i nl i ne   s t yl es   of    el ement   e   t o   el ement   f : f . s et At t r i but e( " s t yl e" ,	e. get At t r i but e( " s t yl e" ) ) ;

/ /   Or   do   i t   l i ke   t hi s :
f . s t yl e. c s s Text   =   e. s t yl e. c s s Text ;


When querying the s t yl e property of an element, keep in mind that it represents only the inline styles of an element and that most styles for most elements are specified in stylesheets rather than inline. Furthermore, the values you obtain when querying the s t yl e property will use whatever units and whatever shortcut property format is actually used on the HTML attribute, and your code may have to do some sophisticated parsing to interpret them. In general, if you want to query the styles of an element, you probably want the computed style, which is discussed next.


15.4.3 Computed Styles

The computed style for an element is the set of property values that the browser derives (or computes) from the element’s inline style plus all applicable style rules in all stylesheets: it is the set of properties actually used to display the element. Like inline styles, computed styles are represented with a CSSStyleDeclaration object. Unlike inline styles,

however, computed styles are read-only. You can’t set these styles, but the computed CSSStyleDeclaration object for an element lets you determine what style property values the browser used when rendering that element.


Obtain the computed style for an element with the
get Comput edSt yl e( )  method of the Window object. The first argument to this method is the element whose computed style is desired. The optional second argument is used to specify a CSS pseudoelement, such as “::before” or “::after”:

l et   t i t l e   =   doc ument . quer ySel ec t or ( " #s ec t i on1t i t l e" ) ; l et   s t yl es   =   wi ndow. get Comput edSt yl e( t i t l e) ;
l et   bef or eSt yl es   =   wi ndow. get Comput edSt yl e( t i t l e,	" : : bef or e" ) ;


The return value of get Comput edSt yl e( )  is a CSSStyleDeclaration object that represents all the styles that apply to the specified element (or pseudoelement). There are a number of important differences between a CSSStyleDeclaration object that represents inline styles and one that represents computed styles:

Computed style properties are read-only.

Computed style properties are absolute: relative units like percentages and points are converted to absolute values. Any property that specifies a size (such as a margin size or a font size) will have a value measured in pixels. This value will be a string with a “px” suffix, so you’ll still need to parse it, but you won’t have to worry about parsing or converting other units. Properties whose values are colors will be returned in “rgb()” or “rgba()” format.

Shortcut properties are not computed—only the fundamental properties that they are based on are. Don’t query the mar gi n property, for example, but use mar gi nLef t , mar gi nTop, and

so on. Similarly, don’t query bor der  or even bor der Wi dt h. Instead, use bor der Lef t Wi dt h, bor der TopWi dt h, and so on.

The cs s Text  property of the computed style is undefined.

A CSSStyleDeclaration object returned by get Comput edSt yl e( ) generally contains much more information about an element than the CSSStyleDeclaration obtained from the inline s t yl e property of that element. But computed styles can be tricky, and querying them does not always provide the information you might expect. Consider the f ont -
f ami l y attribute: it accepts a comma-separated list of desired font families for cross-platform portability. When you query the f ont Fami l y property of a computed style, you’re simply getting the value of the most specific f ont - f ami l y style that applies to the element. This may return a value such as “arial,helvetica,sans-serif,” which does not tell you which typeface is actually in use. Similarly, if an element is not absolutely positioned, attempting to query its position and size through the t op and
l ef t  properties of its computed style often returns the value aut o. This is a perfectly legal CSS value, but it is probably not what you were looking for.

Although CSS can be used to precisely specify the position and size of document elements, querying the computed style of an element is not the preferred way to determine the element’s size and position. See §15.5.2 for a simpler, portable alternative.


15.4.4 Scripting Stylesheets

In addition to scripting class attributes and inline styles, JavaScript can also manipulate stylesheets themselves. Stylesheets are associated with an HTML document with a <s t yl e> tag or with a <l i nk

r el =" s t yl es heet " > tag. Both of these are regular HTML tags, so you can give them both i d attributes and then look them up with document . quer ySel ect or ( ) .


The Element objects for both <s t yl e> and <l i nk> tags have a
di s abl ed property that you can use to disable the entire stylesheet. You might use it with code like this:

/ /   Thi s   f unc t i on   s wi t c hes   bet ween   t he   " l i ght "   and   " dar k"   t hemes f unc t i on   t oggl eTheme( )    {
l et   l i ght Theme   =   doc ument . quer ySel ec t or ( " #l i ght - t heme" ) ; l et   dar kTheme   =   doc ument . quer ySel ec t or ( " #dar k- t heme" ) ;
i f    ( dar kTheme. di s abl ed)    {	/ /   Cur r ent l y   l i ght , s wi t c h   t o   dar k
l i ght Theme. di s abl ed   =   t r ue; dar kTheme. di s abl ed   =   f al s e;
}    el s e   {	/ /   Cur r ent l y   dar k,	s wi t c h t o   l i ght
l i ght Theme. di s abl ed   =   f al s e; dar kTheme. di s abl ed   =   t r ue;
} }


Another simple way to script stylesheets is to insert new ones into the document using DOM manipulation techniques we’ve already seen. For example:

f unc t i on   s et Theme( name)    {
/ /   Cr eat e   a   new  <l i nk   r el =" s t yl es heet " >   el ement   t o   l oad   t he named   s t yl es heet
l et   l i nk   =   doc ument . c r eat eEl ement ( " l i nk" ) ;
l i nk. i d   =   " t heme" ;
l i nk. r el	=   " s t yl es heet " ;
l i nk. hr ef    =   ` t hemes / ${ name} . c s s ` ;

/ /   L ook   f or   an   exi s t i ng   l i nk   wi t h   i d   " t heme"
l et   c ur r ent Theme   =   doc ument . quer ySel ec t or ( " #t heme" ) ; i f    ( c ur r ent Theme)    {

/ /   I f    t her e   i s   an   exi s t i ng   t heme,	r epl ac e   i t   wi t h   t he new  one.
c ur r ent Theme. r epl ac eWi t h( l i nk) ;
}    el s e   {
/ /   Ot her wi s e,	j us t   i ns er t   t he   l i nk   t o   t he   t heme s t yl es heet .
doc ument . head. append( l i nk) ;
} }


Less subtly, you can also just insert a string of HTML containing a <s t yl e> tag into your document. This is a fun trick, for example:


doc ument . head. i ns er t Adj ac ent HTML ( " bef or eend" ,
" <s t yl e>body{ t r ans f or m: r ot at e( 180deg) } </ s t yl e>" ) ;


Browsers define an API that allows JavaScript to look inside stylesheets to query, modify, insert, and delete style rules in that stylesheet. This API is so specialized that it is not documented here. You can read about it on MDN by searching for “CSSStyleSheet” and “CSS Object Model.”


15.4.5 CSS Animations and Events

Suppose you have the following two CSS classes defined in a stylesheet:


. t r ans par ent   {    opac i t y:	0;	}
. f adeabl e   {    t r ans i t i on:	opac i t y   . 5s   eas e- i n   }


If you apply the first style to an element, it will be fully transparent and therefore invisible. But if you apply the second style that tells the browser that when the opacity of the element changes, that change should be animated over a period of 0.5 seconds, “ease-in” specifies that the opacity change animation should start off slow and then accelerate.

Now suppose that your HTML document contains an element with the “fadeable” class:

<di v   i d=" s ubs c r i be"   c l as s =" f adeabl e   not i f i c at i on" >. . . </di v>


In JavaScript, you can add the “transparent” class:


doc ument . quer ySel ec t or ( " #s ubs c r i be" ) . c l as s L i s t . add( " t r ans par ent " ) ;


This element is configured to animate opacity changes. Adding the “transparent” class changes the opacity and triggers an animate: the browser “fades out” the element so that it becomes fully transparent over the period of half a second.


This works in reverse as well: if you remove the “transparent” class of a “fadeable” element, that is also an opacity change, and the element fades back in and becomes visible again.


JavaScript does not have to do any work to make these animations happen: they are a pure CSS effect. But JavaScript can be used to trigger them.


JavaScript can also be used to monitor the progress of a CSS transition because the web browser fires events at the start and end of a transition. The “transitionrun” event is dispatched when the transition is first triggered. This may happen before any visual changes begin, when the
t r ans i t i on- del ay style has been specified. Once the visual changes begin a “transitionstart” event is dispatched, and when the animation is complete, a “transitionend” event is dispatched. The target of all these events is the element being animated, of course. The event object passed to handlers for these events is a TransitionEvent object. It has a
pr oper t yName property that specifies the CSS property being animated

and an el aps edTi me property that for “transitionend” events specifies how many seconds have passed since the “transitionstart” event.

In addition to transitions, CSS also supports a more complex form of animation known simply as “CSS Animations.” These use CSS properties such as ani mat i on- name and ani mat i on- dur at i on and a special @keyf r ames  rule to define animation details. Details of how CSS animations work are beyond the scope of this book, but once again, if you define all of the animation properties on a CSS class, then you can use JavaScript to trigger the animation simply by adding the class to the element that is to be animated.

And like CSS transitions, CSS animations also trigger events that your JavaScript code can listen form. “animationstart” is dispatched when the animation starts, and “animationend” is dispatched when it is complete. If the animation repeats more than once, then an “animationiteration” event is dispatched after each repetition except the last. The event target is the animated element, and the event object passed to handler functions is an AnimationEvent object. These events include an ani mat i onName property that specifies the ani mat i on- name property that defines the animation and an el aps edTi me property that specifies how many seconds have passed since the animation started.


15.5 Document Geometry and Scrolling

In this chapter so far, we have thought about documents as abstract trees of elements and text nodes. But when a browser renders a document within a window, it creates a visual representation of the document in which each element has a position and a size. Often, web applications can treat documents as trees of elements and never have to think about how those

elements are rendered on screen. Sometimes, however, it is necessary to determine the precise geometry of an element. If, for example, you want to use CSS to dynamically position an element (such as a tooltip) next to some ordinary browser-positioned element, you need to be able to determine the location of that element.


The following subsections explain how you can go back and forth between the abstract, tree-based model of a document and the geometrical, coordinate-based view of the document as it is laid out in a browser window.


15.5.1 Document Coordinates and Viewport Coordinates

The position of a document element is measured in CSS pixels, with the x coordinate increasing to the right and the y coordinate increasing as we go down. There are two different points we can use as the coordinate system origin, however: the x and y coordinates of an element can be relative to the top-left corner of the document or relative to the top-left corner of the viewport in which the document is displayed. In top-level windows and tabs, the “viewport” is the portion of the browser that actually displays document content: it excludes browser “chrome” such as menus, toolbars, and tabs. For documents displayed in <i f r ame> tags, it is the iframe element in the DOM that defines the viewport for the nested document. In either case, when we talk about the position of an element, we must be clear whether we are using document coordinates or viewport coordinates. (Note that viewport coordinates are sometimes called “window coordinates.”)

If the document is smaller than the viewport, or if it has not been scrolled, the upper-left corner of the document is in the upper-left corner of the

viewport and the document and viewport coordinate systems are the same. In general, however, to convert between the two coordinate systems, we must add or subtract the scroll offsets. If an element has a y coordinate of 200 pixels in document coordinates, for example, and if the user has scrolled down by 75 pixels, then that element has a y coordinate of 125 pixels in viewport coordinates. Similarly, if an element has an x coordinate of 400 in viewport coordinates after the user has scrolled the viewport 200 pixels horizontally, then the element’s x coordinate in document coordinates is 600.


If we use the mental model of printed paper documents, it is logical to assume that every element in a document must have a unique position in document coordinates, regardless of how much the user has scrolled the document. That is an appealing property of paper documents, and it applies for simple web documents, but in general, document coordinates don’t really work on the web. The problem is that the CSS over f l ow property allows elements within a document to contain more content than it can display. Elements can have their own scrollbars and serve as viewports for the content they contain. The fact that the web allows scrolling elements within a scrolling document means that it is simply not possible to describe the position of an element within the document using a single (x,y) point.


Because document coordinates don’t really work, client-side JavaScript tends to use viewport coordinates. The get Boundi ngCl i ent Rect ( ) and el ement Fr omPoi nt ( )  methods described next use viewport coordinates, for example, and the cl i ent X and cl i ent Y properties of mouse and pointer event objects also use this coordinate system.

When you explicitly position an element using CSS pos i t i on: f i xed,

the t op and l ef t  properties are interpreted in viewport coordinates. If you use pos i t i on: r el at i ve, the element is positioned relative to where it would have been if it didn’t have the pos i t i on property set. If you use pos i t i on: abs ol ut e, then t op and l ef t  are relative to the document or to the nearest containing positioned element. This means, for example, that an absolutely positioned element inside a relatively positioned element is positioned relative to the container element, not relative to the overall document. It is sometimes very useful to create a relatively positioned container with t op and l ef t  set to 0 (so the container is laid out normally) in order to establish a new coordinate system origin for the absolutely positioned elements it contains. We might refer to this new coordinate system as “container coordinates” to distinguish it from document coordinates and viewport coordinates.



CSS PIXELS

If, like me, you are old enough to remember computer monitors with resolutions of 1024 × 768 and touch-screen phones with resolutions of 320 × 480, then you may still think that the word “pixel” refers to a single “picture element” in hardware. Today’s 4K monitors and “retina” displays have such high resolution that software pixels have been decoupled from hardware pixels. A CSS pixel—and therefore a client-side JavaScript pixel—may in fact consist of multiple device pixels. The devi cePi xel Rat i o property of the Window object specifies how many device pixels are used for each software pixel. A “dpr” of 2, for example, means that each software pixel is actually a 2 × 2 grid of hardware pixels. The
devi cePi xel Rat i o value depends on the physical resolution of your hardware, on settings in your operating system, and on the zoom level in your browser.

devi cePi xel Rat i o does not have to be an integer. If you are using a CSS font size of “12px” and the device pixel ratio is 2.5, then the actual font size, in device pixels, is 30. Because the pixel values we use in CSS no longer correspond directly to individual pixels on the screen, pixel coordinates no longer need to be integers. If the devi cePi xel Rat i o is 3, then a coordinate of 3.33 makes perfect sense. And if the ratio is actually 2, then a coordinate of 3.33 will just be rounded up to 3.5.




15.5.2 Querying the Geometry of an Element

You can determine the size (including CSS border and padding, but not the margin) and position (in viewport coordinates) of an element by calling its

get Boundi ngCl i ent Rect ( )  method. It takes no arguments and returns an object with properties l ef t , r i ght , t op, bot t om, wi dt h, and hei ght . The l ef t  and t op properties give the x and y coordinates of the upper-left corner of the element, and the r i ght  and bot t om properties give the coordinates of the lower-right corner. The differences between these values are the wi dt h and hei ght  properties.


Block elements, such as images, paragraphs, and <di v> elements are always rectangular when laid out by the browser. Inline elements, such as <s pan>, <code>, and <b> elements, however, may span multiple lines and may therefore consist of multiple rectangles. Imagine, for example, some text within <em> and </ em> tags that happens to be displayed so that it wraps across two lines. Its rectangles consist of the end of the first line and beginning of the second line. If you call
get Boundi ngCl i ent Rect ( )  on this element, the bounding rectangle would include the entire width of both lines. If you want to query the individual rectangles of inline elements, call the get Cl i ent Rect s ( ) method to obtain a read-only, array-like object whose elements are rectangle objects like those returned by get Boundi ngCl i ent Rect ( ) .


15.5.3 Determining the Element at a Point

The get Boundi ngCl i ent Rect ( )  method allows us to determine the current position of an element in a viewport. Sometimes we want to go in the other direction and determine which element is at a given location in the viewport. You can determine this with the el ement Fr omPoi nt ( ) method of the Document object. Call this method with the x and y coordinates of a point (using viewport coordinates, not document coordinates: the cl i ent X and cl i ent Y coordinates of a mouse event work, for example). el ement Fr omPoi nt ( )  returns an Element object

that is at the specified position. The hit detection algorithm for selecting the element is not precisely specified, but the intent of this method is that it returns the innermost (most deeply nested) and uppermost (highest CSS z - i ndex attribute) element at that point.


15.5.4 Scrolling

The s cr ol l To( )  method of the Window object takes the x and y coordinates of a point (in document coordinates) and sets these as the scrollbar offsets. That is, it scrolls the window so that the specified point is in the upper-left corner of the viewport. If you specify a point that is too close to the bottom or too close to the right edge of the document, the browser will move it as close as possible to the upper-left corner but won’t be able to get it all the way there. The following code scrolls the browser so that the bottom-most page of the document is visible:

/ /   Get   t he   hei ght s   of    t he   doc ument   and   vi ewpor t .

l et   doc ument Hei ght
l et   vi ewpor t Hei ght

=   doc ument . doc ument El ement . of f s et Hei ght ;
=   wi ndow. i nner Hei ght ;

/ /   And   s c r ol l	s o   t he   l as t   " page"   s hows   i n   t he   vi ewpor t wi ndow. s c r ol l To( 0,	doc ument Hei ght   -    vi ewpor t Hei ght ) ;


The s cr ol l By( )  method of the Window is similar to s cr ol l To( ) , but its arguments are relative and are added to the current scroll position:


/ /   Sc r ol l t ur n   t hi s

50   pi xel s   down   ever y   500   ms .	Not e   t her e   i s   no   way   t o of f !

s et I nt er val ( ( )    =>   {    s c r ol l By( 0, 50) } ,	500) ;


If you want to scroll smoothly with s cr ol l To( )  or s cr ol l By( ) , pass a single object argument instead of two numbers, like this:

wi ndow. s c r ol l To( { l ef t :	0,

t op:	doc ument Hei ght   -    vi ewpor t Hei ght , behavi or :	" s moot h"
} ) ;


Often, instead of scrolling to a numeric location in a document, we just want to scroll so that a certain element in the document is visible. You can do this with the s cr ol l I nt oVi ew( )  method on the desired HTML element. This method ensures that the element on which it is invoked is visible in the viewport. By default, it tries to put the top edge of the element at or near the top of the viewport. If f al s e is passed as the only argument, it tries to put the bottom edge of the element at the bottom of the viewport. The browser will also scroll the viewport horizontally as needed to make the element visible.

You can also pass an object to s cr ol l I nt oVi ew( ) , setting the behavi or : " s moot h" property for smooth scrolling. You can set the bl ock property to specify where the element should be positioned
vertically and the i nl i ne property to specify how it should be positioned horizontally if horizontal scrolling is needed. Legal values for both of these properties are s t ar t , end, near es t , and cent er .


15.5.5 Viewport Size, Content Size, and Scroll Position

As we’ve discussed, browser windows and other HTML elements can display scrolling content. When this is the case, we sometimes need to know the size of the viewport, the size of the content, and the scroll offsets of the content within the viewport. This section covers these details.


For browser windows, the viewport size is given by the
wi ndow. i nner Wi dt h and wi ndow. i nner Hei ght  properties. (Web pages optimized for mobile devices often use a <met a

name=" vi ewpor t " > tag in their <head> to set the desired viewport width for the page.) The total size of the document is the same as the size of the <ht ml > element, document . document El ement . You can call get Boundi ngCl i ent Rect ( )  on document . document El ement to get the width and height of the document, or you can use the
of f s et Wi dt h and of f s et Hei ght  properties of
document . document El ement . The scroll offsets of the document within its viewport are available as wi ndow. s cr ol l X and
wi ndow. s cr ol l Y. These are read-only properties, so you can’t set them to scroll the document: use wi ndow. s cr ol l To( )  instead.


Things are a little more complicated for elements. Every Element object defines the following three groups of properties:


of f s et Wi dt h of f s et Hei ght of f s et L ef t
of f s et Top
of f s et Par ent

c l i ent Wi dt h c l i ent Hei ght c l i ent L ef t
c l i ent Top

s c r ol l Wi dt h s c r ol l Hei ght s c r ol l L ef t
s c r ol l Top



The of f s et Wi dt h and of f s et Hei ght  properties of an element return its on-screen size in CSS pixels. The returned sizes include the element border and padding but not margins. The of f s et Lef t  and
of f s et Top properties return the x and y coordinates of the element. For many elements, these values are document coordinates. But for descendants of positioned elements and for some other elements, such as table cells, these properties return coordinates that are relative to an ancestor element rather than the document itself. The of f s et Par ent property specifies which element the properties are relative to. These offset properties are all read-only.

cl i ent Wi dt h and cl i ent Hei ght  are like of f s et Wi dt h and

of f s et Hei ght  except that they do not include the border size—only the content area and its padding. The cl i ent Lef t  and cl i ent Top properties are not very useful: they return the horizontal and vertical distance between the outside of an element’s padding and the outside of its border. Usually, these values are just the width of the left and top borders. These client properties are all read-only. For inline elements like <i >, <code>, and <s pan>, they all return 0.


s cr ol l Wi dt h and s cr ol l Hei ght  return the size of an element’s content area plus its padding plus any overflowing content. When the content fits within the content area without overflow, these properties are the same as cl i ent Wi dt h and cl i ent Hei ght . But when there is overflow, they include the overflowing content and return values larger than cl i ent Wi dt h and cl i ent Hei ght . s cr ol l Lef t  and
s cr ol l Top give the scroll offset of the element content within the element’s viewport. Unlike all the other properties described here,
s cr ol l Lef t  and s cr ol l Top are writable properties, and you can set them to scroll the content within an element. (In most browsers, Element objects also have s cr ol l To( )  and s cr ol l By( )  methods like the Window object does, but these are not yet universally supported.)


15.6 Web Components

HTML is a language for document markup and defines a rich set of tags for that purpose. Over the last three decades, it has become a language that is used to describe the user interfaces of web applications, but basic HTML tags such as <i nput > and <but t on> are inadequate for modern UI designs. Web developers are able to make it work, but only by using CSS and JavaScript to augment the appearance and behavior of basic

HTML tags. Consider a typical user interface component, such as the search box shown in Figure 15-3.








Figure 15-3. A search box user interface component

The HTML <i nput > element can be used to accept a single line of input from the user, but it doesn’t have any way to display icons like the magnifying glass on the left and the cancel X on the right. In order to implement a modern user interface element like this for the web, we need to use at least four HTML elements: an <i nput > element to accept and display the user’s input, two <i mg> elements (or in this case, two
<s pan> elements displaying Unicode glyphs), and a container <di v> element to hold those three children. Furthermore, we have to use CSS to hide the default border of the <i nput > element and define a border for the container. And we need to use JavaScript to make all the HTML elements work together. When the user clicks on the X icon, we need an event handler to clear the input from the <i nput > element, for example.


That is a lot of work to do every time you want to display a search box in a web application, and most web applications today are not written using “raw” HTML. Instead, many web developers use frameworks like React and Angular that support the creation of reusable user interface components like the search box shown here. Web components is a
browser-native alternative to those frameworks based on three relatively recent additions to web standards that allow JavaScript to extend HTML with new tags that work as self-contained, reusable UI components.

The subsections that follow explain how to use web components defined by other developers in your own web pages, then explain each of the three technologies that web components are based on, and finally tie all three together in an example that implements the search box element pictured in Figure 15-3.


15.6.1 Using Web Components

Web components are defined in JavaScript, so in order to use a web component in your HTML file, you need to include the JavaScript file that defines the component. Because web components are a relatively new technology, they are often written as JavaScript modules, so you might include one in your HTML like this:

<s c r i pt   t ype=" modul e"   s r c =" c omponent s / s ear c h- box. j s " >


Web components define their own HTML tag names, with the important restriction that those tag names must include a hyphen. (This means that future versions of HTML can introduce new tags without hyphens, and there is no chance that the tags will conflict with anyone’s web component.) To use a web component, just use its tag in your HTML file:

<s ear c h- box   pl ac ehol der =" Sear c h. . . " ></s ear c h- box>


Web components can have attributes just like regular HTML tags can; the documentation for the component you are using should tell you which attributes are supported. Web components cannot be defined with self-closing tags. You cannot write <s ear ch- box/ >, for example. Your HTML file must include both the opening tag and the closing tag.

Like regular HTML elements, some web components are written to expect children and others are written in such a way that they do not expect (and

will not display) children. Some web components are written so that they can optionally accept specially labeled children that will appear in named “slots.” The <s ear ch- box> component pictured in Figure 15-3 and implemented in Example 15-3 uses “slots” for the two icons it displays. If you want to to use a <s ear ch- box> with different icons, you can use HTML like this:


<s ear c h- box>
<i mg   s r c =" i mages / s ear c h- i c on. png" <i mg   s r c =" i mages / c anc el - i c on. png"
</s ear c h- box>


s l ot =" l ef t " /> s l ot =" r i ght " />



The s l ot  attribute is an extension to HTML that it is used to specify which children should go where. The slot names—“left” and “right” in this example—are defined by the web component. If the component you are using supports slots, that fact should be included in its documentation.

I previously noted that web components are often implemented as JavaScript modules and can be loaded into HTML files with a <s cr i pt t ype=" modul e" > tag. You may remember from the beginning of this chapter that modules are loaded after document content is parsed, as if they had a def er r ed tag. So this means that a web browser will
typically parse and render tags like <s ear ch- box> before it has run the code that will tell it what a <s ear ch- box> is. This is normal when using web components. HTML parsers in web browsers are flexible and very forgiving about input that they do not understand. When they encounter a web component tag before that component has been defined, they add a generic HTMLElement to the DOM tree even though they do not know what to do with it. Later, when the custom element is defined, the generic element is “upgraded” so that it looks and behaves as desired.

If a web component has children, then those children will probably be

displayed incorrectly before the component is defined. You can use this CSS to keep web components hidden until they are defined:

/ *
*   Make   t he   <s ear c h- box>   c omponent   i nvi s i bl e   bef or e   i t   i s def i ned.
*   And   t r y   t o   dupl i c at e   i t s   event ual	l ayout   and   s i z e   s o   t hat near by
*   c ont ent   does   not   move   when   i t   bec omes   def i ned. */
s ear c h- box: not ( : def i ned)    {
opac i t y: 0;
di s pl ay:	i nl i ne- bl oc k; wi dt h:	300px;
hei ght :	50px; }


Like regular HTML elements, web components can be used in JavaScript. If you include a <s ear ch- box> tag in your web page, then you can obtain a reference to it with quer ySel ect or ( )  and an appropriate CSS selector, just as you would for any other HTML tag. Generally, it only makes sense to do this after the module that defines the component has run, so be careful when querying web components that you do not do so too early. Web component implementations typically (but this is not a requirement) define a JavaScript property for each HTML attribute they support. And, like HTML elements, they may also define useful methods. Once again, the documentation for the web component you are using should specify what properties and methods are available to your JavaScript code.

Now that you know how to use web components, the next three sections cover the three web browser features that allow us to implement them.



DOCUMENTFRAGMENT NODES

Before we can cover web component APIs, we need to return briefly to the DOM API to explain what a DocumentFragment is. The DOM API organizes a document into a tree of Node objects, where a Node can be a Document, an Element, a Text node, or even a Comment. None of these node types allows you to represent a fragment of a document that consists of a set of sibling nodes without their parent. This is where DocumentFragment comes in: it is another type of Node that serves as a temporary parent when you want to manipulate a group of sibling nodes as a single unit. You can create a DocumentFragment node with document . cr eat eDocument Fr agment ( ) . Once you have a DocumentFragment, you can use it like an Element and append( )  content to it. A DocumentFragment is different from an Element because it does not have a parent. But more importantly, when you insert a DocumentFragment node into the document, the DocumentFragment itself is not inserted. Instead, all of its children are inserted.




15.6.2 HTML Templates

The HTML <t empl at e> tag is only loosely related to web components, but it does enable a useful optimization for components that appear frequently in web pages. <t empl at e> tags and their children are never rendered by a web browser and are only useful on web pages that use JavaScript. The idea behind this tag is that when a web page contains multiple repetitions of the same basic HTML structure (such as rows in a table or the internal implementation of a web component), then we can use a <t empl at e> to define that element structure once, then use JavaScript to duplicate the structure as many times as needed.

In JavaScript, a <t empl at e> tag is represented by an HTMLTemplateElement object. This object defines a single cont ent property, and the value of this property is a DocumentFragment of all the child nodes of the <t empl at e>. You can clone this DocumentFragment and then insert the cloned copy into your document as needed. The fragment itself will not be inserted, but its children will be. Suppose you’re working with a document that includes a <t abl e> and
<t empl at e   i d=" r ow" > tag and that the template defines the structure of rows for that table. You might use the template like this:

l et   t abl eBody   =   doc ument . quer ySel ec t or ( " t body" ) ;

l et   t empl at e   =   doc ument . quer ySel ec t or ( " #r ow" ) ;
l et   c l one   =   t empl at e. c ont ent . c l oneNode( t r ue) ;	/ /   deep   c l one
/ /   . . . Us e   t he   DOM t o   i ns er t   c ont ent   i nt o   t he   <t d>   el ement s   of t he   c l one. . .
/ /   Now  add   t he   c l oned   and   i ni t i al i z ed   r ow  i nt o   t he   t abl e t abl eBody. append( c l one) ;


Template elements do not have to appear literally in an HTML document in order to be useful. You can create a template in your JavaScript code, create its children with i nner HTML, and then make as many clones as needed without the parsing overhead of i nner HTML. This is how HTML templates are typically used in web components, and Example 15-3 demonstrates this technique.


15.6.3 Custom Elements

The second web browser feature that enables web components is “custom elements”: the ability to associate a JavaScript class with an HTML tag name so that any such tags in the document are automatically turned into instances of the class in the DOM tree. The
cus t omEl ement s . def i ne( )  method takes a web component tag name as its first argument (remember that the tag name must include a hyphen) and a subclass of HTMLElement as its second argument. Any existing elements in the document with that tag name are “upgraded” to newly created instances of the class. And if the browser parses any HTML in the future, it will automatically create an instance of the class for each of the tags it encounters.

The class passed to cus t omEl ement s . def i ne( )  should extend HTMLElement and not a more specific type like HTMLButtonElement.4 Recall from Chapter 9 that when a JavaScript class extends another class, the constructor function must call s uper ( )  before it uses the t hi s

keyword, so if the custom element class has a constructor, it should call s uper ( )  (with no arguments) before doing anything else.


The browser will automatically invoke certain “lifecycle methods” of a custom element class. The connect edCal l back( )  method is invoked when an instance of the custom element is inserted into the document, and many elements use this method to perform initialization. There is also a
di s connect edCal l back( )  method invoked when (and if) the element is removed from the document, though this is less often used.

If a custom element class defines a static obs er vedAt t r i but es property whose value is an array of attribute names, and if any of the named attributes are set (or changed) on an instance of the custom element, the browser will invoke the
at t r i but eChangedCal l back( )  method, passing the attribute name, its old value, and its new value. This callback can take whatever steps are necessary to update the component based on its attribute values.

Custom element classes can also define whatever other properties and methods they want to. Commonly, they will define getter and setter methods that make the element’s attributes available as JavaScript properties.


As an example of a custom element, suppose we want to be able to display circles within paragraphs of regular text. We’d like to be able to write HTML like this in order to render mathematical story problems like the one shown in Figure 15-4:

<p>
The   doc ument   has   one   mar bl e:	<i nl i ne- c i r c l e></i nl i ne- c i r c l e>. The   HTML   par s er   i ns t ant i at es   t wo   mor e   mar bl es :
<i nl i ne- c i r c l e   di amet er =" 1. 2em"   c ol or =" bl ue" ></i nl i ne- c i r c l e>

<i nl i ne- c i r c l e   di amet er =" . 6em"   c ol or =" gol d" ></i nl i ne- c i r c l e>. How  many   mar bl es   does   t he   doc ument   c ont ai n   now?
</p>


















Figure 15-4. An inline circle custom element

We can implement this <i nl i ne- ci r cl e> custom element with the code shown in Example 15-2:

Example 15-2. The <inline-circle> custom element
c us t omEl ement s . def i ne( " i nl i ne- c i r c l e" ,	c l as s   I nl i neCi r c l e   ext ends
HTML El ement   {
/ /   The   br ows er   c al l s   t hi s   met hod   when   an   <i nl i ne- c i r c l e> el ement
/ /   i s   i ns er t ed   i nt o   t he   doc ument .	Ther e   i s   al s o   a di s c onnec t edCal l bac k( )
/ /   t hat   we   don' t   need   i n   t hi s   exampl e. c onnec t edCal l bac k( )    {
/ /   Set   t he   s t yl es   needed   t o   c r eat e   c i r c l es t hi s . s t yl e. di s pl ay   =   " i nl i ne- bl oc k" ;
t hi s . s t yl e. bor der Radi us   =   " 50%" ;
t hi s . s t yl e. bor der   =   " s ol i d   bl ac k   1px" ;
t hi s . s t yl e. t r ans f or m =   " t r ans l at eY( 10%) " ;

/ /   I f    t her e   i s   not   al r eady   a   s i z e   def i ned,	s et   a   def aul t s i z e
/ /   t hat   i s   bas ed   on   t he   c ur r ent   f ont   s i z e. i f    ( ! t hi s . s t yl e. wi dt h)    {
t hi s . s t yl e. wi dt h   =   " 0. 8em" ;
t hi s . s t yl e. hei ght   =   " 0. 8em" ;

} }


/ /   The   s t at i c   obs er vedAt t r i but es   pr oper t y   s pec i f i es at t r i but es
/ /   we   want   t o   be   not i f i ed   about   c hanges   t o.	( We   us e her e   s i nc e
/ /   we   c an   onl y   us e   " s t at i c "   wi t h   met hods . )

whi c h

a   get t er

s t at i c   get   obs er vedAt t r i but es ( )    {    r et ur n   [ " di amet er " , " c ol or " ] ;	}


/ /   Thi s   c al l bac k   i s   i nvoked above
/ /   c hanges ,	ei t her   when   t he l at er .

when   one   of    t he   at t r i but es   l i s t ed

c us t om el ement   i s   f i r s t   par s ed,	or

at t r i but eChangedCal l bac k( name,	ol dVal ue,	newVal ue)    { s wi t c h( name)    {
c as e   " di amet er " :
/ /   I f    t he   di amet er   at t r i but e   c hanges ,	updat e   t he   s i z e s t yl es
t hi s . s t yl e. wi dt h   =   newVal ue;
t hi s . s t yl e. hei ght   =   newVal ue; br eak;
c as e   " c ol or " :
/ /   I f    t he   c ol or   at t r i but e   c hanges ,	updat e   t he   c ol or s t yl es
t hi s . s t yl e. bac kgr oundCol or   =   newVal ue;
br eak; }
}

/ /   Def i ne   J avaSc r i pt   pr oper t i es   t hat   c or r es pond   t o   t he el ement ' s
/ /   at t r i but es .	Thes e   get t er s   and   s et t er s   j us t   get   and   s et   t he under l yi ng
/ /   at t r i but es .	I f    a   J avaSc r i pt   pr oper t y   i s   s et ,	t hat   s et s   t he at t r i but e
/ /   whi c h   t r i gger s   a   c al l	t o   at t r i but eChangedCal l bac k( )    whi c h updat es
/ /   t he   el ement   s t yl es .
get   di amet er ( )    {    r et ur n   t hi s . get At t r i but e( " di amet er " ) ;	}
s et   di amet er ( di amet er )    {    t hi s . s et At t r i but e( " di amet er " , di amet er ) ;	}
get   c ol or ( )    {    r et ur n   t hi s . get At t r i but e( " c ol or " ) ;	}
s et   c ol or ( c ol or )    {    t hi s . s et At t r i but e( " c ol or " ,	c ol or ) ;	}

} ) ;


15.6.4 Shadow DOM

The custom element demonstrated in Example 15-2 is not well encapsulated. When you set its di amet er  or col or  attributes, it responds by altering its own s t yl e attribute, which is not behavior we would ever expect from a real HTML element. To turn a custom element into a true web component, it should use the powerful encapsulation mechanism known as shadow DOM.

Shadow DOM allows a “shadow root” to be attached to a custom element (and also to a <di v>, <s pan>, <body>, <ar t i cl e>, <mai n>, <nav>, <header >, <f oot er >, <s ect i on>, <p>, <bl ockquot e>, <as i de>, or <h1> through <h6> element) known as a “shadow host.” Shadow host elements, like all HTML elements, are already the root of a normal DOM tree of descendant elements and text nodes. A shadow root is the root of another, more private, tree of descendant elements that sprouts from the shadow host and can be thought of as a distinct minidocument.

The word “shadow” in “shadow DOM” refers to the fact that elements that descend from a shadow root are “hiding in the shadows”: they are not part of the normal DOM tree, do not appear in the chi l dr en array of their host element, and are not visited by normal DOM traversal methods such as quer ySel ect or ( ) . For contrast, the normal, regular DOM children of a shadow host are sometimes referred to as the “light DOM.”

To understand the purpose of the shadow DOM, picture the HTML <audi o> and <vi deo> elements: they display a nontrivial user interface for controlling media playback, but the play and pause buttons

and other UI elements are not part of the DOM tree and cannot be manipulated by JavaScript. Given that web browsers are designed to display HTML, it is only natural that browser vendors would want to display internal UIs like these using HTML. In fact, most browsers have been doing something like that for a long time, and the shadow DOM makes it a standard part of the web platform.

SHADOW DOM ENCAPSULATION

The key feature of shadow DOM is the encapsulation it provides. The descendants of a shadow root are hidden from—and independent from— the regular DOM tree, almost as if they were in an independent document. There are three very important kinds of encapsulation provided by the shadow DOM:

As already mentioned, elements in the shadow DOM are hidden from regular DOM methods like quer ySel ect or Al l ( ) . When a shadow root is created and attached to its shadow host, it can be created in “open” or “closed” mode. A closed shadow root is completely sealed away and inaccessible. More commonly, though, shadow roots are created in “open” mode, which means that the shadow host has a s hadowRoot  property that JavaScript can use to gain access to the elements of the shadow root, if it has some reason to do so.

Styles defined beneath a shadow root are private to that tree and will never affect the light DOM elements on the outside. (A shadow root can define default styles for its host element, but these will be overridden by light DOM styles.) Similarly, the light DOM styles that apply to the shadow host element have no effect on the descendants of the shadow root. Elements in the shadow DOM will inherit things like font size and background color from the light DOM, and styles in the shadow DOM can choose to use CSS variables defined in the light DOM. For the most part,

however, the styles of the light DOM and the styles of the shadow DOM are completely independent: the author of a web component and the user of a web component do not have to worry about collisions or conflicts between their stylesheets. Being able to “scope” CSS in this way is perhaps the most important feature of the shadow DOM.

Some events (like “load”) that occur within the shadow DOM are confined to the shadow DOM. Others, including focus, mouse, and keyboard events bubble up and out. When an event that originates in the shadow DOM crosses the boundary and begins to propagate in the light DOM, its t ar get  property is changed to the shadow host element, so it appears to have originated directly on that element.

SHADOW DOM SLOTS AND LIGHT DOM CHILDREN

An HTML element that is a shadow host has two trees of descendants. One is the chi l dr en[ ]  array—the regular light DOM descendants of the host element—and the other is the shadow root and all of its descendants, and you may be wondering how two distinct content trees can be displayed within the same host element. Here’s how it works:

The descendants of the shadow root are always displayed within the shadow host.

If those descendants include a <s l ot > element, then the regular light DOM children of the host element are displayed as if they were children of that <s l ot >, replacing any shadow DOM content in the slot. If the shadow DOM does not include a
<s l ot >, then any light DOM content of the host is never displayed. If the shadow DOM has a <s l ot >, but the shadow host has no light DOM children, then the shadow DOM content of the slot is displayed as a default.

When light DOM content is displayed within a shadow DOM

slot, we say that those elements have been “distributed,” but it is important to understand that the elements do not actually become part of the shadow DOM. They can still be queried with
quer ySel ect or ( ) , and they still appear in the light DOM as children or descendants of the host element.

If the shadow DOM defines more than one <s l ot > and names those slots with a name attribute, then children of the shadow host can specify which slot they would like to appear in by specifying a s l ot =" s l ot name" attribute. We saw an example of this usage in §15.6.1 when we demonstrated how to customize the icons displayed by the <s ear ch- box> component.

SHADOW DOM API

For all of its power, the Shadow DOM doesn’t have much of a JavaScript API. To turn a light DOM element into a shadow host, just call its
at t achShadow( )  method, passing { mode: " open" }  as the only argument. This method returns a shadow root object and also sets that object as the value of the host’s s hadowRoot  property. The shadow root object is a DocumentFragment, and you can use DOM methods to add content to it or just set its i nner HTML property to a string of HTML.


If your web component needs to know when the light DOM content of a shadow DOM <s l ot > has changed, it can register a listener for “slotchanged” events directly on the <s l ot > element.


15.6.5 Example: a <search-box> Web Component

Figure 15-3 illustrated a <s ear ch- box> web component. Example 15-3 demonstrates the three enabling technologies that define web components: it implements the <s ear ch- box> component as a custom element that uses a <t empl at e> tag for efficiency and a shadow root for

encapsulation.


This example shows how to use the low-level web component APIs directly. In practice, many web components developed today create them using higher-level libraries such as “lit-element.” One of the reasons to use a library is that creating reusable and customizable components is actually quite hard to do well, and there are many details to get right. Example 15-3 demonstrates web components and does some basic keyboard focus handling, but otherwise ignores accessibility and makes no attempt to use proper ARIA attributes to make the component work with screen readers and other assistive technology.

Example 15-3. Implementing a web component
/ **
*   Thi s   c l as s   def i nes   a   c us t om HTML   <s ear c h- box>   el ement   t hat di s pl ays   an
*   <i nput >   t ext   i nput   f i el d   pl us   t wo   i c ons   or   emoj i .	By   def aul t , i t   di s pl ays   a
*   magni f yi ng   gl as s   emoj i	( i ndi c at i ng   s ear c h)    t o   t he   l ef t   of    t he t ext   f i el d
*   and   an   X   emoj i	( i ndi c at i ng   c anc el )    t o   t he   r i ght   of    t he   t ext f i el d.	I t
*   hi des   t he   bor der   on   t he   i nput   f i el d   and   di s pl ays   a   bor der ar ound   i t s el f ,
*   c r eat i ng   t he   appear anc e   t hat   t he   t wo   emoj i    ar e   i ns i de   t he   i nput *   f i el d.    Si mi l ar l y,    when   t he   i nt er nal    i nput   f i el d   i s   f oc us ed,    t he
f oc us   r i ng
*   i s   di s pl ayed   ar ound   t he   <s ear c h- box>. *
*   You   c an   over r i de   t he   def aul t   i c ons   by   i nc l udi ng   <s pan>   or   <i mg> c hi l dr en
*   of    <s ear c h- box>   wi t h   s l ot =" l ef t "   and   s l ot =" r i ght "   at t r i but es . *
*   <s ear c h- box>   s uppor t s   t he   nor mal	HTML   di s abl ed   and   hi dden at t r i but es   and
*   al s o   s i z e   and   pl ac ehol der   at t r i but es ,	whi c h   have   t he   s ame meani ng   f or   t hi s
*   el ement   as   t hey   do   f or   t he   <i nput >   el ement . *
*   I nput   event s   f r om t he   i nt er nal	<i nput >   el ement   bubbl e   up   and appear   wi t h

*   t hei r   t ar get   f i el d   s et   t o   t he   <s ear c h- box>   el ement . *
*   The   el ement   f i r es   a   " s ear c h"   event   wi t h   t he   det ai l	pr oper t y   s et t o   t he
*   c ur r ent   i nput   s t r i ng   when   t he   us er   c l i c ks   on   t he   l ef t   emoj i ( t he   magni f yi ng
*   gl as s ) .	The   " s ear c h"   event   i s   al s o   di s pat c hed   when   t he   i nt er nal t ext   f i el d
*   gener at es   a   " c hange"   event   ( when   t he   t ext   has   c hanged   and   t he us er   t ypes
*   Ret ur n   or   Tab) . *
*   The   el ement   f i r es   a   " c l ear "   event   when   t he   us er   c l i c ks   on   t he r i ght   emoj i
*   ( t he   X) .	I f    no   handl er   c al l s   pr event Def aul t ( )    on   t he   event   t hen t he   el ement
*   c l ear s   t he   us er ' s   i nput   onc e   event   di s pat c h   i s   c ompl et e. *
*   Not e   t hat   t her e   ar e   no   ons ear c h   and   onc l ear   pr oper t i es   or at t r i but es :
*   handl er s   f or   t he   " s ear c h"   and   " c l ear "   event s   c an   onl y   be r egi s t er ed   wi t h
*   addEvent L i s t ener ( ) . */
c l as s   Sear c hBox   ext ends   HTML El ement   {
c ons t r uc t or ( )    {
s uper ( ) ;	/ /   I nvoke   t he   s uper c l as s   c ons t r uc t or ;	mus t   be f i r s t .


/ / s et t i ng
/ /

Cr eat e   a   s hadow  DOM t r ee   and   at t ac h   i t   t o   t hi s   el ement ,

t he   val ue   of    t hi s . s hadowRoot .

t hi s . at t ac hShadow( { mode:	" open" } ) ;

/ /   Cl one   t he   t empl at e   t hat   def i nes   t he   des c endant s   and s t yl es heet   f or
/ /   t hi s   c us t om c omponent ,	and   append   t hat   c ont ent   t o   t he s hadow  r oot .

t hi s . s hadowRoot . append( Sear c hBox. t empl at e. c ont ent . c l oneNode( t r ue) ) ;


/ /   Get   r ef er enc es   t o   t he   i mpor t ant   el ement s   i n   t he   s hadow DOM
t hi s . i nput   =   t hi s . s hadowRoot . quer ySel ec t or ( " #i nput " ) ; l et   l ef t Sl ot   =
t hi s . s hadowRoot . quer ySel ec t or ( ' s l ot [ name=" l ef t " ] ' ) ; l et   r i ght Sl ot   =

t hi s . s hadowRoot . quer ySel ec t or ( ' s l ot [ name=" r i ght " ] ' ) ;


/ / or   r emove
/ / s t yl es heet
/ / c omponent .
/ / or i gi nat e
/ /

When   t he   i nt er nal	i nput   f i el d   get s   or   l os es   f oc us ,	s et

t he   " f oc us ed"   at t r i but e   whi c h   wi l l	c aus e   our   i nt er nal

t o   di s pl ay   or   hi de   a   f ake   f oc us   r i ng   on   t he   ent i r e Not e
t hat   t he   " bl ur "   and   " f oc us "   event s   bubbl e   and   appear   t o

f r om t he   <s ear c h- box>.

t hi s . i nput . onf oc us   =   ( )    =>   {    t hi s . s et At t r i but e( " f oc us ed" , " " ) ;	} ;
t hi s . i nput . onbl ur   =   ( )    =>   { t hi s . r emoveAt t r i but e( " f oc us ed" ) ; } ;


/ /   I f    t he " s ear c h"
/ /   event . " c hange"
/ /   event . Shadow  DOM. )

us er   c l i c ks   on   t he   magni f yi ng   gl as s ,	t r i gger   a

Al s o   t r i gger   i t   i f    t he   i nput   f i el d   f i r es   a

( The   " c hange"   event   does   not   bubbl e   out   of    t he

l ef t Sl ot . onc l i c k   =   t hi s . i nput . onc hange   =   ( event )    =>   { event . s t opPr opagat i on( ) ;	/ /   Pr event   c l i c k   event s
f r om bubbl i ng
i f    ( t hi s . di s abl ed)    r et ur n;	/ /   Do   not hi ng   when di s abl ed
t hi s . di s pat c hEvent ( new  Cus t omEvent ( " s ear c h" ,	{ det ai l :	t hi s . i nput . val ue
} ) ) ; } ;


/ /   I f / /   I f
t he   i nput .

t he   us er   c l i c ks   on   t he   X,    t r i gger pr event Def aul t ( )    i s   not   c al l ed   on

a   " c l ear "   event . t he   event ,    c l ear

r i ght Sl ot . onc l i c k   =   ( event )    =>   {
event . s t opPr opagat i on( ) ;	/ /   Don' t   l et   t he   c l i c k bubbl e   up
i f    ( t hi s . di s abl ed)    r et ur n;	/ /   Don' t   do   anyt hi ng   i f di s abl ed
l et   e   =   new  Cus t omEvent ( " c l ear " ,	{    c anc el abl e:	t r ue } ) ;
t hi s . di s pat c hEvent ( e) ;
i f    ( ! e. def aul t Pr event ed)    {	/ /   I f    t he   event   was   not " c anc el l ed"

t hi s . i nput . val ue   =   " " ;	/ /   t hen   c l ear   t he   i nput f i el d
} } ;
}

/ /   When   s ome   of    our   at t r i but es   ar e   s et   or   c hanged,	we   need   t o s et   t he
/ /   c or r es pondi ng   val ue   on   t he   i nt er nal	<i nput >   el ement .	Thi s l i f e   c yc l e
/ /   met hod,	t oget her   wi t h   t he   s t at i c   obs er vedAt t r i but es pr oper t y   bel ow,
/ /   t akes   c ar e   of    t hat .
at t r i but eChangedCal l bac k( name,	ol dVal ue,	newVal ue)    {
i f    ( name   ===   " di s abl ed" )    {
t hi s . i nput . di s abl ed   =   newVal ue   ! ==   nul l ; }    el s e   i f    ( name   ===   " pl ac ehol der " )    {
t hi s . i nput . pl ac ehol der   =   newVal ue; }    el s e   i f    ( name   ===   " s i z e" )    {
t hi s . i nput . s i z e   =   newVal ue; }    el s e   i f    ( name   ===   " val ue" )    {
t hi s . i nput . val ue   =   newVal ue; }
}

/ /   Fi nal l y,	we   def i ne   pr oper t y   get t er s   and   s et t er s   f or pr oper t i es   t hat
/ /   c or r es pond   t o   t he   HTML   at t r i but es   we   s uppor t .	The   get t er s s i mpl y   r et ur n
/ /   t he   val ue   ( or   t he   pr es enc e)    of    t he   at t r i but e.	And   t he s et t er s   j us t   s et
/ /   t he   val ue   ( or   t he   pr es enc e)    of    t he   at t r i but e.	When   a   s et t er met hod
/ /   c hanges   an   at t r i but e,	t he   br ows er   wi l l	aut omat i c al l y   i nvoke t he
/ /   at t r i but eChangedCal l bac k   above.

get   pl ac ehol der ( )    {    r et ur n   t hi s . get At t r i but e( " pl ac ehol der " ) ;	} get   s i z e( )    {    r et ur n   t hi s . get At t r i but e( " s i z e" ) ;	}
get   val ue( )    {    r et ur n   t hi s . get At t r i but e( " val ue" ) ;	}
get   di s abl ed( )    {    r et ur n   t hi s . has At t r i but e( " di s abl ed" ) ;	} get   hi dden( )    {    r et ur n   t hi s . has At t r i but e( " hi dden" ) ;	}


s et
val ue) ;

pl ac ehol der ( val ue)    {    t hi s . s et At t r i but e( " pl ac ehol der " ,
}

s et   s i z e( val ue)    {    t hi s . s et At t r i but e( " s i z e" ,	val ue) ;	} s et   val ue( t ext )    {    t hi s . s et At t r i but e( " val ue" ,    t ext ) ;	} s et   di s abl ed( val ue)    {
i f    ( val ue)    t hi s . s et At t r i but e( " di s abl ed" ,	" " ) ; el s e   t hi s . r emoveAt t r i but e( " di s abl ed" ) ;
}
s et   hi dden( val ue)    {
i f    ( val ue)    t hi s . s et At t r i but e( " hi dden" ,	" " ) ; el s e   t hi s . r emoveAt t r i but e( " hi dden" ) ;
} }


/ /   Thi s met hod. / /   Onl y met hod.

s t at i c   f i el d   i s   r equi r ed

at t r i but es   named   i n   t hi s

f or   t he   at t r i but eChangedCal l bac k

ar r ay   wi l l	t r i gger   c al l s   t o   t hat

Sear c hBox. obs er vedAt t r i but es   =   [ " di s abl ed" ,	" pl ac ehol der " ,	" s i z e" , " val ue" ] ;


/ /   Cr eat e   a of
/ /   el ement s el ement .

<t empl at e>

t hat   we' l l

el ement

us e   f or

t o   hol d   t he   s t yl es heet   and   t he   t r ee

eac h   i ns t anc e   of    t he   Sear c hBox

Sear c hBox. t empl at e   =   doc ument . c r eat eEl ement ( " t empl at e" ) ;


/ /   We   i ni t i al i z e   t he   t empl at e   by   par s i ng   t hi s   s t r i ng   of Not e,	however ,
/ /   t hat   when   we   i ns t ant i at e   a   Sear c hBox,	we   ar e   abl e   t o t he   nodes
/ /   i n   t he   t empl at e   and   do   have   t o   par s e   t he   HTML   agai n.

HTML .

j us t   c l one

Sear c hBox. t empl at e. i nner HTML   =   ` <s t yl e>
/ *
*   The   : hos t   s el ec t or   r ef er s   t o   t he   <s ear c h- box>   el ement   i n   t he l i ght
*   DOM.	Thes e   s t yl es   ar e   def aul t s   and   c an   be   over r i dden   by   t he us er   of    t he
*   <s ear c h- box>   wi t h   s t yl es   i n   t he   l i ght   DOM. */
: hos t   {
di s pl ay:	i nl i ne- bl oc k;	/ *   The   def aul t   i s   i nl i ne   di s pl ay   */
bor der :	s ol i d   bl ac k   1px;	/ *   A  r ounded   bor der   ar ound   t he   <i nput > and   <s l ot s >   */
bor der - r adi us :	5px;
paddi ng:	4px   6px;	/ *   And   s ome   s pac e   i ns i de   t he   bor der   */ }


: hos t ( [ hi dden] )    { hi dden. . .	*/
di s pl ay: none; }
: hos t ( [ di s abl ed] )    { at t r i but e. . .	*/
opac i t y:	0. 5; }
: hos t ( [ f oc us ed] )    { at t r i but e. . .	*/
box- s hadow:	0   0   2px   2px */
}

/ *   Not e   t he   par ent hes es :	when   hos t   has

/ *   . . . at t r i but e   s et   don' t   di s pl ay   i t   */

/ *   When   hos t   has   t he   di s abl ed

/ *   . . . gr ay   i t   out   */

/ *   When   hos t   has   t he   f oc us ed

#6AE;	/ *   di s pl ay   t hi s   f ake   f oc us   r i ng.


/ *   The   r es t   of    t he   s t yl es heet   onl y   appl i es   t o   el ement s   i n   t he Shadow  DOM.	*/
i nput   {
bor der - wi dt h:	0;	/ *   Hi de   t he   bor der   of    t he   i nt er nal i nput   f i el d.	*/
out l i ne:	none;	/ *   Hi de   t he   f oc us   r i ng,	t oo.	*/
f ont :	i nher i t ;	/ *   <i nput >   el ement s   don' t   i nher i t   f ont by   def aul t   */
bac kgr ound:	i nher i t ;	/ *   Same   f or   bac kgr ound   c ol or .	*/ }
s l ot   {
c ur s or :	def aul t ;	/ *   An   ar r ow  poi nt er   c ur s or   over   t he but t ons   */
us er - s el ec t :	none;	/ *   Don' t   l et   t he   us er   s el ec t   t he   emoj i t ext   */
}
</ s t yl e> <di v>
<s l ot   name=" l ef t " >\ u{ 1f 50d} </ s l ot >	<! - -    U+1F50D  i s   a   magni f yi ng gl as s   - - >
<i nput   t ype=" t ext "   i d=" i nput "   / >	<! - -    The   ac t ual	i nput el ement   - - >
<s l ot   name=" r i ght " >\ u{ 2573} </ s l ot >	<! - -    U+2573   i s   an   X   - - > </ di v>
` ;

/ /   Fi nal l y,	we   c al l	c us t omEl ement . def i ne( )    t o   r egi s t er   t he Sear c hBox   el ement
/ /   as   t he   i mpl ement at i on   of    t he   <s ear c h- box>   t ag.	Cus t om el ement s ar e   r equi r ed
/ /   t o   have   a   t ag   name   t hat   c ont ai ns   a   hyphen.
c us t omEl ement s . def i ne( " s ear c h- box" ,	Sear c hBox) ;

15.7 SVG: Scalable Vector Graphics

SVG (scalable vector graphics) is an image format. The word “vector” in its name indicates that it is fundamentally different from raster image formats, such as GIF, JPEG, and PNG, that specify a matrix of pixel values. Instead, an SVG “image” is a precise, resolution-independent (hence “scalable”) description of the steps necessary to draw the desired graphic. SVG images are described by text files using the XML markup language, which is quite similar to HTML.


There are three ways you can use SVG in web browsers:


1.  You can use .svg image files with regular HTML <i mg> tags, just as you would use a .png or .jpeg image.

2.  Because the XML-based SVG format is so similar to HTML, you can actually embed SVG tags directly into your HTML documents. If you do this, the browser’s HTML parser allows you to omit XML namespaces and treat SVG tags as if they were HTML tags.

3.  You can use the DOM API to dynamically create SVG elements to generate images on demand.

The subsections that follow demonstrate the second and third uses of SVG. Note, however, that SVG has a large and moderately complex grammar. In addition to simple shape-drawing primitives, it includes support for arbitrary curves, text, and animation. SVG graphics can even incorporate JavaScript scripts and CSS stylesheets to add behavior and presentation information. A full description of SVG is well beyond the scope of this book. The goal of this section is just to show you how you can use SVG in your HTML documents and script it with JavaScript.

15.7.1 SVG in HTML

SVG images can, of course, be displayed using HTML <i mg> tags. But you can also embed SVG directly in HTML. And if you do this, you can even use CSS stylesheets to specify things like fonts, colors, and line widths. Here, for example, is an HTML file that uses SVG to display an analog clock face:

<ht ml > <head>
<t i t l e>Anal og   Cl oc k</t i t l e> <s t yl e>
/ *   Thes e   CSS   s t yl es   al l	appl y   t o   t he   SVG  el ement s   def i ned   bel ow */
#c l oc k   {	/ *   St yl es   f or   ever yt hi ng   i n t he   c l oc k: */
s t r oke:	bl ac k;	/ *   bl ac k   l i nes   */
s t r oke- l i nec ap:	r ound;	/ *   wi t h   r ounded   ends   */ f i l l :	#f f e;                                                                / *   on   an   of f - whi t e
bac kgr ound   */ }
#c l oc k   . f ac e   {    s t r oke- wi dt h:	3;	}	/ *   Cl oc k   f ac e   out l i ne   */ #c l oc k   . t i c ks   {    s t r oke- wi dt h:    2;    }	/ *   L i nes   t hat   mar k   eac h hour   */
#c l oc k   . hands   {    s t r oke- wi dt h:	3;	}	/ *   How  t o   dr aw  t he   c l oc k hands   */
#c l oc k   . number s   {	/ *   How  t o   dr aw  t he   number s */
f ont - f ami l y:	s ans - s er i f ;	f ont - s i z e:	10;	f ont - wei ght :	bol d; t ext - anc hor :	mi ddl e;	s t r oke:	none;    f i l l :    bl ac k;
}
</s t yl e> </head> <body>
<s vg   i d=" c l oc k"   vi ewBox=" 0   0   100   100"   wi dt h=" 250" hei ght =" 250" >
<! - -    The   wi dt h   and   hei ght   at t r i but es   ar e   t he   s c r een   s i z e   of t he   gr aphi c   - - >
<! - -    The   vi ewBox   at t r i but e   gi ves   t he   i nt er nal	c oor di nat e s ys t em - - >
<c i r c l e   c l as s =" f ac e"   c x=" 50"   c y=" 50"   r =" 45" />	<! - -    t he c l oc k   f ac e   - - >
<g   c l as s =" t i c ks " >	<! - -    t i c k   mar ks   f or   eac h   of    t he   12   hour s

- - >
<l i ne   x1=' 50'	y1=' 5. 000'	x2=' 50. 00'	y2=' 10. 00' />
<l i ne   x1=' 72. 50'	y1=' 11. 03'	x2=' 70. 00'	y2=' 15. 36' /> <l i ne   x1=' 88. 97'	y1=' 27. 50'	x2=' 84. 64'	y2=' 30. 00' /> <l i ne   x1=' 95. 00'	y1=' 50. 00'	x2=' 90. 00'	y2=' 50. 00' /> <l i ne   x1=' 88. 97'	y1=' 72. 50'	x2=' 84. 64'	y2=' 70. 00' /> <l i ne   x1=' 72. 50'	y1=' 88. 97'	x2=' 70. 00'	y2=' 84. 64' /> <l i ne   x1=' 50. 00'	y1=' 95. 00'	x2=' 50. 00'	y2=' 90. 00' /> <l i ne   x1=' 27. 50'	y1=' 88. 97'	x2=' 30. 00'	y2=' 84. 64' /> <l i ne   x1=' 11. 03'	y1=' 72. 50'	x2=' 15. 36'	y2=' 70. 00' /> <l i ne   x1=' 5. 000'	y1=' 50. 00'	x2=' 10. 00'	y2=' 50. 00' /> <l i ne   x1=' 11. 03'	y1=' 27. 50'	x2=' 15. 36'	y2=' 30. 00' /> <l i ne   x1=' 27. 50'	y1=' 11. 03'	x2=' 30. 00'	y2=' 15. 36' />
</g>
<g   c l as s =" number s " >   <! - -    Number   t he   c ar di nal	di r ec t i ons - - > <t ext   x=" 50"   y=" 18" >12</t ext ><t ext   x=" 85"   y=" 53" >3</t ext > <t ext   x=" 50"   y=" 88" >6</t ext ><t ext   x=" 15"   y=" 53" >9</t ext >
</g>
<g   c l as s =" hands " >	<! - -    Dr aw  hands   poi nt i ng   s t r ai ght   up.	- ->
<l i ne   c l as s =" hour hand"   x1=" 50"   y1=" 50"   x2=" 50"   y2=" 25" />
<l i ne   c l as s =" mi nut ehand"   x1=" 50"   y1=" 50"   x2=" 50"   y2=" 20" /> </g>
</s vg>
<s c r i pt   s r c =" c l oc k. j s " ></s c r i pt > </body>
</ht ml >


You’ll notice that the descendants of the <s vg> tag are not normal HTML tags. <ci r cl e>, <l i ne>, and <t ext > tags have obvious purposes, though, and it should be clear how this SVG graphic works. There are many other SVG tags, however, and you’ll need to consult an SVG reference to learn more. You may also notice that the stylesheet is odd. Styles like f i l l , s t r oke- wi dt h, and t ext - anchor  are not normal CSS style properties. In this case, CSS is essentially being used to set attributes of SVG tags that appear in the document. Note also that the CSS f ont  shorthand property does not work for SVG tags, and you must explicitly set f ont - f ami l y, f ont - s i z e, and f ont - wei ght  as separate style properties.

15.7.2 Scripting SVG

One reason to embed SVG directly into your HTML files (instead of just using static <i mg> tags) is that if you do this, then you can use the DOM API to manipulate the SVG image. Suppose you use SVG to display icons in your web application. You could embed SVG within a <t empl at e> tag (§15.6.2) and then clone the template content whenever you need to insert a copy of that icon into your UI. And if you want the icon to respond to user activity—by changing color when the user hovers the pointer over it, for example—you can often achieve this with CSS.

It is also possible to dynamically manipulate SVG graphics that are directly embedded in HTML. The clock face example in the previous section displays a static clock with hour and minute hands facing straight up displaying the time noon or midnight. But you may have noticed that the HTML file includes a <s cr i pt > tag. That script runs a function periodically to check the time and transform the hour and minute hands by rotating them the appropriate number of degrees so that the clock actually displays the current time, as shown in Figure 15-5.





















Figure 15-5. A scripted SVG analog clock

The code to manipulate the clock is straightforward. It determines the proper angle of the hour and minute hands based on the current time, then uses quer ySel ect or ( )  to look up the SVG elements that display those hands, then sets a t r ans f or mattribute on them to rotate them around the center of the clock face. The function uses s et Ti meout ( )  to ensure that it runs once a minute:

( f unc t i on   updat eCl oc k( )    {    / /   Updat e   t he   SVG  c l oc k   gr aphi c   t o s how  c ur r ent   t i me
l et   now  =   new  Dat e( ) ;	/ /   Cur r ent   t i me l et   s ec   =   now. get Sec onds ( ) ;	/ /   Sec onds
l et   mi n   =   now. get Mi nut es ( )    +   s ec / 60;	/ /   Fr ac t i onal mi nut es
l et   hour   =   ( now. get Hour s ( )    %  12)    +   mi n/ 60;	/ /   Fr ac t i onal hour s
l et   mi nangl e   =   mi n   *   6;	/ /   6   degr ees   per mi nut e
l et   hour angl e   =   hour   *   30;	/ /   30   degr ees per   hour

/ /   Get   SVG  el ement s   f or   t he   hands   of    t he   c l oc k
l et   mi nhand   =   doc ument . quer ySel ec t or ( " #c l oc k   . mi nut ehand" ) ; l et   hour hand   =   doc ument . quer ySel ec t or ( " #c l oc k   . hour hand" ) ;


/ /   Set   an   SVG  at t r i but e   on   t hem t o   move   t hem ar ound   t he c l oc k   f ac e
mi nhand. s et At t r i but e( " t r ans f or m" ,
` r ot at e( ${ mi nangl e} , 50, 50) ` ) ;
hour hand. s et At t r i but e( " t r ans f or m" , ` r ot at e( ${ hour angl e} , 50, 50) ` ) ;

/ /   Run   t hi s   f unc t i on   agai n   i n   10   s ec onds s et Ti meout ( updat eCl oc k,	10000) ;
} ( ) ) ;	/ /   Not e   i mmedi at e   i nvoc at i on   of    t he   f unc t i on   her e.


15.7.3 Creating SVG Images with J avaScript

In addition to simply scripting SVG images embedded in your HTML documents, you can also build SVG images from scratch, which can be useful to create visualizations of dynamically loaded data, for example. Example 15-4 demonstrates how you can use JavaScript to create SVG pie charts, like the one shown in Figure 15-6.


Even though SVG tags can be included within HTML documents, they are technically XML tags, not HTML tags, and if you want to create SVG elements with the JavaScript DOM API, you can’t use the normal
cr eat eEl ement ( )  function that was introduced in §15.3.5. Instead you must use cr eat eEl ement NS( ) , which takes an XML namespace string as its first argument. For SVG, that namespace is the literal string “http://www.w3.org/2000/svg.”











































Figure 15-6. An SVG pie chart built with JavaScript (data from Stack Overflow’s 2018 Developer Survey of Most Popular Technologies)

Other than the use of cr eat eEl ement NS( ) , the pie chart–drawing code in Example 15-4 is relatively straightforward. There is a little math to convert the data being charted into pie-slice angles. The bulk of the example, however, is DOM code that creates SVG elements and sets attributes on those elements.

The most opaque part of this example is the code that draws the actual pie slices. The element used to display each slice is <pat h>. This SVG element describes arbitrary shapes comprised of lines and curves. The shape description is specified by the d attribute of the <pat h> element. The value of this attribute uses a compact grammar of letter codes and numbers that specify coordinates, angles, and other values. The letter M, for example, means “move to” and is followed by x and y coordinates. The letter L means “line to” and draws a line from the current point to the coordinates that follow it. This example also uses the letter A to draw an arc. This letter is followed by seven numbers describing the arc, and you can look up the syntax online if you want to know more.

Example 15-4. Drawing a pie chart with JavaScript and SVG
/ **
*   Cr eat e   an   <s vg>   el ement   and   dr aw  a   pi e   c har t   i nt o   i t . *
*   Thi s   f unc t i on   expec t s   an   obj ec t   ar gument   wi t h   t he   f ol l owi ng pr oper t i es :
*
*	wi dt h,	hei ght :	t he   s i z e   of    t he   SVG  gr aphi c ,	i n   pi xel s *	c x,	c y,    r :	t he   c ent er   and   r adi us   of    t he   pi e
*	l x,	l y:	t he   upper - l ef t   c or ner   of    t he   c har t   l egend
*	dat a:	an   obj ec t   whos e   pr oper t y   names   ar e   dat a   l abel s   and whos e
*	pr oper t y   val ues   ar e   t he   val ues   as s oc i at ed   wi t h   eac h l abel
*
*   The   f unc t i on   r et ur ns   an   <s vg>   el ement .	The   c al l er   mus t   i ns er t i t   i nt o
*   t he   doc ument   i n   or der   t o   make   i t   vi s i bl e. */
f unc t i on   pi eChar t ( opt i ons )    {
l et   { wi dt h,	hei ght ,	c x,	c y,	r ,	l x,	l y,	dat a}    =   opt i ons ;

/ /   Thi s   i s   t he   XML   names pac e   f or   s vg   el ement s l et   s vg   =   " ht t p: / / www. w3. or g/ 2000/ s vg" ;

/ /   Cr eat e   t he   <s vg>   el ement ,	and   s pec i f y   pi xel	s i z e   and   us er c oor di nat es
l et   c har t   =   doc ument . c r eat eEl ement NS( s vg,	" s vg" ) ;

c har t . s et At t r i but e( " wi dt h" ,	wi dt h) ;
c har t . s et At t r i but e( " hei ght " ,	hei ght ) ;
c har t . s et At t r i but e( " vi ewBox" ,	` 0   0   ${ wi dt h}    ${ hei ght } ` ) ;


/ /   Def i ne t hes e
/ /   val ues

t he   t ext   s t yl es   we' l l	us e   f or   t he   c har t .	I f    we   l eave

uns et   her e,	t hey   c an   be   s et   wi t h   CSS   i ns t ead.

c har t . s et At t r i but e( " f ont - f ami l y" ,	" s ans - s er i f " ) ; c har t . s et At t r i but e( " f ont - s i z e" ,	" 18" ) ;


/ /   Get know  how
/ /   bi g

l abel s   and   val ues   as   ar r ays   and   add   up   t he   val ues   s o   we

t he   pi e   i s .



l et   l abel s
l et   val ues

=   Obj ec t . keys ( dat a) ;
=   Obj ec t . val ues ( dat a) ;

l et   t ot al	=   val ues . r educ e( ( x, y)    =>   x+y) ;

/ /   Fi gur e   out   t he   angl es   f or   al l	t he   s l i c es .	Sl i c e   i	s t ar t s   at angl es [ i ]
/ /   and   ends   at   angl es [ i +1] .	The   angl es   ar e   meas ur ed   i n r adi ans .
l et   angl es   =   [ 0] ;
val ues . f or Eac h( ( x,	i )    =>   angl es . pus h( angl es [ i ]    +   x/ t ot al	*   2   * Mat h. PI ) ) ;

/ /   Now  l oop   t hr ough   t he   s l i c es   of    t he   pi e val ues . f or Eac h( ( val ue,	i )    =>   {

/ / c i r c l e
/ / 12   o' c l oc k
/ /

Comput e   t he   t wo   poi nt s   wher e

Thes e   f or mul as   ar e   c hos en   s o

and   pos i t i ve   angl es   i nc r eas e

our   s l i c e   i nt er s ec t s   t he

t hat   an   angl e   of    0   i s   at

c l oc kwi s e.



l et   x1   =   c x   +   r l et   y1   =   c y   -    r l et   x2   =   c x   +   r
l et   y2   =   c y   -    r

*   Mat h. s i n( angl es [ i ] ) ; *   Mat h. c os ( angl es [ i ] ) ;
*   Mat h. s i n( angl es [ i +1] ) ;
*   Mat h. c os ( angl es [ i +1] ) ;



/ /   Thi s   i s   a   f l ag / /   I t   i s   r equi r ed

f or   angl es   l ar ger   t han by   t he   SVG  ar c   dr awi ng

a   hal f    c i r c l e c omponent

l et   bi g   =   ( angl es [ i +1]    -    angl es [ i ]    >   Mat h. PI )    ?   1   :	0;


/ /   Thi s   s t r i ng   des c r i bes   how  t o c har t :
l et   pat h   =   ` M${ c x} , ${ c y} `    + ` L ${ x1} , ${ y1} `    +
` A${ r } , ${ r }    0   ${ bi g}    1`    +

dr aw  a   s l i c e   of    t he   pi e

/ /   Move   t o   c i r c l e   c ent er . / /   Dr aw  l i ne   t o   ( x1, y1) . / /   Dr aw  an   ar c   of    r adi us

r . . .
` ${ x2} , ${ y2} `    +	/ /   . . . endi ng   at   t o ( x2, y2) .
" Z" ;	/ /   Cl os e   pat h   bac k   t o ( c x, c y) .


/ /   Comput e   t he   CSS   c ol or   f or wor ks   f or   onl y
/ /   about   15   c ol or s .	So   don' t i n   a   c har t .

t hi s   s l i c e.	Thi s   f or mul a

i nc l ude   mor e   t han   15   s l i c es

l et   c ol or   =   ` hs l ( ${ ( i *40) %360} , ${ 90- 3*i } %, ${ 50+2*i } %) ` ;

/ /   We   des c r i be   a   s l i c e   wi t h   a   <pat h>   el ement .	Not e c r eat eEl ement NS( ) .
l et   s l i c e   =   doc ument . c r eat eEl ement NS( s vg,	" pat h" ) ;

/ /   Now  s et   at t r i but es   on   t he   <pat h>   el ement
s l i c e. s et At t r i but e( " d" ,	pat h) ;	/ /   Set   t he   pat h f or   t hi s   s l i c e
s l i c e. s et At t r i but e( " f i l l " ,	c ol or ) ;	/ /   Set   s l i c e c ol or
s l i c e. s et At t r i but e( " s t r oke" ,	" bl ac k" ) ;	/ /   Out l i ne   s l i c e i n   bl ac k
s l i c e. s et At t r i but e( " s t r oke- wi dt h" ,	" 1" ) ;	/ /   1   CSS   pi xel t hi c k
c har t . append( s l i c e) ;	/ /   Add   s l i c e   t o c har t

/ /   Now  dr aw  a   l i t t l e   mat c hi ng   s quar e   f or   t he   key l et   i c on   =   doc ument . c r eat eEl ement NS( s vg,	" r ec t " ) ;
i c on. s et At t r i but e( " x" ,	l x) ;	/ /   Pos i t i on   t he s quar e
i c on. s et At t r i but e( " y" ,	l y   +   30*i ) ;
i c on. s et At t r i but e( " wi dt h" ,	20) ;	/ /   Si z e   t he s quar e
i c on. s et At t r i but e( " hei ght " ,	20) ;
i c on. s et At t r i but e( " f i l l " ,	c ol or ) ;	/ /   Same   f i l l c ol or   as   s l i c e
i c on. s et At t r i but e( " s t r oke" ,	" bl ac k" ) ;	/ /   Same   out l i ne, t oo.
i c on. s et At t r i but e( " s t r oke- wi dt h" ,	" 1" ) ;
c har t . append( i c on) ;	/ /   Add   t o   t he c har t

/ /   And   add   a   l abel	t o   t he   r i ght   of    t he   r ec t angl e
l et   l abel	=   doc ument . c r eat eEl ement NS( s vg,	" t ext " ) ;


l abel . s et At t r i but e( " x" , t ext
l abel . s et At t r i but e( " y" ,

l x   +   30) ;	/ /   Pos i t i on   t he

l y   +   30*i	+   16) ;

l abel . append( ` ${ l abel s [ i ] }    ${ val ue} ` ) ;	/ /   Add   t ext   t o l abel
c har t . append( l abel ) ;	/ /   Add   l abel	t o t he   c har t
} ) ;

r et ur n   c har t ; }

The pie chart in Figure 15-6 was created using the pi eChar t ( )  function from Example 15-4, like this:

doc ument . quer ySel ec t or ( " #c har t " ) . append( pi eChar t ( {
wi dt h:	640,	hei ght : 400,	/ /   Tot al	s i z e   of    t he   c har t
c x:	200,	c y:	200,	r :	180,	/ /   Cent er   and   r adi us   of    t he   pi e l x:	400,	l y:	10,                               / /   Pos i t i on   of    t he   l egend
dat a:	{	/ /   The   dat a   t o   c har t " J avaSc r i pt " :    71. 5,
" J ava" :	45. 4,
" Bas h/ Shel l " :	40. 4, " Pyt hon" :	37. 9,
" C#" :	35. 3, " PHP" :    31. 4, " C++" :    24. 6, " C" :    22. 1,
" TypeSc r i pt " :	18. 3, " Ruby" :	10. 3,
" Swi f t " :	8. 3,
" Obj ec t i ve- C" :	7. 3, " Go" :	7. 2,
} } ) ) ;


15.8 Graphics in a <canvas>

The <canvas > element has no appearance of its own but creates a

drawing surface within the document and exposes a powerful drawing API to client-side JavaScript. The main difference between the <canvas > API and SVG is that with the canvas you create drawings by calling methods, and with SVG you create drawings by building a tree of XML elements. These two approaches are equivalently powerful: either one can be simulated with the other. On the surface, they are quite different, however, and each has its strengths and weaknesses. An SVG drawing, for example, is easily edited by removing elements from its description. To remove an element from the same graphic in a <canvas >, it is often necessary to erase the drawing and redraw it from scratch. Since the Canvas drawing API is JavaScript-based and relatively compact (unlike the SVG grammar), it is documented in more detail in this book.



3D GRAPHICS IN A CANVAS

You can also call get Cont ext ( )  with the string “webgl” to obtain a context object that allows you to draw 3D graphics using the WebGL API. WebGL is a large, complicated, and low-level API that allows JavaScript programmers to access the GPU, write custom shaders, and perform other very powerful graphics operations. WebGL is not documented in this book, however: web developers are more likely to use utility libraries built on top of WebGL than to use the WebGL API directly.



Most of the Canvas drawing API is defined not on the <canvas > element itself, but instead on a “drawing context” object obtained with the get Cont ext ( )  method of the canvas. Call get Cont ext ( )  with the
argument “2d” to obtain a CanvasRenderingContext2D object that you can use to draw two-dimensional graphics into the canvas.


As a simple example of the Canvas API, the following HTML document uses <canvas > elements and some JavaScript to display two simple shapes:

<p>Thi s   i s   a   r ed   s quar e:	<c anvas   i d=" s quar e"   wi dt h=10   hei ght =10> </c anvas >.

<p>Thi s   i s   a   bl ue   c i r c l e:	<c anvas   i d=" c i r c l e"   wi dt h=10 hei ght =10></c anvas >.
<s c r i pt >
l et   c anvas   =   doc ument . quer ySel ec t or ( " #s quar e" ) ;	/ /   Get   f i r s t c anvas   el ement
l et   c ont ext   =   c anvas . get Cont ext ( " 2d" ) ;	/ /   Get   2D dr awi ng   c ont ext
c ont ext . f i l l St yl e   =   " #f 00" ;	/ /   Set   f i l l c ol or   t o   r ed
c ont ext . f i l l Rec t ( 0, 0, 10, 10) ;	/ /   Fi l l	a s quar e

c anvas   =   doc ument . quer ySel ec t or ( " #c i r c l e" ) ;	/ /   Sec ond c anvas   el ement
c ont ext   =   c anvas . get Cont ext ( " 2d" ) ;	/ /   Get   i t s c ont ext
c ont ext . begi nPat h( ) ;	/ /   Begi n   a   new " pat h"
c ont ext . ar c ( 5,	5,	5,	0,	2*Mat h. PI ,	t r ue) ;	/ /   Add   a   c i r c l e t o   t he   pat h
c ont ext . f i l l St yl e   =   " #00f " ;	/ /   Set   bl ue f i l l	c ol or
c ont ext . f i l l ( ) ;	/ /   Fi l l	t he pat h
</s c r i pt >

We’ve seen that SVG describes complex shapes as a “path” of lines and curves that can be drawn or filled. The Canvas API also uses the notion of a path. Instead of describing a path as a string of letters and numbers, a path is defined by a series of method calls, such as the begi nPat h( ) and ar c( )  invocations in the preceding code. Once a path is defined, other methods, such as f i l l ( ) , operate on that path. Various properties of the context object, such as f i l l St yl e, specify how these operations are performed.

The subsections that follow demonstrate the methods and properties of the 2D Canvas API. Much of the example code that follows operates on a variable c. This variable holds the CanvasRenderingContext2D object of

the canvas, but the code to initialize that variable is sometimes not shown. In order to make these examples run, you would need to add HTML markup to define a canvas with appropriate wi dt h and hei ght attributes, and then add code like this to initialize the variable c:


l et   c anvas   =   doc ument . quer ySel ec t or ( " #my_c anvas _i d" ) ; l et   c   =   c anvas . get Cont ext ( ' 2d' ) ;


15.8.1 Paths and Polygons

To draw lines on a canvas and to fill the areas enclosed by those lines, you begin by defining a path. A path is a sequence of one or more subpaths. A subpath is a sequence of two or more points connected by line segments (or, as we’ll see later, by curve segments). Begin a new path with the
begi nPat h( )  method. Begin a new subpath with the moveTo( ) method. Once you have established the starting point of a subpath with moveTo( ) , you can connect that point to a new point with a straight line by calling l i neTo( ) . The following code defines a path that includes two line segments:

c . begi nPat h( ) ;	/ /   St ar t   a   new  pat h
c . moveTo( 100,	100) ;	/ /   Begi n   a   s ubpat h   at   ( 100, 100)

c . l i neTo( 200,	200) ;
c . l i neTo( 100,	200) ;

/ /   Add   a   l i ne
/ /   Add   a   l i ne

f r om ( 100, 100)
f r om ( 200, 200)

t o   ( 200, 200)
t o   ( 100, 200)



This code simply defines a path; it does not draw anything on the canvas. To draw (or “stroke”) the two line segments in the path, call the
s t r oke( )  method, and to fill the area defined by those line segments, call f i l l ( ) :

c . f i l l ( ) ;	/ /   Fi l l	a   t r i angul ar   ar ea
c . s t r oke( ) ;	/ /   St r oke   t wo   s i des   of    t he   t r i angl e

This code (along with some additional code to set line widths and fill colors) produced the drawing shown in Figure 15-7.















Figure 15-7. A simple path, filled and stroked

Notice that the subpath defined in Figure 15-7 is “open.” It consists of just two line segments, and the end point is not connected back to the starting point. This means that it does not enclose a region. The f i l l ( )  method fills open subpaths by acting as if a straight line connected the last point in the subpath to the first point in the subpath. That is why this code fills a triangle, but strokes only two sides of the triangle.

If you wanted to stroke all three sides of the triangle just shown, you would call the cl os ePat h( )  method to connect the end point of the subpath to the start point. (You could also call l i neTo( 100, 100) , but then you end up with three line segments that share a start and end point but are not truly closed. When drawing with wide lines, the visual results are better if you use cl os ePat h( ) .)


There are two other important points to notice about s t r oke( )  and
f i l l ( ) . First, both methods operate on all subpaths in the current path. Suppose we had added another subpath in the preceding code:

c . moveTo( 300, 100) ;	/ /   Begi n   a   new  s ubpat h   at   ( 300, 100) ;

c . l i neTo( 300, 200) ;	/ /   Dr aw  a   ver t i c al	l i ne   down   t o   ( 300, 200) ;


If we then called s t r oke( ) , we would draw two connected edges of a triangle and a disconnected vertical line.

The second point to note about s t r oke( )  and f i l l ( )  is that neither one alters the current path: you can call f i l l ( )  and the path will still be there when you call s t r oke( ) . When you are done with a path and want to begin another, you must remember to call begi nPat h( ) . If you don’t, you’ll end up adding new subpaths to the existing path, and you may end up drawing those old subpaths over and over again.

Example 15-5 defines a function for drawing regular polygons and demonstrates the use of moveTo( ) , l i neTo( ) , and cl os ePat h( )  for defining subpaths and of f i l l ( )  and s t r oke( )  for drawing those paths. It produces the drawing shown in Figure 15-8.






















Figure 15-8. Regular polygons

Example 15-5. Regular polygons with moveTo(), lineTo(), and closePath()

/ /   Def i ne   a   r egul ar   pol ygon   wi t h   n   s i des ,	c ent er ed   at   ( x, y)    wi t h r adi us   r .
/ /   The   ver t i c es   ar e   equal l y   s pac ed   al ong   t he   c i r c umf er enc e   of    a c i r c l e.
/ /   Put   t he   f i r s t   ver t ex   s t r ai ght   up   or   at   t he   s pec i f i ed   angl e. / /   Rot at e   c l oc kwi s e,	unl es s   t he   l as t   ar gument   i s   t r ue.
f unc t i on   pol ygon( c ,	n,	x,	y,	r ,	angl e=0,	c ount er c l oc kwi s e=f al s e)    {
c . moveTo( x   +   r *Mat h. s i n( angl e) ,	/ /   Begi n   a   new  s ubpat h   at   t he f i r s t   ver t ex
y   -    r *Mat h. c os ( angl e) ) ;	/ /   Us e   t r i gonomet r y   t o c omput e   pos i t i on
l et   del t a   =   2*Mat h. PI / n;	/ /   Angul ar   di s t anc e   bet ween ver t i c es
f or ( l et   i	=   1;	i	<   n;	i ++)    {	/ /   For   eac h   of    t he   r emai ni ng ver t i c es
angl e   +=   c ount er c l oc kwi s e?- del t a: del t a;	/ /   Adj us t   angl e

c . l i neTo( x next   ver t ex
y

+   r *Mat h. s i n( angl e) ,	/ /   Add   l i ne   t o

-    r *Mat h. c os ( angl e) ) ;

}
c . c l os ePat h( ) ;	/ /   Connec t   l as t   ver t ex   bac k t o   t he   f i r s t
}

/ /   As s ume   t her e   i s   j us t   one   c anvas ,	and   get   i t s   c ont ext   obj ec t   t o dr aw  wi t h.
l et   c   =   doc ument . quer ySel ec t or ( " c anvas " ) . get Cont ext ( " 2d" ) ;

/ /   St ar t   a   new  pat h   and   add   pol ygon   s ubpat hs c . begi nPat h( ) ;
pol ygon( c ,	3,	50,	70,	50) ;	/ /   Tr i angl e pol ygon( c ,	4,	150,    60,    50,    Mat h. PI / 4) ;	/ /   Squar e pol ygon( c ,	5,	255,    55,    50) ;	/ /   Pent agon pol ygon( c ,	6,	365,    53,    50,    Mat h. PI / 6) ;	/ /   Hexagon
pol ygon( c ,	4,	365,	53,	20,	Mat h. PI / 4,	t r ue) ;	/ /   Smal l	s quar e i ns i de   t he   hexagon

/ /   Set   s ome   pr oper t i es   t hat   c ont r ol	how  t he   gr aphi c s   wi l l	l ook c . f i l l St yl e   =   " #c c c " ;	/ /   L i ght   gr ay   i nt er i or s
c . s t r okeSt yl e   =   " #008" ;	/ /   out l i ned   wi t h   dar k   bl ue   l i nes c . l i neWi dt h   =   5;	/ /   f i ve   pi xel s   wi de.

/ /   Now  dr aw  al l	t he   pol ygons   ( eac h   i n   i t s   own   s ubpat h)    wi t h   t hes e c al l s
c . f i l l ( ) ;	/ /   Fi l l	t he   s hapes

c . s t r oke( ) ;	/ /   And   s t r oke   t hei r   out l i nes

Notice that this example draws a hexagon with a square inside it. The square and the hexagon are separate subpaths, but they overlap. When this happens (or when a single subpath intersects itself), the canvas needs to be able to determine which regions are inside the path and which are outside. The canvas uses a test known as the “nonzero winding rule” to achieve this. In this case, the interior of the square is not filled because the square and the hexagon were drawn in the opposite directions: the vertices of the hexagon were connected with line segments moving clockwise around the circle. The vertices of the square were connected counterclockwise. Had the square been drawn clockwise as well, the call to f i l l ( )  would have filled the interior of the square as well.


15.8.2 Canvas Dimensions and Coordinates

The wi dt h and hei ght  attributes of the <canvas > element and the corresponding wi dt h and hei ght  properties of the Canvas object specify the dimensions of the canvas. The default canvas coordinate system places the origin (0,0) at the upper-left corner of the canvas. The x coordinates increase to the right and the y coordinates increase as you go down the screen. Points on the canvas can be specified using floating-point values.

The dimensions of a canvas cannot be altered without completely resetting the canvas. Setting either the wi dt h or hei ght  properties of a Canvas (even setting them to their current value) clears the canvas, erases the current path, and resets all graphics attributes (including current transformation and clipping region) to their original state.

The wi dt h and hei ght  attributes of a canvas specify the actual number

of pixels that the canvas can draw into. Four bytes of memory are allocated for each pixel, so if wi dt h and hei ght  are both set to 100, the canvas allocates 40,000 bytes to represent 10,000 pixels.

The wi dt h and hei ght  attributes also specify the default size (in CSS pixels) at which the canvas will be displayed on the screen. If
wi ndow. devi cePi xel Rat i o is 2, then 100 × 100 CSS pixels is actually 40,000 hardware pixels. When the contents of the canvas are drawn onto the screen, the 10,000 pixels in memory will need to be enlarged to cover 40,000 physical pixels on the screen, and this means that your graphics will not be as crisp as they could be.

For optimum image quality, you should not use the wi dt h and hei ght attributes to set the on-screen size of the canvas. Instead, set the desired on-screen size CSS pixel size of the canvas with CSS wi dt h and
hei ght  style attributes. Then, before you begin drawing in your JavaScript code, set the wi dt h and hei ght  properties of the canvas object to the number of CSS pixels times
wi ndow. devi cePi xel Rat i o. Continuing with the preceding example, this technique would result in the canvas being displayed at 100 × 100 CSS pixels but allocating memory for 200 × 200 pixels. (Even with this technique, the user can zoom in on the canvas and may see fuzzy or pixelated graphics if they do. This is in contrast to SVG graphics, which remain crisp no matter the on-screen size or zoom level.)


15.8.3 Graphics Attributes

Example 15-5 set the properties f i l l St yl e, s t r okeSt yl e, and
l i neWi dt h on the context object of the canvas. These properties are graphics attributes that specify the color to be used by f i l l ( )  and by

s t r oke( ) , and the width of the lines to be drawn by s t r oke( ) . Notice that these parameters are not passed to the f i l l ( )  and s t r oke( ) methods, but are instead part of the general graphics state of the canvas. If you define a method that draws a shape and do not set these properties yourself, the caller of your method can define the color of the shape by setting the s t r okeSt yl e and f i l l St yl e properties before calling your method. This separation of graphics state from drawing commands is fundamental to the Canvas API and is akin to the separation of presentation from content achieved by applying CSS stylesheets to HTML documents.

There are a number of properties (and also some methods) on the context object that affect the graphics state of the canvas. They are detailed below.

LINE STYLES

The l i neWi dt h property specifies how wide (in CSS pixels) the lines drawn by s t r oke( )  will be. The default value is 1. It is important to understand that line width is determined by the l i neWi dt h property at the time s t r oke( )  is called, not at the time that l i neTo( )  and other path-building methods are called. To fully understand the l i neWi dt h property, it is important to visualize paths as infinitely thin one-dimensional lines. The lines and curves drawn by the s t r oke( )  method are centered over the path, with half of the l i neWi dt h on either side. If you’re stroking a closed path and only want the line to appear outside the path, stroke the path first, then fill with an opaque color to hide the portion of the stroke that appears inside the path. Or if you only want the line to appear inside a closed path, call the s ave( )  and cl i p( )  methods first, then call s t r oke( )  and r es t or e( ) . (The s ave( ) , r es t or e( ) , and cl i p( )  methods are described later.)

When drawing lines that are more than about two pixels wide, the
l i neCap and l i neJ oi n properties can have a significant impact on the visual appearance of the ends of a path and the vertices at which two path segments meet. Figure 15-9 illustrates the values and resulting graphical appearance of l i neCap and l i neJ oi n.

























Figure 15-9. The lineCap and lineJoin attributes

The default value for l i neCap is “butt.” The default value for
l i neJ oi n is “miter.” Note, however, that if two lines meet at a very narrow angle, then the resulting miter can become quite long and visually distracting. If the miter at a given vertex would be longer than half of the line width times the mi t er Li mi t  property, that vertex will be drawn with a beveled join instead of a mitered join. The default value for
mi t er Li mi t  is 10.


The s t r oke( )  method can draw dashed and dotted lines as well as solid lines, and a canvas’s graphics state includes an array of numbers that

serves as a “dash pattern” by specifying how many pixels to draw, then how many to omit. Unlike other line-drawing properties, the dash pattern is set and queried with the methods s et Li neDas h( )  and
get Li neDas h( )  instead of with a property. To specify a dotted dash pattern, you might use s et Li neDas h( )  like this:

c . s et L i neDas h( [ 18,	3,	3,	3] ) ;	/ /   18px   das h,	3px   s pac e,	3px   dot , 3px   s pac e


Finally, the l i neDas hOf f s et  property specifies how far into the dash pattern drawing should begin. The default is 0. Paths stroked with the dash pattern shown here begin with an 18-pixel dash, but if
l i neDas hOf f s et  is set to 21, then that same path would begin with a dot followed by a space and a dash.

COLORS, PATTERNS, AND GRADIENTS

The f i l l St yl e and s t r okeSt yl e properties specify how paths are filled and stroked. The word “style” often means color, but these properties can also be used to specify a color gradient or an image to be used for filling and stroking. (Note that drawing a line is basically the same as filling a narrow region on both sides of the line, and filling and stroking are fundamentally the same operation.)

If you want to fill or stroke with a solid color (or a translucent color), simply set these properties to a valid CSS color string. Nothing else is required.


To fill (or stroke) with a color gradient, set f i l l St yl e (or s t r okeSt yl e) to a CanvasGradient object returned by the
cr eat eLi near Gr adi ent ( )  or cr eat eRadi al Gr adi ent ( )

methods of the context. The arguments to
cr eat eLi near Gr adi ent ( )  are the coordinates of two points that define a line (it does not need to be horizontal or vertical) along which the colors will vary. The arguments to cr eat eRadi al Gr adi ent ( ) specify the centers and radii of two circles. (They need not be concentric, but the first circle typically lies entirely inside the second.) Areas inside
the smaller circle or outside the larger will be filled with solid colors; areas between the two will be filled with a color gradient.

After creating the CanvasGradient object that defines the regions of the canvas that will be filled, you must define the gradient colors by calling the addCol or St op( )  method of the CanvasGradient. The first argument to this method is a number between 0.0 and 1.0. The second argument is a CSS color specification. You must call this method at least twice to define a simple color gradient, but you may call it more than that. The color at 0.0 will appear at the start of the gradient, and the color at 1.0 will appear at the end. If you specify additional colors, they will appear at the specified fractional position within the gradient. Between the points you specify, colors will be smoothly interpolated. Here are some examples:

/ /   A  l i near   gr adi ent ,	di agonal l y   ac r os s   t he   c anvas   ( as s umi ng   no t r ans f or ms )
l et   bgf ade   =
c . c r eat eL i near Gr adi ent ( 0, 0, c anvas . wi dt h, c anvas . hei ght ) ;
bgf ade. addCol or St op( 0. 0,	" #88f " ) ;	/ /   St ar t   wi t h   l i ght   bl ue   i n upper   l ef t
bgf ade. addCol or St op( 1. 0,	" #f f f " ) ;	/ /   Fade   t o   whi t e   i n   l ower r i ght

/ /   A  gr adi ent   bet ween   t wo   c onc ent r i c   c i r c l es .	Tr ans par ent   i n   t he mi ddl e
/ /   f adi ng   t o   t r ans l uc ent   gr ay   and   t hen   bac k   t o   t r ans par ent .
l et   donut   =   c . c r eat eRadi al Gr adi ent ( 300, 300, 100,	300, 300, 300) ;
donut . addCol or St op( 0. 0,	" t r ans par ent " ) ;	/ /   Tr ans par ent


donut . addCol or St op( 0. 7, gr ay
donut . addCol or St op( 1. 0, agai n

" r gba( 100, 100, 100, . 9) " ) ;

" r gba( 0, 0, 0, 0) " ) ;

/ /   Tr ans l uc ent

/ /   Tr ans par ent



An important point to understand about gradients is that they are not position-independent. When you create a gradient, you specify bounds for the gradient. If you then attempt to fill an area outside of those bounds, you’ll get the solid color defined at one end or the other of the gradient.


In addition to colors and color gradients, you can also fill and stroke using images. To do this, set f i l l St yl e or s t r okeSt yl e to a CanvasPattern returned by the cr eat ePat t er n( )  method of the context object. The first argument to this method should be an <i mg> or <canvas > element that contains the image you want to fill or stroke with. (Note that the source image or canvas does not need to be inserted into the document in order to be used in this way.) The second argument to cr eat ePat t er n( )  is the string “repeat,” “repeat-x,” “repeat-y,” or
“no-repeat,” which specifies whether (and in which dimensions) the background images repeat.

TEXT STYLES

The f ont  property specifies the font to be used by the text-drawing methods f i l l Text ( )  and s t r okeText ( )  (see “Text”). The value of the f ont  property should be a string in the same syntax as the CSS f ont attribute.

The t ext Al i gn property specifies how the text should be horizontally aligned with respect to the X coordinate passed to f i l l Text ( )  or
s t r okeText ( ) . Legal values are “start,” “left,” “center,” “right,” and “end.” The default is “start,” which, for left-to-right text, has the same

meaning as “left.”


The t ext Bas el i ne property specifies how the text should be vertically aligned with respect to the y coordinate. The default value is “alphabetic,” and it is appropriate for Latin and similar scripts. The value “ideographic” is intended for use with scripts such as Chinese and Japanese. The value “hanging” is intended for use with Devanagari and similar scripts (which are used for many of the languages of India). The “top,” “middle,” and “bottom” baselines are purely geometric baselines, based on the “em square” of the font.

SHADOWS

Four properties of the context object control the drawing of drop shadows. If you set these properties appropriately, any line, area, text, or image you draw will be given a shadow, which will make it appear as if it is floating above the canvas surface.


The s hadowCol or  property specifies the color of the shadow. The default is fully transparent black, and shadows will never appear unless you set this property to a translucent or opaque color. This property can only be set to a color string: patterns and gradients are not allowed for shadows. Using a translucent shadow color produces the most realistic shadow effects because it allows the background to show through.

The s hadowOf f s et X and s hadowOf f s et Y properties specify the X and Y offsets of the shadow. The default for both properties is 0, which places the shadow directly beneath your drawing, where it is not visible. If you set both properties to a positive value, shadows will appear below and to the right of what you draw, as if there were a light source above and to the left, shining onto the canvas from outside the computer screen. Larger

offsets produce larger shadows and make drawn objects appear as if they are floating “higher” above the canvas. These values are not affected by coordinate transformations (§15.8.5): shadow direction and “height” remain consistent even when shapes are rotated and scaled.


The s hadowBl ur  property specifies how blurred the edges of the shadow are. The default value is 0, which produces crisp, unblurred shadows. Larger values produce more blur, up to an implementation-defined upper bound.

TRANSLUCENCY AND COMPOSITING

If you want to stroke or fill a path using a translucent color, you can set
s t r okeSt yl e or f i l l St yl e using a CSS color syntax like “rgba(…)” that supports alpha transparency. The “a” in “RGBA” stands for “alpha” and is a value between 0 (fully transparent) and 1 (fully opaque). But the Canvas API provides another way to work with translucent colors. If you do not want to explicitly specify an alpha channel for each color, or if you want to add translucency to opaque images or patterns, you can set the
gl obal Al pha property. Every pixel you draw will have its alpha value multiplied by gl obal Al pha. The default is 1, which adds no transparency. If you set gl obal Al pha to 0, everything you draw will be fully transparent, and nothing will appear in the canvas. But if you set this property to 0.5, then pixels that would otherwise have been opaque will be 50% opaque, and pixels that would have been 50% opaque will be 25% opaque instead.

When you stroke lines, fill regions, draw text, or copy images, you generally expect the new pixels to be drawn on top of the pixels that are already in the canvas. If you are drawing opaque pixels, they simply replace the pixels that are already there. If you are drawing with

translucent pixels, the new (“source”) pixel is combined with the old (“destination”) pixel so that the old pixel shows through the new pixel based on how transparent that pixel is.


This process of combining new (possibly translucent) source pixels with existing (possibly translucent) destination pixels is called compositing, and the compositing process described previously is the default way that the Canvas API combines pixels. But you can set the
gl obal Compos i t eOper at i on property to specify other ways of combining pixels. The default value is “source-over,” which means that source pixels are drawn “over” the destination pixels and are combined with them if the source is translucent. But if you set
gl obal Compos i t eOper at i on to “destination-over”, then the canvas will combine pixels as if the new source pixels were drawn beneath the existing destination pixels. If the destination is translucent or transparent, some or all of the source pixel color is visible in the resulting color. As another example, the compositing mode “source-atop” combines the source pixels with the transparency of the destination pixels so that nothing is drawn on portions of the canvas that are already fully transparent. There are a number of legal values for
gl obal Compos i t eOper at i on, but most have only specialized uses and are not covered here.

SAVING AND RESTORING GRAPHICS STATE

Since the Canvas API defines graphics attributes on the context object, you might be tempted to call get Cont ext ( )  multiple times to obtain multiple context objects. If you could do this, you could define different attributes on each context: each context would then be like a different brush and would paint with a different color or draw lines of different

widths. Unfortunately, you cannot use the canvas in this way. Each <canvas > element has only a single context object, and every call to get Cont ext ( )  returns the same CanvasRenderingContext2D object.


Although the Canvas API only allows you to define a single set of graphics attributes at a time, it does allow you to save the current graphics state so that you can alter it and then easily restore it later. The s ave( ) method pushes the current graphics state onto a stack of saved states. The r es t or e( )  method pops the stack and restores the most recently saved state. All of the properties that have been described in this section are part of the saved state, as are the current transformation and clipping region (both of which are explained later). Importantly, the currently defined path and the current point are not part of the graphics state and cannot be saved and restored.


15.8.4 Canvas Drawing Operations

We’ve already seen some basic canvas methods—begi nPat h( ) , moveTo( ) , l i neTo( ) , cl os ePat h( ) , f i l l ( ) , and s t r oke( ) — for defining, filling, and drawing lines and polygons. But the Canvas API includes other drawing methods as well.

RECTANGLES

CanvasRenderingContext2D defines four methods for drawing rectangles. All four of these rectangle methods expect two arguments that specify one corner of the rectangle followed by the rectangle width and height. Normally, you specify the upper-left corner and then pass a positive width and positive height, but you may also specify other corners and pass negative dimensions.

f i l l Rect ( )  fills the specified rectangle with the current f i l l St yl e. s t r okeRect ( )  strokes the outline of the specified rectangle using the current s t r okeSt yl e and other line attributes. cl ear Rect ( )  is like f i l l Rect ( ) , but it ignores the current fill style and fills the rectangle with transparent black pixels (the default color of all blank canvases). The important thing about these three methods is that they do not affect the current path or the current point within that path.

The final rectangle method is named r ect ( ) , and it does affect the current path: it adds the specified rectangle, in a subpath of its own, to the path. Like other path-definition methods, it does not fill or stroke anything itself.

CURVES

A path is a sequence of subpaths, and a subpath is a sequence of connected points. In the paths we defined in §15.8.1, those points were connected with straight line segments, but that need not always be the case. The CanvasRenderingContext2D object defines a number of methods that add a new point to the subpath and connect the current point to that new point with a curve:


ar c ( )

This method adds a circle, or a portion of a circle (an arc), to the path. The arc to be drawn is specified with six parameters: the x and y coordinates of the center of a circle, the radius of the circle, the start and end angles of the arc, and the direction (clockwise or counterclockwise) of the arc between those two angles. If there is a current point in the path, then this method connects the current point to the beginning of the arc with a straight line (which is useful when drawing wedges or pie slices), then connects the beginning of the arc to the end of the arc with a portion of a circle, leaving the end of the

arc as the new current point. If there is no current point when this method is called, then it only adds the circular arc to the path.

el l i ps e( )

This method is much like ar c( )  except that it adds an ellipse or a portion of an ellipse to the path. Instead of one radius, it has two: an x-axis radius and a y-axis radius. Also, because ellipses are not radially symmetrical, this method takes another argument that specifies the number of radians by which the ellipse is rotated clockwise about its center.

ar c To( )

This method draws a straight line and a circular arc just like the ar c( )  method does, but it specifies the arc to be drawn using
different parameters. The arguments to ar cTo( )  specify points P1 and P2 and a radius. The arc that is added to the path has the specified radius. It begins at the tangent point with the (imaginary) line from the current point to P1 and ends at the tangent point with the (imaginary) line between P1 and P2. This unusual-seeming method of specifying arcs is actually quite useful for drawing shapes with rounded corners. If you specify a radius of 0, this method just draws a straight line from the current point to P1. With a nonzero radius, however, it draws a straight line from the current point in the direction of P1, then curves that line around in a circle until it is heading in the direction of P2.


bez i er Cur veTo( )

This method adds a new point P to the subpath and connects it to the current point with a cubic Bezier curve. The shape of the curve is specified by two “control points,” C1 and C2. At the start of the curve (at the current point), the curve heads in the direction of C1. At the end of the curve (at point P), the curve arrives from the direction of C2. In between these points, the direction of the curve varies smoothly. The point P becomes the new current point for the subpath.


quadr at i c Cur veTo( )

This method is like bez i er Cur veTo( ) , but it uses a quadratic Bezier curve instead of a cubic Bezier curve and has only a single control point.


You can use these methods to draw paths like those in Figure 15-10.














Figure 15-10. Curved paths in a canvas

Example 15-6 shows the code used to create Figure 15-10. The methods demonstrated in this code are some of the most complicated in the Canvas API; consult an online reference for complete details on the methods and their arguments.

Example 15-6. Adding curves to a path
/ /   A  ut i l i t y   f unc t i on   t o   c onver t   angl es   f r om degr ees   t o   r adi ans f unc t i on   r ads ( x)    {    r et ur n   Mat h. PI *x/ 180;	}

/ /   Get   t he   c ont ext   obj ec t   of    t he   doc ument ' s   c anvas   el ement l et   c   =   doc ument . quer ySel ec t or ( " c anvas " ) . get Cont ext ( " 2d" ) ;

/ /   Def i ne   s ome   gr aphi c s   at t r i but es   and   dr aw  t he   c ur ves c . f i l l St yl e   =   " #aaa" ;	/ /   Gr ay   f i l l s
c . l i neWi dt h   =   2;	/ /   2- pi xel	bl ac k   ( by   def aul t )    l i nes


/ /   Dr aw  a   c i r c l e.
/ /   Ther e   i s   no   c ur r ent   poi nt ,	s o   dr aw  j us t   t he s t r ai ght
/ /   l i ne   f r om t he   c ur r ent   poi nt   t o   t he   s t ar t   of


c i r c l e   wi t h   no

t he   c i r c l e.

c . begi nPat h( ) ;
c . ar c ( 75, 100, 50,	/ /   Cent er   at   ( 75, 100) ,	r adi us   50
0, r ads ( 360) , f al s e) ;	/ /   Go   c l oc kwi s e   f r om 0   t o   360   degr ees c . f i l l ( ) ;	/ /   Fi l l	t he   c i r c l e
c . s t r oke( ) ;	/ /   St r oke   i t s   out l i ne.

/ /   Now  dr aw  an   el l i ps e   i n   t he   s ame   way
c . begi nPat h( ) ;	/ /   St ar t   new  pat h   not   c onnec t ed   t o   t he c i r c l e
c . el l i ps e( 200,	100,	50,	35,	r ads ( 15) ,	/ /   Cent er ,	r adi i ,	and r ot at i on
0,	r ads ( 360) ,	f al s e) ;	/ /   St ar t   angl e,	end   angl e, di r ec t i on


/ /   Dr aw  a   wedge.	Angl es axi s .
/ /   Not e   t hat   ar c ( )    adds s t ar t .

ar e   meas ur ed   c l oc kwi s e   f r om t he   pos i t i ve   x

a   l i ne   f r om t he   c ur r ent   poi nt   t o   t he   ar c

c . moveTo( 325,	100) ;	/ /   St ar t   at   t he   c ent er   of    t he   c i r c l e. c . ar c ( 325,	100,	50,	/ /   Ci r c l e   c ent er   and   r adi us
r ads ( - 60) ,	r ads ( 0) ,	/ /   St ar t   at   angl e   - 60   and   go   t o   angl e   0 t r ue) ;                                       / /   c ount er c l oc kwi s e
c . c l os ePat h( ) ;	/ /   Add   r adi us   bac k   t o   t he   c ent er   of    t he c i r c l e

/ /   Si mi l ar   wedge,	of f s et   a   bi t ,	and   i n   t he   oppos i t e   di r ec t i on c . moveTo( 340,	92) ;
c . ar c ( 340,	92,	42,	r ads ( - 60) ,	r ads ( 0) ,	f al s e) ; c . c l os ePat h( ) ;

/ /   Us e   ar c To( )    f or   r ounded   c or ner s .	Her e   we   dr aw  a   s quar e   wi t h / /   upper   l ef t   c or ner   at   ( 400, 50)    and   c or ner s   of    var yi ng   r adi i . c . moveTo( 450,	50) ;	/ /   Begi n   i n   t he   mi ddl e   of    t he   t op edge.
c . ar c To( 500, 50, 500, 150, 30) ;	/ /   Add   par t   of    t op   edge   and   upper r i ght   c or ner .
c . ar c To( 500, 150, 400, 150, 20) ;	/ /   Add   r i ght   edge   and   l ower   r i ght c or ner .
c . ar c To( 400, 150, 400, 50, 10) ;	/ /   Add   bot t om edge   and   l ower   l ef t c or ner .
c . ar c To( 400, 50, 500, 50, 0) ;	/ /   Add   l ef t   edge   and   upper   l ef t c or ner .
c . c l os ePat h( ) ;	/ /   Cl os e   pat h   t o   add   t he   r es t   of    t he t op   edge.

/ /   Quadr at i c   Bez i er   c ur ve:	one   c ont r ol	poi nt
c . moveTo( 525,	125) ;	/ /   Begi n   her e
c . quadr at i c Cur veTo( 550,	75,	625,	125) ;	/ /   Dr aw  a   c ur ve   t o   ( 625, 125)
c . f i l l Rec t ( 550- 3,	75- 3,	6,	6) ;	/ /   Mar k   t he   c ont r ol	poi nt ( 550, 75)

/ /   Cubi c   Bez i er   c ur ve
c . moveTo( 625,	100) ;	/ /   St ar t   at   ( 625,	100) c . bez i er Cur veTo( 645, 70, 705, 130, 725, 100) ;	/ /   Cur ve   t o   ( 725,	100) c . f i l l Rec t ( 645- 3,	70- 3,    6,    6) ;	/ /   Mar k   c ont r ol	poi nt s c . f i l l Rec t ( 705- 3,	130- 3,    6,    6) ;

/ /   Fi nal l y,	f i l l	t he   c ur ves   and   s t r oke   t hei r   out l i nes . c . f i l l ( ) ;
c . s t r oke( ) ;

TEXT

To draw text in a canvas, you normally use the f i l l Text ( )  method, which draws text using the color (or gradient or pattern) specified by the f i l l St yl e property. For special effects at large text sizes, you can use s t r okeText ( )  to draw the outline of the individual font glyphs. Both
methods take the text to be drawn as their first argument and take the x and y coordinates of the text as the second and third arguments. Neither method affects the current path or the current point.


f i l l Text ( )  and s t r okeText ( )  take an optional fourth argument. If given, this argument specifies the maximum width of the text to be displayed. If the text would be wider than the specified value when drawn using the f ont  property, the canvas will make it fit by scaling it or by using a narrower or smaller font.

If you need to measure text yourself before drawing it, pass it to the
meas ur eText ( )  method. This method returns a TextMetrics object that specifies the measurements of the text when drawn with the current f ont .

At the time of this writing, the only “metric” contained in the
Text Met r i cs  object is the width. Query the on-screen width of a string like this:

l et   wi dt h   =   c . meas ur eText ( t ext ) . wi dt h;


This is useful if you want to center a string of text within a canvas, for example.

IMAGES

In addition to vector graphics (paths, lines, etc.), the Canvas API also supports bitmap images. The dr awI mage( )  method copies the pixels of a source image (or of a rectangle within the source image) onto the canvas, scaling and rotating the pixels of the image as necessary.

dr awI mage( )  can be invoked with three, five, or nine arguments. In all cases, the first argument is the source image from which pixels are to be copied. This image argument is often an <i mg> element, but it can also be another <canvas > element or even a <vi deo> element (from which a single frame will be copied). If you specify an <i mg> or <vi deo> element that is still loading its data, the dr awI mage( )  call will do nothing.

In the three-argument version of dr awI mage( ) , the second and third arguments specify the x and y coordinates at which the upper-left corner of the image is to be drawn. In this version of the method, the entire source image is copied to the canvas. The x and y coordinates are interpreted in the current coordinate system, and the image is scaled and rotated if necessary, depending on the canvas transform currently in effect.

The five-argument version of dr awI mage( )  adds wi dt h and hei ght arguments to the x and y arguments described earlier. These four arguments define a destination rectangle within the canvas. The upper-left corner of the source image goes at ( x, y) , and the lower-right corner goes at ( x+wi dt h,	y+hei ght ) . Again, the entire source image is copied. With this version of the method, the source image will be scaled to fit the destination rectangle.

The nine-argument version of dr awI mage( )  specifies both a source rectangle and a destination rectangle and copies only the pixels within the source rectangle. Arguments two through five specify the source rectangle. They are measured in CSS pixels. If the source image is another canvas, the source rectangle uses the default coordinate system for that canvas and ignores any transformations that have been specified. Arguments six through nine specify the destination rectangle into which the image is drawn and are in the current coordinate system of the canvas, not in the default coordinate system.

In addition to drawing images into a canvas, we can also extract the content of a canvas as an image using the t oDat aURL( )  method. Unlike all the other methods described here, t oDat aURL( )  is a method of the Canvas element itself, not of the context object. You normally invoke
t oDat aURL( )  with no arguments, and it returns the content of the canvas as a PNG image, encoded as a string using a dat a:  URL. The returned URL is suitable for use with an <i mg> element, and you can make a static snapshot of a canvas with code like this:

l et   i mg   =   doc ument . c r eat eEl ement ( " i mg" ) ;	/ /   Cr eat e   an   <i mg> el ement
i mg. s r c   =   c anvas . t oDat aURL ( ) ;	/ /   Set   i t s   s r c at t r i but e

doc ument . body. appendChi l d( i mg) ;	/ /   Append   i t   t o   t he doc ument


15.8.5 Coordinate System Transforms

As we’ve noted, the default coordinate system of a canvas places the origin in the upper-left corner, has x coordinates increasing to the right, and has y coordinates increasing downward. In this default system, the coordinates of a point map directly to a CSS pixel (which then maps directly to one or more device pixels). Certain canvas operations and attributes (such as extracting raw pixel values and setting shadow offsets) always use this default coordinate system. In addition to the default coordinate system, however, every canvas has a “current transformation matrix” as part of its graphics state. This matrix defines the current coordinate system of the canvas. In most canvas operations, when you specify the coordinates of a point, it is taken to be a point in the current coordinate system, not in the default coordinate system. The current transformation matrix is used to convert the coordinates you specified to the equivalent coordinates in the default coordinate system.


The s et Tr ans f or m( )  method allows you to set a canvas’s transformation matrix directly, but coordinate system transformations are usually easier to specify as a sequence of translations, rotations, and scaling operations. Figure 15-11 illustrates these operations and their effect on the canvas coordinate system. The program that produced the figure drew the same set of axes seven times in a row. The only thing that changed each time was the current transform. Notice that the transforms affect the text as well as the lines that are drawn.


Figure 15-11. Coordinate system transformations

The t r ans l at e( )  method simply moves the origin of the coordinate system left, right, up, or down. The r ot at e( )  method rotates the axes clockwise by the specified angle. (The Canvas API always specifies angles in radians. To convert degrees to radians, divide by 180 and multiply by Mat h. PI .) The s cal e( )  method stretches or contracts distances along the x or y axes.

Passing a negative scale factor to the s cal e( )  method flips that axis across the origin, as if it were reflected in a mirror. This is what was done in the lower left of Figure 15-11: t r ans l at e( )  was used to move the origin to the bottom-left corner of the canvas, then s cal e( )  was used to flip the y axis around so that y coordinates increase as we go up the page. A flipped coordinate system like this is familiar from algebra class and may be useful for plotting data points on charts. Note, however, that it makes text difficult to read!

UNDERSTANDING TRANSFORMATIONS MATHEMATICALLY

I find it easiest to understand transforms geometrically, thinking about
t r ans l at e( ) , r ot at e( ) , and s cal e( )  as transforming the axes of the coordinate system as illustrated in Figure 15-11. It is also possible to understand transforms algebraically as equations that map the coordinates of a point ( x, y)  in the transformed coordinate system back to the coordinates ( x' , y' )  of the same point in the previous coordinate system.

The method call c. t r ans l at e( dx, dy)  can be described with these equations:

x'	=   x   +   dx;	/ /   An   X   c oor di nat e   of    0   i n   t he   new  s ys t em i s   dx   i n t he   ol d
y'	=   y   +   dy;


Scaling operations have similarly simple equations. A call c. s cal e( s x, s y)  can be described like this:

x'    =   s x   *   x; y'    =   s y   *   y;


Rotations are more complicated. The call c. r ot at e( a)  is described by these trigonometric equations:


x'    =   x   *   c os ( a) y'    =   y   *   c os ( a)

-    y   *   s i n( a) ; +   x   *   s i n( a) ;



Notice that the order of transformations matters. Suppose we start with the default coordinate system of a canvas, then translate it, and then scale it. In order to map the point ( x, y)  in the current coordinate system back to the point ( x' ' , y' ' )  in the default coordinate system, we must first apply the scaling equations to map the point to an intermediate point ( x' , y' ) in the translated but unscaled coordinate system, then use the translation equations to map from this intermediate point to ( x' ' , y' ' ) . The result is this:

x' '    =   s x*x   +   dx; y' '    =   s y*y   +   dy;


If, on the other hand, we’d called s cal e( )  before calling
t r ans l at e( ) , the resulting equations would be different:


x' '    =   s x*( x   +   dx) ; y' '    =   s y*( y   +   dy) ;

The key thing to remember when thinking algebraically about sequences of transformations is that you must work backward from the last (most recent) transformation to the first. When thinking geometrically about transformed axes, however, you work forward from first transformation to last.


The transformations supported by the canvas are known as affine transforms. Affine transforms may modify the distances between points and the angles between lines, but parallel lines always remain parallel after an affine transformation—it is not possible, for example, to specify a fish-eye lens distortion with an affine transform. An arbitrary affine transform can be described by the six parameters a through f  in these equations:

x'    =   ax   +   c y   +   e y'    =   bx   +   dy   +   f


You can apply an arbitrary transformation to the current coordinate system by passing those six parameters to the t r ans f or m( )  method. Figure 15-11 illustrates two types of transformations—shears and rotations about a specified point—that you can implement with the t r ans f or m( )  method like this:

/ /   Shear   t r ans f or m: / /	x'	=   x   +   kx*y; / /	y'	=   ky*x   +   y;
f unc t i on   s hear ( c ,	kx,	ky)    {    c . t r ans f or m( 1,	ky,	kx,	1,	0,	0) ;	}

/ /   Rot at e   t het a   r adi ans   c ount er c l oc kwi s e   ar ound   t he   poi nt   ( x, y) / /   Thi s   c an   al s o   be   ac c ompl i s hed   wi t h   a   t r ans l at e,	r ot at e,
t r ans l at e   s equenc e
f unc t i on   r ot at eAbout ( c ,	t het a,	x,	y)    {
l et   c t   =   Mat h. c os ( t het a) ; l et   s t   =   Mat h. s i n( t het a) ;
c . t r ans f or m( c t ,	- s t ,	s t ,	c t ,	- x*c t - y*s t +x,	x*s t - y*c t +y) ; }

The s et Tr ans f or m( )  method takes the same arguments as
t r ans f or m( ) , but instead of transforming the current coordinate system, it ignores the current system, transforms the default coordinate system, and makes the result the new current coordinate system.
s et Tr ans f or m( )  is useful to temporarily reset the canvas to its default coordinate system:

c . s ave( ) ;	/ /   Save   c ur r ent   c oor di nat e   s ys t em c . s et Tr ans f or m( 1, 0, 0, 1, 0, 0) ;	/ /   Rever t   t o   t he   def aul t
c oor di nat e   s ys t em
/ /   Per f or m oper at i ons   us i ng   def aul t   CSS   pi xel	c oor di nat es
c . r es t or e( ) ;	/ /   Res t or e   t he   s aved   c oor di nat e s ys t em

TRANSFORMATION EXAMPLE

Example 15-7 demonstrates the power of coordinate system transformations by using the t r ans l at e( ) , r ot at e( ) , and s cal e( ) methods recursively to draw a Koch snowflake fractal. The output of this example appears in Figure 15-12, which shows Koch snowflakes with 0, 1, 2, 3, and 4 levels of recursion.












Figure 15-12. Koch snowflakes

The code that produces these figures is elegant, but its use of recursive coordinate system transformations makes it somewhat difficult to understand. Even if you don’t follow all the nuances, note that the code

includes only a single invocation of the l i neTo( )  method. Every single line segment in Figure 15-12 is drawn like this:

c . l i neTo( l en,	0) ;


The value of the variable l en does not change during the execution of the program, so the position, orientation, and length of each of the line segments is determined by translations, rotations, and scaling operations.

Example 15-7. A Koch snowflake with transformations
l et   deg   =   Mat h. PI / 180;	/ /   For   c onver t i ng   degr ees   t o   r adi ans


/ /   Dr aw  a   l evel - n   Koc h   s nowf l ake   f r ac t al    on / /   wi t h   l ower - l ef t   c or ner   at   ( x, y)    and   s i de

t he   c anvas   c ont ext   c , l engt h   l en.

f unc t i on   s nowf l ake( c ,	n,	x,	y,	l en)    {
c . s ave( ) ;	/ /   Save   c ur r ent   t r ans f or mat i on
c . t r ans l at e( x, y) ;	/ /   Tr ans l at e   or i gi n   t o   s t ar t i ng   poi nt
c . moveTo( 0, 0) ;	/ /   Begi n   a   new  s ubpat h   at   t he   new  or i gi n l eg( n) ;	/ /   Dr aw  t he   f i r s t   l eg   of    t he   s nowf l ake
c . r ot at e( - 120*deg) ;	/ /   Now  r ot at e   120   degr ees   c ount er c l oc kwi s e l eg( n) ;	/ /   Dr aw  t he   s ec ond   l eg
c . r ot at e( - 120*deg) ;	/ /   Rot at e   agai n
l eg( n) ;	/ /   Dr aw  t he   f i nal	l eg c . c l os ePat h( ) ;	/ /   Cl os e   t he   s ubpat h
c . r es t or e( ) ;	/ /   And   r es t or e   or i gi nal	t r ans f or mat i on

/ /   Dr aw  a   s i ngl e   l eg   of    a   l evel - n   Koc h   s nowf l ake.
/ /   Thi s   f unc t i on   l eaves   t he   c ur r ent   poi nt   at   t he   end   of    t he l eg   i t   has
/ /   dr awn   and   t r ans l at es   t he   c oor di nat e   s ys t em s o   t he   c ur r ent poi nt   i s   ( 0, 0) .
/ /   Thi s   means   you   c an   eas i l y   c al l	r ot at e( )    af t er   dr awi ng   a l eg.
f unc t i on   l eg( n)    {
c . s ave( ) ;	/ /   Save   t he   c ur r ent   t r ans f or mat i on i f    ( n   ===   0)    {	/ /   Nonr ec ur s i ve   c as e:

c . l i neTo( l en,	0) ; }
_	_

/ /	J us t   dr aw  a   hor i z ont al	l i ne
/ /

el s e   {	/ /   Rec ur s i ve   c as e:	dr aw  4   s ub- l egs

l i ke:	\ /
c . s c al e( 1/ 3, 1/ 3) ;	/ /   Sub- l egs   ar e   1/ 3   t he   s i z e   of t hi s   l eg
l eg( n- 1) ;	/ /   Rec ur s e   f or   t he   f i r s t   s ub- l eg c . r ot at e( 60*deg) ;	/ /   Tur n   60   degr ees   c l oc kwi s e
l eg( n- 1) ;	/ /   Sec ond   s ub- l eg
c . r ot at e( - 120*deg) ;	/ /   Rot at e   120   degr ees   bac k l eg( n- 1) ;	/ /   Thi r d   s ub- l eg
c . r ot at e( 60*deg) ;	/ /   Rot at e   bac k   t o   our   or i gi nal headi ng
l eg( n- 1) ;	/ /   Fi nal	s ub- l eg }
c . r es t or e( ) ;	/ /   Res t or e   t he   t r ans f or mat i on
c . t r ans l at e( l en,	0) ;	/ /   But   t r ans l at e   t o   make   end   of l eg   ( 0, 0)
} }

l et   c   =   doc ument . quer ySel ec t or ( " c anvas " ) . get Cont ext ( " 2d" ) ;
s nowf l ake( c ,	0,	25,	125,	125) ;	/ /   A  l evel - 0   s nowf l ake   i s   a t r i angl e
s nowf l ake( c ,	1,	175,	125,	125) ;	/ /   A  l evel - 1   s nowf l ake   i s   a   6-s i ded   s t ar

s nowf l ake( c ,    2, s nowf l ake( c ,    3,
s nowf l ake( c ,	4,

325,    125, 475,    125,
625,	125,

125) ;	/ / 125) ;
125) ;	/ /

et c .


A  l evel - 4   s nowf l ake   l ooks   l i ke

a   s nowf l ake!
c . s t r oke( ) ;	/ /   St r oke   t hi s   ver y   c ompl i c at ed pat h


15.8.6 Clipping

After defining a path, you usually call s t r oke( )  or f i l l ( )  (or both). You can also call the cl i p( )  method to define a clipping region. Once a clipping region is defined, nothing will be drawn outside of it. Figure 15-13 shows a complex drawing produced using clipping regions. The vertical stripe running down the middle and the text along the bottom of the figure were stroked with no clipping region and then filled after the triangular clipping region was defined.











































Figure 15-13. Unclipped strokes and clipped fills

Figure 15-13 was generated using the pol ygon( )  method of Example 15-5 and the following code:

/ /   Def i ne   s ome   dr awi ng   at t r i but es
c . f ont   =   " bol d   60pt   s ans - s er i f " ;	/ /   Bi g   f ont
c . l i neWi dt h   =   2;	/ /   Nar r ow  l i nes c . s t r okeSt yl e   =   " #000" ;	/ /   Bl ac k   l i nes


/ /   Out l i ne   a   r ec t angl e   and   s ome   t ext
c . s t r okeRec t ( 175,	25,	50,	325) ;	/ /   A  ver t i c al	s t r i pe   down t he   mi ddl e
c . s t r okeText ( " <c anvas >" ,	15,	330) ;	/ /   Not e   s t r okeText ( )    i ns t ead of    f i l l Text ( )

/ /   Def i ne   a   c ompl ex   pat h   wi t h   an   i nt er i or   t hat   i s   out s i de. pol ygon( c , 3, 200, 225, 200) ;	/ /   L ar ge   t r i angl e
pol ygon( c , 3, 200, 225, 100, 0, t r ue) ;	/ /   Smal l er   r ever s e   t r i angl e i ns i de

/ /   Make   t hat   pat h   t he   c l i ppi ng   r egi on. c . c l i p( ) ;

/ /   St r oke   t he   pat h   wi t h   a   5   pi xel	l i ne,	ent i r el y   i ns i de   t he c l i ppi ng   r egi on.
c . l i neWi dt h   =   10;	/ /   Hal f    of    t hi s   10   pi xel	l i ne   wi l l	be c l i pped   away
c . s t r oke( ) ;

/ /   Fi l l	t he   par t s   of    t he   r ec t angl e   and   t ext   t hat   ar e   i ns i de   t he c l i ppi ng   r egi on
c . f i l l St yl e   =   " #aaa" ;	/ /   L i ght   gr ay
c . f i l l Rec t ( 175,	25,	50,	325) ;	/ /   Fi l l	t he   ver t i c al	s t r i pe c . f i l l St yl e   =   " #888" ;                                     / /   Dar ker   gr ay
c . f i l l Text ( " <c anvas >" ,	15,	330) ;	/ /   Fi l l	t he   t ext


It is important to note that when you call cl i p( ) , the current path is itself clipped to the current clipping region, then that clipped path becomes the new clipping region. This means that the cl i p( )  method can shrink the clipping region but can never enlarge it. There is no method to reset the clipping region, so before calling cl i p( ) , you should typically call
s ave( )  so that you can later r es t or e( )  the unclipped region.


15.8.7 Pixel Manipulation

The get I mageDat a( )  method returns an ImageData object that represents the raw pixels (as R, G, B, and A components) from a

rectangular region of your canvas. You can create empty I mageDat a objects with cr eat eI mageDat a( ) . The pixels in an ImageData object are writable, so you can set them any way you want, then copy those pixels back onto the canvas with put I mageDat a( ) .


These pixel manipulation methods provide very low-level access to the canvas. The rectangle you pass to get I mageDat a( )  is in the default coordinate system: its dimensions are measured in CSS pixels, and it is not affected by the current transformation. When you call
put I mageDat a( ) , the position you specify is also measured in the default coordinate system. Furthermore, put I mageDat a( )  ignores all graphics attributes. It does not perform any compositing, it does not multiply pixels by gl obal Al pha, and it does not draw shadows.


Pixel manipulation methods are useful for implementing image processing. Example 15-8 shows how to create a simple motion blur or “smear” effect like that shown in Figure 15-14.














Figure 15-14. A motion blur effect created by image processing

The following code demonstrates get I mageDat a( )  and
put I mageDat a( )  and shows how to iterate through and modify the pixel values in an ImageData object.

Example 15-8. Motion blur with ImageData
/ /   Smear   t he   pi xel s   of    t he   r ec t angl e   t o   t he   r i ght ,	pr oduc i ng   a / /   s or t   of    mot i on   bl ur   as   i f    obj ec t s   ar e   movi ng   f r om r i ght   t o
l ef t .
/ /   n   mus t   be   2   or   l ar ger .	L ar ger   val ues   pr oduc e   bi gger   s mear s . / /   The   r ec t angl e   i s   s pec i f i ed   i n   t he   def aul t   c oor di nat e   s ys t em. f unc t i on   s mear ( c ,	n,	x,	y,    w,	h)    {
/ /   Get   t he   I mageDat a   obj ec t   t hat   r epr es ent s   t he   r ec t angl e   of pi xel s   t o   s mear
l et   pi xel s   =   c . get I mageDat a( x,	y,	w,	h) ;

/ /   Thi s   s mear   i s   done   i n- pl ac e   and   r equi r es   onl y   t he   s our c e I mageDat a.
/ /   Some   i mage   pr oc es s i ng   al gor i t hms   r equi r e   an   addi t i onal I mageDat a   t o
/ /   s t or e   t r ans f or med   pi xel	val ues .	I f    we   needed   an   out put buf f er ,	we   c oul d
/ /   c r eat e   a   new  I mageDat a   wi t h   t he   s ame   di mens i ons   l i ke   t hi s : / /	l et   out put _pi xel s   =   c . c r eat eI mageDat a( pi xel s ) ;

/ /   Get   t he   di mens i ons   of    t he   gr i d   of    pi xel s   i n   t he   I mageDat a obj ec t
l et   wi dt h   =   pi xel s . wi dt h,	hei ght   =   pi xel s . hei ght ;

/ /   Thi s   i s   t he   byt e   ar r ay   t hat   hol ds   t he   r aw  pi xel	dat a,	l ef t -t o- r i ght   and
/ /   t op- t o- bot t om.	Eac h   pi xel	oc c upi es   4   c ons ec ut i ve   byt es   i n R, G, B, A  or der .
l et   dat a   =   pi xel s . dat a;


/ /   Eac h   pi xel	af t er r epl ac i ng   i t   wi t h
/ /   1/ nt h   of    i t s   own val ue

t he   f i r s t   i n   eac h   r ow  i s

val ue   pl us   m/ nt hs   of    t he

s mear ed   by

pr evi ous   pi xel ' s

l et   m =   n- 1;

f or ( l et   r ow  =   0;	r ow  <   hei ght ;	r ow++)    {	/ /   For   eac h   r ow l et   i	=   r ow*wi dt h*4   +   4;      / /   The   of f s et   of    t he   s ec ond
pi xel	of    t he   r ow
f or ( l et   c ol	=   1;	c ol	<   wi dt h;	c ol ++,	i	+=   4)    {    / /   For   eac h c ol umn
dat a[ i ]    =	( dat a[ i ]    +   dat a[ i - 4] *m) / n;	/ /   Red pi xel	c omponent

dat a[ i +1] dat a[ i +2]
dat a[ i +3]

=   ( dat a[ i +1] =   ( dat a[ i +2]
=   ( dat a[ i +3]

+   dat a[ i - 3] *m) / n; +   dat a[ i - 2] *m) / n;
+   dat a[ i - 1] *m) / n;

/ /   Gr een / /   Bl ue
/ /   Al pha

c omponent }
}

/ /   Now  c opy   t he   s mear ed   i mage   dat a   bac k   t o   t he   s ame   pos i t i on on   t he   c anvas
c . put I mageDat a( pi xel s ,	x,	y) ;
}



15.9 Audio APIs

The HTML <audi o> and <vi deo> tags allow you to easily include sound and videos in your web pages. These are complex elements with significant APIs and nontrivial user interfaces. You can control media playback with the pl ay( )  and paus e( )  methods. You can set the
vol ume and pl aybackRat e properties to control the audio volume and speed of playback. And you can skip to a particular time within the media by setting the cur r ent Ti me property.


We will not cover <audi o> and <vi deo> tags in any further detail here, however. The following subsections demonstrate two ways to add scripted sound effects to your web pages.


15.9.1 The Audio() Constructor

You don’t have to include an <audi o> tag in your HTML document in order to include sound effects in your web pages. You can dynamically create <audi o> elements with the normal DOM
document . cr eat eEl ement ( )  method, or, as a shortcut, you can simply use the Audi o( )  constructor. You do not have to add the created element to your document in order to play it. You can simply call its
pl ay( )  method:

/ /   L oad   t he   s ound   ef f ec t   i n   advanc e   s o   i t   i s   r eady   f or   us e l et   s oundef f ec t   =   new  Audi o( " s oundef f ec t . mp3" ) ;

/ /   Pl ay   t he   s ound   ef f ec t   whenever   t he   us er   c l i c ks   t he   mous e but t on
doc ument . addEvent L i s t ener ( " c l i c k" ,	( )    =>   {
s oundef f ec t . c l oneNode( ) . pl ay( ) ;	/ /   L oad   and   pl ay   t he   s ound } ) ;


Note the use of cl oneNode( )  here. If the user clicks the mouse rapidly, we want to be able to have multiple overlapping copies of the sound effect playing at the same time. To do that, we need multiple Audio elements. Because the Audio elements are not added to the document, they will be garbage collected when they are done playing.


15.9.2 The WebAudio API

In addition to playback of recorded sounds with Audio elements, web browsers also allow the generation and playback of synthesized sounds with the WebAudio API. Using the WebAudio API is like hooking up an old-style electronic synthesizer with patch cords. With WebAudio, you create a set of AudioNode objects, which represents sources, transformations, or destinations of waveforms, and then connect these nodes together into a network to produce sounds. The API is not particularly complex, but a full explanation requires an understanding of electronic music and signal processing concepts that are beyond the scope of this book.


The following code below uses the WebAudio API to synthesize a short chord that fades out over about a second. This example demonstrates the basics of the WebAudio API. If this is interesting to you, you can find much more about this API online:

/ /   Begi n   by   c r eat i ng   an   audi oCont ext   obj ec t .	Saf ar i	s t i l l

r equi r es
/ /   us   t o   us e   webki t Audi oCont ext   i ns t ead   of    Audi oCont ext . l et   audi oCont ext   =   new
( t hi s . Audi oCont ext ||t hi s . webki t Audi oCont ext ) ( ) ;

/ /   Def i ne   t he   bas e   s ound   as   a   c ombi nat i on   of    t hr ee   pur e   s i ne waves
l et   not es   =   [    293. 7,	370. 0,	440. 0   ] ;	/ /   D  maj or   c hor d:	D,	F#   and A

/ /   Cr eat e   os c i l l at or   nodes   f or   eac h   of    t he   not es   we   want   t o   pl ay l et   os c i l l at or s   =   not es . map( not e   =>   {
l et   o   =   audi oCont ext . c r eat eOs c i l l at or ( ) ; o. f r equenc y. val ue   =   not e;
r et ur n   o; } ) ;

/ /   Shape   t he   s ound   by   c ont r ol l i ng   i t s   vol ume   over   t i me. / /   St ar t i ng   at   t i me   0   qui c kl y   r amp   up   t o   f ul l	vol ume.
/ /   Then   s t ar t i ng   at   t i me   0. 1   s l owl y   r amp   down   t o   0. l et   vol umeCont r ol	=   audi oCont ext . c r eat eGai n( ) ;
vol umeCont r ol . gai n. s et Tar get At Ti me( 1,	0. 0,	0. 02) ; vol umeCont r ol . gai n. s et Tar get At Ti me( 0,	0. 1,	0. 2) ;

/ /   We' r e   goi ng   t o   s end   t he   s ound   t o   t he   def aul t   des t i nat i on: / /   t he   us er ' s   s peaker s
l et   s peaker s   =   audi oCont ext . des t i nat i on;

/ /   Connec t   eac h   of    t he   s our c e   not es   t o   t he   vol ume   c ont r ol os c i l l at or s . f or Eac h( o   =>   o. c onnec t ( vol umeCont r ol ) ) ;

/ /   And   c onnec t   t he   out put   of    t he   vol ume   c ont r ol	t o   t he   s peaker s . vol umeCont r ol . c onnec t ( s peaker s ) ;

/ /   Now  s t ar t   pl ayi ng   t he   s ounds   and   l et   t hem r un   f or   1. 25 s ec onds .
l et   s t ar t Ti me   =   audi oCont ext . c ur r ent Ti me;
l et   s t opTi me   =   s t ar t Ti me   +   1. 25; os c i l l at or s . f or Eac h( o   =>   {
o. s t ar t ( s t ar t Ti me) ; o. s t op( s t opTi me) ;
} ) ;

/ /   I f    we   want   t o   c r eat e   a   s equenc e   of    s ounds   we   c an   us e   event handl er s

os c i l l at or s [ 0] . addEvent L i s t ener ( " ended" ,	( )    =>   {
/ /   Thi s   event   handl er   i s   i nvoked   when   t he   not e   s t ops   pl ayi ng } ) ;


15.10 Location, Navigation, and History

The l ocat i on property of both the Window and Document objects refers to the Location object, which represents the current URL of the document displayed in the window, and which also provides an API for loading new documents into the window.

The Location object is very much like a URL object (§11.9), and you can use properties like pr ot ocol , hos t name, por t , and pat h to access the various parts of the URL of the current document. The hr ef  property returns the entire URL as a string, as does the t oSt r i ng( )  method.


The has h and s ear ch properties of the Location object are interesting ones. The has h property returns the “fragment identifier” portion of the URL, if there is one: a hash mark (#) followed by an element ID. The
s ear ch property is similar. It returns the portion of the URL that starts with a question mark: often some sort of query string. In general, this portion of a URL is used to parameterize the URL and provides a way to embed arguments in it. While these arguments are usually intended for scripts run on a server, there is no reason why they cannot also be used in JavaScript-enabled pages.

URL objects have a s ear chPar ams  property that is a parsed representation of the s ear ch property. The Location object does not have a s ear chPar ams  property, but if you want to parse
wi ndow. l ocat i on. s ear ch, you can simply create a URL object from the Location object and then use the URL’s s ear chPar ams :

l et   ur l	=   new  URL ( wi ndow. l oc at i on) ;
l et   quer y   =   ur l . s ear c hPar ams . get ( " q" ) ;
l et   numRes ul t s   =   par s eI nt ( ur l . s ear c hPar ams . get ( " n" )    ||   " 10" ) ;


In addition to the Location object that you can refer to as
wi ndow. l ocat i on or document . l ocat i on, and the URL( ) constructor that we used earlier, browsers also define a document . URL property. Surprisingly, the value of this property is not a URL object, but just a string. The string holds the URL of the current document.


15.10.1 Loading New Documents

If you assign a string to wi ndow. l ocat i on or to
document . l ocat i on, that string is interpreted as a URL and the browser loads it, replacing the current document with a new one:

wi ndow. l oc at i on   =   " ht t p: / / www. or ei l l y. c om" ;	/ /   Go   buy   s ome books !


You can also assign relative URLs to l ocat i on. They are resolved relative to the current URL:

doc ument . l oc at i on   =   " page2. ht ml " ;	/ /   L oad   t he   next page


A bare fragment identifier is a special kind of relative URL that does not cause the browser to load a new document but simply to scroll so that the document element with i d or name that matches the fragment is visible at the top of the browser window. As a special case, the fragment identifier #t op makes the browser jump to the start of the document (assuming no element has an i d=" t op" attribute):


l oc at i on   =   " #t op" ;	/ /   J ump   t o   t he   t op of    t he   doc ument

The individual properties of the Location object are writable, and setting them changes the location URL and also causes the browser to load a new document (or, in the case of the has h property, to navigate within the current document):

doc ument . l oc at i on. pat h   =   " pages / 3. ht ml " ;	/ /   L oad   a   new  page
doc ument . l oc at i on. has h   =   " TOC" ;	/ /   Sc r ol l	t o   t he   t abl e of    c ont ent s
l oc at i on. s ear c h   =   " ?page="   +   ( page+1) ;	/ /   Rel oad   wi t h   new quer y   s t r i ng


You can also load a new page by passing a new string to the as s i gn( ) method of the Location object. This is the same as assigning the string to the l ocat i on property, however, so it’s not particularly interesting.


The r epl ace( )  method of the Location object, on the other hand, is quite useful. When you pass a string to r epl ace( ) , it is interpreted as a URL and causes the browser to load a new page, just as as s i gn( )  does. The difference is that r epl ace( )  replaces the current document in the browser’s history. If a script in document A sets the l ocat i on property or calls as s i gn( )  to load document B and then the user clicks the Back button, the browser will go back to document A. If you use r epl ace( ) instead, then document A is erased from the browser’s history, and when the user clicks the Back button, the browser returns to whatever document was displayed before document A.

When a script unconditionally loads a new document, the r epl ace( ) method is a better choice than as s i gn( ) . Otherwise, the Back button would take the browser back to the original document, and the same script would again load the new document. Suppose you have a JavaScript-enhanced version of your page and a static version that does not use

JavaScript. If you determine that the user’s browser does not support the web platform APIs that you want to use, you could use
l ocat i on. r epl ace( )  to load the static version:



/ /   I f    t he   br ows er   does   not   s uppor t   t he / /   r edi r ec t   t o   a   s t at i c   page   t hat   does

J avaSc r i pt   API s   we   need, not   us e   J avaSc r i pt .

i f    ( ! i s Br ows er Suppor t ed( ) )    l oc at i on. r epl ac e( " s t at i c page. ht ml " ) ;


Notice that the URL passed to r epl ace( )  is a relative one. Relative URLs are interpreted relative to the page in which they appear, just as they would be if they were used in a hyperlink.

In addition to the as s i gn( )  and r epl ace( )  methods, the Location object also defines r el oad( ) , which simply makes the browser reload the document.


15.10.2 Browsing History

The hi s t or y property of the Window object refers to the History object for the window. The History object models the browsing history of a window as a list of documents and document states. The l engt h property of the History object specifies the number of elements in the browsing history list, but for security reasons, scripts are not allowed to access the stored URLs. (If they could, any scripts could snoop through your browsing history.)

The History object has back( )  and f or war d( )  methods that behave like the browser’s Back and Forward buttons do: they make the browser go backward or forward one step in its browsing history. A third method, go( ) , takes an integer argument and can skip any number of pages forward (for positive arguments) or backward (for negative arguments) in the history list:

hi s t or y. go( - 2) ;	/ /   Go   bac k   2,	l i ke   c l i c ki ng   t he   Bac k   but t on t wi c e
hi s t or y. go( 0) ;	/ /   Anot her   way   t o   r el oad   t he   c ur r ent   page


If a window contains child windows (such as <i f r ame> elements), the browsing histories of the child windows are chronologically interleaved with the history of the main window. This means that calling
hi s t or y. back( )  (for example) on the main window may cause one of the child windows to navigate back to a previously displayed document but leaves the main window in its current state.

The History object described here dates back to the early days of the web when documents were passive and all computation was performed on the server. Today, web applications often generate or load content dynamically and display new application states without actually loading new documents. Applications like these must perform their own history management if they want the user to be able to use the Back and Forward buttons (or the equivalent gestures) to navigate from one application state to another in an intuitive way. There are two ways to accomplish this, described in the next two sections.


15.10.3 History Management with hashchange Events

One history management technique involves l ocat i on. has h and the “hashchange” event. Here are the key facts you need to know to understand this technique:

The l ocat i on. has h property sets the fragment identifier of the URL and is traditionally used to specify the ID of a document section to scroll to. But l ocat i on. has h does not have to be an element ID: you can set it to any string. As long as no element happens to have that string as its ID, the browser won’t scroll

when you set the has h property like this.

Setting the l ocat i on. has h property updates the URL displayed in the location bar and, very importantly, adds an entry to the browser’s history.

Whenever the fragment identifier of the document changes, the browser fires a “hashchange” event on the Window object. If you set l ocat i on. has h explictly, a “hashchange” event is fired. And, as we’ve mentioned, this change to the Location object creates a new entry in the browser’s browsing history. So if the user now clicks the Back button, the browser will return to its previous URL before you set l ocat i on. has h. But this means that the fragment identifier has changed again, so another “hashchange” event is fired in this case. This means that as long as you can create a unique fragment identifier for each possible state of your application, “hashchange” events will notify you if the user moves backward and forward though their browsing history.

To use this history management mechanism, you’ll need to be able to encode the state information necessary to render a “page” of your application into a relatively short string of text that is suitable for use as a fragment identifier. And you’ll need to write a function to convert page state into a string and another function to parse the string and re-create the page state it represents.


Once you have written those functions, the rest is easy. Define a
wi ndow. onhas hchange function (or register a “hashchange” listener with addEvent Li s t ener ( ) ) that reads l ocat i on. has h, converts that string into a representation of your application state, and then takes whatever actions are necessary to display that new application state.

When the user interacts with your application (such as by clicking a link)

in a way that would cause the application to enter a new state, don’t render the new state directly. Instead, encode the desired new state as a string and set l ocat i on. has h to that string. This will trigger a “hashchange” event, and your handler for that event will display the new state. Using this roundabout technique ensures that the new state is inserted into the browsing history so that the Back and Forward buttons continue to work.


15.10.4 History Management with pushState()

The second technique for managing history is somewhat more complex but is less of a hack than the “hashchange” event. This more robust history-management technique is based on the
hi s t or y. pus hSt at e( )  method and the “popstate” event. When a web app enters a new state, it calls hi s t or y. pus hSt at e( )  to add an object representing the state to the browser’s history. If the user then clicks the Back button, the browser fires a “popstate” event with a copy of that saved state object, and the app uses that object to re-create its previous state. In addition to the saved state object, applications can also save a URL with each state, which is important if you want users to be able to bookmark and share links to the internal states of the app.

The first argument to pus hSt at e( )  is an object that contains all the state information necessary to restore the current state of the document. This object is saved using HTML’s structured clone algorithm, which is more versatile than J SON. s t r i ngi f y( )  and can support Map, Set, and Date objects as well as typed arrays and ArrayBuffers.

The second argument was intended to be a title string for the state, but most browsers do not support it, and you should just pass an empty string. The third argument is an optional URL that will be displayed in the

location bar immediately and also if the user returns to this state via Back and Forward buttons. Relative URLs are resolved against the current location of the document. Associating a URL with each state allows the user to bookmark internal states of your application. Remember, though, that if the user saves a bookmark and then visits it a day later, you won’t get a “popstate” event about that visit: you’ll have to restore your application state by parsing the URL.



THE STRUCTURED CLONE ALGORITHM

The hi s t or y. pus hSt at e( )  method does not use J SON. s t r i ngi f y( )  (§11.6) to serialize state data. Instead, it (and other browser APIs we’ll learn about later) uses a more robust serialization technique known as the structured clone algorithm, defined by the HTML standard.

The structured clone algorithm can serialize anything that J SON. s t r i ngi f y( )  can, but in addition, it enables serialization of most other JavaScript types, including Map, Set, Date, RegExp, and typed arrays, and it can handle data structures that include circular references. The structured clone algorithm cannot serialize functions or classes, however. When cloning objects it does not copy the prototype object, getters and setters, or non-enumerable properties. While the structured clone algorithm can clone most built-in JavaScript types, it cannot copy types defined by the host environment, such as document Element objects.

This means that the state object you pass to hi s t or y. pus hSt at e( )  need not be limited to the objects, arrays, and primitive values that J SON. s t r i ngi f y( )  supports. Note, however, that if you pass an instance of a class that you have defined, that instance will be serialized as an ordinary JavaScript object and will lose its prototype.



In addition to the pus hSt at e( )  method, the History object also defines r epl aceSt at e( ) , which takes the same arguments but replaces the current history state instead of adding a new state to the browsing history. When an application that uses pus hSt at e( )  is first loaded, it is often a good idea to call r epl aceSt at e( )  to define a state object for this initial state of the application.

When the user navigates to saved history states using the Back or Forward buttons, the browser fires a “popstate” event on the Window object. The event object associated with the event has a property named s t at e,

which contains a copy (another structured clone) of the state object you passed to pus hSt at e( ) .


Example 15-9 is a simple web application—the number-guessing game pictured in Figure 15-15—that uses pus hSt at e( )  to save its history, allowing the user to “go back” to review or redo their guesses.

























Figure 15-15. A number-guessing game

Example 15-9. History management with pushState()
<ht ml ><head><t i t l e>I ' m t hi nki ng   of    a   number . . . </t i t l e> <s t yl e>
body   {    hei ght :	250px;	di s pl ay:	f l ex;	f l ex- di r ec t i on:	c ol umn;
al i gn- i t ems :	c ent er ;	j us t i f y- c ont ent :	s pac e- evenl y;	} #headi ng   {    f ont :	bol d   36px   s ans - s er i f ;	mar gi n:	0;	}
#c ont ai ner   {    bor der :	s ol i d   bl ac k   1px;	hei ght :	1em;	wi dt h:	80%;	} #r ange   {    bac kgr ound- c ol or :	gr een;	mar gi n- l ef t :    0%;	hei ght :    1em; wi dt h:	100%;	}
#i nput   {    di s pl ay:	bl oc k;	f ont - s i z e:	24px;	wi dt h:	60%;	paddi ng: 5px;	}
#pl ayagai n   {    f ont - s i z e:	24px;	paddi ng:	10px;	bor der - r adi us :	5px;	}

</s t yl e> </head> <body>
<h1   i d=" headi ng" >I ' m t hi nki ng   of    a   number . . . </h1>
<! - -    A  vi s ual	r epr es ent at i on   of    t he   number s   t hat   have   not   been r ul ed   out   - - >
<di v   i d=" c ont ai ner " ><di v   i d=" r ange" ></di v></di v> <! - -    Wher e   t he   us er   ent er s   t hei r   gues s   - - >
<i nput   i d=" i nput "   t ype=" t ext " >
<! - -    A  but t on   t hat   r el oads   wi t h   no   s ear c h   s t r i ng.	Hi dden   unt i l game   ends .	- - >
<but t on   i d=" pl ayagai n"   hi dden   onc l i c k=" l oc at i on. s ear c h=' ' ; " >Pl ay Agai n</but t on>
<s c r i pt > / **
*   An   i ns t anc e   of    t hi s   GameSt at e   c l as s   r epr es ent s   t he   i nt er nal s t at e   of
*   our   number   gues s i ng   game.	The   c l as s   def i nes   s t at i c   f ac t or y met hods   f or
*   i ni t i al i z i ng   t he   game   s t at e   f r om di f f er ent   s our c es ,	a   met hod f or
*   updat i ng   t he   s t at e   bas ed   on   a   new  gues s ,	and   a   met hod   f or modi f yi ng   t he
*   doc ument   bas ed   on   t he   c ur r ent   s t at e. */
c l as s   GameSt at e   {
/ /   Thi s   i s   a   f ac t or y   f unc t i on   t o   c r eat e   a   new  game s t at i c   newGame( )    {
l et   s   =   new  GameSt at e( ) ;
s . s ec r et   =   s . r andomI nt ( 0,	100) ;	/ /   An   i nt eger :	0   <   n   < 100
s . l ow  =   0;	/ /   Gues s es   mus t   be gr eat er   t han   t hi s
s . hi gh   =   100;	/ /   Gues s es   mus t   be   l es s t han   t hi s
s . numGues s es   =   0;	/ /   How  many   gues s es   have been   made
s . gues s   =   nul l ;	/ /   What   t he   l as t   gues s was
r et ur n   s ; }

/ /   When   we   s ave   t he   s t at e   of    t he   game   wi t h hi s t or y. pus hSt at e( ) ,	i t   i s   j us t
/ /   a   pl ai n   J avaSc r i pt   obj ec t   t hat   get s   s aved,	not   an   i ns t anc e of    GameSt at e.
/ /   So   t hi s   f ac t or y   f unc t i on   r e- c r eat es   a   GameSt at e   obj ec t

bas ed   on   t he
/ /   pl ai n   obj ec t   t hat   we   get   f r om a   pops t at e   event . s t at i c   f r omSt at eObj ec t ( s t at eObj ec t )    {
l et   s   =   new  GameSt at e( ) ;
f or ( l et   key   of    Obj ec t . keys ( s t at eObj ec t ) )    { s [ key]    =   s t at eObj ec t [ key] ;
}
r et ur n   s ; }

/ /   I n   or der   t o   enabl e   bookmar ki ng,	we   need   t o   be   abl e   t o enc ode   t he
/ /   s t at e   of    any   game   as   a   URL .	Thi s   i s   eas y   t o   do   wi t h URL Sear c hPar ams .
t oURL ( )    {
l et   ur l	=   new  URL ( wi ndow. l oc at i on) ;

ur l . s ear c hPar ams . s et ( " l " , ur l . s ear c hPar ams . s et ( " h" , ur l . s ear c hPar ams . s et ( " n" ,
ur l . s ear c hPar ams . s et ( " g" ,

t hi s . l ow) ;
t hi s . hi gh) ;
t hi s . numGues s es ) ;
t hi s . gues s ) ;



/ / or   i t
/ / page   wi t h
/ / pi c k   a
/ /

Not e   t hat   we   c an' t   enc ode   t he   s ec r et   number   i n   t he   ur l

wi l l	gi ve   away   t he   s ec r et .	I f    t he   us er   bookmar ks   t he

t hes e   par amet er s   and   t hen   r et ur ns   t o   i t ,	we   wi l l	s i mpl y

new  r andom number   bet ween   l ow  and   hi gh.

r et ur n   ur l . hr ef ; }

/ /   Thi s   i s   a   f ac t or y   f unc t i on   t hat   c r eat es   a   new  GameSt at e obj ec t   and
/ /   i ni t i al i z es   i t   f r om t he   s pec i f i ed   URL .	I f    t he   URL   does   not c ont ai n   t he
/ /   expec t ed   par amet er s   or   i f    t hey   ar e   mal f or med   i t   j us t r et ur ns   nul l .
s t at i c   f r omURL ( ur l )    {
l et   s   =   new  GameSt at e( ) ;
l et   par ams   =   new  URL ( ur l ) . s ear c hPar ams ; s . l ow  =   par s eI nt ( par ams . get ( " l " ) ) ;
s . hi gh   =   par s eI nt ( par ams . get ( " h" ) ) ;
s . numGues s es   =   par s eI nt ( par ams . get ( " n" ) ) ; s . gues s   =   par s eI nt ( par ams . get ( " g" ) ) ;

/ /   I f    t he   URL   i s   mi s s i ng   any   of    t he   par amet er s   we   need   or

i f
/ /   t hey   di d   not   par s e   as   i nt eger s ,	t hen   r et ur n   nul l ;
i f    ( i s NaN( s . l ow)    ||   i s NaN( s . hi gh)    ||
i s NaN( s . numGues s es )    ||   i s NaN( s . gues s ) )    { r et ur n   nul l ;
}

/ /   Pi c k   a   new  s ec r et   number   i n   t he   r i ght   r ange   eac h   t i me we
/ /   r es t or e   a   game   f r om a   URL .
s . s ec r et   =   s . r andomI nt ( s . l ow,	s . hi gh) ;
r et ur n   s ; }

/ /   Ret ur n   an   i nt eger   n,	mi n   <   n   <   max r andomI nt ( mi n,	max)    {
r et ur n   mi n   +   Mat h. c ei l ( Mat h. r andom( )    *   ( max   -    mi n   -    1) ) ; }

/ /   Modi f y   t he   doc ument   t o   di s pl ay   t he   c ur r ent   s t at e   of    t he game.
r ender ( )    {

l et <h1>   at   t he

headi ng   =   doc ument . quer ySel ec t or ( " #headi ng" ) ;	/ /   The t op

l et   r ange   =   doc ument . quer ySel ec t or ( " #r ange" ) ;	/ / Di s pl ay   gues s   r ange
l et   i nput   =   doc ument . quer ySel ec t or ( " #i nput " ) ;	/ /   Gues s i nput   f i el d
l et   pl ayagai n   =   doc ument . quer ySel ec t or ( " #pl ayagai n" ) ;

/ /   Updat e   t he   doc ument   headi ng   and   t i t l e headi ng. t ext Cont ent   =   doc ument . t i t l e   =
` I ' m t hi nki ng   of    a   number   bet ween   ${ t hi s . l ow}    and ${ t hi s . hi gh} . ` ;

/ /   Updat e   t he   vi s ual	r ange   of    number s
r ange. s t yl e. mar gi nL ef t   =   ` ${ t hi s . l ow} %` ;
r ange. s t yl e. wi dt h   =   ` ${ ( t hi s . hi gh- t hi s . l ow) } %` ;

/ /   Make   s ur e   t he   i nput   f i el d   i s   empt y   and   f oc us ed. i nput . val ue   =   " " ;
i nput . f oc us ( ) ;

/ /   Di s pl ay   f eedbac k   bas ed   on   t he   us er ' s   l as t   gues s .	The i nput
/ /   pl ac ehol der   wi l l	s how  bec aus e   we   made   t he   i nput   f i el d

empt y.
i f    ( t hi s . gues s   ===   nul l )    {
i nput . pl ac ehol der   =   " Type   your   gues s   and   hi t   Ent er " ; }    el s e   i f    ( t hi s . gues s   <   t hi s . s ec r et )    {
i nput . pl ac ehol der   =   ` ${ t hi s . gues s }    i s   t oo   l ow.	Gues s agai n` ;
}    el s e   i f    ( t hi s . gues s   >   t hi s . s ec r et )    {
i nput . pl ac ehol der   =   ` ${ t hi s . gues s }    i s   t oo   hi gh.	Gues s agai n` ;
}    el s e   {
i nput . pl ac ehol der   =   doc ument . t i t l e   =   ` ${ t hi s . gues s }    i s c or r ec t ! ` ;
headi ng. t ext Cont ent   =   ` You   wi n   i n   ${ t hi s . numGues s es } gues s es ! ` ;
pl ayagai n. hi dden   =   f al s e; }
}


/ /   Updat e   t he   s t at e   of gues s ed.
/ /   Ret ur ns   t r ue   i f    t he

t he   game   bas ed   on   what

s t at e   was   updat ed,	and

t he   us er

f al s e   ot her wi s e.

updat eFor Gues s ( gues s )    {
/ /   I f    i t   i s   a   number   and   i s   i n   t he   r i ght   r ange
i f    ( ( gues s   >   t hi s . l ow)    &&  ( gues s   <   t hi s . hi gh) )    { / /   Updat e   s t at e   obj ec t   bas ed   on   t hi s   gues s
i f    ( gues s   <   t hi s . s ec r et )    t hi s . l ow  =   gues s ;
el s e   i f    ( gues s   >   t hi s . s ec r et )    t hi s . hi gh   =   gues s ; t hi s . gues s   =   gues s ;
t hi s . numGues s es ++; r et ur n   t r ue;
}
el s e   {    / /   An   i nval i d   gues s :	not i f y   us er   but   don' t   updat e s t at e
al er t ( ` Pl eas e   ent er   a   number   gr eat er   t han   ${
t hi s . l ow}    and   l es s   t han   ${ t hi s . hi gh} ` ) ; r et ur n   f al s e;
} }
}


/ /   Wi t h   t he   GameSt at e   c l as s   def i ned, a   mat t er
/ /   of    i ni t i al i z i ng,	updat i ng,	s avi ng

maki ng   t he   game   wor k   i s   j us t

and   r ender i ng   t he   s t at e

obj ec t   at
/ /   t he   appr opr i at e   t i mes .

/ /   When   we   ar e   f i r s t   l oaded,	we   t r y   get   t he   s t at e   of    t he   game   f r om t he   URL
/ /   and   i f    t hat   f ai l s   we   i ns t ead   begi n   a   new  game.	So   i f    t he   us er bookmar ks   a
/ /   game   t hat   game   c an   be   r es t or ed   f r om t he   URL .	But   i f    we   l oad   a page   wi t h
/ /   no   quer y   par amet er s   we' l l	j us t   get   a   new  game.
l et   games t at e   =   GameSt at e. f r omURL ( wi ndow. l oc at i on)    ||
GameSt at e. newGame( ) ;


/ /   Save   t hi s   i ni t i al	s t at e but   us e
/ /   r epl ac eSt at e   i ns t ead   of

of    t he   game

pus hSt at e( )

i nt o   t he

f or   t hi s

br ows er

i ni t i al

hi s t or y,

page

hi s t or y. r epl ac eSt at e( games t at e,	" " ,	games t at e. t oURL ( ) ) ;

/ /   Di s pl ay   t hi s   i ni t i al	s t at e games t at e. r ender ( ) ;


/ /   When   t he   us er t hei r   gues s
/ /   t hen   s ave   t he s t at e

gues s es ,	updat e   t he   s t at e   of

new  s t at e   t o   br ows er   hi s t or y

t he   game   bas ed   on

and   r ender   t he   new

doc ument . quer ySel ec t or ( " #i nput " ) . onc hange   =   ( event )    =>   {
i f    ( games t at e. updat eFor Gues s ( par s eI nt ( event . t ar get . val ue) ) )    { hi s t or y. pus hSt at e( games t at e,	" " ,	games t at e. t oURL ( ) ) ;
}
games t at e. r ender ( ) ; } ;

/ /   I f    t he   us er   goes   bac k   or   f or war d   i n   hi s t or y,	we' l l	get   a pops t at e   event
/ /   on   t he   wi ndow  obj ec t   wi t h   a   c opy   of    t he   s t at e   obj ec t   we   s aved wi t h
/ /   pus hSt at e.	When   t hat   happens ,	r ender   t he   new  s t at e. wi ndow. onpops t at e   =   ( event )    =>   {
games t at e   =   GameSt at e. f r omSt at eObj ec t ( event . s t at e) ;	/ /   Res t or e t he   s t at e
games t at e. r ender ( ) ;	/ /   and di s pl ay   i t
} ;
</s c r i pt > </body></ht ml >

15.11 Networking

Every time you load a web page, the browser makes network requests— using the HTTP and HTTPS protocols—for an HTML file as well as the images, fonts, scripts, and stylesheets that the file depends on. But in addition to being able to make network requests in response to user actions, web browsers also expose JavaScript APIs for networking as well.


This section covers three network APIs:


The f et ch( )  method defines a Promise-based API for making HTTP and HTTPS requests. The f et ch( )  API makes basic GET requests simple but has a comprehensive feature set that also supports just about any possible HTTP use case.

The Server-Sent Events (or SSE) API is a convenient, event-based interface to HTTP “long polling” techniques where the web server holds the network connection open so that it can send data to the client whenever it wants.

WebSockets is a networking protocol that is not HTTP but is designed to interoperate with HTTP. It defines an asynchronous message-passing API where clients and servers can send and receive messages from each other in a way that is similar to TCP network sockets.


15.11.1 fetch()

For basic HTTP requests, using f et ch( )  is a three-step process:


1.  Call f et ch( ) , passing the URL whose content you want to retrieve.

2.  Get the response object that is asynchronously returned by step 1 when the HTTP response begins to arrive and call a method of this response object to ask for the body of the response.

3.  Get the body object that is asynchronously returned by step 2 and process it however you want.

The f et ch( )  API is completely Promise-based, and there are two asynchronous steps here, so you typically expect two t hen( )  calls or two awai t  expressions when using f et ch( ) . (And if you’ve forgotten what those are, you may want to reread Chapter 13 before continuing with this section.)

Here’s what a f et ch( )  request looks like if you are using t hen( )  and expect the server’s response to your request to be JSON-formatted:

f et c h( " / api / us er s / c ur r ent " )	/ /   Make   an   HTTP   ( or HTTPS)    GET   r eques t
. t hen( r es pons e   =>   r es pons e. j s on( ) )    / /   Par s e   i t s   body   as   a J SON  obj ec t
. t hen( c ur r ent Us er   =>   {	/ /   Then   pr oc es s   t hat par s ed   obj ec t
di s pl ayUs er I nf o( c ur r ent Us er ) ; } ) ;


Here’s a similar request made using the as ync and awai t  keywords to an API that returns a plain string rather than a JSON object:

as ync   f unc t i on   i s Ser vi c eReady( )    {
l et   r es pons e   =   awai t   f et c h( " / api / s er vi c e/ s t at us " ) ; l et   body   =   awai t   r es pons e. t ext ( ) ;
r et ur n   body   ===   " r eady" ; }


If you understand these two code examples, then you know 80% of what you need to know to use the f et ch( )  API. The subsections that follow will demonstrate how to make requests and receive responses that are somewhat more complicated than those shown here.


GOODBYE XMLHTTPREQUEST

The f et ch( )  API replaces the baroque and misleadingly named XMLHttpRequest API (which has nothing to do with XML). You may still see XHR (as it is often abbreviated) in existing code, but there is no reason today to use it in new code, and it is not documented in this chapter. There is one example of XMLHttpRequest in this book, however, and you can refer to §13.1.3 if you’d like to see an example of old-style JavaScript networking.



HTTP STATUS CODES, RESPONSE HEADERS, AND NETWORK ERRORS

The three-step f et ch( )  process shown in §15.11.1 elides all error-handling code. Here’s a more realistic version:

f et c h( " / api / us er s / c ur r ent " )	/ /   Make   an   HTTP   ( or   HTTPS)    GET r eques t .
. t hen( r es pons e   =>   {	/ /   When   we   get   a   r es pons e,	f i r s t c hec k   i t
i f    ( r es pons e. ok   &&	/ /   f or   a   s uc c es s   c ode   and   t he expec t ed   t ype.
r es pons e. header s . get ( " Cont ent - Type" )    === " appl i c at i on/ j s on" )    {
r et ur n   r es pons e. j s on( ) ;	/ /   Ret ur n   a   Pr omi s e   f or   t he body.
}    el s e   {
t hr ow  new  Er r or (	/ /   Or   t hr ow  an   er r or .


or   c ont ent

}
} )

` Unexpec t ed   r es pons e   s t at us   ${ r es pons e. s t at us } t ype`
) ;

. t hen( c ur r ent Us er   =>   {	/ /   When   t he   r es pons e. j s on( ) Pr omi s e   r es ol ves
di s pl ayUs er I nf o( c ur r ent Us er ) ;	/ /   do   s omet hi ng   wi t h   t he par s ed   body.
} )
. c at c h( er r or   =>   {	/ /   Or   i f    anyt hi ng   went   wr ong,	j us t

l og   t he   er r or .
/ /   I f    t he   us er ' s r ej ec t .
/ /   I f    t he   s er ver er r or   above.


br ows er

r et ur ns


i s   of f l i ne,	f et c h( )

a   bad   r es pons e   t hen


i t s el f    wi l l

we   t hr ow  an

c ons ol e. l og( " Er r or   whi l e   f et c hi ng   c ur r ent   us er : " , er r or ) ;
} ) ;


The Promise returned by f et ch( )  resolves to a Response object. The s t at us  property of this object is the HTTP status code, such as 200 for successful requests or 404 for “Not Found” responses. (s t at us Text gives the standard English text that goes along with the numeric status
code.) Conveniently, the ok property of a Response is t r ue if s t at us  is 200 or any code between 200 and 299 and is f al s e for any other code.

f et ch( )  resolves its Promise when the server’s response starts to arrive, as soon as the HTTP status and response headers are available, but typically before the full response body has arrived. Even though the body is not available yet, you can examine the headers in this second step of the fetch process. The header s  property of a Response object is a Headers object. Use its has ( )  method to test for the presence of a header, or use its get ( )  method to get the value of a header. HTTP header names are case-insensitive, so you can pass lowercase or mixed-case header names to these functions.

The Headers object is also iterable if you ever need to do that:


f et c h( ur l ) . t hen( r es pons e   =>   {
f or ( l et   [ name, val ue]    of    r es pons e. header s )    { c ons ol e. l og( ` ${ name} :	${ val ue} ` ) ;
} } ) ;


If a web server responds to your f et ch( )  request, then the Promise that was returned will be fulfilled with a Response object, even if the server’s response was a 404 Not Found error or a 500 Internal Server Error.

f et ch( )  only rejects the Promise it returns if it cannot contact the web server at all. This can happen if the user’s computer is offline, the server is unresponsive, or the URL specifies a hostname that does not exist. Because these things can happen on any network request, it is always a good idea to include a . cat ch( )  clause any time you make a f et ch( ) call.

SETTING REQUEST PARAMETERS

Sometimes you want to pass extra parameters along with the URL when you make a request. This can be done by adding name/value pairs at the end of a URL after a ?. The URL and URLSearchParams classes (which were covered in §11.9) make it easy to construct URLs in this form, and the f et ch( )  function accepts URL objects as its first argument, so you can include request parameters in a f et ch( )  request like this:


as ync   f unc t i on   s ear c h( t er m)    {
l et   ur l	=   new  URL ( " / api / s ear c h" ) ; ur l . s ear c hPar ams . s et ( " q" ,	t er m) ;
l et   r es pons e   =   awai t   f et c h( ur l ) ;
i f    ( ! r es pons e. ok)    t hr ow  new  Er r or ( r es pons e. s t at us Text ) ; l et   r es ul t s Ar r ay   =   awai t   r es pons e. j s on( ) ;
r et ur n   r es ul t s Ar r ay; }

SETTING REQUEST HEADERS

Sometimes you need to set headers in your f et ch( )  requests. If you’re making web API requests that require credentials, for example, then you may need to include an Authorization header that contains those credentials. In order to do this, you can use the two-argument version of f et ch( ) . As before, the first argument is a string or URL object that specifies the URL to fetch. The second argument is an object that can

provide additional options, including request headers:


l et   aut hHeader s   =   new  Header s ( ) ;
/ /   Don' t   us e   Bas i c   aut h   unl es s   i t   i s   over   an   HTTPS   c onnec t i on. aut hHeader s . s et ( " Aut hor i z at i on" ,
` Bas i c   ${ bt oa( ` ${ us er name} : ${ pas s wor d} ` ) } ` ) ; f et c h( " / api / us er s / " ,	{    header s :	aut hHeader s   } )
. t hen( r es pons e   =>   r es pons e. j s on( ) )	/ /   Er r or handl i ng   omi t t ed. . .
. t hen( us er s L i s t   =>   di s pl ayAl l Us er s ( us er s L i s t ) ) ;


There are a number of other options that can be specified in the second argument to f et ch( ) , and we’ll see it again later. An alternative to passing two arguments to f et ch( )  is to instead pass the same two arguments to the Reques t ( )  constructor and then pass the resulting Request object to f et ch( ) :

l et   r eques t   =   new  Reques t ( ur l ,	{    header s   } ) ; f et c h( r eques t ) . t hen( r es pons e   =>   . . . ) ;

PARSING RESPONSE BODIES

In the three-step f et ch( )  process that we’ve demonstrated, the second step ends by calling the j s on( )  or t ext ( )  methods of the Response object and returning the Promise object that those methods return. Then, the third step begins when that Promise resolves with the body of the response parsed as a JSON object or simply as a string of text.

These are probably the two most common scenarios, but they are not the only ways to obtain the body of a web server’s response. In addition to
j s on( )  and t ext ( ) , the Response object also has these methods:


ar r ayBuf f er ( )

This method returns a Promise that resolves to an ArrayBuffer. This is

useful when the response contains binary data. You can use the ArrayBuffer to create a typed array (§11.2) or a DataView object (§11.2.5) from which you can read the binary data.

bl ob( )

This method returns a Promise that resolves to a Blob object. Blobs are not covered in any detail in this book, but the name stands for “Binary Large Object,” and they are useful when you expect large amounts of binary data. If you ask for the body of the response as a Blob, the browser implementation may stream the response data to a temporary file and then return a Blob object that represents that temporary file. Blob objects, therefore, do not allow random access to the response body the way that an ArrayBuffer does. Once you have a Blob, you can create a URL that refers to it with URL. cr eat eObj ect URL( ) , or you can use the event-based FileReader API to asynchronously obtain the content of the Blob as a string or an ArrayBuffer. At the time of this writing, some browsers also define Promise-based
t ext ( )  and ar r ayBuf f er ( )  methods that give a more direct route for obtaining the content of a Blob.

f or mDat a( )

This method returns a Promise that resolves to a FormData object. You should use this method if you expect the body of the Response to be encoded in “multipart/form-data” format. This format is common in POST requests made to a server, but uncommon in server responses, so this method is not frequently used.


STREAMING RESPONSE BODIES

In addition to the five response methods that asynchronously return some form of the complete response body to you, there is also an option to stream the response body, which is useful if there is some kind of processing you can do on the chunks of the response body as they arrive over the network. But streaming the response is also useful if you want to

display a progress bar so that the user can see the progress of the download.


The body property of a Response object is a ReadableStream object. If you have already called a response method like t ext ( )  or j s on( )  that reads, parses, and returns the body, then bodyUs ed will be t r ue to indicate that the body stream has already been read. If bodyUs ed is
f al s e, however, then the stream has not yet been read. In this case, you can call get Reader ( )  on r es pons e. body to obtain a stream reader object, then use the r ead( )  method of this reader object to asynchronously read chunks of text from the stream. The r ead( )  method returns a Promise that resolves to an object with done and val ue properties. done will be t r ue if the entire body has been read or if the stream was closed. And val ue will either be the next chunk, as a Uint8Array, or undef i ned if there are no more chunks.


This streaming API is relatively straightforward if you use as ync and awai t  but is surprisingly complex if you attempt to use it with raw Promises. Example 15-10 demonstrates the API by defining a
s t r eamBody( )  function. Suppose you wanted to download a large JSON file and report download progress to the user. You can’t do that with the j s on( )  method of the Response object, but you could do it with the
s t r eamBody( )  function, like this (assuming that an
updat ePr ogr es s ( )  function is defined to set the val ue attribute on an HTML <pr ogr es s > element):

f et c h( ' bi g. j s on' )
. t hen( r es pons e   =>   s t r eamBody( r es pons e,	updat ePr ogr es s ) ) . t hen( bodyText   =>   J SON. par s e( bodyText ) )
. t hen( handl eBi gJ SONObj ec t ) ;

The s t r eamBody( )  function can be implemented as shown in Example 15-10.

Example 15-10. Streaming the response body from a fetch() request
/ **
*   An   as ync hr onous   f unc t i on   f or   s t r eami ng   t he   body   of    a   Res pons e obj ec t
*   obt ai ned   f r om a   f et c h( )    r eques t .	Pas s   t he   Res pons e   obj ec t   as t he   f i r s t
*   ar gument   f ol l owed   by   t wo   opt i onal	c al l bac ks . *
*   I f    you   s pec i f y   a   f unc t i on   as   t he   s ec ond   ar gument ,	t hat r epor t Pr ogr es s
*   c al l bac k   wi l l	be   c al l ed   onc e   f or   eac h   c hunk   t hat   i s   r ec ei ved. The   f i r s t
*   ar gument   pas s ed   i s   t he   t ot al	number   of    byt es   r ec ei ved   s o   f ar . The   s ec ond
*   ar gument   i s   a   number   bet ween   0   and   1   s pec i f yi ng   how  c ompl et e t he   downl oad
*   i s .	I f    t he   Res pons e   obj ec t   has   no   " Cont ent - L engt h"   header , however ,	t hen
*   t hi s   s ec ond   ar gument   wi l l	al ways   be   NaN. *
*   I f    you   want   t o   pr oc es s   t he   dat a   i n   c hunks   as   t hey   ar r i ve, s pec i f y   a
*   f unc t i on   as   t he   t hi r d   ar gument .	The   c hunks   wi l l	be   pas s ed,	as Ui nt 8Ar r ay
*   obj ec t s ,	t o   t hi s   pr oc es s Chunk   c al l bac k. *
*   s t r eamBody( )    r et ur ns   a   Pr omi s e   t hat   r es ol ves   t o   a   s t r i ng.	I f    a pr oc es s Chunk
*   c al l bac k   was   s uppl i ed   t hen   t hi s   s t r i ng   i s   t he   c onc at enat i on   of t he   val ues
*   r et ur ned   by   t hat   c al l bac k.	Ot her wi s e   t he   s t r i ng   i s   t he c onc at enat i on   of
*   t he   c hunk   val ues   c onver t ed   t o   UTF- 8   s t r i ngs . */
as ync   f unc t i on   s t r eamBody( r es pons e,	r epor t Pr ogr es s ,	pr oc es s Chunk)
{
/ /   How  many   byt es   ar e   we   expec t i ng,	or   NaN  i f    no   header
l et   expec t edByt es   =   par s eI nt ( r es pons e. header s . get ( " Cont ent -L engt h" ) ) ;
l et   byt es Read   =   0;	/ /   How  many   byt es r ec ei ved   s o   f ar
l et   r eader   =   r es pons e. body. get Reader ( ) ;	/ /   Read   byt es   wi t h t hi s   f unc t i on

l et   dec oder   =   new  Text Dec oder ( " ut f - 8" ) ;	/ /   For   c onver t i ng byt es   t o   t ext
l et   body   =   " " ;	/ /   Text   r ead   s o   f ar

whi l e( t r ue)    {	/ /   L oop   unt i l	we exi t   bel ow
l et   { done,	val ue}    =   awai t   r eader . r ead( ) ;	/ /   Read   a   c hunk

i f    ( val ue)    {	/ /   I f    we   got   a byt e   ar r ay:
i f    ( pr oc es s Chunk)    {	/ /   Pr oc es s   t he byt es   i f
l et   pr oc es s ed   =   pr oc es s Chunk( val ue) ;	/ /   a c al l bac k   was   pas s ed.
i f    ( pr oc es s ed)    {
body   +=   pr oc es s ed; }
}    el s e   {	/ /   Ot her wi s e, c onver t   byt es
body   +=   dec oder . dec ode( val ue,	{ s t r eam:	t r ue} ) ;	/ / t o   t ext .
}

i f    ( r epor t Pr ogr es s )    {	/ /   I f    a   pr ogr es s c al l bac k   was
byt es Read   +=   val ue. l engt h;	/ /   pas s ed,	t hen c al l	i t
r epor t Pr ogr es s ( byt es Read,	byt es Read   / expec t edByt es ) ;
} }
i f    ( done)    {	/ /   I f    t hi s   i s t he   l as t   c hunk,
br eak;	/ /   exi t   t he   l oop }
}

r et ur n   body;	/ /   Ret ur n   t he   body   t ext   we   ac c umul at ed }

This streaming API is new at the time of this writing and is expected to evolve. In particular, there are plans to make ReadableStream objects

asynchronously iterable so that they can be used with f or / awai t  loops (§13.4.1).

SPECIFYING THE REQUEST METHOD AND REQUEST BODY

In each of the f et ch( )  examples shown so far, we have made an HTTP (or HTTPS) GET request. If you want to use a different request method (such as POST, PUT, or DELETE), simply use the two-argument version of f et ch( ) , passing an Options object with a met hod parameter:


f et c h( ur l ,	{    met hod:	" POST"   } ) . t hen( r   => r . j s on( ) ) . t hen( handl eRes pons e) ;


POST and PUT requests typically have a request body containing data to be sent to the server. As long as the met hod property is not set to " GET" or " HEAD" (which do not support request bodies), you can specify a request body by setting the body property of the Options object:

f et c h( ur l ,	{
met hod:	" POST" , body:	" hel l o   wor l d"
} )


When you specify a request body, the browser automatically adds an appropriate “Content-Length” header to the request. When the body is a string, as in the preceding example, the browser defaults the “Content-Type” header to “text/plain;charset=UTF-8.” You may need to override this default if you specify a string body of some more specific type such as “text/html” or “application/json”:

f et c h( ur l ,	{
met hod:	" POST" ,
header s :	new  Header s ( { " Cont ent - Type" :	" appl i c at i on/ j s on" } ) ,

body:	J SON. s t r i ngi f y( r eques t Body) } )


The body property of the f et ch( )  options object does not have to be a string. If you have binary data in a typed array or a DataView object or an ArrayBuffer, you can set the body property to that value and specify an appropriate “Content-Type” header. If you have binary data in Blob form, you can simply set body to the Blob. Blobs have a t ype property that specifies their content type, and the value of this property is used as the default value of the “Content-Type” header.

With POST requests, is it somewhat common to pass a set of name/value parameters in the request body (instead of encoding them into the query portion of the URL). There are two ways to do this:

You can specify your parameter names and values with URLSearchParams (which we saw earlier in this section, and which is documented in §11.9) and then pass the URLSearchParams object as the value of the body property. If you do this, the body will be set to a string that looks like the query portion of a URL, and the “Content-Type” header will be automatically set to “application/x-www-form-urlencoded;charset=UTF-8.”

If instead you specify your parameter names and values with a FormData object, the body will use a more verbose multipart encoding and “Content-Type” will be set to “multipart/form-data; boundary=…” with a unique boundary string that matches the body. Using a FormData object is particularly useful when the values you want to upload are long, or are File or Blob objects that may each have its own “Content-Type.” FormData objects can be created and initialized with values by passing a <f or m> element to the For mDat a( )  constructor. But you can also create “multipart/form-data” request bodies by invoking the

For mDat a( )  constructor with no arguments and initializing the name/value pairs it represents with the s et ( )  and append( ) methods.

FILE UPLOAD WITH FETCH()

Uploading files from a user’s computer to a web server is a common task and can be accomplished using a FormData object as the request body. A common way to obtain a File object is to display an <i nput
t ype=" f i l e" > element on your web page and listen for “change” events on that element. When a “change” event occurs, the f i l es  array of the input element should contain at least one File object. File objects are also available through the HTML drag-and-drop API. That API is not covered in this book, but you can get files from the
dat aTr ans f er . f i l es  array of the event object passed to an event listener for “drop” events.

Remember also that File objects are a kind of Blob, and sometimes it can be useful to upload Blobs. Suppose you’ve written a web application that allows the user to create drawings in a <canvas > element. You can upload the user’s drawings as PNG files with code like the following:


/ /   The   c anvas . t oBl ob( )    f unc t i on   i s / /   Thi s   i s   a   Pr omi s e- bas ed   wr apper

c al l bac k- bas ed. f or   i t .

as ync   f unc t i on   get Canvas Bl ob( c anvas )    {
r et ur n   new  Pr omi s e( ( r es ol ve,	r ej ec t )    =>   { c anvas . t oBl ob( r es ol ve) ;
} ) ; }

/ /   Her e   i s   how  we   upl oad   a   PNG  f i l e   f r om a   c anvas as ync   f unc t i on   upl oadCanvas I mage( c anvas )    {
l et   pngbl ob   =   awai t   get Canvas Bl ob( c anvas ) ; l et   f or mdat a   =   new  For mDat a( ) ;
f or mdat a. s et ( " c anvas i mage" ,	pngbl ob) ;

l et   r es pons e   =   awai t   f et c h( " / upl oad" ,	{    met hod:	" POST" , body:	f or mdat a   } ) ;
l et   body   =   awai t   r es pons e. j s on( ) ; }

CROSS-ORIGIN REQUESTS

Most often, f et ch( )  is used by web applications to request data from their own web server. Requests like these are known as same-origin requests because the URL passed to f et ch( )  has the same origin (protocol plus hostname plus port) as the document that contains the script that is making the request.

For security reasons, web browsers generally disallow (though there are exceptions for images and scripts) cross-origin network requests. However, Cross-Origin Resource Sharing, or CORS, enables safe cross-origin requests. When f et ch( )  is used with a cross-origin URL, the browser adds an “Origin” header to the request (and does not allow it to be overridden via the header s  property) to notify the web server that the request is coming from a document with a different origin. If the server responds to the request with an appropriate “Access-Control-Allow-Origin” header, then the request proceeds. Otherwise, if the server does not explicitly allow the request, then the Promise returned by f et ch( )  is rejected.

ABORTING A REQUEST

Sometimes you may want to abort a f et ch( )  request that you have already issued, perhaps because the user clicked a Cancel button or the request is taking too long. The fetch API allows requests to be aborted using the AbortController and AbortSignal classes. (These classes define a generic abort mechanism suitable for use by other APIs as well.)

If you want to have the option of aborting a f et ch( )  request, then create an AbortController object before starting the request. The s i gnal property of the controller object is an AbortSignal object. Pass this signal object as the value of the s i gnal  property of the options object that you pass to f et ch( ) . Having done that, you can call the abor t ( )  method of the controller object to abort the request, which will cause any Promise objects related to the fetch request to reject with an exception.

Here is an example of using the AbortController mechanism to enforce a timeout for fetch requests:

/ /   Thi s   f unc t i on   i s   l i ke   f et c h( ) ,	but   i t   adds   s uppor t   f or   a t i meout
/ /   pr oper t y   i n   t he   opt i ons   obj ec t   and   abor t s   t he   f et c h   i f    i t   i s not   c ompl et e
/ /   wi t hi n   t he   number   of    mi l l i s ec onds   s pec i f i ed   by   t hat   pr oper t y. f unc t i on   f et c hWi t hTi meout ( ur l ,	opt i ons ={ } )    {
i f    ( opt i ons . t i meout )    {	/ /   I f    t he   t i meout   pr oper t y   exi s t s and   i s   nonz er o
l et   c ont r ol l er   =   new  Abor t Cont r ol l er ( ) ;	/ /   Cr eat e   a c ont r ol l er
opt i ons . s i gnal	=   c ont r ol l er . s i gnal ;	/ /   Set   t he s i gnal	pr oper t y
/ /   St ar t   a   t i mer   t hat   wi l l	s end   t he   abor t   s i gnal	af t er t he   s pec i f i ed
/ /   number   of    mi l l i s ec onds   have   pas s ed.	Not e   t hat   we never   c anc el
/ /   t hi s   t i mer .	Cal l i ng   abor t ( )    af t er   t he   f et c h   i s c ompl et e   has
/ /   no   ef f ec t .
s et Ti meout ( ( )    =>   {    c ont r ol l er . abor t ( ) ;	} ,
opt i ons . t i meout ) ; }
/ /   Now  j us t   per f or m a   nor mal	f et c h r et ur n   f et c h( ur l ,	opt i ons ) ;
}


MISCELLANEOUS REQUEST OPTIONS

We’ve seen that an Options object can be passed as the second argument to f et ch( )  (or as the second argument to the Reques t ( )  constructor) to specify the request method, request headers, and request body. It supports a number of other options as well, including these:


c ac he

Use this property to override the browser’s default caching behavior. HTTP caching is a complex topic that is beyond the scope of this book, but if you know something about how it works, you can use the following legal values of cache:

" def aul t "

This value specifies the default caching behavior. Fresh responses in the cache are served directly from the cache, and stale responses are revalidated before being served.

" no- s t or e"

This value makes the browser ignore its cache. The cache is not checked for matches when the request is made and is not updated when the response arrives.

" r el oad"

This value tells the browser to always make a normal network request, ignoring the cache. When the response arrives, however, it is stored in the cache.

" no- c ac he"

This (misleadingly named) value tells the browser to not serve fresh values from the cache. Fresh or stale cached values are revalidated before being returned.

" f or c e- c ac he"

This value tells the browser to serve responses from the cache even

if they are stale.


r edi r ec t

This property controls how the browser handles redirect responses from the server. The three legal values are:

" f ol l ow"

This is the default value, and it makes the browser follow redirects automatically. If you use this default, the Response objects you get with f et ch( )  should never have a s t at us  in the 300 to 399 range.

" er r or "

This value makes f et ch( )  reject its returned Promise if the server returns a redirect response.

" manual "

This value means that you want to manually handle redirect responses, and the Promise returned by f et ch( )  may resolve to a Response object with a s t at us  in the 300 to 399 range. In this case, you will have to use the “Location” header of the Response to manually follow the redirection.


r ef er r er

You can set this property to a string that contains a relative URL to specify the value of the HTTP “Referer” header (which is historically misspelled with three Rs instead of four). If you set this property to the empty string, then the “Referer” header will be omitted from the request.


15.11.2 Server-Sent Events

A fundamental feature of the HTTP protocol upon which the web is built

is that clients initiate requests and servers respond to those requests. Some web apps find it useful, however, to have their server send them notifications when events occur. This does not come naturally to HTTP, but the technique that has been devised is for the client to make a request to the server, and then neither the client nor the server close the connection. When the server has something to tell the client about, it writes data to the connection but keeps it open. The effect is as if the client makes a network request and the server responds in a slow and bursty way with significant pauses between bursts of activity. Network connections like this don’t usually stay open forever, but if the client detects that the connection has closed, it can simply make another request to reopen the connection.


This technique for allowing servers to send messages to clients is surprisingly effective (though it can be expensive on the server side because the server must maintain an active connection to all of its clients). Because it is a useful programming pattern, client-side JavaScript supports it with the EventSource API. To create this kind of long-lived request connection to a web server, simply pass a URL to the Event Sour ce( ) constructor. When the server writes (properly formatted) data to the connection, the EventSource object translates those into events that you can listen for:

l et   t i c ker   =   new  Event Sour c e( " s t oc kpr i c es . php" ) ; t i c ker . addEvent L i s t ener ( " bi d" ,	( event )    =>   {
di s pl ayNewBi d( event . dat a) ; }


The event object associated with a message event has a dat a property that holds whatever string the server sent as the payload for this event. The event object also has a t ype property, like all event objects do, that

specifies the name of the event. The server determines the type of the events that are generated. If the server omits an event name in the data it writes, then the event type defaults to “message.”


The Server-Sent Event protocol is straightforward. The client initiates a connection to the server (when it creates the Event Sour ce object), and the server keeps this connection open. When an event occurs, the server writes lines of text to the connection. An event going over the wire might look like this, if the comments were omitted:


event :	bi d dat a:    GOOG dat a:    999

/ /   s et s   t he   t ype   of    t he   event   obj ec t / /   s et s   t he   dat a   pr oper t y
/ /   appends   a   newl i ne   and   mor e   dat a
/ /   a   bl ank   l i ne   mar ks   t he   end   of    t he   event



There are some additional details to the protocol that allow events to be given IDs and allow a reconnecting client to tell the server what the ID of the last event it received was, so that a server can resend any events it missed. Those details are invisible on the client side, however, and are not discussed here.


One obvious application for Server-Sent Events is for multiuser collaborations like online chat. A chat client might use f et ch( )  to post messages to the chat room and subscribe to the stream of chatter with an EventSource object. Example 15-11 demonstrates how easy it is to write a chat client like this with EventSource.

Example 15-11. A simple chat client using EventSource
<ht ml >
<head><t i t l e>SSE   Chat </ t i t l e></ head> <body>
<! - -    The   c hat   UI	i s   j us t   a   s i ngl e   t ext   i nput   f i el d   - - >
<! - -    New  c hat   mes s ages   wi l l	be   i ns er t ed   bef or e   t hi s   i nput   f i el d   - ->
<i nput   i d=" i nput "   s t yl e=" wi dt h: 100%;	paddi ng: 10px;	bor der : s ol i d


bl ac k   2px" / > <s c r i pt >
/ /   Take   c ar e   of    s ome   UI	det ai l s
l et   ni c k   =   pr ompt ( " Ent er   your   ni c kname" ) ; ni c kname
l et   i nput   =   doc ument . get El ement ByI d( " i nput " ) ; f i el d
i nput . f oc us ( ) ; f oc us




/ /   Get   us er ' s

/ /   Fi nd   t he   i nput

/ /   Set   keyboar d



/ /   Regi s t er   f or   not i f i c at i on   of    new  mes s ages l et   c hat   =   new  Event Sour c e( " / c hat " ) ;
c hat . addEvent L i s t ener ( " c hat " ,	event   =>   {	/ / ar r i ves
l et   di v   =   doc ument . c r eat eEl ement ( " di v" ) ; di v. append( event . dat a) ;
mes s age
i nput . bef or e( di v) ; bef or e   i nput
i nput . s c r ol l I nt oVi ew( ) ; i s   vi s i bl e
} ) ;

us i ng   Event Sour c e

When   a   c hat   mes s age

/ /   Cr eat e   a   <di v>
/ /   Add   t ext   f r om t he

/ /   And   add   di v

/ /   Ens ur e   i nput   el t


/ /   Pos t   t he   us er ' s   mes s ages   t o   t he   s er ver   us i ng   f et c h
i nput . addEvent L i s t ener ( " c hange" ,	( ) =>{	/ /   When   t he   us er   s t r i kes r et ur n
f et c h( " / c hat " ,	{	/ /   St ar t   an   HTTP   r eques t t o   t hi s   ur l .
met hod:	" POST" ,	/ /   Make   i t   a   POST   r eques t wi t h   body
body:	ni c k   +   " :	"   +   i nput . val ue   / /   s et   t o   t he   us er ' s   ni c k and   i nput .
} )
. c at c h( e   =>   c ons ol e. er r or ) ;	/ /   I gnor e   r es pons e,	but l og   any   er r or s .
i nput . val ue   =   " " ;	/ /   Cl ear   t he   i nput } ) ;
</ s c r i pt > </ body> </ ht ml >

The server-side code for this chat program is not much more complicated than the client-side code. Example 15-12 is a simple Node HTTP server. When a client requests the root URL “/”, it sends the chat client code shown in Example 15-11. When a client makes a GET request for the URL “/chat”, it saves the response object and keeps that connection open. And

when a client makes a POST request to “/chat”, it uses the body of the request as a chat message and writes it, using the “text/event-stream” format to each of the saved response objects. The server code listens on port 8080, so after running it with Node, point your browser to
ht t p: / / l ocal hos t : 8080 to connect and begin chatting with yourself.

Example 15-12. A Server-Sent Events chat server
/ /   Thi s   i s   s er ver - s i de   J avaSc r i pt ,	i nt ended   t o   be   r un   wi t h   NodeJ S. / /   I t   i mpl ement s   a   ver y   s i mpl e,	c ompl et el y   anonymous   c hat   r oom.
/ /   POST   new  mes s ages   t o   / c hat ,	or   GET   a   t ext / event - s t r eam of mes s ages
/ /   f r om t he   s ame   URL .	Maki ng   a   GET   r eques t   t o   /   r et ur ns   a   s i mpl e HTML   f i l e
/ /   t hat   c ont ai ns   t he   c l i ent - s i de   c hat   UI . c ons t   ht t p   =   r equi r e( " ht t p" ) ;
c ons t   f s   =   r equi r e( " f s " ) ;
c ons t   ur l	=   r equi r e( " ur l " ) ;

/ /   The   HTML   f i l e   f or   t he   c hat   c l i ent .	Us ed   bel ow.
c ons t   c l i ent HTML   =   f s . r eadFi l eSync ( " c hat Cl i ent . ht ml " ) ;

/ /   An   ar r ay   of    Ser ver Res pons e   obj ec t s   t hat   we' r e   goi ng   t o   s end event s   t o
l et   c l i ent s   =   [ ] ;

/ /   Cr eat e   a   new  s er ver ,	and   l i s t en   on   por t   8080. / /   Connec t   t o   ht t p: / / l oc al hos t : 8080/   t o   us e   i t .
l et   s er ver   =   new  ht t p. Ser ver ( ) ;
s er ver . l i s t en( 8080) ;

/ /   When   t he   s er ver   get s   a   new  r eques t ,	r un   t hi s   f unc t i on s er ver . on( " r eques t " ,	( r eques t ,	r es pons e)    =>   {
/ /   Par s e   t he   r eques t ed   URL
l et   pat hname   =   ur l . par s e( r eques t . ur l ) . pat hname;

/ /   I f    t he   r eques t   was   f or   " / " ,	s end   t he   c l i ent - s i de   c hat   UI . i f    ( pat hname   ===   " / " )    {	/ /   A  r eques t   f or   t he   c hat   UI
r es pons e. wr i t eHead( 200,	{ " Cont ent - Type" : " t ext / ht ml " } ) . end( c l i ent HTML ) ;
}
/ /   Ot her wi s e   s end   a   404   er r or   f or   any   pat h   ot her   t han   " / c hat "

or   f or
/ /   any   met hod   ot her   t han   " GET"   and   " POST" el s e   i f    ( pat hname   ! ==   " / c hat "   ||
( r eques t . met hod   ! ==   " GET"   &&  r eques t . met hod   ! == " POST" ) )    {
r es pons e. wr i t eHead( 404) . end( ) ; }
/ /   I f    t he   / c hat   r eques t   was   a   GET,	t hen   a   c l i ent   i s c onnec t i ng.
el s e   i f    ( r eques t . met hod   ===   " GET" )    {
ac c ept NewCl i ent ( r eques t ,	r es pons e) ; }
/ /   Ot her wi s e   t he   / c hat   r eques t   i s   a   POST   of    a   new  mes s age el s e   {
br oadc as t NewMes s age( r eques t ,	r es pons e) ; }
} ) ;

/ /   Thi s   handl es   GET   r eques t s   f or   t he   / c hat   endpoi nt   whi c h   ar e gener at ed   when
/ /   t he   c l i ent   c r eat es   a   new  Event Sour c e   obj ec t   ( or   when   t he Event Sour c e
/ /   r ec onnec t s   aut omat i c al l y) .
f unc t i on   ac c ept NewCl i ent ( r eques t ,	r es pons e)    {
/ /   Remember   t he   r es pons e   obj ec t   s o   we   c an   s end   f ut ur e   mes s ages t o   i t
c l i ent s . pus h( r es pons e) ;


/ /   I f    t he   c l i ent   c l os es   t he c or r es pondi ng
/ /   r es pons e   obj ec t   f r om t he

c onnec t i on,	r emove   t he

ar r ay   of    ac t i ve   c l i ent s

r eques t . c onnec t i on. on( " end" ,	( )    =>   {
c l i ent s . s pl i c e( c l i ent s . i ndexOf ( r es pons e) ,	1) ; r es pons e. end( ) ;
} ) ;

/ /   Set   header s   and   s end   an   i ni t i al	c hat   event   t o   j us t   t hi s   one c l i ent
r es pons e. wr i t eHead( 200,	{
" Cont ent - Type" :	" t ext / event - s t r eam" , " Connec t i on" :	" keep- al i ve" ,
" Cac he- Cont r ol " :	" no- c ac he" } ) ;
r es pons e. wr i t e( " event :	c hat \ ndat a:	Connec t ed\ n\ n" ) ;


/ /   Not e   t hat   we   i nt ent i onal l y   do   not   c al l	r es pons e. end( )    her e. / /   Keepi ng   t he   c onnec t i on   open   i s   what   makes   Ser ver - Sent
Event s   wor k. }


/ /   Thi s   f unc t i on / c hat   endpoi nt
/ /   whi c h   c l i ent s

i s   c al l ed

s end   when

i n   r es pons e   t o   POST   r eques t s   t o   t he

us er s   t ype   a   new  mes s age.

as ync   f unc t i on   br oadc as t NewMes s age( r eques t ,	r es pons e)    {
/ /   Fi r s t ,	r ead   t he   body   of    t he   r eques t   t o   get   t he   us er ' s mes s age
r eques t . s et Enc odi ng( " ut f 8" ) ;
l et   body   =   " " ;
f or   awai t   ( l et   c hunk   of    r eques t )    { body   +=   c hunk;
}

/ /   Onc e   we' ve   r ead   t he   body   s end   an   empt y   r es pons e   and   c l os e t he   c onnec t i on
r es pons e. wr i t eHead( 200) . end( ) ;

/ /   For mat   t he   mes s age   i n   t ext / event - s t r eam f or mat ,	pr ef i xi ng eac h
/ /   l i ne   wi t h   " dat a:	"
l et   mes s age   =   " dat a:	"   +   body. r epl ac e( " \ n" ,	" \ ndat a:	" ) ;


/ /   Gi ve   t he event
/ /   and   gi ve t he   event .

mes s age   dat a   a   pr ef i x   t hat

i t   a   doubl e   newl i ne   s uf f i x

def i nes   i t

t hat   mar ks

as   a   " c hat "

t he   end   of

l et   event   =   ` event :	c hat \ n${ mes s age} \ n\ n` ;

/ /   Now  s end   t hi s   event   t o   al l    l i s t eni ng   c l i ent s c l i ent s . f or Eac h( c l i ent   =>   c l i ent . wr i t e( event ) ) ;
}


15.11.3 WebSockets

The WebSocket API is a simple interface to a complex and powerful network protocol. WebSockets allow JavaScript code in the browser to easily exchange text and binary messages with a server. As with Server-Sent Events, the client must establish the connection, but once the

connection is established, the server can asynchronously send messages to the client. Unlike SSE, binary messages are supported, and messages can be sent in both directions, not just from server to client.


The network protocol that enables WebSockets is a kind of extension to HTTP. Although the WebSocket API is reminiscent of low-level network sockets, connection endpoints are not identified by IP address and port. Instead, when you want to connect to a service using the WebSocket protocol, you specify the service with a URL, just as you would for a web service. WebSocket URLs begin with ws s : / /  instead of ht t ps : / / , however. (Browsers typically restrict WebSockets to only work in pages loaded over secure ht t ps : / /  connections).


To establish a WebSocket connection, the browser first establishes an HTTP connection and sends the server an Upgr ade:	webs ocket header requesting that the connection be switched from the HTTP protocol to the WebSocket protocol. What this means is that in order to use WebSockets in your client-side JavaScript, you will need to be working with a web server that also speaks the WebSocket protocol, and you will need to have server-side code written to send and receive data using that protocol. If your server is set up that way, then this section will explain everything you need to know to handle the client-side end of the connection. If your server does not support the WebSocket protocol, consider using Server-Sent Events (§15.11.2) instead.

CREATING, CONNECTING, AND DISCONNECTING WEBSOCKETS

If you want to communicate with a WebSocket-enabled server, create a WebSocket object, specifying the ws s : / /  URL that identifies the server and service you want to use:

l et   s oc ket   =   new  WebSoc ket ( " ws s : / / exampl e. c om/ s t oc kt i c ker " ) ;


When you create a WebSocket, the connection process begins automatically. But a newly created WebSocket will not be connected when it is first returned.


The r eadySt at e property of the socket specifies what state the connection is in. This property can have the following values:


WebSoc ket . CONNECTI NG This WebSocket is connecting.
WebSoc ket . OPEN

This WebSocket is connected and ready for communication.

WebSoc ket . CLOSI NG

This WebSocket connection is being closed.

WebSoc ket . CLOSED

This WebSocket has been closed; no further communication is possible. This state can also occur when the initial connection attempt fails.


When a WebSocket transitions from the CONNECTING to the OPEN state, it fires an “open” event, and you can listen for this event by setting the onopen property of the WebSocket or by calling
addEvent Li s t ener ( )  on that object.


If a protocol or other error occurs for a WebSocket connection, the WebSocket object fires an “error” event. You can set oner r or  to define a handler, or, alternatively, use addEvent Li s t ener ( ) .

When you are done with a WebSocket, you can close the connection by calling the cl os e( )  method of the WebSocket object. When a WebSocket changes to the CLOSED state, it fires a “close” event, and you can set the oncl os e property to listen for this event.

SENDING MESSAGES OVER A WEBSOCKET

To send a message to the server on the other end of a WebSocket connection, simply invoke the s end( )  method of the WebSocket object. s end( )  expects a single message argument, which can be a string, Blob, ArrayBuffer, typed array, or DataView object.

The s end( )  method buffers the specified message to be transmitted and returns before the message is actually sent. The buf f er edAmount property of the WebSocket object specifies the number of bytes that are buffered but not yet sent. (Surprisingly, WebSockets do not fire any event when this value reaches 0.)

RECEIVING MESSAGES FROM A WEBSOCKET

To receive messages from a server over a WebSocket, register an event handler for “message” events, either by setting the onmes s age property of the WebSocket object, or by calling addEvent Li s t ener ( ) . The object associated with a “message” event is a MessageEvent instance with a dat a property that contains the server’s message. If the server sent UTF-8 encoded text, then event . dat a will be a string containing that text.

If the server sends a message that consists of binary data instead of text, then the dat a property will (by default) be a Blob object representing that data. If you prefer to receive binary messages as ArrayBuffers instead of

Blobs, set the bi nar yType property of the WebSocket object to the string “arraybuffer.”

There are a number of Web APIs that use MessageEvent objects for exchanging messages. Some of these APIs use the structured clone algorithm (see “The Structured Clone Algorithm”) to allow complex data structures as the message payload. WebSockets is not one of those APIs: messages exchanged over a WebSocket are either a single string of Unicode characters or a single string of bytes (represented as a Blob or an ArrayBuffer).

PROTOCOL NEGOTIATION

The WebSocket protocol enables the exchange of text and binary messages, but says nothing at all about the structure or meaning of those messages. Applications that use WebSockets must build their own communication protocol on top of this simple message-exchange mechanism. The use of ws s : / /  URLs helps with this: each URL will typically have its own rules for how messages are to be exchanged. If you write code to connect to ws s : / / exampl e. com/ s t ockt i cker , then you probably know that you will be receiving messages about stock prices.

Protocols tend to evolve, however. If a hypothetical stock quotation protocol is updated, you can define a new URL and connect to the updated service as ws s : / / exampl e. com/ s t ockt i cker / v2. URL-based versioning is not always sufficient, however. With complex protocols that have evolved over time, you may end up with deployed servers that support multiple versions of the protocol and deployed clients that support a different set of protocol versions.

Anticipating this situation, the WebSocket protocol and API include an

application-level protocol negotiation feature. When you call the WebSocket ( )  constructor, the ws s : / /  URL is the first argument, but you can also pass an array of strings as the second argument. If you do this, you are specifying a list of application protocols that you know how to handle and asking the server to pick one. During the connection process, the server will choose one of the protocols (or will fail with an error if it does not support any of the client’s options). Once the connection has been established, the pr ot ocol  property of the WebSocket object specifies which protocol version the server chose.


15.12 Storage

Web applications can use browser APIs to store data locally on the user’s computer. This client-side storage serves to give the web browser a memory. Web apps can store user preferences, for example, or even store their complete state, so that they can resume exactly where you left off at the end of your last visit. Client-side storage is segregated by origin, so pages from one site can’t read the data stored by pages from another site. But two pages from the same site can share storage and use it as a communication mechanism. Data input in a form on one page can be displayed in a table on another page, for example. Web applications can choose the lifetime of the data they store: data can be stored temporarily so that it is retained only until the window closes or the browser exits, or it can be saved on the user’s computer and stored permanently so that it is available months or years later.


There are a number of forms of client-side storage:


Web Storage

The Web Storage API consists of the l ocal St or age and
s es s i onSt or age objects, which are essentially persistent objects that map string keys to string values. Web Storage is very easy to use and is suitable for storing large (but not huge) amounts of data.

Cookies

Cookies are an old client-side storage mechanism that was designed for use by server-side scripts. An awkward JavaScript API makes cookies scriptable on the client side, but they’re hard to use and suitable only for storing small amounts of textual data. Also, any data stored as cookies is always transmitted to the server with every HTTP request, even if the data is only of interest to the client.

IndexedDB

IndexedDB is an asynchronous API to an object database that supports indexing.



STORAGE, SECURITY, AND PRIVACY

Web browsers often offer to remember web passwords for you, and they store them safely in encrypted form on the device. But none of the forms of client-side data storage described in this chapter involve encryption: you should assume that anything your web applications save resides on the user’s device in unencrypted form. Stored data is therefore accessible to curious users who share access to the device and to malicious software (such as spyware) that exists on the device. For this reason, no form of client-side storage should ever be used for passwords, financial account numbers, or other similarly sensitive information.



15.12.1 localStorage and sessionStorage

The l ocal St or age and s es s i onSt or age properties of the Window object refer to Storage objects. A Storage object behaves much like a regular JavaScript object, except that:

The property values of Storage objects must be strings.

The properties stored in a Storage object persist. If you set a

property of the localStorage object and then the user reloads the page, the value you saved in that property is still available to your program.

You can use the localStorage object like this, for example:


l et   name   =   l oc al St or age. us er name;	/ /   Quer y   a   s t or ed val ue.
i f    ( ! name)    {
name   =   pr ompt ( " What   i s   your   name?" ) ;	/ /   As k   t he   us er   a ques t i on.
l oc al St or age. us er name   =   name;	/ /   St or e   t he   us er ' s r es pons e.
}


You can use the del et e operator to remove properties from
l ocal St or age and s es s i onSt or age, and you can use a f or / i n loop or Obj ect . keys ( )  to enumerate the properties of a Storage object. If you want to remove all properties of a storage object, call the cl ear ( )  method:

l oc al St or age. c l ear ( ) ;


Storage objects also define get I t em( ) , s et I t em( ) , and
del et eI t em( )  methods, which you can use instead of direct property access and the del et e operator if you want to.

Keep in mind that the properties of Storage objects can only store strings. If you want to store and retrieve other kinds of data, you’ll have to encode and decode it yourself.


For example:


/ /   I f    you   s t or e   a   number ,	i t   i s   aut omat i c al l y   c onver t ed   t o   a s t r i ng.

/ /   Don' t   f or get   t o   par s e   i t   when   r et r i evi ng   i t   f r om s t or age. l oc al St or age. x   =   10;
l et   x   =   par s eI nt ( l oc al St or age. x) ;

/ /   Conver t   a   Dat e   t o   a   s t r i ng   when   s et t i ng,	and   par s e   i t   when get t i ng
l oc al St or age. l as t Read   =   ( new  Dat e( ) ) . t oUTCSt r i ng( ) ;
l et   l as t Read   =   new  Dat e( Dat e. par s e( l oc al St or age. l as t Read) ) ;

/ /   J SON  makes   a   c onveni ent   enc odi ng   f or   any   pr i mi t i ve   or   dat a s t r uc t ur e
l oc al St or age. dat a   =   J SON. s t r i ngi f y( dat a) ;	/ /   Enc ode   and   s t or e
l et   dat a   =   J SON. par s e( l oc al St or age. dat a) ;	/ /   Ret r i eve   and dec ode.

STORAGE LIFETIME AND SCOPE

The difference between l ocal St or age and s es s i onSt or age involves the lifetime and scope of the storage. Data stored through
l ocal St or age is permanent: it does not expire and remains stored on the user’s device until a web app deletes it or the user asks the browser (through some browser-specific UI) to delete it.

l ocal St or age is scoped to the document origin. As explained in “The same-origin policy”, the origin of a document is defined by its protocol, hostname, and port. All documents with the same origin share the same
l ocal St or age data (regardless of the origin of the scripts that actually access l ocal St or age). They can read each other’s data, and they can overwrite each other’s data. But documents with different origins can never read or overwrite each other’s data (even if they’re both running a script from the same third-party server).

Note that l ocal St or age is also scoped by browser implementation. If you visit a site using Firefox and then visit again using Chrome (for example), any data stored during the first visit will not be accessible

during the second visit.


Data stored through s es s i onSt or age has a different lifetime than data stored through l ocal St or age: it has the same lifetime as the top-level window or browser tab in which the script that stored it is running. When the window or tab is permanently closed, any data stored through
s es s i onSt or age is deleted. (Note, however, that modern browsers have the ability to reopen recently closed tabs and restore the last browsing session, so the lifetime of these tabs and their associated
s es s i onSt or age may be longer than it seems.)


Like l ocal St or age, s es s i onSt or age is scoped to the document origin so that documents with different origins will never share
s es s i onSt or age. But s es s i onSt or age is also scoped on a per-window basis. If a user has two browser tabs displaying documents from the same origin, those two tabs have separate s es s i onSt or age data: the scripts running in one tab cannot read or overwrite the data written by scripts in the other tab, even if both tabs are visiting exactly the same page and are running exactly the same scripts.

STORAGE EVENTS

Whenever the data stored in l ocal St or age changes, the browser triggers a “storage” event on any other Window objects to which that data is visible (but not on the window that made the change). If a browser has two tabs open to pages with the same origin, and one of those pages stores a value in l ocal St or age, the other tab will receive a “storage” event.


Register a handler for “storage” events either by setting wi ndow. ons t or age or by calling
wi ndow. addEvent Li s t ener ( )  with event type “storage”.



The event object associated with a “storage” event has some important properties:


key

The name or key of the item that was set or removed. If the cl ear ( ) method was called, this property will be nul l .

newVal ue

Holds the new value of the item, if there is one. If r emoveI t em( ) was called, this property will not be present.

ol dVal ue

Holds the old value of an existing item that changed or was deleted. If a new property (with no old value) is added, then this property will not be present in the event object.

s t or ageAr ea

The Storage object that changed. This is usually the l ocal St or age object.

ur l

The URL (as a string) of the document whose script made this storage change.


Note that l ocal St or age and the “storage” event can serve as a broadcast mechanism by which a browser sends a message to all windows that are currently visiting the same website. If a user requests that a website stop performing animations, for example, the site might store that preference in l ocal St or age so that it can honor it in future visits. And by storing the preference, it generates an event that allows other windows displaying the same site to honor the request as well.

As another example, imagine a web-based image-editing application that allows the user to display tool palettes in separate windows. When the user selects a tool, the application uses l ocal St or age to save the current state and to generate a notification to other windows that a new tool has been selected.


15.12.2 Cookies

A cookie is a small amount of named data stored by the web browser and associated with a particular web page or website. Cookies were designed for server-side programming, and at the lowest level, they are implemented as an extension to the HTTP protocol. Cookie data is automatically transmitted between the web browser and web server, so server-side scripts can read and write cookie values that are stored on the client. This section demonstrates how client-side scripts can also manipulate cookies using the cooki e property of the Document object.



WHY “COOKIE”?

The name “cookie” does not have a lot of significance, but it is not used without precedent. In the annals of computing history, the term “cookie” or “magic cookie” has been used to refer to a small chunk of data, particularly a chunk of privileged or secret data, akin to a password, that proves identity or permits access. In JavaScript, cookies are used to save state and can establish a kind of identity for a web browser. Cookies in JavaScript do not use any kind of cryptography, however, and are not secure in any way (although transmitting them across an ht t ps :  connection helps).



The API for manipulating cookies is an old and cryptic one. There are no methods involved: cookies are queried, set, and deleted by reading and writing the cooki e property of the Document object using specially formatted strings. The lifetime and scope of each cookie can be individually specified with cookie attributes. These attributes are also specified with specially formatted strings set on the same cooki e property.

The subsections that follow explain how to query and set cookie values and attributes.

READING COOKIES

When you read the document . cooki e property, it returns a string that contains all the cookies that apply to the current document. The string is a list of name/value pairs separated from each other by a semicolon and a space. The cookie value is just the value itself and does not include any of the attributes that may be associated with that cookie. (We’ll talk about attributes next.) In order to make use of the document . cooki e property, you must typically call the s pl i t ( )  method to break it into individual name/value pairs.

Once you have extracted the value of a cookie from the cooki e property, you must interpret that value based on whatever format or encoding was used by the cookie’s creator. You might, for example, pass the cookie value to decodeURI Component ( )  and then to J SON. par s e( ) .


The code that follows defines a get Cooki e( )  function that parses the document . cooki e property and returns an object whose properties specify the names and values of the document’s cookies:


/ /   Ret ur n   t he   doc ument ' s   c ooki es / /   As s ume   t hat   c ooki e   val ues   ar e enc odeURI Component ( ) .

as   a   Map   obj ec t . enc oded   wi t h

f unc t i on   get Cooki es ( )    {
l et   c ooki es   =   new  Map( ) ;	/ /   The   obj ec t   we   wi l l	r et ur n
l et   al l	=   doc ument . c ooki e;	/ /   Get   al l	c ooki es   i n   one   bi g s t r i ng
l et   l i s t   =   al l . s pl i t ( " ;	" ) ;	/ /   Spl i t   i nt o   i ndi vi dual name/ val ue   pai r s
f or ( l et   c ooki e   of    l i s t )    {	/ /   For   eac h   c ooki e   i n   t hat   l i s t
i f    ( ! c ooki e. i nc l udes ( " =" ) )    c ont i nue;	/ /   Ski p   i f    t her e   i s no   =   s i gn

l et   p   =   c ooki e. i ndexOf ( " =" ) ;	/ /   Fi nd   t he   f i r s t   = s i gn
l et   name   =   c ooki e. s ubs t r i ng( 0,	p) ;	/ /   Get   c ooki e   name
l et   val ue   =   c ooki e. s ubs t r i ng( p+1) ;	/ /   Get   c ooki e   val ue val ue   =   dec odeURI Component ( val ue) ;	/ /   Dec ode   t he   val ue c ooki es . s et ( name,	val ue) ;	/ /   Remember   c ooki e
name   and   val ue }
r et ur n   c ooki es ; }

COOKIE ATTRIBUTES: LIFETIME AND SCOPE

In addition to a name and a value, each cookie has optional attributes that control its lifetime and scope. Before we can describe how to set cookies with JavaScript, we need to explain cookie attributes.


Cookies are transient by default; the values they store last for the duration of the web browser session but are lost when the user exits the browser. If you want a cookie to last beyond a single browsing session, you must tell the browser how long (in seconds) you would like it to retain the cookie by specifying a max- age attribute. If you specify a lifetime, the browser will store cookies in a file and delete them only once they expire.

Cookie visibility is scoped by document origin as l ocal St or age and s es s i onSt or age are, but also by document path. This scope is configurable through cookie attributes pat h and domai n. By default, a cookie is associated with, and accessible to, the web page that created it and any other web pages in the same directory or any subdirectories of that directory. If the web page example.com/catalog/index.html creates a cookie, for example, that cookie is also visible to example.com/catalog/order.html and example.com/catalog/widgets/index.html, but it is not visible to example.com/about.html.



This default visibility behavior is often exactly what you want. Sometimes, though, you’ll want to use cookie values throughout a website, regardless of which page creates the cookie. For instance, if the user enters their mailing address in a form on one page, you may want to save that address to use as the default the next time they return to the page and also as the default in an entirely unrelated form on another page where they are asked to enter a billing address. To allow this usage, you specify a pat h for the cookie. Then, any web page from the same web server whose URL begins with the path prefix you specified can share the cookie. For example, if a cookie set by example.com/catalog/widgets/index.html has its path set to “/catalog”, that cookie is also visible to example.com/catalog/order.html. Or, if the path is set to “/”, the cookie is visible to any page in the example.com domain, giving the cookie a scope like that of l ocal St or age.


By default, cookies are scoped by document origin. Large websites may want cookies to be shared across subdomains, however. For example, the server at order.example.com may need to read cookie values set from catalog.example.com. This is where the domai n attribute comes in. If a cookie created by a page on catalog.example.com sets its pat h attribute to “/” and its domai n attribute to “.example.com,” that cookie is available to all web pages on catalog.example.com, orders.example.com, and any other server in the example.com domain. Note that you cannot set the domain of a cookie to a domain other than a parent domain of your server.

The final cookie attribute is a boolean attribute named s ecur e that specifies how cookie values are transmitted over the network. By default, cookies are insecure, which means that they are transmitted over a normal, insecure HTTP connection. If a cookie is marked secure, however, it is

transmitted only when the browser and server are connected via HTTPS or another secure protocol.



COOKIE LIMITATIONS

Cookies are intended for storage of small amounts of data by server-side scripts, and that data is transferred to the server each time a relevant URL is requested. The standard that defines cookies encourages browser manufacturers to allow unlimited numbers of cookies of unrestricted size but does not require browsers to retain more than 300 cookies total, 20 cookies per web server, or 4 KB of data per cookie (both name and value count toward this 4 KB limit). In practice, browsers allow many more than 300 cookies total, but the 4 KB size limit may still be enforced by some.



STORING COOKIES

To associate a transient cookie value with the current document, simply set the cooki e property to a name=val ue string. For example:


doc ument . c ooki e   =
` ver s i on=${ enc odeURI Component ( doc ument . l as t Modi f i ed) } ` ;


The next time you read the cooki e property, the name/value pair you stored is included in the list of cookies for the document. Cookie values cannot include semicolons, commas, or whitespace. For this reason, you may want to use the core JavaScript global function
encodeURI Component ( )  to encode the value before storing it in the cookie. If you do this, you’ll have to use the corresponding
decodeURI Component ( )  function when you read the cookie value.


A cookie written with a simple name/value pair lasts for the current web-browsing session but is lost when the user exits the browser. To create a cookie that can last across browser sessions, specify its lifetime (in seconds) with a max- age attribute. You can do this by setting the cooki e property to a string of the form: name=val ue;	max-
age=s econds . The following function sets a cookie with an optional

max- age attribute:


/ /   St or e   t he   name/ val ue   pai r   as   a   c ooki e,	enc odi ng   t he   val ue wi t h
/ /   enc odeURI Component ( )    i n   or der   t o   es c ape   s emi c ol ons ,	c ommas , and   s pac es .
/ /   I f    days ToL i ve   i s   a   number ,	s et   t he   max- age   at t r i but e   s o   t hat t he   c ooki e
/ /   expi r es   af t er   t he   s pec i f i ed   number   of    days .	Pas s   0   t o   del et e a   c ooki e.
f unc t i on   s et Cooki e( name,	val ue,	days ToL i ve=nul l )    {
l et   c ooki e   =   ` ${ name} =${ enc odeURI Component ( val ue) } ` ; i f    ( days ToL i ve   ! ==   nul l )    {
c ooki e   +=   ` ;	max- age=${ days ToL i ve*60*60*24} ` ; }
doc ument . c ooki e   =   c ooki e; }


Similarly, you can set the pat h and domai n attributes of a cookie by appending strings of the form ; pat h=val ue or ; domai n=val ue to the string that you set on the document . cooki e property. To set the s ecur e property, simply append ; s ecur e.


To change the value of a cookie, set its value again using the same name, path, and domain along with the new value. You can change the lifetime of a cookie when you change its value by specifying a new max- age attribute.

To delete a cookie, set it again using the same name, path, and domain, specifying an arbitrary (or empty) value, and a max- age attribute of 0.


15.12.3 IndexedDB

Web application architecture has traditionally featured HTML, CSS, and JavaScript on the client and a database on the server. You may find it surprising, therefore, to learn that the web platform includes a simple

object database with a JavaScript API for persistently storing JavaScript objects on the user’s computer and retrieving them as needed.


IndexedDB is an object database, not a relational database, and it is much simpler than databases that support SQL queries. It is more powerful, efficient, and robust than the key/value storage provided by the
l ocal St or age, however. Like the l ocal St or age, IndexedDB databases are scoped to the origin of the containing document: two web pages with the same origin can access each other’s data, but web pages from different origins cannot.

Each origin can have any number of IndexedDB databases. Each one has a name that must be unique within the origin. In the IndexedDB API, a database is simply a collection of named object stores. As the name implies, an object store stores objects. Objects are serialized into the object store using the structured clone algorithm (see “The Structured Clone Algorithm”), which means that the objects you store can have properties whose values are Maps, Sets, or typed arrays. Each object must have a key by which it can be sorted and retrieved from the store. Keys must be unique—two objects in the same store may not have the same key —and they must have a natural ordering so that they can be sorted. JavaScript strings, numbers, and Date objects are valid keys. An IndexedDB database can automatically generate a unique key for each object you insert into the database. Often, though, the objects you insert into an object store will already have a property that is suitable for use as a key. In this case, you specify a “key path” for that property when you create the object store. Conceptually, a key path is a value that tells the database how to extract an object’s key from the object.


In addition to retrieving objects from an object store by their primary key

value, you may want to be able to search based on the value of other properties in the object. In order to be able to do this, you can define any number of indexes on the object store. (The ability to index an object store explains the name “IndexedDB.”) Each index defines a secondary key for the stored objects. These indexes are not generally unique, and multiple objects may match a single key value.


IndexedDB provides atomicity guarantees: queries and updates to the database are grouped within a transaction so that they all succeed together or all fail together and never leave the database in an undefined, partially updated state. Transactions in IndexedDB are simpler than in many database APIs; we’ll mention them again later.


Conceptually, the IndexedDB API is quite simple. To query or update a database, you first open the database you want (specifying it by name). Next, you create a transaction object and use that object to look up the desired object store within the database, also by name. Finally, you look up an object by calling the get ( )  method of the object store or store a new object by calling put ( )  (or by calling add( ) , if you want to avoid overwriting existing objects).

If you want to look up the objects for a range of keys, you create an IDBRange object that specifies the upper and lower bounds of the range and pass it to the get Al l ( )  or openCur s or ( )  methods of the object store.

If you want to make a query using a secondary key, you look up the named index of the object store, then call the get ( ) , get Al l ( ) , or
openCur s or ( )  methods of the index object, passing either a single key or an IDBRange object.

This conceptual simplicity of the IndexedDB API is complicated, however, by the fact that the API is asynchronous (so that web apps can use it without blocking the browser’s main UI thread). IndexedDB was defined before Promises were widely supported, so the API is event-based rather than Promise-based, which means that it does not work with as ync and awai t .


Creating transactions and looking up object stores and indexes are synchronous operations. But opening a database, updating an object store, and querying a store or index are all asynchronous operations. These asynchronous methods all immediately return a request object. The browser triggers a success or error event on the request object when the request succeeds or fails, and you can define handlers with the
ons ucces s  and oner r or  properties. Inside an ons ucces s  handler, the result of the operation is available as the r es ul t  property of the request object. Another useful event is the “complete” event dispatched on transaction objects when a transaction has completed successfully.

One convenient feature of this asynchronous API is that it simplifies transaction management. The IndexedDB API forces you to create a transaction object in order to get the object store on which you can perform queries and updates. In a synchronous API, you would expect to explicitly mark the end of the transaction by calling a commi t ( )  method. But with IndexedDB, transactions are automatically committed (if you do not explicitly abort them) when all the ons ucces s  event handlers have run and there are no more pending asynchronous requests that refer to that transaction.

There is one more event that is important to the IndexedDB API. When you open a database for the first time, or when you increment the version

number of an existing database, IndexedDB fires an “upgradeneeded” event on the request object returned by the i ndexedDB. open( )  call. The job of the event handler for “upgradeneeded” events is to define or update the schema for the new database (or the new version of the existing database). For IndexedDB databases, this means creating object stores and defining indexes on those object stores. And in fact, the only time the IndexedDB API allows you to create an object store or an index is in response to an “upgradeneeded” event.

With this high-level overview of IndexedDB in mind, you should now be able to understand Example 15-13. That example uses IndexedDB to create and query a database that maps US postal codes (zip codes) to US cities. It demonstrates many, but not all, of the basic features of IndexedDB. Example 15-13 is long, but well commented.

Example 15-13. A IndexedDB database of US postal codes

/ /   Thi s   ut i l i t y   f unc t i on   as ync hr onous l y   obt ai ns   t he obj ec t   ( c r eat i ng
/ /   and   i ni t i al i z i ng   t he   DB  i f    nec es s ar y)    and   pas s es c al l bac k.

dat abas e

i t   t o   t he

f unc t i on   wi t hDB( c al l bac k)    {
l et   r eques t   =   i ndexedDB. open( " z i pc odes " ,	1) ;	/ /   Reques t   v1   of t he   dat abas e
r eques t . oner r or   =   c ons ol e. er r or ;	/ /   L og   any   er r or s
r eques t . ons uc c es s   =   ( )    =>   {	/ /   Or   c al l	t hi s   when   done
l et   db   =   r eques t . r es ul t ;	/ /   The   r es ul t   of    t he   r eques t   i s t he   dat abas e
c al l bac k( db) ;	/ /   I nvoke   t he   c al l bac k   wi t h   t he dat abas e
} ;

/ /   I f    ver s i on   1   of    t he   dat abas e   does   not   yet   exi s t ,	t hen   t hi s event
/ /   handl er   wi l l	be   t r i gger ed.	Thi s   i s   us ed   t o   c r eat e   and i ni t i al i z e
/ /   obj ec t   s t or es   and   i ndexes   when   t he   DB  i s   f i r s t   c r eat ed   or t o   modi f y
/ /   t hem when   we   s wi t c h   f r om one   ver s i on   of    t he   DB  s c hema   t o

anot her .
r eques t . onupgr adeneeded   =   ( )    =>   {    i ni t db( r eques t . r es ul t , c al l bac k) ;	} ;
}

/ /   wi t hDB( )    c al l s   t hi s   f unc t i on   i f    t he   dat abas e   has   not   been i ni t i al i z ed   yet .
/ /   We   s et   up   t he   dat abas e   and   popul at e   i t   wi t h   dat a,	t hen   pas s   t he dat abas e   t o
/ /   t he   c al l bac k   f unc t i on. / /
/ /   Our   z i p   c ode   dat abas e   i nc l udes   one   obj ec t   s t or e   t hat   hol ds obj ec t s   l i ke   t hi s :
/ /
/ /	{
/ /	z i pc ode:	" 02134" , / /	c i t y:	" Al l s t on" , / /	s t at e:    " MA" ,
/ /	} / /
/ /   We   us e   t he   " z i pc ode"   pr oper t y   as   t he   dat abas e   key   and   c r eat e   an i ndex   f or
/ /   t he   c i t y   name.
f unc t i on   i ni t db( db,	c al l bac k)    {

/ /   Cr eat e   t he   obj ec t   s t or e,	s pec i f yi ng   a   name   f or and
/ /   an   opt i ons   obj ec t   t hat   i nc l udes   t he   " key   pat h" t he
/ /   pr oper t y   name   of    t he   key   f i el d   f or   t hi s   s t or e.

t he   s t or e

s pec i f yi ng

l et   s t or e   =   db. c r eat eObj ec t St or e( " z i pc odes " ,	/ /   s t or e   name {    keyPat h:    " z i pc ode"   } ) ;


/ /   Now  i ndex   t he   obj ec t   s t or e   by c ode.
/ /   Wi t h   t hi s   met hod   t he   key   pat h a
/ /   r equi r ed   ar gument   r at her   t han

c i t y   name   as   wel l	as   by   z i p

s t r i ng   i s   pas s ed   di r ec t l y   as

as   par t   of    an   opt i ons   obj ec t .

s t or e. c r eat eI ndex( " c i t i es " ,	" c i t y" ) ;

/ /   Now  get   t he   dat a   we   ar e   goi ng   t o   i ni t i al i z e   t he   dat abas e wi t h.
/ /   The   z i pc odes . j s on   dat a   f i l e   was   gener at ed   f r om CC- l i c ens ed dat a   f r om
/ /   www. geonames . or g:
ht t ps : / / downl oad. geonames . or g/ expor t / z i p/ US. z i p
f et c h( " z i pc odes . j s on" )	/ /   Make   an   HTTP   GET r eques t
. t hen( r es pons e   =>   r es pons e. j s on( ) )	/ /   Par s e   t he   body   as

J SON
. t hen( z i pc odes   =>   {	/ /   Get   40K   z i p   c ode r ec or ds
/ /   I n   or der   t o   i ns er t   z i p   c ode   dat a   i nt o   t he   dat abas e we   need   a
/ /   t r ans ac t i on   obj ec t .	To   c r eat e   our   t r ans ac t i on obj ec t ,	we   need
/ /   t o   s pec i f y   whi c h   obj ec t   s t or es   we' l l	be   us i ng   ( we onl y   have
/ /   one)    and   we   need   t o   t el l	i t   t hat   we' l l	be   doi ng wr i t es   t o   t he
/ /   dat abas e,	not   j us t   r eads :
l et   t r ans ac t i on   =   db. t r ans ac t i on( [ " z i pc odes " ] ,
" r eadwr i t e" ) ;
t r ans ac t i on. oner r or   =   c ons ol e. er r or ;

/ /   Get   our   obj ec t   s t or e   f r om t he   t r ans ac t i on
l et   s t or e   =   t r ans ac t i on. obj ec t St or e( " z i pc odes " ) ;


/ / obj ec t   s t or es
/ / our   r ec or ds :

The   bes t   par t   about   t he   I ndexedDB  API	i s   t hat

ar e   *r eal l y*   s i mpl e.	Her e' s   how  we   add   ( or   updat e)

f or ( l et   r ec or d   of    z i pc odes )    {    s t or e. put ( r ec or d) ;	}



dat abas e

t he

wi t hDB( )

/ /   When   t he   t r ans ac t i on   c ompl et es   s uc c es s f ul l y,	t he

/ /   i s   i ni t i al i z ed   and   r eady   f or   us e,	s o   we   c an   c al l

/ /   c al l bac k   f unc t i on   t hat   was   or i gi nal l y   pas s ed   t o

t r ans ac t i on. onc ompl et e   =   ( )    =>   {    c al l bac k( db) ;	} ; } ) ;
}

/ /   Gi ven   a   z i p   c ode,	us e   t he   I ndexedDB  API	t o   as ync hr onous l y   l ook up   t he   c i t y
/ /   wi t h   t hat   z i p   c ode,	and   pas s   i t   t o   t he   s pec i f i ed   c al l bac k,	or pas s   nul l	i f
/ /   no   c i t y   i s   f ound.
f unc t i on   l ookupCi t y( z i p,	c al l bac k)    {
wi t hDB( db   =>   {

/ /   Cr eat e   a The
/ /   ar gument us e.

r ead- onl y   t r ans ac t i on   obj ec t

i s   an   ar r ay   of    obj ec t   s t or es

f or   t hi s   quer y.

we   wi l l	need   t o

l et   t r ans ac t i on   =   db. t r ans ac t i on( [ " z i pc odes " ] ) ;


/ /   Get   t he   obj ec t   s t or e   f r om t he   t r ans ac t i on
l et   z i pc odes   =   t r ans ac t i on. obj ec t St or e( " z i pc odes " ) ;



z i pc ode

as ync .

/ /   Now  r eques t   t he key.
/ /   The   l i nes   above

obj ec t   t hat   mat c hes   t he   s pec i f i ed

wer e   s ync hr onous ,	but   t hi s   one   i s

l et   r eques t   =   z i pc odes . get ( z i p) ;
r eques t . oner r or   =   c ons ol e. er r or ;	/ /   L og   er r or s
r eques t . ons uc c es s   =   ( )    =>   {	/ /   Or   c al l	t hi s   f unc t i on on   s uc c es s
l et   r ec or d   =   r eques t . r es ul t ;	/ /   Thi s   i s   t he   quer y r es ul t
i f    ( r ec or d)    {    / /   I f    we   f ound   a   mat c h,	pas s   i t   t o   t he c al l bac k
c al l bac k( ` ${ r ec or d. c i t y} ,	${ r ec or d. s t at e} ` ) ;
}    el s e   {	/ /   Ot her wi s e,	t el l	t he   c al l bac k   t hat   we f ai l ed
c al l bac k( nul l ) ; }
} ; } ) ;
}

/ /   Gi ven   t he   name   of    a   c i t y,	us e   t he   I ndexedDB  API	t o as ync hr onous l y
/ /   l ook   up   al l	z i p   c ode   r ec or ds   f or   al l	c i t i es   ( i n   any   s t at e)    t hat have
/ /   t hat   ( c as e- s ens i t i ve)    name.
f unc t i on   l ookupZi pc odes ( c i t y,	c al l bac k)    {
wi t hDB( db   =>   {
/ /   As   above,	we   c r eat e   a   t r ans ac t i on   and   get   t he   obj ec t s t or e
l et   t r ans ac t i on   =   db. t r ans ac t i on( [ " z i pc odes " ] ) ;
l et   s t or e   =   t r ans ac t i on. obj ec t St or e( " z i pc odes " ) ;

/ /   Thi s   t i me   we   al s o   get   t he   c i t y   i ndex   of    t he   obj ec t s t or e
l et   i ndex   =   s t or e. i ndex( " c i t i es " ) ;


/ / s pec i f i ed
/ / c al l bac k.
/ /

As k   f or   al l	mat c hi ng   r ec or ds   i n   t he   i ndex   wi t h   t he

c i t y   name,	and   when   we   get   t hem we   pas s   t hem t o   t he

I f    we   expec t ed   mor e   r es ul t s ,	we   mi ght   us e   openCur s or ( )

i ns t ead.
l et   r eques t   =   i ndex. get Al l ( c i t y) ; r eques t . oner r or   =   c ons ol e. er r or ;
r eques t . ons uc c es s   =   ( )    =>   {    c al l bac k( r eques t . r es ul t ) ;	} ; } ) ;
}



15.13 Worker Threads and Messaging

One of the fundamental features of JavaScript is that it is single-threaded: a browser will never run two event handlers at the same time, and it will never trigger a timer while an event handler is running, for example. Concurrent updates to application state or to the document are simply not possible, and client-side programmers do not need to think about, or even understand, concurrent programming. A corollary is that client-side JavaScript functions must not run too long; otherwise, they will tie up the event loop and the web browser will become unresponsive to user input. This is the reason that f et ch( )  is an asynchronous function, for example.

Web browsers very carefully relax the single-thread requirement with the Worker class: instances of this class represent threads that run concurrently with the main thread and the event loop. Workers live in a self-contained execution environment with a completely independent global object and no access to the Window or Document objects. Workers can communicate with the main thread only through asynchronous message passing. This means that concurrent modifications of the DOM remain impossible, but it also means that you can write long-running functions that do not stall the event loop and hang the browser. Creating a new worker is not a heavyweight operation like opening a new browser window, but workers are not flyweight “fibers” either, and it does not

make sense to create new workers to perform trivial operations. Complex web applications may find it useful to create tens of workers, but it is unlikely that an application with hundreds or thousands of workers would be practical.


Workers are useful when your application needs to perform computationally intensive tasks, such as image processing. Using a worker moves tasks like this off the main thread so that the browser does not become unresponsive. And workers also offer the possibility of dividing the work among multiple threads. But workers are also useful when you have to perform frequent moderately intensive computations. Suppose, for example, that you’re implementing a simple in-browser code editor, and want to include syntax highlighting. To get the highlighting right, you need to parse the code on every keystroke. But if you do that on the main thread, it is likely that the parsing code will prevent the event handlers that respond to the user’s key strokes from running promptly and the user’s typing experience will be sluggish.


As with any threading API, there are two parts to the Worker API. The first is the Worker object: this is what a worker looks like from the outside, to the thread that creates it. The second is the WorkerGlobalScope: this is the global object for a new worker, and it is what a worker thread looks like, on the inside, to itself.


The following sections cover Worker and WorkerGlobalScope and also explain the message-passing API that allows workers to communicate with the main thread and each other. The same communication API is used to exchange messages between a document and <i f r ame> elements contained in the document, and this is covered in the following sections as well.

15.13.1 Worker Objects

To create a new worker, call the Wor ker ( )  constructor, passing a URL that specifies the JavaScript code that the worker is to run:

l et   dat aCr unc her   =   new  Wor ker ( " ut i l s / c r unc her . j s " ) ;


If you specify a relative URL, it is resolved relative to the URL of the document that contains the script that called the Wor ker ( )  constructor. If you specify an absolute URL, it must have the same origin (same protocol, host, and port) as that containing document.

Once you have a Worker object, you can send data to it with
pos t Mes s age( ) . The value you pass to pos t Mes s age( )  will be copied using the structured clone algorithm (see “The Structured Clone Algorithm”), and the resulting copy will be delivered to the worker via a message event:

dat aCr unc her . pos t Mes s age( " / api / dat a/ t o/ c r unc h" ) ;


Here we’re just passing a single string message, but you can also use objects, arrays, typed arrays, Maps, Sets, and so on. You can receive messages from a worker by listening for “message” events on the Worker object:

dat aCr unc her . onmes s age   =   f unc t i on( e)    {
l et   s t at s   =   e. dat a;	/ /   The   mes s age   i s   t he   dat a   pr oper t y   of t he   event
c ons ol e. l og( ` Aver age:	${ s t at s . mean} ` ) ; }


Like all event targets, Worker objects define the standard
addEvent Li s t ener ( )  and r emoveEvent Li s t ener ( )  methods,

and you can use these in place of the onmes s age.


In addition to pos t Mes s age( ) , Worker objects have just one other method, t er mi nat e( ) , which forces a worker thread to stop running.


15.13.2 The Global Object in Workers

When you create a new worker with the Wor ker ( )  constructor, you specify the URL of a file of JavaScript code. That code is executed in a new, pristine JavaScript execution environment, isolated from the script that created the worker. The global object for that new execution environment is a WorkerGlobalScope object. A WorkerGlobalScope is something more than the core JavaScript global object, but less than a full-blown client-side Window object.

The WorkerGlobalScope object has a pos t Mes s age( )  method and an onmes s age event handler property that are just like those of the Worker object but work in the opposite direction: calling pos t Mes s age( ) inside a worker generates a message event outside the worker, and messages sent from outside the worker are turned into events and delivered to the onmes s age handler. Because the WorkerGlobalScope is the global object for a worker, pos t Mes s age( )  and onmes s age look like a global function and global variable to worker code.

If you pass an object as the second argument to the Wor ker ( ) constructor, and if that object has a name property, then the value of that property becomes the value of the name property in the worker’s global object. A worker might include this name in any messages it prints with cons ol e. war n( )  or cons ol e. er r or ( ) .

The cl os e( )  function allows a worker to terminate itself, and it is similar in effect to the t er mi nat e( )  method of a Worker object.


Since WorkerGlobalScope is the global object for workers, it has all of the properties of the core JavaScript global object, such as the JSON object, the i s NaN( )  function, and the Dat e( )  constructor. In addition, however, WorkerGlobalScope also has the following properties of the client-side Window object:

s el f  is a reference to the global object itself. WorkerGlobalScope is not a Window object and does not define a wi ndowproperty.

The timer methods s et Ti meout ( ) , cl ear Ti meout ( ) , s et I nt er val ( ) , and cl ear I nt er val ( ) .

A l ocat i on property that describes the URL that was passed to the Wor ker ( )  constructor. This property refers to a Location object, just as the l ocat i on property of a Window does. The Location object has properties hr ef , pr ot ocol , hos t ,
hos t name, por t , pat hname, s ear ch, and has h. In a worker, these properties are read-only, however.

A navi gat or  property that refers to an object with properties like those of the Navigator object of a window. A worker’s Navigator object has the properties appName, appVer s i on, pl at f or m, us er Agent , and onLi ne.

The usual event target methods addEvent Li s t ener ( )  and r emoveEvent Li s t ener ( ) .

Finally, the WorkerGlobalScope object includes important client-side JavaScript APIs including the Console object, the f et ch( )  function, and the IndexedDB API. WorkerGlobalScope also includes the Wor ker ( ) constructor, which means that worker threads can create their own

workers.


15.13.3 Importing Code into a Worker

Workers were defined in web browsers before JavaScript had a module system, so workers have a unique system for including additional code. WorkerGlobalScope defines i mpor t Scr i pt s ( )  as a global function that all workers have access to:

/ /   Bef or e   we   s t ar t   wor ki ng,	l oad   t he   c l as s es   and   ut i l i t i es   we' l l need
i mpor t Sc r i pt s ( " ut i l s / Hi s t ogr am. j s " ,	" ut i l s / Bi t Set . j s " ) ;


i mpor t Scr i pt s ( )  takes one or more URL arguments, each of which should refer to a file of JavaScript code. Relative URLs are resolved relative to the URL that was passed to the Wor ker ( )  constructor (not relative to the containing document). i mpor t Scr i pt s ( ) synchronously loads and executes these files one after the other, in the order in which they were specified. If loading a script causes a network error, or if executing throws an error of any sort, none of the subsequent scripts are loaded or executed. A script loaded with i mpor t Scr i pt s ( ) can itself call i mpor t Scr i pt s ( )  to load the files it depends on. Note, however, that i mpor t Scr i pt s ( )  does not try to keep track of what scripts have already loaded and does nothing to prevent dependency cycles.

i mpor t Scr i pt s ( )  is a synchronous function: it does not return until all of the scripts have loaded and executed. You can start using the scripts you loaded as soon as i mpor t Scr i pt s ( )  returns: there is no need for a callback, event handler, t hen( )  method or awai t . Once you have internalized the asynchronous nature of client-side JavaScript, it feels

strange to go back to simple, synchronous programming again. But that is the beauty of threads: you can use a blocking function call in a worker without blocking the event loop in the main thread, and without blocking the computations being concurrently performed in other workers.



MODULES IN WORKERS

In order to use modules in workers, you must pass a second argument to the Wor ker ( )  constructor. This second argument must be an object with a t ype property set to the string “module.” Passing a
t ype: " modul e"  option to the Wor ker ( )  constructor is much like using the t ype=" modul e"  attribute on an HTML <s cr i pt > tag: it means that the code should be interpreted as a module and that i mpor t declarations are allowed.

When a worker loads a module instead of a traditional script, the WorkerGlobalScope does not define the i mpor t Scr i pt s ( )  function.

Note that as of early 2020, Chrome is the only browser that supports true modules and i mpor t declarations in workers.



15.13.4 Worker Execution Model

Worker threads run their code (and all imported scripts or modules) synchronously from top to bottom, and then enter an asynchronous phase in which they respond to events and timers. If a worker registers a “message” event handler, it will never exit as long as there is a possibility that message events will still arrive. But if a worker doesn’t listen for messages, it will run until there are no further pending tasks (such as
f et ch( )  promises and timers) and all task-related callbacks have been called. Once all registered callbacks have been called, there is no way a worker can begin a new task, so it is safe for the thread to exit, which it will do automatically. A worker can also explicitly shut itself down by calling the global cl os e( )  function. Note that there are no properties or methods on the Worker object that specify whether a worker thread is still running or not, so workers should not close themselves without somehow

coordinating this with their parent thread.


ERRORS IN WORKERS

If an exception occurs in a worker and is not caught by any cat ch clause, then an “error” event is triggered on the global object of the worker. If this event is handled and the handler calls the pr event Def aul t ( )  method of the event object, the error propagation ends. Otherwise, the “error” event is fired on the Worker object. If pr event Def aul t ( )  is called there, then propagation ends. Otherwise, an error message is printed in the developer console and the onerror handler (§15.1.7) of the Window object is invoked.

/ /   Handl e   unc aught   wor ker   er r or s   wi t h   a   handl er   i ns i de   t he wor ker .
s el f . oner r or   =   f unc t i on( e)    {
c ons ol e. l og( ` Er r or   i n   wor ker   at   ${ e. f i l ename} : ${ e. l i neno} : ${ e. mes s age} ` ) ;
e. pr event Def aul t ( ) ; } ;

/ /   Or ,	handl e   unc aught   wor ker   er r or s   wi t h   a   handl er   out s i de   t he wor ker .
wor ker . oner r or   =   f unc t i on( e)    {
c ons ol e. l og( ` Er r or   i n   wor ker   at   ${ e. f i l ename} : ${ e. l i neno} : ${ e. mes s age} ` ) ;
e. pr event Def aul t ( ) ; } ;


Like windows, workers can register a handler to be invoked when a Promise is rejected and there is no . cat ch( )  function to handle it. Within a worker you can detect this by defining a
s el f . onunhandl edr ej ect i on function or by using addEvent Li s t ener ( )  to register a global handler for
“unhandledrejection” events. The event object passed to this handler will

have a pr omi s e property whose value is the Promise object that rejected and a r eas on property whose value is what would have been passed to a . cat ch( )  function.


15.13.5 postMessage(), MessagePorts, and MessageChannels

The pos t Mes s age( )  method of the Worker object and the global
pos t Mes age( )  function defined inside a worker both work by invoking the pos t Mes s age( )  methods of a pair of MessagePort objects that are automatically created along with the worker. Client-side JavaScript can’t directly access these automatically created MessagePort objects, but it can create new pairs of connected ports with the Mes s ageChannel ( ) constructor:

l et   c hannel	=   new  Mes s ageChannel ;	/ /   Cr eat e   a   new c hannel .
l et   myPor t   =   c hannel . por t 1;	/ /   I t   has   t wo por t s
l et   your Por t   =   c hannel . por t 2;	/ /   c onnec t ed   t o eac h   ot her .

myPor t . pos t Mes s age( " Can   you   hear   me?" ) ;	/ /   A  mes s age pos t ed   t o   one   wi l l
your Por t . onmes s age   =   ( e)    =>   c ons ol e. l og( e. dat a) ;	/ /   be   r ec ei ved on   t he   ot her .


A MessageChannel is an object with por t 1 and por t 2 properties that refer to a pair of connected MessagePort objects. A MessagePort is an object with a pos t Mes s age( )  method and an onmes s age event handler property. When pos t Mes s age( )  is called on one port of a connected pair, a “message” event is fired on the other port in the pair. You can receive these “message” events by setting the onmes s age property or by using addEvent Li s t ener ( )  to register a listener for

“message” events.


Messages sent to a port are queued until the onmes s age property is defined or until the s t ar t ( )  method is called on the port. This prevents messages sent by one end of the channel from being missed by the other end. If you use addEvent Li s t ener ( )  with a MessagePort, don’t forget to call s t ar t ( )  or you may never see a message delivered.


All the pos t Mes s age( )  calls we’ve seen so far have taken a single message argument. But the method also accepts an optional second argument. This second argument is an array of items that are to be transferred to the other end of the channel instead of having a copy sent across the channel. Values that can be transferred instead of copied are MessagePorts and ArrayBuffers. (Some browsers also implement other transferable types, such as ImageBitmap and OffscreenCanvas. These are not universally supported, however, and are not covered in this book.) If the first argument to pos t Mes s age( )  includes a MessagePort (nested anywhere within the message object), then that MessagePort must also appear in the second argument. If you do this, then the MessagePort will become available to the other end of the channel and will immediately become nonfunctional on your end. Suppose you have created a worker and want to have two channels for communicating with it: one channel for ordinary data exchange and one channel for high-priority messages. In the main thread, you might create a MessageChannel, then call
pos t Mes s age( )  on the worker to pass one of the MessagePorts to it:


l et   wor ker   =   new  Wor ker ( " wor ker . j s " ) ;
l et   ur gent Channel	=   new  Mes s ageChannel ( ) ; l et   ur gent Por t   =   ur gent Channel . por t 1;
wor ker . pos t Mes s age( {    c ommand:	" s et Ur gent Por t " ,	val ue: ur gent Channel . por t 2   } ,

[    ur gent Channel . por t 2   ] ) ;
/ /   Now  we   c an   r ec ei ve   ur gent   mes s ages   f r om t he   wor ker   l i ke   t hi s ur gent Por t . addEvent L i s t ener ( " mes s age" ,	handl eUr gent Mes s age) ;
ur gent Por t . s t ar t ( ) ;	/ /   St ar t   r ec ei vi ng   mes s ages / /   And   s end   ur gent   mes s ages   l i ke   t hi s
ur gent Por t . pos t Mes s age( " t es t " ) ;


MessageChannels are also useful if you create two workers and want to allow them to communicate directly with each other rather than requiring code on the main thread to relay messages between them.


The other use of the second argument to pos t Mes s age( )  is to transfer ArrayBuffers between workers without having to copy them. This is an important performance enhancement for large ArrayBuffers like those used to hold image data. When an ArrayBuffer is transferred over a MessagePort, the ArrayBuffer becomes unusable in the original thread so that there is no possibility of concurrent access to its contents. If the first argument to pos t Mes s age( )  includes an ArrayBuffer, or any value (such as a typed array) that has an ArrayBuffer, then that buffer may appear as an array element in the second pos t Mes s age( )  argument. If it does appear, then it will be transferred without copying. If not, then the ArrayBuffer will be copied rather than transferred. Example 15-14 will demonstrate the use of this transfer technique with ArrayBuffers.


15.13.6 Cross-Origin Messaging with postMessage()

There is another use case for the pos t Mes s age( )  method in client-side JavaScript. It involves windows instead of workers, but there are enough similarities between the two cases that we will describe the
pos t Mes s age( )  method of the Window object here.


When a document contains an <i f r ame> element, that element acts as

an embedded but independent window. The Element object that represents the <i f r ame> has a cont ent Wi ndowproperty that is the Window object for the embedded document. And for scripts running within that nested iframe, the wi ndow. par ent  property refers to the containing Window object. When two windows display documents with the same origin, then scripts in each of those windows have access to the contents of the other window. But when the documents have different origins, the browser’s same-origin policy prevents JavaScript in one window from accessing the content of another window.

For workers, pos t Mes s age( )  provides a safe way for two independent threads to communicate without sharing memory. For windows,
pos t Mes s age( )  provides a controlled way for two independent origins to safely exchange messages. Even if the same-origin policy prevents your script from seeing the content of another window, you can still call
pos t Mes s age( )  on that window, and doing so will cause a “message” event to be triggered on that window, where it can be seen by the event handlers in that window’s scripts.

The pos t Mes s age( )  method of a Window is a little different than the pos t Mes s age( )  method of a Worker, however. The first argument is still an arbitrary message that will be copied by the structured clone algorithm. But the optional second argument listing objects to be transferred instead of copied becomes an optional third argument. The pos t Mes s age( )  method of a window takes a string as its required second argument. This second argument should be an origin (a protocol, hostname, and optional port) that specifies who you expect to be receiving the message. If you pass the string “https://good.example.com” as the second argument, but the window you are posting the message to actually contains content from “https://malware.example.com,” then the message

you posted will not be delivered. If you are willing to send your message to content from any origin, then you can pass the wildcard “*” as the second argument.


JavaScript code running inside a window or <i f r ame> can receive messages posted to that window or frame by defining the onmes s age property of that window or by calling addEvent Li s t ener ( )  for “message” events. As with workers, when you receive a “message” event for a window, the dat a property of the event object is the message that was sent. In addition, however, “message” events delivered to windows also define s our ce and or i gi n properties. The s our ce property specifies the Window object that sent the event, and you can use
event . s our ce. pos t Mes s age( )  to send a reply. The or i gi n property specifies the origin of the content in the source window. This is not something the sender of the message can forge, and when you receive a “message” event, you will typically want to verify that it is from an origin you expect.


15.14 Example: The Mandelbrot Set

This chapter on client-side JavaScript culminates with a long example that demonstrates using workers and messaging to parallelize computationally intensive tasks. But it is written to be an engaging, real-world web application and also demonstrates a number of the other APIs demonstrated in this chapter, including history management; use of the ImageData class with a <canvas >; and the use of keyboard, pointer, and resize events. It also demonstrates important core JavaScript features, including generators and a sophisticated use of Promises.

The example is a program for displaying and exploring the Mandelbrot

set, a complex fractal that includes beautiful images like the one shown in Figure 15-16.


































Figure 15-16. A portion of the Mandelbrot set

The Mandelbrot set is defined as the set of points on the complex plane, which, when put through a repeated process of complex multiplication and addition, produce a value whose magnitude remains bounded. The contours of the set are surprisingly complex, and computing which points are members of the set and which are not is computationally intensive: to produce a 500×500 image of the Mandelbrot set, you must individually compute the membership of each of the 250,000 pixels in your image. And

to verify that the value associated with each pixel remains bounded, you may have to repeat the process of complex multiplication 1,000 times or more. (More iterations give more sharply defined boundaries for the set; fewer iterations produce fuzzier boundaries.) With up to 250 million steps of complex arithmetic required to produce a high-quality image of the Mandelbrot set, you can understand why using workers is a valuable technique. Example 15-14 shows the worker code we will use. This file is relatively compact: it is just the raw computational muscle for the larger program. Two things are worth noting about it, however:

The worker creates an ImageData object to represent the rectangular grid of pixels for which it is computing Mandelbrot set membership. But instead of storing actual pixel values in the ImageData, it uses a custom-typed array to treat each pixel as a 32-bit integer. It stores the number of iterations required for each pixel in this array. If the magnitude of the complex number computed for each pixel becomes greater than four, then it is mathematically guaranteed to grow without bounds from then on, and we say it has “escaped.” So the value this worker returns for each pixel is the number of iterations before the value escaped. We tell the worker the maximum number of iterations it should try for each value, and pixels that reach this maximum number are considered to be in the set.

The worker transfers the ArrayBuffer associated with the ImageData back to the main thread so the memory associated with it does not need to be copied.

Example 15-14. Worker code for computing regions of the Mandelbrot set
/ /   Thi s   i s   a   s i mpl e   wor ker   t hat   r ec ei ves   a   mes s age   f r om i t s   par ent t hr ead,
/ /   per f or ms   t he   c omput at i on   des c r i bed   by   t hat   mes s age   and   t hen pos t s   t he
/ /   r es ul t   of    t hat   c omput at i on   bac k   t o   t he   par ent   t hr ead. onmes s age   =   f unc t i on( mes s age)    {
/ /   Fi r s t ,	we   unpac k   t he   mes s age   we   r ec ei ved:

/ /	-    t i l e   i s   an   obj ec t   wi t h   wi dt h   and   hei ght   pr oper t i es .	I t s pec i f i es   t he
/ /	s i z e   of    t he   r ec t angl e   of    pi xel s   f or   whi c h   we   wi l l	be c omput i ng
/ /	Mandel br ot   s et   member s hi p.
/ /	-    ( x0,	y0)    i s   t he   poi nt   i n   t he   c ompl ex   pl ane   t hat c or r es ponds   t o   t he
/ /	upper - l ef t   pi xel	i n   t he   t i l e.
/ /	-    per Pi xel	i s   t he   pi xel	s i z e   i n   bot h   t he   r eal	and i magi nar y   di mens i ons .
/ /	-    maxI t er at i ons   s pec i f i es   t he   maxi mum number   of    i t er at i ons we   wi l l
/ /	per f or m bef or e   dec i di ng   t hat   a   pi xel	i s   i n   t he   s et .
c ons t   { t i l e,	x0,	y0,	per Pi xel ,	maxI t er at i ons }    =   mes s age. dat a;
c ons t   { wi dt h,	hei ght }    =   t i l e;

/ /   Next ,	we   c r eat e   an   I mageDat a   obj ec t   t o   r epr es ent   t he r ec t angul ar   ar r ay
/ /   of    pi xel s ,	get   i t s   i nt er nal	Ar r ayBuf f er ,	and   c r eat e   a   t yped ar r ay   vi ew
/ /   of    t hat   buf f er   s o   we   c an   t r eat   eac h   pi xel	as   a   s i ngl e i nt eger   i ns t ead   of
/ /   f our   i ndi vi dual	byt es .	We' l l	s t or e   t he   number   of    i t er at i ons f or   eac h
/ /   pi xel	i n   t hi s   i t er at i ons   ar r ay.	( The   i t er at i ons   wi l l	be t r ans f or med   i nt o
/ /   ac t ual	pi xel	c ol or s   i n   t he   par ent   t hr ead. )
c ons t   i mageDat a   =   new  I mageDat a( wi dt h,	hei ght ) ;
c ons t   i t er at i ons   =   new  Ui nt 32Ar r ay( i mageDat a. dat a. buf f er ) ;

/ /   Now  we   begi n   t he   c omput at i on.	Ther e   ar e   t hr ee   nes t ed   f or l oops   her e.
/ /   The   out er   t wo   l oop   over   t he   r ows   and   c ol umns   of    pi xel s ,	and t he   i nner
/ /   l oop   i t er at es   eac h   pi xel	t o   s ee   i f    i t   " es c apes "   or   not .	The var i ous
/ /   l oop   var i abl es   ar e   t he   f ol l owi ng:
/ /   -    r ow  and   c ol umn   ar e   i nt eger s   r epr es ent i ng   t he   pi xel c oor di nat e.
/ /   -    x   and   y   r epr es ent   t he   c ompl ex   poi nt   f or   eac h   pi xel :	x   + yi .
/ /   -    i ndex   i s   t he   i ndex   i n   t he   i t er at i ons   ar r ay   f or   t he c ur r ent   pi xel .
/ /   -    n   t r ac ks   t he   number   of    i t er at i ons   f or   eac h   pi xel .
/ /   -    max   and   mi n   t r ac k   t he   l ar ges t   and   s mal l es t   number   of i t er at i ons
/ /	we' ve   s een   s o   f ar   f or   any   pi xel	i n   t he   r ec t angl e. l et   i ndex   =   0,	max   =   0,	mi n=maxI t er at i ons ;

f or ( l et   r ow  =   0,	y   =   y0;	r ow  <   hei ght ;	r ow++,	y   +=   per Pi xel )    { f or ( l et   c ol umn   =   0,    x   =   x0;	c ol umn   <   wi dt h;	c ol umn++,	x   +=
per Pi xel )    {
/ /   For   eac h   pi xel	we   s t ar t   wi t h   t he   c ompl ex   number   c   = x+yi .
/ /   Then   we   r epeat edl y   c omput e   t he   c ompl ex   number z ( n+1)    bas ed   on
/ /   t hi s   r ec ur s i ve   f or mul a: / /	z ( 0)    =   c
/ /	z ( n+1)    =   z ( n) ^2   +   c
/ /   I f    |z ( n) |   ( t he   magni t ude   of    z ( n) )    i s   >   2,	t hen   t he / /   pi xel	i s   not   par t   of    t he   s et   and   we   s t op   af t er   n
i t er at i ons .
l et   n;	/ /   The   number   of    i t er at i ons   s o   f ar
l et   r   =   x,	i	=   y;	/ /   St ar t   wi t h   z ( 0)    s et   t o   c f or ( n   =   0;	n   <   maxI t er at i ons ;	n++)    {
l et   r r   =   r *r ,	i i	=   i *i ;	/ /   Squar e   t he   t wo   par t s   of z ( n) .
i f    ( r r   +   i i	>   4)    {	/ /   I f    |z ( n) |^2   i s   >   4   t hen br eak;                                       / /   we' ve   es c aped   and   c an
s t op   i t er at i ng.
}
i	=   2*r *i	+   y;	/ /   Comput e   i magi nar y   par t of    z ( n+1) .
r   =   r r   -    i i	+   x;	/ /   And   t he   r eal	par t   of z ( n+1) .
}
i t er at i ons [ i ndex++]    =   n;	/ /   Remember   #   i t er at i ons f or   eac h   pi xel .
i f    ( n   >   max)    max   =   n;	/ /   Tr ac k   t he   maxi mum number   we' ve   s een.
i f    ( n   <   mi n)    mi n   =   n;	/ /   And   t he   mi ni mum as wel l .
} }

/ /   When   t he   c omput at i on   i s   c ompl et e,	s end   t he   r es ul t s   bac k   t o t he   par ent
/ /   t hr ead.	The   i mageDat a   obj ec t   wi l l	be   c opi ed,	but   t he   gi ant Ar r ayBuf f er
/ /   i t   c ont ai ns   wi l l	be   t r ans f er r ed   f or   a   ni c e   per f or manc e boos t .
pos t Mes s age( { t i l e,	i mageDat a,	mi n,	max} ,
[ i mageDat a. dat a. buf f er ] ) ; } ;

The Mandelbrot set viewer application that uses that worker code is shown in Example 15-15. Now that you have nearly reached the end of this chapter, this long example is something of a capstone experience that brings together a number of important core and client-side JavaScript features and APIs. The code is thoroughly commented, and I encourage you to read it carefully.

Example 15-15. A web application for displaying and exploring the Mandelbrot set
/ *
*   Thi s   c l as s   r epr es ent s   a   s ubr ec t angl e   of    a   c anvas   or   i mage.	We us e   Ti l es   t o
*   di vi de   a   c anvas   i nt o   r egi ons   t hat   c an   be   pr oc es s ed i ndependent l y   by   Wor ker s .
*/
c l as s   Ti l e   {
c ons t r uc t or ( x,	y,	wi dt h,	hei ght )    {
t hi s . x   =   x;	/ /   The   pr oper t i es   of    a Ti l e   obj ec t
t hi s . y   =   y;	/ /   r epr es ent   t he   pos i t i on and   s i z e
t hi s . wi dt h   =   wi dt h;	/ /   of    t he   t i l e   wi t hi n   a l ar ger
t hi s . hei ght   =   hei ght ;	/ /   r ec t angl e. }

/ /   Thi s   s t at i c   met hod   i s   a   gener at or   t hat   di vi des   a   r ec t angl e of    t he
/ /   s pec i f i ed   wi dt h   and   hei ght   i nt o   t he   s pec i f i ed   number   of r ows   and
/ /   c ol umns   and   yi el ds   numRows *numCol s   Ti l e   obj ec t s   t o   c over t he   r ec t angl e.
s t at i c   *t i l es ( wi dt h,	hei ght ,	numRows ,	numCol s )    {
l et   c ol umnWi dt h   =   Mat h. c ei l ( wi dt h   /   numCol s ) ; l et   r owHei ght   =   Mat h. c ei l ( hei ght   /   numRows ) ;

f or ( l et   r ow  =   0;	r ow  <   numRows ;	r ow++)    { l et   t i l eHei ght   =   ( r ow  <   numRows - 1)
?   r owHei ght	/ /   hei ght   of mos t   r ows
:	hei ght   -    r owHei ght   *   ( numRows - 1) ;	/ /   hei ght   of

l as t   r ow
f or ( l et   c ol	=   0;	c ol	<   numCol s ;	c ol ++)    { l et   t i l eWi dt h   =   ( c ol	<   numCol s - 1)
?   c ol umnWi dt h	/ /   wi dt h   of mos t   c ol umns
:	wi dt h   -    c ol umnWi dt h   *   ( numCol s - 1) ;	/ /   and l as t   c ol umn

yi el d   new  Ti l e( c ol	*   c ol umnWi dt h,	r ow  *   r owHei ght , t i l eWi dt h,	t i l eHei ght ) ;
} }
} }

/ *
*   Thi s   c l as s   r epr es ent s   a   pool	of    wor ker s ,	al l	r unni ng   t he   s ame c ode.	The
*   wor ker   c ode   you   s pec i f y   mus t   r es pond   t o   eac h   mes s age   i t r ec ei ves   by
*   per f or mi ng   s ome   ki nd   of    c omput at i on   and   t hen   pos t i ng   a   s i ngl e mes s age   wi t h
*   t he   r es ul t   of    t hat   c omput at i on. *
*   Gi ven   a   Wor ker Pool	and   mes s age   t hat   r epr es ent s   wor k   t o   be per f or med,	s i mpl y
*   c al l	addWor k( ) ,	wi t h   t he   mes s age   as   an   ar gument .	I f    t her e   i s   a Wor ker
*   obj ec t   t hat   i s   c ur r ent l y   i dl e,	t he   mes s age   wi l l	be   pos t ed   t o t hat   wor ker
*   i mmedi at el y.	I f    t her e   ar e   no   i dl e   Wor ker   obj ec t s ,	t he   mes s age wi l l	be
*   queued   and   wi l l	be   pos t ed   t o   a   Wor ker   when   one   bec omes avai l abl e.
*
*   addWor k( )    r et ur ns   a   Pr omi s e,	whi c h   wi l l	r es ol ve   wi t h   t he mes s age   r ec i eved
*   f r om t he   wor k,	or   wi l l	r ej ec t   i f    t he   wor ker   t hr ows   an   unhandl ed er r or .
*/
c l as s   Wor ker Pool	{
c ons t r uc t or ( numWor ker s ,	wor ker Sour c e)    {
t hi s . i dl eWor ker s   =   [ ] ;	/ /   Wor ker s   t hat   ar e   not c ur r ent l y   wor ki ng
t hi s . wor kQueue   =   [ ] ;	/ /   Wor k   not   c ur r ent l y   bei ng pr oc es s ed

t hi s . wor ker Map   =   new  Map( ) ;	/ /   Map   wor ker s   t o   r es ol ve   and r ej ec t   f unc s

/ /   Cr eat e   t he   s pec i f i ed   number   of    wor ker s ,	add   mes s age   and er r or
/ /   handl er s   and   s ave   t hem i n   t he   i dl eWor ker s   ar r ay. f or ( l et   i	=   0;	i	<   numWor ker s ;	i ++)    {
l et   wor ker   =   new  Wor ker ( wor ker Sour c e) ; wor ker . onmes s age   =   mes s age   =>   {
t hi s . _wor ker Done( wor ker ,	nul l ,	mes s age. dat a) ; } ;
wor ker . oner r or   =   er r or   =>   {
t hi s . _wor ker Done( wor ker ,	er r or ,	nul l ) ; } ;
t hi s . i dl eWor ker s [ i ]    =   wor ker ; }
}


/ /   Thi s   i nt er nal	met hod   i s wor ki ng,	ei t her
/ /   by   s endi ng   a   mes s age   or

c al l ed   when

by   t hr owi ng

a   wor ker   f i ni s hes

an   er r or .

_wor ker Done( wor ker ,	er r or ,	r es pons e)    {

/ /   L ook   up   t he   r es ol ve( )    and   r ej ec t ( ) wor ker
/ /   and   t hen   r emove   t he   wor ker ' s   ent r y

f unc t i ons   f or   t hi s

f r om t he   map.

l et   [ r es ol ver ,	r ej ec t or ]    =   t hi s . wor ker Map. get ( wor ker ) ; t hi s . wor ker Map. del et e( wor ker ) ;


/ /   I f    t her e   i s / /   t he   l i s t   of
queue
/ /   and   s end   i t

no   queued   wor k,    put   t hi s i dl e   wor ker s .    Ot her wi s e,

t o   t hi s   wor ker .

wor ker   bac k   i n
t ake   wor k   f r om t he

i f    ( t hi s . wor kQueue. l engt h   ===   0)    { t hi s . i dl eWor ker s . pus h( wor ker ) ;
}    el s e   {
l et   [ wor k,	r es ol ver ,	r ej ec t or ]    = t hi s . wor kQueue. s hi f t ( ) ;
t hi s . wor ker Map. s et ( wor ker ,	[ r es ol ver ,	r ej ec t or ] ) ; wor ker . pos t Mes s age( wor k) ;
}

/ /   Fi nal l y,	r es ol ve   or   r ej ec t   t he   pr omi s e   as s oc i at ed   wi t h t he   wor ker .
er r or   ===   nul l	?   r es ol ver ( r es pons e)    :	r ej ec t or ( er r or ) ;

}

/ /   Thi s   met hod   adds   wor k   t o   t he   wor ker   pool	and   r et ur ns   a Pr omi s e   t hat
/ /   wi l l	r es ol ve   wi t h   a   wor ker ' s   r es pons e   when   t he   wor k   i s done.	The   wor k
/ /   i s   a   val ue   t o   be   pas s ed   t o   a   wor ker   wi t h   pos t Mes s age( ) .	I f t her e   i s   an
/ /   i dl e   wor ker ,	t he   wor k   mes s age   wi l l	be   s ent   i mmedi at el y. Ot her wi s e   i t
/ /   wi l l	be   queued   unt i l	a   wor ker   i s   avai l abl e. addWor k( wor k)    {
r et ur n   new  Pr omi s e( ( r es ol ve,	r ej ec t )    =>   { i f    ( t hi s . i dl eWor ker s . l engt h   >   0)    {
l et   wor ker   =   t hi s . i dl eWor ker s . pop( ) ;
t hi s . wor ker Map. s et ( wor ker ,	[ r es ol ve,	r ej ec t ] ) ; wor ker . pos t Mes s age( wor k) ;
}    el s e   {
t hi s . wor kQueue. pus h( [ wor k,	r es ol ve,	r ej ec t ] ) ; }
} ) ; }
}

/ *
*   Thi s   c l as s   hol ds   t he   s t at e   i nf or mat i on   nec es s ar y   t o   r ender   a Mandel br ot   s et .
*   The   c x   and   c y   pr oper t i es   gi ve   t he   poi nt   i n   t he   c ompl ex   pl ane t hat   i s   t he
*   c ent er   of    t he   i mage.	The   per Pi xel	pr oper t y   s pec i f i es   how  muc h t he   r eal	and
*   i magi nar y   par t s   of    t hat   c ompl ex   number   c hanges   f or   eac h   pi xel of    t he   i mage.
*   The   maxI t er at i ons   pr oper t y   s pec i f i es   how  har d   we   wor k   t o c omput e   t he   s et .
*   L ar ger   number s   r equi r e   mor e   c omput at i on   but   pr oduc e   c r i s per i mages .
*   Not e   t hat   t he   s i z e   of    t he   c anvas   i s   not   par t   of    t he   s t at e. Gi ven   c x,	c y,	and
*   per Pi xel	we   s i mpl y   r ender   what ever   por t i on   of    t he   Mandel br ot s et   f i t s   i n
*   t he   c anvas   at   i t s   c ur r ent   s i z e. *
*   Obj ec t s   of    t hi s   t ype   ar e   us ed   wi t h   hi s t or y. pus hSt at e( )    and   ar e us ed   t o   r ead
*   t he   des i r ed   s t at e   f r om a   bookmar ked   or   s har ed   URL . */

c l as s   PageSt at e   {
/ /   Thi s   f ac t or y   met hod   r et ur ns   an   i ni t i al	s t at e   t o   di s pl ay   t he ent i r e   s et .
s t at i c   i ni t i al St at e( )    {
l et   s   =   new  PageSt at e( ) ; s . c x   =   - 0. 5;
s . c y   =   0;
s . per Pi xel	=   3/ wi ndow. i nner Hei ght ; s . maxI t er at i ons   =   500;
r et ur n   s ; }


/ /   Thi s   f ac t or y   met hod nul l	i f
/ /   a   val i d   s t at e   c oul d

obt ai ns   s t at e   f r om a   URL ,	or   r et ur ns

not   be   r ead   f r om t he   URL .

s t at i c   f r omURL ( ur l )    {
l et   s   =   new  PageSt at e( ) ;
l et   u   =   new  URL ( ur l ) ;	/ /   I ni t i al i z e   s t at e   f r om t he   ur l ' s s ear c h   par ams .
s . c x   =   par s eFl oat ( u. s ear c hPar ams . get ( " c x" ) ) ; s . c y   =   par s eFl oat ( u. s ear c hPar ams . get ( " c y" ) ) ;
s . per Pi xel	=   par s eFl oat ( u. s ear c hPar ams . get ( " pp" ) ) ;
s . maxI t er at i ons   =   par s eI nt ( u. s ear c hPar ams . get ( " i t " ) ) ;
/ /   I f    we   got   val i d   val ues ,	r et ur n   t he   PageSt at e   obj ec t , ot her wi s e   nul l .
r et ur n   ( i s NaN( s . c x)    ||   i s NaN( s . c y)    ||   i s NaN( s . per Pi xel )
||   i s NaN( s . maxI t er at i ons ) ) ?   nul l
:	s ; }


/ /   Thi s   i ns t anc e s ear c h
/ /   par amet er s   of

met hod   enc odes   t he   c ur r ent   s t at e   i nt o   t he

t he   br ows er ' s   c ur r ent   l oc at i on.



t oURL ( )
l et

{
u   =   new  URL ( wi ndow. l oc at i on) ;



u. s ear c hPar ams . s et ( " c x" , u. s ear c hPar ams . s et ( " c y" , u. s ear c hPar ams . s et ( " pp" ,
u. s ear c hPar ams . s et ( " i t " ,

t hi s . c x) ; t hi s . c y) ;
t hi s . per Pi xel ) ;
t hi s . maxI t er at i ons ) ;

r et ur n   u. hr ef ; }
}



/ /   Thes e   c ons t ant s c omput at i on.
/ /   You   may   need   t o c omput er .

c ont r ol	t he   par al l el i s m of    t he   Mandel br ot   s et

adj us t   t hem t o   get   opt i mum per f or manc e   on   your

c ons t   ROWS   =   3,	COL S   =   4,	NUMWORKERS   = navi gat or . har dwar eConc ur r enc y   ||   2;

/ /   Thi s   i s   t he   mai n   c l as s   of    our   Mandel br ot   s et   pr ogr am.	Si mpl y i nvoke   t he
/ /   c ons t r uc t or   f unc t i on   wi t h   t he   <c anvas >   el ement   t o   r ender   i nt o. The   pr ogr am
/ /   as s umes   t hat   t hi s   <c anvas >   el ement   i s   s t yl ed   s o   t hat   i t   i s al ways   as   bi g
/ /   as   t he   br ows er   wi ndow. c l as s   Mandel br ot Canvas   {
c ons t r uc t or ( c anvas )    {

/ / i ni t i al i z e

St or e   t he   c anvas ,	get   i t s   c ont ext   obj ec t ,	and a   Wor ker Pool

t hi s . c anvas   =   c anvas ;
t hi s . c ont ext   =   c anvas . get Cont ext ( " 2d" ) ;
t hi s . wor ker Pool	=   new  Wor ker Pool ( NUMWORKERS, " mandel br ot Wor ker . j s " ) ;

/ /   Def i ne   s ome   pr oper t i es   t hat   we' l l	us e   l at er
t hi s . t i l es   =   nul l ;	/ /   Subr egi ons   of    t he   c anvas t hi s . pendi ngRender   =   nul l ;	/ /   We' r e   not   c ur r ent l y
r ender i ng
t hi s . want s Rer ender   =   f al s e;	/ /   No   r ender   i s   c ur r ent l y r eques t ed
t hi s . r es i z eTi mer   =   nul l ;	/ /   Pr event s   us   f r om r es i z i ng t oo   f r equent l y
t hi s . c ol or Tabl e   =   nul l ;	/ /   For   c onver t i ng   r aw  dat a   t o pi xel	val ues .

/ /   Set   up   our   event   handl er s
t hi s . c anvas . addEvent L i s t ener ( " poi nt er down" ,	e   => t hi s . handl ePoi nt er ( e) ) ;
wi ndow. addEvent L i s t ener ( " keydown" ,	e   => t hi s . handl eKey( e) ) ;
wi ndow. addEvent L i s t ener ( " r es i z e" ,	e   => t hi s . handl eRes i z e( e) ) ;
wi ndow. addEvent L i s t ener ( " pops t at e" ,	e   => t hi s . s et St at e( e. s t at e,	f al s e) ) ;

/ /   I ni t i al i z e   our   s t at e   f r om t he   URL   or   s t ar t   wi t h   t he i ni t i al	s t at e.
t hi s . s t at e   =
PageSt at e. f r omURL ( wi ndow. l oc at i on)    || PageSt at e. i ni t i al St at e( ) ;

/ /   Save   t hi s   s t at e   wi t h   t he   hi s t or y   mec hani s m.
hi s t or y. r epl ac eSt at e( t hi s . s t at e,	" " ,	t hi s . s t at e. t oURL ( ) ) ;

/ /   Set   t he   c anvas   s i z e   and   get   an   ar r ay   of    t i l es   t hat c over   i t .
t hi s . s et Si z e( ) ;

/ /   And   r ender   t he   Mandel br ot   s et   i nt o   t he   c anvas . t hi s . r ender ( ) ;
}

/ /   Set   t he   c anvas   s i z e   and   i ni t i al i z e   an   ar r ay   of    Ti l e obj ec t s .	Thi s
/ /   met hod   i s   c al l ed   f r om t he   c ons t r uc t or   and   al s o   by   t he handl eRes i z e( )
/ /   met hod   when   t he   br ows er   wi ndow  i s   r es i z ed. s et Si z e( )    {
t hi s . wi dt h   =   t hi s . c anvas . wi dt h   =   wi ndow. i nner Wi dt h;
t hi s . hei ght   =   t hi s . c anvas . hei ght   =   wi ndow. i nner Hei ght ;
t hi s . t i l es   =   [ . . . Ti l e. t i l es ( t hi s . wi dt h,	t hi s . hei ght ,	ROWS, COL S) ] ;
}

/ /   Thi s   f unc t i on   makes   a   c hange   t o   t he   PageSt at e,	t hen   r e-r ender s   t he
/ /   Mandel br ot   s et   us i ng   t hat   new  s t at e,	and   al s o   s aves   t he   new s t at e   wi t h
/ /   hi s t or y. pus hSt at e( ) .	I f    t he   f i r s t   ar gument   i s   a   f unc t i on t hat   f unc t i on
/ /   wi l l	be   c al l ed   wi t h   t he   s t at e   obj ec t   as   i t s   ar gument   and s houl d   make
/ /   c hanges   t o   t he   s t at e.	I f    t he   f i r s t   ar gument   i s   an   obj ec t , t hen   we   s i mpl y
/ /   c opy   t he   pr oper t i es   of    t hat   obj ec t   i nt o   t he   s t at e   obj ec t . I f    t he   opt i onal
/ /   s ec ond   ar gument   i s   f al s e,	t hen   t he   new  s t at e   wi l l	not   be s aved.	( We
/ /   do   t hi s   when   c al l i ng   s et St at e   i n   r es pons e   t o   a   pops t at e event . )
s et St at e( f ,	s ave=t r ue)    {


/ /   I f    t he   ar gument s t at e.
/ /   Ot her wi s e,	c opy

i s   a   f unc t i on,

i t s   pr oper t i es

c al l	i t   t o   updat e   t he

i nt o   t he   c ur r ent   s t at e.

i f    ( t ypeof    f    ===   " f unc t i on" )    { f ( t hi s . s t at e) ;
}    el s e   {
f or ( l et   pr oper t y   i n   f )    {
t hi s . s t at e[ pr oper t y]    =   f [ pr oper t y] ; }
}

/ /   I n   ei t her   c as e,	s t ar t   r ender i ng   t he   new  s t at e   ASAP. t hi s . r ender ( ) ;


/ /   Nor mal l y c al l ed   wi t h
/ /   a   s ec ond pops t at e   event .

we   s ave   t he

ar gument   of

new  s t at e.	Exc ept

f al s e   whi c h   we   do

when   we' r e

when   we   get   a

i f    ( s ave)    {
hi s t or y. pus hSt at e( t hi s . s t at e,	" " ,	t hi s . s t at e. t oURL ( ) ) ; }
}

/ /   Thi s   met hod   as ync hr onous l y   dr aws   t he   por t i on   of    t he Mandel br ot   s et
/ /   s pec i f i ed   by   t he   PageSt at e   obj ec t   i nt o   t he   c anvas .	I t   i s c al l ed   by
/ /   t he   c ons t r uc t or ,	by   s et St at e( )    when   t he   s t at e   c hanges ,	and by   t he
/ /   r es i z e   event   handl er   when   t he   s i z e   of    t he   c anvas   c hanges . r ender ( )    {
/ /   Somet i mes   t he   us er   may   us e   t he   keyboar d   or   mous e   t o r eques t   r ender s
/ /   mor e   qui c kl y   t han   we   c an   per f or m t hem.	We   don' t   want   t o s ubmi t   al l
/ /   t he   r ender s   t o   t he   wor ker   pool .	I ns t ead   i f    we' r e r ender i ng,	we' l l
/ /   j us t   make   a   not e   t hat   a   new  r ender   i s   needed,	and   when t he   c ur r ent
/ /   r ender   c ompl et es ,	we' l l	r ender   t he   c ur r ent   s t at e, pos s i bl y   s ki ppi ng
/ /   mul t i pl e   i nt er medi at e   s t at es .
i f    ( t hi s . pendi ngRender )    {	/ /   I f    we' r e   al r eady r ender i ng,
t hi s . want s Rer ender   =   t r ue;	/ /   make   a   not e   t o r er ender   l at er

r et ur n;	/ /   and   don' t   do   anyt hi ng mor e   now.
}

/ /   Get   our   s t at e   var i abl es   and   c omput e   t he   c ompl ex   number f or   t he
/ /   upper   l ef t   c or ner   of    t he   c anvas .
l et   { c x,	c y,	per Pi xel ,	maxI t er at i ons }    =   t hi s . s t at e;

l et   x0   =   c x   -
l et   y0   =   c y   -

per Pi xel
per Pi xel

*   t hi s . wi dt h/ 2;
*   t hi s . hei ght / 2;



/ /   For   eac h   of    our mes s age
/ /   f or   t he   c ode   i n r es ul t i ng   Pr omi s e
/ /   obj ec t s   i nt o   an

ROWS*COL S   t i l es ,	c al l	addWor k( )    wi t h   a

mandel br ot Wor ker . j s .	Col l ec t   t he

ar r ay.

l et   pr omi s es   =   t hi s . t i l es . map( t i l e   => t hi s . wor ker Pool . addWor k( {
t i l e:	t i l e,

x0:	x0   +   t i l e. x
y0:	y0   +   t i l e. y

*   per Pi xel ,
*   per Pi xel ,

per Pi xel :	per Pi xel ,
maxI t er at i ons :	maxI t er at i ons } ) ) ;

/ /   Us e   Pr omi s e. al l ( )    t o   get   an   ar r ay   of    r es pons es   f r om t he ar r ay   of
/ /   pr omi s es .	Eac h   r es pons e   i s   t he   c omput at i on   f or   one   of our   t i l es .
/ /   Rec al l	f r om mandel br ot Wor ker . j s   t hat   eac h   r es pons e i nc l udes   t he
/ /   Ti l e   obj ec t ,	an   I mageDat a   obj ec t   t hat   i nc l udes i t er at i on   c ount s
/ /   i ns t ead   of    pi xel	val ues ,	and   t he   mi ni mum and   maxi mum i t er at i ons
/ /   f or   t hat   t i l e.
t hi s . pendi ngRender   =   Pr omi s e. al l ( pr omi s es ) . t hen( r es pons es
=>   {



al l	t i l es .

t he   pi xel s .

/ /   Fi r s t ,	f i nd   t he   over al l	max

/ /   We   need   t hes e   number s   s o   we

and   mi n   i t er at i ons   over

c an   as s i gn   c ol or s   t o

l et   mi n   =   maxI t er at i ons ,	max   =   0; f or ( l et   r   of    r es pons es )    {
i f    ( r . mi n   <   mi n)    mi n   =   r . mi n;

i f    ( r . max   >   max)    max   =   r . max; }

/ /   Now  we   need   a   way   t o   c onver t   t he   r aw  i t er at i on c ount s   f r om t he
/ /   wor ker s   i nt o   pi xel	c ol or s   t hat   wi l l	be   di s pl ayed   i n t he   c anvas .
/ /   We   know  t hat   al l	t he   pi xel s   have   bet ween   mi n   and max   i t er at i ons
/ /   s o   we   pr ec omput e   t he   c ol or s   f or   eac h   i t er at i on c ount   and   s t or e
/ /   t hem i n   t he   c ol or Tabl e   ar r ay.


/ / i s   no   l onger
/ /

I f    we   haven' t   al l oc at ed   a   c ol or

t he   r i ght   s i z e,	t hen   al l oc at e   a

t abl e   yet ,	or   i f    i t

new  one.

i f    ( ! t hi s . c ol or Tabl e   ||   t hi s . c ol or Tabl e. l engt h   ! == maxI t er at i ons +1) {
t hi s . c ol or Tabl e   =   new Ui nt 32Ar r ay( maxI t er at i ons +1) ;
}

/ /   Gi ven   t he   max   and   t he   mi n,	c omput e   appr opr i at e val ues   i n   t he
/ /   c ol or   t abl e.	Pi xel s   i n   t he   s et   wi l l	be   c ol or ed f ul l y   opaque
/ /   bl ac k.	Pi xel s   out s i de   t he   s et   wi l l	be   t r ans l uc ent bl ac k   wi t h   hi gher
/ /   i t er at i on   c ount s   r es ul t i ng   i n   hi gher   opac i t y. Pi xel s   wi t h
/ /   mi ni mum i t er at i on   c ount s   wi l l	be   t r ans par ent   and t he   whi t e
/ /   bac kgr ound   wi l l	s how  t hr ough,	r es ul t i ng   i n   a gr ays c al e   i mage.
i f    ( mi n   ===   max)    {	/ /   I f    al l	t he   pi xel s ar e   t he   s ame,
i f    ( mi n   ===   maxI t er at i ons )    {	/ /   Then   make   t hem al l	bl ac k
t hi s . c ol or Tabl e[ mi n]    =   0xFF000000;
}    el s e   {	/ /   Or   al l t r ans par ent .
t hi s . c ol or Tabl e[ mi n]    =   0; }
}    el s e   {
/ /   I n   t he   nor mal	c as e   wher e   mi n   and   max   ar e di f f er ent ,	us e   a



i t er at i on   c ount

s hi f t   l ef t

/ /   l ogar i t hi c   s c al e   t o   as s i gn an
/ /   opac i t y   bet ween   0   and   255,

/ /   oper at or   t o   t ur n   t hat   i nt o

eac h   pos s i bl e

and   t hen   us e   t he

a   pi xel	val ue.

l et   maxl og   =   Mat h. l og( 1+max- mi n) ; f or ( l et   i    =   mi n;    i    <=   max;    i ++)    {
t hi s . c ol or Tabl e[ i ]    =
( Mat h. c ei l ( Mat h. l og( 1+i - mi n) / maxl og   *   255) <<   24) ;
} }


/ / r es pons e' s
/ /

Now  t r ans l at e   t he   i t er at i on   number s   i n   eac h

I mageDat a   t o   c ol or s   f r om t he   c ol or Tabl e.

f or ( l et   r   of    r es pons es )    { l et   i t er at i ons   =   new
Ui nt 32Ar r ay( r . i mageDat a. dat a. buf f er ) ;
f or ( l et   i	=   0;	i	<   i t er at i ons . l engt h;	i ++)    { i t er at i ons [ i ]    =
t hi s . c ol or Tabl e[ i t er at i ons [ i ] ] ; }
}

/ /   Fi nal l y,	r ender   al l	t he   i mageDat a   obj ec t s   i nt o t hei r
/ /   c or r es pondi ng   t i l es   of    t he   c anvas   us i ng put I mageDat a( ) .
/ /   ( Fi r s t ,	t hough,	r emove   any   CSS   t r ans f or ms   on   t he c anvas   t hat   may
/ /   have   been   s et   by   t he   poi nt er down   event   handl er . ) t hi s . c anvas . s t yl e. t r ans f or m =   " " ;
f or ( l et   r   of    r es pons es )    {
t hi s . c ont ext . put I mageDat a( r . i mageDat a,	r . t i l e. x, r . t i l e. y) ;
} } )
. c at c h( ( r eas on)    =>   {


we' l l	l og

hel p   wi t h

/ /   I f    anyt hi ng   went   wr ong   i n   any

/ /   an   er r or   her e.	Thi s   s houl dn' t

/ /   debuggi ng   i f    i t   does .

of    our   Pr omi s es ,

happen,	but   t hi s   wi l l

c ons ol e. er r or ( " Pr omi s e   r ej ec t ed   i n   r ender ( ) : " ,

r eas on) ;
} )
. f i nal l y( ( )    =>   {
/ /   When   we   ar e   done   r ender i ng,	c l ear   t he   pendi ngRender f l ags
t hi s . pendi ngRender   =   nul l ;
/ /   And   i f    r ender   r eques t s   c ame   i n   whi l e   we   wer e   bus y, r er ender   now.
i f    ( t hi s . want s Rer ender )    {
t hi s . want s Rer ender   =   f al s e; t hi s . r ender ( ) ;
} } ) ;
}

/ /   I f    t he   us er   r es i z es   t he   wi ndow,	t hi s   f unc t i on   wi l l	be c al l ed   r epeat edl y.
/ /   Res i z i ng   a   c anvas   and   r er ender i ng   t he   Mandl ebr ot   s et   i s   an expens i ve
/ /   oper at i on   t hat   we   c an' t   do   mul t i pl e   t i mes   a   s ec ond,	s o   we us e   a   t i mer
/ /   t o   def er   handl i ng   t he   r es i z e   unt i l	200ms   have   el aps ed   s i nc e t he   l as t
/ /   r es i z e   event   was   r ec ei ved. handl eRes i z e( event )    {
/ /   I f    we   wer e   al r eady   def er r i ng   a   r es i z e,	c l ear   i t .
i f    ( t hi s . r es i z eTi mer )    c l ear Ti meout ( t hi s . r es i z eTi mer ) ; / /   And   def er   t hi s   r es i z e   i ns t ead.
t hi s . r es i z eTi mer   =   s et Ti meout ( ( )    =>   {
t hi s . r es i z eTi mer   =   nul l ;	/ /   Not e   t hat   r es i z e   has   been handl ed
t hi s . s et Si z e( ) ;	/ /   Res i z e   c anvas   and   t i l es
t hi s . r ender ( ) ;	/ /   Rer ender   at   t he   new  s i z e } ,	200) ;
}

/ /   I f    t he   us er   pr es s es   a   key,	t hi s   event   handl er   wi l l	be c al l ed.
/ /   We   c al l	s et St at e( )    i n   r es pons e   t o   var i ous   keys ,	and s et St at e( )    r ender s
/ /   t he   new  s t at e,	updat es   t he   URL ,	and   s aves   t he   s t at e   i n br ows er   hi s t or y.
handl eKey( event )    {
s wi t c h( event . key)    {
c as e   " Es c ape" :	/ /   Type   Es c ape   t o   go   bac k   t o   t he

i ni t i al	s t at e
t hi s . s et St at e( PageSt at e. i ni t i al St at e( ) ) ; br eak;
c as e   " +" :	/ /   Type   +   t o   i nc r eas e   t he   number   of i t er at i ons
t hi s . s et St at e( s   =>   {
s . maxI t er at i ons   =   Mat h. r ound( s . maxI t er at i ons *1. 5) ; } ) ;
br eak;
c as e   " - " :	/ /   Type   -    t o   dec r eas e   t he   number   of i t er at i ons
t hi s . s et St at e( s   =>   {
s . maxI t er at i ons   =   Mat h. r ound( s . maxI t er at i ons / 1. 5) ; i f    ( s . maxI t er at i ons   <   1)    s . maxI t er at i ons   =   1;
} ) ;
br eak;
c as e   " o" :	/ /   Type   o   t o   z oom out t hi s . s et St at e( s   =>   s . per Pi xel	*=   2) ; br eak;
c as e   " Ar r owUp" :	/ /   Up   ar r ow  t o   s c r ol l	up
t hi s . s et St at e( s   =>   s . c y   - =   t hi s . hei ght / 10   * s . per Pi xel ) ;
br eak;
c as e   " Ar r owDown" :      / /   Down   ar r ow  t o   s c r ol l    down t hi s . s et St at e( s   =>   s . c y   +=   t hi s . hei ght / 10   *
s . per Pi xel ) ;
br eak;
c as e   " Ar r owL ef t " :	/ /   L ef t   ar r ow  t o   s c r ol l	l ef t t hi s . s et St at e( s   =>   s . c x   - =   t hi s . wi dt h/ 10   *
s . per Pi xel ) ;
br eak;
c as e   " Ar r owRi ght " :	/ /   Ri ght   ar r ow  t o   s c r ol l	r i ght t hi s . s et St at e( s   =>   s . c x   +=   t hi s . wi dt h/ 10   *
s . per Pi xel ) ;
br eak; }
}


/ /   Thi s   met hod   i s   c al l ed t he   c anvas .
/ /   The   poi nt er down   event ( a   c l i c k   or
/ /   t ap)    or   a   pan   ges t ur e handl er s   f or

when   we   get   a   poi nt er down   event   on

mi ght   be   t he   s t ar t   of    a   z oom ges t ur e

( a   dr ag) .	Thi s   handl er   r egi s t er s


/ /   t he   poi nt er move   and   poi nt er up   event s   i n   or der t he   r es t
/ /   of    t he   ges t ur e.	( Thes e   t wo   ext r a   handl er s   ar e t he   ges t ur e
/ /   ends   wi t h   a   poi nt er up. )

t o   r es pond   t o

r emoved   when

handl ePoi nt er ( event )    {
/ /   The   pi xel	c oor di nat es   and   t i me   of    t he   i ni t i al	poi nt er down.
/ /   Bec aus e   t he   c anvas   i s   as   bi g   as   t he   wi ndow,	t hes e   event c oor di nat es
/ /   ar e   al s o   c anvas   c oor di nat es .
c ons t   x0   =   event . c l i ent X,	y0   =   event . c l i ent Y,	t 0   =
Dat e. now( ) ;

/ /   Thi s   i s   t he   handl er   f or   move   event s . c ons t   poi nt er MoveHandl er   =   event   =>   {
/ /   How  muc h   have   we   moved,	and   how  muc h   t i me   has pas s ed?
l et   dx=event . c l i ent X- x0,	dy=event . c l i ent Y- y0,
dt =Dat e. now( ) - t 0;


/ /   I f    t he   poi nt er   has   moved   enough   or   enough pas s ed   t hat
/ /   t hi s   i s   not   a   r egul ar   c l i c k,	t hen   us e   CSS t he   di s pl ay.
/ /   ( We   wi l l	r er ender   i t   f or   r eal	when   we   get poi nt er up   event . )

t i me   has

t o   pan

t he

i f    ( dx   >   10   ||   dy   >   10   ||   dt   >   500)    {
t hi s . c anvas . s t yl e. t r ans f or m =   ` t r ans l at e( ${ dx} px, ${ dy} px) ` ;
} } ;

/ /   Thi s   i s   t he   handl er   f or   poi nt er up   event s c ons t   poi nt er UpHandl er   =   event   =>   {

/ /   When   t he r emove
/ /   t he   move

poi nt er   goes   up,	t he   ges t ur e   i s   over ,	s o

and   up   handl er s   unt i l	t he   next   ges t ur e.

t hi s . c anvas . r emoveEvent L i s t ener ( " poi nt er move" , poi nt er MoveHandl er ) ;
t hi s . c anvas . r emoveEvent L i s t ener ( " poi nt er up" , poi nt er UpHandl er ) ;

/ /   How  muc h   di d   t he   poi nt er   move,	and   how  muc h   t i me pas s ed?
c ons t   dx   =   event . c l i ent X- x0,	dy=event . c l i ent Y- y0,

dt =Dat e. now( ) - t 0;
/ /   Unpac k   t he   s t at e   obj ec t   i nt o   i ndi vi dual	c ons t ant s . c ons t   { c x,	c y,	per Pi xel }    =   t hi s . s t at e;


/ / pas s ed,	t hen
/ / t o   c hange
/ / t apped   on   a
/ / poi nt .

I f    t he   poi nt er   moved   f ar   enough   or   i f    enough   t i me

t hi s   was   a   pan   ges t ur e,	and   we   need   t o   c hange   s t at e

t he   c ent er   poi nt .	Ot her wi s e,	t he   us er   c l i c ked   or

poi nt   and   we   need   t o   c ent er   and   z oom i n   on   t hat

i f    ( dx   >   10   ||   dy   >   10   ||   dt   >   500)    {
/ /   The   us er   panned   t he   i mage   by   ( dx,	dy)    pi xel s .
/ /   Conver t   t hos e   val ues   t o   of f s et s   i n   t he   c ompl ex pl ane.
t hi s . s et St at e( { c x:	c x   -    dx*per Pi xel ,	c y:	c y   -
dy*per Pi xel } ) ;

}

c ent er   moves .

el s e   {
/ /   The   us er   c l i c ked.	Comput e   how  many   pi xel s   t he



l et   c dx   =   x0   -
l et   c dy   =   y0   -

t hi s . wi dt h/ 2;
t hi s . hei ght / 2;


/ /   Us e   CSS   t o   qui c kl y   and   t empor ar i l y   z oom i n t hi s . c anvas . s t yl e. t r ans f or m =
` t r ans l at e( ${ - c dx*2} px,	${ - c dy*2} px) s c al e( 2) ` ;


/ / poi nt   and
/ /

Set   t he   c ompl ex   c oor di nat es   of    t he   new  c ent er

z oom i n   by   a   f ac t or   of    2.

t hi s . s et St at e( s   =>   {

s . c x   +=   c dx
s . c y   +=   c dy

*   s . per Pi xel ;
*   s . per Pi xel ;

s . per Pi xel	/ =   2; } ) ;
} } ;

/ /   When   t he   us er   begi ns   a   ges t ur e   we   r egi s t er   handl er s   f or t he
/ /   poi nt er move   and   poi nt er up   event s   t hat   f ol l ow. t hi s . c anvas . addEvent L i s t ener ( " poi nt er move" ,
poi nt er MoveHandl er ) ;

t hi s . c anvas . addEvent L i s t ener ( " poi nt er up" , poi nt er UpHandl er ) ;
} }


/ /   Fi nal l y,	her e' s   how  we   s et   up   t he J avaSc r i pt   f i l e
/ /   i s   s el f - s uf f i c i ent .	The   HTML   f i l e one   <s c r i pt >.

c anvas .	Not e   t hat   t hi s

onl y   needs   t o   i nc l ude   t hi s

l et   c anvas   =   doc ument . c r eat eEl ement ( " c anvas " ) ;	/ /   Cr eat e   a   c anvas el ement
doc ument . body. append( c anvas ) ;	/ /   I ns er t   i t   i nt o t he   body
doc ument . body. s t yl e   =   " mar gi n: 0" ;	/ /   No   mar gi n   f or t he   <body>
c anvas . s t yl e. wi dt h   =   " 100%" ;	/ /   Make   c anvas   as wi de   as   body
c anvas . s t yl e. hei ght   =   " 100%" ;	/ /   and   as   hi gh   as t he   body.
new  Mandel br ot Canvas ( c anvas ) ;	/ /   And   s t ar t r ender i ng   i nt o   i t !


15.15 Summary and Suggestions for Further Reading

This long chapter has covered the fundamentals of client-side JavaScript programming:

How scripts and JavaScript modules are included in web pages and how and when they are executed.

Client-side JavaScript’s asynchronous, event-driven programming model.

The Document Object Model (DOM) that allows JavaScript code to inspect and modify the HTML content of the document it is embedded within. This DOM API is the heart of all client-side JavaScript programming.

How JavaScript code can manipulate the CSS styles that are

applied to content within the document.

How JavaScript code can obtain the coordinates of document elements in the browser window and within the document itself.

How to create reusable UI “Web Components” with JavaScript, HTML, and CSS using the Custom Elements and Shadow DOM APIs.

How to display and dynamically generate graphics with SVG and the HTML <canvas > element.

How to add scripted sound effects (both recorded and synthesized) to your web pages.

How JavaScript can make the browser load new pages, go backward and forward in the user’s browsing history, and even add new entries to the browsing history.

How JavaScript programs can exchange data with web servers using the HTTP and WebSocket protocols.

How JavaScript programs can store data in the user’s browser.

How JavaScript programs can use worker threads to achieve a safe form of concurrency.

This has been the longest chapter of the book, by far. But it cannot come close to covering all the APIs available to web browsers. The web platform is sprawling and ever-evolving, and my goal for this chapter was to introduce the most important core APIs. With the knowledge you have from this book, you are well equipped to learn and use new APIs as you need them. But you can’t learn about a new API if you don’t know that it exists, so the short sections that follow end the chapter with a quick list of web platform features that you might want to investigate in the future.


15.15.1 HTML and CSS

The web is built upon three key technologies: HTML, CSS, and JavaScript, and knowledge of JavaScript can take you only so far as a web developer unless you also develop your expertise with HTML and CSS. It is important to know how to use JavaScript to manipulate HTML elements and CSS styles, but that knowledge is is much more useful if you also know which HTML elements and which CSS styles to use.


So before you start exploring more JavaScript APIs, I would encourage you to invest some time in mastering the other tools in a web developer’s toolkit. HTML form and input elements, for example, have sophisticated behavior that is important to understand, and the flexbox and grid layout modes in CSS are incredibly powerful.


Two topics worth paying particular attention to in this area are accessibility (including ARIA attributes) and internationalization (including support for right-to-left writing directions).


15.15.2 Performance

Once you have written a web application and released it to the world, the never-ending quest to make it fast begins. It is hard to optimize things that you can’t measure, however, so it is worth familiarizing yourself with the Performance APIs. The per f or mance property of the window object is the main entry point to this API. It includes a high-resolution time source per f or mance. now( ) , and methods per f or mance. mar k( )  and per f or mance. meas ur e( )  for marking critical points in your code and measuring the elapsed time between them. Calling these methods creates PerformanceEntry objects that you can access with
per f or mance. get Ent r i es ( ) . Browsers add their own PerformanceEntry objects any time the browser loads a new page or

fetches a file over the network, and these automatically created PerformanceEntry objects include granular timing details of your application’s network performance. The related PerformanceObserver class allows you to specify a function to be invoked when new PerformanceEntry objects are created.


15.15.3 Security

This chapter introduced the general idea of how to defend against cross-site scripting (XSS) security vulnerabilities in your websites, but we did not go into much detail. The topic of web security is an important one, and you may want to spend some time learning more about it. In addition to XSS, it is worth learning about the Cont ent - Secur i t y- Pol i cy HTTP header and understanding how CSP allows you to ask the web browser to restrict the capabilities it grants to JavaScript code. Understanding CORS (Cross-Origin Resource Sharing) is also important.


15.15.4 WebAssembly

WebAssembly (or “wasm”) is a low-level virtual machine bytecode format that is designed to integrate well with JavaScript interpreters in web browsers. There are compilers that allow you to compile C, C++, and Rust programs to WebAssembly bytecode and to run those programs in web browsers at close to native speed, without breaking the browser sandbox or security model. WebAssembly can export functions that can be called by JavaScript programs. A typical use case for WebAssembly would be to compile the standard C-language zlib compression library so that JavaScript code has access to high-speed compression and decompression algorithms. Learn more at https://webassembly.org.


15.15.5 More Document and Window Features

The Window and Document objects have a number of features that were not covered in this chapter:

The Window object defines al er t ( ) , conf i r m( ) , and
pr ompt ( )  methods that display simple modal dialogues to the user. These methods block the main thread. The conf i r m( ) method synchronously returns a boolean value, and pr ompt ( ) synchronously returns a string of user input. These are not suitable for production use but can be useful for simple projects and prototypes.

The navi gat or  and s cr een properties of the Window object were mentioned in passing at the start of this chapter, but the Navigator and Screen objects that they reference have some features that were not described here that you may find useful.

The r eques t Ful l s cr een( )  method of any Element object requests that that element (a <vi deo> or <canvas > element, for example) be displayed in fullscreen mode. The
exi t Ful l s cr een( )  method of the Document returns to normal display mode.

The r eques t Ani mat i onFr ame( )  method of the Window object takes a function as its argument and will execute that function when the browser is preparing to render the next frame. When you are making visual changes (especially repeated or animated ones), wrapping your code within a call to
r eques t Ani mat i onFr ame( )  can help to ensure that the changes are rendered smoothly and in a way that is optimized by the browser.

If the user selects text within your document, you can obtain details of that selection with the Window method
get Sel ect i on( )  and get the selected text with
get Sel ect i on( ) . t oSt r i ng( ) . In some browsers,
navi gat or . cl i pboar d is an object with an async API for reading and setting the content of the system clipboard to enable

copy-and-paste interactions with applications outside of the browser.

A little-known feature of web browsers is that HTML elements with a cont ent edi t abl e=" t r ue" attribute allow their content to be edited. The document . execCommand( ) method enables rich-text editing features for editable content.

A MutationObserver allows JavaScript to monitor changes to, or beneath, a specified element in the document. Create a MutationObserver with the Mut at i onObs er ver ( ) constructor, passing the callback function that should be called when changes are made. Then call the obs er ve( )  method of the MutationObserver to specify which parts of which element are to be monitored.

An IntersectionObserver allows JavaScript to determine which document elements are on the screen and which are close to being on the screen. It is particularly useful for applications that want to dynamically load content on demand as the user scrolls.


15.15.6 Events

The sheer number and diversity of events supported by the web platform can be daunting. This chapter has discussed a variety of event types, but here are some more that you may find useful:

Browsers fire “online” and “offline” events at the Window object when the browser gains or loses an internet connection.

Browsers fire a “visiblitychange” event at the Document object when a document becomes visible or invisible (usually because a user has switched tabs). JavaScript can check
document . vi s i bi l i t ySt at e to determine whether its document is currently “visible” or “hidden.”

Browsers support a complicated API to support drag-and-drop

UIs and to support data exchange with applications outside the browser. This API involves a number of events, including “dragstart,” “dragover,” “dragend,” and “drop.” This API is tricky to use correctly but useful when you need it. It is an important API to know about if you want to enable users to drag files from their desktop into your web application.

The Pointer Lock API enables JavaScript to hide the mouse pointer and get raw mouse events as relative movement amounts rather than absolute positions on the screen. This is typically useful for games. Call r eques t Poi nt er Lock( )  on the element you want all mouse events directed to. After you do this, “mousemove” events delivered to that element will have movement X and movement Y properties.

The Gamepad API adds support for game controllers. Use navi gat or . get Gamepads ( )  to get connected Gamepad objects, and listen for “gamepadconnected” events on the
Window object to be notified when a new controller is plugged in. The Gamepad object defines an API for querying the current state of the buttons on the controller.


15.15.7 Progressive Web Apps and Service Workers

The term Progressive Web Apps, or PWAs, is a buzzword that describes web applications that are built using a few key technologies. Careful documentation of these key technologies would require a book of its own, and I have not covered them in this chapter, but you should be aware of all of these APIs. It is worth noting that powerful modern APIs like these are typically designed to work only on secure HTTPS connections. Websites that are still using ht t p: / /  URLs will not be able to take advantage of these:

A ServiceWorker is a kind of worker thread with the ability to intercept, inspect, and respond to network requests from the web

application that it “services.” When a web application registers a service worker, that worker’s code becomes persistent in the browser’s local storage, and when the user visits the associated website again, the service worker is reactivated. Service workers can cache network responses (including files of JavaScript code), which means that web applications that use service workers can effectively install themselves onto the user’s computer for rapid startup and offline use. The Service Worker Cookbook at https://serviceworke.rs is a valuable resource for learning about service workers and their related technologies.

The Cache API is designed for use by service workers (but is also available to regular JavaScript code outside of workers). It works with the Request and Response objects defined by the f et ch( ) API and implements a cache of Request/Response pairs. The Cache API enables a service worker to cache the scripts and other assets of the web app it serves and can also help to enable offline use of the web app (which is particularly important for mobile devices).

A Web Manifest is a JSON-formatted file that describes a web application including a name, a URL, and links to icons in various sizes. If your web app uses a service worker and includes a <l i nk   r el =" mani f es t " > tag that references a
. webmani f es t  file, then browsers (particularly browsers on mobile devices) may give you the option to add an icon for the web app to your desktop or home screen.

The Notifications API allows web apps to display notifications using the native OS notification system on both mobile and desktop devices. Notifications can include an image and text, and your code can receive an event if the user clicks on the notification. Using this API is complicated by the fact that you must first request the user’s permission to display notifications.

The Push API allows web applications that have a service worker (and that have the user’s permission) to subscribe to notifications

from a server, and to display those notifications even when the application itself is not running. Push notifications are common on mobile devices, and the Push API brings web apps closer to feature parity with native apps on mobile.


15.15.8 Mobile Device APIs

There are a number of web APIs that are primarily useful for web apps running on mobile devices. (Unfortunately, a number of these APIs only work on Android devices and not iOS devices.)

The Geolocation API allows JavaScript (with the user’s permission) to determine the user’s physical location. It is well supported on desktop and mobile devices, including iOS devices. Use
navi gat or . geol ocat i on. get Cur r ent Pos i t i on( )  to request the user’s current position and use
navi gat or . geol ocat i on. wat chPos i t i on( )  to register a callback to be called when the user’s position changes.

The navi gat or . vi br at e( )  method causes a mobile device (but not iOS) to vibrate. Often this is only allowed in response to a user gesture, but calling this method will allow your app to provide silent feedback that a gesture has been recognized.

The ScreenOrientation API enables a web application to query the current orientation of a mobile device screen and also to lock themselves to landscape or portrait orientation.

The “devicemotion” and “deviceorientation” events on the window object report accelerometer and magnetometer data for the device, enabling you to determine how the device is accelerating and how the user is orienting it in space. (These events do work on iOS.)

The Sensor API is not yet widely supported beyond Chrome on Android devices, but it enables JavaScript access to the full suite

of mobile device sensors, including accelerometer, gyroscope, magnetometer, and ambient light sensor. These sensors enable JavaScript to determine which direction a user is facing or to detect when the user shakes their phone, for example.


15.15.9 Binary APIs

Typed arrays, ArrayBuffers, and the DataView class (all covered in §11.2) enable JavaScript to work with binary data. As described earlier in this chapter, the f et ch( )  API enables JavaScript programs to load binary data over the network. Another source of binary data is files from the user’s local filesystem. For security reasons, JavaScript can’t just read local files. But if the user selects a file for upload (using an <i nput
t ype=" f i l e> form element) or uses drag-and-drop to drop a file into your web application, then JavaScript can access that file as a File object.

File is a subclass of Blob, and as such, it is an opaque representation of a chunk of data. You can use a FileReader class to asynchronously get the content of a file as an ArrayBuffer or string. (In some browsers, you can skip the FileReader and instead use the Promise-based t ext ( )  and
ar r ayBuf f er ( )  methods defined by the Blob class, or the s t r eam( ) method for streaming access to the file contents.)

When working with binary data, especially streaming binary data, you may need to decode bytes into text or encode text as bytes. The TextEncoder and TextDecoder classes help with this task.


15.15.10 Media APIs

The navi gat or . medi aDevi ces . get Us er Medi a( )  function allows JavaScript to request access to the user’s microphone and/or video camera. A successful request results in a MediaStream object. Video

streams can be displayed in a <vi deo> tag (by setting the s r cObj ect property to the stream). Still frames of the video can be captured into an offscreen <canvas > with the canvas dr awI mage( )  function resulting in a relatively low-resolution photograph. Audio and video streams returned by get Us er Medi a( )  can be recorded and encoded to a Blob with a MediaRecorder object.

The more complex WebRTC API enables the transmission and reception of MediaStreams over the network, enabling peer-to-peer video conferencing, for example.


15.15.11 Cryptography and Related APIs

The cr ypt o property of the Window object exposes a
get RandomVal ues ( )  method for cryptographically secure pseudorandom numbers. Other methods for encryption, decryption, key generation, digital signatures, and so on are available through
cr ypt o. s ubt l e. The name of this property is a warning to everyone who uses these methods that properly using cryptographic algorithms is difficult and that you should not use those methods unless you really know what you are doing. Also, the methods of cr ypt o. s ubt l e are only available to JavaScript code running within documents that were loaded over a secure HTTPS connection.

The Credential Management API and the Web Authentication API allow JavaScript to generate, store, and retrieve public key (and other types of) credentials and enables account creation and login without passwords. The JavaScript API consists primarily of the functions
navi gat or . cr edent i al s . cr eat e( )  and
navi gat or . cr edent i al s . get ( ) , but substantial infrastructure is

required on the server side to make these methods work. These APIs are not universally supported yet, but have the potential to revolutionize the way we log in to websites.


The Payment Request API adds browser support for making credit card payments on the web. It allows users to store their payment details securely in the browser so that they don’t have to type their credit card number each time they make a purchase. Web applications that want to request a payment create a PaymentRequest object and call its s how( ) method to display the request to the user.





1





2



3






4

Previous editions of this book had an extensive reference section covering the JavaScript standard library and web APIs. It was removed in the seventh edition because MDN has made it obsolete: today, it is quicker to look something up on MDN than it is to flip through a book, and my former colleagues at MDN do a better job at keeping their online documentation up to date than this book ever could.

Some sources, including the HTML specification, make a technical distinction between handlers and listeners, based on the way in which they are registered. In this book, we treat the two terms as synonyms.

If you have used the React framework to create client-side user interfaces, this may surprise you. React makes a number of minor changes to the client-side event model, and one of them is that in React, event handler property names are written in camelCase: onCl i c k,
onMous eOver , and so on. When working with the web platform natively, however, the event handler properties are written entirely in lowercase.

The custom element specification allows subclassing of <but t on> and other specific element classes, but this is not supported in Safari and a different syntax is required to use a custom element that extends anything other than HTMLElement.



Chapter 16. Server-Side J avaScript with Node




Node is JavaScript with bindings to the underlying operating system, making it possible to write JavaScript programs that read and write files, execute child processes, and communicate over the network. This makes Node useful as a:

Modern alternative to shell scripts that does not suffer from the arcane syntax of bash and other Unix shells.

General-purpose programming language for running trusted programs, not subject to the security constraints imposed by web browsers on untrusted code.

Popular environment for writing efficient and highly concurrent web servers.

The defining feature of Node is its single-threaded event-based concurrency enabled by an asynchronous-by-default API. If you have programmed in other languages but have not done much JavaScript coding, or if you’re an experienced client-side JavaScript programmer used to writing code for web browers, using Node will be a bit of an adjustment, as is any new programming language or environment. This chapter begins by explaining the Node programming model, with an emphasis on concurrency, Node’s API for working with streaming data, and Node’s Buffer type for working with binary data. These initial sections are followed by sections that highlight and demonstrate some of the most important Node APIs, including those for working with files,

networks, processes, and threads.


One chapter is not enough to document all of Node’s APIs, but my hope is that this chapter will explain enough of the fundamentals to make you productive with Node, and confident that you can master any new APIs you need.



INSTALLING NODE

Node is open source software. Visit https://nodejs.org to download and install Node for Windows and MacOS. On Linux, you may be able to install Node with your normal package manager, or you can visit https://nodejs.org/en/download to download the binaries directly. If you work on containerized software, you can find official Node Docker images at https://hub.docker.com.

In addition to the Node executable, a Node installation also includes npm, a package manager that enables easy access to a vast ecosystem of JavaScript tools and libraries. The examples in this chapter will use only Node’s built-in packages and will not require npm or any external libraries.

Finally, do not overlook the official Node documentation, available at https://nodejs.org/api and https://nodejs.org/docs/guides. I have found it to be well organized and well written.




16.1 Node Programming Basics

We’ll begin this chapter with a quick look at how Node programs are structured and how they interact with the operating system.


16.1.1 Console Output

If you are used to JavaScript programming for web browsers, one of the minor surprises about Node is that cons ol e. l og( )  is not just for debugging, but is Node’s easiest way to display a message to the user, or, more generally, to send output to the stdout stream. Here’s the classic “Hello World” program in Node:

c ons ol e. l og( " Hel l o   Wor l d! " ) ;

There are lower-level ways to write to stdout, but no fancier or more official way than simply calling cons ol e. l og( ) .


In web browsers, cons ol e. l og( ) , cons ol e. war n( ) , and
cons ol e. er r or ( )  typically display little icons next to their output in the developer console to indicate the variety of the log message. Node does not do this, but output displayed with cons ol e. er r or ( )  is distinguished from output displayed with cons ol e. l og( )  because cons ol e. er r or ( )  writes to the stderr stream. If you’re using Node to write a program that is designed to have stdout redirected to a file or a pipe, you can use cons ol e. er r or ( )  to display text to the console where the user will see it, even though text printed with
cons ol e. l og( )  is hidden.


16.1.2 Command-Line Arguments and Environment Variables

If you have previously written Unix-style programs designed to be invoked from a terminal or other command-line interface, you know that these programs typically get their input primarily from command-line arguments and secondarily from environment variables.


Node follows these Unix conventions. A Node program can read its command-line arguments from the array of strings pr oces s . ar gv. The first element of this array is always the path to the Node executable. The second argument is the path to the file of JavaScript code that Node is executing. Any remaining elements in this array are the space-separated arguments that you passed on the command-line when you invoked Node.

For example, suppose you save this very short Node program to the file

argv.js:


c ons ol e. l og( pr oc es s . ar gv) ;


You can then execute the program and see output like this:


$   node   - - t r ac e- unc aught   ar gv. j s   - - ar g1   - - ar g2   f i l ename [
' / us r / l oc al / bi n/ node' ,
' / pr i vat e/ t mp/ ar gv. j s ' , ' - - ar g1' ,
' - - ar g2' ,
' f i l ename' ]


There are a couple of things to note here:


The first and second elements of pr oces s . ar gv will be fully qualified filesystem paths to the Node executable and the file of JavaScript that is being executed, even if you did not type them that way.

Command-line arguments that are intended for and interpreted by the Node executable itself are consumed by the Node executable and do not appear in pr oces s . ar gv. (The - - t r ace-uncaught  command-line argument isn’t actually doing anything useful in the previous example; it is just there to demonstrate that it does not appear in the output.) Any arguments (such as - - ar g1 and f i l ename) that appear after the name of the JavaScript file will appear in pr oces s . ar gv.

Node programs can also take input from Unix-style environment variables. Node makes these available though the pr oces s . env object. The property names of this object are environment variable names, and the property values (always strings) are the values of those variables.

Here is a partial list of environment variables on my system:

$   node   - p   - e   ' pr oc es s . env' {
SHEL L :	' / bi n/ bas h' , USER:    ' davi d' ,
PATH:	' / us r / l oc al / bi n: / us r / bi n: / bi n: / us r / s bi n: / s bi n' , PWD:    ' / t mp' ,
L ANG:	' en_US. UTF- 8' , HOME:	' / Us er s / davi d' ,
}


You can use node   - h or node   - - hel p to find out what the - p and - e command-line arguments do. However, as a hint, note that you could rewrite the line above as node   - - eval	' pr oces s . env'	- -
pr i nt .


16.1.3 Program Life Cycle

The node command expects a command-line argument that specifies the file of JavaScript code to be run. This initial file typically imports other modules of JavaScript code, and may also define its own classes and functions. Fundamentally, however, Node executes the JavaScript code in the specified file from top to bottom. Some Node programs exit when they are done executing the last line of code in the file. Often, however, a Node program will keep running long after the initial file has been executed. As we’ll discuss in the following sections, Node programs are often asynchronous and based on callbacks and event handlers. Node programs do not exit until they are done running the initial file and until all callbacks have been called and there are no more pending events. A Node-based server program that listens for incoming network connections will theoretically run forever because it will always be waiting for more events.

A program can force itself to exit by calling pr oces s . exi t ( ) . Users can usually terminate a Node program by typing Ctrl-C in the terminal window where the program is running. A program can ignore Ctrl-C by

registering a signal handler function with pr oces s . on( " SI GI NT" , ( ) =>{ } ) .


If code in your program throws an exception and no cat ch clause catches it, the program will print a stack trace and exit. Because of Node’s asynchronous nature, exceptions that occur in callbacks or event handlers must be handled locally or not handled at all, which means that handling exceptions that occur in the asynchronous parts of your program can be a difficult problem. If you don’t want these exceptions to cause your program to completely crash, register a global handler function that will be invoked instead of crashing:

pr oc es s . s et Unc aught Exc ept i onCapt ur eCal l bac k( e   =>   { c ons ol e. er r or ( " Unc aught   exc ept i on: " ,	e) ;
} ) ;


A similar situation arises if a Promise created by your program is rejected and there is no . cat ch( )  invocation to handle it. As of Node 13, this is not a fatal error that causes your program to exit, but it does print a verbose error message to the console. In some future version of Node, unhandled Promise rejections are expected to become fatal errors. If you do not want unhandled rejections, to print error messages or terminate your program, register a global handler function:

pr oc es s . on( " unhandl edRej ec t i on" ,	( r eas on,	pr omi s e)    =>   {
/ /   r eas on   i s   what ever   val ue   woul d   have   been   pas s ed   t o   a . c at c h( )    f unc t i on
/ /   pr omi s e   i s   t he   Pr omi s e   obj ec t   t hat   r ej ec t ed } ) ;


16.1.4 Node Modules

Chapter 10 documented JavaScript module systems, covering both Node

modules and ES6 modules. Because Node was created before JavaScript had a module system, Node had to create its own. Node’s module system uses the r equi r e( )  function to import values into a module and the expor t s  object or the modul e. expor t s  property to export values from a module. These are a fundamental part of the Node programming model, and they are covered in detail in §10.2.

Node 13 adds support for standard ES6 modules as well as require-based modules (which Node calls “CommonJS modules”). The two module systems are not fully compatible, so this is somewhat tricky to do. Node needs to know—before it loads a module—whether that module will be using r equi r e( )  and modul e. expor t s  or if it will be using
i mpor t  and expor t . When Node loads a file of JavaScript code as a CommonJS module, it automatically defines the r equi r e( )  function along with identifiers expor t s  and modul e, and it does not enable the i mpor t  and expor t  keywords. On the other hand, when Node loads a file of code as an ES6 module, it must enable the i mpor t  and expor t declarations, and it must not define extra identifiers like r equi r e, modul e, and expor t s .


The simplest way to tell Node what kind of module it is loading is to encode this information in the file extension. If you save your JavaScript code in a file that ends with .mjs, then Node will always load it as an ES6 module, will expect it to use i mpor t  and expor t , and will not provide a r equi r e( )  function. And if you save your code in a file that ends with .cjs, then Node will always treat it as a CommonJS module, will provide a r equi r e( )  function, and will throw a SyntaxError if you use i mpor t
or expor t  declarations.


For files that do not have an explicit .mjs or .cjs extension, Node looks for

a file named package.json in the same directory as the file and then in each of the containing directories. Once the nearest package.json file is found, Node checks for a top-level t ype property in the JSON object. If the value of the t ype property is “module”, then Node loads the file as an ES6 module. If the value of that property is “commonjs”, then Node loads the file as a CommonJS module. Note that you do not need to have a package.json file to run Node programs: when no such file is found (or when the file is found but it does not have a t ype property), Node defaults to using CommonJS modules. This package.json trick only becomes necessary if you want to use ES6 modules with Node and do not want to use the .mjs file extension.

Because there is an enormous amount of existing Node code written using CommonJS module format, Node allows ES6 modules to load CommonJS modules using the i mpor t  keyword. The reverse is not true, however: a CommonJS module cannot use r equi r e( )  to load an ES6 module.


16.1.5 The Node Package Manager

When you install Node, you typically get a program named npm as well. This is the Node Package Manager, and it helps you download and manage libraries that your program depends on. npm keeps track of those dependencies (as well as other information about your program) in a file named package.json in the root directory of your project. This package.json file created by npm is where you would add
" t ype" : " modul e" if you wanted to use ES6 modules for your project.


This chapter does not cover npm in any detail (but see §17.4 for a little more depth). I’m mentioning it here because unless you write programs that do not use any external libraries, you will almost certainly be using

npm or a tool like it. Suppose, for example, that you are going to be developing a web server and plan to use the Express framework (https://expressjs.com) to simplify the task. To get started, you might create a directory for your project, and then, in that directory type npm
i ni t . npm will ask you for your project name, version number, etc., and will then create an initial package.json file based on your responses.

Now to start using Express, you’d type npm i ns t al l	expr es s . This tells npm to download the Express library along with all of its dependencies and install all the packages in a local node_modules/ directory:

$   npm i ns t al l	expr es s
npm not i c e   c r eat ed   a   l oc kf i l e   as   pac kage- l oc k. j s on.	You   s houl d c ommi t   t hi s   f i l e.
npm WARN  my- s er ver @1. 0. 0   No   des c r i pt i on
npm WARN  my- s er ver @1. 0. 0   No   r epos i t or y   f i el d.

+   expr es s @4. 17. 1
added   50   pac kages   f r om 37   c ont r i but or s   and   audi t ed   126   pac kages i n   3. 058s
f ound   0   vul ner abi l i t i es


When you install a package with npm, npm records this dependency—that your project depends on Express—in the package.json file. With this dependency recorded in package.json, you could give another programmer a copy of your code and your package.json, and they could simply type npm i ns t al l  to automatically download and install all of the libraries that your program needs in order to run.


16.2 Node Is Asynchronous by Default

JavaScript is a general-purpose programming language, so it is perfectly possible to write CPU-intensive programs that multiply large matrices or

perform complicated statistical analyses. But Node was designed and optimized for programs—like network servers—that are I/O intensive. And in particular, Node was designed to make it possible to easily implement highly concurrent servers that can handle many requests at the same time.


Unlike many programming languages, however, Node does not achieve concurrency with threads. Multithreaded programming is notoriously hard to do correctly, and difficult to debug. Also, threads are a relatively heavyweight abstraction and if you want to write a server that can handle hundreds of concurrent requests, using hundreds of threads may require a prohibitive amount of memory. So Node adopts the single-threaded JavaScript programming model that the web uses, and this turns out to be a vast simplification that makes the creation of network servers a routine skill rather than an arcane one.



TRUE PARALLELISM WITH NODE

Node programs can run multiple operating system processes, and Node 10 and later support Worker objects (§16.11), which are a kind of thread borrowed from web browsers. If you use multiple processes or create one or more Worker threads and run your program on a system with more than one CPU, then your program will no longer be single-threaded and your program will truly be executing multiple streams of code in parallel. These techniques can be valuable for CPU-intensive operations but are not commonly used for I/O-intensive programs like servers.

It is worth noting, however, that Node’s processes and Workers avoid the typical complexity of multithreaded programming because interprocess and inter-Worker communication is via message passing and they cannot easily share memory with each other.



Node achieves high levels of concurrency while maintaining a single-threaded programming model by making its API asynchronous and nonblocking by default. Node takes its nonblocking approach very seriously and to an extreme that may surprise you. You probably expect functions that read from and write to the network to be asynchronous, but

Node goes further and defines nonblocking asynchronous functions for reading and writing files from the local filesystem. This makes sense, when you think about it: the Node API was designed in the days when spinning hard drives were still the norm and there really were milliseconds of blocking “seek time” while waiting for the disc to spin around before a file operation could begin. And in modern datacenters, the “local” filesystem may actually be across the network somewhere with network latencies on top of drive latencies. But even if reading a file asynchronously seems normal to you, Node takes it still further: the default functions for initiating a network connection or looking up a file modification time, for example, are also nonblocking.


Some functions in Node’s API are synchronous but nonblocking: they run to completion and return without ever needing to block. But most of the interesting functions perform some kind of input or output, and these are asynchronous functions so they can avoid even the tiniest amount of blocking. Node was created before JavaScript had a Promise class, so asynchronous Node APIs are callback-based. (If you have not yet read or have already forgotten Chapter 13, this would be a good time to skip back to that chapter.) Generally, the last argument you pass to an asynchronous Node function is a callback. Node uses error-first callbacks, which are typically invoked with two arguments. The first argument to an error-first callback is normally nul l  in the case where no error occurred, and the second argument is whatever data or response was produced by the original asynchronous function you called. The reason for putting the error argument first is to make it impossible for you to omit it, and you should always check for a non-null value in this argument. If it is an Error object, or even an integer error code or string error message, then something went wrong. In this case, the second argument to your callback function is likely to be nul l .

The following code demonstrates how to use the nonblocking
r eadFi l e( )  function to read a configuration file, parse it as JSON, and then pass the parsed configuration object to another callback:

c ons t   f s   =   r equi r e( " f s " ) ;	/ /   Requi r e   t he   f i l es ys t em modul e

/ /   Read   a   c onf i g   f i l e,	par s e   i t s   c ont ent s   as   J SON,	and   pas s   t he / /   r es ul t i ng   val ue   t o   t he   c al l bac k.	I f    anyt hi ng   goes   wr ong,
/ /   pr i nt   an   er r or   mes s age   t o   s t der r   and   i nvoke   t he   c al l bac k   wi t h nul l
f unc t i on   r eadConf i gFi l e( pat h,	c al l bac k)    {
f s . r eadFi l e( pat h,	" ut f 8" ,	( er r ,	t ext )    =>   {
i f    ( er r )    {	/ /   Somet hi ng   went   wr ong   r eadi ng   t he   f i l e c ons ol e. er r or ( er r ) ;
c al l bac k( nul l ) ; r et ur n;

}
l et   dat a t r y   {
dat a


=   nul l ;


=   J SON. par s e( t ext ) ;

}    c at c h( e)    {	/ /   Somet hi ng   went   wr ong   par s i ng   t he   f i l e c ont ent s
c ons ol e. er r or ( e) ; }
c al l bac k( dat a) ; } ) ;
}


Node predates standardized promises, but because it is fairly consistent about its error-first callbacks, it is easy to create Promise-based variants of its callback-based APIs using the ut i l . pr omi s i f y( )  wrapper. Here’s how we could rewrite the r eadConf i gFi l e( )  function to return a Promise:

c ons t   ut i l	=   r equi r e( " ut i l " ) ;
c ons t   f s   =   r equi r e( " f s " ) ;	/ /   Requi r e   t he   f i l es ys t em modul e
c ons t   pf s   =   {	/ /   Pr omi s e- bas ed   var i ant s   of    s ome   f s f unc t i ons

r eadFi l e:	ut i l . pr omi s i f y( f s . r eadFi l e) } ;

f unc t i on   r eadConf i gFi l e( pat h)    {
r et ur n   pf s . r eadFi l e( pat h,	" ut f - 8" ) . t hen( t ext   =>   { r et ur n   J SON. par s e( t ext ) ;
} ) ; }


We can also simpify the preceding Promise-based function using as ync and awai t  (again, if you have not yet read through Chapter 13, this would be a good time to do so):

as ync   f unc t i on   r eadConf i gFi l e( pat h)    {
l et   t ext   =   awai t   pf s . r eadFi l e( pat h,	" ut f - 8" ) ; r et ur n   J SON. par s e( t ext ) ;
}


The ut i l . pr omi s i f y( )  wrapper can produce a Promise-based version of many Node functions. In Node 10 and later, the
f s . pr omi s es  object has a number of predefined Promise-based functions for working with the filesystem. We’ll discuss them later in this chapter, but note that in the preceding code, we could replace
pf s . r eadFi l e( )  with f s . pr omi s es . r eadFi l e( ) .


We had said that Node’s programming model is async-by-default. But for programmer convenience, Node does define blocking, synchronous variants of many of its functions, especially in the filesystem module. These functions typically have names that are clearly labeled with Sync at the end.

When a server is first starting up and is reading its configuration files, it is not handling network requests yet, and little or no concurrency is actually

possible. So in this situation, there is really no need to avoid blocking, and we can safely use blocking functions like f s . r eadFi l eSync( ) . We can drop the as ync and awai t  from this code and write a purely synchronous version of our r eadConf i gFi l e( )  function. Instead of invoking a callback or returning a Promise, this function simply returns the parsed JSON value or throws an exception:

c ons t   f s   =   r equi r e( " f s " ) ;
f unc t i on   r eadConf i gFi l eSync ( pat h)    {
l et   t ext   =   f s . r eadFi l eSync ( pat h,	" ut f - 8" ) ; r et ur n   J SON. par s e( t ext ) ;
}


In addition to its error-first two-argument callbacks, Node also has a number of APIs that use event-based asynchrony, typically for handling streaming data. We’ll cover Node events in more detail later.


Now that we’ve discussed Node’s aggressively nonblocking API, let’s turn back to the topic of concurrency. Node’s built-in nonblocking functions work using the operating system’s version of callbacks and event handlers. When you call one of these functions, Node takes action to get the operation started, then registers some kind of event handler with the operating system so that it will be notified when the operation is complete. The callback you passed to the Node function gets stored internally so that Node can invoke your callback when the operating system sends the appropriate event to Node.


This kind of concurrency is often called event-based concurrency. At its core, Node has a single thread that runs an “event loop.” When a Node program starts, it runs whatever code you’ve told it to run. This code presumably calls at least one nonblocking function causing a callback or

event handler to be registered with the operating system. (If not, then you’ve written a synchronous Node program, and Node simply exits when it reaches the end.) When Node reaches the end of your program, it blocks until an event happens, at which time the OS starts it running again. Node maps the OS event to the JavaScript callback you registered and then invokes that function. Your callback function may invoke more nonblocking Node functions, causing more OS event handlers to be registered. Once your callback function is done running, Node goes back to sleep again and the cycle repeats.


For web servers and other I/O-intensive applications that spend most of their time waiting for input and output, this style of event-based concurrency is efficient and effective. A web server can concurrently handle requests from 50 different clients without needing 50 different threads as long as it uses nonblocking APIs and there is some kind of internal mapping from network sockets to JavaScript functions to invoke when activity occurs on those sockets.


16.3 Buffers

One of the datatypes you’re likely to use frequently in Node—especially when reading data from files or from the network—is the Buffer class. A Buffer is a lot like a string, except that it is a sequence of bytes instead of a sequence of characters. Node was created before core JavaScript supported typed arrays (see §11.2) and there was no Uint8Array to represent an array of unsigned bytes. Node defined the Buffer class to fill that need. Now that Uint8Array is part of the JavaScript language, Node’s Buffer class is a subclass of Uint8Array.


What distinguishes Buffer from its Uint8Array superclass is that it is

designed to interoperate with JavaScript strings: the bytes in a buffer can be initialized from character strings or converted to character strings. A character encoding maps each character in some set of characters to an integer. Given a string of text and a character encoding, we can encode the characters in the string into a sequence of bytes. And given a (properly encoded) sequence of bytes and a character encoding, we can decode those bytes into a sequence of characters. Node’s Buffer class has methods that perform both encoding and decoding, and you can recognize these methods because they expect an encodi ng argument that specifies the encoding to be used.


Encodings in Node are specified by name, as strings. The supported encodings are:


" ut f 8"

This is the default when no encoding is specified, and is the Unicode encoding you are most likely to use.

" ut f 16l e"

Two-byte Unicode characters, with little-endian ordering. Codepoints above \ uf f f f  are encoded as a pair of two-byte sequences. Encoding " ucs 2" is an alias.

" l at i n1"

The one-byte-per-character ISO-8859-1 encoding that defines a character set suitable for many Western European languages. Because there is a one-to-one mapping between bytes and latin-1 characters, this encoding is also known as " bi nar y" .

" as c i i "

The 7-bit English-only ASCII encoding, a strict subset of the " ut f 8" encoding.


" hex"

This encoding converts each byte to a pair of ASCII hexadecimal digits.

" bas e64"

This encoding converts each sequence of three bytes into a sequence of four ascii characters.


Here is some example code that demonstrates how to work with Buffers and how to convert to and from strings:

l et   b   =   Buf f er . f r om( [ 0x41,	0x42,	0x43] ) ;	/ /   <Buf f er   41 42   43>
b. t oSt r i ng( )	/ /   =>   " ABC" ; def aul t   " ut f 8"
b. t oSt r i ng( " hex" )	/ /   =>   " 414243"

l et   c omput er   =   Buf f er . f r om( " I BM3111" ,	" as c i i " ) ;	/ /   Conver t s t r i ng   t o   Buf f er
f or ( l et   i	=   0;	i	<   c omput er . l engt h;	i ++)    {	/ /   Us e   Buf f er as   byt e   ar r ay

c omput er [ i ] - - ; mut abl e
}
c omput er . t oSt r i ng( " as c i i " )
" HAL 2000"

/ /   Buf f er s   ar e



/ /   =>

c omput er . s ubar r ay( 0, 3) . map( x=>x+1) . t oSt r i ng( )	/ /   =>   " I BM"

/ /   Cr eat e   new  " empt y"   buf f er s   wi t h   Buf f er . al l oc ( )
l et   z er os   =   Buf f er . al l oc ( 1024) ;	/ /   1024   z er os l et   ones   =   Buf f er . al l oc ( 128,	1) ;	/ /   128   ones
l et   dead   =   Buf f er . al l oc ( 1024,	" DEADBEEF" ,	" hex" ) ;	/ /   Repeat i ng pat t er n   of    byt es


/ /   Buf f er s   have   met hods val ues
/ /   f r om and   t o   a   buf f er

f or   r eadi ng   and   wr i t i ng   mul t i - byt e

at   any   s pec i f i ed   of f s et .



dead. r eadUI nt 32BE( 0)
dead. r eadUI nt 32BE( 1)

/ /   =>   0xDEADBEEF
/ /   =>   0xADBEEFDE


dead. r eadBi gUI nt 64BE( 6)
dead. r eadUI nt 32L E( 1020)

/ /   =>   0xBEEFDEADBEEFDEADn
/ /   =>   0xEFBEADDE



If you write a Node program that actually manipulates binary data, you may find yourself using the Buffer class extensively. On the other hand, if you are just working with text that is read from or written to a file or the network, then you may only encounter Buffer as an intermediate representation of your data. A number of Node APIs can take input or return output as either strings or Buffer objects. Typically, if you pass a string, or expect a string to be returned, from one of these APIs, you’ll need to specify the name of the text encoding you want to use. And if you do this, then you may not need to use a Buffer object at all.


16.4 Events and EventEmitter

As described, all of Node’s APIs are asynchronous by default. For many of them, this asynchrony takes the form of two-argument error-first callbacks that are invoked when the requested operation is complete. But some of the more complicated APIs are event-based instead. This is typically the case when the API is designed around an object rather than a function, or when a callback function needs to be invoked multiple times, or when there are multiple types of callback functions that may be required. Consider the net . Ser ver  class, for example: an object of this type is a server socket that is used to accept incoming connections from clients. It emits a “listening” event when it first starts listening for connections, a “connection” event every time a client connects, and a “close” event when it has been closed and is no longer listening.

In Node, objects that emit events are instances of EventEmitter or a subclass of EventEmitter:

c ons t   Event Emi t t er   =   r equi r e( " event s " ) ;	/ /   Modul e   name   does   not mat c h   c l as s   name
c ons t   net   =   r equi r e( " net " ) ;
l et   s er ver   =   new  net . Ser ver ( ) ;	/ /   c r eat e   a   Ser ver
obj ec t
s er ver   i ns t anc eof    Event Emi t t er	/ /   =>   t r ue:	Ser ver s   ar e Event Emi t t er s


The main feature of EventEmitters is that they allow you to register event handler functions with the on( )  method. EventEmitters can emit multiple types of events, and event types are identified by name. To register an event handler, call the on( )  method, passing the name of the event type and the function that should be invoked when an event of that type occurs. EventEmitters can invoke handler functions with any number of arguments, and you need to read the documentation for a specific kind of event from a specific EventEmitter to know what arguments you should expect to be passed:

c ons t   net   =   r equi r e( " net " ) ;
l et   s er ver   =   new  net . Ser ver ( ) ;	/ /   c r eat e   a   Ser ver obj ec t
s er ver . on( " c onnec t i on" ,	s oc ket   =>   {	/ /   L i s t en   f or
" c onnec t i on"   event s
/ /   Ser ver   " c onnec t i on"   event s   ar e   pas s ed   a   s oc ket   obj ec t / /   f or   t he   c l i ent   t hat   j us t   c onnec t ed.    Her e   we   s end   s ome
dat a
/ /   t o   t he   c l i ent   and   di s c onnec t .
s oc ket . end( " Hel l o   Wor l d" ,	" ut f 8" ) ;
} ) ;


If you prefer more explicit method names for registering event listeners, you can also use addLi s t ener ( ) . And you can remove a previously registered event listener with of f ( )  or r emoveLi s t ener ( ) . As a special case, you can register an event listener that will be automatically removed after it is triggered for the first time by calling once( )  instead of on( ) .

When an event of a particular type occurs for a particular EventEmitter object, Node invokes all of the handler functions that are currently registered on that EventEmitter for events of that type. They are invoked in order from the first registered to the last registered. If there is more than one handler function, they are invoked sequentially on a single thread: there is no parallelism in Node, remember. And, importantly, event handling functions are invoked synchronously, not asynchronously. What this means is that the emi t ( )  method does not queue up event handlers to be invoked at some later time. emi t ( )  invokes all the registered handlers, one after the other, and does not return until the last event handler has returned.

What this means, in effect, is that when one of the built-in Node APIs emits an event, that API is basically blocking on your event handlers. If you write an event handler that calls a blocking function like
f s . r eadFi l eSync( ) , no further event handling will happen until your synchronous file read is complete. If your program is one—like a network server—that needs to be responsive, then it is important that you keep your event handler functions nonblocking and fast. If you need to do a lot of computation when an event occurs, it is often best to use the handler to schedule that computation asynchronously using s et Ti meout ( )  (see §11.10). Node also defines s et I mmedi at e( ) , which schedules a function to be invoked immediately after all pending callbacks and events have been handled.

The EventEmitter class also defines an emi t ( )  method that causes the registered event handler functions to be invoked. This is useful if you are defining your own event-based API, but is not commonly used when you’re just programming with existing APIs. emi t ( )  must be invoked with the name of the event type as its first argument. Any additional

arguments that are passed to emi t ( )  become arguments to the registered event handler functions. The handler functions are also invoked with the
t hi s  value set to the EventEmitter object itself, which is often convenient. (Remember, though, that arrow functions always use the
t hi s  value of the context in which they are defined, and they cannot be invoked with any other t hi s  value. Nevertheless, arrow functions are often the most convenient way to write event handlers.)

Any value returned by an event handler function is ignored. If an event handler function throws an exception, however, it propagates out from the emi t ( )  call and prevents the execution of any handler functions that were registered after the one that threw the exception.

Recall that Node’s callback-based APIs use error-first callbacks, and it is important that you always check the first callback argument to see if an error occurred. With event-based APIs, the equivalent is “error” events. Since event-based APIs are often used for networking and other forms of streaming I/O, they are vulnerable to unpredictable asynchronous errors, and most EventEmitters define an “error” event that they emit when an error occurs. Whenever you use an event-based API, you should make it a habit to register a handler for “error” events. “Error” events get special treatment by the EventEmitter class. If emi t ( )  is called to emit an “error” event, and if there are no handlers registered for that event type, then an exception will be thrown. Since this occurs asynchronously, there is no way for you to handle the exception in a cat ch block, so this kind of error typically causes your program to exit.


16.5 Streams

When implementing an algorithm to process data, it is almost always

easiest to read all the data into memory, do the processing, and then write the data out. For example, you could write a Node function to copy a file like this.1


c ons t   f s   =   r equi r e( " f s " ) ;

/ /   An   as ync hr onous   but   nons t r eami ng   ( and   t her ef or e   i nef f i c i ent ) f unc t i on.
f unc t i on   c opyFi l e( s our c eFi l ename,	des t i nat i onFi l ename,	c al l bac k)
{
f s . r eadFi l e( s our c eFi l ename,	( er r ,	buf f er )    =>   { i f    ( er r )    {
c al l bac k( er r ) ; }    el s e   {
f s . wr i t eFi l e( des t i nat i onFi l ename,	buf f er ,	c al l bac k) ; }
} ) ; }


This copyFi l e( )  function uses asynchronous functions and callbacks, so it does not block and is suitable for use in concurrent programs like servers. But notice that it must allocate enough memory to hold the entire contents of the file in memory at once. This may be fine in some use cases, but it starts to fail if the files to be copied are very large, or if your program is highly concurrent and there may be many files being copied at the same time. Another shortcoming of this copyFi l e( ) implementation is that it cannot start writing the new file until it has finished reading the old file.

The solution to these problems is to use streaming algorithms where data “flows” into your program, is processed, and then flows out of your program. The idea is that your algorithm processes the data in small chunks and the full dataset is never held in memory at once. When streaming solutions are possible, they are more memory efficient and can

also be faster. Node’s networking APIs are stream-based and Node’s filesystem module defines streaming APIs for reading and writing files, so you are likely to use a streaming API in many of the Node programs that you write. We’ll see a streaming version of the copyFi l e( )  function in “Flowing mode”.

Node supports four basic stream types:


Readable

Readable streams are sources of data. The stream returned by
f s . cr eat eReadSt r eam( ) , for example, is a stream from which the content of a specified file can be read. pr oces s . s t di n is another Readable stream that returns data from standard input.

Writable

Writable streams are sinks or destinations for data. The return value of f s . cr eat eWr i t eSt r eam( ) , for example, is a Writable stream: it allows data to be written to it in chunks, and outputs all of that data to a specified file.

Duplex

Duplex streams combine a Readable stream and a Writable stream into one object. The Socket objects returned by net . connect ( )  and other Node networking APIs, for example, are Duplex streams. If you write to a socket, your data is sent across the network to whatever computer the socket is connected to. And if you read from a socket, you access the data written by that other computer.

Transform

Transform streams are also readable and writable, but they differ from Duplex streams in an important way: data written to a Transform stream becomes readable—usually in some transformed form—from the same stream. The z l i b. cr eat eGz i p( )  function, for example,

returns a Transform stream that compresses (with the gzip algorithm) the data written to it. In a similar way, the
cr ypt o. cr eat eCi pher i v( )  function returns a Transform stream that encrypts or decrypts data that is written to it.


By default, streams read and write buffers. If you call the
s et Encodi ng( )  method of a Readable stream, it will return decoded strings to you instead of Buffer objects. And if you write a string to a Writable buffer, it will be automatically encoded using the buffer’s default encoding or whatever encoding you specify. Node’s stream API also supports an “object mode” where streams read and write objects more complex than buffers and strings. None of Node’s core APIs use this object mode, but you may encounter it in other libraries.

Readable streams have to read their data from somewhere, and Writable streams have to write their data to somewhere, so every stream has two ends: an input and an output or a source and a destination. The tricky thing about stream-based APIs is that the two ends of the stream will almost always flow at different speeds. Perhaps the code that reads from a stream wants to read and process data more quickly than the data is actually being written into the stream. Or the reverse: perhaps data is written to a stream more quickly than it can be read and pulled out of the stream on the other end. Stream implementations almost always include an internal buffer to hold data that has been written but not yet read. Buffering helps to ensure that there is data available to read when it’s requested, and that there is space to hold data when it is written. But neither of these things can ever be guaranteed, and it is the nature of stream-based programming that readers will sometimes have to wait for data to be written (because the stream buffer is empty), and writers will sometimes have to wait for data to be read (because the stream buffer is full).

In programming environments that use thread-based concurrency, stream APIs typically have blocking calls: a call to read data does not return until data arrives in the stream and a call to write data blocks until there is enough room in the stream’s internal buffer to accommodate the new data. With an event-based concurrency model, however, blocking calls do not make sense, and Node’s stream APIs are event- and callback-based. Unlike other Node APIs, there are not “Sync” versions of the methods that will be described later in this chapter.


The need to coordinate stream readability (buffer not empty) and writability (buffer not full) via events makes Node’s stream APIs somewhat complicated. This is compounded by the fact that these APIs have evolved and changed over the years: for Readable streams, there are two completely distinct APIs that you can use. Despite the complexity, it is worth understanding and mastering Node’s streaming APIs because they enable high-throughput I/O in your programs.


The subsections that follow demonstrate how to read and write from Node’s stream classes.


16.5.1 Pipes

Sometimes, you need to read data from a stream simply to turn around and write that same data to another stream. Imagine, for example, that you are writing a simple HTTP server that serves a directory of static files. In this case, you will need to read data from a file input stream and write it out to a network socket. But instead of writing your own code to handle the reading and writing, you can instead simply connect the two sockets together as a “pipe” and let Node handle the complexities for you. Simply pass the Writable stream to the pi pe( )  method of the Readable stream:

c ons t   f s   =   r equi r e( " f s " ) ;

f unc t i on   pi peFi l eToSoc ket ( f i l ename,	s oc ket )    {
f s . c r eat eReadSt r eam( f i l ename) . pi pe( s oc ket ) ; }


The following utility function pipes one stream to another and invokes a callback when done or when an error occurs:

f unc t i on   pi pe( r eadabl e,	wr i t abl e,	c al l bac k)    { / /   Fi r s t ,	s et   up   er r or   handl i ng
f unc t i on   handl eEr r or ( er r )    { r eadabl e. c l os e( ) ;
wr i t abl e. c l os e( ) ; c al l bac k( er r ) ;
}

/ /   Next   def i ne   t he   pi pe   and   handl e   t he   nor mal	t er mi nat i on c as e
r eadabl e
. on( " er r or " ,	handl eEr r or )
. pi pe( wr i t abl e)
. on( " er r or " ,	handl eEr r or ) . on( " f i ni s h" ,    c al l bac k) ;
}


Transform streams are particularly useful with pipes, and create pipelines that involve more than two streams. Here’s an example function that compresses a file:

c ons t   f s   =   r equi r e( " f s " ) ;
c ons t   z l i b   =   r equi r e( " z l i b" ) ;

f unc t i on   gz i p( f i l ename,	c al l bac k)    { / /   Cr eat e   t he   s t r eams
l et   s our c e   =   f s . c r eat eReadSt r eam( f i l ename) ;
l et   des t i nat i on   =   f s . c r eat eWr i t eSt r eam( f i l ename   +   " . gz " ) ; l et   gz i pper   =   z l i b. c r eat eGz i p( ) ;

/ /   Set   up   t he   pi pel i ne

s our c e
. on( " er r or " ,	c al l bac k)	/ /   c al l	c al l bac k   on   r ead   er r or . pi pe( gz i pper )
. pi pe( des t i nat i on)
. on( " er r or " ,	c al l bac k)	/ /   c al l	c al l bac k   on   wr i t e   er r or . on( " f i ni s h" ,    c al l bac k) ;	/ /   c al l	c al l bac k   when   wr i t i ng
i s   c ompl et e }


Using the pi pe( )  method to copy data from a Readable stream to a Writable stream is easy, but in practice, you often need to process the data somehow as it streams through your program. One way to do this is to implement your own Transform stream to do that processing, and this approach allows you to avoid manually reading and writing the streams. Here, for example, is a function that works like the Unix gr ep utility: it reads lines of text from an input stream, but writes only the lines that match a specified regular expression:

c ons t   s t r eam =   r equi r e( " s t r eam" ) ;

c l as s   Gr epSt r eam ext ends   s t r eam. Tr ans f or m { c ons t r uc t or ( pat t er n)    {
s uper ( { dec odeSt r i ngs :	f al s e} ) ; / /   Don' t   c onver t   s t r i ngs bac k   t o   buf f er s
t hi s . pat t er n   =   pat t er n;	/ /   The   r egul ar   expr es s i on we   want   t o   mat c h
t hi s . i nc ompl et eL i ne   =   " " ;	/ /   Any   r emnant   of    t he   l as t c hunk   of    dat a
}

/ /   Thi s   met hod   i s   i nvoked   when   t her e   i s   a   s t r i ng   r eady   t o   be / /   t r ans f or med.	I t   s houl d   pas s   t r ans f or med   dat a   t o   t he
s pec i f i ed
/ /   c al l bac k   f unc t i on.	We   expec t   s t r i ng   i nput   s o   t hi s   s t r eam s houl d
/ /   onl y   be   c onnec t ed   t o   r eadabl e   s t r eams   t hat   have   had / /   s et Enc odi ng( )    c al l ed   on   t hem.
_t r ans f or m( c hunk,	enc odi ng,	c al l bac k)    {
i f    ( t ypeof    c hunk   ! ==   " s t r i ng" )    {
c al l bac k( new  Er r or ( " Expec t ed   a   s t r i ng   but   got   a

buf f er " ) ) ;
r et ur n; }
/ /   Add   t he   c hunk   t o   any   pr evi ous l y   i nc ompl et e   l i ne   and br eak
/ /   ever yt hi ng   i nt o   l i nes
l et   l i nes   =   ( t hi s . i nc ompl et eL i ne   +   c hunk) . s pl i t ( " \ n" ) ;

/ /   The   l as t   el ement   of    t he   ar r ay   i s   t he   new  i nc ompl et e l i ne
t hi s . i nc ompl et eL i ne   =   l i nes . pop( ) ;

/ /   Fi nd   al l	mat c hi ng   l i nes
l et   out put   =   l i nes	/ /   St ar t   wi t h   al l c ompl et e   l i nes ,
. f i l t er ( l	=>   t hi s . pat t er n. t es t ( l ) )    / /   f i l t er   t hem f or   mat c hes ,
. j oi n( " \ n" ) ;	/ /   and   j oi n   t hem bac k   up.

/ /   I f    anyt hi ng   mat c hed,	add   a   f i nal	newl i ne i f    ( out put )    {
out put   +=   " \ n" ; }

/ /   Al ways   c al l	t he   c al l bac k   even   i f    t her e   i s   no   out put c al l bac k( nul l ,	out put ) ;
}

/ /   Thi s   i s   c al l ed   r i ght   bef or e   t he   s t r eam i s   c l os ed. / /   I t   i s   our   c hanc e   t o   wr i t e   out   any   l as t   dat a.
_f l us h( c al l bac k)    {
/ /   I f    we   s t i l l	have   an   i nc ompl et e   l i ne,	and   i t   mat c hes / /   pas s   i t   t o   t he   c al l bac k
i f    ( t hi s . pat t er n. t es t ( t hi s . i nc ompl et eL i ne) )    {
c al l bac k( nul l ,	t hi s . i nc ompl et eL i ne   +   " \ n" ) ; }
} }

/ /   Now  we   c an   wr i t e   a   pr ogr am l i ke   ' gr ep'	wi t h   t hi s   c l as s .
l et   pat t er n   =   new  RegExp( pr oc es s . ar gv[ 2] ) ;	/ /   Get   a   RegExp   f r om c ommand   l i ne.
pr oc es s . s t di n	/ /   St ar t   wi t h s t andar d   i nput ,


. s et Enc odi ng( " ut f 8" ) s t r i ngs ,
. pi pe( new  Gr epSt r eam( pat t er n) ) Gr epSt r eam,

/ /   r ead   i t

/ /   pi pe   i t

as   Uni c ode

t o   our

. pi pe( pr oc es s . s t dout )	/ /   and   pi pe   t hat   t o s t andar d   out .
. on( " er r or " ,	( )    =>   pr oc es s . exi t ( ) ) ;	/ /   Exi t   gr ac ef ul l y   i f s t dout   c l os es .


16.5.2 Asynchronous Iteration

In Node 12 and later, Readable streams are asynchronous iterators, which means that within an as ync function you can use a f or / awai t  loop to read string or Buffer chunks from a stream using code that is structured like synchronous code would be. (See §13.4 for more on asynchronous iterators and f or / awai t  loops.)


Using an asynchronous iterator is almost as easy as using the pi pe( ) method, and is probably easier when you need to process each chunk you read in some way. Here’s how we could rewrite the gr ep program in the previous section using an as ync function and a f or / awai t  loop:


/ /   Read   l i nes l i nes
/ /   t hat   mat c h

of    t ext   f r om t he   s our c e   s t r eam,	and   wr i t e   any

t he   s pec i f i ed   pat t er n   t o   t he   des t i nat i on   s t r eam.

as ync   f unc t i on   gr ep( s our c e,	des t i nat i on,	pat t er n, enc odi ng=" ut f 8" )    {
/ /   Set   up   t he   s our c e   s t r eam f or   r eadi ng   s t r i ngs ,	not   Buf f er s s our c e. s et Enc odi ng( enc odi ng) ;


/ /   Set   an s t andar d
/ /   out put e. g. )

er r or   handl er   on   t he   des t i nat i on

c l os es   unexpec t edl y   ( when   pi pi ng

s t r eam i n

out put   t o

c as e

` head` ,

des t i nat i on. on( " er r or " ,	er r   =>   pr oc es s . exi t ( ) ) ;


/ /   The   c hunks   we eac h   wi l l
/ /   pr obabl y   have

r ead   ar e   unl i kel y

a   par t i al	l i ne   at

t o   end   wi t h   a   newl i ne,	s o

t he   end.	Tr ac k   t hat   her e

l et   i nc ompl et eL i ne   =   " " ;

/ /   Us e   a   f or / awai t   l oop   t o   as ync hr onous l y   r ead   c hunks   f r om t he   i nput   s t r eam
f or   awai t   ( l et   c hunk   of    s our c e)    {
/ /   Spl i t   t he   end   of    t he   l as t   c hunk   pl us   t hi s   one   i nt o l i nes
l et   l i nes   =   ( i nc ompl et eL i ne   +   c hunk) . s pl i t ( " \ n" ) ; / /   The   l as t   l i ne   i s   i nc ompl et e
i nc ompl et eL i ne   =   l i nes . pop( ) ;
/ /   Now  l oop   t hr ough   t he   l i nes   and   wr i t e   any   mat c hes   t o t he   des t i nat i on
f or ( l et   l i ne   of    l i nes )    {
i f    ( pat t er n. t es t ( l i ne) )    {
des t i nat i on. wr i t e( l i ne   +   " \ n" ,	enc odi ng) ; }
} }
/ /   Fi nal l y,	c hec k   f or   a   mat c h   on   any   t r ai l i ng   t ext . i f    ( pat t er n. t es t ( i nc ompl et eL i ne) )    {
des t i nat i on. wr i t e( i nc ompl et eL i ne   +   " \ n" ,	enc odi ng) ; }
}

l et   pat t er n   =   new  RegExp( pr oc es s . ar gv[ 2] ) ;	/ /   Get   a   RegExp f r om c ommand   l i ne.
gr ep( pr oc es s . s t di n,	pr oc es s . s t dout ,	pat t er n)    / /   Cal l	t he   as ync gr ep( )    f unc t i on.
. c at c h( er r   =>   {	/ /   Handl e as ync hr onous   exc ept i ons .
c ons ol e. er r or ( er r ) ; pr oc es s . exi t ( ) ;
} ) ;


16.5.3 Writing to Streams and Handling Backpressure

The async gr ep( )  function in the preceding code example demonstrated how to use a Readable stream as an asynchronous iterator, but it also demonstrated that you can write data to a Writable stream simply by passing it to the wr i t e( )  method. The wr i t e( )  method takes a buffer or string as the first argument. (Object streams expect other kinds of

objects, but are beyond the scope of this chapter.) If you pass a buffer, the bytes of that buffer will be written directly. If you pass a string, it will be encoded to a buffer of bytes before being written. Writable streams have a default encoding that is used when you pass a string as the only argument to wr i t e( ) . The default encoding is typically “utf8,” but you can set it explicitly by calling s et Def aul t Encodi ng( )  on the Writable stream. Alternatively, when you pass a string as the first argument to wr i t e( ) you can pass an encoding name as the second argument.

wr i t e( )  optionally takes a callback function as its third argument. This will be invoked when the data has actually been written and is no longer in the Writable stream’s internal buffer. (This callback may also be invoked if an error occurs, but this is not guaranteed. You should register an “error” event handler on the Writable stream to detect errors.)

The wr i t e( )  method has a very important return value. When you call wr i t e( )  on a stream, it will always accept and buffer the chunk of data you have passed. It then returns t r ue if the internal buffer is not yet full. Or, if the buffer is now full or overfull, it returns f al s e. This return value is advisory, and you can ignore it—Writable streams will enlarge their internal buffer as much as needed if you keep calling wr i t e( ) . But remember that the reason to use a streaming API in the first place is to avoid the cost of keeping lots of data in memory at once.

A return value of f al s e from the wr i t e( )  method is a form of backpressure: a message from the stream that you have written data more quickly than it can be handled. The proper response to this kind of backpressure is to stop calling wr i t e( )  until the stream emits a “drain” event, signaling that there is once again room in the buffer. Here, for example, is a function that writes to a stream, and then invokes a callback

when it is OK to write more data to the stream:


f unc t i on   wr i t e( s t r eam,	c hunk,	c al l bac k)    {
/ /   Wr i t e   t he   s pec i f i ed   c hunk   t o   t he   s pec i f i ed   s t r eam l et   has Mor eRoom =   s t r eam. wr i t e( c hunk) ;

/ /   Chec k   t he   r et ur n   val ue   of    t he   wr i t e( )    met hod:
i f    ( has Mor eRoom)    {	/ /   I f    i t   r et ur ned   t r ue, t hen
s et I mmedi at e( c al l bac k) ;	/ /   i nvoke   c al l bac k as ync hr onous l y.
}    el s e   {	/ /   I f    i t   r et ur ned   f al s e, t hen
s t r eam. onc e( " dr ai n" ,	c al l bac k) ;	/ /   i nvoke   c al l bac k   on dr ai n   event .
} }


The fact that it is sometimes OK to call wr i t e( )  multiple times in a row and sometimes you have to wait for an event between writes makes for awkward algorithms. This is one of the reasons that using the pi pe( ) method is so appealing: when you use pi pe( ) , Node handles backpressure for you automatically.

If you are using awai t  and as ync in your program, and are treating Readable streams as asynchronous iterators, it is straightforward to implement a Promise-based version of the wr i t e( )  utility function above to properly handle backpressure. In the async gr ep( )  function we just looked at, we did not handle backpressure. The async copy( ) function in the following example demonstrates how it can be done correctly. Note that this function just copies chunks from a source stream to a destination stream and calling copy( s our ce,	des t i nat i on)  is much like calling s our ce. pi pe( des t i nat i on) :

/ /   Thi s   f unc t i on   wr i t es   t he   s pec i f i ed   c hunk   t o   t he   s pec i f i ed s t r eam and

/ /   r et ur ns   a   Pr omi s e   t hat   wi l l	be   f ul f i l l ed   when   i t   i s   OK   t o wr i t e   agai n.
/ /   Bec aus e   i t   r et ur ns   a   Pr omi s e,	i t   c an   be   us ed   wi t h   awai t . f unc t i on   wr i t e( s t r eam,	c hunk)    {
/ /   Wr i t e   t he   s pec i f i ed   c hunk   t o   t he   s pec i f i ed   s t r eam l et   has Mor eRoom =   s t r eam. wr i t e( c hunk) ;

i f    ( has Mor eRoom)    {	/ /   I f    buf f er   i s   not f ul l ,	r et ur n
r et ur n   Pr omi s e. r es ol ve( nul l ) ;	/ /   an   al r eady r es ol ved   Pr omi s e   obj ec t
}    el s e   {
r et ur n   new  Pr omi s e( r es ol ve   =>   {	/ /   Ot her wi s e,	r et ur n a   Pr omi s e   t hat
s t r eam. onc e( " dr ai n" ,	r es ol ve) ;	/ /   r es ol ves   on   t he dr ai n   event .
} ) ; }
}

/ /   Copy   dat a   f r om t he   s our c e   s t r eam t o   t he   des t i nat i on   s t r eam / /   r es pec t i ng   bac kpr es s ur e   f r om t he   des t i nat i on   s t r eam.
/ /   Thi s   i s   muc h   l i ke   c al l i ng   s our c e. pi pe( des t i nat i on) . as ync   f unc t i on   c opy( s our c e,	des t i nat i on)    {

/ /   Set   an s t andar d
/ /   out put e. g. )

er r or   handl er   on   t he   des t i nat i on

c l os es   unexpec t edl y   ( when   pi pi ng

s t r eam i n

out put   t o

c as e

` head` ,

des t i nat i on. on( " er r or " ,	er r   =>   pr oc es s . exi t ( ) ) ;

/ /   Us e   a   f or / awai t   l oop   t o   as ync hr onous l y   r ead   c hunks   f r om t he   i nput   s t r eam
f or   awai t   ( l et   c hunk   of    s our c e)    {
/ /   Wr i t e   t he   c hunk   and   wai t   unt i l	t her e   i s   mor e   r oom i n t he   buf f er .
awai t   wr i t e( des t i nat i on,	c hunk) ;
} }

/ /   Copy   s t andar d   i nput   t o   s t andar d   out put c opy( pr oc es s . s t di n,	pr oc es s . s t dout ) ;


Before we conclude this discussion of writing to streams, note again that failing to respond to backpressure can cause your program to use more

memory than it should when the internal buffer of a Writable stream overflows and grows larger and larger. If you are writing a network server, this can be a remotely exploitable security issue. Suppose you write an HTTP server that delivers files over the network, but you didn’t use
pi pe( )  and you didn’t take the time to handle backpressure from the wr i t e( )  method. An attacker could write an HTTP client that initiates requests for large files (such as images) but never actually reads the body of the request. Since the client is not reading the data over the network, and the server isn’t responding to backpressure, buffers on the server are
going to overflow. With enough concurrent connections from the attacker, this can turn into a denial-of-service attack that slows your server down or even crashes it.


16.5.4 Reading Streams with Events

Node’s readable streams have two modes, each of which has its own API for reading. If you can’t use pipes or asynchronous iteration in your program, you will need to pick one of these two event-based APIs for handling streams. It is important that you use only one or the other and do not mix the two APIs.

FLOWING MODE

In flowing mode, when readable data arrives, it is immediately emitted in the form of a “data” event. To read from a stream in this mode, simply register an event handler for “data” events, and the stream will push chunks of data (buffers or strings) to you as soon as they becomes available. Note that there is no need to call the r ead( )  method in flowing mode: you only need to handle “data” events. Note that newly created streams do not start off in flowing mode. Registering a “data” event handler switches a stream into flowing mode. Conveniently, this

means that a stream does not emit “data” events until you register the first “data” event handler.


If you are using flowing mode to read data from a Readable stream, process it, then write it to a Writable stream, then you may need to handle backpressure from the Writable stream. If the wr i t e( )  method returns
f al s e to indicate that the write buffer is full, you can call paus e( )  on the Readable stream to temporarily stop dat a events. Then, when you get a “drain” event from the Writable stream, you can call r es ume( )  on the Readable stream to start the “data” events flowing again.

A stream in flowing mode emits an “end” event when the end of the stream is reached. This event indicates that no more “data” events will ever be emitted. And, as with all streams, an “error” event is emitted if an error occurs.


At the beginning of this section on streams, we showed a nonstreaming copyFi l e( )  function and promised a better version to come. The following code shows how to implement a streaming copyFi l e( ) function that uses the flowing mode API and handles backpressure. This would have been easier to implement with a pi pe( )  call, but it serves here as a useful demonstration of the multiple event handlers that are used to coordinate data flow from one stream to the other.

c ons t   f s   =   r equi r e( " f s " ) ;

/ /   A  s t r eami ng   f i l e   c opy   f unc t i on,	us i ng   " f l owi ng   mode" .
/ /   Copi es   t he   c ont ent s   of    t he   named   s our c e   f i l e   t o   t he   named des t i nat i on   f i l e.
/ /   On   s uc c es s ,	i nvokes   t he   c al l bac k   wi t h   a   nul l	ar gument .	On er r or ,
/ /   i nvokes   t he   c al l bac k   wi t h   an   Er r or   obj ec t .
f unc t i on   c opyFi l e( s our c eFi l ename,	des t i nat i onFi l ename,	c al l bac k)
{

l et   i nput   =   f s . c r eat eReadSt r eam( s our c eFi l ename) ;
l et   out put   =   f s . c r eat eWr i t eSt r eam( des t i nat i onFi l ename) ;

i nput . on( " dat a" ,	( c hunk)    =>   {	/ /   When   we   get   new dat a,
l et   has Room =   out put . wr i t e( c hunk) ;	/ /   wr i t e   i t   t o   t he out put   s t r eam.
i f    ( ! has Room)    {	/ /   I f    t he   out put s t r eam i s   f ul l
i nput . paus e( ) ;	/ /   t hen   paus e   t he i nput   s t r eam.
} } ) ;
i nput . on( " end" ,	( )    =>   {	/ /   When   we   r eac h   t he end   of    i nput ,
out put . end( ) ;	/ /   t el l	t he   out put s t r eam t o   end.
} ) ;
i nput . on( " er r or " ,	er r   =>   {	/ /   I f    we   get   an   er r or on   t he   i nput ,
c al l bac k( er r ) ;	/ /   c al l	t he   c al l bac k wi t h   t he   er r or
pr oc es s . exi t ( ) ;	/ /   and   qui t . } ) ;

out put . on( " dr ai n" ,	( )    =>   {	/ /   When   t he   out put   i s no   l onger   f ul l ,
i nput . r es ume( ) ;	/ /   r es ume   dat a   event s on   t he   i nput
} ) ;
out put . on( " er r or " ,	er r   =>   {	/ /   I f    we   get   an   er r or on   t he   out put ,
c al l bac k( er r ) ;	/ /   c al l	t he   c al l bac k wi t h   t he   er r or
pr oc es s . exi t ( ) ;	/ /   and   qui t . } ) ;
out put . on( " f i ni s h" ,	( )    =>   {	/ /   When   out put   i s f ul l y   wr i t t en
c al l bac k( nul l ) ;	/ /   c al l	t he   c al l bac k wi t h   no   er r or .
} ) ; }

/ /   Her e' s   a   s i mpl e   c ommand- l i ne   ut i l i t y   t o   c opy   f i l es

l et   f r om =   pr oc es s . ar gv[ 2] ,	t o   =   pr oc es s . ar gv[ 3] ; c ons ol e. l og( ` Copyi ng   f i l e   ${ f r om}    t o   ${ t o} . . . ` ) ; c opyFi l e( f r om,	t o,	er r   =>   {
i f    ( er r )    {
c ons ol e. er r or ( er r ) ; }    el s e   {
c ons ol e. l og( " done. " ) ; }
} ) ;


PAUSED MODE

The other mode for Readable streams is “paused mode.” This is the mode that streams start in. If you never register a “data” event handler and never call the pi pe( )  method, then a Readable stream remains in paused mode. In paused mode, the stream does not push data to you in the form of “data” events. Instead, you pull data from the stream by explicitly calling its
r ead( )  method. This is not a blocking call, and if there is no data available to read on the stream, it will return nul l . Since there is not a synchronous API to wait for data, the paused mode API is also event-based. A Readable stream in paused mode emits “readable” events when data becomes available to read on the stream. In response, your code should call the r ead( )  method to read that data. You must do this in a loop, calling r ead( )  repeatedly until it returns nul l . It is necessary to completely drain the stream’s buffer like this in order to trigger a new “readable” event in the future. If you stop calling r ead( )  while there is still readable data, you will not get another “readable” event and your program is likely to hang.

Streams in paused mode emit “end” and “error” events just like flowing mode streams do. If you are writing a program that reads data from a Readable stream and writes it to a Writable stream, then paused mode may not be a good choice. In order to properly handle backpressure, you only

want to read when the input stream is readable and the output stream is not backed up. In paused mode, that means reading and writing until r ead( ) returns nul l  or wr i t e( )  returns f al s e, and then starting reading or writing again on a r eadabl e or dr ai n event. This is inelegant, and you may find that flowing mode (or pipes) is easier in this case.

The following code demonstrates how you can compute a SHA256 hash for the contents of a specified file. It uses a Readable stream in paused mode to read the contents of a file in chunks, then passes each chunk to the object that computes the hash. (Note that in Node 12 and later, it would be simpler to write this function using a f or / awai t  loop.)


c ons t   f s   =   r equi r e( " f s " ) ;
c ons t   c r ypt o   =   r equi r e( " c r ypt o" ) ;


/ /   Comput e   a   s ha256   has h pas s   t he
/ /   has h   ( as   a   s t r i ng)    t o f unc t i on.

of    t he   c ont ent s   of    t he   named   f i l e   and

t he   s pec i f i ed   er r or - f i r s t   c al l bac k

f unc t i on   s ha256( f i l ename,	c al l bac k)    {
l et   i nput   =   f s . c r eat eReadSt r eam( f i l ename) ;	/ /   The   dat a s t r eam.
l et   has her   =   c r ypt o. c r eat eHas h( " s ha256" ) ;	/ /   For   c omput i ng t he   has h.

i nput . on( " r eadabl e" ,	( )    =>   {	/ /   When   t her e   i s   dat a r eady   t o   r ead
l et   c hunk;
whi l e( c hunk   =   i nput . r ead( ) )    {	/ /   Read   a   c hunk,	and   i f non- nul l ,
has her . updat e( c hunk) ;	/ /   pas s   i t   t o   t he has her ,
}	/ /   and   keep   l oopi ng unt i l	not   r eadabl e
} ) ;
i nput . on( " end" ,	( )    =>   {	/ /   At   t he   end   of    t he s t r eam,
l et   has h   =   has her . di ges t ( " hex" ) ;	/ /   c omput e   t he   has h,
c al l bac k( nul l ,	has h) ;	/ /   and   pas s   i t   t o   t he

c al l bac k. } ) ;
i nput . on( " er r or " ,	c al l bac k) ;	/ /   On   er r or ,	c al l c al l bac k
}

/ /   Her e' s   a   s i mpl e   c ommand- l i ne   ut i l i t y   t o   c omput e   t he   has h   of    a f i l e
s ha256( pr oc es s . ar gv[ 2] ,	( er r ,	has h)    =>   {    / /   Pas s   f i l ename   f r om c ommand   l i ne.
i f    ( er r )    {	/ /   I f    we   get   an   er r or
c ons ol e. er r or ( er r . t oSt r i ng( ) ) ;	/ /   pr i nt   i t   as   an er r or .
}    el s e   {	/ /   Ot her wi s e,
c ons ol e. l og( has h) ;	/ /   pr i nt   t he   has h s t r i ng.
} } ) ;


16.6 Process, CPU, and Operating System Details

The global Process object has a number of useful properties and functions that generally relate to the state of the currently running Node process. Consult the Node documentation for complete details, but here are some properties and functions you should be aware of:

pr oc es s . ar gv	/ /   An   ar r ay   of    c ommand- l i ne   ar gument s . pr oc es s . ar c h	/ /   The   CPU  ar c hi t ec t ur e:	" x64" ,	f or exampl e.
pr oc es s . c wd( )	/ /   Ret ur ns   t he   c ur r ent   wor ki ng di r ec t or y.
pr oc es s . c hdi r ( )	/ /   Set s   t he   c ur r ent   wor ki ng   di r ec t or y. pr oc es s . c puUs age( )	/ /   Repor t s   CPU  us age.
pr oc es s . env	/ /   An   obj ec t   of    envi r onment   var i abl es . pr oc es s . exec Pat h	/ /   The   abs ol ut e   f i l es ys t em pat h   t o   t he node   exec ut abl e.
pr oc es s . exi t ( )	/ /   Ter mi nat es   t he   pr ogr am.
pr oc es s . exi t Code	/ /   An   i nt eger   c ode   t o   be   r epor t ed   when t he   pr ogr am exi t s .

pr oc es s . get ui d( )	/ /   Ret ur n   t he   Uni x   us er   i d   of    t he c ur r ent   us er .
pr oc es s . hr t i me. bi gi nt ( )    / /   Ret ur n   a   " hi gh- r es ol ut i on"   nanos ec ond t i mes t amp.
pr oc es s . ki l l ( )	/ /   Send   a   s i gnal	t o   anot her   pr oc es s . pr oc es s . memor yUs age( )	/ /   Ret ur n   an   obj ec t   wi t h   memor y   us age det ai l s .
pr oc es s . next Ti c k( )	/ /   L i ke   s et I mmedi at e( ) ,	i nvoke   a f unc t i on   s oon.
pr oc es s . pi d	/ /   The   pr oc es s   i d   of    t he   c ur r ent pr oc es s .
pr oc es s . ppi d	/ /   The   par ent   pr oc es s   i d.
pr oc es s . pl at f or m	/ /   The   OS:	" l i nux" ,	" dar wi n" ,	or " wi n32" ,	f or   exampl e.
pr oc es s . r es our c eUs age( )    / /   Ret ur n   an   obj ec t   wi t h   r es our c e   us age det ai l s .
pr oc es s . s et ui d( )	/ /   Set s   t he   c ur r ent   us er ,	by   i d   or   name. pr oc es s . t i t l e	/ /   The   pr oc es s   name   t hat   appear s   i n   ` ps ` l i s t i ngs .
pr oc es s . umas k( )	/ /   Set   or   r et ur n   t he   def aul t   per mi s s i ons f or   new  f i l es .
pr oc es s . upt i me( )	/ /   Ret ur n   Node' s   upt i me   i n   s ec onds . pr oc es s . ver s i on	/ /   Node' s   ver s i on   s t r i ng.
pr oc es s . ver s i ons	/ /   Ver s i on   s t r i ngs   f or   t he   l i br ar i es Node   depends   on.

The “os” module (which, unlike pr oces s , needs to be explicitly loaded with r equi r e( ) ) provides access to similarly low-level details about the computer and operating system that Node is running on. You may never need to use any of these features, but it is worth knowing that Node makes them available:

c ons t   os   =   r equi r e( " os " ) ;
os . ar c h( )	/ /   Ret ur ns   CPU  ar c hi t ec t ur e.	" x64"   or " ar m" ,	f or   exampl e.
os . c ons t ant s	/ /   Us ef ul	c ons t ant s   s uc h   as os . c ons t ant s . s i gnal s . SI GI NT.
os . c pus ( )	/ /   Dat a   about   s ys t em CPU  c or es ,	i nc l udi ng us age   t i mes .
os . endi annes s ( )	/ /   The   CPU' s   nat i ve   endi annes s   " BE"   or " L E" .

os . EOL	/ /   The   OS   nat i ve   l i ne   t er mi nat or :	" \ n"   or " \ r \ n" .
os . f r eemem( )	/ /   Ret ur ns   t he   amount   of    f r ee   RAM i n byt es .
os . get Pr i or i t y( )	/ /   Ret ur ns   t he   OS   s c hedul i ng   pr i or i t y   of a   pr oc es s .
os . homedi r ( )	/ /   Ret ur ns   t he   c ur r ent   us er ' s   home di r ec t or y.
os . hos t name( )	/ /   Ret ur ns   t he   hos t name   of    t he   c omput er . os . l oadavg( )	/ /   Ret ur ns   t he   1,	5,	and   15- mi nut e   l oad aver ages .
os . net wor kI nt er f ac es ( )    / /   Ret ur ns   det ai l s   about   avai l abl e net wor k.	c onnec t i ons .
os . pl at f or m( )	/ /   Ret ur ns   OS:	" l i nux" ,	" dar wi n" ,	or " wi n32" ,	f or   exampl e.
os . r el eas e( )	/ /   Ret ur ns   t he   ver s i on   number   of    t he   OS. os . s et Pr i or i t y( )	/ /   At t empt s   t o   s et   t he   s c hedul i ng
pr i or i t y   f or   a   pr oc es s .
os . t mpdi r ( )	/ /   Ret ur ns   t he   def aul t   t empor ar y di r ec t or y.
os . t ot al mem( )	/ /   Ret ur ns   t he   t ot al	amount   of    RAM i n byt es .
os . t ype( )	/ /   Ret ur ns   OS:	" L i nux" ,	" Dar wi n" ,	or " Wi ndows _NT" ,    e. g.
os . upt i me( )	/ /   Ret ur ns   t he   s ys t em upt i me   i n   s ec onds . os . us er I nf o( )	/ /   Ret ur ns   ui d,	us er name,	home,	and   s hel l of    c ur r ent   us er .


16.7 Working with Files

Node’s “fs” module is a comprehensive API for working with files and directories. It is complemented by the “path” module, which defines utility functions for working with file and directory names. The “fs” module contains a handful of high-level functions for easily reading, writing, and copying files. But most of the functions in the module are low-level JavaScript bindings to Unix system calls (and their equivalents on Windows). If you have worked with low-level filesystem calls before (in C or other languages), then the Node API will be familiar to you. If not, you

may find parts of the “fs” API to be terse and unintuitive. The function to delete a file, for example, is called unl i nk( ) .


The “fs” module defines a large API, mainly because there are usually multiple variants of each fundamental operation. As discussed at the beginning of the chapter, most functions such as f s . r eadFi l e( )  are nonblocking, callback-based, and asynchronous. Typically, though, each of these functions has a synchronous blocking variant, such as
f s . r eadFi l eSync( ) . In Node 10 and later, many of these functions also have a Promise-based asynchronous variant such as
f s . pr omi s es . r eadFi l e( ) . Most “fs” functions take a string as their first argument, specifying the path (filename plus optional directory names) to the file that is to be operated on. But a number of these functions also support a variant that takes an integer “file descriptor” as the first argument instead of a path. These variants have names that begin with the letter “f.” For example, f s . t r uncat e( )  truncates a file specified by path, and f s . f t r uncat e( )  truncates a file specified by file descriptor. There is a Promise-based f s . pr omi s es . t r uncat e( ) that expects a path and another Promise-based version that is implemented as a method of a FileHandle object. (The FileHandle class is the equivalent of a file descriptor in the Promise-based API.) Finally, there are a handful of functions in the “fs” module that have variants whose names are prefixed with the letter “l.” These “l” variants are like the base function but do not follow symbolic links in the filesystem and instead operate directly on the symbolic links themselves.


16.7.1 Paths, File Descriptors, and FileHandles

In order to use the “fs” module to work with files, you first need to be able to name the file you want to work with. Files are most often specified by

path, which means the name of the file itself, plus the hierarchy of directories in which the file appears. If a path is absolute, it means that directories all the way up to the filesystem root are specified. Otherwise, the path is relative and is only meaningful in relation to some other path, usually the current working directory. Working with paths can be a little tricky because different operating systems use different characters to separate directory names, it is easy to accidentally double those separator characters when concatenating paths, and because . . /  parent directory path segments need special handling. Node’s “path” module and a couple of other important Node features help:

/ /   Some   i mpor t ant   pat hs
pr oc es s . c wd( )	/ /   Abs ol ut e   pat h   of    t he   c ur r ent   wor ki ng

di r ec t or y. __f i l ename
c ur r ent   c ode. __di r name
__f i l ename.


/ /   Abs ol ut e   pat h   of

/ /   Abs ol ut e   pat h   of


t he   f i l e   t hat

t he   di r ec t or y


hol ds   t he

t hat   hol ds

os . homedi r ( )	/ /   The   us er ' s   home   di r ec t or y.

c ons t   pat h   =   r equi r e( " pat h" ) ;

pat h. s ep	/ /   Ei t her   " / "   or   " \ "   dependi ng on   your   OS

/ /   The   pat h   modul e   has   s i mpl e   par s i ng   f unc t i ons
l et   p   =   " s r c / pkg/ t es t . j s " ;	/ /   An   exampl e   pat h

pat h. bas ename( p) pat h. ext name( p) pat h. di r name( p)
pat h. bas ename( pat h. di r name( p) )
pat h. di r name( pat h. di r name( p) )

/ /   =>   " t es t . j s " / /   =>   " . j s "
/ /   =>   " s r c / pkg" / /   =>   " pkg"
/ /   =>   " s r c "


/ /   nor mal i z e( )    c l eans   up   pat hs :
pat h. nor mal i z e( " a/ b/ c / . . / d/ " )	/ /   =>   " a/ b/ d/ " :	handl es   . . / s egment s
pat h. nor mal i z e( " a/ . / b" )	/ /   =>   " a/ b" :	s t r i ps   " . / " s egment s
pat h. nor mal i z e( " / / a/ / b/ / " )	/ /   =>   " / a/ b/ " :	r emoves dupl i c at e   /


/ /   j oi n( )    c ombi nes   pat h   s egment s ,	addi ng   s epar at or s ,	t hen nor mal i z es
pat h. j oi n( " s r c " ,	" pkg" ,	" t . j s " )	/ /   =>   " s r c / pkg/ t . j s "

/ /   r es ol ve( )    t akes   one   or   mor e   pat h   s egment s   and   r et ur ns   an abs ol ut e
/ /   pat h.	I t   s t ar t s   wi t h   t he   l as t   ar gument   and   wor ks   bac kwar d, s t oppi ng
/ /   when   i t   has   bui l t   an   abs ol ut e   pat h   or   r es ol vi ng   agai ns t pr oc es s . c wd( ) .

pat h. r es ol ve( )
pat h. r es ol ve( " t . j s " ) " t . j s " )
pat h. r es ol ve( " / t mp" ,	" t . j s " )

/ /   =>   pr oc es s . c wd( )
/ /   =>   pat h. j oi n( pr oc es s . c wd( ) ,

/ /   =>   " / t mp/ t . j s "

pat h. r es ol ve( " / a" ,	" / b" ,	" t . j s " )    / /   =>   " / b/ t . j s "


Note that pat h. nor mal i z e( )  is simply a string manipulation function that has no access to the actual filesystem. The f s . r eal pat h( )  and
f s . r eal pat hSync( )  functions perform filesystem-aware canonicalization: they resolve symbolic links and interpret relative pathnames relative to the current working directory.

In the previous examples, we assumed that the code is running on a Unix-based OS and pat h. s ep is “/.” If you want to work with Unix-style paths even when on a Windows system, then use pat h. pos i x instead of pat h. And conversely, if you want to work with Windows paths even when on a Unix system, pat h. wi n32. pat h. pos i x and
pat h. wi n32 define the same properties and functions as pat h itself.


Some of the “fs” functions we’ll be covering in the next sections expect a file descriptor instead of a file name. File descriptors are integers used as OS-level references to “open” files. You obtain a descriptor for a given name by calling the f s . open( )  (or f s . openSync( ) ) function. Processes are only allowed to have a limited number of files open at one

time, so it is important that you call f s . cl os e( )  on your file descriptors when you are done with them. You need to open files if you want to use the lowest-level f s . r ead( )  and f s . wr i t e( )  functions that allow you to jump around within a file, reading and writing bits of it at different times. There are other functions in the “fs” module that use file descriptors, but they all have name-based versions, and it only really makes sense to use the descriptor-based functions if you were going to open the file to read or write anyway.

Finally, in the Promise-based API defined by f s . pr omi s es , the equivalent of f s . open( )  is f s . pr omi s es . open( ) , which returns a Promise that resolves to a FileHandle object. This FileHandle object serves the same purpose as a file descriptor. Again, however, unless you need to use the lowest-level r ead( )  and wr i t e( )  methods of a FileHandle, there is really no reason to create one. And if you do create a FileHandle, you should remember to call its cl os e( )  method once you are done with it.


16.7.2 Reading Files

Node allows you to read file content all at once, via a stream, or with the low-level API.


If your files are small, or if memory usage and performance are not the highest priority, then it is often easiest to read the entire content of a file with a single call. You can do this synchronously, with a callback, or with a Promise. By default, you’ll get the bytes of the file as a buffer, but if you specify an encoding, you’ll get a decoded string instead.

c ons t   f s   =   r equi r e( " f s " ) ;
l et   buf f er   =   f s . r eadFi l eSync ( " t es t . dat a" ) ;	/ /   Sync hr onous ,

r et ur ns   buf f er
l et   t ext   =   f s . r eadFi l eSync ( " dat a. c s v" ,	" ut f 8" ) ;	/ /   Sync hr onous , r et ur ns   s t r i ng

/ /   Read   t he   byt es   of    t he   f i l e   as ync hr onous l y f s . r eadFi l e( " t es t . dat a" ,	( er r ,	buf f er )    =>   {
i f    ( er r )    {
/ /   Handl e   t he   er r or   her e }    el s e   {
/ /   The   byt es   of    t he   f i l e   ar e   i n   buf f er }
} ) ;

/ /   Pr omi s e- bas ed   as ync hr onous   r ead f s . pr omi s es
. r eadFi l e( " dat a. c s v" ,	" ut f 8" ) . t hen( pr oc es s Fi l eText )
. c at c h( handl eReadEr r or ) ;

/ /   Or   us e   t he   Pr omi s e   API	wi t h   awai t   i ns i de   an   as ync   f unc t i on as ync   f unc t i on   pr oc es s Text ( f i l ename,	enc odi ng=" ut f 8" )    {
l et   t ext   =   awai t   f s . pr omi s es . r eadFi l e( f i l ename,	enc odi ng) ; / /   . . .	pr oc es s   t he   t ext   her e. . .
}


If you are able to process the contents of a file sequentially and do not need to have the entire content of the file in memory at the same time, then reading a file via a stream may be the most efficient approach. We’ve covered streams extensively: here is how you might use a stream and the pi pe( )  method to write the contents of a file to standard output:


f unc t i on   pr i nt Fi l e( f i l ename,	enc odi ng=" ut f 8" )    { f s . c r eat eReadSt r eam( f i l ename,
enc odi ng) . pi pe( pr oc es s . s t dout ) ; }


Finally, if you need low-level control over exactly what bytes you read from a file and when you read them, you can open a file to get a file descriptor and then use f s . r ead( ) , f s . r eadSync( ) , or

f s . pr omi s es . r ead( )  to read a specified number of bytes from a specified source location of the file into a specified buffer at the specified destination position:

c ons t   f s   =   r equi r e( " f s " ) ;

/ /   Readi ng   a   s pec i f i c   por t i on   of    a   dat a   f i l e f s . open( " dat a" ,	( er r ,	f d)    =>   {
i f    ( er r )    {
/ /   Repor t   er r or   s omehow r et ur n;
}
t r y   {
/ /   Read   byt es   20   t hr ough   420   i nt o   a   newl y   al l oc at ed buf f er .
f s . r ead( f d,	Buf f er . al l oc ( 400) ,	0,	400,	20,	( er r ,	n,	b)
=>   {
/ /   er r   i s   t he   er r or ,	i f    any.
/ /   n   i s   t he   number   of    byt es   ac t ual l y   r ead
/ /   b   i s   t he   buf f er   t hat   t hey   byt es   wer e   r ead   i nt o. } ) ;
}
f i nal l y   {	/ /   Us e   a   f i nal l y   c l aus e   s o   we   al ways f s . c l os e( f d) ;	/ /   c l os e   t he   open   f i l e   des c r i pt or
} } ) ;


The callback-based r ead( )  API is awkward to use if you need to read more than one chunk of data from a file. If you can use the synchronous API (or the Promise-based API with awai t ), it becomes easy to read multiple chunks from a file:

c ons t   f s   =   r equi r e( " f s " ) ;

f unc t i on   r eadDat a( f i l ename)    {
l et   f d   =   f s . openSync ( f i l ename) ; t r y   {
/ /   Read   t he   f i l e   header
l et   header   =   Buf f er . al l oc ( 12) ;	/ /   A  12   byt e   buf f er

f s . r eadSync ( f d,	header ,	0,	12,	0) ;

/ /   Ver i f y   t he   f i l e' s   magi c   number
l et   magi c   =   header . r eadI nt 32L E( 0) ; i f    ( magi c   ! ==   0xDADAFEED)    {
t hr ow  new  Er r or ( " Fi l e   i s   of    wr ong   t ype" ) ; }

/ /   Now  get   t he   of f s et   and   l engt h   of    t he   dat a   f r om t he header

l et   of f s et   =
l et   l engt h   =

header . r eadI nt 32L E( 4) ;
header . r eadI nt 32L E( 8) ;


/ /   And   r ead   t hos e   byt es   f r om t he   f i l e l et   dat a   =   Buf f er . al l oc ( l engt h) ;
f s . r eadSync ( f d,	dat a,	0,	l engt h,	of f s et ) ; r et ur n   dat a;
}    f i nal l y   {
/ /   Al ways   c l os e   t he   f i l e,	even   i f    an   exc ept i on   i s   t hr own above
f s . c l os eSync ( f d) ;
} }


16.7.3 Writing Files

Writing files in Node is a lot like reading them, with a few extra details that you need to know about. One of these details is that the way you create a new file is simply by writing to a filename that does not already exist.


As with reading, there are three basic ways to write files in Node. If you have the entire content of the file in a string or a buffer, you can write the entire thing in one call with f s . wr i t eFi l e( )  (callback-based),
f s . wr i t eFi l eSync( )  (synchronous), or
f s . pr omi s es . wr i t eFi l e( )  (Promise-based):


f s . wr i t eFi l eSync ( pat h. r es ol ve( __di r name,	" s et t i ngs . j s on" ) ,

J SON. s t r i ngi f y( s et t i ngs ) ) ;


If the data you are writing to the file is a string, and you want to use an encoding other than “utf8,” pass the encoding as an optional third argument.


The related functions f s . appendFi l e( ) , f s . appendFi l eSync( ) , and f s . pr omi s es . appendFi l e( )  are similar, but when the specified file already exists, they append their data to the end rather than overwriting the existing file content.

If the data you want to write to a file is not all in one chunk, or if it is not all in memory at the same time, then using a Writable stream is a good approach, assuming that you plan to write the data from beginning to end without skipping around in the file:

c ons t   f s   =   r equi r e( " f s " ) ;
l et   out put   =   f s . c r eat eWr i t eSt r eam( " number s . t xt " ) ; f or ( l et   i	=   0;	i	<   100;	i ++)    {
out put . wr i t e( ` ${ i } \ n` ) ; }
out put . end( ) ;


Finally, if you want to write data to a file in multiple chunks, and you want to be able to control the exact position within the file at which each chunk is written, then you can open the file with f s . open( ) ,
f s . openSync( ) , or f s . pr omi s es . open( )  and then use the resulting file descriptor with the f s . wr i t e( )  or f s . wr i t eSync( ) functions. These functions come in different forms for strings and buffers. The string variant takes a file descriptor, a string, and the file position at which to write that string (with an encoding as an optional fourth argument). The buffer variant takes a file descriptor, a buffer, an offset,

and a length that specify a chunk of data within the buffer, and a file position at which to write the bytes of that chunk. And if you have an array of Buffer objects that you want to write, you can do this with a single f s . wr i t ev( )  or f s . wr i t evSync( ) . Similar low-level functions exist for writing buffers and strings using
f s . pr omi s es . open( )  and the FileHandle object it produces.



FILE MODE STRINGS

We saw the f s . open( )  and f s . openSync( )  methods before when using the low-level API to read files. In that use case, it was sufficient to just pass the filename to the open function. When you want to write a file, however, you must also specify a second string argument that specifies how you intend to use the file descriptor. Some of the available flag strings are as follows:

" w"

Open the file for writing

" w+"

Open for writing and reading

" wx"

Open for creating a new file; fails if the named file already exists

" wx+"

Open for creation, and also allow reading; fails if the named file already exists

" a"

Open the file for appending; existing content won’t be overwritten

" a+"

Open for appending, but also allow reading

If you do not pass one of these flag strings to f s . open( )  or f s . openSync( ) , they use the default “r” flag, making the file descriptor read-only. Note that it can also be useful to pass these flags to other file-writing methods:

/ /   Wr i t e   t o   a   f i l e   i n   one   c al l ,    but   append   t o   anyt hi ng   t hat   i s   al r eady t her e.
/ /   Thi s   wor ks   l i ke   f s . appendFi l eSync ( )

f s . wr i t eFi l eSync( " mes s ages . l og" ,    " hel l o" ,    {   f l ag:    " a"   } ) ;

/ /   Open   a   wr i t e   s t r eam,    but   t hr ow  an   er r or   i f    t he   f i l e   al r eady   exi s t s . / /   We   don' t   want   t o   ac c i dent al l y   over wr i t e   s omet hi ng!
/ /   Not e   t hat   t he   opt i on   above   i s   " f l ag"   and   i s   " f l ags "   her e f s . cr eat eWr i t eSt r eam( " mes s ages . l og" ,    {   f l ags :    " wx"   } ) ;




You can chop off the end of a file with f s . t r uncat e( ) ,
f s . t r uncat eSync( ) , or f s . pr omi s es . t r uncat e( ) . These functions take a path as their first argument and a length as their second, and modify the file so that it has the specified length. If you omit the length, zero is used and the file becomes empty. Despite the name of these functions, they can also be used to extend a file: if you specify a length that is longer than the current file size, the file is extended with zero bytes to the new size. If you have already opened the file you wish to modify, you can use f t r uncat e( )  or f t r uncat eSync( )  with the file descriptor or FileHandle.

The various file-writing functions described here return or invoke their callback or resolve their Promise when the data has been “written” in the sense that Node has handed it off to the operating system. But this does not necessarily mean that the data has actually been written to persistent storage yet: at least some of your data may still be buffered somewhere in the operating system or in a device driver waiting to be written to disk. If you call f s . wr i t eSync( )  to synchronously write some data to a file, and if there is a power outage immediately after the function returns, you may still lose data. If you want to force your data out to disk so you know for sure that it has been safely saved, use f s . f s ync( )  or
f s . f s yncSync( ) . These functions only work with file descriptors: there is no path-based version.


16.7.4 File Operations

The preceding discussion of Node’s stream classes included two examples of copyFi l e( )  functions. These are not practical utilities that you would actually use because the “fs” module defines its own
f s . copyFi l e( )  method (and also f s . copyFi l eSync( )  and f s . pr omi s es . copyFi l e( ) , of course).

These functions take the name of the original file and the name of the copy as their first two arguments. These can be specified as strings or as URL or Buffer objects. An optional third argument is an integer whose bits specify flags that control details of the copy operation. And for the callback-based f s . copyFi l e( ) , the final argument is a callback function that will be called with no arguments when the copy is complete, or that will be called with an error argument if something fails. Following are some examples:

/ /   Bas i c   s ync hr onous   f i l e   c opy.
f s . c opyFi l eSync ( " c h15. t xt " ,	" c h15. bak" ) ;

/ /   The   COPYFI L E_EXCL   ar gument   c opi es   onl y   i f    t he   new  f i l e   does not   al r eady
/ /   exi s t .	I t   pr event s   c opi es   f r om over wr i t i ng   exi s t i ng   f i l es .
f s . c opyFi l e( " c h15. t xt " ,	" c h16. t xt " ,	f s . c ons t ant s . COPYFI L E_EXCL ,
er r   =>   {
/ /   Thi s   c al l bac k   wi l l	be   c al l ed   when   done.	On   er r or ,	er r wi l l	be   non- nul l .
} ) ;

/ /   Thi s   c ode   demons t r at es   t he   Pr omi s e- bas ed   ver s i on   of    t he c opyFi l e   f unc t i on.
/ /   Two   f l ags   ar e   c ombi ned   wi t h   t he   bi t wi s e   OR  opear t or   |.	The f l ags   mean   t hat
/ /   exi s t i ng   f i l es   won' t   be   over wr i t t en,	and   t hat   i f    t he f i l es ys t em s uppor t s
/ /   i t ,	t he   c opy   wi l l	be   a   c opy- on- wr i t e   c l one   of    t he   or i gi nal f i l e,    meani ng
/ /   t hat   no   addi t i onal	s t or age   s pac e   wi l l	be   r equi r ed   unt i l ei t her   t he   or i gi nal
/ /   or   t he   c opy   i s   modi f i ed.
f s . pr omi s es . c opyFi l e( " I mpor t ant   dat a" ,

` I mpor t ant   dat a   ${ new Dat e( ) . t oI SOSt r i ng( ) } "
f s . c ons t ant s . COPYFI L E_EXCL   | f s . c ons t ant s . COPYFI L E_FI CL ONE)
. t hen( ( )    =>   {
c ons ol e. l og( " Bac kup   c ompl et e" ) ; } ) ;
. c at c h( er r   =>   {
c ons ol e. er r or ( " Bac kup   f ai l ed" ,	er r ) ; } ) ;


The f s . r ename( )  function (along with the usual synchronous and Promise-based variants) moves and/or renames a file. Call it with the current path to the file and the desired new path to the file. There is no flags argument, but the callback-based version takes a callback as the third argument:

f s . r enameSync ( " c h15. bak" ,	" bac kups / c h15. bak" ) ;


Note that there is no flag to prevent renaming from overwriting an existing file. Also keep in mind that files can only be renamed within a filesystem.


The functions f s . l i nk( )  and f s . s yml i nk( )  and their variants have the same signatures as f s . r ename( )  and behave something like
f s . copyFi l e( )  except that they create hard links and symbolic links, respectively, rather than creating a copy.

Finally, f s . unl i nk( ) , f s . unl i nkSync( ) , and
f s . pr omi s es . unl i nk( )  are Node’s functions for deleting a file. (The unintuitive naming is inherited from Unix where deleting a file is basically the opposite of creating a hard link to it.) Call this function with the string, buffer, or URL path to the file to be deleted, and pass a callback if you are using the callback-based version:

f s . unl i nkSync ( " bac kups / c h15. bak" ) ;

16.7.5 File Metadata

The f s . s t at ( ) , f s . s t at Sync( ) , and f s . pr omi s es . s t at ( ) functions allow you to obtain metadata for a specified file or directory. For example:

c ons t   f s   =   r equi r e( " f s " ) ;
l et   s t at s   =   f s . s t at Sync ( " book/ c h15. md" ) ;
s t at s . i s Fi l e( )	/ /   =>   t r ue:	t hi s   i s   an   or di nar y   f i l e s t at s . i s Di r ec t or y( )	/ /   =>   f al s e:    i t   i s   not   a   di r ec t or y
s t at s . s i z e	/ /   f i l e   s i z e   i n   byt es
s t at s . at i me	/ /   ac c es s   t i me:	Dat e   when   i t   was   l as t r ead
s t at s . mt i me	/ /   modi f i c at i on   t i me:	Dat e   when   i t   was l as t   wr i t t en
s t at s . ui d	/ /   t he   us er   i d   of    t he   f i l e' s   owner s t at s . gi d	/ /   t he   gr oup   i d   of    t he   f i l e' s   owner
s t at s . mode. t oSt r i ng( 8)    / /   t he   f i l e' s   per mi s s i ons ,	as   an   oc t al s t r i ng


The returned Stats object contains other, more obscure properties and methods, but this code demonstrates those that you are most likely to use.


f s . l s t at ( )  and its variants work just like f s . s t at ( ) , except that if the specified file is a symbolic link, Node will return metadata for the link itself rather than following the link.

If you have opened a file to produce a file descriptor or a FileHandle object, then you can use f s . f s t at ( )  or its variants to get metadata information for the opened file without having to specify the filename again.

In addition to querying metadata with f s . s t at ( )  and all of its variants, there are also functions for changing metadata.

f s . chmod( ) , f s . l chmod( ) , and f s . f chmod( )  (along with synchronous and Promise-based versions) set the “mode” or permissions of a file or directory. Mode values are integers in which each bit has a specific meaning and are easiest to think about in octal notation. For example, to make a file read-only to its owner and inaccessible to everyone else, use 0o400:


f s . c hmodSync ( " c h15. md" ,	0o400) ;	/ /   Don' t   del et e   i t ac c i dent al l y!


f s . chown( ) , f s . l chown( ) , and f s . f chown( )  (along with synchronous and Promise-based versions) set the owner and group (as IDs) for a file or directory. (These matter because they interact with the file permissions set by f s . chmod( ) .)


Finally, you can set the access time and modification time of a file or directory with f s . ut i mes ( )  and f s . f ut i mes ( )  and their variants.


16.7.6 Working with Directories

To create a new directory in Node, use f s . mkdi r ( ) ,
f s . mkdi r Sync( ) , or f s . pr omi s es . mkdi r ( ) . The first argument is the path of the directory to be created. The optional second argument can be an integer that specifies the mode (permissions bits) for the new directory. Or you can pass an object with optional mode and r ecur s i ve properties. If r ecur s i ve is t r ue, then this function will create any directories in the path that do not already exist:

/ /   Ens ur e   t hat   di s t /   and   di s t / l i b/   bot h   exi s t . f s . mkdi r Sync ( " di s t / l i b" ,    {    r ec ur s i ve:    t r ue   } ) ;


f s . mkdt emp( )  and its variants take a path prefix you provide, append

some random characters to it (this is important for security), create a directory with that name, and return (or pass to a callback) the directory path to you.


To delete a directory, use f s . r mdi r ( )  or one of its variants. Note that directories must be empty before they can be deleted:


/ /   Cr eat e / /   del et e

a   r andom t empor ar y   di r ec t or y   and   get   i t s   pat h,	t hen i t   when   we   ar e   done

l et   t empDi r Pat h; t r y   {
t empDi r Pat h   =   f s . mkdt empSync ( pat h. j oi n( os . t mpdi r ( ) ,	" d" ) ) ; / /   Do   s omet hi ng   wi t h   t he   di r ec t or y   her e
}    f i nal l y   {
/ /   Del et e   t he   t empor ar y   di r ec t or y   when   we' r e   done   wi t h   i t f s . r mdi r Sync ( t empDi r Pat h) ;
}


The “fs” module provides two distinct APIs for listing the contents of a directory. First, f s . r eaddi r ( ) , f s . r eaddi r Sync( ) , and
f s . pr omi s es . r eaddi r ( )  read the entire directory all at once and give you an array of strings or an array of Dirent objects that specify the names and types (file or directory) of each item. Filenames returned by these functions are just the local name of the file, not the entire path. Here are examples:

l et   t empFi l es   =   f s . r eaddi r Sync ( " / t mp" ) ;	/ /   r et ur ns   an   ar r ay   of s t r i ngs

/ /   Us e   t he   Pr omi s e- bas ed   API	t o   get   a   Di r ent   ar r ay,	and   t hen / /   pr i nt   t he   pat hs   of    s ubdi r ec t or i es
f s . pr omi s es . r eaddi r ( " / t mp" ,	{ wi t hFi l eTypes :	t r ue} )
. t hen( ent r i es   =>   {
ent r i es . f i l t er ( ent r y   =>   ent r y. i s Di r ec t or y( ) ) . map( ent r y   =>   ent r y. name)
. f or Eac h( name   =>   c ons ol e. l og( pat h. j oi n( " / t mp/ " , name) ) ) ;

} )
. c at c h( c ons ol e. er r or ) ;


If you anticipate needing to list directories that might have thousands of entries, you might prefer the streaming approach of f s . opendi r ( )  and its variants. These functions return a Dir object representing the specified directory. You can use the r ead( )  or r eadSync( )  methods of the Dir object to read one Dirent at a time. If you pass a callback function to
r ead( ) , it will call the callback. And if you omit the callback argument, it will return a Promise. When there are no more directory entries, you’ll get nul l  instead of a Dirent object.


The easiest way to use Dir objects is as async iterators with a
f or / awai t  loop. Here, for example, is a function that uses the streaming API to list directory entries, calls s t at ( )  on each entry, and prints file and directory names and sizes:

c ons t   f s   =   r equi r e( " f s " ) ;
c ons t   pat h   =   r equi r e( " pat h" ) ;

as ync   f unc t i on   l i s t Di r ec t or y( di r pat h)    {
l et   di r   =   awai t   f s . pr omi s es . opendi r ( di r pat h) ; f or   awai t   ( l et   ent r y   of    di r )    {
l et   name   =   ent r y. name;
i f    ( ent r y. i s Di r ec t or y( ) )    {
name   +=   " / " ;	/ /   Add   a   t r ai l i ng   s l as h   t o s ubdi r ec t or i es
}
l et   s t at s   =   awai t   f s . pr omi s es . s t at ( pat h. j oi n( di r pat h, name) ) ;
l et   s i z e   =   s t at s . s i z e;
c ons ol e. l og( St r i ng( s i z e) . padSt ar t ( 10) ,	name) ; }
}

16.8 HTTP Clients and Servers

Node’s “http,” “https,” and “http2” modules are full-featured but relatively low-level implementations of the HTTP protocols. They define comprehensive APIs for implementing HTTP clients and servers. Because the APIs are relatively low-level, there is not room in this chapter to cover all the features. But the examples that follow demonstrate how to write basic clients and servers.


The simplest way to make a basic HTTP GET request is with
ht t p. get ( )  or ht t ps . get ( ) . The first argument to these functions is the URL to fetch. (If it is an ht t p: / /  URL, you must use the “http” module, and if it is an ht t ps : / /  URL you must use the “https” module.) The second argument is a callback that will be invoked with an IncomingMessage object when the server’s response has started to arrive. When the callback is called, the HTTP status and headers are available, but the body may not be ready yet. The IncomingMessage object is a Readable stream, and you can use the techniques demonstrated earlier in this chapter to read the response body from it.

The get J SON( )  function at the end of §13.2.6 used the ht t p. get ( ) function as part of a demonstration of the Pr omi s e( )  constructor. Now that you know about Node streams and the Node programming model more generally, it is worth revisiting that example to see how

ht t p. get ( )


ht t p. get ( )

is used.


and ht t ps . get ( )  are slightly simplified variants of the

more general ht t p. r eques t ( )  and ht t ps . r eques t ( )  functions. The following pos t J SON( )  function demonstrates how to use
ht t ps . r eques t ( )  to make an HTTPS POST request that includes a

JSON request body. Like the get J SON( )  function of Chapter 13, it expects a JSON response and returns a Promise that fulfills to the parsed version of that response:

c ons t   ht t ps   =   r equi r e( " ht t ps " ) ;

/ *
*   Conver t   t he   body   obj ec t   t o   a   J SON  s t r i ng   t hen   HTTPS   POST   i t t o   t he
*   s pec i f i ed   API	endpoi nt   on   t he   s pec i f i ed   hos t .	When   t he r es pons e   ar r i ves ,
*   par s e   t he   r es pons e   body   as   J SON  and   r es ol ve   t he   r et ur ned Pr omi s e   wi t h
*   t hat   par s ed   val ue. */
f unc t i on   pos t J SON( hos t ,	endpoi nt ,	body,	por t ,	us er name,
pas s wor d)    {

/ /   Ret ur n   a r ej ec t
/ /   when   t he

Pr omi s e   obj ec t   i mmedi at el y,	t hen   c al l	r es ol ve   or

HTTPS   r eques t   s uc c eeds   or   f ai l s .

r et ur n   new  Pr omi s e( ( r es ol ve,	r ej ec t )    =>   {
/ /   Conver t   t he   body   obj ec t   t o   a   s t r i ng l et   bodyText   =   J SON. s t r i ngi f y( body) ;

/ /   Conf i gur e   t he   HTTPS   r eques t l et   r eques t Opt i ons   =   {
met hod:	" POST" ,	/ /   Or   " GET" ,	" PUT" ,	" DEL ETE" , et c .
hos t :	hos t ,	/ /   The   hos t   t o   c onnec t   t o pat h:	endpoi nt ,	/ /   The   URL   pat h
header s :	{	/ /   HTTP   header s   f or   t he r eques t
" Cont ent - Type" :	" appl i c at i on/ j s on" ,
" Cont ent - L engt h" :	Buf f er . byt eL engt h( bodyText ) }
} ;

i f    ( por t )    {	/ /   I f    a   por t   i s s pec i f i ed,
r eques t Opt i ons . por t   =   por t ;	/ /   us e   i t   f or   t he r eques t .
}
/ /   I f    c r edent i al s   ar e   s pec i f i ed,	add   an   Aut hor i z at i on

header .
i f    ( us er name   &&  pas s wor d)    {
r eques t Opt i ons . aut h   =   ` ${ us er name} : ${ pas s wor d} ` ; }

/ /   Now  c r eat e   t he   r eques t   bas ed   on   t he   c onf i gur at i on obj ec t
l et   r eques t   =   ht t ps . r eques t ( r eques t Opt i ons ) ;

/ /   Wr i t e   t he   body   of    t he   POST   r eques t   and   end   t he r eques t .
r eques t . wr i t e( bodyText ) ;
r eques t . end( ) ;

/ /   Fai l	on   r eques t   er r or s   ( s uc h   as   no   net wor k c onnec t i on)
r eques t . on( " er r or " ,	e   =>   r ej ec t ( e) ) ;

/ /   Handl e   t he   r es pons e   when   i t   s t ar t s   t o   ar r i ve. r eques t . on( " r es pons e" ,	r es pons e   =>   {
i f    ( r es pons e. s t at us Code   ! ==   200)    { r ej ec t ( new  Er r or ( ` HTTP   s t at us
${ r es pons e. s t at us Code} ` ) ) ;


c as e,	but

s omewher e,	s o

r egi s t er i ng

di s c ar ded.

/ /   We   don' t   c ar e   about   t he   r es pons e   body   i n   t hi s

/ /   we   don' t   want   i t   t o   s t i c k   ar ound   i n   a   buf f er

/ /   we   put   t he   s t r eam i nt o   f l owi ng   mode   wi t hout

/ /   a   " dat a"   handl er   s o   t hat   t he   body   i s

r es pons e. r es ume( ) ; r et ur n;
}

/ /   We   want   t ext ,	not   byt es .	We' r e   as s umi ng   t he   t ext wi l l	be
/ /   J SON- f or mat t ed   but   ar en' t   bot her i ng   t o   c hec k   t he / /   Cont ent - Type   header .
r es pons e. s et Enc odi ng( " ut f 8" ) ;


/ / r ead   t he
/ /

Node   does n' t   have   a   s t r eami ng   J SON  par s er ,	s o   we

ent i r e   r es pons e   body   i nt o   a   s t r i ng.

l et   body   =   " " ;
r es pons e. on( " dat a" ,	c hunk   =>   {    body   +=   c hunk;	} ) ;


/ /   And   now  handl e   t he   r es pons e   when   i t   i s   c ompl et e. r es pons e. on( " end" ,	( )    =>   {	/ /   When   t he
r es pons e   i s   done,
t r y   {	/ /   t r y   t o   par s e i t   as   J SON
r es ol ve( J SON. par s e( body) ) ;	/ /   and   r es ol ve t he   r es ul t .
}    c at c h( e)    {	/ /   Or ,	i f anyt hi ng   goes   wr ong,
r ej ec t ( e) ;	/ /   r ej ec t   wi t h t he   er r or
} } ) ;
} ) ; } ) ;
}


In addition to making HTTP and HTTPS requests, the “http” and “https” modules also allow you to write servers that respond to those requests. The basic approach is as follows:

Create a new Server object.

Call its l i s t en( )  method to begin listening for requests on a specified port.

Register an event handler for “request” events, use that handler to read the client’s request (particularly the r eques t . ur l property), and write your response.

The code that follows creates a simple HTTP server that serves static files from the local filesystem and also implements a debugging endpoint that responds to a client’s request by echoing that request.

/ /   Thi s   i s   a   s i mpl e   s t at i c   HTTP   s er ver   t hat   s er ves   f i l es   f r om a s pec i f i ed
/ /   di r ec t or y.	I t   al s o   i mpl ement s   a   s pec i al	/ t es t / mi r r or   endpoi nt t hat
/ /   ec hoes   t he   i nc omi ng   r eques t ,	whi c h   c an   be   us ef ul	when

debuggi ng   c l i ent s .
c ons t   ht t p   =   r equi r e( " ht t p" ) ;	/ /   Us e   " ht t ps "   i f    you   have   a c er t i f i c at e
c ons t   ur l	=   r equi r e( " ur l " ) ;	/ /   For   par s i ng   URL s
c ons t   pat h   =   r equi r e( " pat h" ) ;	/ /   For   mani pul at i ng   f i l es ys t em pat hs
c ons t   f s   =   r equi r e( " f s " ) ;	/ /   For   r eadi ng   f i l es

/ /   Ser ve   f i l es   f r om t he   s pec i f i ed   r oot   di r ec t or y   vi a   an   HTTP s er ver   t hat
/ /   l i s t ens   on   t he   s pec i f i ed   por t .
f unc t i on   s er ve( r oot Di r ec t or y,	por t )    {
l et   s er ver   =   new  ht t p. Ser ver ( ) ;	/ /   Cr eat e   a   new  HTTP   s er ver s er ver . l i s t en( por t ) ;	/ /   L i s t en   on   t he   s pec i f i ed
por t
c ons ol e. l og( " L i s t eni ng   on   por t " ,	por t ) ;

/ /   When   r eques t s   c ome   i n,	handl e   t hem wi t h   t hi s   f unc t i on s er ver . on( " r eques t " ,	( r eques t ,	r es pons e)    =>   {

/ /   Get   t he   pat h   por t i on / /   any   quer y   par amet er s

of    t he   r eques t   URL ,	i gnor i ng t hat   ar e   appended   t o   i t .

l et   endpoi nt   =   ur l . par s e( r eques t . ur l ) . pat hname;



r eques t

header s

/ /   I f    t he   r eques t   was   f or   " / t es t / mi r r or " ,	s end   bac k   t he

/ /   ver bat i m.	Us ef ul	when   you   need   t o   s ee   t he   r eques t and   body.

i f    ( endpoi nt   ===   " / t es t / mi r r or " )    { / /   Set   r es pons e   header
r es pons e. s et Header ( " Cont ent - Type" ,	" t ext / pl ai n; c har s et =UTF- 8" ) ;

/ /   Spec i f y   r es pons e   s t at us   c ode
r es pons e. wr i t eHead( 200) ;	/ /   200   OK

/ /   Begi n   t he   r es pons e   body   wi t h   t he   r eques t
r es pons e. wr i t e( ` ${ r eques t . met hod}    ${ r eques t . ur l } HTTP/ ${
r eques t . ht t pVer s i on } \ r \ n` ) ;

/ /   Out put   t he   r eques t   header s
l et   header s   =   r eques t . r awHeader s ;
f or ( l et   i	=   0;	i	<   header s . l engt h;	i	+=   2)    { r es pons e. wr i t e( ` ${ header s [ i ] } :

${ header s [ i +1] } \ r \ n` ) ; }

/ /   End   header s   wi t h   an   ext r a   bl ank   l i ne r es pons e. wr i t e( " \ r \ n" ) ;


/ / r es pons e   body
/ /

Now  we   need   t o

Si nc e   t hey   ar e

c opy   any   r eques t

bot h   s t r eams ,	we

body   t o   t he

c an   us e   a   pi pe

r eques t . pi pe( r es pons e) ; }
/ /   Ot her wi s e,	s er ve   a   f i l e   f r om t he   l oc al	di r ec t or y. el s e   {
/ /   Map   t he   endpoi nt   t o   a   f i l e   i n   t he   l oc al f i l es ys t em
l et   f i l ename   =   endpoi nt . s ubs t r i ng( 1) ;	/ /   s t r i p

l eadi ng   /

a   s ec ur i t y

di r ec t or y.


/ /   Don' t   al l ow  " . . / "   i n   t he   pat h   bec aus e   i t   woul d   be

/ /   hol e   t o   s er ve   anyt hi ng   out s i de   t he   r oot

f i l ename   =   f i l ename. r epl ac e( / \ . \ . \ / / g,	" " ) ;
/ /   Now  c onver t   f r om r el at i ve   t o   abs ol ut e   f i l ename f i l ename   =   pat h. r es ol ve( r oot Di r ec t or y,    f i l ename) ;

/ /   Now  gues s   t he   t ype   f i l e' s   c ont ent   t ype   bas ed   on ext ens i on
l et   t ype;
s wi t c h( pat h. ext name( f i l ename) )	{ c as e   " . ht ml " :
c as e   " . ht m" :	t ype   =   " t ext / ht ml " ;	br eak;
c as e   " . j s " :	t ype   =   " t ext / j avas c r i pt " ;	br eak; c as e   " . c s s " :	t ype   =   " t ext / c s s " ;	br eak;
c as e   " . png" :	t ype   =   " i mage/ png" ;	br eak; c as e   " . t xt " :	t ype   =   " t ext / pl ai n" ;    br eak;
def aul t :	t ype   =   " appl i c at i on/ oc t et - s t r eam" ; br eak;
}

l et   s t r eam =   f s . c r eat eReadSt r eam( f i l ename) ; s t r eam. onc e( " r eadabl e" ,	( )    =>   {

/ / / /
pi pe   t he
/ /

I f    t he   s t r eam bec omes   r eadabl e,	t hen   s et   t he Cont ent - Type   header   and   a   200   OK   s t at us .	Then

f i l e   r eader   s t r eam t o   t he   r es pons e.	The   pi pe

wi l l
/ /   aut omat i c al l y   c al l	r es pons e. end( )    when   t he s t r eam ends .
r es pons e. s et Header ( " Cont ent - Type" ,	t ype) ;
r es pons e. wr i t eHead( 200) ; s t r eam. pi pe( r es pons e) ;
} ) ;

s t r eam. on( " er r or " ,	( er r )    =>   {


t he   s t r eam

not   r eadabl e.

t he

/ /   I ns t ead,	i f    we   get   an   er r or   t r yi ng   t o   open

/ /   t hen   t he   f i l e   pr obabl y   does   not   exi s t   or   i s

/ /   Send   a   404   Not   Found   pl ai n- t ext   r es pons e   wi t h

/ /   er r or   mes s age.

r es pons e. s et Header ( " Cont ent - Type" ,	" t ext / pl ai n; c har s et =UTF- 8" ) ;
r es pons e. wr i t eHead( 404) ;
r es pons e. end( er r . mes s age) ; } ) ;
} } ) ;
}

/ /   When   we' r e   i nvoked   f r om t he   c ommand   l i ne,	c al l	t he   s er ve( ) f unc t i on
s er ve( pr oc es s . ar gv[ 2]    ||   " / t mp" ,	par s eI nt ( pr oc es s . ar gv[ 3] )    ||
8000) ;


Node’s built-in modules are all you need to write simple HTTP and HTTPS servers. Note, however, that production servers are not typically built directly on top of these modules. Instead, most nontrivial servers are implemented using external libraries—such as the Express framework— that provide “middleware” and other higher-level utilities that backend web developers have come to expect.


16.9 Non-HTTP Network Servers and Clients

Web servers and clients have become so ubiquitous that it is easy to forget that it is possible to write clients and servers that do not use HTTP. Even though Node has a reputation as a good environment for writing web servers, Node also has full support for writing other types of network servers and clients.


If you are comfortable working with streams, then networking is relatively simple, because network sockets are simply a kind of Duplex stream. The “net” module defines Server and Socket classes. To create a server, call net . cr eat eSer ver ( ) , then call the l i s t en( )  method of the resulting object to tell the server what port to listen on for connections. The Server object will generate “connection” events when a client connects on that port, and the value passed to the event listener will be a Socket object. The Socket object is a Duplex stream, and you can use it to read data from the client and write data to the client. Call end( )  on the Socket to disconnect.

Writing a client is even easier: pass a port number and hostname to
net . cr eat eConnect i on( )  to create a socket to communicate with whatever server is running on that host and listening on that port. Then use that socket to read and write data from and to the server.

The following code demonstrates how to write a server with the “net” module. When the client connects, the server tells a knock-knock joke:

/ /   A  TCP   s er ver   t hat   del i ver s   i nt er ac t i ve   knoc k- knoc k   j okes   on por t   6789.
/ /   ( Why   i s   s i x   af r ai d   of    s even?   Bec aus e   s even   at e   ni ne! ) c ons t   net   =   r equi r e( " net " ) ;
c ons t   r eadl i ne   =   r equi r e( " r eadl i ne" ) ;

/ /   Cr eat e   a   Ser ver   obj ec t   and   s t ar t   l i s t eni ng   f or   c onnec t i ons l et   s er ver   =   net . c r eat eSer ver ( ) ;

s er ver . l i s t en( 6789,	( )    =>   c ons ol e. l og( " Del i ver i ng   l aughs   on   por t 6789" ) ) ;

/ /   When   a   c l i ent   c onnec t s ,	t el l	t hem a   knoc k- knoc k   j oke. s er ver . on( " c onnec t i on" ,	s oc ket   =>   {
t el l J oke( s oc ket )
. t hen( ( )    =>   s oc ket . end( ) )	/ /   When   t he   j oke   i s   done, c l os e   t he   s oc ket .
. c at c h( ( er r )    =>   {
c ons ol e. er r or ( er r ) ;	/ /   L og   any   er r or s   t hat   oc c ur , s oc ket . end( ) ;	/ /   but   s t i l l	c l os e   t he
s oc ket !
} ) ; } ) ;

/ /   Thes e   ar e   al l	t he   j okes   we   know. c ons t   j okes   =   {
" Boo" :	" Don' t   c r y. . . i t ' s   onl y   a   j oke! " ,
" L et t uc e" :	" L et   us   i n!   I t ' s   f r eez i ng   out   her e! " ,
" A  l i t t l e   ol d   l ady" :	" Wow,	I	di dn' t   know  you   c oul d   yodel ! " } ;

/ /   I nt er ac t i vel y   per f or m a   knoc k- knoc k   j oke   over   t hi s   s oc ket , wi t hout   bl oc ki ng.
as ync   f unc t i on   t el l J oke( s oc ket )    {
/ /   Pi c k   one   of    t he   j okes   at   r andom
l et   r andomEl ement   =   a   =>   a[ Mat h. f l oor ( Mat h. r andom( )    *
a. l engt h) ] ;
l et   who   =   r andomEl ement ( Obj ec t . keys ( j okes ) ) ; l et   punc hl i ne   =   j okes [ who] ;

/ /   Us e   t he   r eadl i ne   modul e   t o   r ead   t he   us er ' s   i nput   one   l i ne at   a   t i me.
l et   l i neReader   =   r eadl i ne. c r eat eI nt er f ac e( {
i nput :	s oc ket , out put :    s oc ket , pr ompt :    " >>   "
} ) ;


/ /   A  ut i l i t y   f unc t i on   t o / /   and   t hen   ( by   def aul t )

out put   a   l i ne   of    t ext   t o   t he   c l i ent di s pl ay   a   pr ompt .

f unc t i on   out put ( t ext ,    pr ompt =t r ue)    { s oc ket . wr i t e( ` ${ t ext } \ r \ n` ) ;
i f    ( pr ompt )    l i neReader . pr ompt ( ) ;

}

/ /   Knoc k- knoc k   j okes   have   a   c al l - and- r es pons e   s t r uc t ur e. / /   We   expec t   di f f er ent   i nput   f r om t he   us er   at   di f f er ent
s t ages   and
/ /   t ake   di f f er ent   ac t i on   when   we   get   t hat   i nput   at   di f f er ent s t ages .
l et   s t age   =   0;

/ /   St ar t   t he   knoc k- knoc k   j oke   of f    i n   t he   t r adi t i onal	way. out put ( " Knoc k   knoc k! " ) ;

/ /   Now  r ead   l i nes   as ync hr onous l y   f r om t he   c l i ent   unt i l	t he j oke   i s   done.
f or   awai t   ( l et   i nput L i ne   of    l i neReader )    {
i f    ( s t age   ===   0)    {
i f    ( i nput L i ne. t oL ower Cas e( )    ===   " who' s   t her e?" )    {


0

t o   s t age   1.

/ /   I f    t he   us er   gi ves   t he   r i ght

/ /   t hen   t el l	t he   f i r s t   par t   of

r es pons e

t he   j oke

at   s t age

and   go

out put ( who) ; s t age   =   1;
}    el s e	{
/ /   Ot her wi s e   t eac h   t he   us er   how  t o   do   knoc k-knoc k   j okes .
out put ( ' Pl eas e   t ype   " Who\ ' s   t her e?" . ' ) ;
}
}    el s e   i f    ( s t age   ===   1)    {
i f    ( i nput L i ne. t oL ower Cas e( )    === ` ${ who. t oL ower Cas e( ) }    who?` )    {


t hen

j oke   i s   done.

/ /   I f    t he   us er ' s   r es pons e   i s

/ /   del i ver   t he   punc hl i ne   and

c or r ec t   at   s t age   1,

r et ur n   s i nc e   t he

out put ( ` ${ punc hl i ne} ` ,	f al s e) ; r et ur n;
}    el s e   {
/ /   Make   t he   us er   pl ay   al ong.
out put ( ` Pl eas e   t ype   " ${ who}    who?" . ` ) ; }
} }
}

Simple text-based servers like this do not typically need a custom client. If the nc (“netcat”) utility is installed on your system, you can use it to communicate with this server as follows:

$   nc   l oc al hos t   6789 Knoc k   knoc k!
>>   Who' s   t her e?
A  l i t t l e   ol d   l ady
>>   A  l i t t l e   ol d   l ady   who?
Wow,	I	di dn' t   know  you   c oul d   yodel !


On the other hand, writing a custom client for the joke server is easy in Node. We just connect to the server, then pipe the server’s output to stdout and pipe stdin to the server’s input:

/ /   Connec t   t o   t he   j oke   por t   ( 6789)    on   t he   s er ver   named   on   t he c ommand   l i ne
l et   s oc ket   =   r equi r e( " net " ) . c r eat eConnec t i on( 6789,
pr oc es s . ar gv[ 2] ) ;
s oc ket . pi pe( pr oc es s . s t dout ) ;	/ /   Pi pe   dat a   f r om t he s oc ket   t o   s t dout
pr oc es s . s t di n. pi pe( s oc ket ) ;	/ /   Pi pe   dat a   f r om s t di n   t o   t he   s oc ket
s oc ket . on( " c l os e" ,	( )    =>   pr oc es s . exi t ( ) ) ;	/ /   Qui t   when   t he s oc ket   c l os es .


In addition to supporting TCP-based servers, Node’s “net” module also supports interprocess communication over “Unix domain sockets” that are identified by a filesystem path rather than by a port number. We are not going to cover that kind of socket in this chapter, but the Node documentation has details. Other Node features that we don’t have space to cover here include the “dgram” module for UDP-based clients and servers and the “tls” module that is to “net” as “https” is to “http.” The
t l s . Ser ver  and t l s . TLSSocket  classes allow the creation of TCP servers (like the knock-knock joke server) that use SSL-encrypted connections like HTTPS servers do.

16.10 Working with Child Processes

In addition to writing highly concurrent servers, Node also works well for writing scripts that execute other programs. In Node the “child_process” module defines a number of functions for running other programs as child processes. This section demonstrates some of those functions, starting with the simplest and moving to the more complicated.


16.10.1 execSync() and execFileSync()

The easiest way to run another program is with
chi l d_pr oces s . execSync( ) . This function takes the command to run as its first argument. It creates a child process, runs a shell in that process, and uses the shell to execute the command you passed. Then it blocks until the command (and the shell) exit. If the command exits with an error, then execSync( )  throws an exception. Otherwise, execSync( )  returns whatever output the command writes to its stdout stream. By default this return value is a buffer, but you can specify an encoding in an optional second argument to get a string instead. If the command writes any output to stderr, that output just gets passed through to the parent process’s stderr stream.

So, for example, if you are writing a script and performance is not a concern, you might use chi l d_pr oces s . execSync( )  to list a directory with a familiar Unix shell command rather than using the f s . r eaddi r Sync( )  function:

c ons t   c hi l d_pr oc es s   =   r equi r e( " c hi l d_pr oc es s " ) ;
l et   l i s t i ng   =   c hi l d_pr oc es s . exec Sync ( " l s   - l	web/ *. ht ml " , { enc odi ng:	" ut f 8" } ) ;


The fact that execSync( )  invokes a full Unix shell means that the string

you pass to it can include multiple semicolon-separated commands, and can take advantage of shell features such as filename wildcards, pipes, and output redirection. This also means that you must be careful to never pass a command to execSync( )  if any portion of that command is user input or comes from a similar untrusted source. The complex syntax of shell commands can be easily subverted to allow an attacker to run arbitrary code.

If you don’t need the features of a shell, you can avoid the overhead of starting a shell by using chi l d_pr oces s . execFi l eSync( ) . This function executes a program directly, without invoking a shell. But since no shell is involved, it can’t parse a command line, and you must pass the executable as the first argument and an array of command-line arguments as the second argument:

l et   l i s t i ng   =   c hi l d_pr oc es s . exec Fi l eSync ( " l s " ,	[ " - l " ,	" web/ " ] , { enc odi ng:	" ut f 8" } ) ;



CHILD PROCESS OPTIONS

execSync( )  and many of the other chi l d_pr oces s  functions have a second or third optional argument that specifies additional details about how the child process is to run. The encodi ng property of this object was used earlier to specify that we’d like the command output to be delivered as a string rather than as a buffer. Other important properties that you can specify include the following (note that not all options are available to all child process functions):

cwd specifies the working directory for the child process. If you omit this, then the child process inherits the value of pr oces s . cwd( ) .

env specifies the environment variables that the child process will have access to. By default, child processes simply inherit pr oces s . env, but you can specify a different object if you want.

i nput  specifies a string or buffer of input data that should be used as the standard input to the child process. This option is only available to the synchronous functions that do not return a ChildProcess object.

maxBuf f er  specifies the maximum number of bytes of output that will be collected by the exec functions. (It does not apply to s pawn( )  and f or k( ) , which use streams.) If a child process produces more output than this, it will be killed and will exit with an error.

s hel l  specifies the path to a shell executable or t r ue. For child process functions that normally execute a shell command, this option allows you to specify which shell to use. For functions that

do not normally use a shell, this option allows you to specify that a shell should be used (by setting the property to t r ue) or to specify exactly which shell to use.

t i meout  specifies the maximum number of milliseconds that the child process should be allowed to run. If it has not exited before this time elapses, it will be killed and will exit with an error. (This option applies to the exec  functions but not to s pawn( )  or f or k( ) .)

ui d specifies the user ID (a number) under which the program should be run. If the parent process is running in a privileged account, it can use this option to run the child with reduced privileges.




16.10.2 exec() and execFile()

The execSync( )  and execFi l eSync( )  functions are, as their names indicate, synchronous: they block and do not return until the child process exits. Using these functions is a lot like typing Unix commands in a terminal window: they allow you to run a sequence of commands one at a time. But if you’re writing a program that needs to accomplish a number of tasks, and those tasks don’t depend on each other in any way, then you may want to parallelize them and run multiple commands at the same time. You can do this with the asynchronous functions
chi l d_pr oces s . exec( )  and chi l d_pr oces s . execFi l e( ) .


exec( )  and execFi l e( )  are like their synchronous variants except that they return immediately with a ChildProcess object that represents the running child process, and they take an error-first callback as their final argument. The callback is invoked when the child process exits, and it is actually called with three arguments. The first is the error, if any; it will be nul l  if the process terminated normally. The second argument is the collected output that was sent to the child’s standard output stream. And the third argument is any output that was sent to the child’s standard error stream.

The ChildProcess object returned by exec( )  and execFi l e( )  allows

you to terminate the child process, and to write data to it (which it can then read from its standard input). We’ll cover ChildProcess in more detail when we discuss the chi l d_pr oces s . s pawn( )  function.


If you plan to execute multiple child processes at the same time, then it may be easiest to use the “promisified” version of exec( )  which returns a Promise object which, if the child process exits without error, resolves to an object with s t dout  and s t der r  properties. Here, for example, is a function that takes an array of shell commands as its input and returns a Promise that resolves to the result of all of those commands:

c ons t   c hi l d_pr oc es s   =   r equi r e( " c hi l d_pr oc es s " ) ; c ons t   ut i l	=   r equi r e( " ut i l " ) ;
c ons t   exec P   =   ut i l . pr omi s i f y( c hi l d_pr oc es s . exec ) ;

f unc t i on   par al l el Exec ( c ommands )    {
/ /   Us e   t he   ar r ay   of    c ommands   t o   c r eat e   an   ar r ay   of    Pr omi s es l et   pr omi s es   =   c ommands . map( c ommand   =>   exec P( c ommand,
{ enc odi ng:	" ut f 8" } ) ) ;
/ /   Ret ur n   a   Pr omi s e   t hat   wi l l	f ul f i l l	t o   an   ar r ay   of    t he f ul f i l l ment
/ /   val ues   of    eac h   of    t he   i ndi vi dual	pr omi s es .	( I ns t ead   of r et ur ni ng   obj ec t s
/ /   wi t h   s t dout   and   s t der r   pr oper t i es   we   j us t   r et ur n   t he s t dout   val ue. )
r et ur n   Pr omi s e. al l ( pr omi s es )
. t hen( out put s   =>   out put s . map( out   =>   out . s t dout ) ) ; }

modul e. expor t s   =   par al l el Exec ;


16.10.3 spawn()

The various exec functions described so far—both synchronous and asynchronous—are designed to be used with child processes that run quickly and do not produce a lot of output. Even the asynchronous exec( )  and execFi l e( )  are nonstreaming: they return the process

output in a single batch, only after the process has exited.


The chi l d_pr oces s . s pawn( )  function allows you streaming access to the output of the child process, while the process is still running. It also allows you to write data to the child process (which will see that data as input on its standard input stream): this means it is possible to dynamically interact with a child process, sending it input based on the output it generates.

s pawn( )  does not use a shell by default, so you must invoke it like execFi l e( )  with the executable to be run and a separate array of command-line arguments to pass to it. s pawn( )  returns a ChildProcess object like execFi l e( )  does, but it does not take a callback argument. Instead of using a callback function, you listen to events on the ChildProcess object and on its streams.

The ChildProcess object returned by s pawn( )  is an event emitter. You can listen for the “exit” event to be notified when the child process exits. A ChildProcess object also has three stream properties. s t dout  and
s t der r  are Readable streams: when the child process writes to its stdout and its stderr streams, that output becomes readable through the ChildProcess streams. Note the inversion of the names here. In the child process, “stdout” is a Writable output stream, but in the parent process, the s t dout  property of a ChildProcess object is a Readable input stream.


Similarly, the s t di n property of the ChildProcess object is a Writeable stream: anything you write to this stream becomes available to the child process on its standard input.

The ChildProcess object also defines a pi d property that specifies the

process id of the child. And it defines a ki l l ( )  method that you can use to terminate a child process.


16.10.4 fork()

chi l d_pr oces s . f or k( )  is a specialized function for running a module of JavaScript code in a child Node process. f or k( )  expects the same arguments as s pawn( ) , but the first argument should specify the path to a file of JavaScript code instead of an executable binary file.

A child process created with f or k( )  can communicate with the parent process via its standard input and standard output streams, as described in the previous section for s pawn( ) . But in addition, f or k( )  enables another, much easier, communication channel between the parent and child processes.

When you create a child process with f or k( ) , you can use the s end( ) method of the returned ChildProcess object to send a copy of an object to the child process. And you can listen for the “message” event on the ChildProcess to receive messages from the child. The code running in the child process can use pr oces s . s end( )  to send a message to the parent and can listen for “message” events on pr oces s  to receive messages from the parent.

Here, for example, is some code that uses f or k( )  to create a child process, then sends that child a message and waits for a response:

c ons t   c hi l d_pr oc es s   =   r equi r e( " c hi l d_pr oc es s " ) ;

/ /   St ar t   a   new  node   pr oc es s   r unni ng   t he   c ode   i n   c hi l d. j s   i n   our di r ec t or y
l et   c hi l d   =   c hi l d_pr oc es s . f or k( ` ${ __di r name} / c hi l d. j s ` ) ;

/ /   Send   a   mes s age   t o   t he   c hi l d c hi l d. s end( { x:	4,	y:	3} ) ;

/ /   Pr i nt   t he   c hi l d' s   r es pons e   when   i t   ar r i ves . c hi l d. on( " mes s age" ,	mes s age   =>   {
c ons ol e. l og( mes s age. hypot enus e) ;	/ /   Thi s   s houl d   pr i nt   " 5"
/ /   Si nc e   we   onl y   s end   one   mes s age   we   onl y   expec t   one r es pons e.
/ /   Af t er   we   r ec ei ve   i t   we   c al l	di s c onnec t ( )    t o   t er mi nat e   t he c onnec t i on
/ /   bet ween   par ent   and   c hi l d.	Thi s   al l ows   bot h   pr oc es s es   t o exi t   c l eanl y.
c hi l d. di s c onnec t ( ) ;
} ) ;


And here is the code that runs in the child process:


/ /   Wai t   f or   mes s ages   f r om our   par ent   pr oc es s pr oc es s . on( " mes s age" ,	mes s age   =>   {

/ /   When   we / /   bac k   t o

r ec ei ve   one,	do   a   c al c ul at i on   and   s end   t he   r es ul t t he   par ent .

pr oc es s . s end( { hypot enus e:	Mat h. hypot ( mes s age. x, mes s age. y) } ) ;
} ) ;


Starting child processes is an expensive operation, and the child process would have to be doing orders of magnitude more computation before it would make sense to use f or k( )  and interprocess communication in this way. If you are writing a program that needs to be very responsive to incoming events and also needs to perform time-consuming computations, then you might consider using a separate child process to perform the computations so that they don’t block the event loop and reduce the responsiveness of the parent process. (Though a thread—see §16.11—may be a better choice than a child process in this scenario.)

The first argument to s end( )  will be serialized with
J SON. s t r i ngi f y( )  and deserialized in the child process with

J SON. par s e( ) , so you should only include values that are supported by the JSON format. s end( )  has a special second argument, however, that allows you to transfer Socket and Server objects (from the “net” module) to a child process. Network servers tend to be IO-bound rather than compute-bound, but if you have written a server that needs to do more computation than a single CPU can handle, and if you’re running that server on a machine with multiple CPUs, then you could use f or k( )  to create multiple child processes for handling requests. In the parent process, you might listen for “connection” events on your Server object, then get the Socket object from that “connection” event and s end( )  it— using the special second argument—to one of the child processes to be handled. (Note that this is an unlikely solution to an uncommon scenario. Rather than writing a server that forks child processes, it is probably simpler to keep your server single-threaded and deploy multiple instances of it in production to handle the load.)


16.11 Worker Threads

As explained at the beginning of this chapter, Node’s concurrency model is single-threaded and event-based. But in version 10 and later, Node does allow true multithreaded programming, with an API that closely mirrors the Web Workers API defined by web browsers (§15.13). Multithreaded programming has a well-deserved reputation for being difficult. This is almost entirely because of the need to carefully synchronize access by threads to shared memory. But JavaScript threads (in both Node and browsers) do not share memory by default, so the dangers and difficulties of using threads do not apply to these “workers” in JavaScript.


Instead of using shared memory, JavaScript’s worker threads communicate by message passing. The main thread can send a message to a worker

thread by calling the pos t Mes s age( )  method of the Worker object that represents that thread. The worker thread can receive messages from its parent by listening for “message” events. And workers can send messages to the main thread with their own version of pos t Mes s age( ) , which the parent can receive with its own “message” event handler. The example code will make it clear how this works.

There are three reasons why you might want to use worker threads in a Node application:

If your application actually needs to do more computation than one CPU core can handle, then threads allow you to distribute work across the multiple cores, which have become commonplace on computers today. If you’re doing scientific computing or machine learning or graphics processing in Node, then you may want to use threads simply to throw more computing power at your problem.

Even if your application is not using the full power of one CPU, you may still want to use threads to maintain the responsiveness of the main thread. Consider a server that handles large but relatively infrequent requests. Suppose it gets only one request a second, but needs to spend about half a second of (blocking CPU-bound) computation to process each request. On average, it will be idle 50% of the time. But when two requests arrive within a few milliseconds of each other, the server will not even be able to begin a response to the second request until the computation of the first response is complete. Instead, if the server uses a worker thread to perform the computation, the server can begin the response to both requests immediately and provide a better experience for the server’s clients. Assuming the server has more than one CPU core, it can also compute the body of both responses in parallel, but even if there is only a single core, using workers still improves the responsiveness.

In general, workers allow us to turn blocking synchronous operations into nonblocking asynchronous operations. If you are writing a program that depends on legacy code that is unavoidably synchronous, you may be able to use workers to avoid blocking when you need to call that legacy code.

Worker threads are not nearly as heavyweight as child processes, but they are not lightweight. It does not generally make sense to create a worker unless you have significant work for it to do. And, generally speaking, if your program is not CPU-bound and is not having responsiveness problems, then you probably do not need worker threads.


16.11.1 Creating Workers and Passing Messages

The Node module that defines workers is known as “worker_threads.” In this section we’ll refer to it with the identifier t hr eads :


c ons t   t hr eads   =   r equi r e( " wor ker _t hr eads " ) ;


This module defines a Worker class to represent a worker thread, and you can create a new thread with the t hr eads . Wor ker ( )  constructor. The following code demonstrates using this constructor to create a worker, and shows how to pass messages from main thread to worker and from worker to main thread. It also demonstrates a trick that allows you to put the main thread code and the worker thread code in the same file.2

c ons t   t hr eads   =   r equi r e( " wor ker _t hr eads " ) ;

/ /   The   wor ker _t hr eads   modul e   expor t s   t he   bool ean   i s Mai nThr ead pr oper t y.
/ /   Thi s   pr oper t y   i s   t r ue   when   Node   i s   r unni ng   t he   mai n   t hr ead and   i t   i s
/ /   f al s e   when   Node   i s   r unni ng   a   wor ker .	We   c an   us e   t hi s   f ac t   t o i mpl ement
/ /   t he   mai n   and   wor ker   t hr eads   i n   t he   s ame   f i l e. i f    ( t hr eads . i s Mai nThr ead)    {

/ /   I f    we' r e   r unni ng   i n   t he   mai n   t hr ead,	t hen   al l	we   do   i s expor t
/ /   a   f unc t i on.	I ns t ead   of    per f or mi ng   a   c omput at i onal l y i nt ens i ve
/ /   t as k   on   t he   mai n   t hr ead,	t hi s   f unc t i on   pas s es   t he   t as k   t o a   wor ker
/ /   and   r et ur ns   a   Pr omi s e   t hat   wi l l	r es ol ve   when   t he   wor ker i s   done.
modul e. expor t s   =   f unc t i on   r et i c ul at eSpl i nes ( s pl i nes )    {
r et ur n   new  Pr omi s e( ( r es ol ve, r ej ec t )    =>   {

/ / f i l e   of    c ode.
/ /

Cr eat e   a   wor ker

Not e   t he   us e   of

t hat   l oads   and   r uns   t hi s   s ame

t he   s pec i al	__f i l ename   var i abl e.

l et   r et i c ul at or   =   new  t hr eads . Wor ker ( __f i l ename) ;

/ /   Pas s   a   c opy   of    t he   s pl i nes   ar r ay   t o   t he   wor ker r et i c ul at or . pos t Mes s age( s pl i nes ) ;

/ /   And   t hen   r es ol ve   or   r ej ec t   t he   Pr omi s e   when   we get
/ /   a   mes s age   or   er r or   f r om t he   wor ker . r et i c ul at or . on( " mes s age" ,	r es ol ve) ;
r et i c ul at or . on( " er r or " ,	r ej ec t ) ; } ) ;
} ;
}    el s e   {
/ /   I f    we   get   her e,	i t   means   we' r e   i n   t he   wor ker ,	s o   we r egi s t er   a
/ /   handl er   t o   get   mes s ages   f r om t he   mai n   t hr ead.	Thi s   wor ker i s   des i gned
/ /   t o   onl y   r ec ei ve   a   s i ngl e   mes s age,	s o   we   r egi s t er   t he event   handl er
/ /   wi t h   onc e( )    i ns t ead   of    on( ) .	Thi s   al l ows   t he   wor ker   t o exi t   nat ur al l y
/ /   when   i t s   wor k   i s   c ompl et e.
t hr eads . par ent Por t . onc e( " mes s age" ,	s pl i nes   =>   {

/ /   When   we / /   t hr ough

get   t he   s pl i nes   f r om t he   par ent   t hr ead,	l oop t hem and   r et i c ul at e   al l	of    t hem.

f or ( l et   s pl i ne   of    s pl i nes )    {
/ /   For   t he   s ake   of    exampl e,	as s ume   t hat   s pl i ne obj ec t s   us ual l y
/ /   have   a   r et i c ul at e( )    met hod   t hat   does   a   l ot   of c omput at i on.
s pl i ne. r et i c ul at e   ?   s pl i ne. r et i c ul at e( )    :
s pl i ne. r et i c ul at ed   =   t r ue; }


/ /   When   al l	t he   s pl i nes   have   ( f i nal l y! )    been   r et i c ul at ed / /   pas s   a   c opy   bac k   t o   t he   mai n   t hr ead.
t hr eads . par ent Por t . pos t Mes s age( s pl i nes ) ;
} ) ; }


The first argument to the Wor ker ( )  constructor is the path to a file of JavaScript code that is to run in the thread. In the preceding code, we used the predefined __f i l ename identifier to create a worker that loads and runs the same file as the main thread. In general, though, you will be passing a file path. Note that if you specify a relative path, it is relative to pr oces s . cwd( ) , not relative to the currently running module. If you want a path relative to the current module, use something like
pat h. r es ol ve( __di r name,	' wor ker s / r et i cul at or . j s ' ) .


The Wor ker ( )  constructor can also accept an object as its second argument, and the properties of this object provide optional configuration for the worker. We’ll cover a number of these options later, but for now note that if you pass { eval :	t r ue}  as the second argument, then the first argument to Wor ker ( )  is interpreted as a string of JavaScript code to be evaluated instead of a filename:

new  t hr eads . Wor ker ( `
c ons t   t hr eads   =   r equi r e( " wor ker _t hr eads " ) ;
t hr eads . par ent Por t . pos t Mes s age( t hr eads . i s Mai nThr ead) ;
` ,	{ eval :	t r ue} ) . on( " mes s age" ,	c ons ol e. l og) ;	/ /   Thi s   wi l l	pr i nt " f al s e"


Node makes a copy of the object passed to pos t Mes s age( )  rather than sharing it directly with the worker thread. This prevents the worker thread and the main thread from sharing memory. You might expect that this copying would be done with J SON. s t r i ngi f y( )  and
J SON. par s e( )  (§11.6). But in fact, Node borrows a more robust

technique known as the structured clone algorithm from web browsers.


The structured clone algorithm enables serialization of most JavaScript types, including Map, Set, Date, and RegExp objects and typed arrays, but it cannot, in general, copy types defined by the Node host environment, such as sockets and streams. Note, however, that Buffer objects are partially supported: if you pass a Buffer to pos t Mes s age( )  it will be received as a Uint8Array, and can be converted back into a Buffer with Buf f er . f r om( ) . Read more about the structured clone algorithm in “The Structured Clone Algorithm”.


16.11.2 The Worker Execution Environment

For the most part, JavaScript code in a Node worker thread runs just like it would in Node’s main thread. There are a few differences that you should be aware of, and some of these differences involve properties of the optional second argument to the Wor ker ( )  constructor:

As we’ve seen, t hr eads . i s Mai nThr ead is t r ue in the main thread but is always f al s e in any worker thread.

In a worker thread, you can use
t hr eads . par ent Por t . pos t Mes s age( )  to send a message to the parent thread and t hr eads . par ent Por t . on to register event handlers for messages from the parent thread. In the main thread, t hr eads . par ent Por t  is always nul l .

In a worker thread, t hr eads . wor ker Dat a is set to a copy of the wor ker Dat a property of the second argument to the
Wor ker ( )  constructor. In the main thread, this property is always nul l . You can use this wor ker Dat a property to pass an initial message to the worker that will be available as soon as it starts so that the worker does not have to wait for a “message” event before it can start doing work.


By default, pr oces s . env in a worker thread is a copy of
pr oces s . env in the parent thread. But the parent thread can specify a custom set of environment variables by setting the env property of the second argument to the Wor ker ( )  constructor. As a special (and potentially dangerous) case, the parent thread can set the env property to t hr eads . SHARE_ENV, which will cause the two threads to share a single set of environment variables so that a change in one thread is visible in the other.

By default, the pr oces s . s t di n stream in a worker never has any readable data on it. You can change this default by passing
s t di n:	t r ue in the second argument to the Wor ker ( ) constructor. If you do that, then the s t di n property of the Worker object is a Writable stream. Any data that the parent writes to wor ker . s t di n becomes readable on
pr oces s . s t di n in the worker.

By default, the pr oces s . s t dout  and pr oces s . s t der r streams in the worker are simply piped to the corresponding streams in the parent thread. This means, for example, that
cons ol e. l og( )  and cons ol e. er r or ( )  produce output in exactly the same way in a worker thread as they do in the main thread. You can override this default by passing s t dout : t r ue or s t der r : t r ue in the second argument to the Wor ker ( ) constructor. If you do this, then any output the worker writes to those streams becomes readable by the parent thread on the
wor ker . s t dout  and wor ker . s t der r  threads. (There is a potentially confusing inversion of stream directions here, and we saw the same thing with with child processes earlier in the chapter: the output streams of a worker thread are input streams for the parent thread, and the input stream of a worker is an output stream for the parent.)

If a worker thread calls pr oces s . exi t ( ) , only the thread exits, not the entire process.

Worker threads are not allowed to change shared state of the process they are part of. Functions like pr oces s . chdi r ( )  and pr oces s . s et ui d( )  will throw exceptions when invoked from a worker.

Operating system signals (like SI GI NT and SI GTERM) are only delivered to the main thread; they cannot be received or handled in worker threads.


16.11.3 Communication Channels and MessagePorts

When a new worker thread is created, a communication channel is created along with it that allows messages to be passed back and forth between the worker and the parent thread. As we’ve seen, the worker thread uses
t hr eads . par ent Por t  to send and receive messages to and from the parent thread, and the parent thread uses the Worker object to send and receive messages to and from the worker thread.

The worker thread API also allows the creation of custom communication channels using the MessageChannel API defined by web browsers and covered in §15.13.5. If you have read that section, much of what follows will sound familiar to you.


Suppose a worker needs to handle two different kinds of messages sent by two different modules in the main thread. These two different modules could both share the default channel and send messages with
wor ker . pos t Mes s age( ) , but it would be cleaner if each module has its own private channel for sending messages to the worker. Or consider the case where the main thread creates two independent workers. A custom communication channel can allow the two workers to communicate directly with each other instead of having to send all their messages via the parent.

Create a new message channel with the Mes s ageChannel ( ) constructor. A MessageChannel object has two properties, named por t 1 and por t 2. These properties refer to a pair of MessagePort objects. Calling pos t Mes s age( )  on one of the ports will cause a “message” event to be generated on the other with a structured clone of the Message object:

c ons t   t hr eads   =   r equi r e( " wor ker _t hr eads " ) ;
l et   c hannel	=   new  t hr eads . Mes s ageChannel ( ) ;
c hannel . por t 2. on( " mes s age" ,	c ons ol e. l og) ;	/ /   L og   any   mes s ages we   r ec ei ve
c hannel . por t 1. pos t Mes s age( " hel l o" ) ;	/ /   Wi l l	c aus e   " hel l o" t o   be   pr i nt ed


You can also call cl os e( )  on either port to break the connection between the two ports and to signal that no more messages will be exchanged. When cl os e( )  is called on either port, a “close” event is delivered to both ports.

Note that the code example above creates a pair of MessagePort objects and then uses those objects to transmit a message within the main thread. In order to use custom communication channels with workers, we must transfer one of the two ports from the thread in which it is created to the thread in which it will be used. The next section explains how to do this.


16.11.4 Transferring MessagePorts and Typed Arrays

The pos t Mes s age( )  function uses the structured clone algorithm, and as we’ve noted, it cannot copy objects like SSockets and Streams. It can handle MessagePort objects, but only as a special case using a special technique. The pos t Mes s age( )  method (of a Worker object, of
t hr eads . par ent Por t , or of any MessagePort object) takes an

optional second argument. This argument (called t r ans f er Li s t ) is an array of objects that are to be transferred between threads rather than being copied.

A MessagePort object cannot be copied by the structured clone algorithm, but it can be transferred. If the first argument to pos t Mes s age( )  has included one or more MessagePorts (nested arbitrarily deeply within the Message object), then those MessagePort objects must also appear as members of the array passed as the second argument. Doing this tells Node that it does not need to make a copy of the MessagePort, and can instead just give the existing object to the other thread. The key thing to understand, however, about transferring values between threads is that once a value is transferred, it can no longer be used in the thread that called pos t Mes s age( ) .


Here is how you might create a new MessageChannel and transfer one of its MessagePorts to a worker:

/ /   Cr eat e   a   c us t om c ommuni c at i on   c hannel
c ons t   t hr eads   =   r equi r e( " wor ker _t hr eads " ) ;
l et   c hannel	=   new  t hr eads . Mes s ageChannel ( ) ;

/ /   Us e   t he   wor ker ' s   def aul t   c hannel	t o   t r ans f er   one   end   of    t he new
/ /   c hannel	t o   t he   wor ker .	As s ume   t hat   when   t he   wor ker   r ec ei ves t hi s
/ /   mes s age   i t   i mmedi at el y   begi ns   t o   l i s t en   f or   mes s ages   on   t he new  c hannel .
wor ker . pos t Mes s age( {    c ommand:	" c hangeChannel " ,	dat a:
c hannel . por t 1   } ,
[    c hannel . por t 1   ] ) ;

/ /   Now  s end   a   mes s age   t o   t he   wor ker   us i ng   our   end   of    t he   c us t om c hannel
c hannel . por t 2. pos t Mes s age( " Can   you   hear   me   now?" ) ;

/ /   And   l i s t en   f or   r es pons es   f r om t he   wor ker   as   wel l

c hannel . por t 2. on( " mes s age" ,	handl eMes s ages Fr omWor ker ) ;


MessagePort objects are not the only ones that can be transferred. If you call pos t Mes s age( )  with a typed array as the message (or with a message that contains one or more typed arrays nested arbitrarily deep within the message), that typed array (or those typed arrays) will simply be copied by the structured clone algorithm. But typed arrays can be large; for example, if you are using a worker thread to do image processing on millions of pixels. So for efficiency, pos t Mes s age( )  also gives us the option to transfer typed arrays rather than copying them. (Threads share memory by default. Worker threads in JavaScript generally avoid shared memory, but when we allow this kind of controlled transfer, it can be done very efficiently.) What makes this safe is that when a typed array is transferred to another thread, it becomes unusable in the thread that transferred it. In the image-processing scenario, the main thread could transfer the pixels of an image to the worker thread, and then the worker thread could transfer the processed pixels back to the main thread when it was done. The memory would not need to be copied, but it would never be accessible by two threads at once.

To transfer a typed array instead of copying it, include the ArrayBuffer that backs the array in the second argument to pos t Mes s age( ) :


l et   pi xel s   =   new  Ui nt 32Ar r ay( 1024*1024) ;	/ /   4   megabyt es   of memor y


/ /   As s ume   we t r ans f er   t he / /   pi xel s   t o t he   ar r ay
/ /   i t s el f    i n i ns t ead.

r ead   s ome   dat a   i nt o   t hi s   t yped   ar r ay,	and   t hen

a   wor ker   wi t hout   c opyi ng.	Not e   t hat   we   don' t   put

t he   t r ans f er   l i s t ,	but   t he   ar r ay' s   Buf f er   obj ec t

wor ker . pos t Mes s age( pi xel s ,	[    pi xel s . buf f er   ] ) ;

As with transferred MessagePorts, a transferred typed array becomes unusable once transferred. No exceptions are thrown if you attempt to use a MessagePort or typed array that has been transferred; these objects simply stop doing anything when you interact with them.


16.11.5 Sharing Typed Arrays Between Threads

In addition to transferring typed arrays between threads, it is actually possible to share a typed array between threads. Simply create a SharedArrayBuffer of the desired size and then use that buffer to create a typed array. When a typed array that is backed by a SharedArrayBuffer is passed via pos t Mes s age( ) , the underlying memory will be shared between the threads. You should not include the shared buffer in the second argument to pos t Mes s age( )  in this case.


You really should not do this, however, because JavaScript was never designed with thread safety in mind and multithreaded programming is very difficult to get right. (And this is why SharedArrayBuffer was not covered in §11.2: it is a niche feature that is difficult to get right.) Even the simple ++ operator is not thread-safe because it needs to read a value, increment it, and write it back. If two threads are incrementing a value at the same time, it will often only be incremented once, as the following code demonstrates:

c ons t   t hr eads   =   r equi r e( " wor ker _t hr eads " ) ;

i f    ( t hr eads . i s Mai nThr ead)    {

/ /   I n   t he   mai n   t hr ead,	we   c r eat e   a   s har ed / /   one   el ement .	Bot h   t hr eads   wi l l	be   abl e / /   s har edAr r ay[ 0]    at   t he   s ame   t i me.

t yped   ar r ay   wi t h
t o   r ead   and   wr i t e

l et   s har edBuf f er   =   new  Shar edAr r ayBuf f er ( 4) ;
l et   s har edAr r ay   =   new  I nt 32Ar r ay( s har edBuf f er ) ;

/ /   Now  c r eat e   a   wor ker   t hr ead,	pas s i ng   t he   s har ed   ar r ay   t o

i t   wi t h
/ /   as   i t s   i ni t i al	wor ker Dat a   val ue   s o   we   don' t   have   t o bot her   wi t h
/ /   s endi ng   and   r ec ei vi ng   a   mes s age
l et   wor ker   =   new  t hr eads . Wor ker ( __f i l ename,	{    wor ker Dat a:
s har edAr r ay   } ) ;

/ /   Wai t   f or   t he   wor ker   t o   s t ar t   r unni ng   and   t hen   i nc r ement t he
/ /   s har ed   i nt eger   10   mi l l i on   t i mes . wor ker . on( " onl i ne" ,	( )    =>   {
f or ( l et   i	=   0;	i	<   10_000_000;	i ++)    s har edAr r ay[ 0] ++;


/ /   Onc e   we' r e   done   wi t h l i s t eni ng   f or
/ /   mes s age   event s   s o   we

our   i nc r ement s ,	we   s t ar t

know  when   t he   wor ker   i s   done.

wor ker . on( " mes s age" ,	( )    =>   {



muc h   l es s .

12   mi l l i on.

/ /   Al t hough   t he   s har ed   i nt eger   has   been   i nc r ement ed / /   20   mi l l i on   t i mes ,	i t s   val ue   wi l l	gener al l y   be

/ /   On   my   c omput er   t he   f i nal	val ue   i s   t ypi c al l y   under

c ons ol e. l og( s har edAr r ay[ 0] ) ; } ) ;
} ) ;
}    el s e   {

/ /   I n   t he   wor ker   t hr ead, wor ker Dat a
/ /   and   t hen   i nc r ement   i t

we   get   t he   s har ed   ar r ay   f r om

10   mi l l i on   t i mes .

l et   s har edAr r ay   =   t hr eads . wor ker Dat a;
f or ( l et   i	=   0;	i	<   10_000_000;	i ++)    s har edAr r ay[ 0] ++;
/ /   When   we' r e   done   i nc r ement i ng,	l et   t he   mai n   t hr ead   know t hr eads . par ent Por t . pos t Mes s age( " done" ) ;
}


One scenario in which it might be reasonable to use a SharedArrayBuffer is when the two threads operate on entirely separate sections of the shared memory. You might enforce this by creating two typed arrays that serve as views of nonoverlapping regions of the shared buffer, and then have your two threads use those two separate typed arrays. A parallel merge sort could be done like this: one thread sorts the bottom half of an array and the other thread sorts the top half, for example. Or some kinds of image-

processing algorithms are also suitable for this approach: multiple threads working on disjoint regions of the image.


If you really must allow multiple threads to access the same region of a shared array, you can take one step toward thread safety with the functions defined by the Atomics object. Atomics was added to JavaScript when SharedArrayBuffer was to define atomic operations on the elements of a shared array. For example, the At omi cs . add( )  function reads the specified element of a shared array, adds a specified value to it, and writes the sum back into the array. It does this atomically as if it was a single operation, and ensures that no other thread can read or write the value while the operation is taking place. At omi cs . add( )  allows us to rewrite the parallel increment code we just looked at and get the correct result of 20 million increments of a shared array element:

c ons t   t hr eads   =   r equi r e( " wor ker _t hr eads " ) ;

i f    ( t hr eads . i s Mai nThr ead)    {
l et   s har edBuf f er   =   new  Shar edAr r ayBuf f er ( 4) ;
l et   s har edAr r ay   =   new  I nt 32Ar r ay( s har edBuf f er ) ;
l et   wor ker   =   new  t hr eads . Wor ker ( __f i l ename,	{    wor ker Dat a: s har edAr r ay   } ) ;

wor ker . on( " onl i ne" ,	( )    =>   {
f or ( l et   i	=   0;	i	<   10_000_000;	i ++)    {
At omi c s . add( s har edAr r ay,	0,	1) ;	/ /   Thr eads af e at omi c   i nc r ement
}

wor ker . on( " mes s age" ,	( mes s age)    =>   {


f unc t i on

t he

/ /   When   bot h   t hr eads   ar e   done,	us e   a   t hr eads af e

/ /   t o   r ead   t he   s har ed   ar r ay   and   c onf i r m t hat   i t   has

/ /   expec t ed   val ue   of    20, 000, 000.

c ons ol e. l og( At omi c s . l oad( s har edAr r ay,	0) ) ; } ) ;

} ) ;
}    el s e   {
l et   s har edAr r ay   =   t hr eads . wor ker Dat a; f or ( l et   i    =   0;    i    <   10_000_000;    i ++)    {
At omi c s . add( s har edAr r ay,	0,	1) ;	/ /   Thr eads af e at omi c   i nc r ement
}
t hr eads . par ent Por t . pos t Mes s age( " done" ) ; }


This new version of the code correctly prints the number 20,000,000. But it is about nine times slower than the incorrect code it replaces. It would be much simpler and much faster to just do all 20 million increments in one thread. Also note that atomic operations may be able to ensure thread safety for image-processing algorithms for which each array element is a value entirely independent of all other values. But in most real-world programs, multiple array elements are often related to one another and some kind of higher-level thread synchronization is required. The low-level At omi cs . wai t ( )  and At omi cs . not i f y( )  function can help with this, but a discussion of their use is out of scope for this book.


16.12 Summary

Although JavaScript was created to run in web browsers, Node has made JavaScript into a general-purpose programming language. It is particularly popular for implementing web servers, but its deep bindings to the operating system mean that it is also a good alternative to shell scripts.


The most important topics covered in this long chapter include:


Node’s asynchronous-by-default APIs and its single-threaded, callback, and event-based style of concurrency.

Node’s fundamental datatypes, buffers, and streams.

Node’s “fs” and “path” modules for working with the filesystem.

Node’s “http” and “https” modules for writing HTTP clients and servers.

Node’s “net” module for writing non-HTTP clients and servers.

Node’s “child_process” module for creating and communicating with child processes.

Node’s “worker_threads” module for true multithreaded programming using message-passing instead of shared memory.





1

2

Node defines a f s . c opyFi l e( )  function that you would actually use in practice.

It is often cleaner and simpler to define the worker code in a separate file. But this trick of having two threads run different sections of the same file blew my mind when I first encountered it for the Unix f or k( )  system call. And I think it is worth demonstrating this technique simply for its strange elegance.



Chapter 17. J avaScript Tools and Extensions




Congratulations on reaching the final chapter of this book. If you have read everything that comes before, you now have a detailed understanding of the JavaScript language and know how to use it in Node and in web browsers. This chapter is a kind of graduation present: it introduces a handful of important programming tools that many JavaScript programmers find useful, and also describes two widely used extensions to the core JavaScript language. Whether or not you choose to use these tools and extensions for your own projects, you are almost certain to see them used in other projects, so it is important to at least know what they are.


The tools and language extensions covered in this chapter are:


ESLint for finding potential bugs and style problems in your code.

Prettier for formatting your JavaScript code in a standardized way.

Jest as an all-in-one solution for writing JavaScript unit tests.

npm for managing and installing the software libraries that your program depends on.

Code-bundling tools—like webpack, Rollup, and Parcel—that convert your modules of JavaScript code into a single bundle for use on the web.

Babel for translating JavaScript code that uses brand-new language features (or that uses language extensions) into

JavaScript code that can run in current web browsers.

The JSX language extension (used by the React framework) that allows you to describe user interfaces using JavaScript expressions that look like HTML markup.

The Flow language extension (or the similar TypeScript extension) that allows you to annotate your JavaScript code with types and check your code for type safety.

This chapter does not document these tools and extensions in any comprehensive way. The goal is simply to explain them in enough depth that you can understand why they are useful and when you might want to use them. Everything covered in this chapter is widely used in the JavaScript programming world, and if you do decide to adopt a tool or extension, you’ll find lots of documentation and tutorials online.


17.1 Linting with ESLint

In programming, the term lint refers to code that, while technically correct, is unsightly, or a possible bug, or suboptimal in some way. A linter is a tool for detecting lint in your code, and linting is the process of running a linter on your code (and then fixing your code to remove the lint so that the linter no longer complains).


The most commonly used linter for JavaScript today is ESLint. If you run it and then take the time to actually fix the issues it points out, it will make your code cleaner and less likely to have bugs. Consider the following code:

var   x   =   ' unus ed' ;

expor t   f unc t i on   f ac t or i al ( x)    { i f    ( x   ==   1)    {

r et ur n   1; }    el s e   {
r et ur n   x   *   f ac t or i al ( x- 1) }
}


If you run ESLint on this code, you might get output like this:


$   es l i nt   c ode/ c h17/ l i nt y. j s

c ode/ c h17/ l i nt y. j s
1: 1	er r or	Unexpec t ed   var ,	us e   l et   or   c ons t   i ns t ead no- var
1: 5	er r or	' x'	i s   as s i gned   a   val ue   but   never   us ed no- unus ed- var s
1: 9	war ni ng	St r i ngs   mus t   us e   doubl equot e quot es
4: 11	er r or	Expec t ed   ' ==='	and   i ns t ead   s aw  ' ==' eqeqeq
5: 1	er r or	Expec t ed   i ndent at i on   of    8   s pac es   but   f ound   6 i ndent
7: 28	er r or	Mi s s i ng   s emi c ol on s emi

✖  6   pr obl ems   ( 5   er r or s ,	1   war ni ng)
3   er r or s   and   1   war ni ng   pot ent i al l y   f i xabl e   wi t h   t he   ` - - f i x` opt i on.


Linters can seem nitpicky sometimes. Does it really matter whether we used double quotes or single quotes for our strings? On the other hand, getting indentation right is important for readability, and using === and l et  instead of == and var  protects you from subtle bugs. And unused variables are dead weight in your code—there is no reason to keep those around.

ESLint defines many linting rules and has an ecosystem of plug-ins that add many more. But ESLint is fully configurable, and you can define a configuration file that tunes ESLint to enforce exactly the rules you want and only those rules.

17.2 J avaScript Formatting with Prettier

One of the reasons that some projects use linters is to enforce a consistent coding style so that when a team of programmers is working on a shared codebase, they use compatible code conventions. This includes code indentation rules, but can also include things like what kind of quotation marks are preferred and whether there should be a space between the f or keyword and the open parenthesis that follows it.

A modern alternative to enforcing code formatting rules via a linter is to adopt a tool like Prettier to automatically parse and reformat all of your code.


Suppose you have written the following function, which works, but is formatted unconventionally:


f unc t i on
{

f ac t or i al ( x)


i f ( x===1) { r et ur n   1}

el s e{ r et ur n   x*f ac t or i al ( x- 1) } }


Running Prettier on this code fixes the indentation, adds missing semicolons, adds spaces around binary operators and inserts line breaks after {  and before } , resulting in much more conventional-looking code:

$   pr et t i er   f ac t or i al . j s f unc t i on   f ac t or i al ( x)    {
i f    ( x   ===   1)    { r et ur n   1;
}    el s e   {
r et ur n   x   *   f ac t or i al ( x   -    1) ; }
}

If you invoke Prettier with the - - wr i t e option, it will simply reformat the specified file in place rather than printing a reformatted version. If you use gi t  to manage your source code, you can invoke Prettier with the - -wr i t e option in a commit hook so that code is automatically formatted before being checked in.

Prettier is particularly powerful if you configure your code editor to run it automatically every time you save a file. I find it liberating to write sloppy code and see it fixed automatically for me.


Prettier is configurable, but it only has a few options. You can select the maximum line length, the indentation amount, whether semicolons should be used, whether strings should be single- or double-quoted, and a few other things. In general, Prettier’s default options are quite reasonable. The idea is that you just adopt Prettier for your project and then never have to think about code formatting again.


Personally, I really like using Prettier on JavaScript projects. I have not used it for the code in this book, however, because in much of my code I rely on careful hand formatting to align my comments vertically, and Prettier messes them up.


17.3 Unit Testing with J est

Writing tests is an important part of any nontrivial programming project. Dynamic languages like JavaScript support testing frameworks that dramatically reduce the effort required to write tests, and almost make test writing fun! There are a lot of test tools and libraries for JavaScript, and many are written in a modular way so that it is possible to pick one library as your test runner, another library for assertions, and a third for mocking.

In this section, however, we’ll describe Jest, which is a popular framework that includes everything you need in a single package.


Suppose you’ve written the following function:


c ons t   get J SON  =   r equi r e( " . / get J SON. j s " ) ;

/ **
*   get Temper at ur e( )    t akes   t he   name   of    a   c i t y   as   i t s   i nput ,	and r et ur ns
*   a   Pr omi s e   t hat   wi l l	r es ol ve   t o   t he   c ur r ent   t emper at ur e   of t hat   c i t y,
*   i n   degr ees   Fahr enhei t .	I t   r el i es   on   a   ( f ake)    web   s er vi c e   t hat r et ur ns
*   wor l d   t emper at ur es   i n   degr ees   Cel s i us . */
modul e. expor t s   =   as ync   f unc t i on   get Temper at ur e( c i t y)    {
/ /   Get   t he   t emper at ur e   i n   Cel s i us   f r om t he   web   s er vi c e l et   c   =   awai t   get J SON(

` ht t ps : / / gl obal t emps . exampl e. c om/ api / c i t y/ ${ c i t y. t oL ower Cas e( ) } ` ) ;
/ /   Conver t   t o   Fahr enhei t   and   r et ur n   t hat   val ue.
r et ur n   ( c   *   5   /   9)    +   32;	/ /   TODO:	doubl e- c hec k   t hi s   f or mul a } ;


A good set of tests for this function might verify that
get Temper at ur e( )  is fetching the right URL, and that it is converting temperature scales correctly. We can do this with a Jest-based test like the following. This code defines a mock implementation of get J SON( )  so that the test does not actually make a network request. And because
get Temper at ur e( )  is an async function, the tests are async as well— it can be tricky to test asynchronous functions, but Jest makes it relatively easy:

/ /   I mpor t   t he   f unc t i on   we   ar e   goi ng   t o   t es t
c ons t   get Temper at ur e   =   r equi r e( " . / get Temper at ur e. j s " ) ;

/ /   And   moc k   t he   get J SON( )    modul e   t hat   get Temper at ur e( )    depends

on
j es t . moc k( " . / get J SON" ) ;
c ons t   get J SON  =   r equi r e( " . / get J SON. j s " ) ;

/ /   Tel l	t he   moc k   get J SON( )    f unc t i on   t o   r et ur n   an   al r eady r es ol ved   Pr omi s e
/ /   wi t h   f ul f i l l ment   val ue   0. get J SON. moc kRes ol vedVal ue( 0) ;

/ /   Our   s et   of    t es t s   f or   get Temper at ur e( )    begi ns   her e des c r i be( " get Temper at ur e( ) " ,	( )    =>   {
/ /   Thi s   i s   t he   f i r s t   t es t .	We' r e   ens ur i ng   t hat get Temper at ur e( )    c al l s
/ /   get J SON( )    wi t h   t he   URL   t hat   we   expec t
t es t ( " I nvokes   t he   c or r ec t   API " ,	as ync   ( )    =>   { l et   expec t edURL   =
" ht t ps : / / gl obal t emps . exampl e. c om/ api / c i t y/ vanc ouver " ;
l et   t   =   awai t ( get Temper at ur e( " Vanc ouver " ) ) ;
/ /   J es t   moc ks   r emember   how  t hey   wer e   c al l ed,	and   we   c an c hec k   t hat .
expec t ( get J SON) . t oHaveBeenCal l edWi t h( expec t edURL ) ;
} ) ;

/ /   Thi s   s ec ond   t es t   ver i f i es   t hat   get Temper at ur e( )    c onver t s / /   Cel s i us   t o   Fahr enhei t   c or r ec t l y
t es t ( " Conver t s   C   t o   F   c or r ec t l y" ,	as ync   ( )    =>   {
get J SON. moc kRes ol vedVal ue( 0) ;	/ /   I f get J SON  r et ur ns   0C
expec t ( awai t   get Temper at ur e( " x" ) ) . t oBe( 32) ;	/ /   We expec t   32F

/ /   100C   s houl d   c onver t   t o   212F
get J SON. moc kRes ol vedVal ue( 100) ;	/ /   I f get J SON  r et ur ns   100C
expec t ( awai t   get Temper at ur e( " x" ) ) . t oBe( 212) ;	/ /   We expec t   212F
} ) ; } ) ;


With the test written, we can use the j es t  command to run it, and we discover that one of our tests fails:

$   j es t   get Temper at ur e
FAI L	c h17/ get Temper at ur e. t es t . j s

get Temper at ur e( )
✓  I nvokes   t he   c or r ec t   API	( 4ms )
✕  Conver t s   C   t o   F   c or r ec t l y   ( 3ms )

●  get Temper at ur e( )    ›   Conver t s   C   t o   F   c or r ec t l y

expec t ( r ec ei ved) . t oBe( expec t ed)    / /   Obj ec t . i s   equal i t y


Expec t ed: Rec ei ved:

212
87. 55555555555556



29   | 30   |
r et ur ns   100C >   31   |
/ /   Expec t   212F |
32   |	} ) ; 33   |   } ) ;
34   |

/ /   100C   s houl d   c onver t   t o   212F
get J SON. moc kRes ol vedVal ue( 100) ;	/ /   I f    get J SON

expec t ( awai t   get Temper at ur e( " x" ) ) . t oBe( 212) ;

^


at   Obj ec t . <anonymous >   ( c h17/ get Temper at ur e. t es t . j s : 31: 43)


Tes t   Sui t es : Tes t s :
Snaps hot s : Ti me:
Ran   al l	t es t

1   f ai l ed,	1   t ot al
1   f ai l ed,	1   pas s ed,	2   t ot al 0   t ot al
1. 403s
s ui t es   mat c hi ng   / get Temper at ur e/ i .



Our get Temper at ur e( )  implementation is using the wrong formula for converting C to F. It multiplies by 5 and divides by 9 rather than multiplying by 9 and dividing by 5. If we fix the code and run Jest again, we can see the tests pass. And, as a bonus, if we add the - - cover age argument when we invoke j es t , it will compute and display the code coverage for our tests:

$   j es t   - - c over age   get Temper at ur e PASS	c h17/ get Temper at ur e. t es t . j s
get Temper at ur e( )
✓  I nvokes   t he   c or r ec t   API	( 3ms )
✓  Conver t s   C   t o   F   c or r ec t l y   ( 1ms )

- - - - - - - - - - - - - - - - - - |- - - - - - - - |- - - - - - - - - |- - - - - - - - - |- - - - - - - - - |- - - - - -- - - - - - - - - - - - |
Fi l e	|   %  St mt s |   %  Br anc h|	%  Func s |	%  L i nes |

Unc over ed   L i ne   #s |
- - - - - - - - - - - - - - - - - - |- - - - - - - - |- - - - - - - - - |- - - - - - - - - |- - - - - - - - - |- - - - - -- - - - - - - - - - - - |
Al l	f i l es	|	71. 43|	100|	33. 33|	83. 33| |
get J SON. j s	|	33. 33|	100|	0|	50| 2|
get Temper at ur e. j s |	100|	100|	100|	100| |
- - - - - - - - - - - - - - - - - - |- - - - - - - - |- - - - - - - - - |- - - - - - - - - |- - - - - - - - - |- - - - - -- - - - - - - - - - - - |
Tes t   Sui t es :	1   pas s ed,	1   t ot al Tes t s :	2   pas s ed,	2   t ot al Snaps hot s :	0   t ot al
Ti me:	1. 508s
Ran   al l	t es t   s ui t es   mat c hi ng   / get Temper at ur e/ i .


Running our test gave us 100% code coverage for the module we were testing, which is exactly what we wanted. It only gave us partial coverage of get J SON( ) , but we mocked that module and were not trying to test it, so that is expected.


17.4 Package Management with npm

In modern software development, it is common for any nontrivial program that you write to depend on third-party software libraries. If you’re writing a web server in Node, for example, you might be using the Express framework. And if you’re creating a user interface to be displayed in a web browser, you might use a frontend framework like React or LitElement or Angular. A package manager makes it easy to find and install third-party packages like these. Just as importantly, a package manager keeps track of what packages your code depends on and saves this information into a file so that when someone else wants to try your program, they can download your code and your list of dependencies, then use their own package manager to install all the third-party packages that your code needs.

npm is the package manager that is bundled with Node, and was introduced in §16.1.5. It is just as useful for client-side JavaScript programming as it is for server-side programming with Node, however.


If you are trying out someone else’s JavaScript project, then one of the first things you will often do after downloading their code is to type npm i ns t al l . This reads the dependencies listed in the package.json file and downloads the third-party packages that the project needs and saves them in a node_modules/ directory.

You can also type npm i ns t al l	<package- name> to install a particular package to your project’s node_modules/ directory:

$   npm i ns t al l	expr es s


In addition to installing the named package, npm also makes a record of the dependency in the package.json file for the project. Recording dependencies in this way is what allows others to install those dependencies simply by typing npm i ns t al l .


The other kind of dependency is on developer tools that are needed by developers who want to work on your project, but aren’t actually needed to run the code. If a project uses Prettier, for example, to ensure that all of its code is consistently formatted, then Prettier is a “dev dependency,” and you can install and record one of these with - - s ave- dev:

$   npm i ns t al l	- - s ave- dev   pr et t i er


Sometimes you might want to install developer tools globally so that they are accessible anywhere even for code that is not part of a formal project with a package.json file and a node_modules/ directory. For that you can

use the - g (for global) option:


$   npm i ns t al l	- g   es l i nt   j es t / us r / l oc al / bi n/ es l i nt   - >
/ us r / l oc al / l i b/ node_modul es / es l i nt / bi n/ es l i nt . j s / us r / l oc al / bi n/ j es t   - >
/ us r / l oc al / l i b/ node_modul es / j es t / bi n/ j es t . j s +   j es t @24. 9. 0
+   es l i nt @6. 7. 2
added   653   pac kages   f r om 414   c ont r i but or s   i n   25. 596s

$   whi c h   es l i nt
/ us r / l oc al / bi n/ es l i nt $   whi c h   j es t
/ us r / l oc al / bi n/ j es t


In addition to the “install” command, npm supports “uninstall” and “update” commands, which do what their names say. npm also has an interesting “audit” command that you can use to find and fix security vulnerabilities in your dependencies:

$   npm audi t   - - f i x

===   npm audi t   s ec ur i t y   r epor t   ===

f ound   0   vul ner abi l i t i es
i n   876354   s c anned   pac kages


When you install a tool like ESLint locally for a project, the eslint script winds up in ./node_modules/.bin/eslint, which makes the command awkward to run. Fortunately, npm is bundled with a command known as “npx,” which you can use to run locally installed tools with commands like npx   es l i nt  or npx   j es t . (And if you use npx to invoke a tool that has not been installed yet, it will install it for you.)

The company behind npm also maintains the https://npmjs.com package repository, which holds hundreds of thousands of open source packages. But you don’t have to use the npm package manager to access this

repository of packages. Alternatives include yarn and pnpm.



17.5 Code Bundling

If you are writing a large JavaScript program to run in web browsers, you will probably want to use a code-bundling tool, especially if you use external libraries that are delivered as modules. Web developers have been using ES6 modules (§10.3) for years, since well before the i mpor t  and expor t  keywords were supported on the web. In order to do this, programmers use a code-bundler tool that starts at the main entry point (or entry points) of the program and follows the tree of i mpor t  directives to find all modules that the program depends on. It then combines all of those individual module files into a single bundle of JavaScript code and rewrites the i mpor t  and expor t  directives to make the code work in this new form. The result is a single file of code that can be loaded into a web browser that does not support modules.

ES6 modules are nearly universally supported by web browsers today, but web developers still tend to use code bundlers, at least when releasing production code. Developers find that user experience is best when a single medium-sized bundle of code is loaded when a user first visits a website than when many small modules are loaded.


NOTE

Web performance is a notoriously tricky topic and there are lots of variables to consider, including ongoing improvements by browser vendors, so the only way to be sure of the fastest way to load your code is by testing thoroughly and measuring carefully. Keep in mind that there is one variable that is completely under your control: code size. Less JavaScript code will always load and run faster than more JavaScript code!



There are a number of good JavaScript bundler tools available. Commonly used bundlers include webpack, Rollup and Parcel. The basic features of bundlers are more or less the same, and they are differentiated based on how configurable they are or how easy they are to use. Webpack has been around for a long time, has a large ecosystem of plug-ins, is highly configurable, and can support older nonmodule libraries. But it can also be complex and hard to configure. At the other end of the spectrum is Parcel which is intended as a zero-configuration alternative that simply does the right thing.


In addition to performing basic bundling, bundler tools can also provide some additional features:

Some programs have more than one entry point. A web application with multiple pages, for example, could be written with a different entry point for each page. Bundlers generally allow you to create one bundle per entry point or to create a single bundle that supports multiple entry points.

Programs can use i mpor t ( )  in its functional form (§10.3.6) instead of its static form to dynamically load modules when they are actually needed rather than statically loading them at program startup time. Doing this is often a good way to improve the startup time for your program. Bundler tools that support
i mpor t ( )  may be able to produce multiple output bundles: one to load at startup time, and one or more that are loaded dynamically when needed. This can work well if there are only a few calls to i mpor t ( )  in your program and they load modules with relatively disjoint sets of dependencies. If the dynamically loaded modules share dependencies then it becomes tricky to figure out how many bundles to produce, and you are likely to have to manually configure your bundler to sort this out.

Bundlers can generally output a source map file that defines a mapping between the lines of code in the bundle and the corresponding lines in the original source files. This allows browser developer tools to automatically display JavaScript errors at their original unbundled locations.

Sometimes when you import a module into your program, you only use a few of its features. A good bundler tool can analyze the code to determine which parts are unused and can be omitted from the bundles. This feature goes by the whimsical name of “tree-shaking.”

Bundlers typically have a plug-in–based architecture and support plug-ins that allow importing and bundling “modules” that are not actually files of JavaScript code. Suppose that your program includes a large JSON-compatible data structure. Code bundlers can be configured to allow you to move that data structure into a separate JSON file and then import it into your program with a declaration like i mpor t   wi dget s   f r om " . / bi g-
wi dget - l i s t . j s on" . Similarly, web developers who embed CSS into their JavaScript programs can use bundler plug-ins that allow them to import CSS files with an i mpor t  directive. Note, however, that if you import anything other than a JavaScript file, you are using a nonstandard JavaScript extension and making your code dependent on the bundler tool.

In a language like JavaScript that does not require compilation, running a bundler tool feels like a compilation step, and it is frustrating to have to run a bundler after every code edit before you can run the code in your browser. Bundlers typically support filesystem watchers that detect edits to any files in a project directory and automatically regenerate the necessary bundles. With this feature in place you can typically save your code and then immediately reload your web browser window to try it out.

Some bundlers also support a “hot module replacement” mode for developers where each time a bundle is regenerated, it is

automatically loaded into the browser. When this works, it is a magical experience for developers, but there are some tricks going on under the hood to make it work, and it is not suitable for all projects.


17.6 Transpilation with Babel

Babel is a tool that compiles JavaScript written using modern language features into JavaScript that does not use those modern language features. Because it compiles JavaScript to JavaScript, Babel is sometimes called a “transpiler.” Babel was created so that web developers could use the new language features of ES6 and later while still targeting web browsers that only supported ES5.


Language features such as the ** exponentiation operator and arrow functions can be transformed relatively easily into Mat h. pow( )  and f unct i on expressions. Other language features, such as the cl as s
keyword, require much more complex transformations, and, in general, the code output by Babel is not meant to be human readable. Like bundler tools, however, Babel can produce source maps that map transformed code locations back to their original source locations, and this helps dramatically when working with transformed code.


Browser vendors are doing a better job of keeping up with the evolution of the JavaScript language, and there is much less need today to compile away arrow functions and class declarations. Babel can still help when you want to use the very latest features like underscore separators in numeric literals.


Like most of the other tools described in this chapter, you can install Babel with npm and run it with npx. Babel reads a .babelrc configuration file

that tells it how you would like your JavaScript code transformed. Babel defines “presets” that you can choose from depending on which language extensions you want to use and how aggressively you want to transform standard language features. One of Babel’s interesting presets is for code compression by minification (stripping comments and whitespace, renaming variables, and so on).


If you use Babel and a code-bundling tool, you may be able to set up the code bundler to automatically run Babel on your JavaScript files as it builds the bundle for you. If so, this can be a convenient option because it simplifies the process of producing runnable code. Webpack, for example, supports a “babel-loader” module that you can install and configure to run Babel on each JavaScript module as it is bundled up.


Even though there is less need to transform the core JavaScript language today, Babel is still commonly used to support nonstandard extensions to the language, and we’ll describe two of these language extensions in the sections that follow.


17.7 J SX: Markup Expressions in J avaScript

JSX is an extension to core JavaScript that uses HTML-style syntax to define a tree of elements. JSX is most closely associated with the React framework for user interfaces on the web. In React, the trees of elements defined with JSX are ultimately rendered into a web browser as HTML. Even if you have no plans to use React yourself, its popularity means that you are likely to see code that uses JSX. This section explains what you need to know to make sense of of it. (This section is about the JSX language extension, not about React, and it explains only enough of React to provide context for the JSX syntax.)

You can think of a JSX element as a new type of JavaScript expression syntax. JavaScript string literals are delimited with quotation marks, and regular expression literals are delimited with slashes. In the same way, JSX expression literals are delimited with angle brackets. Here is a very simple one:

l et   l i ne   =   <hr / >;


If you use JSX, you will need to use Babel (or a similar tool) to compile JSX expressions into regular JavaScript. The transformation is simple enough that some developers choose to use React without using JSX. Babel transforms the JSX expression in this assignment statement into a simple function call:

l et   l i ne   =   Reac t . c r eat eEl ement ( " hr " ,	nul l ) ;


JSX syntax is HTML-like, and like HTML elements, React elements can have attributes like these:

l et   i mage   =   <i mg   s r c =" l ogo. png"   al t =" The   J SX   l ogo"   hi dden/ >;


When an element has one or more attributes, they become properties of an object passed as the second argument to cr eat eEl ement ( ) :


l et   i mage   =   Reac t . c r eat eEl ement ( " i mg" ,	{ s r c :	" l ogo. png" ,
al t :	" The   J SX   l ogo" , hi dden:	t r ue
} ) ;


Like HTML elements, JSX elements can have strings and other elements as children. Just as JavaScript’s arithmetic operators can be used to write arithmetic expressions of arbitrary complexity, JSX elements can also be

nested arbitrarily deeply to create trees of elements:


l et   s i debar   =   (
<di v   c l as s Name=" s i debar " > <h1>Ti t l e</ h1>
<hr / >
<p>Thi s   i s   t he   s i debar   c ont ent </ p> </ di v>
) ;


Regular JavaScript function call expressions can also be nested arbitrarily deeply, and these nested JSX expressions translate into a set of nested
cr eat eEl ement ( )  calls. When an JSX element has children, those children (which are typically strings and other JSX elements) are passed as the third and subsequent arguments:

l et   s i debar   =   Reac t . c r eat eEl ement (
" di v" ,	{    c l as s Name:	" s i debar " } ,	/ /   Thi s   out er   c al l	c r eat es a   <di v>
Reac t . c r eat eEl ement ( " h1" ,	nul l ,	/ /   Thi s   i s   t he   f i r s t   c hi l d of    t he   <di v/ >
" Ti t l e" ) ,	/ /   and   i t s   own   f i r s t   c hi l d. Reac t . c r eat eEl ement ( " hr " ,	nul l ) ,	/ /   The   s ec ond   c hi l d   of    t he
<di v/ >.
Reac t . c r eat eEl ement ( " p" ,	nul l ,	/ /   And   t he   t hi r d   c hi l d. " Thi s   i s   t he   s i debar   c ont ent " ) ) ;


The value returned by React . cr eat eEl ement ( )  is an ordinary JavaScript object that is used by React to render output in a browser window. Since this section is about the JSX syntax and not about React, we’re not going to go into any detail about the returned Element objects or the rendering process. It is worth noting that you can configure Babel to compile JSX elements to invocations of a different function, so if you think that JSX syntax would be a useful way to express other kinds of nested data structures, you can adopt it for your own non-React uses.

An important feature of JSX syntax is that you can embed regular JavaScript expressions within JSX expressions. Within a JSX expression, text within curly braces is interpreted as plain JavaScript. These nested expressions are allowed as attribute values and as child elements. For example:


f unc t i on
r et ur n

s i debar ( c l as s Name,	t i t l e,	c ont ent ,	dr awL i ne=t r ue)    {
(

<di v   c l as s Name={ c l as s Name} > <h1>{ t i t l e} </ h1>
{    dr awL i ne   &&  <hr / >   } <p>{ c ont ent } </ p>
</ di v> ) ;
}


The s i debar ( )  function returns a JSX element. It takes four arguments that it uses within the JSX element. The curly brace syntax may remind you of template literals that use ${ }  to include JavaScript expressions within strings. Since we know that JSX expressions compile into function invocations, it should not be surprising that arbitrary JavaScript expressions can be included because function invocations can be written with arbitrary expressions as well. This example code is translated by Babel into the following:

f unc t i on   s i debar ( c l as s Name,	t i t l e,	c ont ent ,	dr awL i ne=t r ue)    { r et ur n   Reac t . c r eat eEl ement ( " di v" ,    {    c l as s Name:	c l as s Name   } ,
Reac t . c r eat eEl ement ( " h1" ,	nul l , t i t l e) ,
dr awL i ne   && Reac t . c r eat eEl ement ( " hr " ,	nul l ) ,
Reac t . c r eat eEl ement ( " p" ,	nul l , c ont ent ) ) ;
}

This code is easy to read and understand: the curly braces are gone and the resulting code passes the incoming function parameters to
React . cr eat eEl ement ( )  in a natural way. Note the neat trick that we’ve done here with the dr awLi ne parameter and the short-circuiting &&operator. If you call s i debar ( )  with only three arguments, then dr awLi ne defaults to t r ue, and the fourth argument to the outer
cr eat eEl ement ( )  call is the <hr / > element. But if you pass f al s e as the fourth argument to s i debar ( ) , then the fourth argument to the outer cr eat eEl ement ( )  call evaluates to f al s e, and no <hr / > element is ever created. This use of the &&operator is a common idiom in JSX to conditionally include or exclude a child element depending on the value of some other expression. (This idiom works with React because React simply ignores children that are f al s e or nul l  and does not produce any output for them.)

When you use JavaScript expressions within JSX expressions, you are not limited to simple values like the string and boolean values in the preceding example. Any JavaScript value is allowed. In fact, it is quite common in React programming to use objects, arrays, and functions. Consider the following function, for example:


/ /   Gi ven   an   ar r ay   of    s t r i ngs J SX   el ement
/ /   r epr es ent i ng   an   HTML   <ul > as   i t s   c hi l d.

and   a   c al l bac k   f unc t i on   r et ur n   a

l i s t   wi t h   an   ar r ay   of    <l i >   el ement s



f unc t i on
r et ur n

l i s t ( i t ems ,	c al l bac k)    {
(

<ul	s t yl e={    { paddi ng: 10,	bor der : " s ol i d   r ed   4px" }    } > { i t ems . map( ( i t em, i ndex)    =>   {
<l i	onCl i c k={ ( )    =>   c al l bac k( i ndex) }    key={ i ndex} >{ i t em} </ l i >
} ) } </ ul >
) ;

}


This function uses an object literal as the value of the s t yl e attribute on the <ul > element. (Note that double curly braces are required here.) The <ul > element has a single child, but the value of that child is an array. The child array is the array created by using the map( )  function on the input array to create an array of <l i > elements. (This works with React because the React library flattens the children of an element when it renders them. An element with one array child is the same as that element with each of those array elements as children.) Finally, note that each of the nested <l i > elements has an onCl i ck event handler attribute whose value is an arrow function. The JSX code compiles to the following pure JavaScript code (which I have formatted with Prettier):

f unc t i on   l i s t ( i t ems ,	c al l bac k)    { r et ur n   Reac t . c r eat eEl ement (
" ul " ,
{    s t yl e:	{    paddi ng:	10,	bor der :	" s ol i d   r ed   4px"   }    } , i t ems . map( ( i t em,	i ndex)    =>
Reac t . c r eat eEl ement ( " l i " ,
{    onCl i c k:	( )    =>   c al l bac k( i ndex) ,	key:	i ndex   } , i t em
) )
) ; }


One other use of object expressions in JSX is with the object spread operator (§6.10.4) to specify multiple attributes at once. Suppose that you find yourself writing a lot of JSX expressions that repeat a common set of attributes. You can simplify your expressions by defining the attributes as properties of an object and “spreading them into” your JSX elements:

l et   hebr ew  =   {    l ang:	" he" ,	di r :	" r t l "   } ;	/ /   Spec i f y   l anguage   and di r ec t i on
l et   s hal om =   <s pan   c l as s Name=" emphas i s "   { . . . hebr ew} >םו לש</ s pan>;


Babel compiles this to use an _ext ends ( )  function (omitted here) that combines that cl as s Name attribute with the attributes contained in the hebr ewobject:

l et   s hal om =   Reac t . c r eat eEl ement ( " s pan" ,
_ext ends ( { c l as s Name: " emphas i s " } ,	hebr ew) ,
" \ u05E9\ u05DC\ u05D5\ u05DD" ) ;


Finally, there is one more important feature of JSX that we have not covered yet. As you’ve seen, all JSX elements begin with an identifier immediately after the opening angle bracket. If the first letter of this identifier is lowercase (as it has been in all of the examples here), then the identifier is passed to cr eat eEl ement ( )  as a string. But if the first letter of the identifier is uppercase, then it is treated as an actual identifer, and it is the JavaScript value of that identifier that is passed as the first argument to cr eat eEl ement ( ) . This means that the JSX expression <Mat h/ > compiles to JavaScript code that passes the global Math object to React . cr eat eEl ement ( ) .


For React, this ability to pass non-string values as the first argument to cr eat eEl ement ( )  enables the creation of components. A component is a way of writing a simple JSX expression (with an uppercase component name) that represents a more complex expression (using lowercase HTML tag names).

The simplest way to define a new component in React is to write a function that takes a “props object” as its argument and returns a JSX

expression. A props object is simply a JavaScript object that represents attribute values, like the objects that are passed as the second argument to cr eat eEl ement ( ) . Here, for example, is another take on our
s i debar ( )  function:



f unc t i on
r et ur n

Si debar ( pr ops )    {
(

<di v>
<h1>{ pr ops . t i t l e} </ h1>
{    pr ops . dr awL i ne   &&  <hr / >   } <p>{ pr ops . c ont ent } </ p>
</ di v> ) ;
}


This new Si debar ( )  function is a lot like the earlier s i debar ( ) function. But this one has a name that begins with a capital letter and takes a single object argument instead of separate arguments. This makes it a React component and means that it can be used in place of an HTML tag name in JSX expressions:

l et   s i debar   =   <Si debar   t i t l e=" Somet hi ng   s nappy" c ont ent =" Somet hi ng   wi s e" / >;


This <Si debar / > element compiles like this:


l et   s i debar   =   Reac t . c r eat eEl ement ( Si debar ,	{ t i t l e:	" Somet hi ng   s nappy" ,
c ont ent :	" Somet hi ng   wi s e" } ) ;


It is a simple JSX expression, but when React renders it, it will pass the second argument (the Props object) to the first argument (the Si debar ( ) function) and will use the JSX expression returned by that function in place of the <Si debar > expression.

17.8 Type Checking with Flow

Flow is a language extension that allows you to annotate your JavaScript code with type information, and a tool for checking your JavaScript code (both annotated and unannotated) for type errors. To use Flow, you start writing code using the Flow language extension to add type annotations. Then you run the Flow tool to analyze your code and report type errors. Once you have fixed the errors and are ready to run the code, you use Babel (perhaps automatically as part of the code-bundling process) to strip the Flow type annotations out of your code. (One of the nice things about the Flow language extension is that there isn’t any new syntax that Flow has to compile or transform. You use the Flow language extension to add annotations to the code, and all Babel has to do is to strip those annotations out to return your code to standard JavaScript.)



TYPESCRIPT VERSUS FLOW

TypeScript is a very popular alternative to Flow. TypeScript is an extension of JavaScript that adds types as well as other language features. The TypeScript compiler “tsc” compiles TypeScript programs into JavaScript programs and in the process analyzes them and reports type errors in much the same the way that Flow does. tsc is not a Babel plugin: it is its own standalone compiler.

Simple type annotations in TypeScript are usually written identically to the same annotations in Flow. For more advanced typing, the syntax of the two extensions diverges, but the intent and value of the two extensions is the same. My goal in this section is to explain the benefits of type annotations and static code analysis. I’ll be doing that with examples based on Flow, but everything demonstrated here can also be achieved with TypeScript with relatively simple syntax changes.

TypeScript was released in 2012, before ES6, when JavaScript did not have a cl as s  keyword or a
f or / of  loop or modules or Promises. Flow is a narrow language extension that adds type annotations to JavaScript and nothing else. TypeScript, by contrast, was very much designed as a new language. As its name implies, adding types to JavaScript is the primary purpose of TypeScript, and it is the reason that people use it today. But types are not the only feature that TypeScript adds to JavaScript: the TypeScript language has enumand names pace keywords that simply do not exist in JavaScript. In 2020, TypeScript has better integration with IDEs and code editors (particularly VSCode, which, like TypeScript, is from Microsoft) than Flow does.

Ultimately, this is a book about JavaScript, and I’m covering Flow here instead of TypeScript because I don’t want to take the focus off of JavaScript. But everything you learn here about adding types to JavaScript will be helpful to you if you decide to adopt TypeScript for your projects.

Using Flow requires commitment, but I have found that for medium and large projects, the extra effort is worth it. It takes extra time to add type annotations to your code, to run Flow every time you edit the code, and to fix the type errors it reports. But in return Flow will enforce good coding discipline and will not allow you to cut corners that can lead to bugs. When I have worked on projects that use Flow, I have been impressed by the number of errors it found in my own code. Being able to fix those issues before they became bugs is a great feeling and gives me extra confidence that my code is correct.


When I first started using Flow, I found that it was sometimes difficult to understand why it was complaining about my code. With some practice, though, I came to understand its error messages and found that it was usually easy to make minor changes to my code to make it safer and to satisfy Flow.1 I do not recommend using Flow if you still feel like you are learning JavaScript itself. But once you are confident with the language, adding Flow to your JavaScript projects will push you to take your programming skills to the next level. And this, really, is why I’m dedicating the last section of this book to a Flow tutorial: because learning about JavaScript type systems offers a glimpse of another level, or another style, of programming.


This section is a tutorial, and it does not attempt to cover Flow comprehensively. If you decide to try Flow, you will almost certainly end up spending time reading the documentation at https://flow.org. On the other hand, you do not need to master the Flow type system before you can start making practical use of it in your projects: the simple uses of Flow described here will take you a long way.


17.8.1 Installing and Running Flow

Like the other tools described in this chapter, you can install the Flow type-checking tool using a package manager, with a command like npm i ns t al l	- g   f l ow- bi n or npm i ns t al l	- - s ave- dev   f l ow-bi n. If you install the tool globally with - g, then you can run it with
f l ow. And if you install it locally in your project with - - s ave- dev, then you can run it with npx   f l ow. Before using Flow to do type checking, the first time run it as f l ow  - - i ni t  in the root directory of your project to create a . f l owconf i g configuration file. You may never need to add anything to this file, but Flow needs it to know where your project root is.

When you run Flow, it will find all the JavaScript source code in your project, but it will only report type errors for the files that have “opted in” to type checking by adding a / /   @f l owcomment at the top of the file. This opt-in behavior is important because it means that you can adopt Flow for existing projects and then begin to convert your code one file at a time, without being bothered by errors and warnings on files that have not yet been converted.

Flow may be able to find errors in your code even if all you do is opt in with a / /   @f l owcomment. Even if you do not use the Flow language extension and add no type annotations to your code, the Flow type checker tool can still make inferences about the values in your program and alert you when you use them inconsistently.

Consider the following Flow error message:


Er r or   ┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈ var i abl eReas s i gnment . j s : 6: 3


Cannot   as s i gn •   pr oper t y   r

1   t o   i . r   bec aus e:
i s   mi s s i ng   i n   number   [ 1] .



2│   l et   i	=   {    r :	0,	i :	1   } ;
[ 1]    3│   f or ( i	=   0;	i	<   10;	i ++)    { over wr i t es   i
4│	c ons ol e. l og( i ) ; 5│   }
6│   i . r   =   1; her e

/ /   The   c ompl ex   number   0+1i / /   Oops !   The   l oop   var i abl e



/ /   Fl ow  det ec t s   t he   er r or



In this case, we declare the variable i  and assign an object to it. Then we use i  again as a loop variable, overwriting the object. Flow notices this and flags an error when we try to use i  as if it still held an object. (A simple fix would be to write f or ( l et   i	=   0;  making the loop variable local to the loop.)

Here is another error that Flow detects even without type annotations:


Er r or   ┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈ s i z e. j s : 3: 14

Cannot   get   x. l engt h   bec aus e   pr oper t y   l engt h   i s   mi s s i ng   i n   Number [ 1] .

1│   / /   @f l ow
2│   f unc t i on   s i z e( x)    { 3│	r et ur n   x. l engt h; 4│   }
[ 1]    5│   l et   s   =   s i z e( 1000) ;


Flow sees that the s i z e( )  function takes a single argument. It doesn’t know the type of that argument, but it can see that the argument is expected to have a l engt h property. When it sees this s i z e( )  function being called with a numeric argument, it correctly flags this as an error because numbers do not have l engt h properties.


17.8.2 Using Type Annotations

When you declare a JavaScript variable, you can add a Flow type

annotation to it by following the variable name with a colon and the type:


l et   mes s age:	s t r i ng   =   " Hel l o   wor l d" ; l et   f l ag:	bool ean   =   f al s e;
l et   n:	number   =   42;


Flow would know the types of these variables even if you did not annotate them: it can see what values you assign to each variable, and it keeps track of that. If you add type annotations, however, Flow knows both the type of the variable and that you have expressed the intent that the variable should always be of that type. So if you use the type annotation, Flow will flag an error if you ever assign a value of a different type to that variable. Type annotations for variables are also particularly useful if you tend to declare all your variables up at the top of a function before they are used.


Type annotations for function arguments are like annotations for variables: follow the name of the function argument with a colon and the type name. When annotating a function, you typically also add an annotation for the return type of the function. This goes between the close parenthesis and the open curly brace of the function body. Functions that return nothing use the Flow type voi d.


In the preceding example we defined a s i z e( )  function that expected an argument with a l engt h property. Here’s how we could change that function to explicitly specify that it expects a string argument and returns a number. Note, Flow now flags an error if we pass an array to the function, even though the function would work in that case:

Er r or   ┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈ s i z e2. j s : 5: 18

Cannot   c al l	s i z e   wi t h   ar r ay   l i t er al	bound   t o   s   bec aus e   ar r ay l i t er al	[ 1]

i s   i nc ompat i bl e   wi t h   s t r i ng   [ 2] .

[ 2]    2│   f unc t i on   s i z e( s :	s t r i ng) :	number   { 3│	r et ur n   s . l engt h;
4│   }
[ 1]    5│   c ons ol e. l og( s i z e( [ 1, 2, 3] ) ) ;


Using type annotations with arrow functions is also possible, though it can turn this normally succinct syntax into something more verbose:

c ons t   s i z e   =   ( s :	s t r i ng) :	number   =>   s . l engt h;


An important thing to understand about Flow is that the JavaScript value nul l  has the Flow type nul l  and the JavaScript value undef i ned has the Flow type voi d. But neither of these values is a member of any other type (unless you explicitly add it). If you declare a function parameter to be a string, then it must be a string, and it is an error to pass nul l  or to pass undef i ned or to omit the argument (which is basically the same thing as passing undef i ned):

Er r or   ┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈ s i z e3. j s : 3: 18

Cannot   c al l	s i z e   wi t h   nul l	bound   t o   s   bec aus e   nul l	[ 1]    i s i nc ompat i bl e
wi t h   s t r i ng   [ 2] .

1│   / /   @f l ow
[ 2]    2│   c ons t   s i z e   =   ( s :	s t r i ng) :	number   =>   s . l engt h; [ 1]    3│   c ons ol e. l og( s i z e( nul l ) ) ;


If you want to allow nul l  and undef i ned as legal values for a variable or function argument, simply prefix the type with a question mark. For example, use ?s t r i ng or ?number  instead of s t r i ng or number . If we change our s i z e( )  function to expect an argument of type ?
s t r i ng, then Flow doesn’t complain when we pass nul l  to the function. But it now has something else to complain about:

Er r or   ┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈ s i z e4. j s : 3: 14

Cannot   get   s . l engt h   bec aus e   pr oper t y   l engt h   i s   mi s s i ng   i n   nul l or
undef i ned   [ 1] .

1│   / /   @f l ow
[ 1]    2│   f unc t i on   s i z e( s :	?s t r i ng) :	number   { 3│	r et ur n   s . l engt h;
4│   }
5│   c ons ol e. l og( s i z e( nul l ) ) ;


What Flow is telling us here is that it is not safe to write s . l engt h because, at this place in our code, s  might be nul l  or undef i ned, and those values do not have l engt h properties. This is where Flow makes sure we do not cut any corners. If a value might be nul l , Flow will insist that we check for that case before we do anything that depends on the value not being nul l .


In this case, we can fix the issue by changing the body of the function as follows:

f unc t i on   s i z e( s :	?s t r i ng) :	number   {
/ /   At   t hi s   poi nt   i n   t he   c ode,	s   c oul d   be   a   s t r i ng   or   nul l	or undef i ned.
i f    ( s   ===   nul l	||   s   ===   undef i ned)    {
/ /   I n   t hi s   bl oc k,	Fl ow  knows   t hat   s   i s   nul l	or undef i ned.
r et ur n   - 1;
}    el s e   {
/ /   And   i n   t hi s   bl oc k,	Fl ow  knows   t hat   s   i s   a   s t r i ng. r et ur n   s . l engt h;
} }


When the function is first called, the parameter can have more than one type. But by adding type-checking code, we create a block within the code where Flow knows for sure that the parameter is a string. When we use

s . l engt h within that block, Flow does not complain. Note that Flow does not require you to write verbose code like this. Flow would also be satisfied if we just replaced the body of the s i z e( )  function with
r et ur n  s   ?   s . l engt h  :	- 1; .


Flow syntax allows a question mark before any type specification to indicate that, in addition to the specified type, nul l  and undef i ned are allowed as well. Question marks can also appear after a parameter name to indicate that the parameter itself is optional. So if we changed the declaration of the parameter s  from s :	?s t r i ng to s ?   :	s t r i ng, that would mean it is OK to call s i z e( )  with no arguments (or with the value undef i ned, which is the same as omitting it), but that if we do call it with a parameter other than undef i ned, then that parameter must be a string. In this case, nul l  is not a legal value.


So far, we’ve discussed primitive types s t r i ng, number , bool ean, nul l , and voi d and have demonstrated how you can use use them with variable declarations, function parameters, and function return values. The subsections that follow describe some more complex types supported by Flow.


17.8.3 Class Types

In addition to the primitive types that Flow knows about, it also knows about all of JavaScript’s built-in classes and allows you to use class name as types. The following function, for example, uses type annotations to indicate that it should be invoked with one Date object and one RegExp object:

/ /   @f l ow
/ /   Ret ur n   t r ue   i f    t he   I SO  r epr es ent at i on   of    t he   s pec i f i ed   dat e

/ /   mat c hes   t he   s pec i f i ed   pat t er n,	or   f al s e   ot her wi s e.
/ /   E. g:	c ons t   i s TodayChr i s t mas   =   dat eMat c hes ( new  Dat e( ) , / ^\ d{ 4} - 12- 25T/ ) ;
expor t   f unc t i on   dat eMat c hes ( d:	Dat e,	p:	RegExp) :	bool ean   {
r et ur n   p. t es t ( d. t oI SOSt r i ng( ) ) ; }


If you define your own classes with the cl as s  keyword, those classes automatically become valid Flow types. In order to make this work, however, Flow does require you to use type annotations in the class. In particular, each property of the class must have its type declared. Here is a simple complex number class that demonstrates this:

/ /   @f l ow
expor t   def aul t   c l as s   Compl ex   {

/ /   Fl ow  r equi r es   an   ext ended   c l as s   s ynt ax annot at i ons
/ /   f or   eac h   of    t he   pr oper t i es   us ed   by   t he

t hat   i nc l udes   t ype

c l as s .

i :    number ; r :    number ;
s t at i c   i :	Compl ex;

c ons t r uc t or ( r :	number ,	i : number )    {
/ /   Any   pr oper t i es   i ni t i al i z ed   by   t he   c ons t r uc t or   mus t have   Fl ow  t ype
/ /   annot at i ons   above. t hi s . r   =   r ;
t hi s . i	=   i ; }

add( t hat :	Compl ex)    {
r et ur n   new  Compl ex( t hi s . r   +   t hat . r ,	t hi s . i	+   t hat . i ) ; }
}


/ /   Thi s   as s i gnment   woul d   not   be a
/ /   t ype   annot at i on   f or   i	i ns i de

al l owed   by   Fl ow  i f    t her e   was   not

t he   c l as s .

Compl ex. i	=   new  Compl ex( 0, 1) ;


17.8.4 Object Types

The Flow type to describe an object looks a lot like an object literal, except that property values are replaced by property types. Here, for example, is a function that expects an object with numeric x and y properties:


/ /   @f l ow
/ /   Gi ven   an / /   di s t anc e


obj ec t   wi t h   numer i c   x   and   y   pr oper t i es , f r om t he   or i gi n   t o   t he   poi nt   ( x, y)    as   a


r et ur n   t he number .

expor t   def aul t   f unc t i on   di s t anc e( poi nt :	{ x: number ,	y: number } ) : number   {
r et ur n   Mat h. hypot ( poi nt . x,	poi nt . y) ; }


In this code, the text { x: number ,	y: number }  is a Flow type, just like s t r i ng or Dat e is. As with any type, you can add a question mark at the front to indicate that nul l  and undef i ned should also be allowed.


Within an object type, you can follow any of the property names with a question mark to indicate that that property is optional and may be omitted. For example, you might write the type for an object that represents a 2D or 3D point like this:

{ x:	number ,	y:	number ,	z ?:	number }


If a property is not marked as optional in an object type, then it is required, and Flow will report an error if an appropriate property is not present in the actual value. Normally, however, Flow tolerates extra properties. If you were to pass an object that had a wproperty to the di s t ance( ) function above, Flow would not complain.

If you want Flow to strictly enforce that an object does not have properties other than those explicitly declared in its type, you can declare an exact object type by adding vertical bars to the curly braces:

{ |   x:	number ,	y:	number   |}


JavaScript’s objects are sometimes used as dictionaries or string-to-value maps. When used like this, the property names are not known in advance and cannot be declared in a Flow type. If you use objects this way, you can still use Flow to describe the data structure. Suppose that you have an object where the properties are the names of the world’s major cities and the values of those properties are objects that specify the geographical location of those cities. You might declare this data structure like this:

/ /   @f l ow
c ons t   c i t yL oc at i ons   :	{ [ s t r i ng] :	{ l ongi t ude: number , l at i t ude: number } }    =   {
" Seat t l e" :	{    l ongi t ude:	47. 6062,	l at i t ude:	- 122. 3321   } ,
/ /   TODO:	i f    t her e   ar e   any   ot her   i mpor t ant   c i t i es ,	add   t hem her e.
} ;
expor t   def aul t   c i t yL oc at i ons ;


17.8.5 Type Aliases

Objects can have many properties, and the Flow type that describes such an object will be long and difficult to type. And even relatively short object types can be confusing because they look so much like object literals. Once we get beyond simple types like number  and ?s t r i ng, it is often useful to be able to define names for our Flow types. And in fact, Flow uses the t ype keyword to do exactly that. Follow the t ype keyword with an identifier, an equals sign, and a Flow type. Once you’ve done that, the identifier will be an alias for the type. Here, for example, is how we could rewrite the di s t ance( )  function from the previous section with an explicitly defined Poi nt  type:

/ /   @f l ow
expor t   t ype   Poi nt   =   {

x:	number , y:	number
} ;

/ /   Gi ven   a   Poi nt   obj ec t   r et ur n   i t s   di s t anc e   f r om t he   or i gi n expor t   def aul t   f unc t i on   di s t anc e( poi nt :	Poi nt ) :	number   {
r et ur n   Mat h. hypot ( poi nt . x,	poi nt . y) ; }


Note that this code exports the di s t ance( )  function and also exports the Poi nt  type. Other modules can use i mpor t   t ype   Poi nt   f r om ' . / di s t ance. j s '  if they want to use that type definition. Keep in mind, though, that i mpor t   t ype is a Flow language extension and not a real JavaScript import directive. Type imports and exports are used by the Flow type checker, but like all other Flow language extensions, they are stripped out of the code before it ever runs.

Finally, it is worth noting that instead of defining a name for a Flow object type that represents a point, it would probably be simpler and cleaner to just define a Point class and use that class as the type.


17.8.6 Array Types

The Flow type to describe an array is a compound type that also includes the type of the array elements. Here, for example, is a function that expects an array of numbers, and the error that Flow reports if you try to call the function with an array that has non-numeric elements:

Er r or   ┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈ aver age. j s : 8: 16

Cannot   c al l	aver age   wi t h   ar r ay   l i t er al	bound   t o   dat a   bec aus e s t r i ng   [ 1]
i s   i nc ompat i bl e   wi t h   number   [ 2]    i n   ar r ay   el ement .

[ 2]	2│   f unc t i on   aver age( dat a:	Ar r ay<number >)    { 3│	l et   s um =   0;

4│	f or ( l et   x   of    dat a)    s um +=   x; 5│	r et ur n   s um/ dat a. l engt h;
6│   } 7│
[ 1]	8│   aver age( [ 1,	2,	" t hr ee" ] ) ;


The Flow type for an array is Ar r ay followed by the element type in angle brackets. You can also express an array type by following the element type with open and close square brackets. So in this example we could have written number [ ]  instead of Ar r ay<number >. I prefer the angle bracket notation because, as we’ll see, there are other Flow types that use this angle-bracket syntax.

The Array type syntax shown works for arrays with an arbitrary number of elements, all of which have the same type. Flow has a different syntax for describing the type of a tuple: an array with a fixed number of elements, each of which may have a different type. To express the type of a tuple, simply write the type of each of its elements, separate them with commas, and enclose them all in square brackets.


A function that returns an HTTP status code and message might look like this, for example:

f unc t i on   get St at us ( ) : [ number ,	s t r i ng]    {
r et ur n   [ get St at us Code( ) ,	get St at us Mes s age( ) ] ; }


Functions that return tuples are awkward to work with unless you use destructuring assignment:

l et   [ c ode,	mes s age]    =   get St at us ( ) ;


Destructuring assignment, plus Flow’s type-aliasing capabilities, make tuples easy enough to work with that you might consider them as an

alternative to classes for simple datatypes:


/ /   @f l ow
expor t   t ype   Col or   =   [ number ,	number ,	number ,	number ] ;	/ /   [ r ,	g, b,	opac i t y]

f unc t i on   gr ay( l evel :	number ) :	Col or   { r et ur n   [ l evel ,	l evel ,	l evel ,	1] ;
}

f unc t i on   f ade( [ r , g, b, a] :	Col or ,	f ac t or :	number ) :	Col or   { r et ur n   [ r ,	g,	b,	a/ f ac t or ] ;
}

l et   [ r ,	g,	b,	a]    =   f ade( gr ay( 75) ,	3) ;


Now that we have a way to express the type of an array, let’s return to the s i z e( )  function from earlier and modify it to expect an array argument instead of a string argument. We want the function to be able to accept an array of any length, so a tuple type is not appropriate. But we don’t want to restrict our function to working only for arrays where all the elements have the same type. The solution is the type Ar r ay<mi xed>:

/ /   @f l ow
f unc t i on   s i z e( s :	Ar r ay<mi xed>) :	number   { r et ur n   s . l engt h;
}
c ons ol e. l og( s i z e( [ 1, t r ue, " t hr ee" ] ) ) ;


The element type mi xed indicates that the elements of the array can be of any type. If our function actually indexed the array and attempted to use any of those elements, Flow would insist that we use t ypeof  checks or other tests to determine the type of the element before performing any unsafe operation on it. (If you are willing to give up on type checking, you can also use any instead of mi xed: it allows you to do whatever you want with the values of the array without ensuring that the values are of

the type you expect.)


17.8.7 Other Parameterized Types

We’ve seen that when you annotate a value as an Ar r ay, Flow requires you to also specify the type of the array elements inside angle brackets. This additional type is known as a type parameter, and Array is not the only JavaScript class that is parameterized.

JavaScript’s Set class is a collection of elements, like an array is, and you can’t use Set  as a type by itself, but you have to include a type parameter within angle brackets to specify the type of the values contained in the set. (Though you can use mi xed or any if the set may contain values of multiple types.) Here’s an example:


/ /   @f l ow
/ /   Ret ur n   a   s et t hos e
/ /   of    t he   i nput


of    number s   wi t h   member s   t hat   ar e   exac t l y   t wi c e

s et   of    number s .

f unc t i on   doubl e( s :	Set <number >) :	Set <number >   { l et   doubl ed:	Set <number >   =   new  Set ( ) ;
f or ( l et   n   of    s )    doubl ed. add( n   *   2) ; r et ur n   doubl ed;
}
c ons ol e. l og( doubl e( new  Set ( [ 1, 2, 3] ) ) ) ;	/ /   Pr i nt s   " Set   { 2,	4, 6} "


Map is another parameterized type. In this case, there are two type parameters that must be specified; the type of the keys and the types of the values:

/ /   @f l ow
i mpor t   t ype   {    Col or   }    f r om " . / Col or . j s " ;

l et   c ol or Names :	Map<s t r i ng,	Col or >   =   new  Map( [ [ " r ed" ,	[ 1,	0,	0,	1] ] ,

[ " gr een" ,	[ 0,	1,	0,	1] ] , [ " bl ue" ,    [ 0,    0,    1,    1] ]
] ) ;


Flow lets you define type parameters for your own classes as well. The following code defines a Result class but parameterizes that class with an Error type and a Value type. We use placeholders E and V in the code to represent these type parameters. When the user of this class declares a variable of type Result, they will specify the actual types to substitute for E and V. The variable declaration might look like this:


l et   r es ul t :	Res ul t <TypeEr r or ,	Set <s t r i ng>>;


And here is how the parameterized class is defined:



/ /   @f l ow
/ /   Thi s   c l as s   r epr es ent s   t he   r es ul t   of ei t her
/ /   t hr ow  an   er r or   of    t ype   E   or   a   val ue


an   oper at i on   t hat   c an

of    t ype   V.

expor t   c l as s   Res ul t <E,	V>   { er r or :	?E;
val ue:	?V;

c ons t r uc t or ( er r or :	?E,	val ue:	?V)    {

t hi s . er r or t hi s . val ue
}

=   er r or ;
=   val ue;


t hr ew( ) :	?E   {    r et ur n   t hi s . er r or ;	}
r et ur ned( ) :	?V  {    r et ur n   t hi s . val ue;	}

get ( ) : V  {
i f    ( t hi s . er r or )    {
t hr ow  t hi s . er r or ;
}    el s e   i f    ( t hi s . val ue   ===   nul l	||   t hi s . val ue   === undef i ned)    {
t hr ow  new  TypeEr r or ( " Er r or   and   val ue   mus t   not   bot h be   nul l " ) ;
}    el s e   {

r et ur n   t hi s . val ue; }
}

}


And you can even define type parameters for functions:


/ /   @f l ow
/ /   Combi ne   t he   el ement s   of    t wo   ar r ays   i nt o   an   ar r ay   of    pai r s f unc t i on   z i p<A, B>( a: Ar r ay<A>,	b: Ar r ay<B>) :	Ar r ay<[ ?A, ?B] >   {
l et   r es ul t : Ar r ay<[ ?A, ?B] >   =   [ ] ;
l et   l en   =   Mat h. max( a. l engt h,	b. l engt h) ; f or ( l et   i	=   0;	i	<   l en;	i ++)    {
r es ul t . pus h( [ a[ i ] ,	b[ i ] ] ) ; }
r et ur n   r es ul t ; }

/ /   Cr eat e   t he   ar r ay   [ [ 1, ' a' ] ,	[ 2, ' b' ] ,	[ 3, ' c ' ] ,	[ 4, undef i ned] ] l et   pai r s :	Ar r ay<[ ?number , ?s t r i ng] >   =   z i p( [ 1, 2, 3, 4] ,
[ ' a' , ' b' , ' c ' ] )


17.8.8 Read-Only Types

Flow defines some special parameterized “utility types” that have names beginning with $. Most of these types have advanced use cases that we are not going to cover here. But two of them are quite useful in practice. If you have an object type T and want to make a read-only version of that type, just write $ReadOnl y<T>. Similarly, you can write
$ReadOnl yAr r ay<T> to describe a read-only array with elements of type T.

The reason to use these types is not because they can offer any guarantee that an object or array can’t be modified (see Obj ect . f r eez e( )  in §14.2 if you want true read-only objects) but because it allows you to

catch bugs caused by unintentional modifications. If you write a function that takes an object or array argument and does not change any of the object’s properties or the array’s elements, then you can annotate the function parameter with one of Flow’s read-only types. If you do this, then Flow will report an error if you forget and accidentally modify the input value. Here are two examples:

/ /   @f l ow
t ype   Poi nt   =   { x: number ,	y: number } ;

/ /   Thi s   f unc t i on   t akes   a   Poi nt   obj ec t   but   pr omi s es   not   t o   modi f y i t
f unc t i on   di s t anc e( p:	$ReadOnl y<Poi nt >) :	number   {
r et ur n   Mat h. hypot ( p. x,	p. y) ; }

l et   p:	Poi nt   =   { x: 3,	y: 4} ; di s t anc e( p)	/ /   =>   5

/ /   Thi s   f unc t i on   t akes   an   ar r ay   of    number s   t hat   i t   wi l l	not modi f y
f unc t i on   aver age( dat a:	$ReadOnl yAr r ay<number >) :	number   {
l et   s um =   0;
f or ( l et   i	=   0;	i	<   dat a. l engt h;	i ++)    s um +=   dat a[ i ] ; r et ur n   s um/ dat a. l engt h;
}

l et   dat a:	Ar r ay<number >   =   [ 1, 2, 3, 4, 5] ; aver age( dat a)    / /   =>   3


17.8.9 Function Types

We have seen how to add type annotations to specify the types of a function’s parameters and its return type. But when one of the parameters of a function is itself a function, we need to be able to specify the type of that function parameter.


To express the type of a function with Flow, write the types of each

parameter, separate them with commas, enclose them in parentheses, and then follow that with an arrow and type return type of the function.


Here is an example function that expects to be passed a callback function. Notice how we defined a type alias for the type of the callback function:

/ /   @f l ow
/ /   The   t ype   of    t he   c al l bac k   f unc t i on   us ed   i n   f et c hText ( )    bel ow expor t   t ype   Fet c hText Cal l bac k   =   ( ?Er r or ,	?number ,	?s t r i ng)    =>
voi d;

expor t   def aul t   f unc t i on   f et c hText ( ur l :	s t r i ng,	c al l bac k: Fet c hText Cal l bac k)    {
l et   s t at us   =   nul l ; f et c h( ur l )
. t hen( r es pons e   =>   {
s t at us   =   r es pons e. s t at us ; r et ur n   r es pons e. t ext ( )
} )
. t hen( body   =>   {
c al l bac k( nul l ,	s t at us ,	body) ; } )
. c at c h( er r or   =>   {
c al l bac k( er r or ,	s t at us ,	nul l ) ; } ) ;
}


17.8.10 Union Types

Let’s return one more time to the s i z e( )  function. It doesn’t really make sense to have a function that does nothing other than return the length of an array. Arrays have a perfectly good l engt h property for that. But
s i z e( )  might be useful if it could take any kind of collection object (an array or a Set or a Map) and return the number of elements in the collection. In regular untyped JavaScript it would be easy to write a
s i z e( )  function like that. With Flow, we need a way to express a type

that allows arrays, Sets, and Maps, but doesn’t allow values of any other type.


Flow calls types like this Union types and allows you to express them by simply listing the desired types and separating them with vertical bar characters:

/ /   @f l ow
f unc t i on   s i z e( c ol l ec t i on:
Ar r ay<mi xed>|Set <mi xed>|Map<mi xed, mi xed>) :	number   { i f    ( Ar r ay. i s Ar r ay( c ol l ec t i on) )    {
r et ur n   c ol l ec t i on. l engt h; }    el s e   {
r et ur n   c ol l ec t i on. s i z e; }
}
s i z e( [ 1, t r ue, " t hr ee" ] )    +   s i z e( new  Set ( [ t r ue, f al s e] ) )    / /   =>   5


Union types can be read using the word “or”—“an array or a Set or a Map”—so the fact that this Flow syntax uses the same vertical bar character as JavaScript’s OR operators is intentional.


We saw earlier that putting a question mark before a type allows nul l and undef i ned values. And now you can see that a ? prefix is simply a shortcut for adding a |nul l |voi d suffix to a type.


In general, when you annotate a value with a Union type, Flow will not allow you to use that value until you’ve done enough tests to figure out what the type of the actual value is. In the s i z e( )  example we just looked at, we need to explicitly check whether the argument is an array before we try to access the l engt h property of the argument. Note that we do not have to distinguish a Set argument from a Map argument, however: both of those classes define a s i z e property, so the code in the

el s e clause is safe as long as the argument is not an array.


17.8.11 Enumerated Types and Discriminated Unions

Flow allows you to use primitive literals as types that consist of that one single value. If you write l et   x: 3; , then Flow will not allow you to assign any value to that variable other than 3. It is not often useful to define types that have only a single member, but a union of literal types can be useful. You can probably imagine a use for types like these, for example:

t ype   Ans wer   =   " yes "   |   " no" ;
t ype   Di gi t   =   0|1|2|3|4|5|6|7|8|9;


If you use types made up of literals, you need to understand that only literal values are allowed:

l et   a:	Ans wer   =   " Yes " . t oL ower Cas e( ) ;	/ /   Er r or :	c an' t   as s i gn s t r i ng   t o   Ans wer
l et   d:	Di gi t   =   3+4;	/ /   Er r or :	c an' t   as s i gn number   t o   Di gi t


When Flow checks your types, it does not actually do the calculations: it just checks the types of the calculations. Flow knows that
t oLower Cas e( )  returns a string and that the + operator on numbers returns a number. Even though we know that both of these calculations return values that are within the type, Flow cannot know that and flags errors on both of these lines.

A union type of literal types like Ans wer  and Di gi t  is an example of an enumerated type, or enum. A canonical use case for enum types is to represent the suits of playing cards:

t ype   Sui t   =   " Cl ubs "   |   " Di amonds "   |   " Hear t s "   |   " Spades " ;


A more relevant example might be HTTP status codes:



t ype   HTTPSt at us |   200	/ / |   304	/ / |   403	/ /

= OK
Not   Modi f i ed For bi dden

|   404;	/ /   Not   Found


One of the pieces of advice that new programmers often hear is to avoid using literals in their code and to instead define symbolic constants to represent those values. One practical reason for this is to avoid the problem of typos: if you misspell a string literal like “Diamonds” JavaScript may never complain but your code may not work right. If you mistype an identifier, on the other hand, JavaScript is likely to throw an error that you’ll notice. With Flow, this advice does not always apply. If you annotate a variable with the type Suit, and then try to assign a misspelled suit to it, Flow will alert you to the error.


Another important use for literal types is the creation of discriminated unions. When you work with union types (made up of actually different types, not of literals), you typically have to write code to discriminate among the possible types. In the previous section, we wrote a function that could take an array or a Set or a Map as its argument and had to write code to discriminate array input from Set or Map input. If you want to create a union of Object types, you can make these types easy to discriminate by using a literal type within each of the individual Object types.


An example will make this clear. Suppose you’re using a worker thread in Node (§16.11) and are using pos t Mes s age( )  and “message” events for sending object-based messages between the main thread and the worker

thread. There are multiple types of messages that the worker might want to send to the main thread, but we’d like to write a Flow Union type that describes all possible messages. Consider this code:


/ /   @f l ow
/ /   The   wor ker   s ends / /   r et i c ul at i ng   t he


a   mes s age   of    t hi s   t ype   when   i t   i s   done s pl i nes   we   s ent   i t .

expor t   t ype   Res ul t Mes s age   =   { mes s ageType:	" r es ul t " ,
r es ul t :	Ar r ay<Ret i c ul at edSpl i ne>,	/ /   As s ume   t hi s   t ype   i s def i ned   el s ewher e.
} ;

/ /   The   wor ker   s ends   a   mes s age   of    t hi s   t ype   i f    i t s   c ode   f ai l ed wi t h   an   exc ept i on.
expor t   t ype   Er r or Mes s age   =   {
mes s ageType:	" er r or " , er r or :	Er r or ,
} ;

/ /   The   wor ker   s ends   a   mes s age   of    t hi s   t ype   t o   r epor t   us age s t at i s t i c s .
expor t   t ype   St at i s t i c s Mes s age   =   {
mes s ageType:	" s t at s " ,
s pl i nes Ret i c ul at ed:	number , s pl i nes Per Sec ond:	number
} ;

/ /   When   we   r ec ei ve   a   mes s age   f r om t he   wor ker   i t   wi l l	be   a Wor ker Mes s age.
expor t   t ype   Wor ker Mes s age   =   Res ul t Mes s age   |   Er r or Mes s age   | St at i s t i c s Mes s age;

/ /   The   mai n   t hr ead   wi l l	have   an   event   handl er   f unc t i on   t hat   i s pas s ed
/ /   a   Wor ker Mes s age.	But   bec aus e   we' ve   c ar ef ul l y   def i ned   eac h   of t he
/ /   mes s age   t ypes   t o   have   a   mes s ageType   pr oper t y   wi t h   a   l i t er al t ype,
/ /   t he   event   handl er   c an   eas i l y   di s c r i mi nat e   among   t he   pos s i bl e mes s ages :
f unc t i on   handl eMes s ageFr omRet i c ul at or ( mes s age:	Wor ker Mes s age)    {
i f    ( mes s age. mes s ageType   ===   " r es ul t " )    {
/ /   Onl y   Res ul t Mes s age   has   a   mes s ageType   pr oper t y   wi t h


t hi s   val ue / /
her e.
/ / pr oper t y.


s o   Fl ow  knows

And   Fl ow  wi l l


t hat   i t   i s   s af e   t o   us e

c ompl ai n   i f    you   t r y   t o


mes s age. r es ul t

us e   any   ot her

c ons ol e. l og( mes s age. r es ul t ) ;
}    el s e   i f    ( mes s age. mes s ageType   ===   " er r or " )    {
/ /   Onl y   Er r or Mes s age   has   a   mes s ageType   pr oper t y   wi t h val ue   " er r or "
/ /   s o   knows   t hat   i t   i s   s af e   t o   us e   mes s age. er r or   her e. t hr ow  mes s age. er r or ;
}    el s e   i f    ( mes s age. mes s ageType   ===   " s t at s " )    {
/ /   Onl y   St at i s t i c s Mes s age   has   a   mes s ageType   pr oper t y wi t h   val ue   " s t at s "
/ /   s o   knows   t hat   i t   i s   s af e   t o   us e mes s age. s pl i nes Per Sec ond   her e.
c ons ol e. i nf o( mes s age. s pl i nes Per Sec ond) ;
} }


17.9 Summary

JavaScript is the most-used programming language in the world today. It is a living language—one that continues to evolve and improve—surrounded by a flourishing ecosystem of libraries, tools, and extensions. This chapter introduced some of those tools and extensions, but there are many more to learn about. The JavaScript ecosystem flourishes because the JavaScript developer community is active and vibrant, full of peers who share their knowledge through blog posts, videos, and conference presentations. As you close this book and go forth to join this community, you will find no shortage of information sources to keep you engaged with and learning about JavaScript.

Best wishes, David Flanagan, March 2020





1

If you have programmed with Java, you may have experienced something like this the first time you wrote a generic API that used a type parameter. I found the learning process for

Flow to be remarkably similar to what I went through in 2004 when generics were added to Java.



Index




SYMBOLS

! (Boolean NOT operator), Logical NOT (!)

!= (non-strict inequality operator)

relational expressions, Equality and Inequality Operators type conversions, Special case operator conversions
!== (inequality operator)

boolean values, Boolean Values

overview of, Equality and Inequality Operators string comparison, Working with Strings
" (double quotes), String Literals

$ (dollar sign), Identifiers and Reserved Words

% (modulo operator), Arithmetic in JavaScript, Arithmetic Expressions

& (bitwise AND operator), Bitwise Operators

&& (Boolean AND operator), Boolean Values, Logical AND (&&)

' (single quotes), String Literals

* (multiplication operator), Arithmetic in JavaScript, Expressions and Operators, Arithmetic Expressions

** (exponentiation operator), Arithmetic in JavaScript, Arithmetic Expressions

+ (plus sign)

addition and assignment operator (+=), Assignment with Operation

addition operator, Arithmetic in JavaScript, The + Operator

string concatenation, String Literals, Working with Strings, The + Operator

type conversions, Special case operator conversions

unary arithmetic operator, Unary Arithmetic Operators

++ (increment operator), Unary Arithmetic Operators

, (comma operator), The comma Operator (,)

- (minus sign)

subtraction operator, Arithmetic in JavaScript, Arithmetic Expressions

unary arithmetic operator, Unary Arithmetic Operators

-- (decrement operator), Unary Arithmetic Operators

. (dot operator), A Tour of JavaScript, Querying and Setting Properties

/ (division operator), Arithmetic in JavaScript, Arithmetic Expressions

/* */ characters, Comments

// (double slashes), A Tour of JavaScript, A Tour of JavaScript, Comments

3D graphics, Graphics in a <canvas>

; (semicolon), Optional Semicolons-Optional Semicolons

< (less than operator)

overview of, Comparison Operators string comparison, Working with Strings
type conversions, Special case operator conversions

<< (shift left operator), Bitwise Operators

<= (less than or equal to operator) overview of, Comparison Operators
string comparison, Working with Strings

type conversions, Special case operator conversions

= (assignment operator), A Tour of JavaScript, Equality and Inequality Operators, Assignment Expressions

== (equality operator)

overview of, Equality and Inequality Operators

type conversions, Overview and Definitions, Conversions and Equality, Special case operator conversions

=== (strict equality operator) boolean values, Boolean Values
overview of, Equality and Inequality Operators string comparison, Working with Strings
type conversions, Overview and Definitions, Conversions and Equality

=> (arrows), A Tour of JavaScript, Optional Semicolons, Arrow Functions

> (greater than operator)

overview of, Comparison Operators string comparison, Working with Strings
type conversions, Special case operator conversions

>= (greater than or equal to operator) overview of, Comparison Operators string comparison, Working with Strings

type conversions, Special case operator conversions

>> (shift right with sign operator), Bitwise Operators

>>> (shift right with zero fill operator), Bitwise Operators

?. (conditional access operator), A Tour of JavaScript, Function Invocation

?: (conditional operator), The Conditional Operator (?:)

?? (first-defined operator), First-Defined (??)

[] (square brackets), A Tour of JavaScript, Working with Strings, Object and Array Initializers, Querying and Setting Properties, Reading and Writing Array Elements, Strings as Arrays

\ (backslash), String Literals-Escape Sequences in String Literals

\n (newline), String Literals, Escape Sequences in String Literals

\u (Unicode character escape), Unicode Escape Sequences, Escape Sequences in String Literals

\xA9 (copyright symbol), Escape Sequences in String Literals

\` (backtick or apostrophe) escape, Escape Sequences in String Literals

^ (bitwise XOR operator), Bitwise Operators

_ (underscore), Identifiers and Reserved Words

_ (underscores, as numeric separators), Floating-Point Literals

` (backtick), String Literals, Template Literals

{} (curly braces), A Tour of JavaScript, Object and Array Initializers

|| (Boolean OR operator), Boolean Values, Logical OR (||)

~ (bitwise NOT operator), Bitwise Operators

ǀ (bitwise OR operator), Bitwise Operators

… (spread operator), Spread Operator, The Spread Operator, The Spread

Operator for Function Calls, Iterators and Generators


A

abstract classes, Class Hierarchies and Abstract Classes-Summary

accelerometers, Mobile Device APIs

accessor properties, Property Getters and Setters

addEventListener() method, addEventListener()

addition operator (+), Arithmetic in JavaScript, The + Operator

advanced features

object extensibility, Object Extensibility overview of, Metaprogramming
property attributes, Property Attributes-Property Attributes prototype attribute, The prototype Attribute
Proxy objects, Proxy Objects-Proxy Invariants Reflect API, The Reflect API-The Reflect API template tags, Template Tags-Template Tags well-known Symbols
pattern-matching symbols, Pattern-Matching Symbols Symbol.asyncIterator, Symbol.iterator and Symbol.asyncIterator Symbol.hasInstance, Symbol.hasInstance Symbol.isConcatSpreadable, Symbol.isConcatSpreadable Symbol.iterator, Well-Known Symbols
Symbol.species, Symbol.species-Symbol.species Symbol.toPrimitive, Symbol.toPrimitive

Symbol.toStringTag, Symbol.toStringTag

Symbol.unscopables, Symbol.unscopables

alphabetization, Comparing Strings

anchor characters, Specifying match position

apostrophes, String Literals

apply() method, Indirect Invocation, The call() and apply() Methods

arc() method, Curves

arcTo() method, Curves

arguments

argument types, Argument Types Arguments object, The Arguments Object definition of term, Functions
destructuring function arguments into parameters, Destructuring Function Arguments into Parameters-Destructuring Function Arguments into Parameters

variable-length argument lists, Rest Parameters and Variable-Length Argument Lists

arithmetic operators, A Tour of JavaScript, Arithmetic in JavaScript-Arithmetic in JavaScript, Arithmetic Expressions-Bitwise Operators

array index, Reading and Writing Array Elements

array iterator methods

every() and some(), every() and some() filter(), filter()
find() and findIndex(), find() and findIndex()

forEach(), forEach()

map(), map()

overview of, Array Iterator Methods

reduce() and reduceRight(), reduce() and reduceRight()

array literals, Object and Array Initializers, Array Literals

Array() constructor, The Array() Constructor

Array.from() function, Array.from(), Static Array Functions

Array.isArray() function, Static Array Functions

Array.of() function, Array.of(), Static Array Functions

Array.prototype, Arrays, Array-Like Objects

Array.sort() method, Functions as Values

arrayBuffer() method, Parsing response bodies

arrays

adding and deleting, Adding and Deleting Array Elements array length, Array Length
array methods

adding arrays, Adding arrays with concat()

array to string conversions, Array to String Conversions flattening arrays, Flattening arrays with flat() and flatMap() generic application of, Arrays
iterator methods, Array Iterator Methods-reduce() and reduceRight()

overview of, Array Methods

searching and sorting, Array Searching and Sorting Methods-reverse()

stacks and queues, Stacks and Queues with push(), pop(), shift(), and unshift()

static array functions, Static Array Functions

subarrays, Subarrays with slice(), splice(), fill(), and copyWithin()

array-like objects, Array-Like Objects-Array-Like Objects

associative arrays, Introduction to Objects, Objects As Associative Arrays

creating, Creating Arrays-Array.from()

definition of term, Overview and Definitions

initializer expressions, A Tour of JavaScript, Object and Array Initializers

iterating arrays, Iterating Arrays

multidimensional arrays, Multidimensional Arrays

nested, Object and Array Initializers

overview of, A Tour of JavaScript, Arrays

processing with functions, Processing Arrays with Functions

reading and writing array elements, Reading and Writing Array Elements

sparse arrays, Sparse Arrays

strings as arrays, Strings as Arrays

typed arrays

creating, Creating Typed Arrays

DataView and endianness, DataView and Endianness

methods and properties, Typed Array Methods and Properties

overview of, Typed Arrays and Binary Data

typed array types, Typed Array Types

using, Using Typed Arrays

arrow functions, A Tour of JavaScript, Defining Functions, Arrow Functions

arrows (=>), A Tour of JavaScript, Optional Semicolons, Arrow Functions

ASCII control characters, The Text of a JavaScript Program

assertions, A Tour of JavaScript

assignment operator (=), A Tour of JavaScript, Equality and Inequality Operators, Assignment Expressions

associative arrays, Introduction to Objects, Objects As Associative Arrays

associativity, Operator Associativity

async keyword, async and await-Implementation Details

asynchronous programming (see also Node)

async and await keywords, async and await-Implementation Details asynchronous iteration
asynchronous generators, Asynchronous Generators asynchronous iterators, Asynchronous Iterators
for/await loops, Asynchronous iteration with for/await, Asynchronous Iteration

implementation, Implementing Asynchronous Iterators-Implementing Asynchronous Iterators

callbacks

callbacks and events in Node, Callbacks and Events in Node definition of term, Asynchronous Programming with Callbacks events, Events
network events, Network Events timers, Timers
definition of term, Asynchronous JavaScript

JavaScript support for, Asynchronous JavaScript

Promises

chaining Promises, Chaining Promises-Chaining Promises

error handling with, Handling errors with Promises, More on Promises and Errors-The catch and finally methods

making Promises, Making Promises-Promises in Sequence

overview of, Promises

parallel operations, Promises in Parallel

Promises in sequence, Promises in Sequence-Promises in Sequence

resolving Promises, Resolving Promises-More on Promises and Errors

returning from Promise callbacks, The catch and finally methods

terminology, Handling errors with Promises

using, Using Promises-Handling errors with Promises

audio APIs

Audio() constructor, The Audio() Constructor

overview of, Audio APIs

WebAudio API, The WebAudio API

await keyword, async and await-Implementation Details

await operator, The await Operator


B

Babel, Transpilation with Babel

backend JavaScript, JavaScript in Web Browsers

backpressure, Writing to Streams and Handling Backpressure-Writing to Streams and Handling Backpressure

backslash (\), String Literals-Escape Sequences in String Literals

backtick (`), String Literals, Template Literals

bare catch clauses, try/catch/finally

bezierCurveTo() method, Curves

big-endian byte ordering, DataView and Endianness

BigInt type, Arbitrary Precision Integers with BigInt

binary data, processing, Typed Arrays and Binary Data-DataView and Endianness, Binary APIs (see also typed arrays)

binary integer literals, Integer Literals

binary operators, Number of Operands

bind() method, The bind() Method, Partial Application of Functions

bitwise operators, Bitwise Operators

blob() method, Parsing response bodies

block scoping, Variable and constant scope

blocking script execution, When scripts run: async and deferred

Boolean AND operator (&&), Boolean Values, Logical AND (&&)

Boolean NOT operator (!), Logical NOT (!)

Boolean OR operator (||), Boolean Values, Logical OR (||)

boolean values, Boolean Values-Boolean Values

Boolean() function, Explicit Conversions

break statements, break

browser development tools, Exploring JavaScript

browsing history

managing with hashchange events, History Management with hashchange Events

managing with pushState(), History Management with pushState()

overview of, Browsing History

structured clone algorithm, History Management with pushState()

Buffer class (Node), Buffers


C

Cache API, Progressive Web Apps and Service Workers

calendars, Formatting Dates and Times

call() method, Indirect Invocation, The call() and apply() Methods

callbacks

callbacks and events in Node, Callbacks and Events in Node definition of term, Asynchronous Programming with Callbacks events, Events

network events, Network Events

timers, Timers

Canvas API, Graphics in a <canvas>-Pixel Manipulation

canvas dimensions and coordinates, Canvas Dimensions and Coordinates

coordinate system transforms, Coordinate System Transforms-Transformation example

drawImage() function, Media APIs

drawing operations curves, Curves images, Images
rectangles, Rectangles text, Text
graphics attributes

colors, patterns, and gradients, Colors, patterns, and gradients line styles, Line styles
overview of, Graphics Attributes

saving and restoring graphics state, Saving and restoring graphics state

shadows, Shadows

text styles, Text styles

translucency and compositing, Translucency and compositing

overview of, Graphics in a <canvas>

paths and polygons, Paths and Polygons

pixel manipulation, Pixel Manipulation

case sensitivity, The Text of a JavaScript Program

catch clauses, try/catch/finally-Miscellaneous Statements

catch statements, Error Classes

.catch() method, The catch and finally methods-The catch and finally methods

character classes (regular expressions), Character classes

character frequency histograms, Example: Character Frequency Histograms-Summary

charAt() method, Strings as Arrays

checkscope() function, Closures

child processes (Node), Working with Child Processes-fork() benefits of, Working with Child Processes
exec() and execFile(), exec() and execFile()

execSync() and execFileSync(), execSync() and execFileSync() fork(), fork()
options, execSync() and execFileSync() spawn(), spawn()
class declaration, class

class keyword, Classes with the class Keyword-Example: A Complex Number Class

class methods, Static Methods

classes

adding methods to existing classes, Adding Methods to Existing

Classes

classes and constructors, Classes and Constructors-The constructor Property

constructor property, The constructor Property

constructors, class identity, and instanceof, Constructors, Class Identity, and instanceof

new.target expression, Classes and Constructors

classes and prototypes, Classes and Prototypes

classes with class keyword, Classes with the class Keyword-Example: A Complex Number Class

complex number class example, Example: A Complex Number Class-Example: A Complex Number Class

getters, setters, and other method forms, Getters, Setters, and other Method Forms

public private, and static fields, Public, Private, and Static Fields-Public, Private, and Static Fields

static methods, Static Methods

modular programming with, Modules with Classes, Objects, and Closures

naming, Reserved Words

overview of, Overview and Definitions, Classes

subclasses

class hierarchies and abstract classes, Class Hierarchies and Abstract Classes-Summary

delegation versus inheritance, Delegation Instead of Inheritance

overview of, Subclasses

subclasses and prototypes, Subclasses and Prototypes

with extends clause, Subclasses with extends and super-Subclasses with extends and super

client-side JavaScript, JavaScript in Web Browsers

client-side storage, Storage

clipping, Clipping

closest() method, Selecting elements with CSS selectors

closures

combining with property getters and setters, Closures common errors, Closures
definition of term, Closures lexical scoping rules and, Closures
modular programming with, Automating Closure-Based Modularity nested function closures, Closures
shared private state, Closures

code bundling, Code Bundling

code examples

comment syntax in, A Tour of JavaScript obtaining and using, Example Code
trying out JavaScript code, Exploring JavaScript

collation order, Comparing Strings

colors, Colors, patterns, and gradients

comma operator (,), The comma Operator (,)

comments

syntax for, A Tour of JavaScript, Comments syntax in code examples, A Tour of JavaScript
compare() method, Comparing Strings

comparison operators, Comparison Operators

compositing, Translucency and compositing

compound statements, Compound and Empty Statements

computed properties, Computed Property Names

concat() method, Adding arrays with concat()

conditional access operator (?.), A Tour of JavaScript, Function Invocation

conditional invocation, Conditional Invocation, Function Invocation

conditional operator (?:), The Conditional Operator (?:)

conditional statements, Statements, Conditionals-switch

configurable attribute, Introduction to Objects, Property Attributes

Console API

console.log() function, The Console API

formatted output with, Formatted Output with Console functions defined by, The Console API-The Console API support for, The Console API
console.log() function, Hello World, Console Output

const keyword, Declarations with let and const

constants

declaring, Overview and Definitions, Declarations with let and const,

const, let, and var

definition of term, Variable Declaration and Assignment

naming, Reserved Words

constructors

Array() constructor, The Array() Constructor Audio() constructor, The Audio() Constructor
classes and, Classes and Constructors-The constructor Property

constructor property, The constructor Property-The constructor Property

constructors, class identity, and instanceof, Constructors, Class Identity, and instanceof

new.target expression, Classes and Constructors

constructor invocation, Constructor Invocation

definition of term, Functions

examples of, Creating Objects with new

Function() constructor, The Function() Constructor

Set() constructor, The Set Class

Content-Security-Policy HTTP header, Security

continue statements, continue

control structures, A Tour of JavaScript-A Tour of JavaScript, Statements

cookies

API for manipulating, Cookies definition of term, Cookies
lifetime and scope attributes, Cookie attributes: lifetime and scope

limitations of, Cookie attributes: lifetime and scope

origin of name, Cookies

reading, Reading cookies

storing, Storing cookies

coordinate system transforms, Coordinate System Transforms-Transformation example

copyright symbol (\xA9), Escape Sequences in String Literals

copyWithin() method, copyWithin()

Credential Management API, Cryptography and Related APIs

Cross-Origin Resource Sharing (CORS), The same-origin policy, Cross-origin requests

cross-site scripting (XSS), Cross-site scripting

cryptography, Arbitrary Precision Integers with BigInt, Cryptography and Related APIs

CSS pixels, Document Coordinates and Viewport Coordinates

CSS stylesheets

common CSS styles, Scripting CSS computed styles, Computed Styles
CSS animations and events, CSS Animations and Events CSS classes, CSS Classes
CSS selector syntax, Selecting elements with CSS selectors inline styles, Inline Styles
naming conventions, Inline Styles scripting stylesheets, Scripting Stylesheets

CSSStyleDeclaration object, Inline Styles

curly braces ({}), A Tour of JavaScript, Object and Array Initializers

currency, Formatting Numbers

curves, Curves


D

data properties, Property Getters and Setters

DataView class, DataView and Endianness

Date type, Overview and Definitions, Dates and Times

dates and times

date arithmetic, Date Arithmetic

formatting and parsing date strings, Formatting and Parsing Date Strings

formatting for internationalization, Formatting Dates and Times-Formatting Dates and Times

high-resolution timestamps, Timestamps

overview of, Dates and Times, Dates and Times

timestamps, Timestamps

debugger statements, debugger

declarations class, class
const, let, and var, const, let, and var function, function
import and export, import and export

overview of, Declarations

decodeURI() function, Legacy URL Functions

decodeURIComponent() function, Legacy URL Functions

decrement operator (--), Unary Arithmetic Operators

delegation, Delegation Instead of Inheritance

delete operator, The delete Operator, Deleting Properties

denial-of-service attacks, Writing to Streams and Handling Backpressure

destructuring assignment, Destructuring Assignment-Destructuring Assignment, Destructuring Function Arguments into Parameters-Destructuring Function Arguments into Parameters

development tools, Exploring JavaScript

devicemotion event, Mobile Device APIs

deviceorientation event, Mobile Device APIs

devicePixelRatio property, Document Coordinates and Viewport Coordinates

dictionaries, Introduction to Objects, Objects As Associative Arrays

directories (Node), Working with Directories

distance() function, Function Declarations

division operator (/), Arithmetic in JavaScript, Arithmetic Expressions

do/while loops, do/while

document geometry and scrolling, Document Geometry and Scrolling-Viewport Size, Content Size, and Scroll Position

CSS pixels, Document Coordinates and Viewport Coordinates

determining element at a point, Determining the Element at a Point

document coordinates and viewport coordinates, Document Coordinates and Viewport Coordinates

querying geometry of elements, Querying the Geometry of an Element

scrolling, Scrolling

viewport size, content size, and scroll position, Viewport Size, Content Size, and Scroll Position

Document Object Model (DOM), The Document Object Model-Example: Generating a Table of Contents

document structure and traversal, Document Structure and Traversal

DocumentFragment nodes, Using Web Components

dynamically generating tables of contents, Example: Generating a Table of Contents

iframe elements, Document Coordinates and Viewport Coordinates

modifying content, Element content as HTML

modifying structure, Creating, Inserting, and Deleting Nodes

overview of, Scripting Documents

querying and setting attributes, Attributes

selecting document elements, Selecting Document Elements

shadow DOM, Shadow DOM-Shadow DOM API

DocumentFragment nodes, Using Web Components

documents, loading new, Loading New Documents

dollar sign ($), Identifiers and Reserved Words

DOMContentLoaded event, Execution of JavaScript Programs, Client-side JavaScript timeline

dot operator (.), A Tour of JavaScript, Querying and Setting Properties

double quotes ("), String Literals

double slashes (//), A Tour of JavaScript, A Tour of JavaScript, Comments

drawImage() function, Media APIs

drawing operations curves, Curves images, Images
rectangles, Rectangles text, Text
dynamic arrays, Arrays


E

ECMA402 standard, The Internationalization API

ECMAScript (ES), Introduction to JavaScript

elementFromPoint() method, Document Coordinates and Viewport Coordinates

elements

array elements

definition of term, Arrays

reading and writing, Reading and Writing Array Elements

document elements

custom elements, Custom Elements

determining element at a point, Determining the Element at a Point

iframe, Document Coordinates and Viewport Coordinates

querying geometry of elements, Querying the Geometry of an Element

selecting, Selecting Document Elements

ellipse() method, Curves

else if statements, else if

emojis, Unicode, Escape Sequences in String Literals

empty statements, Compound and Empty Statements

empty strings, Text

encodeURI() function, Legacy URL Functions

encodeURIComponent() function, Legacy URL Functions

English contractions, String Literals

enumerable attribute, Introduction to Objects, Property Attributes

equality operator (==)

overview of, Equality and Inequality Operators

type conversions, Overview and Definitions, Conversions and Equality, Special case operator conversions

equality operators, A Tour of JavaScript

Error classes, Error Classes

error handling

using Promises, Handling errors with Promises, More on Promises and Errors

web browser host environment, Program Errors

ES2016

exponentiation operator (**), Arithmetic in JavaScript, Arithmetic Expressions

includes() method, includes()

ES2017, async and await keywords, The await Operator, Asynchronous JavaScript, async and await-Implementation Details

ES2018

asynchronous iterator, Asynchronous iteration with for/await, Asynchronous Iteration

destructuring with rest parameters, Destructuring Function Arguments into Parameters

.finally() method, The catch and finally methods

regular expressions

lookbehind assertions, Specifying match position

named capture groups, Alternation, grouping, and references s flag, Flags
Unicode character classes, Character classes

spread operator (…), Spread Operator, Destructuring Function Arguments into Parameters, Iterators and Generators

ES2019

bare catch clauses, try/catch/finally

flattening arrays, Flattening arrays with flat() and flatMap()

ES2020

?? operator, First-Defined (??)

BigInt type, Arbitrary Precision Integers with BigInt BigInt64Array(), Typed Array Types

BigUint64Array(), Typed Array Types

conditional access operator (?.), A Tour of JavaScript, Property Access Errors, Function Invocation

conditional invocation, Conditional Invocation

globalThis, The Global Object

import() function, Dynamic Imports with import()

lastIndex and RegExp API, exec()

matchAll() method, matchAll(), exec(), Implementing Iterable Objects

operator precedence, Operator Precedence

Promise.allSettled(), Promises in Parallel

property access expressions, Conditional Property Access

ES5

apply() method, The call() and apply() Methods

breaking strings across multiple lines, String Literals, Escape Sequences in String Literals

bugs addressed by block-scoped variables, Closures

compatibility baseline, Introduction to JavaScript

Function.bind() method, The constructor Property

getters and setters, Property Getters and Setters

IE11 workaround, JavaScript Modules on the Web

transpilation with Babel, Transpilation with Babel

ES6

Array.of() function, Array.of()

arrow functions, Defining Functions, Arrow Functions

binary and octal integers, Integer Literals

built-in tag function, Tagged template literals

class declaration, class

class keyword, Classes with the class Keyword-Example: A Complex Number Class

computed properties, Computed Property Names

extended object literal syntax, Shorthand Properties

for/of loops, for/of-for/in

IE11 workaround, JavaScript Modules on the Web

iterable strings in, Text

iterating arrays, Iterating Arrays

Math object, Arithmetic in JavaScript

modules in

dynamic imports with import(), Dynamic Imports with import() exports, ES6 Exports
import.meta.url, import.meta.url imports, ES6 Imports-ES6 Imports
imports and exports with renaming, Imports and Exports with Renaming

JavaScript modules on the web, JavaScript Modules on the Web-JavaScript Modules on the Web

overview of, Modules in ES6

re-exports, Re-Exports

Promises

chaining Promises, Chaining Promises-Chaining Promises

error handling with, More on Promises and Errors-The catch and finally methods

making Promises, Making Promises-Promises in Sequence

overview of, Promises

parallel operations, Promises in Parallel

Promises in sequence, Promises in Sequence-Promises in Sequence

resolving Promises, Resolving Promises-More on Promises and Errors

returning from Promise callbacks, The catch and finally methods

using, Using Promises-Handling errors with Promises

property enumeration order, Property Enumeration Order

release of, Introduction to JavaScript

Set and Map classes, for/of with Set and Map

shorthand methods, Shorthand Methods

spread operator (…), The Spread Operator

strings delimited with backticks, String Literals, Template Literals

subclasses with extends clause, Subclasses with extends and super-Subclasses with extends and super

Symbol type, Overview and Definitions

symbols as property names, Symbols as Property Names

typed arrays, Arrays

variable declaration in, Variable Declaration and Assignment

yield* keyword, yield* and Recursive Generators

escape sequences

apostrophes, String Literals

in string literals, Escape Sequences in String Literals Unicode, Unicode Escape Sequences
escape() function, Legacy URL Functions

ESLint, Linting with ESLint

eval() function, Evaluation Expressions-Strict eval() global eval(), Global eval()
strict eval(), Strict eval()

evaluation expressions, Evaluation Expressions-Strict eval()

event listeners, Events, Events

event-driven programming model, Asynchronous JavaScript, Events-Dispatching Custom Events, Server-Sent Events

definition of term, Asynchronous JavaScript

dispatching custom events, Dispatching Custom Events

event cancellation, Event Cancellation

event categories, Event Categories

event handler invocation, Event Handler Invocation

event propagation, Event Propagation

overview of, Events

registering event handlers, Registering Event Handlers

server-sent events, Server-Sent Events

web platform features to investigate, Events

EventEmitter class, Events and EventEmitter

every() method, every() and some()

exceptions, throwing and catching, throw

exec() method, exec()

exponential notation, Floating-Point Literals

exponentiation operator (**), Arithmetic in JavaScript, Arithmetic Expressions

export declaration, import and export

export keyword, Modules in ES6

expression statements, Expression Statements

expressions

arithmetic expressions, Arithmetic Expressions-Bitwise Operators

assignment expressions, Assignment Expressions-Assignment with Operation

definition of term, Expressions and Operators

embedding within string literals, String Literals

evaluation expressions, Evaluation Expressions-Strict eval()

forming with operators, A Tour of JavaScript, Expressions and Operators

function definition expressions, Function Definition Expressions

function expressions, Function Expressions, Functions as Namespaces

initializer expression, A Tour of JavaScript, Object and Array Initializers

invocation expressions, Invocation Expressions-Conditional Invocation, Function Invocation-Constructor Invocation

logical expressions, Logical Expressions-Logical NOT (!)

new.target expression, Classes and Constructors

object and array initializers, Object and Array Initializers

object creation expressions, Object Creation Expressions

primary expressions, Primary Expressions

property access expressions, Property Access Expressions-Conditional Property Access

relational expressions, Relational Expressions-The instanceof Operator

versus statements, A Tour of JavaScript, Statements

extensibility, Object Extensibility


F

factorial() function, Function Declarations, Function Invocation

factory functions, Classes and Prototypes

falsy values, Boolean Values

fetch() function, Network Events

fetch() method

aborting requests, Aborting a request

cross-origin requests, Cross-origin requests examples of, fetch()

file upload, File upload with fetch()

HTTP status codes, response headers, and network errors, HTTP status codes, response headers, and network errors

miscellaneous request options, Miscellaneous request options

parsing response bodies, Parsing response bodies

setting request headers, Setting request headers

setting request parameters, Setting request parameters

specifying request method and request body, Specifying the request method and request body

steps of, fetch()

streaming response bodies, Streaming response bodies

fields, public, private, and static, Public, Private, and Static Fields

file handling (Node), Working with Files-Working with Directories directories, Working with Directories
file metadata, File Metadata file mode strings, Writing Files file operations, File Operations
overview of, Working with Files

paths, file descriptors, and FileHandles, Paths, File Descriptors, and FileHandles

reading files, Reading Files

writing files, Writing Files

fill() method, fill()

filter() method, filter()

.finally() method, The catch and finally methods-The catch and finally methods

financial account numbers, Storage

find() method, find() and findIndex()

findIndex() method, find() and findIndex()

Firefox Developer Tools, Exploring JavaScript

first-defined operator (??), First-Defined (??)

flat() method, Flattening arrays with flat() and flatMap()

flatMap() method, Flattening arrays with flat() and flatMap()

floating-point literals, Floating-Point Literals, Binary Floating-Point and Rounding Errors

Flow language extension, Type Checking with Flow-Enumerated Types and Discriminated Unions

array types, Array Types

class types, Class Types

enumerated types and discriminated unions, Enumerated Types and Discriminated Unions

function types, Function Types

installing and running, Installing and Running Flow

object types, Object Types

other parameterized types, Other Parameterized Types

overview of, Type Checking with Flow

read-only types, Read-Only Types

type aliases, Type Aliases

TypeScript versus Flow, Type Checking with Flow

union types, Union Types

using type annotations, Using Type Annotations

for loops, for, Iterating Arrays

for/await loops, Asynchronous iteration with for/await, Asynchronous Iteration

for/in loops, for/in, Enumerating Properties

for/of loops, Text, for/of-for/in, Iterating Arrays, Iterators and Generators

forEach() method, Iterating Arrays, forEach()

format() method, Formatting Numbers

fractions, Formatting Numbers

fromData() method, Parsing response bodies

front-end JavaScript, JavaScript in Web Browsers

fs module (Node), Working with Files-Working with Directories

function declaration, function

function expressions, Function Expressions, Functions as Namespaces

function keyword, Defining Functions

Function() constructor, The Function() Constructor

function* keyword, Generators

functions

arrow functions, A Tour of JavaScript, Defining Functions, Arrow Functions

case sensitivity, The Text of a JavaScript Program

closures, Closures-Closures

defining, Defining Functions-Nested Functions

defining your own function properties, Defining Your Own Function Properties

factory functions, Classes and Prototypes

function arguments and parameters argument types, Argument Types
arguments object, The Arguments Object

destructuring function arguments into parameters, Destructuring Function Arguments into Parameters-Destructuring Function Arguments into Parameters

optional parameters and defaults, Optional Parameters and Defaults

overview of, Function Arguments and Parameters

rest parameters, Rest Parameters and Variable-Length Argument Lists

spread operator for function calls, The Spread Operator for Function Calls

variable-length argument lists, Rest Parameters and Variable-Length Argument Lists

function definition expressions, Function Definition Expressions

function invocation, Creating Objects with new

function properties, methods, and constructor, Function Properties, Methods, and Constructor-The Function() Constructor

bind() method, The bind() Method

call() and apply() methods, The call() and apply() Methods

Function() constructor, The Function() Constructor

length property, The length Property

name property, The name Property

prototype property, The prototype Property

toString() method, The toString() Method

functional programming

exploring, Functional Programming

higher-order functions, Higher-Order Functions memoization, Memoization
partial application of functions, Partial Application of Functions

processing arrays with function, Processing Arrays with Functions

functions as namespaces, Functions as Namespaces

functions as values, Functions as Values-Defining Your Own Function Properties

invoking

approaches to, Invoking Functions

constructor invocation, Constructor Invocation examples, A Tour of JavaScript
implicit function invocation, Implicit Function Invocation indirect invocation, Indirect Invocation
invocation expressions, Function Invocation

method invocation, Method Invocation-Method Invocation

naming, Reserved Words

overview of, Overview and Definitions, Functions

recursive functions, Function Invocation

shorthand syntax for, A Tour of JavaScript

static array functions, Static Array Functions


G

garbage collection, Overview and Definitions

generator functions, Generators, The Return Value of a Generator Function (see also iterators and generators)

Geolocation API, Mobile Device APIs

getBoundingClientRect() method, Document Coordinates and Viewport Coordinates

getRandomValues() method, Cryptography and Related APIs

getter methods, Property Getters and Setters, Getters, Setters, and other Method Forms

global eval(), Global eval()

global object, The Global Object, The Global Object in Web Browsers

global variables, Variable and constant scope

gradients, Colors, patterns, and gradients

graphics

3D, Graphics in a <canvas>

Canvas API, Graphics in a <canvas>-Pixel Manipulation

canvas dimensions and coordinates, Canvas Dimensions and Coordinates

clipping, Clipping

coordinate system transforms, Coordinate System Transforms-

Transformation example

drawing operations, Canvas Drawing Operations

graphics attributes, Graphics Attributes

overview of, Graphics in a <canvas>

paths and polygons, Paths and Polygons

pixel manipulation, Pixel Manipulation

saving and restoring graphics state, Saving and restoring graphics state

scalable vector graphics (SVG), SVG: Scalable Vector Graphics-Creating SVG Images with JavaScript

greater than operator (>)

overview of, Comparison Operators string comparison, Working with Strings
type conversions, Special case operator conversions

greater than or equal to operator (>=) overview of, Comparison Operators string comparison, Working with Strings
type conversions, Special case operator conversions


H

hashchange events, History Management with hashchange Events

hashtables, Introduction to Objects, Objects As Associative Arrays

hasOwnProperty operator, Testing Properties

Hello World, Hello World, Console Output

hexadecimal literals, Integer Literals, Escape Sequences in String Literals

higher-order functions, Higher-Order Functions

histograms, character frequency, Example: Character Frequency Histograms-Summary

history.pushState() method, History Management with pushState()

history.replaceState() method, History Management with pushState()

hoisting, Variable Declarations with var

HTML <script> tags, JavaScript in HTML <script> Tags-Loading scripts on demand

import and export directives, Modules

loading scripts on demand, Loading scripts on demand

specifying script type, Specifying script type

synchronous script execution, When scripts run: async and deferred

text property, Element content as plain text

HTML <template> tag, HTML Templates

HTML code, single and double quotes in, String Literals

HTTP clients and servers, HTTP Clients and Servers-HTTP Clients and Servers


I

identifiers

case sensitivity, The Text of a JavaScript Program

purpose of, Identifiers and Reserved Words, Variable Declaration and Assignment

reserved words, Identifiers and Reserved Words, Primary Expressions

syntax for, Identifiers and Reserved Words

ideographs, Unicode

if statements, if-if

if/else statement, Boolean Values

images

drawing in Canvas, Images

pixel manipulation, Pixel Manipulation

immediately invoked function expression, Functions as Namespaces

immutability, Working with Strings, Immutable Primitive Values and Mutable Object References

implicit function invocation, Implicit Function Invocation

import declaration, import and export

import keyword, Modules in ES6

import() function, Dynamic Imports with import()

import.meta.url, import.meta.url

in operator, The in Operator, Testing Properties

includes() method, includes()

increment operator (++), Unary Arithmetic Operators

index position, Arrays, Reading and Writing Array Elements

IndexedDB, IndexedDB-Worker Threads and Messaging

indexOf() method, indexOf() and lastIndexOf()

indirect invocation, Indirect Invocation

inequality operator (!==)

boolean values, Boolean Values

overview of, Equality and Inequality Operators

string comparison, Working with Strings

infinity value, Arithmetic in JavaScript

inheritance, Introduction to Objects, Inheritance, Delegation Instead of Inheritance

initializer expression, A Tour of JavaScript, Object and Array Initializers

instance methods, Static Methods

instanceof operator, The instanceof Operator, Constructors, Class Identity, and instanceof

integer literals, Integer Literals

internationalization API

classes included in, The Internationalization API comparing strings, Comparing Strings-Comparing Strings
formatting dates and times, Formatting Dates and Times-Formatting Dates and Times

formatting numbers, Formatting Numbers-Formatting Numbers

support for in Node, The Internationalization API

translated text, The Internationalization API

interpolation, String Literals

Intl.DateTimeFormat class, Formatting Dates and Times-Formatting Dates and Times

Intl.NumberFormat class, Formatting Numbers-Formatting Numbers

invocation expressions

conditional invocation, Conditional Invocation, Function Invocation

method invocation, Invocation Expressions, Method Invocation

overview of, Function Invocation

isFinite() function, Arithmetic in JavaScript

isNaN() function, Arithmetic in JavaScript

iterators and generators (see also array iterator methods) advanced generator features
return value of generator functions, The Return Value of a Generator Function

return() and throw() methods, The return() and throw() Methods of a Generator

value of yield expressions, The Value of a yield Expression

asynchronous, Asynchronous Iterators-Implementing Asynchronous Iterators

closing iterators, “Closing” an Iterator: The Return Method

generators

benefits of, A Final Note About Generators creating, Generators
definition of term, Generators examples of, Generator Examples
yield* and recursive generators, yield* and Recursive Generators

how iterators work, How Iterators Work

implementing iterable objects, Implementing Iterable Objects-Implementing Iterable Objects

overview of, Iterators and Generators


J

JavaScript

benefits of, Introduction to JavaScript, Summary introduction to
chapter overviews, A Tour of JavaScript, A Tour of JavaScript

character frequency histograms, Example: Character Frequency Histograms-Summary

Hello World, Hello World

history of, JavaScript in Web Browsers

JavaScript interpreters, Exploring JavaScript

lexical structure, Lexical Structure-Summary

names, versions, and modes, Introduction to JavaScript

syntax and capabilities, A Tour of JavaScript-A Tour of JavaScript

reference documentation, Preface

JavaScript standard library

Console API, The Console API-Formatted Output with Console

dates and times, Dates and Times-Formatting and Parsing Date Strings

error classes, Error Classes-Error Classes

internationalization API, The Internationalization API-Comparing Strings

JSON serialization and parsing, JSON Serialization and Parsing-

JSON Customizations

overview of, The JavaScript Standard Library

pattern matching, Pattern Matching with Regular Expressions-exec()

sets and maps, Sets and Maps-WeakMap and WeakSet

timers, Timers-Timers

typed arrays and binary data, Typed Arrays and Binary Data-DataView and Endianness

URL APIs, URL APIs-Legacy URL Functions

Jest, Unit Testing with Jest

join() method, Array to String Conversions

JSON serialization and parsing, JSON Serialization and Parsing-JSON Customizations

JSON.parse() function, Serializing Objects, JSON Serialization and Parsing

JSON.stringify() function, Serializing Objects, The toJSON() Method, JSON Serialization and Parsing

JSX language extension, JSX: Markup Expressions in JavaScript-JSX: Markup Expressions in JavaScript

jump statements, Statements, Jumps-try/catch/finally break statements, break
continue statements, continue definition of term, Statements
labeled statements, Labeled Statements overview of, Jumps
return statements, return


K

keywords

async keyword, async and await-Implementation Details await keyword, async and await-Implementation Details case sensitivity, The Text of a JavaScript Program
class keyword, Classes with the class Keyword-Example: A Complex Number Class

const keyword, Declarations with let and const

export keyword, Modules in ES6

function keyword, Defining Functions

function* keyword, Generators

import keyword, Modules in ES6

let keyword, A Tour of JavaScript, Declarations with let and const, const, let, and var

new keyword, Creating Objects with new, Constructor Invocation

reserved words, Reserved Words, Primary Expressions

this keyword, A Tour of JavaScript, Primary Expressions, Function Invocation

var keyword, Variable Declarations with var, const, let, and var

yield* keyword, yield* and Recursive Generators

Koch snowflakes, Transformation example


L

labeled statements, Labeled Statements

lastIndex property, exec()

lastIndexOf() method, indexOf() and lastIndexOf()

less than operator (<)

overview of, Comparison Operators string comparison, Working with Strings
type conversions, Special case operator conversions

less than or equal to operator (<=) overview of, Comparison Operators
string comparison, Working with Strings

type conversions, Special case operator conversions

let keyword, A Tour of JavaScript, Declarations with let and const, const, let, and var

lexical scoping, Closures

lexical structure, Lexical Structure-Summary

case sensitivity, The Text of a JavaScript Program comments, Comments
identifiers, The Text of a JavaScript Program-Identifiers and Reserved Words

line breaks, The Text of a JavaScript Program

literals, Literals

reserved words, Reserved Words, Primary Expressions

semicolons, Optional Semicolons-Optional Semicolons

spaces, The Text of a JavaScript Program

Unicode character set

escape sequences, Unicode Escape Sequences

normalization, Unicode Normalization

overview of, Unicode

line breaks, The Text of a JavaScript Program, Optional Semicolons-Optional Semicolons

line styles, Line styles

line terminators, The Text of a JavaScript Program

linting tools, Linting with ESLint

literals numeric
floating-point literals, Floating-Point Literals, Binary Floating-Point and Rounding Errors

integer literals, Integer Literals

negative numbers, Numbers

separators in, Floating-Point Literals

regular expressions, Pattern Matching, Pattern Matching with Regular Expressions

string, String Literals

template literals, Template Literals, Template Tags

little-endian architecture, DataView and Endianness

load event, Execution of JavaScript Programs

localStorage property, localStorage and sessionStorage

location property, Location, Navigation, and History

logical operators, A Tour of JavaScript, Logical Expressions-Logical NOT

(!)

lookbehind assertions, Specifying match position

looping statements

do/while loops, do/while

for loops, for, Iterating Arrays

for/await loops, Asynchronous iteration with for/await, Asynchronous Iteration

for/in loops, for/in, Enumerating Properties

for/of loops, for/of-for/in, Iterating Arrays, Iterators and Generators

purpose of, Statements

while loops, while

lvalue, Operand and Result Type


M

magnetometers, Mobile Device APIs

Mandelbrot set, Example: The Mandelbrot Set-Summary and Suggestions for Further Reading

Map class, for/of with Set and Map, The Map Class-The Map Class

Map objects, Overview and Definitions, The Map Class

map() method, map()

marshaling, JSON Serialization and Parsing

match() method, match()

matchAll() method, matchAll()

matches() method, Selecting elements with CSS selectors

Math.pow function, Arithmetic Expressions

mathematical operations, Arithmetic in JavaScript-Arithmetic in JavaScript

MDN website, Preface

media APIs, Media APIs

memoization, Memoization

memory management, Overview and Definitions

message events, Client-side JavaScript threading model, Events, Server-Sent Events, Worker Objects-The Global Object in Workers, Worker Execution Model-postMessage(), MessagePorts, and MessageChannels, Cross-Origin Messaging with postMessage(), fork()-Worker Threads, Communication Channels and MessagePorts, Enumerated Types and Discriminated Unions

MessageChannels, postMessage(), MessagePorts, and MessageChannels

MessagePort objects, postMessage(), MessagePorts, and MessageChannels, Communication Channels and MessagePorts

messaging WebSocket API
receiving messages, Receiving messages from a WebSocket sending messages, Sending messages over a WebSocket
worker threads and messaging, Worker Threads and Messaging-Cross-Origin Messaging with postMessage()

cross-origin messaging, Cross-Origin Messaging with postMessage(), Cross-Origin Messaging with postMessage()

execution model, Worker Execution Model

importing code, Importing Code into a Worker

Mandelbrot set example, Example: The Mandelbrot Set-Summary and Suggestions for Further Reading

modules, Importing Code into a Worker

overview of, Worker Threads and Messaging

postMessage(), MessagePorts and MessageChannels, postMessage(), MessagePorts, and MessageChannels

Worker objects, Worker Objects

WorkerGlobalScope object, The Global Object in Workers

metaprogramming, Metaprogramming

methods

adding methods to existing classes, Adding Methods to Existing Classes

array methods

generic application of, Arrays overview of, Array Methods
class versus instance methods, Static Methods

creating, A Tour of JavaScript

definition of term, Functions, Method Invocation

method chaining, Method Invocation

method invocation, Invocation Expressions, Method Invocation-Method Invocation

shorthand methods, Getters, Setters, and other Method Forms

shorthand syntax, Shorthand Methods

static methods, Static Methods

typed array methods, Typed Array Methods and Properties

minus sign (-)

subtraction operator, Arithmetic in JavaScript, Arithmetic Expressions

unary arithmetic operator, Unary Arithmetic Operators

mobile device APIs, Mobile Device APIs

modules

automating closure-based modularity, Automating Closure-Based Modularity

in ES6

dynamic imports with import(), Dynamic Imports with import() exports, ES6 Exports
import.meta.url, import.meta.url imports, ES6 Imports-ES6 Imports
imports and exports with renaming, Imports and Exports with Renaming

JavaScript modules on the web, JavaScript Modules on the Web-JavaScript Modules on the Web

overview of, Modules in ES6

re-exports, Re-Exports

fs module (Node), Working with Files-Working with Directories

import and export directives, Modules

in Node, Modules in Node-Node-Style Modules on the Web, Node Modules

Node exports, Node Exports

Node imports, Node Imports

Node-style modules on the web, Node-Style Modules on the Web

overview of, Modules

purpose of, Modules

using in workers, Importing Code into a Worker

with classes, objects, and closures, Modules with Classes, Objects, and Closures-Automating Closure-Based Modularity

modulo operator (%), Arithmetic in JavaScript, Arithmetic Expressions

multiplication operator (*), Arithmetic in JavaScript, Expressions and Operators, Arithmetic Expressions

multithreaded programming, Node Is Asynchronous by Default, Worker Threads

mutability, Overview and Definitions, Introduction to Objects


N

named capture groups, Alternation, grouping, and references

NaN (not-a-number value), Arithmetic in JavaScript

navigator.mediaDevices.getUserMedia() function, Media APIs

navigator.vibrate() method, Mobile Device APIs

negative infinity value, Arithmetic in JavaScript

negative zero, Arithmetic in JavaScript

nested functions, Nested Functions

network events, Network Events

networking, Networking-Protocol negotiation

fetch() method

aborting requests, Aborting a request

cross-origin requests, Cross-origin requests examples of, fetch()
file upload, File upload with fetch()

HTTP status codes, response headers, and network errors, HTTP status codes, response headers, and network errors

miscellaneous request options, Miscellaneous request options

parsing response bodies, Parsing response bodies

setting request headers, Setting request headers

setting request parameters, Setting request parameters

specifying request method and request body, Specifying the request method and request body

steps of, fetch()

streaming response bodies, Streaming response bodies

overview of, Networking

server-sent events, Server-Sent Events

WebSocket API, WebSockets

XMLHttpRequest API (XHR), fetch()

new keyword, Creating Objects with new, Constructor Invocation

new.target expression, Classes and Constructors

newline (\n), String Literals, Escape Sequences in String Literals

newlines, Optional Semicolons-Optional Semicolons

using for code formatting, The Text of a JavaScript Program

Node

asynchronous iteration in, The for/await Loop, Node Is Asynchronous by Default-Node Is Asynchronous by Default

benefits of, Introduction to JavaScript, Server-Side JavaScript with Node

BigInt type, Arbitrary Precision Integers with BigInt

buffers, Buffers

callbacks and events in, Callbacks and Events in Node

child processes, Working with Child Processes-fork()

defining feature of, Server-Side JavaScript with Node

events and EventEmitter, Events and EventEmitter

file handling, Working with Files-Working with Directories directories, Working with Directories
file metadata, File Metadata file mode strings, Writing Files file operations, File Operations
overview of, Working with Files

paths, file descriptors, and FileHandles, Paths, File Descriptors, and FileHandles

reading files, Reading Files

writing files, Writing Files

HTTP clients and servers, HTTP Clients and Servers-HTTP Clients and Servers

installing, Exploring JavaScript, Server-Side JavaScript with Node

Intl API, The Internationalization API

modules in, Modules in Node-Node-Style Modules on the Web

non-HTTP network servers and clients, Non-HTTP Network Servers and Clients

parallelism with, Node Is Asynchronous by Default

process details, Process, CPU, and Operating System Details

programming basics, Node Programming Basics-The Node Package Manager

command-line arguments, Command-Line Arguments and Environment Variables

console output, Console Output

environment variables, Command-Line Arguments and Environment Variables

modules, Node Modules

package manager, The Node Package Manager

program life cycle, Program Life Cycle

reference documentation, Preface

streams, Streams-Paused mode

asynchronous iteration in, Asynchronous Iteration overview of, Streams
pipes, Pipes

reading with events, Reading Streams with Events types of, Streams
writing to and handling backpressure, Writing to Streams and Handling Backpressure

worker threads, Worker Threads-Sharing Typed Arrays Between Threads

communication channels and MessagePorts, Communication Channels and MessagePorts

creating workers and passing messages, Creating Workers and Passing Messages

overview of, Worker Threads

sharing typed arrays between threads, Sharing Typed Arrays Between Threads

transferring MessagePorts and typed arrays, Transferring MessagePorts and Typed Arrays

worker execution environment, The Worker Execution Environment

NodeLists, Selecting elements with CSS selectors

non-inherited properties, Introduction to Objects

non-strict inequality operator (!=)

relational expressions, Equality and Inequality Operators type conversions, Special case operator conversions
normalization, Unicode Normalization

not-a-number value (NaN), Arithmetic in JavaScript

Notifications API, Progressive Web Apps and Service Workers

npm package manager, Package Management with npm

null values, null and undefined

nullish coalescing operator (??), First-Defined (??)

Number type

64-bit floating-point format, Numbers

arbitrary precision integers with BigInt, Arbitrary Precision Integers with BigInt

arithmetic and complex math, Arithmetic in JavaScript-Arithmetic in JavaScript

binary floating-point and rounding errors, Binary Floating-Point and Rounding Errors

dates and times, Dates and Times

floating-point literals, Floating-Point Literals

integer literals, Integer Literals

separators in numeric literals, Floating-Point Literals

Number() function, Explicit Conversions, Explicit Conversions

Number.isFinite() function, Arithmetic in JavaScript

numbers, formatting for internationalization, Formatting Numbers-Formatting Numbers

numeric literals, Numbers


O

object literals

extended syntax for, Extended Object Literal Syntax-Property Getters and Setters

overview of, Object and Array Initializers

simplest form of, Object Literals

object property names, Reading and Writing Array Elements

object-oriented programming

definition of term, Overview and Definitions

example of, A Tour of JavaScript

Object.assign() function, Extending Objects

Object.create() function, Object.create(), Property Attributes

Object.defineProperties() method, Property Attributes

Object.defineProperty() method, Property Attributes

Object.entries() method, for/of with objects

Object.getOwnPropertyNames() function, Enumerating Properties

Object.getOwnPropertySymbols() function, Enumerating Properties

Object.keys method, for/of with objects

Object.keys() function, Enumerating Properties

Object.prototype, Prototypes, Object Methods

objects

Arguments object, The Arguments Object

array-like objects, Array-Like Objects-Array-Like Objects creating, Creating Objects-Object.create()
deleting properties, Deleting Properties enumerating properties, Enumerating Properties
extended object literal syntax, Extended Object Literal Syntax-Property Getters and Setters

extending objects, Extending Objects

implementing iterable objects, Implementing Iterable Objects-Implementing Iterable Objects

introduction to, Objects

modular programming with, Modules with Classes, Objects, and Closures

mutable object references, Immutable Primitive Values and Mutable Object References, Introduction to Objects

naming properties within, Reserved Words

object creation expressions, Object Creation Expressions

object extensibility, Object Extensibility

object methods, Object Methods-The toJSON() Method

overview of, A Tour of JavaScript, Overview and Definitions-Overview and Definitions

querying and setting properties, Querying and Setting Properties-Property Access Errors

serializing objects, Serializing Objects

testing properties, Testing Properties

onmessage event, Receiving messages from a WebSocket, Worker
Objects-The Global Object in Workers, postMessage(), MessagePorts, and MessageChannels, Cross-Origin Messaging with postMessage()

operators

arithmetic operators, A Tour of JavaScript, Arithmetic in JavaScript-Arithmetic in JavaScript, Arithmetic Expressions-Bitwise Operators

assignment operators, Assignment Expressions-Assignment with Operation

binary operators, Number of Operands

comparison operators, Comparison Operators

equality and inequality operators, Equality and Inequality Operators

equality operators, A Tour of JavaScript

forming expressions with, A Tour of JavaScript, Expressions and Operators

logical operators, A Tour of JavaScript, Logical Expressions-Logical NOT (!)

miscellaneous operators

await operator, The await Operator

comma operator (,), The comma Operator (,) conditional operator (?:), The Conditional Operator (?:) delete operator, The delete Operator
first-defined operator (??), First-Defined (??) typeof operator, The typeof Operator
void operator, The void Operator

number of operands, Number of Operands

operand and result type, Operand and Result Type

operator associativity, Operator Associativity

operator precedence, Operator Precedence

operator side effects, Operator Side Effects

order of evaluation, Order of Evaluation

overview of, Operator Overview

postfix operators, Optional Semicolons

relational operators, A Tour of JavaScript, Relational Expressions-The instanceof Operator

table of, Operator Overview

ternary operators, Number of Operands

optional semicolons, Optional Semicolons-Optional Semicolons

overflow, Arithmetic in JavaScript

own properties, Introduction to Objects, Inheritance


P

package manager (Node), The Node Package Manager, Package Management with npm

parallelization, Node Is Asynchronous by Default

parameterization, Functions

parseFloat() function, Explicit Conversions

parseInt() function, Explicit Conversions

passwords, Storage

paths, Paths and Polygons-Paths and Polygons

pattern matching

defining regular expressions

alternation, grouping, and references, Alternation, grouping, and references

character classes, Character classes

flags, Flags

literal characters, Literal characters

lookbehind assertions, Specifying match position

named group captures, Alternation, grouping, and references

non-greedy repetition, Non-greedy repetition

pattern specifications, Defining Regular Expressions

repetition characters, Repetition

specifying match position, Specifying match position

Unicode character classes, Character classes

overview of, Pattern Matching with Regular Expressions

pattern-matching symbols, Pattern-Matching Symbols

RegExp class

exec() method, exec()

lastIndex property and RegExp reuse, exec() overview of, The RegExp Class
RegExp properties, RegExp properties test() method, test()
string methods for match(), match()
matchAll(), matchAll() replace(), replace()
search(), String Methods for Pattern Matching split(), split()
syntax for, Pattern Matching

patterns, Colors, patterns, and gradients

Payment Request API, Cryptography and Related APIs

Performance APIs, Performance

pickling, JSON Serialization and Parsing

pixels, Document Coordinates and Viewport Coordinates, Pixel

Manipulation

plus sign (+)

addition and assignment operator (+=), Assignment with Operation addition operator, Arithmetic in JavaScript, The + Operator
string concatenation, String Literals, Working with Strings, The + Operator

type conversions, Special case operator conversions

unary arithmetic operator, Unary Arithmetic Operators

polygons, Paths and Polygons-Paths and Polygons

pop() method, Stacks and Queues with push(), pop(), shift(), and unshift()

popstate event, Event Categories, History Management with pushState()-Networking

positive zero, Arithmetic in JavaScript

possessives, String Literals

postfix operators, Optional Semicolons

postMessage() method, postMessage(), MessagePorts, and MessageChannels

Prettier, JavaScript Formatting with Prettier

primary expressions, Primary Expressions

primitive types

Boolean truth values, Boolean Values-Boolean Values

immutable primitive values, Immutable Primitive Values and Mutable Object References

Number type, Numbers-Dates and Times

overview and definitions, Overview and Definitions

String type, Text-Tagged template literals

printprops() function, Function Declarations

private fields, Public, Private, and Static Fields

procedures, Functions

programs

error handling, Program Errors

execution of JavaScript, Execution of JavaScript Programs-Client-side JavaScript timeline

client-side threading model, Client-side JavaScript threading model

client-side timeline, Client-side JavaScript timeline

input and output, Program Input and Output

Progressive Web Apps (PWAs), Progressive Web Apps and Service Workers

Promise chains, Promises, Chaining Promises-Chaining Promises

Promise.all() function, Promises in Parallel

Promises

chaining Promises, Chaining Promises-Chaining Promises

error handling with, Handling errors with Promises, More on Promises and Errors-The catch and finally methods

making Promises, Making Promises-Promises in Sequence based on other Promises, Promises based on other Promises
based on synchronous values, Promises based on synchronous values

from scratch, Promises from scratch

overview of, Promises

parallel operations, Promises in Parallel

Promises in sequence, Promises in Sequence-Promises in Sequence

resolving Promises, Resolving Promises-More on Promises and Errors

returning from Promise callbacks, The catch and finally methods

terminology, Handling errors with Promises

using, Using Promises-Handling errors with Promises

properties

computed property names, Computed Property Names conditional property access, Conditional Property Access copying from one object to another, Extending Objects
defining your own function properties, Defining Your Own Function Properties

definition of term, Overview and Definitions

deleting, Deleting Properties

enumerating properties, Enumerating Properties

inheriting, Inheritance

naming, Symbols, Introduction to Objects, Symbols as Property Names

non-inherited properties, Introduction to Objects

property access errors, Property Access Errors

property access expressions, Property Access Expressions

property attributes, Introduction to Objects, Property Attributes-Property Attributes

property descriptors, Property Attributes

property getters and setters, Property Getters and Setters

querying and setting, Querying and Setting Properties-Property Access Errors

testing, Testing Properties

typed array properties, Typed Array Methods and Properties

propertyIsEnumerable() method, Testing Properties

prototypal inheritance, Introduction to Objects, Inheritance

prototype chains, Prototypes

prototypes, Prototypes, Inheritance, The prototype Property, Classes and Prototypes, The prototype Attribute

proxy invariants, Proxy Invariants

Proxy objects, Proxy Objects-Proxy Invariants

pseudorandom numbers, Cryptography and Related APIs

public fields, Public, Private, and Static Fields

Push API, Progressive Web Apps and Service Workers

push() method, A Tour of JavaScript, Stacks and Queues with push(), pop(), shift(), and unshift()


Q

quadraticCurveTo() method, Curves

querySelector() method, Selecting elements with CSS selectors

querySelectorAll() method, Selecting elements with CSS selectors

quote marks

double quotes ("), String Literals single quotes ('), String Literals

R

React, JSX: Markup Expressions in JavaScript

rectangles, Rectangles

recursive functions, Function Invocation

recursive generators, yield* and Recursive Generators

reduce() method, reduce() and reduceRight()

reduceRight() method, reduce() and reduceRight()

reference types, Immutable Primitive Values and Mutable Object References

Reflect API, The Reflect API-The Reflect API

Reflect.ownKeys() function, Enumerating Properties

RegExp class

exec() method, exec()

lastIndex property and RegExp reuse, exec() overview of, The RegExp Class
RegExp properties, RegExp properties test() method, test()
RegExp type, Overview and Definitions, Pattern Matching, Pattern Matching with Regular Expressions (see also pattern matching)

regular expressions, Pattern Matching with Regular Expressions

(see also pattern matching)

relational expressions, Relational Expressions-The instanceof Operator

relational operators, A Tour of JavaScript

replace() method, Working with Strings

require() function, Node Imports

reserved words, Reserved Words, Primary Expressions

rest parameters, Rest Parameters and Variable-Length Argument Lists

return statements, return

return values, Functions

return() method, “Closing” an Iterator: The Return Method, The return() and throw() Methods of a Generator

reverse() method, A Tour of JavaScript, reverse()

rounding errors, Binary Floating-Point and Rounding Errors


S

same-origin policy, The same-origin policy

scalable vector graphics (SVG), SVG: Scalable Vector Graphics-Creating SVG Images with JavaScript

creating SVG images with JavaScript, Creating SVG Images with JavaScript

overview of, SVG: Scalable Vector Graphics

scripting SVG, Scripting SVG

SVG in HTML, SVG in HTML

ScreenOrientation API, Mobile Device APIs

scroll offsets, Document Coordinates and Viewport Coordinates

scrolling, Scrolling

scrollTo() method, Scrolling

search() method, String Methods for Pattern Matching

security

client-side storage, Storage

competing goals of web programming, The Web Security Model

Cross-Origin Resource Sharing (CORS), The same-origin policy, Cross-origin requests

cross-site scripting (XSS), Cross-site scripting

cryptography APIs, Cryptography and Related APIs

defense against malicious code, What JavaScript can’t do

denial-of-service attacks, Writing to Streams and Handling Backpressure

same-origin policy, The same-origin policy

web platform features to investigate, Security

semicolon (;), Optional Semicolons-Optional Semicolons

sensitive information, Storage

Sensor API, Mobile Device APIs

serialization, Serializing Objects, JSON Serialization and Parsing, History Management with pushState()

server-sent events, Server-Sent Events-Server-Sent Events

server-side JavaScript, JavaScript in Web Browsers, Server-Side JavaScript with Node

ServiceWorkers, Progressive Web Apps and Service Workers

sessionStorage property, localStorage and sessionStorage

Set class, for/of with Set and Map, The Set Class-The Set Class

Set objects, Overview and Definitions

Set() constructor, The Set Class

setInterval() function, Timers

sets and maps

definition of sets, The Set Class

Map class, The Map Class-The Map Class overview of, Sets and Maps
Set class, The Set Class-The Set Class

WeakMap and WeakSet classes, WeakMap and WeakSet

setter methods, Property Getters and Setters, Getters, Setters, and other Method Forms

setTimeout() function, Timers, Timers

setTransform() method, Coordinate System Transforms

shadow DOM, Shadow DOM-Shadow DOM API

shadows, Shadows

shift left operator (<<), Bitwise Operators

shift right with sign operator (>>), Bitwise Operators

shift right with zero fill operator (>>>), Bitwise Operators

shift() method, Stacks and Queues with push(), pop(), shift(), and unshift()

shorthand methods, Shorthand Methods, Getters, Setters, and other Method Forms

side effects, Operator Side Effects

single quotes ('), String Literals

slice() method, slice()

some() method, every() and some()

sort order, Comparing Strings

sort() method, Conditional Invocation, sort()

sparse arrays, Arrays, Sparse Arrays

splice() method, splice()

split() method, split()

spread operator (…), Spread Operator, The Spread Operator, The Spread Operator for Function Calls, Iterators and Generators

square brackets ([]), A Tour of JavaScript, Working with Strings, Object and Array Initializers, Querying and Setting Properties, Reading and Writing Array Elements, Strings as Arrays

standard library (see JavaScript standard library)

statement blocks, Compound and Empty Statements

statements (see also declarations)

compound and empty statements, Compound and Empty Statements conditional statements, Statements, Conditionals-switch
control structures, A Tour of JavaScript-A Tour of JavaScript, Statements

expression statements, Expression Statements

versus expressions, A Tour of JavaScript

if/else statement, Boolean Values

jump statements, Statements, Jumps-try/catch/finally

line breaks and, Optional Semicolons-Optional Semicolons

list of, Summary of JavaScript Statements

loops, Statements, Loops-for/in

miscellaneous statements

debugger statements, debugger use strict directive, “use strict”
with statements, Miscellaneous Statements

overview of, Statements

separating with semicolons, Optional Semicolons-Optional Semicolons

throw statements, throw

try/catch/finally statements, try/catch/finally-try/catch/finally

yield statements, yield, The Value of a yield Expression

static fields, Public, Private, and Static Fields

static methods, Static Methods

storage, Storage-IndexedDB cookies, Cookies IndexedDB, IndexedDB
localStorage and sessionStorage, localStorage and sessionStorage overview of, Storage
security and privacy, Storage

streams (Node), Streams-Paused mode

asynchronous iteration in, Asynchronous Iteration

overview of, Streams

pipes, Pipes

reading with events, Reading Streams with Events

types of, Streams

writing to and handling backpressure, Writing to Streams and Handling Backpressure

strict equality operator (===) boolean values, Boolean Values
overview of, Equality and Inequality Operators string comparison, Working with Strings
type conversions, Overview and Definitions, Conversions and Equality

strict mode

default application of, Classes with the class Keyword, Modules in ES6, JavaScript Modules on the Web

delete operator and, The delete Operator

deleting properties, Deleting Properties

eval() function, Strict eval()

function declarations, Function Declarations

function invocation, Function Invocation

versus non-strict mode, “use strict”-“use strict”

opting into, Introduction to JavaScript

TypeError, Property Access Errors, Object Extensibility

undeclared variables and, Variable Declarations with var

with statement and, with, Setting event handler attributes

string literals

escape sequences in, Escape Sequences in String Literals overview of, String Literals
String() function, Explicit Conversions

String.raw() function, Tagged template literals

strings

array to string conversions, Array to String Conversions characters and codepoints, Text
methods for pattern matching match(), match() matchAll(), matchAll() replace(), replace()
search(), String Methods for Pattern Matching split(), split()
overview of, Text

string literals, String Literals

strings as arrays, Strings as Arrays

working with

accessing individual characters, Working with Strings API for, Working with Strings
comparing, Working with Strings, Comparing Strings

concatenation, Working with Strings

determining length, Working with Strings

immutability, Working with Strings

structured clone algorithm, History Management with pushState()

subarrays, Subarrays with slice(), splice(), fill(), and copyWithin()

subclasses

class hierarchies and abstract classes, Class Hierarchies and Abstract Classes-Summary

delegation versus inheritance, Delegation Instead of Inheritance

overview of, Subclasses

prototypes and, Subclasses and Prototypes

with extends clause, Subclasses with extends and super-Subclasses with extends and super

subroutines, Functions

subtraction operator (-), Arithmetic in JavaScript

surrogate pairs, Text

SVG (see scalable vector graphics (SVG))

switch statements, switch-switch

Symbol.asyncIterator, Symbol.iterator and Symbol.asyncIterator

Symbol.hasInstance, Symbol.hasInstance

Symbol.isConcatSpreadable, Symbol.isConcatSpreadable

Symbol.iterator, Well-Known Symbols

Symbol.species, Symbol.species-Symbol.species

Symbol.toPrimitive, Symbol.toPrimitive

Symbol.toStringTag, Symbol.toStringTag

Symbol.unscopables, Symbol.unscopables

Symbols

definition of language extensions, Overview and Definitions property names, Symbols, Symbols as Property Names
well-known Symbols, Well-Known Symbols

synchronous script execution, When scripts run: async and deferred

syntax

control structures, A Tour of JavaScript-A Tour of JavaScript declaring variables, A Tour of JavaScript
English-language comments, A Tour of JavaScript, A Tour of JavaScript

equality and relational operators, A Tour of JavaScript

expressions

forming with operators, A Tour of JavaScript initializer expression, A Tour of JavaScript
extended for object literals, Extended Object Literal Syntax-Property Getters and Setters

functions, A Tour of JavaScript

lexical structure, Lexical Structure-Summary

case sensitivity, The Text of a JavaScript Program comments, Comments
identifiers, The Text of a JavaScript Program-Identifiers and Reserved Words

line breaks, The Text of a JavaScript Program

literals, Literals

reserved words, Reserved Words, Primary Expressions

semicolons, Optional Semicolons-Optional Semicolons

spaces, The Text of a JavaScript Program

Unicode character set, Unicode Escape Sequences-Unicode Normalization

logical operators, A Tour of JavaScript

methods, A Tour of JavaScript

objects

conditionally accessing properties, A Tour of JavaScript declaring, A Tour of JavaScript
shorthand methods, Shorthand Methods

statements, A Tour of JavaScript

variables, assigning values to, A Tour of JavaScript


T

tabs, The Text of a JavaScript Program

tagged template literals, Tagged template literals, Template Tags

template literals, Template Literals, Template Tags

ternary operators, Number of Operands

test() method, test()

text

drawing in Canvas, Text

escape sequences in string literals, Escape Sequences in String Literals

pattern matching, Pattern Matching

string literals, String Literals

string type representing, Text

template literals, Template Literals

working with strings, Working with Strings

text editors

normalization, Unicode Normalization using with Node, Hello World
text styles, Text styles

.then() method, Using Promises, Chaining Promises, More on Promises and Errors

this keyword, A Tour of JavaScript, Primary Expressions, Function Invocation

threading, Worker Threads and Messaging, Progressive Web Apps and Service Workers (see also Worker API)

3D graphics, Graphics in a <canvas>

throw statements, throw, Error Classes

throw() method, The return() and throw() Methods of a Generator

time zones, Formatting Dates and Times

timers, Timers, Timers

timestamps, Dates and Times, Timestamps

toDateString() method, Formatting and Parsing Date Strings

toExponential() method, Explicit Conversions

toFixed() method, Explicit Conversions

toISOString() method, Formatting and Parsing Date Strings, JSON Customizations

toJSON() method, The toJSON() Method, JSON Customizations

toLocaleDateString() method, Formatting and Parsing Date Strings, Formatting Dates and Times

toLocaleString() method, The toLocaleString() Method, Array to String Conversions, Formatting and Parsing Date Strings

toLocaleTimeString() method, Formatting and Parsing Date Strings, Formatting Dates and Times

tools and extensions, JavaScript Tools and Extensions-Enumerated Types and Discriminated Unions

code bundling, Code Bundling

JavaScript formatting with Prettier, JavaScript Formatting with Prettier

JSX language extension, JSX: Markup Expressions in JavaScript-JSX: Markup Expressions in JavaScript

linting with ESLint, Linting with ESLint

overview of, JavaScript Tools and Extensions

package management with npm, Package Management with npm

transpilation with Babel, Transpilation with Babel

type checking with Flow, Type Checking with Flow-Enumerated Types and Discriminated Unions

array types, Array Types

class types, Class Types

enumerated types and discriminated unions, Enumerated Types and Discriminated Unions

function types, Function Types

installing and running, Installing and Running Flow

object types, Object Types

other parameterized types, Other Parameterized Types

overview of, Type Checking with Flow

read-only types, Read-Only Types

type aliases, Type Aliases

TypeScript versus Flow, Type Checking with Flow

union types, Union Types

using type annotations, Using Type Annotations

unit testing with Jest, Unit Testing with Jest

toPrecision() method, Explicit Conversions

toString() method, Boolean Values, Explicit Conversions, The toString() and valueOf() methods, The + Operator, Equality with type conversion, The toString() Method, The toString() Method, Formatting and Parsing Date Strings

toTimeString() method, Formatting and Parsing Date Strings

toUpperCase() method, Working with Strings

toUTCString() method, Formatting and Parsing Date Strings

transformations, Coordinate System Transforms-Transformation example

translate() method, Coordinate System Transforms

translucency, Translucency and compositing

transpilation, Transpilation with Babel

truthy values, Boolean Values

try/catch/finally statements, try/catch/finally-try/catch/finally

type checking, Type Checking with Flow-Enumerated Types and Discriminated Unions

array types, Array Types

class types, Class Types

enumerated types and discriminated unions, Enumerated Types and Discriminated Unions

function types, Function Types

installing and running Flow, Installing and Running Flow

object types, Object Types

other parameterized types, Other Parameterized Types

overview of, Type Checking with Flow

read-only types, Read-Only Types

type aliases, Type Aliases

TypeScript versus Flow, Type Checking with Flow

union types, Union Types

using type annotations, Using Type Annotations

type conversions

equality and, Conversions and Equality, Equality with type conversion

explicit conversions, Explicit Conversions

financial and scientific data, Explicit Conversions

implicit conversions, Explicit Conversions

object to primitive conversions

algorithms for, Object to Primitive Conversions, Object-to-primitive conversion algorithms

object-to-boolean, Object-to-boolean conversions

object-to-number, Object-to-number conversions

object-to-string, Object-to-string conversions

special case operator conversions, Special case operator conversions

toString() and valueOf() methods, The toString() and valueOf() methods

overview of, Type Conversions

typed arrays

creating, Creating Typed Arrays

DataView and endianness, DataView and Endianness methods and properties, Typed Array Methods and Properties overview of, Typed Arrays and Binary Data
versus regular arrays, Arrays

sharing between threads, Sharing Typed Arrays Between Threads typed array types, Typed Array Types
using, Using Typed Arrays

typeof operator, The typeof Operator

types

global object, The Global Object-The Global Object

Number type, Numbers-Dates and Times

objects (see objects)

overview of, Types, Values, and Variables-Overview and Definitions

primitive, Overview and Definitions

RegExp, Pattern Matching-Pattern Matching

strings, Text-Tagged template literals

Symbols, Symbols-Symbols

type conversions, Type Conversions-Object-to-primitive conversion algorithms

TypeScript, Type Checking with Flow


U

Uint8Array, Typed Array Types, Streaming response bodies, Buffers

unary operators

arithmetic operators, Unary Arithmetic Operators Boolean NOT operator (!), Boolean Values JavaScript support for, Number of Operands
undeclared variables, Variable Declarations with var

undefined values, null and undefined

underflow, Arithmetic in JavaScript

underscore (_), Identifiers and Reserved Words

underscores, as numeric separators (_), Floating-Point Literals

unescape() function, Legacy URL Functions

unhandledrejection event, Program Errors

Unicode character set

escape sequences, Unicode Escape Sequences, Escape Sequences in String Literals

JavaScript strings, Text

normalization, Unicode Normalization

overview of, Unicode

pattern matching, Character classes

space characters, The Text of a JavaScript Program

unit testing, Unit Testing with Jest

unshift() method, Stacks and Queues with push(), pop(), shift(), and unshift()

URL APIs, URL APIs-Legacy URL Functions

use strict directive

default application of strict mode, Classes with the class Keyword, Modules in ES6, JavaScript Modules on the Web

delete operator and, The delete Operator

eval() function, Strict eval()

function declarations, Function Declarations

function invocation, Function Invocation

opting into strict mode, Introduction to JavaScript

strict versus non-strict mode, “use strict”-“use strict”

TypeError, Property Access Errors, Object Extensibility

undeclared variables and, Variable Declarations with var

with statement and, with, Setting event handler attributes

use strict mode, Introduction to JavaScript

and global variables, Variable Declarations with var deleting properties, Deleting Properties
UTF-16 encoding, Text


V

valueOf() method, The toString() and valueOf() methods, The valueOf() Method

values

assigning, A Tour of JavaScript

boolean values, Boolean Values-Boolean Values falsy and truthy, Boolean Values
functions as values, Functions as Values-Defining Your Own Function Properties

immutable primitive values, Immutable Primitive Values and Mutable Object References

null and undefined, null and undefined

overview of, Types, Values, and Variables-Overview and Definitions

types of, A Tour of JavaScript

var keyword, Variable Declarations with var, const, let, and var

varargs, Rest Parameters and Variable-Length Argument Lists

variable arity functions, Rest Parameters and Variable-Length Argument Lists

variables

case sensitivity, The Text of a JavaScript Program

declaration and assignment

declarations with let and const, Declarations with let and const-Declarations and types

declarations with var, Variable Declarations with var

destructuring assignment, Destructuring Assignment-Destructuring Assignment

overview of, A Tour of JavaScript

undeclared variables, Variable Declarations with var

definition of term, Variable Declaration and Assignment

hoisted, Variable Declarations with var

naming, Reserved Words

overview of, Types, Values, and Variables-Overview and Definitions

scope of, Variable and constant scope, Nested Functions

variadic functions, Rest Parameters and Variable-Length Argument Lists

video streams, Media APIs

viewport, Document Coordinates and Viewport Coordinates, Viewport Size, Content Size, and Scroll Position

void operator, The void Operator


W

WeakMap class, WeakMap and WeakSet

WeakSet class, WeakMap and WeakSet

Web Authentication API, Cryptography and Related APIs

web browser host environment asynchronous APIs, Events

audio APIs, Audio APIs-The WebAudio API

benefits of JavaScript, JavaScript in Web Browsers

Canvas API, Graphics in a <canvas>-Pixel Manipulation

canvas dimensions and coordinates, Canvas Dimensions and Coordinates

clipping, Clipping

coordinate system transforms, Coordinate System Transforms-Transformation example

drawing operations, Canvas Drawing Operations

graphics attributes, Graphics Attributes, Saving and restoring graphics state

overview of, Graphics in a <canvas>

paths and polygons, Paths and Polygons

pixel manipulation, Pixel Manipulation

document geometry and scrolling, Document Geometry and Scrolling-Viewport Size, Content Size, and Scroll Position

CSS pixels, Document Coordinates and Viewport Coordinates

determining element at a point, Determining the Element at a Point

document coordinates and viewport coordinates, Document Coordinates and Viewport Coordinates

querying geometry of elements, Querying the Geometry of an Element

scrolling, Scrolling

viewport size, content size, and scroll position, Viewport Size, Content Size, and Scroll Position

events, Events-Dispatching Custom Events

dispatching custom events, Dispatching Custom Events event cancellation, Event Cancellation
event categories, Event Categories

event handler invocation, Event Handler Invocation event propagation, Event Propagation
overview of, Events

registering event handlers, Registering Event Handlers

legacy APIs, JavaScript in Web Browsers

location, navigation, and history, Location, Navigation, and History-History Management with pushState()

browsing history, Browsing History

loading new documents, Loading New Documents

overview of, Location, Navigation, and History

Mandelbrot set example, Example: The Mandelbrot Set-Summary and Suggestions for Further Reading

module-aware browsers, JavaScript Modules on the Web

networking, Networking-Protocol negotiation fetch() method, fetch()
overview of, Networking

server-sent events, Server-Sent Events WebSocket API, WebSockets
overview of, JavaScript in Web Browsers

scalable vector graphics (SVG), SVG: Scalable Vector Graphics-

Creating SVG Images with JavaScript

creating SVG images with JavaScript, Creating SVG Images with JavaScript

overview of, SVG: Scalable Vector Graphics

scripting SVG, Scripting SVG

SVG in HTML, SVG in HTML

scripting CSS, Scripting CSS-CSS Animations and Events common CSS styles, Scripting CSS
computed styles, Computed Styles

CSS animations and events, CSS Animations and Events CSS classes, CSS Classes
inline styles, Inline Styles

naming conventions, Inline Styles scripting stylesheets, Scripting Stylesheets
scripting documents, Scripting Documents-Example: Generating a Table of Contents

document structure and traversal, Document Structure and Traversal

dynamically generating tables of contents, Example: Generating a Table of Contents

modifying content, Element content as HTML

modifying structure, Creating, Inserting, and Deleting Nodes

overview of, Scripting Documents

querying and setting attributes, Attributes

selecting document elements, Selecting Document Elements

storage, Storage-IndexedDB cookies, Cookies IndexedDB, IndexedDB
localStorage and sessionStorage, localStorage and sessionStorage

overview of, Storage

security and privacy, Storage

web components, Web Components-Example: a <search-box> Web Component

custom elements, Custom Elements

DocumentFragment nodes, Using Web Components

HTML templates, HTML Templates

overview of, Web Components

search box example, Example: a <search-box> Web Component

shadow DOM, Shadow DOM

using, Using Web Components

web platform features to investigate binary APIs, Binary APIs
cryptography and security APIs, Cryptography and Related APIs events, Events
HTML and CSS, HTML and CSS media APIs, Media APIs
mobile device APIs, Mobile Device APIs

Performance APIs, Performance

Progressive Web Apps and ServiceWorkers, Progressive Web Apps and Service Workers

security, Security

WebAssembly, WebAssembly

Window and Document object features, More Document and Window Features

web programming basics

Document Object Model (DOM), The Document Object Model-The Document Object Model

execution of JavaScript programs, Execution of JavaScript Programs-Client-side JavaScript timeline

global object in web browsers, The Global Object in Web Browsers

JavaScript in HTML <script> tags, JavaScript in HTML <script> Tags-Loading scripts on demand

program errors, Program Errors

program input and output, Program Input and Output

scripts sharing namespaces, Scripts Share a Namespace

web security model, The Web Security Model-Cross-site scripting

worker threads and messaging, Worker Threads and Messaging-Cross-Origin Messaging with postMessage()

web developer tools, Exploring JavaScript

Web Manifest, Progressive Web Apps and Service Workers

Web Workers API, Client-side JavaScript threading model, Worker

Threads

WebAssembly, WebAssembly

WebAudio API, The WebAudio API

WebRTC API, Media APIs

WebSocket API

creating, connecting and disconnecting WebSockets, Creating, connecting, and disconnecting WebSockets

overview of, WebSockets

protocol negotiation, Protocol negotiation

receiving messages, Receiving messages from a WebSocket

sending messages, Sending messages over a WebSocket

while loops, while

with statements, Miscellaneous Statements

Worker API

cross-origin messaging, Cross-Origin Messaging with postMessage() errors, Errors in Workers
execution model, Worker Execution Model importing code, Importing Code into a Worker
Mandelbrot set example, Example: The Mandelbrot Set-Summary and Suggestions for Further Reading

modules, Importing Code into a Worker

overview of, Worker Threads and Messaging

postMessage(), MessagePorts and MessageChannels, postMessage(), MessagePorts, and MessageChannels

Worker objects, Worker Objects

WorkerGlobalScope object, The Global Object in Workers

writable attribute, Introduction to Objects, Property Attributes


X

XMLHttpRequest API (XHR), fetch()

XSS (cross-site scripting), The same-origin policy


Y

yield statements, yield, The Value of a yield Expression

yield* keyword, yield* and Recursive Generators


Z

zero

negative zero, Arithmetic in JavaScript positive zero, Arithmetic in JavaScript
zero-based arrays, Arrays



About the Author

David Flanagan has been programming with and writing about JavaScript since 1995. He lives with his wife and children in the Pacific Northwest between the cities of Seattle, Washington, and Vancouver, British Columbia. David has a degree in computer science and engineering from the Massachusetts Institute of Technology and works as a software engineer at VMware.



Colophon

The animal on the cover of JavaScript: The Definitive Guide, Seventh Edition, is a Javan rhinoceros (Rhinoceros sondaicus). All five species of rhinoceros are distinguished by their large size, thick armor-like skin, three-toed feet, and single or double snout horn. The Javan rhinoceros resembles the related Indian rhinoceros, and as with that species, the males have a single horn. However, Javan rhinos are smaller and have unique skin textures. Though found today only in Indonesia, Javan rhinos once ranged throughout Southeastern Asia. They live in rainforest habitats, where they graze on abundant leaves and grasses and hide from insect pests such as blood-sucking flies by standing up to their snouts in water or mud.


The Javan rhino averages about 6 feet in height and can be up to 10 feet in length, with adults weighing up to 3,000 pounds. Like the Indian rhinoceros its gray skin seems to be separated into “plates,” some of them textured. The natural lifespan of a Javan rhino is estimated at 45–50 years. Females give birth every 3–5 years, after a gestation period of 16 months. Calves weigh about 100 pounds when born, and stay with their protective mothers for up to 2 years.


Rhinoceros are generally a somewhat plentiful animal, being adaptable to a range of habitats and at adulthood having no natural predators. However, humans have hunted them nearly to extinction. Folklore holds that the horn of the rhinoceros possesses magical and aphrodisiac powers, and because of this, rhinos are a prime target for poachers. The Javan rhino population is the most precarious: as of 2020, the 70 or so remaining animals of this species live, under guard, in Ujung Kulon National Park, in Java, Indonesia. This strategy seems to be helping ensure the survival of

these rhinos for the time being, as a 1967 census counted only 25.


Many of the animals on O’Reilly covers are endangered; all of them are important to the world.


The color illustration on the cover is by Karen Montgomery, based on a black-and-white engraving from Dover Animals. The cover fonts are Gilroy and Guardian Sans. The text font is Adobe Minion Pro; the heading font is Adobe Myriad Condensed; and the code font is Dalton Maag’s Ubuntu Mono.