Secrets Of The JavaScript Ninja

JOHN RESIG . BEAR BIBEAULT

MANNING. SHELTER ISLAND

PART 1 PREPARING FOR TRAINING
PART 2 APPRENTICE TRAINING
PART 3 NINJA TRAINING
PART 4 MASTER TRAINING

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 BuiltWith.com) 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,
Works.com, 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 CodeRanch.com 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.

acknowledgments
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 javaranch.com.
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.

Audience
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.

Roadmap

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

Screenshot

Purchase Now !
Just with Paypal

Product details

Price	2.00 USD
Pages	394 p
File Size	15,237 KB
File Type	PDF format
ISBN	978-1-933988-69-6
Copyright	2013 by Manning Publications Co

  ●▬▬▬▬▬❂❂❂▬▬▬▬▬●

●▬▬❂❂▬▬●

●▬❂▬●

●❂●

═════● ●═════