Secrets Of The JavaScript Ninja




e-books shop
Secrets Of The
JavaScript Ninja

about the authors
John Resig is the Dean of Computer Science at Khan
Academy and the creator of the jQuery JavaScript
library. jQuery is currently used in 58% of the top
10,000 websites (according to and is
used on tens of millions of other sites, making it one
of the most popular technologies used to build websites
and possibly one of the most popular programming
technologies of all time.
He’s also created a number of other open source
utilities and projects, including Processing.js (a port
of the Processing language to JavaScript), QUnit (a
test suite for testing JavaScript code), and TestSwarm
(a platform for distributed JavaScript testing).
He is currently working to take Computer Science education a step further at
Khan Academy, where he’s developing Computer Science curriculum and tools to
teach people of all ages how to program. Khan Academy’s goal is to create excellent
educational resources that are freely available for all to learn from. He’s working to
not just teach people how to program, but to replicate the initial spark of excitement
that every programmer has felt after writing their first program.
Currently, John is located in Brooklyn, NY, and enjoys studying Ukiyo-e (Japanese
woodblock printing) in his spare time.

Bear Bibeault has been writing software for over
three decades, starting with a Tic-Tac-Toe program
written on a Control Data Cyber supercomputer via
a 100-baud teletype. Because he has two degrees in
Electrical Engineering, Bear should be designing
antennas or something; but since his first job with
Digital Equipment Corporation, he has always been
much more fascinated with programming.
Bear has also served stints with companies such
as Lightbridge Inc., BMC Software, Dragon Systems,, and a handful of other companies. Bear
even served in the U.S. Military, teaching infantry soldiers how to blow up tanks—
skills that come in handy during those daily scrum meetings.
Bear is currently a Software Architect for a leading provider of household gateway
devices and television set-top boxes.
Bear is the author of a number of other Manning books: jQuery in Action (first and
second editions), Ajax in Practice, and Prototype and Scriptaculous in Action, and he has
been a technical reviewer for many of the web-focused “Head First” books by O’Reilly
Publishing, such as Head First Ajax, Head Rush Ajax, and Head First Servlets and JSP.
In addition to his day job, Bear also writes books (duh!), runs a small business that
creates web applications and offers other media services (but not wedding videography—
never, ever wedding videography), and helps to moderate as a
“marshal” (very senior moderator).
When not planted in front of a computer, Bear likes to cook big food (which
accounts for his jeans size), dabble in photography and video, ride his Yamaha V-Star,
and wear tropical print shirts.
He works and resides in Austin, Texas, a city he dearly loves except for the completely
insane drivers.

The number of people involved in writing a book would surprise most people. It took
a collaborative effort on the part of many contributors with a variety of talents to bring
the volume you are holding (or ebook that you are reading onscreen) to fruition.
The staff at Manning worked tirelessly with us to make sure this book attained the
level of quality we hoped for, and we thank them for their efforts. Without them, this
book would not have been possible. The “end credits” for this book include not only
our publisher, Marjan Bace, and editor Mike Stephens, but also the following contributors:
Jeff Bleiel, Douglas Pudnick, Sebastian Stirling, Andrea Kaucher, Karen Tegtmayer,
Katie Tennant, Megan Yockey, Dottie Marsico, Mary Piergies, Andy Carroll, Melody
Dolab, Tiffany Taylor, Dennis Dalinnik, Gabriel Dobrescu, and Ron Tomich.
Enough cannot be said to thank our peer reviewers who helped mold the final
form of the book, from catching simple typos to correcting errors in terminology and
code, and helping to organize the chapters in the book. Each pass through a review
cycle ended up vastly improving the final product. For taking the time to review the
book, we’d like to thank Alessandro Gallo, André Roberge, Austin King, Austin
Ziegler, Chad Davis, Charles E. Logston, Chris Gray, Christopher Haupt, Craig
Lancaster, Curtis Miller, Daniel Bretoi, David Vedder, Erik Arvidsson, Glenn Stokol,
Greg Donald, James Hatheway, Jared Hirsch, Jim Roos, Joe Litton, Johannes Link,
John Paulson, Joshua Heyer, Julio Guijarro, Kurt Jung, Loïc Simon, Neil Mix, Robert
Hanson, Scott Sauyet, Stuart Caborn, and Tony Niemann.

Special thanks go to Valentin Crettaz, who served as the book’s technical editor. In
addition to checking each and every sample of example code in multiple environments,
he also offered invaluable contributions to the technical accuracy of the text, located
information that was originally missing, and kept abreast of the rapid changes to
JavaScript and HTML5 support in the browsers.
Special thanks also to Bert Bates, who provided invaluable feedback and suggestions
for improving the book. All those endless hours on Skype have certainly paid off.

John Resig
I would like to thank my parents for their constant support and encouragement over
the years. They provided me with the resources and tools that I needed to spark my
initial interest in programming—and they have been encouraging me ever since.
Bear Bibeault
For this, my fifth published tome, the cast of characters I’d like to thank has a long list
of “usual suspects,” including, once again, the membership and staff at
Without my involvement in JavaRanch, I’d never have gotten the opportunity to start
writing in the first place, and so I sincerely thank Paul Wheaton and Kathy Sierra for
starting the whole thing, as well as fellow staffers who gave me encouragement and
support, including (but probably not limited to) Eric Pascarello, Ernest Friedman
Hill, Andrew Monkhouse, Jeanne Boyarsky, Bert Bates, and Max Habibi.
My partner Jay, and my dogs, Little Bear and Cozmo, get the usual warm thanks for
putting up with the shadowy presence who shared their home and rarely looked up
from his keyboard except to curse Word, or one of the browsers, or anything else that
attracted my ire while I was working on this project.
And finally, I’d like to thank my coauthor, John Resig, without whom this project

would not exist.

about this book
JavaScript is important. That wasn’t always so, but it’s true now.
Web applications are expected to give users a rich user interface experience, and
without JavaScript, you might as well just be showing pictures of kittens. More than
ever, web developers need to have a sound grasp of the language that brings life to
web applications.

And like orange juice and breakfast, JavaScript isn’t just for browsers anymore. The
language has knocked down the walls of the browser and is being used on the server
in engines such as Rhino and V8, and in frameworks like Node.js.
Although this book is primarily focused on JavaScript for web applications, the
fundamentals of the language presented in part 2 of this book are applicable across the board.

With more and more developers using JavaScript, it’s now more important
than ever that they grasp its fundamentals, so that they can become true ninjas of the language.

This is not your first JavaScript book. If you’re a complete novice to JavaScript, or you
only understand a handful of statements by searching the web for code snippets, this
is not the book for you. Yet.
This book is aimed at web developers who already have at least a basic grasp of
JavaScript. You should understand the basic structure of JavaScript statements and
how they work to create straightforward on-page scripts. You don’t need to be an
advanced user of the language—that’s what this book is for—but you shouldn’t be a rank novice.
You should also have a working knowledge of HTML and CSS. Again, nothing too
advanced, but you should know the basics of putting a web page together.
If you want some good prerequisite material, grab one of the popular books on
JavaScript and web development, and then tackle this one. We can recommend
JavaScript: The Definitive Guide by David Flanagan, JavaScript: The Good Parts by Douglas
Crockford, and Head First JavaScript by Michael Morrison.

This book is organized to take you from an apprentice to a ninja in four parts.
Part 1 introduces the topic and some tools we’ll need as we progress through the
rest of the book.
Part 2 focuses on JavaScript fundamentals: aspects of the language that you take
for granted but aren’t really sure how they work. This may be the most important part
of the book, and even if it’s all you read, you’ll come away with a much sounder understanding
of JavaScript, the language.
In part 3, we dive into using the fundamentals that we learned in part 2 to solve
knotty problems that the browsers throw at us.
Part 4 wraps up the book with a look at advanced topics focusing on lessons
learned from the creation of advanced JavaScript libraries, such as jQuery.
Let’s take a brief look at what each chapter will cover.

Chapter 1 introduces us to the challenges that we face as writers of advanced web
applications. It presents some of the problems that the proliferation of browsers creates,
and suggests best current practices that we should follow when developing our
applications, including testing and performance analysis.
Chapter 2 discusses testing, taking a look at the current state of testing and test
tools. It also introduces a small but powerful testing concept, the assert, which will be
used extensively throughout the remainder of the book to make sure that our code
does what we think it should be doing (or sometimes to prove that it doesn’t!).
Armed with these tools, chapter 3 begins our foray into the fundamentals of the
language, starting, perhaps to your surprise, with a thorough examination of the function
as defined by JavaScript. Although you might have expected the object to be the
target of first focus, it’s a solid understanding of the function, and JavaScript as a functional
language, that begins our transformation from run-of-the-mill JavaScript coders
to JavaScript ninjas!
Not being done with functions quite yet, chapter 4 takes the fundamentals we
learned in chapter 3 and applies them to problems we face in creating our applications.
We’ll explore recursion—not only for its own sake, but because we can learn a
lot more about functions through scrutinizing it—and we’ll learn how the functional
programming aspects of JavaScript can be applied to not only make our code elegant,
but also more robust and succinct. We’ll learn ways to deal with variable argument
lists, and ways to overload functions in a language that doesn’t natively support the
object-oriented concept of method overloading.
One of the most important concepts you can take away from this book is the subject
of chapter 5: closures. A key concept in functional programming, closures allow
us to exert fine-grained control over the scope of objects that we declare and create in
our programs. The control of these scopes is the key factor in writing code worthy of a
ninja. Even if you stop reading after this chapter (but we hope that you don’t), you’ll
be a far better JavaScript developer than when you started.
Objects are finally addressed in chapter 6, where we learn how patterns of objects
can be created through the prototype property of the function, and we’ll learn how
objects are tied to functions for their definitions—one of the many reasons we discussed
functions first.
Chapter 7 focuses on the regular expression, an often-overlooked feature of
the language that can do the work of scores of lines of code when used correctly.
We’ll learn how to construct and use regular expressions and how to solve some
recurring problems elegantly, using regular expressions and the methods that work with them.

Part 2 on language fundamentals closes out with chapter 8, in which we learn how
timers and intervals work in the single-threaded nature of JavaScript. HTML5 promises
to bring us relief from the confines of the single thread with web workers, but most
browsers aren’t quite there yet, and virtually all of the existing JavaScript code
depends upon a good understanding of JavaScript’s single-threaded model.
Part 3 opens with chapter 9, in which we open the black box of JavaScript’s runtime
code evaluation. We’ll look at various ways to evaluate code on the fly, including
how to do so safely and in the scope of our choosing. Real-world examples, such as
JSON evaluation, metalanguages (a.k.a. domain-specific languages), compression and
obfuscation, and even aspect-oriented programming, are discussed.
In chapter 10, we examine the controversial with statement, which is used to
shorten references within a scope. Whether you are a fan or detractor of with, it exists
in a lot of code in the wild, and you should understand it regardless of whether you
think it’s the bomb or an abomination.

Dealing with cross-browser issues is the subject of chapter 11. We examine the five
key development concerns with regard to these issues: browser differences, bugs and
bug fixes, external code and markup, missing features, and regressions. Strategies
such as feature simulation and object detection are discussed at length to help us deal
with these cross-browser challenges.

Handling element attributes, properties, and styles is the focus of chapter 12.
While the differences in how the various browsers handle these aspects of elements
are slowly converging over time, there still exists a number of knotty problems that
this chapter describes how to solve.

Part 3 concludes in chapter 13 with a thorough investigation of event handling
in the browsers and ways to create a unified subsystem that handles events in a
browser-agnostic manner. This includes adding features not provided by the browsers,
such as custom events and event delegation.

In part 4 we pick up the pace and delve deeply into advanced topics taken from the
heart of JavaScript libraries such as jQuery. Chapter 14 discusses how DOM manipulation
APIs can be constructed to manipulate the Document Object Model at runtime,
including the Gordian knot of injecting new elements into the DOM.
Finally, in chapter 15, we discuss how CSS selector engines are constructed and the
different ways in which they parse and evaluate selectors. Not for the faint of heart,
this chapter, but it’s a worthy final test of your ninja-hood.

About the cover illustration
The figure on the cover of Secrets of the JavaScript Ninja is captioned “Noh Actor,
Samurai,” from a woodblock print by an unknown Japanese artist of the mid-nineteenth
century. Derived from the Japanese word for talent or skill, Noh is a form of classical
Japanese musical drama that has been performed since the 14th century. Many characters
are masked, with men playing male and female roles. The samurai, a hero figure
in Japan for hundreds of years, was often featured in the performances, and in
this print the artist renders with great skill the beauty of the costume and the ferocity
of the samurai.

Samurai and ninjas were both warriors excelling in the Japanese art of war, known
for their bravery and cunning. Samurai were elite soldiers, well-educated men who
knew how to read and write as well as fight, and they were bound by a strict code of
honor called Bushido (The Way of the Warrior), which was passed down orally from
generation to generation, starting in the 10th century. Recruited from the aristocracy
and upper classes, analagous to European knights, samurai went into battle in large
formations, wearing elaborate armor and colorful dress meant to impress and intimidate.
Ninjas were chosen for their martial arts skills rather than their social standing
or education. Dressed in black and with their faces covered, they were sent on missions
alone or in small groups to attack the enemy with subterfuge and stealth, using
any tactics to assure success; their only code was one of secrecy.

The cover illustration is from a set of three Japanes prints owned for many years by
a Manning editor, and when we were looking for a ninja for the cover of this book, the
striking samurai print came to our attention and was selected for its intricate details,
vibrant colors, and vivid depiction of a ferocious warrior ready to strike—and win.
At a time when it is hard to tell one computer book from another, Manning celebrates
the inventiveness and initiative of the computer business with book covers
based on two-hundred-year-old illustrations that depict the rich diversity of traditional
costumes from around the world, brought back to life by prints such as this one.

Table of Contents
preface xi
acknowledgments xiii
about this book xv
about the authors xx
PART 1 PREPARING FOR TRAINING . ...............................1
1 Enter the ninja 3
1.1 The JavaScript libraries we’ll be tapping 4
1.2 Understanding the JavaScript language 5
1.3 Cross-browser considerations 6
1.4 Current best practices 9
Current best practice: testing 9 ■ Current best practice:
performance analysis 10
1.5 Summary 11
2 Arming with testing and debugging 13
2.1 Debugging code 14
Logging 14 ■ Breakpoints 16
2.2 Test generation 17
2.3 Testing frameworks 19
QUnit 21 ■ YUI Test 22 ■ JsUnit 22
Newer unit-testing frameworks 22
2.4 The fundamentals of a test suite 22
The assertion 23 ■ Test groups 24 ■ Asynchronous testing 25
2.5 Summary 27
PART 2 APPRENTICE TRAINING.....................................29
3 Functions are fundamental 31
3.1 What’s with the functional difference? 32
Why is JavaScript’s functional nature important? 33
Sorting with a comparator 37
3.2 Declarations 40
Scoping and functions 43
3.3 Invocations 46
From arguments to function parameters 47 ■ Invocation as
a function 49 ■ Invocation as a method 50 ■ Invocation as
a constructor 52 ■ Invocation with the apply() and
call() methods 54
3.4 Summary 58
4 Wielding functions 61
4.1 Anonymous functions 62
4.2 Recursion 64
Recursion in named functions 64 ■ Recursion with methods 65
The pilfered reference problem 66 ■ Inline named functions 68
The callee property 70
4.3 Fun with function as objects 71
Storing functions 72 ■ Self-memoizing functions 73
Faking array methods 76
4.4 Variable-length argument lists 77
Using apply() to supply variable arguments 77
Function overloading 79
4.5 Checking for functions 86
4.6 Summary 88
5 Closing in on closures 89
5.1 How closures work 90
5.2 Putting closures to work 94
Private variables 94 ■ Callbacks and timers 96
5.3 Binding function contexts 99
5.4 Partially applying functions 103
5.5 Overriding function behavior 106
Memoization 106 ■ Function wrapping 109
5.6 Immediate functions 111
Temporary scope and private variables 112 ■ Loops 115
Library wrapping 117
5.7 Summary 118
6 Object-orientation with prototypes 119
6.1 Instantiation and prototypes 120
Object instantiation 120 ■ Object typing via constructors 127
Inheritance and the prototype chain 128
HTML DOM prototypes 133
6.2 The gotchas! 135
Extending Object 135 ■ Extending Number 136
Subclassing native objects 137 ■ Instantiation issues 139
6.3 Writing class-like code 143
Checking for function serializability 146 ■ Initialization
of subclasses 147 ■ Preserving super-methods 148
6.4 Summary 150
7 Wrangling regular expressions 151
7.1 Why regular expressions rock 152
7.2 A regular expression refresher 153
Regular expressions explained 153 ■ Terms and operators 154
7.3 Compiling regular expressions 158
7.4 Capturing matching segments 161
Performing simple captures 161 ■ Matching using
global expressions 162 ■ Referencing captures 163
Non-capturing groups 165
7.5 Replacing using functions 166
7.6 Solving common problems with regular expressions 168
Trimming a string 168 ■ Matching newlines 170
Unicode 171 ■ Escaped characters 172
7.7 Summary 172
8 Taming threads and timers 175
8.1 How timers and threading work 176
Setting and clearing timers 176 ■ Timer execution within
the execution thread 177 ■ Differences between timeouts
and intervals 179
8.2 Minimum timer delay and reliability 180
8.3 Dealing with computationally expensive processing 183
8.4 Central timer control 186
8.5 Asynchronous testing 189
8.6 Summary 190
PART 3 NINJA TRAINING ............................................191
9 Ninja alchemy: runtime code evaluation 193
9.1 Code evaluation mechanisms 194
Evaluation with the eval() method 194 ■ Evaluation via the
Function constructor 197 ■ Evaluation with timers 197
Evaluation in the global scope 198 ■ Safe code evaluation 199
9.2 Function “decompilation” 201
9.3 Code evaluation in action 204
Converting JSON 204 ■ Importing namespaced code 205
JavaScript compression and obfuscation 206 ■ Dynamic
code rewriting 208 ■ Aspect-oriented script tags 209
Metalanguages and DSLs 210
9.4 Summary 213
10 With statements 215
10.1 What’s with “with”? 216
Referencing properties within a with scope 216 ■ Assignments
within a with scope 218 ■ Performance considerations 219
10.2 Real-world examples 221
10.3 Importing namespaced code 223
10.4 Testing 223
10.5 Templating with “with” 224
10.6 Summary 227
11 Developing cross-browser strategies 229
11.1 Choosing which browsers to support 230
11.2 The five major development concerns 231
Browser bugs and differences 232 ■ Browser bug fixes 233
Living with external code and markup 234
Missing features 239 ■ Regressions 240
11.3 Implementation strategies 242
Safe cross-browser fixes 242 ■ Object detection 243
Feature simulation 245 ■ Untestable browser issues 247
11.4 Reducing assumptions 249
11.5 Summary 251
12 Cutting through attributes, properties, and CSS 253
12.1 DOM attributes and properties 255
Cross-browser naming 256 ■ Naming restrictions 257
Differences between XML and HTML 257 ■ Behavior of
custom attributes 258 ■ Performance considerations 258
12.2 Cross-browser attribute issues 262
DOM id/name expansion 262 ■ URL normalization 264
The style attribute 265 ■ The type attribute 265
The tab index problem 266 ■ Node names 267
12.3 Styling attribute headaches 267
Where are my styles? 268 ■ Style property naming 270
The float style property 271 ■ Conversion of pixel values 271
Measuring heights and widths 272 ■ Seeing through
opacity 276 ■ Riding the color wheel 279
12.4 Fetching computed styles 282
12.5 Summary 285
PART 4 MASTER TRAINING.........................................287
13 Surviving events 289
13.1 Binding and unbinding event handlers 290
13.2 The Event object 294
13.3 Handler management 297
Centrally storing associated information 298
Managing event handlers 300
13.4 Triggering events 309
Custom events 310
13.5 Bubbling and delegation 315
Delegating events to an ancestor 315 ■ Working around
browser deficiencies 316
13.6 The document ready event 324
13.7 Summary 326
14 Manipulating the DOM 329
14.1 Injecting HTML into the DOM 330
Converting HTML to DOM 331 ■ Inserting into
the document 334 ■ Script execution 336
14.2 Cloning elements 338
14.3 Removing elements 340
14.4 Text contents 341
Setting text 342 ■ Getting text 343
14.5 Summary 344
15 CSS selector engines 345
15.1 The W3C Selectors API 347
15.2 Using XPath to find elements 349
15.3 The pure-DOM implementation 351
Parsing the selector 353 ■ Finding the elements 354
Filtering the set 355 ■ Recursing and merging 356
Bottom-up selector engine 357
15.4 Summary 359
index 361


e-books shop

Purchase Now !
Just with Paypal

Product details
 2.00 USD
 394 p
 File Size
 15,237 KB
 File Type
 PDF format
 2013 by Manning Publications Co 

═════ ═════

Loading... Protection Status