JavaScript: The Definitive Guide: The Definitive Guide

JavaScript: The Definitive Guide: The Definitive Guide

by David Flanagan

View All Available Formats & Editions

This Fifth Edition is completely revised and expanded to cover JavaScript as it is used in today's Web 2.0 applications. This book is both an example-driven programmer's guide and a keep-on-your-desk reference, with new chapters that explain everything you need to know to get the most out of JavaScript, including:

  • Scripted HTTP and Ajax


This Fifth Edition is completely revised and expanded to cover JavaScript as it is used in today's Web 2.0 applications. This book is both an example-driven programmer's guide and a keep-on-your-desk reference, with new chapters that explain everything you need to know to get the most out of JavaScript, including:

  • Scripted HTTP and Ajax
  • XML processing
  • Client-side graphics using the canvas tag
  • Namespaces in JavaScript--essential when writing complex programs
  • Classes, closures, persistence, Flash, and JavaScript embedded in Java applications

Part I explains the core JavaScript language in detail. If you are new to JavaScript, it will teach you the language. If you are already a JavaScript programmer, Part I will sharpen your skills and deepen your understanding of the language.

Part II explains the scripting environment provided by web browsers, with a focus on DOM scripting with unobtrusive JavaScript. The broad and deep coverage of client-side JavaScript is illustrated with many sophisticated examples that demonstrate how to:

  • Generate a table of contents for an HTML document
  • Display DHTML animations
  • Automate form validation
  • Draw dynamic pie charts
  • Make HTML elements draggable
  • Define keyboard shortcuts for web applications
  • Create Ajax-enabled tool tips
  • Use XPath and XSLT on XML documents loaded with Ajax
  • And much more

Part III is a complete reference for core JavaScript. It documents every class, object, constructor, method, function, property, and constant defined by JavaScript 1.5 and ECMAScript Version 3.

Part IV is a reference for client-side JavaScript, covering legacy web browser APIs, the standard Level 2 DOM API, and emerging standards such as the XMLHttpRequest object and the canvas tag.

More than 300,000 JavaScript programmers around the world have madethis their indispensable reference book for building JavaScript applications.

"A must-have reference for expert JavaScript programmers...well-organized and detailed."
-- Brendan Eich, creator of JavaScript

Editorial Reviews
The Barnes & Noble Review
Over the past few years, the JavaScript language has matured. Not only is JavaScript now an international standard (called ECMAScript), the standard itself is in its third, refined version. Conformant implementations are available in several leading browsers, from Microsoft Internet Explorer 6 to Mozilla; and open source versions are available to be incorporated into any application that can benefit from a scripting language.

All this is to say that JavaScript is more useful than ever, and the JavaScript you use now can be relied upon (at least as much as anything in the computer industry ) to remain stable for years to come. It's worth your time to become a more capable JavaScript programmer -- and David Flanagan's JavaScript: The Definitive Guide, Fourth Edition may be your best tool for achieving that goal.

Well-known as "The Rhino Book" for its cover, JavaScript: The Definitive Guide has long been an outstanding resource for JavaScript programmers. Flanagan writes with discipline and clarity, and his book combines excellent tutorial coverage with a detailed reference that documents the classes, methods, and properties defined by the core JavaScript language.

But a lot's changed since the 1998 edition. And if you got involved with JavaScript at the heat of the web gold rush, a lot's changed since whatever JavaScript book you rely on was written. Here's just some of what's new and different in this book.

First of all, Flanagan's thoroughly updated his coverage to reflect JavaScript 1.5 and the aforementioned ECMA-262 third edition standard. Previous editions had a heavy focus on Netscape's implementation of JavaScript; that will obviously no longer do, so Flanagan has moved to a focus on the official standard. Since browser conformance has improved significantly, this book will help you write code that'll survive pretty much any browser you throw at it. (The reference section carefully specifies when each language element was introduced, and which versions of the standard support it.)

Flanagan's reorganized the book. For one thing, core language coverage has been separated with coverage of using JavaScript in client-side browsers, recognizing that many JavaScript developers nowadays aren't working in classic web browser environments. More important, he's moved the coverage of the W3C's DOM implementation into a section of its own, and substantially expanded that coverage. (Both DOM Level 2 and Level 1 are covered, with Level 0 coverage kept for backward compatibility.)

JavaScript: The Definitive Guide, Fourth Edition begins with an overview of what JavaScript can and cannot do, including some lingering myths about the language (many still view it as purely a simple scripting language, and are surprised by its depth when they attempt to perform complex tasks with it.) Next, Flanagan reviews the fundamentals of JavaScript 1.5: its lexical structure, data types and values, variables, expressions, operators, and statements.

If you're an experienced Java, C++, or C programmer, much of Section I will be familiar: JavaScript was designed to help developers leverage existing skills. Section II, however, focuses on stuff that's handled significantly differently in JavaScript. Here, Flanagan covers functions, objects, arrays, and pattern matching with regular expressions. He also introduces several advanced features, notably JavaScript's automatic data type conversion, garbage collection, lexical scoping, and function constructors.

Next, Flanagan focuses on client-side JavaScript. He shows how JavaScript integrates with web browsers; introduces the Window object and JavaScript's event-driven programming model; and shows how to use the Document Object to expose an HTML document's contents to JavaScript code. The book includes chapters on forms and form elements; cookies; and scripting CSS/DHTML to manipulate the style, appearance, and position of HTML document elements.

Notwithstanding Microsoft's dominance, it's still a diverse world out there. Flanagan shows how to avoid, minimize, and mitigate browser incompatibilities, introducing techniques for testing features, implementing platform-specific workarounds, and testing compatibility with server-side scripts. There's coverage of security, and a quick look at using Java with JavaScript. And the 300-page reference? Invaluable.

You'll live happily with this book for a long time. (Bill Camarda)

Bill Camarda is a consultant, writer, and web/multimedia content developer with nearly 20 years' experience in helping technology companies deploy and market advanced software, computing, and networking products and services. He served for nearly ten years as vice president of a New Jersey–based marketing company, where he supervised a wide range of graphics and web design projects. His 15 books include Special Edition Using Word 2000 and Upgrading & Fixing Networks For Dummies®, Second Edition. Review

Geared toward JavaScript programmers, this book provides an excellent programmer's guide and reference manual for JavaScript 1.2. It includes a thorough description of the core JavaScript language and a detailed reference section.


  • You study lexical structure, data types, values and variables.
  • Examines pattern matching with regular expressions.
  • Describes statements, functions and objects.
  • Details expressions and operators.
  • Covers the document object model, events and event handling.
  • You study windows and frames of client-side JavaScript.
  • Explores forms, form elements, dynamic HTML and cookies.
  • Details compatibility techniques, LiveConnect and JavaScript security.
  • Includes a complete reference to all of the objects, properties, functions, methods and event handlers in client-side JavaScript and in the core JavaScript language.


  • The text includes a thorough reference section with more than 300 pages.
  • This well written and organized text includes examples of sample script.

Related Titles:

For more information on JavaScript, try Java 1.2 and JavaScript for C and C++ Programmers or JavaScript Bible, Third Edition. For a crash course in JavaScript, try Instant JavaScript.

Product Details

O'Reilly Media, Incorporated
Publication date:
Sold by:
Barnes & Noble
Sales rank:
File size:
9 MB

Read an Excerpt

Chapter 17: The Document Object Model

A document object model (DOM) is an application programming interface (API) for representing a document (such as an HTML document) and accessing and manipulating the various elements (such as HTML tags and strings of text) that make up that document. JavaScript-enabled web browsers have always defined a document object model; a web-browser DOM may specify, for example, that the forms in an HTML document are accessible through the forms[] array of the Document object.

In this chapter, we'll discuss the W3C DOM, a standard document object model defined by the World Wide Web Consortium and implemented (at least partially) by Netscape 6 and Internet Explorer 5 and 6. This DOM standard1 is a full-featured superset of the traditional web-browser DOM. It represents HTML (and XML) documents in a tree structure and defines properties and methods for traversing the tree and examining and modifying its nodes. Other portions of the standard specify techniques for defining event handlers for the nodes of a document, working with the style sheets of a document, and manipulating contiguous ranges of a document.

This chapter begins with an overview of the DOM standard and then describes the core portions of the standard for working with HTML documents. The discussion of the core standard is followed by short sections that explain the DOM-like features of Internet Explorer 4 and Netscape 4. The chapter ends with an overview of two optional parts of the DOM standard that are closely related to the core. Later chapters cover advanced DOM features for working with style sheets and events.

An Overview of the DOM

The DOM API is not particularly complicated, but before we can begin our discussion of programming with the DOM, there are a number of things you should understand about the DOM architecture.

Representing Documents as Trees

HTML documents have a hierarchical structure that is represented in the DOM as a tree structure. The nodes of the tree represent the various types of content in a document. The tree representation of an HTML document primarily contains nodes representing elements or tags such as <body> and <p> and nodes representing strings of text. An HTML document may also contain nodes representing HTML comments.2 Consider the following simple HTML document:

    <title>Sample Document</title>
    <h1>An HTML Document</h2>
    <p>This is a <i>simple</i> document.

The DOM representation of this document is the tree pictured in Figure 17-1.

If you are not already familiar with tree structures in computer programming, it is helpful to know that they borrow terminology from family trees. The node directly above a node is the parent of that node. The nodes one level directly below another node are the children of that node. Nodes at the same level, and with the same parent, are siblings. The set of nodes any number of levels below another node are the descendants of that node. And the parent, grandparent, and all other nodes above a node are the ancestors of that node.


The DOM tree structure illustrated in Figure 17-1 is represented as a tree of various types of Node objects. The Node interface3 defines properties and methods for traversing and manipulating the tree. The childNodes property of a Node object returns a list of children of the node, and the firstChild, lastChild, nextSibling, previousSibling, and parentNode properties provide a way to traverse the tree of nodes. Methods such as appendChild( ), removeChild( ), replaceChild( ), and insertBefore( ) enable you to add and remove nodes from the document tree. We'll see examples of the use of these properties and methods later in this chapter.

Types of nodes

Different types of nodes in the document tree are represented by specific subinterfaces of Node. Every Node object has a nodeType property that specifies what kind of node it is. If the nodeType property of a node equals the constant Node.ELEMENT_NODE, for example, you know the Node object is also an Element object and you can use all the methods and properties defined by the Element interface with it. Table 17-1 lists the node types commonly encountered in HTML documents and the nodeType value for each one.

Table 17-1: Common node types


nodeType constant

nodeType value



















The Node at the root of the DOM tree is a Document object. The documentElement property of this object refers to an Element object that represents the root element of the document. For HTML documents, this is the <html> tag that is either explicit or implicit in the document. (The Document node may have other children, such as Comment nodes, in addition to the root element.) The bulk of a DOM tree consists of Element objects, which represent tags such as <html> and <i>, and Text objects, which represent strings of text. If the document parser preserves comments, those comments are represented in the DOM tree by Comment objects. Figure 17-2 shows a partial class hierarchy for these and other core DOM interfaces.


The attributes of an element (such as the src and width attributes of an <img> tag) may be queried, set, and deleted using the getAttribute( ), setAttribute( ), and removeAttribute( ) methods of the Element interface.

Another, more awkward way to work with attributes is with the getAttributeNode( ) method, which returns an Attr object representing an attribute and its value. (One reason to use this more awkward technique is that the Attr interface defines a specified property that allows you to determine whether the attribute is literally specified in the document, or whether its value is a default value.) The Attr interface appears in Figure 17-2, and it is a type of node. Note, however, that Attr objects do not appear in the childNodes[] array of an element and are not directly part of the document tree in the way that Element and Text nodes are. The DOM specification allows Attr nodes to be accessed through the attributes[] array of the Node interface, but Microsoft's Internet Explorer defines a different and incompatible attributes[] array that makes it impossible to use this feature portably....

Meet the Author

David Flanagan is a computer programmer who spends most of his time writing about JavaScript and Java. His books with O'Reilly include Java in a Nutshell, Java Examples in a Nutshell, Java Foundation Classes in a Nutshell, JavaScript: The Definitive Guide, and JavaScript Pocket Reference. David has a degree in computer science and engineering from the Massachusetts Institute of Technology. He lives with his wife and children in the U.S. Pacific Northwest bewteen the cities of Seattle, Washington and Vancouver, British Columbia. David has a blog at

Customer Reviews

Average Review:

Write a Review

and post it to your social network


Most Helpful Customer Reviews

See all customer reviews >