精通JavaScript设计模式：提升Web应用效率与可维护性

需积分: 10 130 浏览量更新于2024-07-20 收藏 1.34MB PDF 举报

"Pro JavaScript Design Patterns" 是一本由 Ross Harmes 和 Dustin Diaz 合著的专业书籍，主要关注JavaScript设计模式的运用。这本书旨在帮助Web开发者深入理解JavaScript的面向对象编程原则，通过应用OOP（面向对象编程）理念、最佳实践和设计模式，提升代码的性能、效率，并使其更易于维护和团队协作。书中首先介绍了JavaScript中面向对象编程的基础，涵盖了如何使JavaScript更加表达力强，以及继承、封装、信息隐藏等核心概念。在基础部分之后，作者详细阐述了多个设计模式在JavaScript中的实现和应用，包括但不限于组合（Composites）、装饰器（Decorators）、外观（Facades）、适配器（Adapters）等。每个章节都包含真实世界的应用示例，以展示如何最有效地使用这些设计模式，同时提供了编写更好代码的专家建议和潜在陷阱的警示。此外，读者还将学习如何创建自己的库和API，以便进一步提高编码效率。本书的目标是让读者能够熟练掌握JavaScript设计模式，从而提升JavaScript开发的水平。无论是对于个人项目还是团队合作，都能从中受益。通过阅读 "Pro JavaScript Design Patterns"，你将能够： 1. 掌握JavaScript面向对象编程的基础，了解其在设计模式中的应用。 2. 学习并应用多种设计模式来提升JavaScript项目的开发。 3. 通过真实世界案例理解每个设计模式的最佳实践。 4. 获得编写高效、可维护代码的技巧和建议。 5. 学会创建自定义库和API，优化编程流程。这本书适合有一定JavaScript基础，希望通过学习设计模式提升编程技能的开发者阅读。通过深入学习和实践，你可以将JavaScript的潜力发挥到极致，开发出更强大、更高效的Web应用。

them. This type of reader will already be familiar with the basic JavaScript syntax and will focus

more on the sections that deal with converting existing code to implement specific patterns,

and explanations of when each pattern should or shouldn’t be used.

The second type of readers are programmers who are more involved with server-side

languages such as Java and C++ and are relative beginners in JavaScript. They wish to use

their knowledge of design patterns and object-oriented programming and put it to use in

a client-side language. This book will teach these readers how to implement commonly

used object-oriented idioms in JavaScript, such as interfaces, inheritance, and encapsula-

tion. These readers will find the code samples particularly useful because they may not be

familiar with the differences in syntax between JavaScript and other object-oriented lan-

guages. This type of reader may already be familiar with specific design patterns and so

may get more out of the JavaScript-specific, object-oriented techniques covered in Part 1.

Readers who are unfamiliar with the basics of JavaScript and object-oriented program-

ming may have a tough time following some of the examples. This is not an entry-level text,

and it assumes a certain level of programming knowledge. That being said, we do our best to

explain each concept as simply and clearly as possible, to make it easy to understand regard-

less of your level of expertise.

How This Book Is Structured

This book is divided into two parts. Part 1 covers the basics of object-oriented JavaScript. The

chapters are intended to be read sequentially. Each chapter builds on the one before it and

assumes that you have read all preceding chapters. It is a good idea to read these chapters all

the way through because the chapters in Part 2 use the techniques described in Part 1, in some

cases without further explanations.

Part 2 covers specific design patterns and their practical applications in JavaScript. Each

chapter can be read in whatever order you like. Some chapters reference other chapters, either in

Part 1 or Part 2, but we always give the chapter number where more information can be found.

Part 1

Chapter 1: Expressive JavaScript

We dive into the expressive nature of the JavaScript language. We look at how the language

allows you to use different styles to accomplish similar tasks, and how you can take alternative

approaches to object-oriented programming by using concepts from functional programming.

We discuss why you should use design patterns in the first place, and how adapting them to the

JavaScript language will make your code more efficient and easier to work with.

Chapter 2: Interfaces

We look at how other object-oriented languages implement interfaces and try to emulate the

best features of each in JavaScript. We explore the options available for interface checking and

come up with a reusable class that can be used to check objects for needed methods.

■INTRODUCTIONxxii

908Xch00FM.qxd 11/16/07 1:05 PM Page xxii

Chapter 3: Encapsulation and Information Hiding

We explore the different ways in which objects can be created in JavaScript, and the techniques

available within each to create public, private, and protected methods. We also take a look at the

situations where using complex encapsulated objects can benefit the JavaScript programmer.

Chapter 4: Inheritance

We look at the techniques that can be used to create subclasses in JavaScript. We cover both

classical and prototypal inheritance, and outline the situations where it is appropriate to use

each. We also discuss mixin classes and how they can be used as an alternative to multiple

inheritance.

Chapter 5: The Singleton Pattern

We discuss the uses of the singleton pattern in JavaScript. We cover namespacing, code organi-

zation, and branching, which can be used to define methods dynamically based on the run-time

environment. We look at the patterns that benefit from being coupled with singletons, such as

factories and flyweights.

Chapter 6: Chaining

We explore JavaScript’s ability to chain methods together and how this can lead to cleaner, more

elegant code. We adapt this technique to create a small JavaScript library and compare the meth-

ods within it to the equivalent implementations that don’t utilize chaining.

Part 2

Chapter 7: The Factory Pattern

We look at the factory pattern, which helps decouple the classes that instantiate each other

and instead uses a method to decide which specific class to instantiate. We discuss the simple

factory pattern, which uses a separate class (often a singleton) to create instances, and the

more complex factory pattern, which uses subclasses to decide what concrete class to instan-

tiate as a member object.

Chapter 8: The Bridge Pattern

We look at a way of connecting two objects together without tightly coupling them. Bridges

link two objects together while allowing them both to vary independently. We show you how

to use bridges to loosely tie functions to events. We build an asynchronous connection queue

to show how bridges can be used to keep your implementation code clean.

Chapter 9: The Composite Pattern

We explore a design pattern that is tailor-made for creating dynamic user interfaces on the Web:

the composite pattern. We show you how to use this pattern to initiate complex or recursive

■INTRODUCTION xxiii

908Xch00FM.qxd 11/16/07 1:05 PM Page xxiii

behaviors on many objects with a single command, and how to use it to organize objects into

complex hierarchies. We walk through the steps needed to implement the composite pattern

and discuss situations where it might be useful.

Chapter 10: The Facade Pattern

We discuss a way to create a more fully featured interface for an object. The facade pattern can

be used to convert an existing interface into one that you can use more easily. We explain how

most JavaScript libraries are facades over the specific browser’s implementation of the lan-

guage. We show you how to use this pattern to create convenience methods, and how facades

are used to create an event utility library.

Chapter 11: The Adapter Pattern

We examine a pattern that allows you to mold existing interfaces to meet your needs. Adapters,

also called wrappers, replace an incompatible interface with one that works in an existing sys-

tem. We explore the ways the adapter can be used to reconcile the differences in JavaScript

libraries and make the transition from one to another easier. We look at a webmail API and cre-

ate an adapter that helps you transition to a new version.

Chapter 12: The Decorator Pattern

We look at a way to add features to objects without creating new subclasses. The decorator

pattern is used to transparently wrap objects within another object of the same interface. We

examine the structure of the decorator and how it can be coupled with the factory pattern to

create nested objects automatically. We create a profiler to show how the decorator can be

used to implement an interface dynamically.

Chapter 13: The Flyweight Pattern

We examine another optimization pattern, the flyweight. We show how it can be used to dra-

matically reduce the number of objects needed to implement your applications, by converting

many independent objects into a few shared objects. We create a web calendar and a reusable

tooltip class to show how classes can be converted to the flyweight pattern.

Chapter 14: The Proxy Pattern

We look at the proxy pattern, which can be used to control access to other objects. We show how

a proxy can be instantiated in place of this real subject, and allow it to be accessed remotely. We

examine the uses of the proxy, including delaying instantiation of a computationally expensive

class. We create a general class that can be used to delay the loading of any class.

Chapter 15: The Observer Pattern

We examine a way to observe the state of an object and be notified if it changes. The observer

pattern, also known as the publisher-subscriber pattern, lets objects listen for events and act

upon them. We use the newspaper industry as an example of the different ways the observer

pattern can work. We look at the different events you can subscribe to when using an anima-

tion library.

■INTRODUCTIONxxiv

908Xch00FM.qxd 11/16/07 1:05 PM Page xxiv

Chapter 16: The Command Pattern

We look at a way to encapsulate the invocation of a method. The command pattern gives you

the ability to parameterize and pass around a method call, which can then be executed when-

ever you need it. We show that this pattern can be used in many different situations–for instance,

for creating user interfaces, especially where an unlimited undo action is required. We discuss

the structure of the command pattern and give several practical examples of how it can be

used in JavaScript.

Chapter 17: The Chain of Responsibility Pattern

We look at the chain of responsibility pattern, which allows you to decouple the sender and

the receiver of a request. We explain how this pattern is used in JavaScript to handle event cap-

turing and bubbling. We explore how you can use this pattern to create more loosely coupled

modules and to optimize event attachment.

Prerequisites

In order to make the code examples in this book as clear and focused as possible, we use sev-

eral convenience functions to perform tasks such as event listener attachment, subclassing,

cookie manipulation, and references to HTML elements. Rather than choose a particular

library, such as YUI or jQuery, we decided to keep our code library-agnostic, so that it can be

adapted to whatever library the reader prefers. Each major library has functions that corre-

spond to the convenience methods we use. The full code can be downloaded at the book’s

website, http://jsdesignpatterns.com, and at the Apress website, http://www.apress.com.

Here is a brief description of each function:

• $(id): Gets a reference to an HTML element based on ID. Can take a string or an array

of strings as an argument.

• addEvent(obj, type, func): Attaches function func as a listener to the element obj. type

specifies the event that the function should listen for.

• addLoadEvent(func): Attaches function func to the window object’s load event.

• getElementsByClass(searchClass, node, tag): Gets references to all elements with the

class searchClass. Has two optional arguments, node and tag, that can be used to

narrow the search. Returns an array.

• insertAfter(parent, node, referenceNode): Inserts element node into the parent ele-

ment, after referenceNode.

• getCookie(name): Gets the string associated with cookie name.

• setCookie(name, value, expires, path, domain, secure): Sets the string associated with

cookie name to value. All other arguments are optional.

• deleteCookie(name): Sets the expiration date for cookie name in the past.

• clone(object): Creates a copy of object. Used in prototypal inheritance, and covered in

Chapter 4.

■INTRODUCTION xxv

908Xch00FM.qxd 11/16/07 1:05 PM Page xxv

剩余280页未读，继续阅读

xym9616

粉丝: 0
资源: 14

精通JavaScript设计模式：提升Web应用效率与可维护性

Learning JavaScript Design Patterns - Addy Osmani.pdf

pro javascript design patterns

Learning JavaScript Design Patterns

mastering javascript design patterns, 3rd edition

23 design patterns in C++ code

design patterns elements of reusable object-oriented software下载

modern c++ design: generic programming and design patterns pdf

dive into design patterns 中文

hands-on design patterns with c++下载

design patterns 有哪些

最新资源