Advanced JavaScript电子书

Preface

About the Book

About the Author

Objectives

Audience

Approach

Minimum Hardware Requirements

Software Requirements

Installing the Code Bundle

Additional Resources

Conventions

Installing Atom IDE

Installing Node.js and npm

Chapter 1

Introducing ECMAScript 6

Introduction

Beginning with ECMAScript

Understanding Scope

Function Scope

Function Scope Hoisting

Block Scope

Exercise 1: Implementing Block Scope

Declaring Variables

Exercise 2: Utilizing Variables

Introducing Arrow Functions

Exercise 3: Converting Arrow Functions

Arrow Function Syntax

Exercise 4: Upgrading Arrow Functions

Learning Template Literals

Exercise 5: Converting to Template Literals

Exercise 6: Template Literal Conversion

Enhanced Object Properties

Object Properties

Function Declarations

Computed Properties

Exercise 7: Implementing Enhanced Object Properties

Destructuring Assignment

Array Destructuring

Exercise 8: Array Destructuring

Rest and Spread Operators

Object Destructuring

Exercise 9: Object Destructuring

Exercise 10: Nested Destructuring

Exercise 11: Implementing Destructuring

Classes and Modules

Classes

Exercise 12: Creating Your Own Class

Classes – Subclasses

Modules

Export Keyword

Import Keyword

Exercise 13: Implementing Classes

Transpilation

Babel- Transpiling

Exercise 14: Transpiling ES6 Code

Iterators and Generators

Iterators

Generators

Exercise 15: Creating a Generator

Activity 1: Implementing Generators

Summary

Chapter 2

Asynchronous JavaScript

Introduction

Asynchronous Programming

Sync Versus Async

Synchronous versus Asynchronous Timing

Introducing Event Loops

Stack

Heap and Event Queue

Event Loops

Things to Consider

Exercise 16: Handling the Stack with an Event Loop

Callbacks

Building Callbacks

Callback Pitfalls

Fixing Callback Hell

Exercise 17: Working with Callbacks

Promises

Promises States

Resolving or Rejecting a Promise

Using Promises

Exercise 18: Creating and Resolving Your First Promise

Handling Promises

Promise Chaining

Promises and Callbacks

Wrapping Promises in Callbacks

Exercise 19: Working with Promises

Async/Await

Async/Await Syntax

Asnyc/Await Promise Rejection

Using Async Await

Activity 2: Using Async/Await

Summary

Chapter 3

DOM Manipulation and Event Handling

Introduction

DOM Chaining, Navigation, and Manipulation

Exercise 20: Building the HTML Document from a DOM Tree Structure

DOM Navigation

Finding a DOM Node

Traversing the DOM

DOM Manipulation

Updating Nodes in the DOM

Updating Nodes in the DOM

Exercise 21: DOM Manipulation

DOM Events and Event Objects

DOM Event

Event Listeners

Event Objects and Handling Events

Event Propagation

Firing Events

Exercise 22: Handling Your First Event

Custom Events

Exercise 23: Handling and Delegating Events

JQuery

jQuery Basics

jQuery Selector

jQuery DOM Manipulation

Selecting Elements

Traversing the DOM

Modifying the DOM

Chaining

jQuery Events

Firing Events

Custom Events

Activity 3: Implementing jQuery

Summary

Chapter 4

Testing JavaScript

Introduction

Testing

Reasons to Test Code

Test-driven Development

TDD Cycle

Conclusion

Exercise 24: Applying Test-Driven Development

Types of Testing

Black Box and White Box Testing

Unit Tests

Exercise 25: Building Unit Tests

Functional Testing

Integration Tests

Building Tests

Exercise 26: Writing Tests

Test Tools and Environments

Testing Frameworks

Mocha

Setting Up Mocha

Mocha Basics

Exercise 27: Setting Up a Mocha Testing Environment

Mocha Async

Mocha Hooks

Activity 4: Utilizing Test Environments

Summary

Chapter 5

Functional Programming

Introduction

Introducing Functional Programming

Object-Oriented Programming

Functional Programming

Declarative Versus Imperative

Imperative Functions

Declarative Functions

Exercise 28: Building Imperative and Declarative Functions

Pure Functions

Same Output Given Same Input

No Side Effects

Referential Transparency

Exercise 29: Building Pure Controllers

Higher Order Functions

Exercise 30: Editing Object Arrays

Shared State

Exercise 31: Fixing Shared States

Immutability

Immutability in JavaScript

Side Effects

Avoiding Side Effects

Function Composition

Activity 5: Recursive Immutability

Summary

Chapter 6

The JavaScript Ecosystem

Introduction

JavaScript Ecosystem

Frontend JavaScript

Command-Line Interface

Mobile Development

Backend Development

Node.js

Setting Up Node.js

Node Package Manager

Loading and Creating Modules

Exercise 32: Exporting and Importing NPM Modules

Basic Node.js Server

Exercise 33: Creating a Basic HTTP Server

Streams and Pipes

Types of Streams

Writeable Stream Events:

Readable Stream Events:

Filesystem Operations

Express Server

Exercise 34: Creating a Basic Express Server

Routing

Advanced Routing

Middleware

Error Handling

Exercise 35: Building a Backend with Node.js

React

Installing React

React Basics

React Specifics

JSX

ReactDOM

React.Component

State

Conditional Rendering

List of Items

HTML Forms

Activity 6: Building a Frontend with React

Summary

Appendix

Chapter 1: Introducing ECMAScript 6

Activity 1 – Implementing Generators

Chapter 2: Asynchronous JavaScript

Activity 2 – Using Async/Await

Chapter 3: DOM Manipulation and Event Handling

Activity 3 – Implementing jQuery

Chapter 4: Testing JavaScript

Activity 4 – Utilizing Test Environments

Chapter 5: Functional Programming

Activity 1 – Recursive Immutability

Chapter 6: JavaScript Ecosystem

Activity 6 – Building a Frontend with React