JavaScript: The Definitive Guide

• #1 in Best Javascript Books

277 Reviews

Sort by: Most Helpful ▲ Date Rating

As you may know, this book is considered THE Javascript book. What's makes the book worthwhile is it's fine discussion of Javascript's innerworkings. If you really want learn how Javascript's objects, functions, and data type handling work, then this is the book for you. The criticisms of this book fall into three catagories: 1) "Not for beginners". Yes, this book is not intended for people who have never studied object oriented programming. But that doesn't make it a 2 star book! Even beginners, if they are serious enough, will eventually need some clues about how Javascript really works. 2) "It's outdated". Again, yes; the reference section, and some of the browser dependant discussion is clearly outdated; BUT that still does not make this an outdated book! The author's in-depth explanation of Javascript innerworkings may never become outdated, and that alone is what makes this book worthwhile. 3) "Not enough examples". This is the only criticism that I

actually agree with, and therefore the 4, instead of 5 stars. Not only can this book benefit from additional small examples, but the author's explanations are sometimes lacking, or even worse, missing. On a few examples, he basically says, "This is worthy of study. Go ahead and study it." Sorry, I expect more from my books, than a grumpy professor in a university lecture hall, nearing the end of class.

This is the best Javascript reference available.

The book is divided into three sections. The first covers "Core Javascript", defining the language itself with only occasional references to how you might use it in a browser. This initially seemed to me to be a roundabout way to approach the language--why wouldn't you want to explain it by examples in a web page? However, after becoming more familiar with the language I think it was absolutely the right decision, since it avoids confusing the document object model (see below for more about that) with the language itself, a confusion common among beginners.

At the end of the first section (which developers experienced in other languages can skim, but shouldn't skip) you know what Javascript code looks like and how to do assignments, define functions, and so on. The second section, "Client-side Javascript", is where examples start to show up that you can really run in a test page of your own. The examples are good and there are plenty of them.

The heart of the second section is the discussion of the document object model. After some introductory discussion, covering windows and frames and some of the more common Javascript tasks, there's an overview of the DOM. Subsequent chapters cover it in more detail. This organization makes it pretty easy to find what you need without even resorting to the index. For example, I find the forms chapter, and the chapter on how to use cookies to save state, to be very useful, and easy to find information in.

Finally, there's a reference section at the back. This is the most valuable section once you're well on your way with the language, and is what I now use most of all. It's comprehensive and clearly written.

The book does have one weakness, which has been noted by other reviewers here: it doesn't have a "cookbook" section, showing you how to do common tasks with Javascript. This is a serious omission because of the nature of Javascript usage. Very often a webmaster for a small non-profit or a small business will decide they want to do a rollover, or add an alert for form validation failures, or something similar. Users like this need something equivalent to the "Perl Cookbook"; a "How to . . ." section that gives you an example close to what you need.

Despite this caveat, however, this is still the best book around: an excellent reference, and a great way to learn the language.

I purchased the Netscape One Developer's Guide thinking it would provide answers to my Javascript questions - it answered very few, unfortunately. The 'Guide' doesn't begin to approach the ease of use, thoroughness or amount of information contained in "Javascript: The Definitive Guide". Javascript is as completely covered as it can be (with the free-flowing nature of WWW specifications, its hard to keep track of all the changes). I found the descriptions and examples informative, clear and concise and kinda fun sometimes. The layed back nature of the writing won't scare off novice coders/web developers and yet doesn't turn off more advanced developers. The book is cut in half - the first provides an introduction into Javascript and discusses its more important subjects while the second is a complete reference section for Javascript 1.2. It specifically treats the differences between Netscape and Internet Explorer whereas the Netscape One guide left that up to the reader to figure out - an oversight which relegates the Netscape One Developer's Handbook to the dusty bookshelf (way in the back). If you're doing web development and need to use Javascript - this is probably the only book you'll need. If you're doing web development and you're not using Javascript - you NEED this book - it will show you what you can do with simple client-side scripts.

Let's face it: modern programming languages from C++ to Java, Javascript, etc., are absurdly difficult designs by emotionally dysfunctional, sociopathic nerds. This book isn't boring because of its style, it's boring because Javascript has an idiotic syntax to begin with. But you'll definitely learn some solid Javascript from this book, as well as the theory behind it that will make a power programmer out of you.

No single book is the total answer to subjects like this one. I'd suggest additional material, like Goodman's Javascript Bible. But I do feel that this book really is a definitive source and is essential for understanding and fully using Javascript. If you're a serious programmer, you'll need the reference material as well as the how-to sections of this work. If you're a beginner, you should definitely start here.

After trying to learn javascript from the visual series "javascript for the world wide web, 3rd ed" (and being thoroughly disappointed), I finally have found a book that describes the fundamentals of the javascript language in detail. This book explains from an academic perspective the rules, usage, and syntax of javascript. It leads the reader into the depths of how javascript implements an object-oriented paradigm without getting too esoteric. It can be difficult reading at times, but the true nature of javascript programming is not that of a simple little scripting language as some would have you believe. The coding examples could have been better, with more full-sized scripts showing the language in action instead of the numerous 1-4 line code snipets. The one big distraction I noticed was the seemingly constant references to netscape navigator, and all the bugs present in older versions of that browser. Unfortunately, this dated the book and tended to highlight a bias when the author would have been better off staying with the academic focus. Even still, the majority of the theory is unaffected by nav or ie, and the reference section is essential for any serious javascript developer. It is noted that this book was copyright 1998, so "cutting edge" javascript extensions will not be included, but the fundamental theory behind the language remains intact. With the combination of this book (theory and reference) and the visual series book (cutesy web page tricks), I can finally get on with the task of finishing my web site.

The book has a very good introduction to the core of client side javascript. It is a great reference for coming back to those things that you get kind of rusty on like "regular expressions" and "creating your own objects". The rest of the book is an incredibly comprehensive reference which goes into considerable detail. It's the kind of detail that a compiler manual goes into. I would prefer a version with indexes like a study bible. If you read most of this book you wont have to go around copying other peoples code snippets because you'll be to busy making up your own scripting libraries. I wish that this author would add about 300 pages on Server Side JScripting and Active Server Pages. I'm sure he could take the magic out of it in a way that most programmers could pickup in a matter of hours.

This book was perfect as a "learning" book and a refernce manual. I read the book, learning by examples and excellent descriptions. Now I use the book almost everyday as a reference when I develope web applications. Roughly half of the book is a complete reference manual focusing on the syntax, methods, and properties of ALL of the Javascript components. The reference is organized by Object making it easy to find what you want. There are also plenty of cross references for easy indexing. O'Reilly has done it again.

I have had this book for years. I really like this book a lot.

It teaches you the language. It is a good reference for the syntax of Javascript 1.5. It also does a decent job of teaching DHTML. Some foreknowledge of HTML is going to be helpful. That can easily be gained from other books, reading the spec, or going through some of the HTML tutorials on the web. This book tells you how to access the structure of an HTML document - and change it.

Amazingly, it really did not start to become obsolete for almost half a decade. For a computer book on a heavily used computer language, that is great.

In late 2005, Mozilla released Firefox 1.5 which included a new version of Javascript: Javascript 1.6. Unlike some updates, this one was a doozy.

Javascript 1.6 introduced a feature called E4X - Ecmascript for Java. This powerful feature actually upgrades the language, making XML fragments a first class data type.

What this means is two things:

First, you can put XML fragments in your program. Just as quoted strings are interpreted as string literals, these fragments are treated as XML literals. No quoting or anything is required: the parser just sees them and knows what they are.

Second, you can evaluate XPath-like expressions to find things in an XML fragment value. Those things would be attribute values, text content, and elements that are in it.

Today, XML is much more important to organizations and much more useful to programmers than it was in 2001. It is a given that easier, more powerful ways for programmers to work with XML are going to grab programmers' interest.

Another thing has changed since 2001. AJAX programming has become white-hot. Website users like it because the system seems more responsive. Programmers like it because it lets them create web sites that seem more fun and are more impressive to a generation numbed-out by constant fill-in-form/Submit cycle of web pages. Companies like it because it AJAX is "in" and having it on their site can draw people to it by word of mouth or as marketable feature.

AJAX programming relies on the XMLHttpRequest object. That is not described in this book. Consequently AJAX programming is not explained in it.

A lot of AJAX components & effects libraries; e.g. Prototype.js, scriptaculous (script.aculo.us if you are looking for it on the web), etc., were in high gear by 2005. Since the book came out years before that, it does not mention any of these, tell what they can do, or explain how to write programs that use them.

Two other standards got added to Firefox 1.5 when it was released in 2005: SVG content and the CANVAS element. While CANVAS is a new invention, it is already supported by Apple's Safari 2 web browser that came with Tiger, released in early 2005. SVG is a very mature standard, invented in the late 1990s - but not really included in a widely distributed piece of software until Firefox included it. From watching what is going on in Apple's Safari development site, it seems likely Safari will gain SVG support sometime in 2006.

These 2 graphics capabilities are both important.

The CANVAS element is perfect for realtime and/or interactive graphics. For instance, it would be great for a "paint" program or a constantly-updated graph/chart display.

The SVG content is XML. The elements describe how to draw some shapes and text, fill them in, draw the borders, and perform transformations on them - as well as fancy effects like "shear". The power of SVG is huge. It can be used to draw all of the things described, plus more advanced things like "quadratic bezier curves". This makes it also suited to render art objects or sophisticated two-dimensional visualizations.

Now, go back to what is in the 4th edition of the book. The coverage of the different types of objects is covered in different sections - based on what the objects are used for. This is fine, but then there needs to be a special alphabetized index as well as detailed table of contents that shows you where to find each one - and what is in each section. Reading the whole book is not an option when you are in a hurry. When you are doing stuff on the web, you are always in a hurry. So, ways to find things quickly and survey quickly what is there - that is crucial.

I think a 5th edition of this book could be phenomenal, if it takes care of the omissions I have cited. Even in its present form, it does a good job of teaching the language - with the exception of the missing items I have noted.

This is the book to get if you want a reference guide to JavaScript! The book starts by going through language syntax (complete beginners - take note!), then covers working with objects in detail. The book then puts it all into context by covering all aspects of working with browsers - specifically how to manage and manipulate page content and the browser window itself to enhance display (eg. rollovers) and add client-side functionality (eg. form validation).

The next section covers the document object model (browser DOM), and for me this was the only disappointment in the book. While I found every other part of the book thorough and informative, I found the DOM chapter a bit light-on.

However, this is easily compensated for with the excellent reference section at the back of the book which details each object, explains its purpose, and describes all of its properties and methods. The book is almost worth its price just for this reference, and I almost always turn to the back first!

As a web developer / back-end programmer, this is one of four books I always keep with me! The other three are "HTML: The Difinitive Guide", "ASP in a nutshell" and an SQL reference.

This is a great book about Javascript. The author provided good introduction to all of the subjects before he discussed them, helping the reader to understand better.

My only problem with the book is that it doesn't reflect IE. Navigator's and IE's Javascript interpreter (engine) is vastly different, and the book primarily discusses Navigator. Given the market conditions, IE has surpassed Navigator and I'm at this point targeting development more for IE rather than Navigator. As a result, most of the code examples were inoperable in IE.

I would love to see a newer edition where he concentrates on IE's Javascript interpreter.

First off, this is a review of the 5th edition, released August 1, 2006. All other reviews prior to that date are talking about previous editions of this book, which are considerably different than the current one.

The reason the various editions of this book have been so good over the last ten years is probably because they have all been written by the same author, David Flanagan, who seems to really know his audience. Part one of the book is pretty much the same as in the previous edition. It acts as a complete tutorial on the language, taking you all the way from basic language constructs into object-oriented programming and finally basic scripting.

Where things get really interesting and cutting edge is in part two of the book, "Client-Side Javascript". Most of the examples we've seen so far, while legal JavaScript code, had no particular context - they were JavaScript fragments that ran in no specified environment. Chapters 13 and 14, "Javascript in Web Browsers", and "Scripting Browser Windows" provide that context. This begins with a conceptual introduction to the web browser programming environment and basic client-side JavaScript concepts. Next, it discusses how to embed JavaScript code within HTML documents so it can run in a web browser. Finally, the chapter goes into detail about how JavaScript programs are executed in a web browser.

Next, the book turns its attention to the Document Object Model (DOM). Client-side JavaScript exists to turn static HTML documents into interactive programs. It is the Document object that gives JavaScript interactive access to the content of otherwise static documents. In addition to the properties that provide information about a document as a whole, the Document object has a number of very important properties that provide information about document content. Chapter 15 explains all of these issues.

Cascading Style Sheets (CSS) is a technology intended for use by graphic designers or anyone concerned with the precise visual display of HTML documents. It is of interest to client-side JavaScript programmers because the document object model allows the styles that are applied to the individual elements of a document to be scripted. Used together, CSS and JavaScript enable a variety of visual effects loosely referred to as Dynamic HTML (DHTML). This is the subject of chapter 16, "Cascading Style Sheets and Dynamic HTML".

Interactive JavaScript programs use an event-driven programming model. In this style of programming, the web browser generates an event whenever something interesting happens to the document or to some element of it. For example, the web browser generates an event when it finishes loading a document, when the user moves the mouse over a hyperlink, or when the user clicks on the Submit button of a form. If a JavaScript application cares about a particular type of event for a particular document element, it can register an event handler - a JavaScript function or snippet of code - for that type of event on the element of interest. Then, when that particular event occurs, the browser invokes the handler code. All applications with graphical user interfaces are designed this way: they sit around waiting for the user to do something interesting (i.e., they wait for events to occur) and then they respond. Chapter 17, "Events and Event Handling", discusses these issues.

The use of HTML forms is basic to almost all JavaScript programs. Chapter 18, "Forms and Form Elements", explains the details of programming with forms in JavaScript. It is assumed that you are already somewhat familiar with the creation of HTML forms and with the input elements that they contain. If not, you may want to refer to a good book on HTML.

The Document object contains a property named "cookie" that, on the surface, appears to be a simple string value. A cookie is a small amount of named data stored by the web browser and associated with a particular web page or web site. Cookies serve to give the web browser a memory, so that scripts and server-side programs can use data that was input on one page in another page, or so the browser can recall user preferences or other state variables when the user leaves a page and then returns. Thus, the cookie property controls a very important feature of the web browser and is important enough to warrant a complete chapter of its own, "Cookies and Client-Side Persistence".

Internet Explorer on Windows, Safari on Mac OS-X, Mozilla on all platforms, Konqueror in KDE, IceBrowser on Java, and Opera on all platforms provide a method for client side Javascript to make HTTP requests. From humble beginnings as an oddly named object with few admirers, it's blossomed to be the core technology in something called AJAX. The object in question is called the XMLHTTPRequest object, and it is not limited to being used with XML. It can request or send any type of document, although dealing with binary streams can be problematical in Javascript. This chapter, "Scripting HTTP", covers these issues. Since AJAX actually stands for "Asynchronous Javascript and XML", the next chapter discusses Javascript and XML working together.

The final two chapters of part two of the book are very cool and interesting to me, but might not be of interest to the standard professional Javascript programmer, since it deals with client-side graphics and movies using Javascript. This includes working with VML, SVG, graphics and Java, and finally using Javascript with Flash 8. Parts three and four form a reference section for Javascript, including the various methods and their usages.

The source code is well commented and explained, as in all previous editions, and is available for download from the book's website. This book is a great instructive textbook and reference on Javascript. I highly recommend it.

This 4th edition of Javascript was published in 2001 and is by now way out-dated. Granted, a lot has *not* changed with Javascript, but new techniques and formats have become available. Luckily, a new edition (5th ed.) of this book will be available in August 2006. Better hold off your purchase until the new edition. Then this book will deserve 4 stars.

This is a wonderful reference book. Not for the beginner but the quality examples and the entire demonstrate concept is truly wonderful. This is done without being to fundamental or dry. It covers the basic important appearance of JavaScript that you would expect in any book covering a progress language. The explanation of questions you may have are already answered. The reading goes by quickly and you just seem to understand what the author is saying.
I highly recommend this book to all programers.

I own the third edition of this book, and bought it when I was starting to write a web-based decision support system for a very large beverage company. I can safely say that this book, and the HTML Definitive Guide (also by O'Reilly) were critical to the success of the system.

I have seldom had a question about JavaScript for which I could not find the answer in this book. I referred to it so frequently during the development of our system that it is now the most dog-eared book in my collection. I'm going to order the fourth edition simply because this baby is ready for retirement.

If you are learning client-side JavaScript, by all means purchase this book. The first half of the book is a guided introduction to the language and does a wonderful job of explaining the syntax of the language, the underlying object model, and virtually every pertinent feature of the language. The real value, though, is in the reference, which documents every object, method, property and event of standard JavaScript.

Non-conformists who wish to exploit features unique to Internet Explorer will find some reference material here, but the book does try to focus on the "standard" features of the language, which I think is a good thing.

You just can't go wrong with this book.

If you are a professional programmer or a computer science college student who wants to learn JavaScript the "right" or "computer-science" way, you only need this book (David Flanagan's third edition of "JavaScript: The Definitive Guide").

The e-mail support is also very good with the author himself involved in the process.

I recommend it as a University textbook for a "JavaScript Language Programming" course and to everyone seriously interested in learning everything that there is to know about the language.

If you want a "cookbook recipe" type of text, get a different book.

It's big all right, but completely lacking in practical substance. Read this book and you'll give up before you even start coding. The most basic components of the language, such as datatypes, expressions, variables, etc., are explained in painful and excruciating detail, while solid, useful code examples are absent, presumably left as an exercise to the reader. The large reference section, which at least has some value because it lists all of the methods and properties, reads like the Unix man pages, all crytic explanations with no examples.

If you already know how to code but just not in JavaScript, choose JavaScript for the World Wide Web by Tom Negrino and Dori Smith to get you started with basic examples of the sort of tasks suited to JavaScript (field validation, rollovers, cookies, etc). For a more detailed text, try JavaScript Interactive Course by Arman Danesh.

An overall good book. The reference section is the strongest point, however the though of simply reading a reference section is terrifying.

If you already know one of the languages, or are familiar with Object oriented Programming, this is very probably the book for you.

If you have not programmed before, do a little online reading, then try this book. if your willing to put the time in, you will learn a lot.

Before reading this I knew HTML, and had read some online tutorials of JavaScript, which classifies me somewhere outside the realm of programmer. The first 11 chapters were rather abstract and somewhat confusing, and would have been moreso if i had not already read up a little.

But then it started making sense. you don't really learn how to write any script for real until about chapter 12, but then it really starts making sense. I had to read the beginning again after finishing the book, but now I feel like I have a firm handle on the topic.

Throughout the book many (many) referneces are made to the similarities and ifferences between JScript and C/C++/Java. There is an entire chapter devouted to java and Jscript working together.

This book is an excellent complement to Danny Goodman's 'Dynamic HTML'. I was able to put my new-found knowledge distilled from both books, together with ASP, to good use in creating a 30-page web application for marketing a local institution abroad. In practice, I learned that the greatest challenge facing the 'Dynamic HTML' author is providing consistency across the main browsers. Working with IE was fun: Navigator 4.0 has some catching up to do.

If you're already an experienced programmer, it can be frustrating trying to find a good book on JavaScript (aka JScript, aka ECMAScript, aka ECMA-262). A lot of books out there are aimed at HTML developers, maybe even graphic designers. Many such users have little or no real programming experience, and maybe no real interest. Books for that audience are user-friendly, filled with useful examples, and low on scary-sounding technical terms. In other words, almost useless.

Flanagan has good credentials as a technical writer, and as a highly technical writer. He really knows what software engineers look for - trust me, it's not what a graphic designer looks for.

This starts with a clear, methodical description of the language. Flanagan goes through all the language basics, pointing out where JavaScript differs form languages like Java, C#, or C++. The differences are numerous. For example, JavaScript has typed data, but not typed variables. It's object oriented, but doesn't have classes. It's an interpreted language, not compiled, and that opens up generative programming possibilities that reflection APIs can't approach.

After the language itself, Flanagan presents it in the client-side HTML context, where it appears most often. That's about 20% of the book. It goes over all the common HTML features, and shows how JavaScript can add dynamics or configurability to most HTML features. The last part of this section discusses XML and the DOM model. It does not yet discuss the E4X standard, ECMAScript for XML, the new ECMA-357 standard. As of this writing, the standard has only been out for three months, though. I'm sure Flanagan will catch up to it soon.

The book's remaining three sections cover the language's basic APIs, the APIs needed in the client-side HTML context, and the DOM model. The first two are fundamental to any non-trivial use of the language, the last is the programming model that gives access to XML or XHTML in a rational, predictable way.

JavaScript has a number of very different user communities, with different needs when it comes to language documentation. This isn't a cut&paster's book, and is nothing at all like a training guide. It's a reference manual. If you're a serious techie, then this is the book for you.

//wiredweird

I have yet to meet an O'Reilly book I didn't like, and this is no exception. As an instructor I am always looking for good reference texts and O'Reilly publishes some of the finest computer references available on the planet. They are NOT, however, "how to" books that most beginners will find useful.

Once you have grasped the basics of JavaScript and can tell the difference between a function, a method, and an event handler, THEN buy this book! Until then, stick with references from PeachPit Press, or the Dummies Guides. They will help you get started with a much lower frustration factor. O'Reilly texts assume some working knowledge of how computers work, and Javascript: The Definitive Guide will be much easier for you once you have an understanding of basic programming concepts and theory.

The Third Edition of Javascript: The Definitive Guide has several improvements over the Second Edition. For example, the reference pages include the availability of each command described (i.e. is it JavaScript 1.0, 1.1, 1.2 and which version of Netscape or MSIE will it work in). That aspect alone makes it worth every penny because it will save you HOURS of time when trying to write cross-browser friendly code.

Chapter 1 also contains some excellent background information about the history of JavaScript, dispels a few myths, provides an overview of client-side features and addresses security issues. (Not many texts even bother to mention that there ARE security issues when using JavaScript!)

Highly, HIGHLY recommended for intermediate to advanced JavaScript developers, or anyone who is already familiar with object oriented programming and wants to add JavaScript to their tool kit.

BKA

If you're looking for a complete reference on the JavaScript programming language, this is it. This book teaches the JavaScript language from the ground up and includes a very complete reference section.

On the other hand, if all you want is to write or understand JavaScript in its most common use - providing a little more dynamic content in web pages than can be done with html alone - the book may be overkill. For example, in addition to the useful sections on client side JavaScript - the JavaScript that you include in your web pages to be run in the client's browser - there are even larger sections that are really only useful for server side JavaScript - as if anyone uses JavaScript on the server side. As an experienced C, C++, and Java programmer, I had to wade through quite a bit of redundant material before I could effectively use the book to answer the simple questions I had.

In addition, some critical issues about using client side JavaScript are omitted from the book. For example, there is a chapter on security, but it only covers security issues applicable to the user - that with modern browsers, it's pretty safe for the user to allow JavaScripts to run. Issues pertaining to the security of the web site and the server it runs on - far more important to someone writing JavaScript code - are omitted. The book even provides a very unsafe example of allowing a client side script to calculate sales tax, which if used would make it easy for someone to tell your site he owed less tax than he really did, leaving the website owner holding the bag. It would have been better to include these server security issues and omit the client security issues.

Still, this book will let you find the answers to your questions, even if it does take longer than it seems like it should.

Having recently shipped an open source JavaScript application framework comprising 125,000 lines of JavaScript (TIBET) I can say it would have been impossible without Version 3 of this book -- and impossible with only Version 4 of this book.

Where Version 3 focused on documenting the *reality* of the browsers, covering the various bugs and inconsistencies in detail, Version 4 abandons that approach in favor of documenting the *dream* embodied in the standards. While that's "a good thing", what's really needed, and what was provided by Version 3, is a volume that also covers how the browers vary from the standards. That's what made V3 the best JavaScript book on the market. Much of that content has been removed from V4 however.

V4 is a solid effort. Don't get me wrong. You should have a copy. The coverage is for the most part accurate and accessible. The new content on Mozilla and the DOM/CSS standards is solid. But the missing material means you can't toss all your other JS books and just settle down with JSTDG V4 :(.

With V3 you rarely needed to go anywhere else. With V4 I find myself looking back at V3 to check accuracy or going to the net to search for bug reports. The book just isn't as functional in the real world of web development. So buy V4, but don't get rid of that well-used copy of V3 just yet ;).

ss

O'Reilly Press never ceases to amaze me. I have had this bookfor about a year now and it is my reference guide when I have aJavaScript question.

I did not learn JavaScript from this book, Iknew quite a bit about the subject prior to reading the book. If youwant a book that will teach you more than the usual annoying web trick(window:open, mouseovers, etc) get this book.

As far as I can telltheir code examples are virtually bug free. Usually any errors areposted with corrections on their web site...

Even if you are brandnew to JavaScript I would suggest buying this book as your reference.Then go to the web and learn basic JavaScript from one of the manyJavaScript tutorials available on the web.

The previous edition of this book, 4th edition, remained at arm's length at all times at work and rescued me repeatedly from various day-to-day JavaScript challenges. It has become tattered from rigorous use. I always loved how the book was organized, with the first half as a walk through the entire gamut of JavaScript's workings -- tutorials, walk-thrus, code samples, cross-browser issues, and practical solutions -- and the second half of the book as a complete JavaScript language and DOM reference. That already very useful format has actually been improved upon. David has combined the DOM API reference and client-side JavaScript reference into a single alphabetized section. Now that I think about it, I did find myself flipping back and forth a lot in the previous edition, so this is a welcome improvement. Each object, property, and method contains a helpful "availability" of that item. This may be the standards spec it came from [DOM Level 2 HTML, ECMAScript v1], the JavaScript version in which it emerged [JavaScript 1.0], or a list of browser versions, if it is a proprietary feature. This is critical info to have at-a-glance - could perhaps save you 2 days of work implementing a non-standard, IE-specific JavaScript feature, when you could have been coding the standards-compliant equivalent. David has removed a lot of the deprecated, not-widely-adopted DOM interfaces that no longer apply to modern browsers. David has also moved focus away from some of the more oddball DOM interfaces that have been replaced by more sensible JavaScript objects that implement those interfaces, for example, window.getComputedStyle() rather than AbstractView.getComputedStyle(). In other words, David has removed all of the "stuff that still exists, but you no longer need to worry about". This makes for a more focused, less cluttered, "on topic", useful tome. I don't need to know about the 10 different methods that browser manufacturers fought over 7 years ago. Tell me what I need to know NOW to write practical, functioning, modern, cross-browser JavaScript. That's exactly what Mr. Flanagan has accomplished.

What else is new in the 5th edition?

1. Nested functions and closures.

2. A dedicated "Classes, Constructors, and Prototypes" chapter, with much more coverage on object-oriented programming in JavaScript.

3. A new chapter on Modules and Namespaces.

4. New chapter on scripting Java with JavaScript.

5. Coverage of the legacy (Level 0) DOM has been combined with the W3C standard DOM. More consolidation. Less flipping back and forth.

6. Cookies and Client-Side Persistence. Updated coverage on cookies, and brand new coverage of other client-side persistence techniques, like IE userData persistence, and Flash Shared Object Persistence.

7. AJAX - Coverage of scripted HTTP calls using the now famous XMLHttpRequest object.

8. XML - Demonstrates how to create, load, transform, query, serialize, and extract info from XML docs.

9. Client-Side Graphics - JavaScript's graphics capabilities. The cutting edge tag, SVG, VML, and communicating with the Flash plug-in.

10. Scripting Java Apps and Flash Movies - Another brand new chapter.

So, is the 5th edition worth the purchase? Absolutely. This book is a must-have for any web development library. I turn to it repeatedly. Here's an example.

Last week, I overheard a developer on my team proclaim to someone, "We can't do that. JavaScript can't control stuff in another frame." They went and informed my boss how monumental their task was becoming as they proposed a hacky, inelegant server-side workaround.

I managed to grab the one developer and said, "JavaScript certainly can talk across frames."

"Really?!", he asked, astonished. I opened "The Definitive Guide" to the part on cross-frame scripting and bookmarked it for them.

"Oh, wow! GREAT!", he exclaimed, "That completely solves our problem. Totally cool!" and zipped away book in hand. Hours later, they had it worked out, rather than days with the server-side solution.

I've seen some one-star, complaint-type reviews posted that this isn't a beginner book. Exactly right, but I'm confused as to how a quality rating [of 1 to 5 stars] equates, in any way, to skill level of the book, or its ability to meet someone's self-conceived personal notions of what the book is supposed to contain. There are some overview-type chapters that go over syntax, operators, scope, expressions, and the usual array of language basics, but these reviewers are correct in that this book is not a beginner's tutorial on JavaScript. It is a meat and potatoes, soup to nuts definitive guide and reference on all of the important and practical aspects of JavaScript programming. It is not a cookbook of cute-but-useless cut-n-paste recipes [although there are plenty of USEFUL code examples]. It is not the quick-and-dirty example of how to slap the hottest AJAX library into your site to attempt to make it behave like a Windows app. The chapter on AJAX shows you how to use the XML HTTP object directly, wrapped up in some nice reusable routines, so you can WRITE YOUR OWN AJAX-based features [which I prefer over using someone else's complicated, obfuscated framework].

Great job, again, David! If you develop websites in any capacity, you need this book. It should be on every developer's shelf.

I'm a technical trainer, and we've decided to distribute this book as part of our Ajax courseware. We've reviewed many other JavaScript books, but we keep coming back to this one.

Suffice to say - its an excellent Core javaScript coursebook by itself (the first 220 pages). But the latest 5th edition is also a great resource for other Web 2.0 relevant topics: Ajax/Remote Scripting, CSS, Event handling, DOM scripting, ... The fifth edition also includes comments related to the just-release Internet Explorer 7.

Add in another 100+ page Core JavaScript reference section

Plus another 240+ page Client-Side JavaScript Object reference section (classes, methods, properties, and event handlers...such as XMLHttpRequest, Document, Window, Event)

And it all adds up to one thick/heavy book that deserves to be on your bookshelf...

My only complaint - the reference section has changed. Previous editions would tell you specifically which browser versions are applicable. In this edition, the author chose to tell us what standard provides the specification. Ex: "ECMAScript v1". IMHO - I wish the reference section consistently showed both bits of information ALL the time: the specification standard, and the browsers which support it.

This book is not for beginners. If you try to learn JavaScript from scratch, this is not the book for you.Try others. I only have little knowledge of JavaScript, I can not understand what this book try to convey. Lengthy description without good examples. It tells you a lot of things you don't need to know.The author likes to compare C/C++/CGI.. in this book in order to illustrate something I don't even care. Those readers who gave five stars to this book have already have great knowledge of JavaScript before they read this book (they forgot to mention that to you) or they are just genius. The only thing I find it useful is the reference.

This review applies to "JavaScript: The Definitive Guide, 2nd Edition" by David Flanigan, published by O'Reilly.

I'm a big fan of O'Reilly books, but this one doesn't get me where I need to go.

1) The topics are assumptive and don't include useful examples.

2) There are too few coding examples.

3) If not a regular coder in a OO language, this book will be especially frustrating.

4) The 'context' of meaning in examples and the code are routinely out of step. A lot of contextual (or what I call contextual at least) information is missing. The index seems like it was auto-generated, meaning it wasn't really meant for a human being to find anything with, just there because a book has to have an index.

For instance, I wanted to add some content using JavaScript to add to the body of the current page, but the only 'adding' reference is for mathematical operations. Looking under 'writing' or other similar words again doesn't give anything to do with adding content to a page already loaded. Then there's the whole 'self' and 'window' concept, which is great if I wanted to 'replace' the currently loaded page with content, but never in the book does it mention what to do with the current 'page', not the current 'window'. I tried other things like 'with' and so on, but 'with' doesn't seem to refer to the page, only other commands. Not really useful.

The index and chapters for this book really hamper understandning of what JavaScript can and cannot do. Invariably, I pour through the book, chuck it against the wall after fifteen-to-thirty minutes, scream, then spend another hour or so searching the 'net for an answer.

JavaScript is a hard technology to (truly) master, and with something called the "Definitive Guide", I thought I would have the tool I needed to get me, a code-tweaker, through my projects.

I don't think I found a single well-explained answer in this book to any JavaScript question ever. That's sad.

Save your money and buy something else. I've never been more unhappy with a book in my life than I was with this.

I bought this book hoping to finally have a complete Javascript reference. You know, the kind that lists the objects, then their properties and has a good index. At first glance this book appears to fill the bill, but after using it for some time I find myself going back to Goodman's "Javascript Bible". There is something half-baked in the organization of this book that makes it hard to find anything when I'm looking for it. In short, this is not the definitive guide, but merely one of several books you'll need on hand to program in Javascript. *Sigh*

This was my first book on Javascript and I think I got pretty lucky. I purchased the 3rd edition which covers up to version 1.2 of Javascript. However, we up to version 1.4 of Javascript (this may change tomorrow!) so this book lacks coverage of some of the latest features.

That said, it is a well-paced introduction to Javascript and, in contrast to some reviewers, I found it easy to follow. The examples are appropriate for the introductory level of the book. Some parts are better than others. For example, the chapters on constructor functions and object prototypes does a poor job of explaining the advantages of one over the other. On the other hand the coverage of the String and Date objects was excellent and indirectly explained much of the philosophy of the language.

The reference section is superb -- there are many books in my library that would be much improved by such a reference section. This is the book I reach for when trying to remember the differences between slice, substr, and substring.

The only reason I didn't give this book 5 stars is that it is more than a year old now and starting to look dated. It's high time O'Reilly published a 4th edition.

This book contains just about every obscure detail about JavaScript that you could possibly want. From its history, syntax, structure, operators, object hierarchy, methods, properties, etc..This book has what you're looking for.

All of the tools available to you in order to spice up your webpages are thoroughly documented in this book. Once you go through this book, you'll know the ins and outs of anything related to client-side JavaScript.

However, I wouldn't recommend this book to the absolute newcomer to JavaScript, especially one with no prior programming experience. Try something like JavaScript Goodies as an introduction. Once you're ready for all the nitty gritty details and to learn about JavaScript's complete (client-side) capabilities, this is what you're looking for. And of course, if you're interested in learning JavaScript, you should be comfortable with HTML.

One of the best in my library. Quick read. Concise, no lame jokes or philosophical episodes, plenty of practical examples. If you want to build a site which is sure to be compatible with both IE and Netscape, this book keeps you out of the ditches. The first half is a guide and the last is a concise reference. The index is great. I never fail to find what I'm looking for.

This book is a must for anyone seriously interested in Javascript. It is not a 101 "how-to" book. You won't find a wealth of script snipplets. If you want that, get them off the net. This book is a serious reference manual to help you learn the theory behind JS. When it all boils down, clipping scripts out of books (or off the web) can only take you so far. This book will can give you what you need to CREATE, not just snip & clip. But, you'll have to STUDY it. It's a "must have" book and one that serious scripters will use over and over. Serious A+.

This is the 5th edition of this almost thousand page book (992), and has been pretty much the gold standard for JavaScript reference books. I have the 4th edition that came out a few years ago and it was worth upgrading to this new 5th edition.

JavaScript use has changed a lot the past few years and this new edition definitely focuses on the changes that have been following JavaScript with Ajax and DOM implementations. The book is totally updated for updated browser support (IE6, Firefox, Opera and Safari) and details any specific browser quirks as well. This book will replace your hours of surfing online for JavaScript sites looking for that one obscure thing that you can't find in your other books. I also like it because it is easy to find things with its divided sections into: Core JavaScript, Client-Side JavaScript, Core JavaScript Reference, and Client-Side JavaScript Reference.

I really can say that this book does not leave anything out. Though I'm not a JavaScript guru (yet), but this book is as complete as you'll find (even comparing it to the Bible books). This should not be your first JavaScript book, unless you have some programming background because it can be a little daunting going through everything because it is so detailed. If you do any real JavaScript programming or development (or will be doing some in the future), this definitely has to be in your bookshelf.

Once again David Flanagan has created the definitive reference text for JavaScript. The most popular scripting language on the Web, JavaScript is nearly ubiquitous now. The fourth edition has been updated all the way from JavaScript 1.2 in the third edition to cover JavaScript 1.5 (ECMAScript-262 Version 3), the W3C DOM standard (Levels 1 and 2), while retaining the old legacy "Level 0" DOM for backwards compatibility.

Older editions emphasized Netscape over Explorer, as Netscape had more market share. This edition has almost completely purged this emphasis, and instead focused on standards-compliance for cross-browser scripting. With the proliferation of implementations, it is no longer practical for one book to document every quirk and workaround associated with all browsers. Focusing instead on specifications instead of implementations makes this book easier to read with a longer shelf-life, and your scripts more portable and maintainable.

With the release of JavaScript 1.5, better browser support, open source JavaScript interpreters (one in C and one in Java), and its availability on a multitude of platforms, JavaScript has become a mature language. This book reflects that. The fourth edition splits the reference section into three parts. Core JavaScript, which should work anywhere. Client-side JavaScript, which deals with browser-specific language material, and the W3C DOM has a section of its own now. The DOM defines a standard API that is distinct from the legacy API of traditional client-side JavaScript. Flanagan has found that depending on the browser platforms they are targeting, developers typically use one API or the other and usually do not need to switch back and forth.

The book is huge, some 916 pages long. In order to accommodate all the new material Flanagan omitted reference pages for the trivial properties of objects. Everything is covered in the object reference page, just not twice as before. Flanagan has left out some non-cross-platform features, like Netscape's nifty .jar ARCHIVE source file attribute, which is not supported by Internet Explorer.

While not a JavaScript in 24 hours how-to, this book has plenty of illustrative examples and explanatory text. This combination of explanatory material and matching extensive reference sections make this a must-have book for any JavaScript programmer. Highly recommended.

All Javascript books I've seen are aimed at beginners. This is the only one that gets your hands dirty with true blue computer science. No other book on JS is going to tell you the language uses prototype-based inheritence instead of class-based inheritence; in fact Javascript has a lot of similarities to the LambdaMOO scripting language, and I suspect the latter influenced Netscape engineers.

With this book I've learned how to visit all objects in the document tree and print out the source code for the event handlers. No "Dummies" or "21 Days" books are going to give you the theoretical grounding to do that! If you have an interest in computer languages in addition to having a need to script your browser, this book is for you. It has a great reference section for looking up language features and the various Window objects as well. If you want to build complex Web applications that use a lot of client side Javascript, this book will open new possiblities to you.

If you still own the Second Edition you owe it to yourself to buy a replacement; this Third Edition is a far superior book.

This is the most concise and focused book on JavaScript. I had tried two other highly recommended books prior to this one, and both left me with many unanswered questions and an image of JavaScript of being an extremely awkward and unmanageable language. This book made everything crystal-clear. There are practically no aspects of the language not revealed in the book. After reading it you will have a structured and in-depth understanding of JavaScript, including its most subtle topics. Examples are short and very helpful. Do not hesitate to buy it. I wished there was the new revision of the book to cover JavaScript 1.4.

The word "guide" suggests a book that will help you learn something from the beginning. This book won't.

"JavaScript - The Definitive Guide" is a very thorough and up-to-date compendium of the JavaScript programming language, so it's definitely an excellent reference book. However, unless you're already very familiar with other languages that have similar syntax and structure (C, C++, Java and perhaps PHP), don't expect to learn how to write JavaScript programs with this book.

The author has no qualms about using complicated language to supposedly "explain" simple concepts. You don't have to take my word for it; here's an excerpt, from page 110:

"The Arguments object has one very unusual feature. When a function has named arguments, the array elements of the Arguments object are synonyms for the local variables that hold the function arguments. The arguments[] array and the argument named arguments are two different ways of referring to the same variable. Changing the value of an argument with an argument name changes the value that is retrieved through the arguments[] array. Changing the value of an argument through the arguments[] array changes the value that is retrieved by the argument name."

Okay, so after reading the above paragraph two or three times you finally get it. But just imagine reading 424 pages (I'm discounting the reference part of the book) of equally dense text, with examples that are sometimes clear as mud.

Bottomline: Need a good JavaScript reference book? Look no further. Want to start learning how to write scripts for the web? You'd probably be better off with a book from the "Teach yourself" series (published by Sams).

Luckily I already had a solid handle on the basics of JavaScript before reading this book, because otherwise I'd be lost. One of the things every beginner programmer books needs is real-word examples of code with an explanation for almost EVERY line containing something new.

It sounds excessive, but if you want to learn something, that's how it works. This book, for example, seems to have devoted half a page to the built in Date() function - which is ridiculous! Dates in JavaScript are a big deal to me, and something I want to learn a lot about.

Ironically, the accompanying pocket reference that I happened to buy along with this book had more information concerning dates than the book, and answered the questions I had at the time, albeit with some guesswork on my part.

The only thing I will praise this book on for now (still going through it) is its chapter on the DOM - Document Object Model. So far it seems quite plentiful, which is good. I'm no JS buff, but it seems as if the DOM is a major part of the language.

Bottom line: do not buy this book if you're new to programming. If you already have a handle on variables, functions, arrays, and other such things, then you might be able to make do.

To quote from page 258 of the 3d (1998) printing: "...since the IE4 DOM will not actually be compatible with the W3C standard, and because it is not supported by Navigator (still the majority browser), it is not documented in this book". 'Nuff said. I only wish they'd said it in the preface!

I've got a real problem with this traditional-computer science approach of learning all about variables and structure but nothing that you can actually use.

This book is better than the previous book I tried, but it still doesn't allow you to really practice the code to learn it (to me, the only way you can really learn). It starts out really good, but still spends too much time on variables and structure and not enough real world code. The cookbook (additional book) is helpful but the code is too complex to learn Javascript on your own.

Look, books don't seem to be doing a very good job. If you want to learn Javascript, goto Yahoo.com and search for Javascript tutorial. I've just tried a few, but in an hour or two I've learned 20x as much as trying to read the book.

Having bought O'Reilly books before, I should have known better than to pick up this one. It follows the same pattern of giving far too much theoretical information without following up with good examples of the concepts in use.

The Core Javascript language section is great, and I can definitely see that the Core and Client-Side Javascript Reference sections will eventually be of great use to me. However, the Client-Side Javascript section is next to useless for learning how to pull all of the concepts together, and implement javascript on your web pages.

If you're already very familiar with javascript and need a reference book, by all means, buy this book. If you want to learn javascript programming, look for something else.

If your use of Javascript is primarily for DHTML on web pages then get these other 2 O'Reilly books by Goodman first in this order -- "Javascript & DHTML Cookbook" and "Dynamic HTML The Definitive Reference". These books cover not only Javascript, but also style sheets, HTML, and browser object models that are needed to make javascript work in a web page environment.

The first book by Goodman is all examples, with explanations of concepts included within each example, with the examples in order of increasing complexity and building on previous examples. Extremely helpful in accomplishing real work on real web sites, much more than Flanagan's Javascript reference guide, especially since Flanagans guide has very few examples.

The second Goodman book is a condensed tutorial on DHTML concepts (Javascript, style sheets, the browser object model, and HTML) combined with reference sections on these subjects. Javascript is just a piece of the web page puzzle. The Goodman books put all the pieces together while Flanagan just covers Javascript.

If all you need is Javascript get Flanagan. If you need Javascript for working with web pages get Goodman. If I had to choose only one book for using Javascript on web pages I would choose Goodman's "Cookbook".

I have tried several books on Javascritping and while they all seem to have the same format of learning, this book draws from a different line of thought, make it simple and you can learn. This book may just be the definitive guide to learning Javascritping.

Starting off this 750 plus page book is the explanation how JavaScript works from the client side and then from the server side of the things. This understanding is crucial to making sure your code is set up properly and that is works correctly the first time.

Other topics covered in the book include data types, values, variables, expressions, operators, functions, objects and arrays. All of these topics are detailed yet simplified so even I could understand the nature of the text.

Moving on you'll also cover how to setup windows, frames, DOM, events, forms, DHTML, cookies and security. All this is coupled with actual code screen shots to show you what the final outcome should look like.

The author's ability to break down each topic and show you what you need to know in order to write the best possible code is the basis of this book. Overall this book is one to have and use on a constant basis.

Perhaps this book *does* define every last aspect of JavaScript, but for the novice programmer, or someone who just wants to get started and write simple scripts, this book is heavy going. Chapter after chapter of detailed (and sometimes over-complicated) English explanantions would be more interesting with visual examples (like the Visual Quickstart guides, for example). We're all trying to produce code for a fun visual environment, but with its lack of supporting visual examples and lack of code examples, this book just didn't make me feel interested.

The book is poorly laid out, and the examples are not explained thoroughly. I already knew Java, so I was able to pick up JavaScript without a large struggle, but if I hadn't known Java, I would have quit reading the book about 10 pages in. One plus is the extensive reference section (200 pages).

This book is a reference book. Once you learn JavaScript from somewhere else then this book is great.

I ordinarily like to say that JavaScript is the worst programming language known to man, but I just read "Programming in Lua" and don't think I can continue in this practice. Nevertheless, it's pretty bad. From its lack of anything remotely resembling an "include" statement to its closures-over-classes OOP implementation, there is nothing pleasant about working in JavaScript, and that's why we need this book--to explain all the bizarre, counterintuitive nuances of scope resolution, interpreter variations and whatever all else the Netscape crackheads who forced this travesty on the world came up with.

Some people seem to think that any book that has the word "JavaScript" in its title should be packed full of code they can simply copy and paste until they have a bangin' new social networking startup site that's going to revolutionize the way we think about horrible photography, and those people are the ones who are disappointed with what they got. While AJAX and DOM scripting are discussed at considerable length here, this is not a book about making flashy, annoying websites.

This is one of the best programming books I have ever read. The author's style is very readable and he mixes in the appropriate amount of code samples to illustrate the concepts. All code samples are very well documented, which is a big help.

This is really two books in one. First is a thorough explanation of the JavaScript language fundamentals and how to use JavaScript in web pages. Then, comes the very complete reference sections which describe all classes and functions of core JavaScript, client-side JavaScript, and DOM programming. As a result, this is the only book you need to both learn and use JavaScript.

The author also does a nice job of pointing out which functionality will or will not work on Netscape or IE. And, he includes useful tips on how to work around some of these issues.

Those with experience in HTML but no programming languages may have a hard time with the level of detail in this book, but experienced programmers will appreciate the serious treatment of the JavaScript language. Beginners who just want to learn how to do simple scripts may want to look elsewhere, but for the serious web programmer, this book is a must have.

If you're thinking of using Javascript for webpages, this book is useless. Even as a reference it's awkwardly arranged and obtuse. The author seems to consider Javascript more intresting as a computer language than as a tool for constructing webpages, and so the book is organized around the abstract structure of Javascript rather than (for example) the structure (document object model) of webpages. Want to create your own objects with Javascript? Use it as a general language? Maybe you would like this.

Do you build websites? There are a hundred books you will find more useful. (O'Reilly usually has a pretty high standard of quality, but the occassional hack job does sneak through -- especially when it's their only book on the subject).

Another reviewer criticizes this book as not being for beginners. I say, thank goodness! This book is tailored as a stripped down, exhaustive guide to JavaScript in two parts: one by area of utility, another by function.

This is the book I turn to when I need to write code, as it has everything I need in it. It's absolutely not for beginners, and, you know what? Some books can't be. This is for people fully comfortable with JavaScript who need a reference because they haven't memorized the five thousand items in the language and all permutations and interactions.

Which is most of us, right? I write JavaScript every few weeks, not daily, and I love this title. I buy each new one when it comes out. (Which might mean this book is at the end of its revision schedule because when will a new JavaScript version ship? Probably never.)

Navigator may have been THE browser back in 96 when the book was first written, but this third edition came out in 98 when IE was fast taking over. I think it's a bit deceptive that the title doesn't indicate the strong Netscape Navigator bias. The end result is that I have to go out and get another book for JavaScript under IE. Pity! Also there's a lot of prose and not enough complete examples that one can try.

I am pretty new to JavaScript and so I decided to buy three book to get me started: this one, the Visual Quickstart Guide by Peachpit Press and The official Netscape JavaScript Guide.

I started with the Visual Quickstart Guide to get a basic understanding of JavaScript but soon noticed that I was just copying the scripts in the book and didn't really learn any JavaScript. This is where the Netscape Guide came into play. It took me through everything step by step and I am now able to actually programm my own stuff. I use THIS book mainly to learn the stuff the previous two books didn't cover and also as a reference, one of the really big plusses of the book. Half of the book consists of a reference that lists all the objects, properties, even-handlers and whatnot. Just amazing, has helped me numerous times!

I cannot recommend this book for absolute beginners though. It just doesn't take you through the process of learning step by step.

Although overall a good book, sometimes the lack of examples is very problematic. For example, section 12.2.4 (Javascript in URL's) does not give a single example that shows the URL script inside an href HTML tag. If somebody was not already familiar with this, they may find the context very confusing.

Another example is the reference entry for the 'window.onerror' command. The odd syntax of this command almost demands examples. I did not know that the handler function reference was not suppose to have parenthesis around it until I looked it up in a different book.

This is a welcome addition to any web development or interface design library. Unlike so many other books on J(ava)Script this book is authoritative (as of its pub date) and compendious; it is an invaluable reference. Like most O'Reilly books, this one manages far more material in greater detail than the typical bookshelf-bending how-to behemoth in far, far fewer pages.

- The syntax coverage is flawless, at times ruthless, and efficient.

- Flanagan shows how powerful, and genuinely object oriented, JavaScript is--prototypes are typically ignored in other books on the topic, with Nick Heinle's as a notable but incommensurable exception.

- Cross platform issues are handled well. When this book was written the IE/Netscape 4.x object models had not been fully explored and exposed as divergent as they are--no current book fully attacks this topic. Compatibility issues are handled straight back to Navigator 2.0. However, given recent browser developments, we're in need of a third edition (and Opera coverage).

- The examples are clear, eminently useful, and will help out even cookbook coders.

I've spun through at least 7 different books on this topic since 1996: if you're a beginner to programming, or a designer hoping to add to the toolbox, this one might be rough going at first. Once you're comfortable with JavaScript, this is the *only* book you will keep.

This review refers to the fifth edition of a book that was first published a decade ago. The fact that the book has remained popular for ten years and has gone to a fifth edition is testimony to its greatness.

If there were such a thing as a medal for lifetime achievement in technical writing, David Flanagan would surely be a leading contender.

Various editions of the book have been reviewed by key players in the JavaScript community, including Brendan Eich (inventor of JavaScript and CTO of Mozilla), Douglas Crockford (creator of JavaScript idioms for inheritance and scope), and Norris Boyd (creator of the Rhino JavaScript interpreter).

The best Ajax book on the market ("Ajax IN ACTION," Dave Crane et. al., Manning, 2006) contains an appendix on JavaScript that refers to this book as "the definitive work."

The book is divided into two broad sections: discussion and reference. Each section has two parts: core and client-side.

The core chapters cover language features such as data types, variables, expressions, operators, statements, objects, arrays, functions, classes, constructors, prototypes, modules, namespaces, and pattern matching.

The client-side chapters cover the use of JavaScript running in a browser to script browsers, HTTP (Ajax), documents (DOM), CSS, DHTML, graphics, Java Applets, Flash movies, and Java.

As the above indicates, JavaScript is not only an important technology in itself, it is also the key enabling technology for Ajax, DOM scripting, Dynamic HTML (DHTML), and Adobe Flash. And this book is THE BEST source for laying the necessary JavaScript foundation.

Furthermore, beginners need not be intimidated by the size of this book. Chapters 1 and 13 combine to make an excellent JavaScript primer or introduction. The remaining chapters are ready and waiting for when you're ready to dive into deeper waters.

This is THE BEST JAVASCRIPT BOOK FOR ALL LEVELS - beginner to advanced. PERIOD.

If you've been in web programming for a while, you're undoubtedly familiar with JavaScript, but may have dismissed it as a "toy language" for flashy graphics effects without much substance. Although JavaScript is certainly the web professional's tool of choice for flashy graphics effects without much substance, the language itself is surprisingly substantial. I had been meaning to learn more about it for years and tried off and on by looking at example scripts and reading online documentation here and there. I finally decided to break down and buy a book on JavaScript, and I'm glad that it was this one. I can't recommend it highly enough - it's especially targeted at people with programming experience. This book doesn't waste your time with basic constructs or meaningless metaphors; it gets to the point, describes JavaScript, and lets you get on about your business.

As the book itself clarifies, JavaScript itself is just a programming language and doesn't necessarily have anything to do with web browsers per se. However, since virtually all JavaScript programming is done for the purpose of controlling web pages, the author specifically dedicates one third of the book to the core JavaScript language, and another third to a thorough description of the bindings between JavaScript and the browser. (The final third is a well-indexed reference that you'll find indispensable).

Since you're probably most interested in the JavaScript-browser bindings (the core language is fairly well documented online), let me say that this books coverage of it is excellent. It covers the entire history of JavaScript, detailing compatibility issues between Netscape, IE, and Mozilla (all the way back to the very first release of Netscape) and detailing exactly the sorts of uses that JavaScript is typically being put to these days. An example in the section on event handling shows how to implement drag and drop on a web page in JavaScript (bet you didn't know you could do that!) and there's even a lengthy section on the relationship between JavaScript and CSS.

I couldn't be happier with the book - it lived entirely up to my expectations and was well worth the money I spent on it.

A great book, but I would've preferred "how to's" that covered common JavaScript uses, like rollovers. A little "cookbook" information would truly make this the "definitive" guide. Buy it anyway. O'Reilly books are extremely well-written. The best, in fact. Many computer books look like a bunch of technical gobbledygook when you open them up. O'Reilly books read like BOOKS.

Put simply, it is the definitive guide. This book starts with the basics of the language and then progresses through each individual piece of it in detail. It takes the time to point out the differences in implementation between browsers, which is very helpful, especially when using the book as a reference during debugging. The only thing I found lacking in the book were short, easy to understand examples of the language in action. While it does have enough code snippets in it to illustrate the general points, it does not show some of the more interesting parts of the language.

This book was required for my CSC 301 "Distributed Software Systems" course in college. I would get alot of programming assignments and try to use the book as a reference to learn the syntax of the language, but, there are virtually no examples to look at and learn from. Maybe when I'm at a more advanced level with JavaScript, I'll appreciate it more, however, right now I'm giving it two thumbs way down.
If you are a beginner to JavaScript, this book is not for you. Even if you have some programming coursework under your belt, this book is not for you. I've taken alot of programming courses and never really had any problems finding answers to my questions, but, I look through this book and I can't find the answers I'm looking for.
Don't waste your money on this book.

I had a VERY basic knowledge of JavaScript coming to this book, (i.e. I could make an alert popup) and no knowledge of other programing languages (well HTML, but that doesn't counts). I found it to be an excelent resource and teaching tool. True, some parts are complicated, but you can skip around chapters with relative ease, and I could always figure things out with some puzzling. It's nice how authoritative it is, and how completely it documents the syntax. It takes a while to get into the programing mood and understand its power though, so it requires some thought to get into the more advanced techniques. I would recommend this book to anyone, with the possible exception of someone without a strong basis in HTML. Also, quite frankly, what you get out of this book depends on your intelligence. If you like to read manuals (like I do), and have a strong basic computer knowledge to back this up, it'll be all you could hope for.

Unfortunately, there are more JavaScript books available than there are stars in the sky. For someone trying to learn JavaScript, I can only imagine the difficulty of trying to pick a good book. I've read several, sold several, thrown away several. You're luck finding a decent book would almost be as good as walking into a book store, closing your eyes, and pointing randomly. That is, EXCEPT for this book.

I cannot stress enough the QUANTITY of information contained in this book, nor can I stress the QUALITY of that information. The first section provides an understanding of the framework and fundamentals of JavaScript. This is a thorough explanation that will NOT leave you wanting like some "Nutshell" or "Learn in 24 Hours" book. The second section is an alphabetized list of every JavaScript element, and here's where the power of this book comes out: each element is defined including any browser limitations, all possible properties and functions of that object, and, in most cases, an actual working example. Yet, with all of this, my admiration for this comes in the last section: a detailed explanation of all the exceptions to the rules. You WILL NOT find this in any book, at least none that I've seen. More than once, my entire team was hung on something only to look in this book to find the problem described with an explanation of how to get around the limitation in the language. This alone is worth every penny, believe me.

If I could give this book more than five stars, I would. To this day, it remains *THE* most valuable book in my bookcase.

It's been said in other reviews. The book is great for reference. However, if you're new to Javascript, this is not the book for you. The author explains concepts in abstract detail. Then, he either doesn't give an example, or his examples are so arcane (i.e., trigonometry or some other obscure math example) that it doesn't clarify the concept he is trying to present. I hope O'Reilly realizes it's missing a marketing opportunity. How about a book for someone trying to Learn Javascript without a great deal of programming experience?

This is a great book. I give it a high recommendation. I'm an application programmer, not a systems programmer nor a software engineer. VB and SQL are just my speed and most 4GLs and scripting languages are too. I may not be a progamming genius but my attitude is 'how hard can it be?'. I will try to hack anything I can before I ask for help, but when I ask for help, I want the full complete definitive answer. That's why this book is for me. I have never coded a lick of javascript before, then one day I had to write some cookie stuff. Fine, how hard can it be? I go out onto the web and look for (and borrow) other cookie code. I find a little bit here and a little bit there. It looks very simple but ultimately none of it works for my problem. Finally I say, I'm going to have to learn this stuff. Might as well by the O'Reilly book. My attitude is that I may never have to do anything with Javascript again, but I'm also not about to waste money on a book if I'll have replace later if and when I get serious. And this book was worth it. I now have industrial strength overkill cookie code in my application plus I undertand why everything works as it does. If you have to ask, you might as well ask for it all. This book has it all. Now I can't give it 5 stars because it's outdated. There's a lot of stuff in it that doesn't apply to the latest browsers. There was nothing about Mozilla or IE 5, so that all needs to be updated. But what's there is good so you get to understand the development priorities of those browsers and what effect that has on ways you should code. All in all it's another home run for OReilly, but Flanagan needs to step up to the plate again. BTW you'll note that this book is often referenced in other good progammer's guides. "Definitive" is right.

This book is a very complete reference for the Javascript languge. It pays particular attention to the incompatibilities that plague the different interpreters/browsers. The book is fairly well written; it doesn't cause your eyes to glaze over from jargon overload. However, it also sometimes underestimates the skill and experience of the targetted reader, IMHO. Considering that this language is predominantly used for scripting web sites, I expected something a little different: more concentration on application and examples and less repetition of fundamental programming concepts and definitions.

Still, this book does a good job at cataloging the syntax and features of the language. It will probably be a very helpful book for people who are new to programming and want to learn a scripting language.

The cover is great. Nothing like a Javanese Rhino to make me whip a book off the shelf. I do not think this is a good beginner's book, though, but once you know what you're doing, it's the thing to sink your braincells into. Absolute beginners should check out something like Javascript Goodies by Joe Burns or an online tutorial.

I agree with many of the writers so far. I find that the book is an excellent reference and a great way to learn javascript functions and methods.

However, the lack of examples hurts the book tremendously and often prevents the reader from applying what they learn to real world examples. Nonetheless, I find myself going back to this book over and over again to solve my javascript problems because it is a great reference.

As for the cover, don't judge a book . . . Once it is opened you don't see the cover anymore. As a philosophical aside, it is this type of logic that keep people from understanding those that are different than themselves.

Overall, I have enjoyed this book and continue to use it today.

I would like thicker pages though so that my highliter doesn't show up on the other side.

For a 600-page book, there certainly isn't much you can use. The first 150 pages (9 chapters) cover elementary stuff like statements, arrays and operators. Although this introductory stuff would have been great for beginners, the author's high-handed style is focused on advanced folks, meaning even though there's 150 pages on basics most people can't understand it.

The next two chapters drone on and on and on and on about structure and name space--another waste of 50 pages. The real meat of the book runs from chapter 12 to chapter 17, a 100 pages of real stuff that may be useful if you can stomach the first 200 pages.

Afterward, the author starts elementary discussions on compatibility, LiveConnect and security. Although these are useful subjects, once again the author assumes that you know what's he's talking about, meaning these chapters are pointless. Either you know the stuff already or you don't and you certainly aren't going to get anywhere with the author's discussion. The next 200-pages provide a JavaScript reference that is flawed and not current. Granted, the book professes to cover JavaScript for Navigator 2.0 and BETA Navigator 3.0.

In summary, after reading this book I was very disappointed and felt cheated out of my money. In the end, I sent the book back and got a different book. My choice this time was based on a friend's recommendation (Netscape ONE Developer's Guide, which covers both client-side and server-side JavaScript, LiveConnect and other Netscape technologies). If you want to learn real-world JavaScript, I too recommend Netscape ONE Developer's Guide. Thomas Warren

I used to think that JavaScript was kind of a toy scripting language -- only good for doing minor web page tasks. But after reading this book -- my 3rd JavaScript book -- I found out that JavaScript can do as much as most programming languages, except for low-level system calls, etc. I'm starting to use JavaScript as my main programming language at home. It's a lot more fun than C++, and it doesn't require a compiler, etc.

David Flanagan knows JavaScript inside and out; he explains everything very clearly; and he covers every detail of the language. If you are a JavaScript programmer, this is THE book to buy. You won't need any other ones.

The information in the book is absolutely solid, but WOW is the information mundanefully unappealing. There was ZERO thought into keeping the reader interested with content layout, bordering, graphic design, illustration, examples, etc. It is a good resource to have handy. I hate to be the superficial simpleton in the bunch but I'm rather BIG on ascetically appealing text... (it helps with my acute A.D.D. ... j/k ;) this is not that. It's like reading the paper version (vs. online version) of the wall street journal... dampened by the rain and chewed up by the neighbors chihuahua. For those like me try, 1. "JavaScript in easy steps" 2."JavaScript for the world wide web" and 3."Pro JavaScript Techniques"... in that order.

This book is divided into four parts - Part 1 covers core JavaScript and it has an incredible amount of detail and examples illustrating fundamentals and intricate details of the language. As the author points out amply by giving specific code examples, even experienced programmers will be surprised by unexpected behavior if they are not careful! Part 2 covers Client-Side JavaScript which is of most interest to web developers - this book simply does an outstanding job of presenting various topics in this part with amazing clarity. Part 3 has Core JavaScript Reference and some of the examples and explanations from Part 1 refer to this part. Part 4 has Client JavaScript Reference and there are references to this part from some chapters of Part 2 as you may expect. Essentially, parts 3 and 4 have the comprehensive API reference.

I read parts 1, 2 in full and I tested the code examples. For the most part, the examples run fine without any problem. The only exception was the chapter 23 that explains scripting flash and I was getting some exception when I tried to run it in both IE and Firefox. Where there are significant differences between IE and Firefox, this book does point out which is really helpful since these two are the most widely used browsers. While this book is not a light read, it is very comprehensive and therefore the only book you ever need on JavaScript. With this book (and possibly few searches on google searches), any one will have all info needed to implement specific functionality using JavaScript. Highly recommended to both novice users and highly experienced JavaScript programmers/developers.

As should be obvious from the large number of positive reviews, this is a great book. I've got a well worn 3rd edition laying around somewhere as well as an abused 4th edition I just replaced with the 5th edition. In short, if you're a new developer trying to get a grasp on serious JavaScript or otherwise looking for a quality JavaScript book, you can't go wrong with this book.

If you're debating whether or not to "upgrade" to the 5th edition, I guess I'd throw out a few thoughts:

1) If you have the 3rd edition or earlier - it's a no brainer, this book is worth the upgrade.

2) If you primarily use the Core and Client-Side Reference portions of the 4th edition (the last 1/3 of the book) - I'd say its a coin toss. The layout is a little cleaner and the information is a little easier to find, but the content hasn't changed significantly (as the APIs haven't changed). Flipping through this section, I did notice the addition of the FlashPlayer object, though.

3) If you used the first 2/3 of the 4th edition - the content and layout has changed and new stuff has been added around cookies, client side graphics, and (everybody's favorite buzzword) Ajax. Enough new stuff to warrant and upgrade, in my opinion.

For details on the changes, it would be worthwhile to read the comments from the author.

Like a lot of people who have been doing web work for a while, I had learned JavaScript a little at a time, figuring out a few tricks here and there but never really going that deep. I had always sort of written it off as a light-weight language and had turned to Perl or PHP when I really needed to do something serious on the web. This book has changed all of that. From start to finish, the explanations were clear and thorough and I came away with a very solid understanding of the language. There are lots of books and web sites that will teach you how to pop open a new window or do a simple rollover, but if you're ready to really learn what JavaScript can do, this book is the one to turn to.

If you can't learn JavaScript with this book you may as well give it up. I have an extensive library of programming books covering a variety of languages and this is easily the best I have ever seen. If you are an inexperienced programmer trying to learn JavaScript this is THE book. If you are experienced and want more depth of understanding, this is your book.

As each new concept is introduced, the usual questions which occur to any programmer are answered clearly and concisely. Browser specific issues are addressed. Material is organized well so you can always find what you need. Nuances of the different Document Object Models are covered. This volume is uniquely qualified to be both a reference and a text book.

My profession requires that I read extensively, but I almost never write a review. I am compelled to make an exception in this case. This book is so good it simply must receive it's due.

"JavaScript: The Definitive Guide" should be required reading for anyone aspiring to write a book on any language. This is the standard by which all other books on the subject could be judged. Four adjetives say it all; readable, clear, accurate and thorough. By all means buy it. It's the best on the planet.

Probably it is not for newbies.. not sure

I am not new in Javascript. My first book was "javascript bible" by Danny Goodman, which got me started with it couple of years ago.

Last year, by accident, I came accross O'reilly's Safari subscription project, and decided to refresh my Javascript knowledge. One of the books I checked out was David Flanagan's "Javascript The Definitive Guide".

I read several chapters from it, and I cought myself enjoying it more than enjoyed my previous similar titles. So I decided to buy the 4th edition of the book, and was not disappointed. So what things does David do differently? Read on!

I remember "Javascript Bible" by Danny Goodman starts off with hands on examples, which anyone without any knowledge of Javascript can try out in his/her editor. This is not the case with "Javascript The Definitive Guide". If you have no idea how Javascript works, you will not see a working real-life example untill Part II (page 181). Untill then, the author explains the core syntax of javascript, how javascript interperator works, how it wraps things into two objects: while interperating - Global and Call objects; talks about variable scopes and Garbage collection, objects, arrays, operators and other good stuff. It will tell you the different between object properties and variables ( or does it say there're no differences? ), talks about Regular Expression and nested functions.

People who have little or no programming background tend to find this chat quite boring and meaningless ( as I would've couple of years ago ). But if you have some Javascript background, or at least know how Javascript works in the browser, and what to strengthen your knowledge of Core JS, you will find this book very informative.

Part || is dedicated to Client side Javascript. That's where your browser comes into play and all the fun starts. Only here it will tell you that "Global object" mentioned in the Core Javascvript part is called "window". Talkes about CSS and DHTML, Scripting Cookies, DOM. It covers every single aspect of Client-Side JavaScript that a good Javascript book should cover.

The rest of the book consists of very well designed references, that you will be using most of the time.

While i'm generally against JavaScript (prefer CGI, CSS, etc.), there
are times when you will need browsers to do some data interpretation. JavaScript is definitely the way to go when you need that power.

This book is definitely not a 'here's how javascript works' book. It is aimed for someone who has a solid understanding of web page design as well as a fairly solid grasp of the basics of programming.

I particularly thought that the way Database linking was dealt with was done very well (altho it's much better done with Perl :) )

The book is good, but does not touch new application of JavaScript - Windows Host Script, MS scripting control.

I'm learning JS at the time of this writing. So far I've bought Goodman's JS Bible, this book by Flanagan and a Peachpit Press book by Negrino & Smith. The Definitive Guide is the best by far of the three. Flanagan does a superior job of writing and explaining clearly.

One drawback to Flanagan's book though is that it mostly seems to be written for someone who has a programming background. His first few chapters will only make sense if you know programming techo-lingo. If not, then your going to have to find another source to get you off of the ground. When your ready to fly, buy *this* book.

§
The new edition of The Definitive Guide represents one more step in the continuing increase in the availability of material on the new ways JavaScript is being implemented.

In the words of the author, "For today's web applications, JavaScript developers are writing programs that are an order of magnitude longer than the scripts that most of us were writing five years ago. The new material on classes and namespaces explains how to structure JavaScript programs and offers techniques for successfully using JavaScript for programming..."

The book is a reference that can be of use to anyone working in JavaScript but it is not a beginner how-to. The book should be seen as a guide for the experienced Web worker, especially those involved in making Web applications.
§

I wasn't a complete beginner to programming, but I was a complete beginner to JavaScript when I read this. JavaScript (also known as ECMA-262) is a beautiful language, so I don't know how much of my fondness for this book the language deserves instead, but I love it. This technical book is one of my favorite books overall, even rivalling (though still falling far short of) "Atlas Shrugged".

Readers of this book will scoff at books claiming to teach advanced JavaScript topics, such as "DHTML Utopia" from the (generally worthless) SitePoint series. It takes the reader all the way from beginning to advanced topics until DHTML is simple. The author even covers the sorts of best practices, such as feature detection rather than browser detection and JavaScript segregation from HTML, for which later writers on the web claim credit and expect praise. (I don't mean to suggest that Mr. Flanagan was the original source. I only mean to condemn second-handers who mystify the field of programming to win undeserved respect for espousing common-sensical and commonly-espoused principles from the sorts of people who are afraid to read technical books.)

The author omitted much that is nonstandard and particular to Internet Explorer, but after reading this, one can easily learn whatever he needs to know about Internet Explorer's flawed DOM implementation from Microsoft's MSDN library site.

Some people want short, simple books that will help them write simple pages within a few hours or days. They don't like this book, which is for people who want to master JavaScript, master web browsers' Document Object Model implementations, and master client-side web programming to write complex solutions to real problems. The author even covers regular expressions well enough for readers immediately to use them to complete complex tasks.

If you want to master web programming, be patient and read this book.

A great book which has helped me out so many times. If you live, eat and breath JavaScript then you probably don't need this book anymore. However I find that I use such a mix of technologies; Lotus Notes, LotusScript, Java, C, C++, HTML, XML etc, that remembering 100% of the syntax just isn't realistic. That's where this book comes into play as it always seemed to contain just the right information to keep me going.

JavaScript: The Definitive Guide is an excellent reference book. Unfortunately many (if not all) of the examples use Internet Explorer extensions instead of standard methods/properties. For a newbie this can be frustrating when the example in the book does not work. And even then I discovered I had to make changes to some of the examples to work on Internet Explorer 6.0. If the examples used the standard (and only the standard) methods and properties this headache would be reduced and, maybe, eliminated.

As a long time C++ programmer, I found this book to be neither too hard or too easy. Readers with no programming experience at all might have a harder time with the text, but if you have any kind of programming background, the text will serve you well. As a reference, the text is second to none. Even the DOM reference is one of the best out there.

The O'Reilly books, for the most part, are some of the best written. But this book in particular, is an essential for any web developer or programmer and in my opinion, the best book ever written on Javascript.

This book covers a massive range of material in the Javascript language using realistic examples and clear explanations. It can be used both as a learning tool and an important resource which I refer back to often for my Javascript needs.

Items I found to be especially useful about this book were the Appendix areas, the way that just about any term is included in the index, and the listings of implicit objects with their properties, methods,arguments, and the accompanying explanations and examples. The book also incorporates how to concatenate JS with Java and with HTML for forms validation, one of the most important uses of the language.

Definitely a true treasure amongst a sea of programming books!

Val Fahey
E-Commerce Analyst

JavaScript is not well organized nor standardized which makes it inherently confusing to work with at an advanced level. But the organization of this book does not help matters. Too often I find myself with book marks in 5+ places as part of researching a fairly basic technique. Some of the examples are overly complex and not real-world. If your customer is standardized on IE 6.0 there are some things missing (contenteditable and document.selection for example). The subtitle "The Definitive Guide" may not be warranted.

I can't imagine any serious Javascript developer not having this book in his or her collection. It is the most complete reference I have seen on Javascript, and one of the most professionally written books period.

Where I work, the book is near ubiquitous among our web developers and has proven to be a valuable desk-side resource. I recently bought the 4th edition, after some of my coworkers commented on how worn my 3rd edition had become. No surprise, really, considering that I had to share the 3rd edition among six developers, all of whom were learning Javascript for the first time. I'm glad to once again have a nice, fresh copy of this book, and even more so, glad to have an updated reference with coverage of the new features in Javascript 1.5.

I'm pleased to say that the 4th edition lives up to the reputation of its predecessor. Reading is easy and informative, and the reference section provides answers to just about any question you'd have regarding the language syntax and object model.

If you're a web developer and have no other books in your collection, make sure you have this one.

Its a good book. The information and is all there, and the author gives thorough coverage on the topics. The reference this book provides is excellent. The only drawback is the book has no tutorials and i have to get them webmonkey.com. I would give 5 stars if the book has slightly more examples, pictures(print screen's) and if the book has slightly thicker paper.

Using this book, and having never written a stitch of JavaScript in my life, I constructed a complete, dynamic, client side treeview that can render 1000s of nodes in seconds, by using the object-oriented concepts in this book and creating my own JavaScript objects. That one-star review below is absurd: if you're going to use the language, use the FEATURES of the language! Now, as for JavaScript itself, it is a phenomenally powerful language. It is not the language itself that has relegated it to the status of a toy-- rather it is the -----poor cross platform support for it in browsers, and the fact that nobody can make any money from it.

If you want to know why there are no other, more recent books available on JavaScript, buy this book: then you'll know. The competition have simply closed their doors on this one.

This book was the first O'Reilly book that I bought. It's the best JavaScript book I currently have in my programming library and I refer to it frequently. The book is part tutorial and part reference and is nicely done. If you're new to JavaScript this book is for you. The first section of the book introduces you to the basic syntax of the scripting language and offers some nice examples. If you are a JavaScript guru it makes a nice reference book. Worth a buy!

If you are a begginer, or an advanced JavaScript programmer this book will be very worthy of your attention. From the first chapter where you will be saying to yourself "I'm not understand anything", to the last chapter where you will look back and lauph that you could not understand the topics he mentioned. If you are a high level HTML writer this book will not only help you, but it will make your web pages one step ahead of your competitors. "Reading Time:Beginner:Month/Advanced:Week."

to write books this good on every programming/scripting language I want to learn. The book is not for raw beginners; you should already be able to program in a language related to C (e.g., C++, Java, Perl). That said, this is the best book on a programming or scripting language I've ever seen (I've read dozens, on four different programming languages and three different scripting languages). If you're a serious programmer who wants to learn JavaScript, GET THIS BOOK.

A dog-eared copy of Edition 2 sits on my desk alongside the new one. I find the writing to be clear and concise. However, the new edition shows how the frenetic pace of the development cycle takes a toll on content.

Specifically, there are inaccuracies in the book and places where it's incomplete. For example, In Chapter 13: Windows and Frames, the discussion of Timeouts and Intervals has this to say:

"The setTimeout() method is commonly used...to animate some kind of message in the status bar of the browser. In general, animations involving the status bar are gaudy and you should shun them!"

I don't need specious comments on the merits (or demerits) of status bar animations, but I do want information about the return value of the setInterval() method. I had to search on Netscape to find the answer I was looking for.

My other complaint is that Internet Explorer's implementation of JavaScript is poorly documented. The authors justify this by the simple expedient of declaring Navigator as the Default JavaScript interpreter.

I need to script for both browsers, however much I may like Netscape Navigator.

To conclude, I have the highest regard for the author, and I do recommend this book. But there are bugs.

I own a bunch of other javascript books and I won't be using them any more. This book always seems to have some detailed info that helps solve whatever problem I'm dealing with. The new edition has full ajax converage. Also the css chapter is very useful and the chapters about object oriented javascript are also exceptional.

I hated the book. I purchased the book because I wanted information on how to use Javascript to implement GET or POST transactions for a website I am working on. None of the examples are complete or clear enough to be of any use whatsoever. Its a lot of verbage with partial code snippets much like microsoft's (terrible) documentation. Don't waste your money.

It's called "The Definitive Guide" for a reason. Covers everything from simple variables to complex AJAX coding. Beginners may be a bit overwhelmed by it, but I would still recommend any O'Reilly guide as it's the one you'll actually use as your skills increase..

This book is just PERFECT... I think this book contains ALL the Javascript language, even the creator of Javascript (Brendan Eich) recommends it, it's amazing!!!.
For me, this is simply the BEST book of Javscript that i've ever seen. It's absolutely simple and easy to understand. It has a lot of simple (and not-that-simple) examples of code.

I'm sure that with this book you'll learn a lot of Javascript and then, you'll be able to make a very useful, sophisticated, and beautiful website.
I really, REALLY recommend to buy this book... when you have it in your hands, you'll remember these words : )

A LITTLE WARNING: (Like I wrote for "PHP Bible")
If you want to use this great book, you have to know at least a little bit of HTML, because Javascript is a language that improves HTML. If you don't even know what is HTML, you'll not love this book as much as I do... so, I recommend that before you get this book, you study some HTML : )

I have been using David Flanagan's "Javascript: The Definitive Guide" since the 1st edition came out in 1996 and I have nothing but praise for this book, a perfect example of what makes O'Reilly books O'REILLY BOOKS. With every new edition, David Flanagan has added new material related to the newest incarnation of Javascript (the latest being 1.5) and he provides a solid introduction of what Javascript is, the history of the language, and the basics. From explaining how control structures are use