Most O'Reilly books I've read are fun and very informative, but this one is dry and full of typos, uses poor examples and is poorly ordered. I do not recommend this one.

One does not read this book; one is tortured by it.

There are two major complaints I have with this book. The first is the number of errors in the text. (If you read another review of this book and it does not cite the problem with errors very early in the review, then you must be reading a review from Ms. Powers's fiance, sister-in-law, best friend, or cousin.) I have never seen anything close to this level of ineptitude in any other book I have ever read, programming-related or not. Just to tip-toe through this cow pasture:
- By my quick count, there are eighty-three errors listed on the book's errata web page. (It took me about two hours simply to go through the book and write in all of the corrections from the errata page.)
- Ms. Powers occasionally manages more than one error per page.
- Not only do the errors occur often, the arise early. There are errors in each of the book's first three Examples, with Example 1-3 alone mangaging to contain two errors.
- Beginning with Chapter 2, Ms. Powers concludes each chapter with a number of exercise questions - the answers to which are provided at the end of the book. Of the five Chapter 2 answers (i.e., the first five questions and answers in the book) there are errors in three.
- Page 11 is missing, well, two pages! The errata file contains ten paragraphs of text that is missing!
- Any number of errors are "simple" typos: the text uses a hyphen when there should be an underscore, variable names are misspelled, errant characters are enclosed, words are duplicated - that kind of thing. While this is sloppy and wholly unprofessional, one could argue that in The Grand Scheme of Things such errors are minor. However, a number of errors are more egregious. For example [all CAPS are mine]....
-On page 94 the book talks about how "the shift RETURNS the first element." Oops! The text should talk about how "the shift REMOVES the first element."
-On page 101 a sentence which begins "If a condition IS met...". Darn. It should read "If a condition ISN'T met..." (Details, details...)
-On page 127 a phrase "cascade means that the LOWEST..." should be (Anyone? Anyone? Class?...) "cascade means the HIGHEST..."

All in all, this is just shameful stuff. If you have a quasi-morbid sense of curiosity you might want to check out the Acknowledgments section which concludes Ms. Powers's Preface. There she thanks her editor, three "tech and content reviewers", a production editor, and a copy editor. I say "quasi-morbid sense of curiosity" because, presumably, all six individuals have since been, as the British like to say, "sacked."

All that said, let us gingerly put aside, for a moment, the stupefying number of errors in this book. How does it fare otherwise? (Or, to cite a quip I just love, "Other than that, how was the play, Mrs. Lincoln?")

Well, I come now to my second major complaint. Errors and typos aside, the book is just terribly written. The organization is dreadful and her grammar is rotten. In fact, the only thing I see Ms. Powers having done well is to compiled the epitome of how NOT to write a book on programming. The two essentials of a good book on programming are that the author:
1) Organizes the material in a logical, coherent manner. A GOOD author introduces essential concepts at the very beginning, and then steadily builds upon and expands upon what the reader has just learned.
2) Takes absolutely every pain to minimize 'jumping ahead' on topics.
Ms. Powers, however, repeatedly drags the reader into complex asides before bailing out by saying "but we will cover that topic later." She does this from the get-go, and it is maddening. Here are some examples from Chapter 1 ALONE...
- In a section about cross-browser incompatibility (p.4), Ms. Powers states most of these incompatibilities "are based on differences in the underlying Document Object Model (DOM) exposed by the browser...". She then goes on for a couple of sentences about why this is so. I, for one, knew next to nothing about the Document Object Model, and I bought the book, in part, because I saw that it contained a discussion of the DOM. Ms. Powers's in-depth discussion of the Document Object Model, however, occurs in Chapters 9 and 10! She should either have made these chapters, perhaps, numbers 1 and 2, or she should should avoid mentioning the DOM until the subject is covered.
- In the section, beginning on p. 7, in which she introduces use of the
This is helpful to know when as a Flash developer you will need to use this line of code in the header of your HTML file to use the Flash (SWF) Object as a work around for the Microsoft Eula. Comments are written the same way in both languages.

I appreciate the higher-level view of programming this book gives you. The author has written books not only on JavaScript but, ASP and Unix so it really has a technical flavor.

Comments are written the same way in both languages. One thing that is quite different is the use of ellipses.... They mean that what follows is processed if the equality operators are evaluated to be true.

The author gives you a real history of the use of JavaScript. She explains how ten years ago when most browsers were on their first or second version, JavaScript contents were enclosed in HTML comments . This was done to keep some browsers from printing the output of the script tag to the page. When the script was enclosed between these HTML comment tags the browsers didn't know it was there. However, that is not something we do today because browsers that don't understand JavaScript are long gone and use of these tags conflicts with pages created as XHTML.

There is discussion about all the programming basics for JavaScript like data types and variables, scope, statements, conditional statements, switch statements, and conditional operators, loops, regular expressions, functions, and objects.

Shelley even gives you the URL for a free JavaScript editor. And many useful links full of JavaScript libraries.

The DOM 2 Event Model is discussed. Each object has 3 methods: addEventListener, removeEventListener, and dispatchEvent.

Then the author goes on to talk about JIT Validation. This stands for Just-in-Time. It is timely forms validation that is triggered as the user goes through the form fields.

Shelley gives you the method to store/read cookies. You will need the cookie name or key, an associated value (cookieName = cookieValue, an expiration date, and a path associated with the cookie (at the top most level of your domain for security). You also must specify whether the cookie is HTTP or HTTPS.

JavaScript derives its OO functionality from prototyping. ActionScript used prototyping in the 1.0 version of the language and has gone way beyond prototyping.

Another great feature of this book is that it discusses AJAX (Asynchronous JavaScript and XML).AJAX is outside the page and requires a server component. It allows web-page form validation to happen in place. By clicking a button a huge form will collapse and clear up the clutter on the page. AJAX handles sending a request to the server, invoking a service and returning data all within the context of the same page. An example of a famous AJAX/DHTML/JS application is Google Maps.

It is a theoretical history with some code examples, which refer you to other links for code libraries you can work with. It is not, however, project based. I recommend it to people interested languages other than JavaScript because it gives you a higher level view of the programming field.

The author definitely sounds like she knows all about javascript, but there doesn't seem to be a real emphasis on teaching for a "learning" book.

The first couple chapters are a dry overview of the nuts and bolts of javascript, if you've have programming experience this will be familiar. After that the book goes into broader topics, but doesn't do much in the way of teaching. More examples, and more specifics would've been helpful.

I wouldn't recommend this book, there has to be a better introductory javascript book on the market.

The author definitely sounds like she knows all about javascript, but there doesn't seem to be a real emphasis on teaching for a "learning" book.

The first couple chapters are a dry overview of the nuts and bolts of javascript, if you've have programming experience this will be familiar. After that the book goes into broader topics, but doesn't do much in the way of teaching. More examples, and more specifics would've been helpful.

I wouldn't recommend this book, there has to be a better introductory javascript book on the market.

Learning Javascript gives a very thorough walk-through of the Javascript language. It doesn't just teach you how to use the language features that are the most convenient or popular. Powerful and advanced concepts (such as recursion and closures) are also covered in order to expose you to the entire language so you won't be surprised when you see it used in the libraries you may end up using. The book is filled with numerous best practices born of experience and historical anecdotes that provide valuable perspective. I've often wondered what the difference was between the various object models offered by the browser and this book answers that question.

The book is not designed to be a reference manual as it is not filled with tables that contain the properties of every object or function you may run across. It does, however, provide you with more in-depth information than you would probably be able to get from a reference manual. For example, it details the three different ways you can construct a function and provides information on when and why you may want to use each.

Each chapter of the book covers one aspect of the language. There are numerous examples that illustrate the concept being discussed. I really enjoyed seeing the author's depth of insight as she explains the various topics. You can tell she has been doing web development for a long time from all of the historical information she provides. This historical information has very practical value as it explains many of the idiosyncrasies of the language. I've often heard that Javascript is a very powerful and under appreciated language. This book attempts to expose that power and make it usable by all users of the language. I think the author has done a good job at doing just that.

The advent of Ajax brings new approaches in developing JavaScript, increased complexity that requires more up to date techniques. As a result most of the existing entry level books on JavaScript are somewhat obsolete. This book brilliantly fills the gap. Shelley Powers is a seasoned author and deliver a gentle introduction to the language. The writing has a pleasant, personal style that makes the book more engaging than the average computer manual. The author is also a DHTML veteran, this allows her to bring an interesting historical perspective to the table. She is very aware of the reasons that ultimately lead DHTML to its failure and warn the readers about repeating the same old mistakes; definitely a valuable plus. Most likely the best starting point to date for JavaScript

This is not a book for beginners. Let me repeat: this is not a book for beginners. Although the Preface states, "Readers of this book should be familiar with web page technology, including CSS and HTML/XHTML ... [p]revious programming experience isn't required, though some sections may require extra review if you have no previous exposure to programming," there is a strong assumption from the start that the reader at least (a) has some experience with current programming concepts and practices, (b) has some experience with web page coding and practices, or (c) has a lot of time to learn (a) and (b) while working through the book. That said, however, this really is an excellent resource.

I fall into categories (a) and (b) above, but I'm rusty when it comes to javascript, and wanted something of a refresher. Instead, the book had the effect of dropping me into a working laboratory where everything, though nicely explained, remained confusing for quite a way into the book. But by the time the author got to the complex stuff, it all made sense and fell together pefectly, rather like finally understanding how all the tools in that laboratory make everything work so smoothly.

The book seems fast paced, and often left me wishing there were more detailed explanations of some of the examples. But the concepts and examples are interwoven, so just working through the book brought some understanding. The end of each chapter has review questions, with the answers at the end of the book, for those who find that helpful. But what impressed me was that the errata sheet is already available at O'Reilly. There are a few errata, and they'll be handy to know if you're trying the examples given in the book. Additional resources are also sprinkled throughout the book which all appear to still be working.

The author's practical bias comes through very strongly in the book. In the introduction, and throughout the book, there are frequent "best practices." Paramount to her philosophy of best practices is the admonition, "whatever JavaScript functionality you create, it must not come between your site and your site's visitors." Consequently, she often recommends solutions other than javascript to ensure accessibility by all types of browsers and users. There are also good discussions of the issues surrounding using javascript, especially the cross platform issues and what is on the horizon. Because of the browser compatibility issues, the author covers work-arounds each step of the way, with different options and a discussion of what works best and why.

If book titles are supposed to be descriptive of the content, I'm not so sure "Learning Javascript" is the best title for this book, although it fits well if one thinks of it as learning another programming language. You'll find this book a lot more helpful if your familiarity with web technology includes using CSS and XHTML, or if you have some experience with another programming language.

Based upon the title, you would think that it's a very basic beginners JavaScript book, but you would be wrong. When I first started reading the first 10 pages of chapter 1 I knew this would be a great edition to my ever growing library of JavaScript books. This book covers the very popular scripting language from a programming perspective, not like a "here's how to create a variable and use document.write to the page".

Just within the first chapter the author talks about development tools such as the Firefox JavaScript console and Firefox DOM Inspector, and accessibility. Not the normal first chapters I have read in other JavaScript books. The book has a couple introductory chapters on the syntax basics such as Data Types and Variables (Ch. 2), Operators and Statements (Ch. 3), Objects (Ch. 4), and Functions (Ch. 5).

Though these chapters really give you a lot of detail on the technical aspect of the language such as: equality with strings and objects, ternary operator, FIFO queue array techniques, anonymous functions, function closure and memory leaks. These more advanced topics I've never seen before in basic introduction chapters before. It was really interesting re-learning the basics with reviewing some new techniques and ideas.

Then the book focuses on events, event bubbling and event handlers (Ch. 6) and forms and JIT Validation (Ch. 7). The JiT validation is a technique that is has been done a long time with JavaScript (validation after every form field entry) and has been usually replaced with form submission validation but the author has some good techniques with adding event listeners that may change your mind about it.

The next chapter (Ch. 8), the author reviews using cookies, but also talks about alternative storage techniques like using Shared Object (SO) in Flash. This is only briefly mentioned but is something in never even heard about before so it was just interesting to think about another technique. Also, a practical application for SO storage was talked about with the Dojo.Storage component by Brad Neuberg that is a very popular in many Ajax toolkits. It kind of wets the appetites for more information, though. Additional topics of interest talked about in Chapter 8 were Cross-Site Scripting (XSS) and how to prevent similar type of JavaScript attacks that are gaining popularity like SQL Injection did a few years ago.

The meat and potatoes of the book are the chapters on DOM (Ch. 10) and Creating Custom Objects (Ch. 11), Ajax Basics (Ch 13), APIs (Ch.14). This is where you get practical knowledge on all the new things these "JavaScript libraries are doing. There's too much information to summarize these chapters but believe me they are worth the price of the book alone.

Unless you are a JavaScript expert, this is a book that you should buy to bring up your skills up to speed. A must buy!

It used to be that getting a book on JavaScript was one of those things you did when you wanted your web page to display a line or two of dynamic text or to edit a couple fields on your form. But it's much more these days with the popularity of Ajax. Learning JavaScript by Shelley Powers is a solid tutorial on the subject, especially for someone who already has some programming background.

Contents: Introduction and First Looks; JavaScript Data Types and Variables; Operators and Statements; The JavaScript Objects; Functions; Catching Events; Forms and JiT Validation; The Sandbox and Beyond - Cookies, Connectivity, and Piracy; The Basic Browser Objects; DOM - The Document Object Model; Creating Custom JavaScript Objects; Building Dynamic Web Pages - Adding Style to Your Script; Moving Outside the Page with Ajax; Good News - Juicy Libraries! Amazing Web Services! Fun APIs!; Appendix - Answers; Index

Pretty much everything you'd expect from a JavaScript tutorial can be found here... variables, statements, operators, and so on. The information is explained well, so the reader shouldn't have any problems following it. Powers has written the code to be fully XHTML compliant, so the scripting tag looks a bit different with the use of CDATA, but it's refreshing to see a subject like JavaScript keep up with standards. Building on top of the basic language structure, she goes into the browser and document object models, which is where the real power of JavaScript resides. When you start manipulating the actual document being displayed, your web sites can take on a whole new dimension.

If you already know JavaScript and you still end up reading this book, you'll find a few sidebars of interest. The sidebars point out some downloadable tools that can make a dramatic difference in your coding routine. Software like the MouseOver DOM Inspector, Alban's Script Editor, and Strong JS could quickly become one of those "how did I live without this?" tools. I'm also more motivated now to look at some JavaScript libraries available for download, like prototype and Dojo. The book does cover Ajax, but it's pretty high-level. I wouldn't depend on this book to be your complete Ajax tutorial, but it will get you started.

This is a good choice for branching out into the world of JavaScript if you haven't yet wandered down that path. By the time you finish the book, you'll be well-grounded in the fundamentals.

If you're new to JavaScript, and web programming in general, this book is a good place to start. I won't go into the details of what is covered in each chapter (another reviewer already did a good job of that), nor will I comment on the typos that annoyed another (you see so many these days; is it simply unavoidable when writing a hundreds-of-pages technical book?).
What I will say is that I like the way Ms. Powers oftentimes shares the "this is *why* it's done this way," as opposed to just spitting out how to do something. For me, folding a bit of history or context into an explanation always makes it easier to remember what is being discussed.
I thought she covered everything she needed to in a nice, orderly, and logical fashion.

I've been a programmer for 35 years. On the web side, I've used PERL, CGI, and PHP. So I could work around the problems (and spot the numerous errors). But it was still disappointing. On the one hand, the book advertises that it's appropriate for "someone new to development" and then helpfully explains why a conditional statement is called "conditional." On the other hand, the author jumps right in in Chapter 4 to discussing objects (and related terms such as properties, methods, encapsulation, and instantiation) without providing any definitions at all. Often, the code examples given to demonstrate something simple crucially (and unnecessarily) rely on other constructs that haven't been introduced. Needlessly, the author wraps code fragments within the same, redundant set of declarations over and over again. This distracts from finding the code, and takes away from space that could be much better used with additional and much-needed examples. Like I said, if you've been around the block a few times, you can piece it all together. But the obstacles it presents to learners are really avoidable and unnecessary. After reading 4 chapters, I'm back at Amazon looking for something better.

As an introduction to javascript, this book covers all the ground you'd hope it would. It introduces JS in the context of a standalone programming language with its various procedural constructs, before moving onto the Document Object Model and Browser Object Model, touches upon objects, and finds the time to explain Ajax. Finally, there's a whistlestop tour of the commonly used JS libraries like Dojo, Prototype and script.aculo.us. Shelley Powers also sprinkles her opinions on JS best practices throughout, with a bias towards favouring accessibility over whiz-bang flashiness. I would recommend being comfortable with XHTML and CSS as a prerequisite for this book - something like O'Reilly's own Head First XHTML and CSS would be very suitable.

If, like me, you know a few programming languages, but nothing about JS, and wanted a crash course so you could understand what all the fuss about the likes of Ajax or the Google Web Toolkit is, this is just what you need. So why am I only giving it three stars?

First, I thought some of the features weren't very well explained - the writing lacks clarity when describing important points. Compounding this, a few of the examples are poorly chosen. Some of my quibbles may seem picky, but the feel of the book is that it's pitched at an inexperienced programmer, and a lot of the time I only followed the discussion because I was already familiar with the material from other languages. Some particular points follow.

i) Accessing the length of various parts of a multidimensional array is illustrated with:

alert(threedPoints[2][2].length); // prints out 3
alert(threedPoints[2].length); // prints out 3
alert(threedPoints.legnth); // prints out 3

ignoring the error on the third line (more on that later), as can be seen from the comments, a three dimensional array has been created where every dimension is of length 3 - surely making them of unequal size would have been more illustrative.

ii) The example of the associative array manages to be even worse:

assocArray["one"] = "one";
assocArray["two"] = "two";

I struggle to think of an example that could be more misleading.

iii) While the author recognises the importance of regular expressions, and goes into reasonable detail, the material is not terribly well organised, and the examples become complicated too quickly.

iv) The section on chained constructors, and the use of call and apply is also unclear - disappointing, given I was most interested in the prototype style of object creation that JS uses.

v) The callback functions of Array are not well described. The function Filter, apparently, "ensures that elements are not added to any element unless they pass certain criteria". So, elements are not added to any element - huh? wha? Those familiar with the likes of Lisp, Python, and especially the iterators in Smalltalk and Ruby will be able to pick up what's going on, but newcomers may be baffled.

vi) The attempt to explain recursion is weak. Admittedly, most programming books do a bad job, but what's here is far too short to be useful. An illustrative quote is: "think of each iteration of the function call as pushing the string and numeric sum onto a stack, and when the numeric array has been traversed, the string and number have to be popped up through the stack to the top". I'm not saying this is wrong, but I do not believe that someone who's just been introduced to recursion would find this description helpful.

vii) Not all the programs have their output shown. This wouldn't be easy for some of the more complicated examples, but a lot of them are text-based.

Second, there are lots and lots of typos in the book. When even a JS noob such as myself spots them, you know there's something up. Fortunately, they're only minor, and they generally aren't sufficiently bad to mislead. As an example, when function literals are introduced, the rather vital keyword 'function' is missing, but the examples quickly clarify the matter. However, elsewhere, some of the code won't actually run as presented (as early as the second example, alas), and it does take the shine off the production. Either the technical reviewers were asleep, or the editors at O'Reilly ignored them. Someone ought to be embarrassed, at any rate.

None of these things are sufficiently show-stopping for someone who knows a little programming, so I would still recommend this book before wrestling with enormous tomes like David Flanagan's JavaScript - The Essential Guide, or a dedicated Ajax book. Complete beginners and the inexperienced, however, should look elsewhere, I'm afraid.

This book assumes you have experience with (X)HTML and CSS, as well as a general understanding of how web applications work. Programming experience isn't necessary, but the book covers all aspects of JavaScript, some of which are relatively sophisticated. Though the heavier pieces of this book are few, you will need to understand JavaScript enough to work with the newer Ajax libraries by the time you get to that part of the book. After you finish this book, "Javascript The Definitive Guide", may make more sense. Either book is OK for those new to Javascript, this book is just more of a gentle introduction, especially if you are not a programmer.

The book is broken into four sections:

Chapters 1 through 3 provide an introduction to the structure of a JavaScript application, including the simple data types supported in the language, as well as the basic statements and control structures. These establish a baseline of understanding of the language for the sections that follow.

Chapters 4 through 8 introduce the main JavaScript objects, including the all-important function, script access for web-page forms, event handling, scripting security, and working with cookies. Combined, these topics comprise the core of JavaScript, and with these chapters, you can validate form elements, set and retrieve cookies, capture and provide functionality for events, and even create JavaScript libraries. The functionality covered in these chapters has been basic to JavaScript for 10 years, and will remain so for at least another 10.

Chapters 9 through 11 delve into the more sophisticated aspects of web-page development. These chapters cover the Browser Object Model and the newer Document Object Model, and show how you can create your own custom objects. Understanding these models is essential if you wish to create new windows, or individually access, modify, or even dynamically create any page element. In addition, with custom objects, you can then move beyond the capabilities that are prebuilt into either language or browser.

Chapters 12 through 14 get into the advanced uses of JavaScript, including DHTML, Ajax, and some of the many wonderful new libraries that support both.

Chapter 1, Introduction and First Looks
Introduces JavaScript and provides a quick first look at a small web-page application. This chapter also covers some issues associated with the use of JavaScript, including the many tools that are available, as well as issues of security and accessibility.

Chapter 2, JavaScript Data Types and Variables
Provides an overview of the basic data types in JavaScript, as well as an overview of language variables, identifiers, and the structure of a JavaScript statement.

Chapter 3, Operators and Statements
Covers the basic statements of JavaScript, including assignment, conditional, and control statements, as well as the operators necessary for all three.

Chapter 4, The JavaScript Objects
Introduces the first of the built-in JavaScript objects, including Number, String, Boolean, Date, and Math. The chapter also introduces the RegExp object, which provides the facilities to do regular-expression pattern matching. Regular expressions are essential when checking form fields.

Chapter 5, Functions
Focuses on one other JavaScript built-in object, the function. The function is key to creating custom objects, as well as packaging blocks of JavaScript into pieces that can be used, again and again, in many different JavaScript applications. This JavaScript function is relatively simple, but certain aspects can be complex. These include recursion and closure, both of which are introduced in this chapter and detailed in Chapter 11.

Chapter 6, Catching Events
Focuses on event handling, including both the original form of event handling which is still commonly used in many applications, as well as the newer DOM-based event handling.

Chapter 7, Forms and JiT Validation
Introduces using JavaScript with forms and form fields, including how to access each field type--such as text input fields and drop-down lists--and validate the data once retrieved. Form validation before the form is submitted to the web server helps prevent an unnecessary round trip to the server, and thus saves both time and resource use.

Chapter 8, The Sandbox and Beyond: Cookies, Connectivity, and Piracy
Covers script-based cookies, which store small pieces of data on the client's machine. With cookies, you can store usernames, passwords, and other information so that users don't have to keep reentering data. In addition, since discussion of cookies inevitably leads to discussions of security, the section also covers some security issues associated with JavaScript.

Chapter 9, The Basic Browser Objects
Begins to look at object models accessible from JavaScript, starting with the Browser Object Model--a hierarchy of objects including the window, document, forms, history, location, and so on. Through the BOM, JavaScript can open windows; access page elements such as forms, links, and images; and even do some basic dynamic effects.

Chapter 10, DOM: The Document Object Model
Focuses on the Document Object Model, a straightforward, but not trivial, object model that provides access to all document elements and attributes. You'll see documents that are based in XML (such as XHTML) as well as HTML. Though the model is comprehensive and its coverage is fairly straightforward, there could be some challenging moments in the chapter for new programmers.

Chapter 11, Creating Custom JavaScript Objects
Demonstrates how to create custom objects in JavaScript and covers the entire prototype structure that enables such structures in the language. Some programming language concepts are discussed, such as inheritance and encapsulation, but you don't need experience with these concepts.

Chapter 12, Building Dynamic Web Pages: Adding Style to Your Script
Provides a general introduction to some of the more commonly used Dynamic HTML effects, including drag and drop, collapsing and expand page sections, visibility, and movement. Some understanding of CSS is required.

Chapter 13, Moving Outside the Page with Ajax
Introduces Ajax, which, despite all the excitement it has generated, is actually not a complicated use of JavaScript. In addition to covering the components of Ajax, the chapter also provides one example of an application that has promoted Ajax probably more than any other: Google Maps.

Chapter 14, Good News
Covers some of the more popular libraries you can download and use for free. This includes Prototype, Sabre's Rico, Dojo, MochiKit, Yahoo User Interface, and aculo. Between these libraries and the book, you'll have all you need to create incredible, and useful, web applications.