Closure: The Definitive Guide

Tools for adding power to your JavaScript

Larger Cover

Tools for adding power to your JavaScript

By Michael Bolin

Publisher: O'Reilly Media

Released: September 2010

Pages: 592

Chapter 1 Introduction to Closure
1. Tools Overview
2. Closure Design Goals and Principles
3. Downloading and Installing the Tools
4. Example: Hello World
Chapter 2 Annotations for Closure JavaScript
1. JSDoc Tags
2. Type Expressions
3. JSDoc Tags That Do Not Deal with Types
4. Is All of This Really Necessary?
Chapter 3 Closure Library Primitives
1. Dependency Management
2. Function Currying
3. Exports
4. Type Assertions
5. Unique Identifiers
6. Internationalization (i18n)
7. Object Orientation
8. Additional Utilities
Chapter 4 Common Utilities
1. goog.string
2. goog.array
3. goog.object
4. goog.json
5. goog.dom
6. goog.dom.classes
7. goog.userAgent
8. goog.userAgent.product
9. goog.net.cookies
10. goog.style
11. goog.functions
Chapter 5 Classes and Inheritance
1. Example of a Class in Closure
2. Example of a Subclass in Closure
3. Example of an Interface in Closure
4. Multiple Inheritance
5. Enums
6. goog.Disposable
Chapter 6 Event Management
1. A Brief History of Browser Event Models
2. Closure Provides a Consistent DOM Level 2 Events API Across Browsers
3. Handling Keyboard Events
Chapter 7 Client-Server Communication
1. Server Requests
2. Resource Loading and Monitoring
3. Cross-Domain Communication
4. Uploading Files
5. Comet
Chapter 8 User Interface Components
1. Design Behind the goog.ui Package
2. goog.ui.Component
3. goog.ui.Control
4. goog.ui.Container
5. Using Common Components
6. Creating Custom Components
Chapter 9 Rich Text Editor
1. Design Behind the goog.editor Package
2. Creating an Editable Region
3. Extending the Editor: The Plugin System
4. UI Components
5. Selections
Chapter 10 Debugging and Logging
1. Creating Logging Information
2. Displaying Logging Information
3. Profiling JavaScript Code
4. Reporting JavaScript Errors
Chapter 11 Closure Templates
1. Limitations of Existing Template Systems
2. Introducing Closure Templates
3. Creating a Template
4. Internationalization (i18n)
5. Compiling Templates
6. Defining a Custom Function
Chapter 12 Using the Compiler
1. Benefits of Using the Compiler
2. How the Compiler Works
3. Compiler Options
4. Running the Compiler
5. Integrating the Compiler into a Build Process
6. Partitioning Compiled Code into Modules
Chapter 13 Advanced Compilation
1. What Happens During Compilation
2. Preparing Code for the Compiler
3. Checks Provided by the Compiler
4. Optimizations Performed by the Compiler
Chapter 14 Inside the Compiler
1. Tour of the Codebase
2. Hidden Options
3. Example: Extending CommandLineRunner
4. Example: Visualizing the AST Using DOT
5. Example: Creating a Compiler Check
6. Example: Creating a Compiler Optimization
Chapter 15 Testing Framework
1. Creating Your First Test
2. Mock Objects
3. Testing to Ensure That an Error Is Thrown
4. Testing Input Events
5. Testing Asynchronous Behavior
6. Running a Single Test
7. Running Multiple Tests
8. Automating Tests
9. System Testing
Chapter 16 Debugging Compiled JavaScript
1. Verify That the Error Occurs in Uncompiled Mode
2. Format Compiled Code for Debugging
3. Compile with --debug=true
4. Use the Closure Inspector

Appendix Inheritance Patterns in JavaScript
1. Example of the Functional Pattern
2. Example of the Pseudoclassical Pattern
3. Drawbacks to the Functional Pattern
4. Potential Objections to the Pseudoclassical Pattern
Appendix Frequently Misunderstood JavaScript Concepts
1. JavaScript Objects Are Associative Arrays Whose Keys Are Always Strings
2. There Are Several Ways to Look Up a Value in an Object
3. Single-Quoted Strings and Double-Quoted Strings Are Equivalent
4. There Are Several Ways to Define an Object Literal
5. The prototype Property Is Not the Prototype You Are Looking For
6. The Syntax for Defining a Function Is Significant
7. What this Refers to When a Function Is Called
8. The var Keyword Is Significant
9. Block Scope Is Meaningless
Appendix plovr
1. Getting Started with plovr
2. Config Files
3. Build Command
4. Serve Command
5. Generating Externs from Exports
6. Generating a Source Map
Colophon

Title:

Closure: The Definitive Guide

By:

Michael Bolin

Publisher:

O'Reilly Media

Formats:

Print
Ebook
Safari Books Online

Print:

September 2010

Ebook:

September 2010

Pages:

592

Print ISBN:

978-1-4493-8187-5

| ISBN 10:

1-4493-8187-1

Ebook ISBN:

978-1-4493-8189-9

| ISBN 10:

1-4493-8189-8

Colophon

The animal on the cover of Closure: The Definitive Guide is a European golden plover (Pluvialis apricaria). These birds are named for the beautiful gold spots on their backs and wings. Their plumage varies greatly between seasons, however. In the summer, their mating season, golden plovers have black feathers on their faces, necks, and bellies, separated by a white line (as seen on the cover of this book). They molt before the winter, and the darker color gives way to yellow or white.

Members of the plover family are identifiable by their small heads, short beaks, and plump bodies. They also have a distinctive manner of feeding, a run-pause-and-peck technique. Foraging by sight, golden plovers largely eat insects, but they also feed on plant matter, berries, and crustaceans. They prefer tundra and moor habitats, and have a large range, living in northern Europe and western Asia during the summer and migrating to southern Europe and northern Africa in the winter. The golden plovers of the Americas (a different species) migrate up to 2,000 miles annually.

Generally, all plovers are known for “distraction displays.” For instance, they will spend time sitting on an imaginary nest to protect the actual site or feign a broken wing when a predator is near. A group of plovers can be referred to in many ways: a brace, congregation, deceit, ponderance, or wing.

The cover image is from Johnson’s Natural History. The cover font is Adobe ITC Garamond. The text font is Linotype Birka; the heading font is Adobe Myriad Condensed; and the code font is LucasFont’s TheSansMonoCondensed.

Description

Table of Contents

Product Details

About the Author

Colophon

Recommended for You

Chapter 1 Introduction to Closure

Tools Overview

Closure Design Goals and Principles

Downloading and Installing the Tools

Example: Hello World

Chapter 2 Annotations for Closure JavaScript

JSDoc Tags

Type Expressions

JSDoc Tags That Do Not Deal with Types

Is All of This Really Necessary?

Chapter 3 Closure Library Primitives

Dependency Management

Function Currying

Exports

Type Assertions

Unique Identifiers

Internationalization (i18n)

Object Orientation

Additional Utilities

Chapter 4 Common Utilities

goog.string

goog.array

goog.object

goog.json

goog.dom

goog.dom.classes

goog.userAgent

goog.userAgent.product

goog.net.cookies

goog.style

goog.functions

Chapter 5 Classes and Inheritance

Example of a Class in Closure

Example of a Subclass in Closure

Example of an Interface in Closure

Multiple Inheritance

Enums

goog.Disposable

Chapter 6 Event Management

A Brief History of Browser Event Models

Closure Provides a Consistent DOM Level 2 Events API Across Browsers

Handling Keyboard Events

Chapter 7 Client-Server Communication

Server Requests

Resource Loading and Monitoring

Cross-Domain Communication

Uploading Files

Comet

Chapter 8 User Interface Components

Design Behind the goog.ui Package

goog.ui.Component

goog.ui.Control

goog.ui.Container

Using Common Components

Creating Custom Components

Chapter 9 Rich Text Editor

Design Behind the goog.editor Package

Creating an Editable Region

Extending the Editor: The Plugin System

UI Components

Selections

Chapter 10 Debugging and Logging

Creating Logging Information

Displaying Logging Information

Profiling JavaScript Code

Reporting JavaScript Errors

Chapter 11 Closure Templates

Limitations of Existing Template Systems

Introducing Closure Templates

Creating a Template

Internationalization (i18n)

Compiling Templates

Defining a Custom Function

Chapter 12 Using the Compiler

Benefits of Using the Compiler

How the Compiler Works

Compiler Options

Running the Compiler

Integrating the Compiler into a Build Process

Partitioning Compiled Code into Modules