Index

A note on the digital index

A link in an index entry is displayed as the section title in which that entry appears. Because some sections have multiple index markers, it is not unusual for an entry to have several links to the same section. Clicking on any link will take you directly to the place in the text in which the marker appears.

Symbols

! (exclamation mark)

!= (inequality) operator, Equality Operators, Equality Operators: === Versus ==, Lenient inequality (!=)

!== (strict inequality) operator, Equality Operators, Equality Operators: === Versus ==, Strict inequality (!==), Commonly Accepted Best Practices

checking for NaN, Pitfall: checking whether a value is NaN

logical NOT operator, Operators for Booleans and Numbers, Logical Not (!)

" " (quotation marks, double)

best practice in JavaScript, Commonly Accepted Best Practices
for string literals, Strings, String Literals

$ (dollar sign)

in a replacement string, Test, Match, and Replace with Regular Expressions

% (percent sign)

%= compound assignment operator, Compound Assignment Operators
remainder operator, Operators, Arithmetic Operators, Arithmetic Operators

& (ampersand)

& (bitwise AND) operator, Operators for Booleans and Numbers, Binary Bitwise Operators
&& (logical AND) operator, Binary Logical Operators, Operators for Booleans and Numbers, Binary Logical Operators: And (&&) and Or (||), Logical And (&&)
&= (bitwise AND and assignment) operator, Compound Assignment Operators

' ' (quotation marks, single)

best practice in JavaScript, Commonly Accepted Best Practices
for string literals, Strings, String Literals

* (asterisk)

*= compound assignment operator, Compound Assignment Operators
multiplication operator, Operators, Arithmetic Operators

+ (plus sign)

++ (increment) operator, Operators, Arithmetic Operators, Increment operator

+= compound assignment operator, Compound Assignment Operators

+= operator, concatenating strings, String Operators

addition operator, Operators, Arithmetic Operators

string concatenation operator, String Operators, Escaping in String Literals, Concatenation: The Plus (+) Operator

performance of, Concatenation: Joining an Array of String Fragments

, (comma) operator, The Comma Operator

- (minus sign)

-- (decrement operator), Increment operator
-- (decrement) operator, Operators, Arithmetic Operators
-= compound assignment operator, Compound Assignment Operators
negation operator, Operators, Arithmetic Operators
subtraction operator, Operators, Arithmetic Operators

. (comma), trailing commas in object literals and array literals, Syntactic Changes

. (dot operator), Values

calling methods with, Calling methods
using to access properties, Values, Dot Operator (.): Accessing Properties via Fixed Keys
working with objects, Cheat Sheet: Working with Objects

/ (slash)

/* and */ delimiting multiline comments, Comments
// delimiting single-line comments, Comments
/= compound assignment operator, Compound Assignment Operators
division operator, Operators, Arithmetic Operators

0 (zero), positive and negative, Two Zeros–Distinguishing the two zeros

1TBS (One True Brace Style), 1TBS (One True Brace Style)

32-bit integers, Integers in JavaScript

signed, Signed 32-bit integers
via bitwise operators, 32-bit Integers via Bitwise Operators

64-bit precision, JavaScript numbers, The Internal Representation of Numbers

; (semicolon)

always using, best practice, Commonly Accepted Best Practices
in JavaScript code, Semicolons, Rules for Using Semicolons–Pitfall: ASI might unexpectedly not be triggered
terminating semicolon for IIFEs, Introducing a New Scope via an IIFE

< (less than)

< (less than) operator, Ordering Operators, Comparing Strings
<< (bitwise left shift) operator, Operators for Booleans and Numbers, Shift operators, Bitwise Shift Operators
<<= (bitwise left shift and assignment operator), Compound Assignment Operators
<= (less than or equal to) operator, Ordering Operators, Comparing Strings

= (equals sign)

== (equality) operator, Equality Operators, Equality Operators: === Versus ==, Normal (Lenient) Equality (==, !=)

no valid use cases for, There Are No Valid Use Cases for ==
pitfalls of, Pitfall: lenient equality is different from conversion to boolean

=== (strict equality) operator, Equality Operators, Equality Operators: === Versus ==, Searching for Values (Nondestructive), Commonly Accepted Best Practices

checking for undefined or null values, Checking for null
checking if value is NaN, Pitfall: checking whether a value is NaN
object vs. primitive value comparisons, Primitive Values Versus Objects

assignment (=) versus equality comparison (===), An Overview of the Syntax, An Overview of the Syntax

assignment operator, Assignment Operators

setting object properties, Setting properties

> (greater than)

> (greater than) operator, Ordering Operators, Comparing Strings
>= (greater than or equal to) operator, Ordering Operators, Comparing Strings
>> (bitwise right shift) operator, Operators for Booleans and Numbers, Shift operators, Bitwise Shift Operators
>>= (bitwise right shift and assignment operator), Compound Assignment Operators
>>> (bitwise right shift with zero fill) operator, Operators for Booleans and Numbers, Shift operators, Bitwise Shift Operators
>>>= (bitwise right shift with zero fill and assignment operator), Compound Assignment Operators

? (question mark)

? : (conditional) operator, Conditional statement versus conditional expressions, The Conditional Operator ( ? : ), Comparing Numbers

enclosing in parentheses, Syntax
nesting, Conditional operator

[ ] (square brackets)

accessing array elements, Converting arguments to an Array
accessing characters in strings, Character Access
accessing single character in strings, Strings
bracket operator, Unusual Property Keys, Bracket Operator ([]): Accessing Properties via Computed Keys, Cheat Sheet: Working with Objects
computing a property key, Arbitrary Property Keys
creating arrays and accessing array elements, Array Literals
getting and setting a property, Arbitrary Property Keys

\ (backslash)

beginning character escape sequences, Escaping in String Literals
escaping characters in strings, Strings, Escaping in String Literals

{ } (curly braces)

enclosing blocks, Control Flow Statements and Blocks
in conditional and control flow statements, Conditionals
styles for, Brace Styles
using to prevent dangling else in if statements, Pitfall: dangling else

| (vertical bar)

bitwise OR operator, Operators for Booleans and Numbers, Binary Bitwise Operators

converting numbers to integers, Bitwise Or (|)

|= (bitwise OR and assignment) operator, Compound Assignment Operators

|| (logical OR) operator, Binary Logical Operators, Operators for Booleans and Numbers, Binary Logical Operators: And (&&) and Or (||), Logical Or (||), Optional Parameters

pattern, providing a default value, Pattern: providing a default value, Default values

~ (tilde)

bitwise NOT operator, Bitwise Not Operator

“single-line comments”), An Overview of the Syntax

‸ (bitwise XOR) operator, Operators for Booleans and Numbers

A

accessors, Kinds of Properties

and inheritance, Accessors and Inheritance
defining via an object literal, Defining Accessors via an Object Literal
defining via property descriptors, Defining Accessors via Property Descriptors
in ECMAScript 5, New Features
property attributes specific to, Property Attributes

Ajax, Historical JavaScript Milestones

Allman style (braces), Allman style

AMD (Asynchronous Module Definition), Module Systems

angles, conversions to and from radians, Trigonometric Functions

anonymous function expressions, Function Expressions

empty string as name of, The Name of a Function

Apache CouchDB, Historical JavaScript Milestones

apply() method, func.apply(thisValue, argArray), Function.prototype.apply()

(see also Function.prototype.apply() method)

for constructors, apply() for Constructors

manually simulating, Manually simulating an apply() for constructors

arguments object, The Special Variable arguments, All Parameters by Index: The Special Variable arguments

characteristics of, All Parameters by Index: The Special Variable arguments
converting to an array, Converting arguments to an Array
defined, Terminology: “Parameter” Versus “Argument”
deprecated features, Deprecated features of arguments
fewer properties in strict mode, The arguments objects has fewer properties
hasOwnProperty() method, All Parameters by Index: The Special Variable arguments
length, checking, Enforcing an Arity

arguments, too many or too few, Too Many or Too Few Arguments

arithmetic operators, Operators, Operators for Booleans and Numbers, Arithmetic Operators–Arithmetic Operators

arity, enforcing, Enforcing an Arity, Mandatory Parameters, Enforcing a Minimum Arity

array literals, Elegant Parts

trailing commas in, Syntactic Changes

Array() constructor, The Array Constructor

preferring literals to, Prefer Literals to Constructors

array-like objects, Pitfall: Array-Like Objects

and generic methods, Array-Like Objects and Generic Methods
patterns for working with, Patterns for working with array-like objects

Array.isArray() method, Pitfall: crossing realms (frames or windows), Array Constructor Method

Array.prototype, abbreviation in generic methods, Generic methods

Array.prototype.concat() method, Concatenating, Slicing, Joining (Nondestructive)

Array.prototype.every() method, Examination Methods

Array.prototype.filter() method, Array iteration methods, Transformation Methods

Array.prototype.forEach() method, Array iteration methods, Examination Methods, Examination Methods

iterating over array elements, Iterating over Arrays
iteration via, skipping holes, Sparse Arrays Versus Dense Arrays
thisValue for, Workaround 3: a thisValue for forEach()

Array.prototype.indexOf() method, Searching for Values (Nondestructive)

Array.prototype.join() method, Concatenating, Slicing, Joining (Nondestructive)

Array.prototype.lastIndexOf() method, Searching for Values (Nondestructive)

Array.prototype.map() method, Transformation Methods

Array.prototype.pop() method, Adding and Removing Elements (Destructive)

Array.prototype.push() method, Adding and Removing Elements (Destructive)

Array.prototype.reduce() method, Reduction Methods

Array.prototype.reduceRight() method, Reduction Methods

Array.prototype.reverse() method, Sorting and Reversing Elements (Destructive)

Array.prototype.shift() method, Adding and Removing Elements (Destructive)

Array.prototype.slice() method, Concatenating, Slicing, Joining (Nondestructive)

Array.prototype.some() method, Examination Methods

Array.prototype.sort() method, Sorting and Reversing Elements (Destructive)

Array.prototype.splice() method, Adding and Removing Elements (Destructive)

Array.prototype.unshift() method, Adding and Removing Elements (Destructive)

arrays, Objects, Arrays–Regular Expressions, An Overview of the Syntax, Objects, Arrays–Best Practices: Iterating over Arrays

adding and removing elements, Adding and Removing Elements (Destructive)

are maps, not tuples, Arrays Are Maps, Not Tuples

array literals, Array Literals

best practice, avoiding Array() constructor, Prefer Literals to Constructors

calling array methods generically, Examples of Calling Methods Generically

concatenating, slicing, and joining, Concatenating, Slicing, Joining (Nondestructive)

concatenattion, joining an array of string fragments, Concatenation: Joining an Array of String Fragments

converting arguments to, Converting arguments to an Array

creating array of character codes, Extract Substrings

holes in, Holes in Arrays–Removing Holes from Arrays

creating, Creating Holes
operations ignoring or considering them, Which Operations Ignore Holes, and Which Consider Them?
removing, Removing Holes from Arrays
sparse versus dense arrays, Sparse Arrays Versus Dense Arrays

indices, Array Indices

deleting array elements, Deleting Array Elements
in detail, Array Indices in Detail
in operator and, The in Operator and Indices

iterating over, Iterating over Arrays

best practices, Best Practices: Iterating over Arrays
not using for-in loop, Best practice: don’t use for-in for arrays
using for loop, for

iteration methods, Iteration (Nondestructive)–Reduction Methods

length, length

clearing an array, Clearing an array
clearing shared arrays, Clearing shared arrays
decreasing length of array, Decreasing the Length of an Array
increasing length of array, Manually Increasing the Length of an Array
maximum length, The Maximum Length

methods, Array Methods

multidimensional, Multidimensional Arrays

overview, Overview

properties, Arrays Can Also Have Properties

prototype methods, Array Prototype Methods

new in ECMAScript 5, New Methods

searching for values, Searching for Values (Nondestructive)

sorting and reversing elements, Sorting and Reversing Elements (Destructive)

splitting string into array of substrings, Extract Substrings

too flexible in JavaScript, Quirks and Unorthodox Features

turning into arguments with hypothetical triple dot operator (...), example, apply() for Constructors

using Array() constructor, The Array Constructor

avoiding initializing array with elements, Initializing an array with elements (avoid!)
creating empty array with given length, Creating an empty array with a given length

ASI (automatic semicolon insertion), Automatic Semicolon Insertion

example, ASI via closing brace, Example: ASI via closing brace
example, ASI via illegal token, Example: ASI via illegal token
pitfall, ASI unexpectedly not triggered, Pitfall: ASI might unexpectedly not be triggered
pitfall, unexpectedly breaking up statements, Pitfall: ASI can unexpectedly break up statements

assertions in regular expressions, Assertions, Regular Expression Cheat Sheet

lookbehind, implementing manually, Manually Implementing Lookbehind
regular expressions without assertions, Pitfall: Without an Assertion (e.g., ^, $), a Regular Expression Is Found Anywhere

assignment, Assignment

assigning to a property, Properties: Definition Versus Assignment

inherited, read-only properties, Inherited Read-Only Properties Can’t Be Assigned To

compound assignment operators, Compound Assignment Operators

value to properties using dot operator, Values

assignment operator (=), An Overview of the Syntax, An Overview of the Syntax, Assignment Operators

assignment operators, compound, Compound Assignment Operators

Asynchronous Module Definition (AMD), Module Systems

attributes (property), Iteration and Detection of Properties, Property Attributes and Property Descriptors

common to all properties, Property Attributes
default values, Default values
getting and setting via property descriptors, Getting and Defining Properties via Descriptors
managing via property descriptors, Metaprogramming
sealing to prevent change in, Sealing

automatic semicolon insertion (see ASI)