Speaking JavaScript

Praise for Speaking JavaScript
Preface
    What You Need to Know About This Book
    Tips for Reading This Book
        The Four Parts of This Book
        JavaScript Command Lines
        Notational Conventions
            Describing syntax
            Referring to methods
            Command-line interaction
            Tips, notes, and warnings
        Quickly Finding Documentation
    Safari® Books Online
    How to Contact Us
    Acknowledgments
        Preparing for JavaScript
        Help with JavaScript
        Reviewers
I. JavaScript Quick Start
    1. Basic JavaScript
        Background
            JavaScript Versus ECMAScript
            Influences and Nature of the Language
        Syntax
            An Overview of the Syntax
            Statements Versus Expressions
            Semicolons
            Comments
        Variables and Assignment
            Assignment
            Compound Assignment Operators
            Identifiers and Variable Names
        Values
            Primitive Values Versus Objects
            Primitive Values
            Objects
            undefined and null
                Checking for undefined or null
            Categorizing Values Using typeof and instanceof
        Booleans
            Truthy and Falsy
            Binary Logical Operators
            Equality Operators
        Numbers
        Operators
        Strings
            String Operators
            String Methods
        Statements
            Conditionals
            Loops
        Functions
            Function Declarations Are Hoisted
            The Special Variable arguments
            Too Many or Too Few Arguments
            Optional Parameters
            Enforcing an Arity
            Converting arguments to an Array
        Exception Handling
        Strict Mode
        Variable Scoping and Closures
            Variables Are Function-Scoped
            Variables Are Hoisted
            Closures
            The IIFE Pattern: Introducing a New Scope
                IIFE use case: inadvertent sharing via closures
        Objects and Constructors
            Single Objects
            Arbitrary Property Keys
            Extracting Methods
            Functions Inside a Method
            Constructors: Factories for Objects
        Arrays
            Array Literals
            Array Methods
            Iterating over Arrays
        Regular Expressions
            Method test(): Is There a Match?
            Method exec(): Match and Capture Groups
            Method replace(): Search and Replace
        Math
        Other Functionality of the Standard Library
II. Background
    2. Why JavaScript?
        Is JavaScript Freely Available?
        Is JavaScript Elegant?
        Is JavaScript Useful?
            Graphical User Interfaces
            Other Technologies Complementing JavaScript
        Does JavaScript Have Good Tools?
        Is JavaScript Fast Enough?
        Is JavaScript Widely Used?
        Does JavaScript Have a Future?
        Conclusion
    3. The Nature of JavaScript
        Quirks and Unorthodox Features
        Elegant Parts
        Influences
    4. How JavaScript Was Created
    5. Standardization: ECMAScript
    6. Historical JavaScript Milestones
III. JavaScript in Depth
    7. JavaScript’s Syntax
        An Overview of the Syntax
        Comments
        Expressions Versus Statements
            Expressions
            Statements
                Conditional statement versus conditional expressions
                Using ambiguous expressions as statements
                Evaluating an object literal via eval()
                Immediately invoking a function expression
        Control Flow Statements and Blocks
        Rules for Using Semicolons
            No Semicolon After a Statement Ending with a Block
            The Empty Statement
            Automatic Semicolon Insertion
                Example: ASI via illegal token
                Example: ASI via closing brace
                Pitfall: ASI can unexpectedly break up statements
                Pitfall: ASI might unexpectedly not be triggered
        Legal Identifiers
        Invoking Methods on Number Literals
        Strict Mode
            Switching on Strict Mode
            Strict Mode: Recommended, with Caveats
            Variables Must Be Declared in Strict Mode
            Functions in Strict Mode
                Functions must be declared at the top level of a scope
                Stricter rules for function parameters
                The arguments objects has fewer properties
                this is undefined in nonmethod functions
            Setting and Deleting Immutable Properties Fails with an Exception in Strict Mode
            Unqualified Identifiers Can’t Be Deleted in Strict Mode
            eval() Is Cleaner in Strict Mode
            Features That Are Forbidden in Strict Mode
    8. Values
        JavaScript’s Type System
            JavaScript’s Types
            Static Versus Dynamic
            Static Typing Versus Dynamic Typing
            Static Type Checking Versus Dynamic Type Checking
            Coercion
        Primitive Values Versus Objects
        Primitive Values
        Objects
        undefined and null
            Occurrences of undefined and null
                Occurrences of undefined
                Occurrences of null
            Checking for undefined or null
                Checking for null
                Checking for undefined
                Checking for either undefined or null
            The History of undefined and null
            Changing undefined
        Wrapper Objects for Primitives
            Wrapper Objects Are Different from Primitives
            Wrapping and Unwrapping Primitives
            Primitives Borrow Their Methods from Wrappers
        Type Coercion
            Type Coercion Can Hide Bugs
            Functions for Converting to Boolean, Number, String, and Object
            Algorithm: ToPrimitive()—Converting a Value to a Primitive
                Examples: ToPrimitive() in action
    9. Operators
        Operators and Objects
        Assignment Operators
            Compound Assignment Operators
        Equality Operators: === Versus ==
            Strict Equality (===, !==)
                Pitfall: NaN
                Strict inequality (!==)
            Normal (Lenient) Equality (==, !=)
                Lenient inequality (!=)
                Pitfall: lenient equality is different from conversion to boolean
                Pitfall: lenient equality and strings
                Pitfall: lenient equality and objects
            There Are No Valid Use Cases for ==
                Use case: checking for undefined or null
                Use case: working with numbers in strings
                Use case: comparing wrapper instances with primitives
        Ordering Operators
            The Algorithm
        The Plus Operator (+)
            The Algorithm
        Operators for Booleans and Numbers
        Special Operators
            The Conditional Operator ( ? : )
            The Comma Operator
            The void Operator
                What is void used for?
                Why does JavaScript have a void operator?
        Categorizing Values via typeof and instanceof
            typeof: Categorizing Primitives
                Pitfall: typeof null
                The history of typeof null
                Checking whether a variable exists
            instanceof: Checking Whether an Object Is an Instance of a Given Constructor
        Object Operators
    10. Booleans
        Converting to Boolean
            Manually Converting to Boolean
            Truthy and Falsy Values
                Pitfall: all objects are truthy
                History: Why are objects always truthy?
        Logical Operators
            Binary Logical Operators: And (&&) and Or (||)
            Logical And (&&)
            Logical Or (||)
                Pattern: providing a default value
                Example 1: a default for a parameter
                Example 2: a default for a property
                Example 3: a default for the result of a function
            Logical Not (!)
        Equality Operators, Ordering Operators
        The Function Boolean
    11. Numbers
        Number Literals
            Exponent
            Invoking Methods on Literals
        Converting to Number
            Manually Converting to Number
            parseFloat()
        Special Number Values
            NaN
                Pitfall: checking whether a value is NaN
            Infinity
                Error: a number’s magnitude is too large
                Error: division by zero
                Computing with Infinity
                Checking for Infinity
            Two Zeros
                Best practice: pretend there’s only one zero
                Distinguishing the two zeros
        The Internal Representation of Numbers
            Special Exponents
        Handling Rounding Errors
        Integers in JavaScript
            Ranges of Integers
            Representing Integers as Floating-Point Numbers
                Best practice
            Safe Integers
                Definitions in ECMAScript 6
                Safe results of arithmetic computations
        Converting to Integer
            Integers via Math.floor(), Math.ceil(), and Math.round()
            Integers via the Custom Function ToInteger()
            32-bit Integers via Bitwise Operators
                Bitwise Or (|)
                Shift operators
                Should I use bitwise operators to coerce to integer?
            Integers via parseInt()
                The radix
                Explanation
                Summary
        Arithmetic Operators
        Bitwise Operators
            Background Knowledge
                Binary complements
                Signed 32-bit integers
                Inputting and outputting binary numbers
            Bitwise Not Operator
            Binary Bitwise Operators
            Bitwise Shift Operators
        The Function Number
        Number Constructor Properties
        Number Prototype Methods
            Number.prototype.toFixed(fractionDigits?)
            Number.prototype.toPrecision(precision?)
            Number.prototype.toString(radix?)
                Decimal exponential notation
            Number.prototype.toExponential(fractionDigits?)
        Functions for Numbers
        Sources for This Chapter
    12. Strings
        String Literals
        Escaping in String Literals
        Character Access
        Converting to String
            Manually Converting to String
                Pitfall: conversion is not invertible
        Comparing Strings
        Concatenating Strings
            Concatenation: The Plus (+) Operator
            Concatenation: Joining an Array of String Fragments
        The Function String
        String Constructor Method
        String Instance Property length
        String Prototype Methods
            Extract Substrings
            Transform
            Search and Compare
            Test, Match, and Replace with Regular Expressions
    13. Statements
        Declaring and Assigning Variables
        The Bodies of Loops and Conditionals
        Loops
            Mechanisms to Be Used with Loops
            while
            do-while
            for
            for-in
                Best practice: don’t use for-in for arrays
                Best practice: be careful with for-in for objects
            for each-in
        Conditionals
            if-then-else
                Chaining if statements
                Pitfall: dangling else
            switch
        The with Statement
            Syntax and Semantics
            The with Statement Is Deprecated
                Techniques for avoiding the with statement
            The Rationale for the Deprecation
        The debugger Statement
    14. Exception Handling
        What Is Exception Handling?
        Exception Handling in JavaScript
            throw
            try-catch-finally
            Examples
        Error Constructors
        Stack Traces
        Implementing Your Own Error Constructor
    15. Functions
        The Three Roles of Functions in JavaScript
        Terminology: “Parameter” Versus “Argument”
        Defining Functions
            Function Expressions
                Named function expressions
            Function Declarations
            The Function Constructor
        Hoisting
        The Name of a Function
        Which Is Better: A Function Declaration or a Function Expression?
        More Control over Function Calls: call(), apply(), and bind()
            func.apply(thisValue, argArray)
            func.bind(thisValue, arg1, ..., argN)
        Handling Missing or Extra Parameters
            All Parameters by Index: The Special Variable arguments
                Deprecated features of arguments
            Mandatory Parameters, Enforcing a Minimum Arity
            Optional Parameters
            Simulating Pass-by-Reference Parameters
            Pitfall: Unexpected Optional Parameters
        Named Parameters
            Named Parameters as Descriptions
            Optional Named Parameters
            Simulating Named Parameters in JavaScript
    16. Variables: Scopes, Environments, and Closures
        Declaring a Variable
        Background: Static Versus Dynamic
        Background: The Scope of a Variable
        Variables Are Function-Scoped
        Variable Declarations Are Hoisted
        Introducing a New Scope via an IIFE
            IIFE Variation: Prefix Operators
            IIFE Variation: Already Inside Expression Context
            IIFE Variation: An IIFE with Parameters
            IIFE Applications
        Global Variables
            Best Practice: Avoid Creating Global Variables
            Module Systems Lead to Fewer Globals
        The Global Object
            Cross-Platform Considerations
            Use Cases for window
                Use case: marking global variables
                Use case: built-ins
                Use case: style checkers
                Use case: checking whether a global variable exists
                Use case: creating things in global scope
        Environments: Managing Variables
        Closures: Functions Stay Connected to Their Birth Scopes
            Handling Closures via Environments
            Pitfall: Inadvertently Sharing an Environment
    17. Objects and Inheritance
        Layer 1: Single Objects
            Kinds of Properties
            Object Literals
            Dot Operator (.): Accessing Properties via Fixed Keys
                Getting properties
                Calling methods
                Setting properties
                Deleting properties
                The return value of delete
            Unusual Property Keys
            Bracket Operator ([]): Accessing Properties via Computed Keys
                Getting properties via the bracket operator
                Calling methods via the bracket operator
                Setting properties via the bracket operator
                Deleting properties via the bracket operator
        Converting Any Value to an Object
        this as an Implicit Parameter of Functions and Methods
            Calling Functions While Setting this: call(), apply(), and bind()
                Function.prototype.call(thisValue, arg1?, arg2?, ...)
                Function.prototype.apply(thisValue, argArray)
                Function.prototype.bind(thisValue, arg1?, ..., argN?)
            apply() for Constructors
                Manually simulating an apply() for constructors
                A library method
                An alternative approach
            Pitfall: Losing this When Extracting a Method
                How to get a warning
                How to properly extract a method
                Callbacks and extracted methods
            Pitfall: Functions Inside Methods Shadow this
                Workaround 1: that = this
                Workaround 2: bind()
                Workaround 3: a thisValue for forEach()
        Layer 2: The Prototype Relationship Between Objects
            Inheritance
            Overriding
            Sharing Data Between Objects via a Prototype
            Getting and Setting the Prototype
                Creating a new object with a given prototype
                Reading the prototype of an object
                Checking whether one object a prototype of another one
                Finding the object where a property is defined
            The Special Property __proto__
            Setting and Deleting Affects Only Own Properties
                Setting a property
                Deleting an inherited property
                Changing properties anywhere in the prototype chain
        Iteration and Detection of Properties
            Listing Own Property Keys
            Listing All Property Keys
            Checking Whether a Property Exists
            Examples
                The effects of enumerability
                The effects of inheritance
                Computing the number of own properties of an object
        Best Practices: Iterating over Own Properties
        Accessors (Getters and Setters)
            Defining Accessors via an Object Literal
            Defining Accessors via Property Descriptors
            Accessors and Inheritance
        Property Attributes and Property Descriptors
            Property Attributes
                Default values
            Property Descriptors
            Getting and Defining Properties via Descriptors
            Copying an Object
            Properties: Definition Versus Assignment
            Inherited Read-Only Properties Can’t Be Assigned To
            Enumerability: Best Practices
        Protecting Objects
            Preventing Extensions
            Sealing
            Freezing
            Pitfall: Protection Is Shallow
        Layer 3: Constructors—Factories for Instances
            The new Operator Implemented in JavaScript
            Terminology: The Two Prototypes
            The constructor Property of Instances
                Use cases for the constructor property
                Best practice
            The instanceof Operator
                Pitfall: objects that are not instances of Object
                Pitfall: crossing realms (frames or windows)
            Tips for Implementing Constructors
                Protection against forgetting new: strict mode
                Returning arbitrary objects from a constructor
        Data in Prototype Properties
            Avoid Prototype Properties with Initial Values for Instance Properties
                Best practice: don’t share default values
                Creating instance properties on demand
            Avoid Nonpolymorphic Prototype Properties
            Polymorphic Prototype Properties
        Keeping Data Private
            Private Data in the Environment of a Constructor (Crockford Privacy Pattern)
                Public properties
                Private values
                Privileged methods
                An example
                The pros and cons of the Crockford privacy pattern
            Private Data in Properties with Marked Keys
            Private Data in Properties with Reified Keys
            Keeping Global Data Private via IIFEs
                Attaching private global data to a singleton object
                Keeping global data private to all of a constructor
                Attaching global data to a method
        Layer 4: Inheritance Between Constructors
            Inheriting Instance Properties
            Inheriting Prototype Properties
            Ensuring That instanceof Works
            Overriding a Method
            Making a Supercall
            Avoiding Hardcoding the Name of the Superconstructor
            Example: Constructor Inheritance in Use
            Example: The Inheritance Hierarchy of Built-in Constructors
            Antipattern: The Prototype Is an Instance of the Superconstructor
        Methods of All Objects
            Conversion to Primitive
            Object.prototype.toLocaleString()
            Prototypal Inheritance and Properties
        Generic Methods: Borrowing Methods from Prototypes
            Accessing Object.prototype and Array.prototype via Literals
            Examples of Calling Methods Generically
            Array-Like Objects and Generic Methods
                Patterns for working with array-like objects
            A List of All Generic Methods
        Pitfalls: Using an Object as a Map
            Pitfall 1: Inheritance Affects Reading Properties
                Checking whether a property exists
                Collecting property keys
                Getting a property value
            Pitfall 2: Overriding Affects Invoking Methods
            Pitfall 3: The Special Property __proto__
            The dict Pattern: Objects Without Prototypes Are Better Maps
                Normal objects
                Prototype-less objects
                Recommendation
            Best Practices
        Cheat Sheet: Working with Objects
    18. Arrays
        Overview
            Arrays Are Maps, Not Tuples
            Arrays Can Also Have Properties
        Creating Arrays
            The Array Constructor
                Creating an empty array with a given length
                Initializing an array with elements (avoid!)
            Multidimensional Arrays
        Array Indices
            The in Operator and Indices
            Deleting Array Elements
            Array Indices in Detail
        length
            Manually Increasing the Length of an Array
            Decreasing the Length of an Array
                Clearing an array
                Clearing shared arrays
            The Maximum Length
        Holes in Arrays
            Creating Holes
            Sparse Arrays Versus Dense Arrays
            Which Operations Ignore Holes, and Which Consider Them?
                Array iteration methods
                Other array methods
                The for-in loop
                Function.prototype.apply()
            Removing Holes from Arrays
        Array Constructor Method
        Array Prototype Methods
        Adding and Removing Elements (Destructive)
        Sorting and Reversing Elements (Destructive)
            Comparing Numbers
            Comparing Strings
            Comparing Objects
        Concatenating, Slicing, Joining (Nondestructive)
        Searching for Values (Nondestructive)
        Iteration (Nondestructive)
            Examination Methods
            Transformation Methods
            Reduction Methods
        Pitfall: Array-Like Objects
        Best Practices: Iterating over Arrays
    19. Regular Expressions
        Regular Expression Syntax
            Atoms: General
            Atoms: Character Classes
            Atoms: Groups
            Quantifiers
            Assertions
            Disjunction
        Unicode and Regular Expressions
        Creating a Regular Expression
            Literal Versus Constructor
            Flags
            Instance Properties of Regular Expressions
            Examples of Creating Regular Expressions
        RegExp.prototype.test: Is There a Match?
        String.prototype.search: At What Index Is There a Match?
        RegExp.prototype.exec: Capture Groups
            First Match (Flag /g Not Set)
            All Matches (Flag /g Set)
        String.prototype.match: Capture Groups or Return All Matching Substrings
        String.prototype.replace: Search and Replace
            Replacement Is a String
            Replacement Is a Function
        Problems with the Flag /g
        Tips and Tricks
            Quoting Text
            Pitfall: Without an Assertion (e.g., ^, $), a Regular Expression Is Found Anywhere
            Matching Everything or Nothing
                Matching everything
                Matching nothing
            Manually Implementing Lookbehind
        Regular Expression Cheat Sheet
    20. Dates
        The Date Constructor
        Date Constructor Methods
        Date Prototype Methods
            Time Unit Getters and Setters
            Various Getters and Setters
            Convert a Date to a String
        Date Time Formats
            Date Formats (No Time)
            Time Formats (No Date)
            Date Time Formats
        Time Values: Dates as Milliseconds Since 1970-01-01
            Converting a Date to a Number
    21. Math
        Math Properties
        Numerical Functions
        Trigonometric Functions
        Other Functions
    22. JSON
        Background
            Data Format
            History
            Grammar
        JSON.stringify(value, replacer?, space?)
            Data Ignored by JSON.stringify()
            The toJSON() Method
        JSON.parse(text, reviver?)
        Transforming Data via Node Visitors
            JSON.stringify()
            JSON.parse()
    23. Standard Global Variables
        Constructors
        Error Constructors
        Nonconstructor Functions
            Encoding and Decoding Text
            Categorizing and Parsing Numbers
        Dynamically Evaluating JavaScript Code via eval() and new Function()
            Evaluating Code Using eval()
                Use eval() in strict mode
                Indirect eval() evaluates in global scope
            Evaluating Code Using new Function()
            eval() Versus new Function()
            Best Practices
                Legitimate use cases
            Conclusion
        The Console API
            How Standardized Is the Console API Across Engines?
            Simple Logging
            Checking and Counting
            Formatted Logging
            Profiling and Timing
        Namespaces and Special Values
    24. Unicode and JavaScript
        Unicode History
        Important Unicode Concepts
        Code Points
        Unicode Encodings
        JavaScript Source Code and Unicode
            Source Code Internally
            Source Code Externally
        JavaScript Strings and Unicode
            Escape Sequences
            Refering to Astral Plane Characters via Escapes
            Counting Characters
            Unicode Normalization
        JavaScript Regular Expressions and Unicode
            Matching Any Code Unit and Any Code Point
            Libraries
            Recommended Reading and Chapter Sources
    25. New in ECMAScript 5
        New Features
        Syntactic Changes
        New Functionality in the Standard Library
            Metaprogramming
            New Methods
            JSON
        Tips for Working with Legacy Browsers
IV. Tips, Tools, and Libraries
    26. A Meta Code Style Guide
        Existing Style Guides
        General Tips
            Code Should Be Consistent
            Code Should Be Easy to Understand
        Commonly Accepted Best Practices
            Brace Styles
                Allman style
                1TBS (One True Brace Style)
                JavaScript
            Prefer Literals to Constructors
            Don’t Be Clever
                Conditional operator
                Abbreviating if statements
                Increment operator
                Checking for undefined
                Converting a number to an integer
            Acceptable Cleverness
                Default values
                Generic methods
                ECMAScript 5: trailing commas
                ECMAScript 5: reserved words
        Controversial Rules
            Syntax
            Variables
            Object Orientation
            Miscellaneous
        Conclusion
    27. Language Mechanisms for Debugging
    28. Subclassing Built-ins
        Terminology
        Obstacle 1: Instances with Internal Properties
            Workaround for Obstacle 1
            Caveats
        Obstacle 2: A Constructor That Can’t Be Called as a Function
            Workaround for Obstacle 2
        Another Solution: Delegation
    29. JSDoc: Generating API Documentation
        The Basics of JSDoc
            Syntax
            Naming Types
        Basic Tags
        Documenting Functions and Methods
        Inline Type Information (“Inline Doc Comments”)
        Documenting Variables, Parameters, and Instance Properties
        Documenting Classes
            Defining a Class via a Constructor Function
            Defining a Class via an Object Literal
            Defining a Class via an Object Literal with an @constructs Method
            Subclassing
        Other Useful Tags
    30. Libraries
        Shims Versus Polyfills
        Four Language Libraries
        The ECMAScript Internationalization API
            The ECMAScript Internationalization API, Edition 1
            What Kind of Standard Is It?
            When Can I Use It?
            Further Reading
        Directories for JavaScript Resources
    31. Module Systems and Package Managers
        Module Systems
        Package Managers
        Quick and Dirty Modules
    32. More Tools
    33. What to Do Next
Index
About the Author
Colophon
Copyright