Object-Oriented JavaScript - Third Edition电子书

Object-Oriented JavaScript - Third Edition

Object-Oriented JavaScript - Third Edition

Credits

About the Authors

About the Reviewer

www.PacktPub.com

Why subscribe?

Customer Feedback

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Errata

Piracy

Questions

1. Object-Oriented JavaScript

A bit of history

Browser wars and renaissance

The present

The future

ECMAScript 5

Strict mode in ES6

ECMAScript 6

Browser support for ES6

Babel

Object-oriented programming

Objects

Classes

Encapsulation

Aggregation

Inheritance

Polymorphism

OOP summary

Setting up your training environment

WebKit's web inspector

JavaScriptCore on a Mac

More consoles

Summary

2. Primitive Data Types, Arrays, Loops, and Conditions

Variables

Variables are case sensitive

Operators

Primitive data types

Finding out the value type - the typeof operator

Numbers

Octal and hexadecimal numbers

Binary Literals

Exponent literals

Infinity

NaN

Number.isNaN

Number.isInteger

Strings

String conversions

Special strings

String template literals

Booleans

Logical operators

Operator precedence

Lazy evaluation

Comparison

Undefined and null

Symbols

Primitive data types recap

Arrays

Adding/updating array elements

Deleting elements

Arrays of arrays

Conditions and loops

Code blocks

The if condition

The else clause

Checking if a variable exists

Alternative if syntax

Switch

Don't forget to break

Loops

While loops

Do-while loops

For loops

For...in loops

Comments

Exercises

Summary

3. Functions

What is a function?

Calling a function

Parameters

Default parameters

Rest parameters

Spread operators

Predefined functions

parseInt()

parseFloat()

isNaN()

isFinite()

Encode/decode URIs

eval()

A bonus - the alert() function

Scope of variables

Variable hoisting

Block scope

Functions are data

Anonymous functions

Callback functions

Callback examples

Immediate functions

Inner (private) functions

Functions that return functions

Function, rewrite thyself!

Closures

Scope chain

Breaking the chain with a closure

Closure #1

Closure #2

A definition and closure #3

Closures in a loop

Getter and setter

Iterator

IIFE versus blocks

Arrow functions

Exercises

Summary

4. Objects

From arrays to objects

Elements, properties, methods, and members

Hashes and associative arrays

Accessing an object's properties

Calling an object's methods

Altering properties/methods

Using the this value

Constructor functions

The global object

The constructor property

The instanceof operator

Functions that return objects

Passing objects

Comparing objects

Objects in the WebKit console

Logging using the console.log method

ES6 object literals

Object properties and attributes

ES6 object methods

Copy properties using Object.assign

Compare values with Object.is

Destructuring

Built-in objects

Object

Array

A few array methods

ES6 array methods

Array.from

Creating arrays using Array.of

Array.prototype methods

Function

Properties of function objects

Using the prototype property

Methods of function objects

Call and apply

The arguments object revisited

Lexical this in arrow functions

Inferring object types

Boolean

Number

String

A few methods of string objects

Math

Date

Methods to work with date objects

Calculating birthdays

RegExp

Properties of RegExp objects

Methods of RegExp objects

String methods that accept regular expressions as arguments

search() and match()

replace()

Replace callbacks

split()

Passing a string when a RegExp is expected

Error objects

Exercises

Summary

5. ES6 Iterators and Generators

For...of loop

Iterators and iterables

Iterators

Iterables

Generators

Iterating over generators

Collections

Map

Iterating over maps

Converting maps to arrays

Set

WeakMap and WeakSet

Summary

6. Prototype

The prototype property

Adding methods and properties using the prototype

Using the prototype's methods and properties

Own properties versus prototype properties

Overwriting a prototype's property with an own property

Enumerating properties

Using isPrototypeOf() method

The secret __proto__ link

Augmenting built-in objects

Augmenting built-in objects - discussion

Prototype gotchas

Exercises

Summary

7. Inheritance

Prototype chaining

Prototype chaining example

Moving shared properties to the prototype

Inheriting the prototype only

A temporary constructor - new F()

Uber - access to the parent from a child object

Isolating the inheritance part into a function

Copying properties

Heads-up when copying by reference

Objects inherit from objects

Deep copy

Using object() method

Using a mix of prototypal inheritance and copying properties

Multiple inheritance

Mixins

Parasitic inheritance

Borrowing a constructor

Borrowing a constructor and copying its prototype

Case study - drawing shapes

Analysis

Implementation

Testing

Exercises

Summary

8. Classes and Modules

Defining classes

Constructor

Prototype methods

Static methods

Static properties

Generator methods

Subclassing

Mixins

Modules

Export lists

Summary

9. Promises and Proxies

Asynchronous programming model

JavaScript call stack

Message queue

Event loop

Timers

Run to completion

Events

Callbacks

Promises

Creating promises

Promise.all()

Metaprogramming and proxies

Proxy

Function traps

Summary

10. The Browser Environment

Including JavaScript in an HTML page

BOM and DOM - an overview

BOM

The window object revisited

Using window.navigator property

Your console is a cheat sheet

Using window.location property

Using window.history property

using window.frames property

Using window.screen property

window.open()/close() method

window.moveTo() and window.resizeTo() methods

window.alert(), window.prompt(), and window.confirm() methods

Using window.setTimeout() and window.setInterval() methods

window.document property

DOM

Core DOM and HTML DOM

Accessing DOM nodes

The document node

documentElement

Child nodes

Attributes

Accessing the content inside a tag

DOM access shortcuts

Siblings, body, first, and last child

Walk the DOM

Modifying DOM nodes

Modifying styles

Fun with forms

Creating new nodes

DOM-only method

Using cloneNode() method

Using insertBefore() method

Removing nodes

HTML - only DOM objects

Primitive ways to access the document

Using document.write() method

Cookies, title, referrer, and domain

Events

Inline HTML attributes

Element Properties

DOM event listeners

Capturing and bubbling

Stop propagation

Prevent default behavior

Cross-browser event listeners

Types of events

XMLHttpRequest

Sending the request

Processing the response

Creating XMLHttpRequest objects in IE prior to Version 7

A is for Asynchronous

X is for XML

An example

Exercises

Summary

11. Coding and Design Patterns

Coding patterns

Separating behavior

Content

Presentation

Behavior

Example of separating behavior

Asynchronous JavaScript loading

Namespaces

An Object as a namespace

Namespaced constructors

A namespace() method

Init-time branching

Lazy definition

Configuration object

Private properties and methods

Privileged methods

Private functions as public methods

Immediate functions

Modules

Chaining

JSON

Higher order functions

Design patterns

Singleton pattern

Singleton 2 pattern

Global variable

Property of the constructor

In a private property

Factory pattern

Decorator pattern

Decorating a christmas tree

Observer pattern

Summary

12. Testing and Debugging

Unit testing

Test Driven Development

Behavior Driven Development

Mocha, Chai and Sinon

JavaScript debugging

Syntax errors

Using strict

Runtime exceptions

Console.log and asserts

Chrome Developer Tools

Summary

13. Reactive Programming and React

Reactive programming

Why should you consider reactive programming?

React

Virtual DOM

Installing and running react

Components and props

State

Life cycle events

Summary

A. Reserved Words

Keywords

ES6 reserved words

Future reserved words

Previously reserved words

B. Built-in Functions

C. Built-in Objects

Object

Members of the Object constructor

The Object.prototype members

ECMAScript 5 additions to objects

ES6 addition to objects

Property shorthand

Computed property names

Object.assign

Array

The Array.prototype members

ECMAScript 5 additions to Array

ES6 addition to arrays

Function

The Function.prototype members

ECMAScript 5 additions to a Function

ECMAScript 6 additions to a Function

Boolean

Number

Members of the Number constructor

The Number.prototype members

String

Members of the String constructor

The String.prototype members

ECMAScript 5 additions to String

ECMAScript 6 additions to String

Date

Members of the Date constructor

The Date.prototype members

ECMAScript 5 additions to Date

Math

Members of the Math object

RegExp

The RegExp.prototype members

Error objects

The Error.prototype members

JSON

Members of the JSON object

D. Regular Expressions

E. Answers to Exercise Questions

Chapter 2, Primitive Data Types, Arrays, Loops, and Conditions

Exercises

Chapter 3, Functions

Exercises

Chapter 4, Objects

Exercises

Chapter 5, Prototype

Exercises

Chapter 6, Inheritance

Exercises

Chapter 7, The Browser Environment

Exercises