Speaking Javascript

[Πρέπει να είστε εγγεγραμμένοι και συνδεδεμένοι για να δείτε αυτή την εικόνα.]

Table of contents

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
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
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
Control Flow Statements and Blocks
Rules for Using Semicolons
No Semicolon After a Statement Ending with a Block
The Empty Statement
Automatic Semicolon Insertion
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
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
Checking for 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
9. Operators
Operators and Objects
Assignment Operators
Compound Assignment Operators
Equality Operators: === Versus ==
Strict Equality (===, !==)
Normal (Lenient) Equality (==, !=)
There Are No Valid Use Cases for ==
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
Categorizing Values via typeof and instanceof
typeof: Categorizing Primitives
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
Logical Operators
Binary Logical Operators: And (&&) and Or (||)
Logical And (&&)
Logical Or (||)
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
Infinity
Two Zeros
The Internal Representation of Numbers
Special Exponents
Handling Rounding Errors
Integers in JavaScript
Ranges of Integers
Representing Integers as Floating-Point Numbers
Safe Integers
Converting to Integer
Integers via Math.floor(), Math.ceil(), and Math.round()
Integers via the Custom Function ToInteger()
32-bit Integers via Bitwise Operators
Integers via parseInt()
Arithmetic Operators
Bitwise Operators
Background Knowledge
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?)
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
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
for each-in
Conditionals
if-then-else
switch
The with Statement
Syntax and Semantics
The with Statement Is Deprecated
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
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
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
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
Unusual Property Keys
Bracket Operator ([]): Accessing Properties via Computed Keys
Converting Any Value to an Object
this as an Implicit Parameter of Functions and Methods
Calling Functions While Setting this: call(), apply(), and bind()
apply() for Constructors
Pitfall: Losing this When Extracting a Method
Pitfall: Functions Inside Methods Shadow this
Layer 2: The Prototype Relationship Between Objects
Inheritance
Overriding
Sharing Data Between Objects via a Prototype
Getting and Setting the Prototype
The Special Property __proto__
Setting and Deleting Affects Only Own Properties
Iteration and Detection of Properties
Listing Own Property Keys
Listing All Property Keys
Checking Whether a Property Exists
Examples
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
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
The instanceof Operator
Tips for Implementing Constructors
Data in Prototype Properties
Avoid Prototype Properties with Initial Values for Instance Properties
Avoid Nonpolymorphic Prototype Properties
Polymorphic Prototype Properties
Keeping Data Private
Private Data in the Environment of a Constructor (Crockford Privacy Pattern)
Private Data in Properties with Marked Keys
Private Data in Properties with Reified Keys
Keeping Global Data Private via IIFEs
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
A List of All Generic Methods
Pitfalls: Using an Object as a Map
Pitfall 1: Inheritance Affects Reading Properties
Pitfall 2: Overriding Affects Invoking Methods
Pitfall 3: The Special Property __proto__
The dict Pattern: Objects Without Prototypes Are Better Maps
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
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
The Maximum Length
Holes in Arrays
Creating Holes
Sparse Arrays Versus Dense Arrays
Which Operations Ignore Holes, and Which Consider Them?
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
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()
Evaluating Code Using new Function()
eval() Versus new Function()
Best Practices
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
Prefer Literals to Constructors
Don’t Be Clever
Acceptable Cleverness
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