Ajax设计模式(影印版)(赠品)（活动已结束）

.ajax patterns overuiew
anatomy ora pattern
ajax patterns demos
conclusions
part two foundational technology patterns
4 ajax app
ajax app
5 display manipulation
display morphing
page rearrangement
6 web remoting
web service
xmlhttprequest call
i frarne call
http streaming
on-demand javascript
7 dynamic behavior
user action
scheduling
8 extended technologies
richer plugin
part three programming patterns
9 web services
restful service
rpc service
ajax stub
html message
plain-text message
xml message
json message
10 browser-server dialogue
call tracking
periodic refresh
submission throttling
explicit submission
distributed events
cross-domain proxy
11 dom population
xml data island
browser-side xslt
browser-side templating
12 code generation and reuse
server-side code generation
cross-browser component
13 performance optimization
browser-side cache
predictive fetch
guesstimate
multi-stage download
fat client
part four functionality and usability patterns..
14 widgets
slider
progress indicator
drilldown
data grid
rich text editor
suggestion
live search
live command-line
live form
15 page architecture
drag-and-drop
sprite
popup
malleable content
microlink
portlet
status area
update control
virtual workspace
16 visual effects
one-second spotlight
one-second mutation
one-second motion
highlight
17 functionality
lazy registration
direct login
host-proof hosting
timeout
heartbeat
unique urls
part five development patterns
18 diagnosis
logging
debugging
dom inspection
traffic sniffing
19 testing
simulation service
browser-side test
service test
system test
part six appendixes
a ajax frameworks and libraries
b setting up the code examples
c patterns and pattern languages
d references
index...

.　　along with an introduction to the patterns themselves.
　　Part II, Foundational Technology Patterns
　　The Foundational Technology patterns outline the "building blocks" at the heart of any Ajax application. Ajax itself is a pattern, hence the first pattern, Ajax App (Chapter 4),which acts as the root for all the Ajax Patterns. The next few chapters look at the three core technologies involved in creating an Ajax App. Display Manipulation (Chapter 5) patterns are about repainting the user interface, and Web Remoting (Chapter 6) patterns document several alternatives for communicating with the server. The Dynamic Behavior (Chapter 7) patterns are about events--those derived by users and those based on timing. Finally, Extended Technologies (Chapter 8) explain how you can
　　extend an Ajax App with nonstandard technologies.
　　Part III, Programming Patterns
　　The Programming patterns focus on technical qualities of software, in particular maintainability, robustness, and performance. The first chapter in this part, Chapter 9, provides several alternative strategies for designing Web Services. Also related to Web Remoting, the Browser-Server Dialogue (Chapter 10) patterns look at the flow of information between browser and server; e.g., synchronization techniques. The DOM Population (Chapter 11 ) patterns cover several strategies for handling DOM population
　　* It would have been nice to ensure full compatibility for all mojor browsers (e.g., Safari, Opera), and that's certainly advisable for production systems, but portability was considered orthogonal to the individual demos, each aiming to expose information about a particular Ajax concept.
　　following a server response. Code Generation and Reuse (Chapter 12) contains a couple of general programming patterns for maintainability and portability. Finally, the Performance Optimization (Chapter 13) patterns are about improving not only speed of updates and communication, but also optimizing the user experience in the face of inevitable delays.
　　Part IV, Funcffonality and Usability Patterns
　　The Functionality and Usability patterns are focused on usability of Ajax applications.Chapter 14 introduces a number of widgets that are being woven into many Ajax interfaces. A higher-level perspective is taken by the Page Architecture (Chapter 15) patterns, where the focus is on page layout, content breakdown, and techniques for exposing server-side content. With the popularity of Ajax, the Web is undergoing a rise in visual effects somewhat unprecedented on conventional desktop systems, and the most common effects are described in the Visual Effects (Chapter 16) patterns. The patterns in the final chapter of this part, Functionality (Chapter 17) patterns, are about new kinds of functionality that Ajax makes possible.
　　Part V, Development Patterns
　　The Development patterns are not "things" in the same sense as the patterns in previous patterns, but "processes" you can use to aid development. Diagnosis Patterns (Chapter 18) helps with troubleshooting and monitoring the health of an Ajax App.Testing Patterns (Chapter 19) helps with testing at various levels and is based on the agile practice of testing as the application evolves.
　　Part VI, Appendixes
　　There are four appendix sections. Appendix A, the largest appendix, is a listing of Ajaxrelated frameworks and libraries, many of which are a great aid in implementing some of the patterns described in this book. Appendix B is a set of installation notes for the code examples. Appendix C places the work here in the context of general design pattern theory. Finally, Appendix D lists texts referenced throughout the book.
　　Conventions Used in This Book
　　Italics
　　Used for names of patterns
　　Constant width
　　Used for code examples and fragments
　　Constant width bold
　　Used for important or significant lines of code ..
　　The term "the browser" is shorthand for the entire system at the browser end--not only the browser application (e.g., Firefox), but also the web application running inside it (e.g.,Google Maps). When I'm talking about the browser application, I'll usually call it a "web browser"--it's fairly obvious from the context anyway. Likewise, "the server" or "the server side" refers to everything on the server--the operating system (e.g., Linux), the web server (e.g., Apache), as well as the application-specific scripts running within.
　　The terms "ECMAScript' and "JScript' don't appear--"JavaScript' is meant to cover these terms.
　　The term "class" is used to describe JavaScript functions that are used in a manner similar to classes in object-oriented systems.
　　The first figure that appears in each pattern's section is an illustrated overview of that particular pattern.
　　Some common acronyms used throughout the book are:
　　· CSS: Cascading Style Sheets
　　· DHTML: Dynamic HTML
　　· DOM: Document Object Model
　　· HTML: Hypertext Markup Language
　　· IE: Microsoft Internet Explorer
　　· XML: eXtensible Markup Language
　　Conventions in Code Examples
　　Design diagrams are based on Universal Modelling Language (UML) notation, though less formal in most cases.
　　In the code examples, a. phtml suffix is used for PHP files that output HTML; all other PHP files (such as business logic modules) end in. php.
　　As illustrated in Chapter 2, $( ) is aliased to document.getElementById( ) to reduce code clutter (inspired by the prototype library--see http://prototype.conio.net/).
　　Some code examples have been reformatted for the sake of clarity.
　　Safari Enabled
　　When you see a Safari~ Enabled icon on the cover of your favorite technology book, that means the book is available online through the O'Reilly Network Safari Bookshelf.
　　Safari offers a solution that's better than e-books. It's a virtual library that lets you easily search thousands of top tech books, cut and paste code samples, download chapters, and find quick answers when you need the most accurate, current information. Try it for free at http://safari.oreilly.com.
　　How to Contact Us
　　Please address comments and questions concerning this book to the publisher:
　　O'Reilly Media, Inc.
　　1005 Gravenstein Highway North
　　Sebastopol, CA 95472
　　800-998-9938 (in the United States or Canada)
　　707-829-0515 (international or local)
　　707-829-0104 (fax)
　　We have a web page for this book, where we list errata, examples, and any additional information. You can access this page at:
　　http://www.oreilly.com/catalog/ajaxdp/
　　There's also web page for this book, containing full draft text for all patterns and links to an increasing collection of audio podcasts about the patterns. In addition, you'll find information on various Ajax resources and errata for this book. The web page is located at:
　　http://ajaxpatterns.org
　　To comment or ask technical questions about this book, send email to:
　　bookquestions@oreilly.com
　　For more information about our books, conferences, Resource Centers, and the O'Reilly Network, see our web site at:
　　http ://www.oreilly.com
　　Acknowledgments
　　Writing this book online means I received lots of excellent feedback throughout the process and have many people to thank. Which is another way of saying it's highly probable I'll leave someone out! If that's the case, please mail me any corrections.
　　My editor, Simon St. Laurent, has always been quick to respond to my queries and dealt admirably with a book being written in a somewhat unusual manner. Thanks also to proofreader Mary Brady for leaving no stone unturned, and illustrator Rob Romano for helping to make the content accessible at a glance. I also want to express my appreciation to O'Reilly for taking on the Ajax Patterns and especially for letting me write the book online, and blog and podcast about the content without restriction.
　　The book grew from a blog post on Ajax Patterns (http://softwareas.com/ajax-patterns), and it was the insight of Thomas Baekdal to cover Ajax usability principles that inspired to the initial patterns post (http://www. baekdal, eom/articles/Usability/XMLHttpRequest-guidelines). I also have Brent Ashley to thank for his discussing the,patterns at the initial Ajax summit and in his blog, apparently the trigger for the initial ripple of online interest in the project.
　　The ideas in this book also owe a great deal to Jesse-James Garrett and his seminal Ajax article, without which you would not be reading these words.
　　All the book reviewers provided valuable feedback on the online version throughout the writing process as well as offering many detailed comments on the book's draft version.The reviewers were: Cameron Shorter (ADI Limited, Mapbuilder) and Kevin Vinsen (ADI Limited), whose employer, ADI Limited, provided time for them both to conduct the review; Jep Castelein (Backbase), Daniel Czarnecki (Zoltak Consulting), Tony Hill (Thomson Corporation), and Alex Kirk (Blummy.com, WizLite.com). In addition, a big thanks to members of the Software Architecture Group (SAG) at the University of Illinois at UrbanaChampaign for conducting several rich discussions on the patterns and making the audio publicly available (http://www.softwareas.com/sag-ajax-patterns-review-1)--the comments certainly made a difference as the editing moved into its final stages. Ralph Johnson, who leads the group, nominated the Ajax Patterns for review, and Brian Foote kept me informed throughout the process. I'm also grateful to everyone who added to the public portions of the AjaxPatterns.org wiki and offered feedback on the online draft via email,blog comments, and in wiki discussions.
　　As the patterns were discovered from many existing applications, I would like to thank the creators of all the examples featured in the pattern descriptions, many of them true pioneers. Special thanks to those developers who explained aspects of their designs to me:Kevin Arthur (Stream), Richard Cowin and Bill Scott (OpenRico), Donovan Preston (LivePage), Jeremy Ruston (TiddlyWiki), and Tino "Crisp" Zijdel (DHTML Lemmings). The patterns are also based on numerous writings, code dissections, ideas, proofs-of-concept, and direct suggestions. In particular, a number of patterns are only here because of the contributions of the following authors and developers (also mentioned in individual pattern descriptions): Julien Couvreur, James Dam, Abe Fettig (Twisted, Jotspot), Chris Justus,Christopher Kruslicky, Alex Russell (Dojo, Jotspot), Richard Schwartz, Mike Stenhouse,Joel Webber, and Chris Were. In addition, there were several news-focused services that made it a lot easier to locate all this content as it happened (and also helped other people find AjaxPatterns.org!). Among these resources: Niner Niner's AjaxBlog.com, Chris Cornutt's AjaxDeveloper.org (Chris is now with Ajaxian.com), Dion Almaer, Ben Galbraith,and Rob Sanheim at Ajaxian.com (disdaimer: I've since joined the Ajaxian team), Shane Witbeck's AjaxMatters.com, Mike Papageorge's FiftyFourEleven.com, Brian Benzinger's SolutionWatch.com, and Mike Arrington's Techcrunch.com.
　　Last but not least, heaps of gratitude to my family for their support throughout the writing process. ...