Product Description

Customer Reviews (74)

Terse Just to Show He Can
Barely helpful. Yes, he identifies the "good parts", but that's it; he doesn't finish the job with explanation. People who fashion themselves as elite programmers will give this book a good review. He repeats himself with cut and pasted text. There are lots of "railroad" diagrams of grammar like some bad Oracle documentation on SQL.

He's pretty impressed with how terse he can be. For example, he doesn't use the ++ operator because he says it's "too tight, too tricky, too cryptic". But then he uses sentences like the following to show just how terse and impressively obscure he can be: "The first thing in a statement cannot be a function expression because the official grammar assumes that a statement that starts with the word function is a function statement." This is followed by nothing.

Oooh...snap...you're so tight. The guy is a JavaScript wizard, but he can't explain or show how to use "the good parts".

Don't code against the grain, stick to the good parts.
According to the author, one of the biggest problems with JavaScript is that most people don't bother to learn the language before they start using it. Indeed, I was one of those people. My first impression of JavaScript was that it was flaky and fragile and very difficult to write robust production quality code in. It wasn't until I came back to JavaScript this year and read this book that I realized that most of my impressions were wrong and that if I coded with the grain, JavaScript is actually quite good and very powerful. This author does an excellent job of pointing out that though JavaScript shares its syntax with Java, C++ and C#, its actually a lot closer to lisp or scheme in the way you should go about programming with it. He carefully discusses what parts of the language to use liberally and what parts to avoid. As a professional developer with many years experience with C++ and C#, I found this book really helped me finally grok this language. Be thankful when you see how thin this book is. Each page is loaded with details and so it will take more work than you expect to wrap your head around all the great information.

Excellent, Succinct Resource
Doug is great at presenting complex Javascript concepts using few words. I recommend his work!

A Great Book on how to write Javascript
Javascript is so easy to misuse - specially for people like me that have a Java background. This book has a bit of "what can you do with Javascript" but it is the "how should you go about using javascript" parts that really help when starting to write bigger Javascript applications. The book isn't that long, but somehow it covers many important topics for its length.

Fantastic Book
I learned a lot from this book.This is not just about syntax but a lot of experienced tips! ... Read more

Product Description

Topics covered: The JavaScript language (version 1.0 through version 1.5) and its relatives, JScript and ECMAScript, as well as the W3C DOM standards they're often used to manipulate. Tutorial sections show how to program in JavaScript, while reference sections summarize syntax and options while providing copious code examples. ... Read more

Customer Reviews (295)

The best book on going below the surface of Javascript
The author knows what he is saying. His style is like Bjarne Stroustrup in "The C++ Programming Language".
Although JavaScript is loosely typed and flexible, if you don't know the intention of each of its object and "type", your code will be a mess, and debugging on messy JavaScript code is painful. David Flanagan guides you to avoid that mess.

A dream come true!
Explains JavaScript with almost perfect clarity. Great for someone who is painfully confused by JavaScript.

The author forgot what Javascript mainly is for
Hi,

The big problem for this book is that the author plays Javascript for Javascript. I know that most readers come here for the useful stuff for Web development, but I have to work hard to dig them out from vast useless language feature and examples. For example, I want to see from very beginning how Javascript useful in my web site, but sorry, it comes at second half book. For example, I want to see how to use client site validation in my JSF page, but sorry, little if any. for exaple, I want to see how to handle multiple actions in my struts JSP page, but sorry, you have to think by your own. The author is so enjoyful by Javascript language itself and forgot what most readers comes here for.

Thanks

Fei Li

The name of the book really means it. THE Definitive guide!
If you want to deeply understand JavaScript beyond simple day-to-day client side scripting, this is THE BOOK. This book is not for beginner programmers. I would guess, an intermediate level of knowledge in a programming language, preferably C-based, would be essential to keep up with the book's goal.
Flanagan is pleasure to read. This is a slam dunk! And he did it again with The Ruby Programming Language. He deeply understands what he is explaining and does such a good job passing that information. I read this book cover to cover twice, certain chapters multiple times - especially chapters 8 and 9 that covers Functions, Classes, Constructors and Prototypes, and now use it mostly for reference. If you can follow this book and understand all the contents, you can call yourself an advanced JavaScript programmer.

Hope this isn't really THE definitive review
I am an experienced programmer, well versed in languages I have learned from O'Reilly books.I read this book cover to cover a couple of years ago.It certainly is thorough.

I have just spent six hours trying to hook in a simple javascript function to my php application.UGH!I swear some of the coding examples in the book are just plain wrong! I finally got the function to recognize a 'hello world' program both written in the file and in an external file.I had to go to the web for a simple tutorial to do this.I now have a five line program that just plain doesn't work!So I looked up 'debugging' in the 'DEFINITIVE' guide.It is clueless.So am I.I have never, ever had this much trouble picking up a new language from a book.

I have to give this book a rating of 1.

... Read more

Product Description

Customer Reviews (4)

Sharpen your shurikens!
This book has the great honor to make the understanding of some complex JS topic incredibly easy.
The writing style is concise but clear: comparing it to the excellent Crockford's "Good Parts" i found this equally concise but far more simple to follow.
Strongly recommended for intermediate programmers who never really understand some of the JS black magic and for the ninjas who need to sharpen their shurikens.

The most elegant JavaScript book I have ever read
This book is not for the newbie JavaScript programmer (for the complete beginner I suggest JavaScript: The Missing Manual). It assumes some deep knowledge about the language and one is well advised to have read Douglas Crockford's JavaScript: The Good Parts before venturing into this book. Having said that, this book is just simply amazing!. It is very obvious that the author knows his subject, knows how to write and knows what problems people actually have. This is no small feat, as most programming books usually fails in one or more of these areas.

The book covers numerous inheritance and code reuse techniques, including most of the GOF patterns, but does also suggest several novel ways to take advantage (and not hack around) JavaScripts prototypical nature. I especially liked the code "tours", where the author spends considerable time developing a solution step by step, demonstrating pitfalls and side effects while simultaneously anticipating questions the reader might have. These JavaScript vistas has added considerably to my knowledge of the language, and I expect I will comeback to them again in the future (this book can easily takea second and third reading).

In summary, a very elegant written book containing an incredibly amount of knowledge, at a great price. Quite possible the best book on JavaScript in existence - highly recommended.

Excellent book with a lot to learn from
Very interesting book, excellent structure, may be a bit academical - in a good way though.

Author often proposes several solutions to a problem, and advises you why certain solution should not be used due to a browser limitations (IE, mostly) and which one is optimal. For instance, he describes implementation of fully blown inheritance model, and then advises not to use it, which is kind of funny.

Sometimes bits of content feel misplaced - for instance author mentions .bind() function only at the end of Chapter 6, while it'd be really useful right next to the discussion of callbacks in Chapter 4.

Thanks all commenters for corrections.

Hit the sweet spot for me!
It's often difficult to find good intermediate to advanced technical books that help you get over the hump. This is most definitely one of those books, IMO, along with Javascript: The Good Parts by Crockford and High Performance JavaScript by Zakas.

If you're a beginner, even an ambitious beginner, such as an experienced programmer in another language, you don't want to start here. For beginners, I'd recommend Zakas (Javascript for Web Developers) as the most complete introduction to Javascript, the DOM and browser scripting; or Simply JavaScript from Sitepoint for a gentler introduction that emphasizes the separation of structured content (HTML), presentation (CSS) and behavior (scripting the DOM with Javascript).

OTOH, if you're more or less comfortable with core Javascript and the DOM but want to clarify and explore the many idiosyncracies and fine points of JS, this book really hits the sweet spot. The table of contents is available on Amazon or O'Reilly, so I won't recap it - but will avow that Stefanov both chooses his topics and covers and organizes his material very well. This is a precisely and well-written book, and the reader will infer that there must have be a lot of experience, previous history and discussions behind these 200+ pages. I've read the blogs of the majority of his technical reviewers and believe you're in good hands here. I'm really lovin' this book. The only caveat - don't expect a lot on browser scripting. However, I'd be surprised if the somewhat experienced, but non-ninja, Javascript programmer did not significantly take his/her knowledge to a higher level after reading JavaScript Patterns. ... Read more

Product Description
Want to create websites that deliver the fast response times, dynamic user interfaces, and special effects that today's users expect?

Then this is the book for you! Whether you're just starting out in JavaScript or whether you're ready to move into DOM scripting, it gives you the skills you need. Here's how:

#1: It's 2 books in 1: A JavaScript book and a DOM scripting book
Most books cover JavaScript or DOM scripting. But to create user-responsive sites, you need to know both.

So the first half of this book is a course in JavaScript essentials. Then, the second half is a course in DOM scripting that gives you a clear understanding of how DOM scripting works, how JavaScript underlies it, and how to use it to build applications that run slide shows, use drop-down menus, rotate headlines, sort tables, provide animation, and more!

That means you can gain basic to expert skills in a single book.

#2: It provides a fast start
Section 1 is a crash course in JavaScript. In fact, by the end of chapter 3, you'll know how to code, test, and debug applications that include elementary DOM scripting. Then, the rest of the book builds on those skills to cover all the JavaScript and DOM scripting essentials.

#3: It shows you how to create and use event-handling libraries for browser compatibility
One of the headaches of web programming is ensuring that the code will work with all the popular browsers.

So this book shows you how to create your own event-handling libraries of browser-compatible code, so you can draw on it as needed. It shows you how to take advantage of free, third-party libraries like jQuery and Dojo. And it helps you to appreciate, and profit from, the extensive libraries of tested code that are included in the downloadable applications for the book.

#4: It shows 20 complete applications that can be used as models for new apps
The key to mastering client-side web development is to have plenty of applications that show how the features interact and what problems might occur in building a website.

So this book gives you complete code for 20 professional applications. These run the gamut from business applications, like object-oriented forms validation, to entertainment apps, like a rotating, 3-dimensional carousel of images that the user can control with the mouse or keystrokes.

You can download these for free from the Murach website. Experiment with them on your own, then use them as time-saving models for new applications.

#5: The paired-pages format lets developers set their own pace
Murach books have a distinctive format. Each two-page spread presents a single topic: the lefthand page explains the topic, while the righthand page shows the critical details, using syntax, code, screen shots, and how-to notes.

Both beginning and experienced developers tell us that this format makes it easy to focus on the information they need, whether they're using the book for training or reference. Again, you can try this out for yourself by downloading chapters 2 and 3 for free from the Murach website.

So don't wait to become an expert web developer. Get your copy of Murach's JavaScript and DOM Scripting today! ... Read more

Customer Reviews (25)

Excellent coverage of JavaScript
What a timely find. I was working on several web projects that required JavaScripting, which I had done before but not to the level that was required on these new projects.

As with all the Murach books I have owned, this was an excellent reference and guided me through these projects, including several using jQuery - which is covered.

I would recommend this book for both the new JavaScript programmer and a veteran that needs a good desk reference.

Too advanced for absolute beginners
It appears as you read through the chapters that the text explains in simple language complex javascript principles.The concept is great: for each set of principles it's explained on the left page and demonstrated with real world (or real "web") examples on the left page.And the fact that the book uses actual examples of everyday javascript applications is outstanding.

Oh well.I I had I hopes for this book.When you get to the exercises to apply your knowledge, it falls completely apart and you realize that perhaps you didn't get the background you needed to do the exercises. I've spent DAYS on these exercises, and only by posting the exercise questions on Javascript forums did I get the answer.

Only because I have some XHTML and CSS background do I recognize the potential this book has --- if you have programming experience, this will be a great book and reference source.If you don't, you will be extremely frustrated.I plan on keeping this book, but it didn't serve the purpose I purchased it for.

Not for the beginner
There is plenty of information to be learned in this book. Consider yourself warned, if you are a beginner with JavaScript and DOM Scripting, it will take some serious hours to finish the tasks that accompany each chapter. Unless you are serious about learning this, you will soon move on to something else and your copy of this book will find a spot on your shelf within a couple of short weeks.

The major problem that I have with this book is that I do not have the answers to the questions. Especially for the beginner, if you cannot finish the problems it is nice to be able to reference the answers so you can see how it is done correctly.

I am finishing the problems but it is taking me a considerable amount of time to do so. Not having the answers really has me stumped. Considering that in order to get the scripts necessary to do the probs you must download them from Murach's website anyway, wouldn't it make sense to include the correct way to implement the answers?

Anyway, that is the reason that I only gave it four stars and not five.

The book is exactly what i was looking for!
"Murach's JavaScript and DOM Scripting" is an excellent book, exactly what I was looking for.

It has well organized material, summary after each chapter, contains code of book applications and exercises created specifically for each chapter. The book is engaging and makes JavaScript easy to learn.

If you want to learn JavaScript or master your skills in it, "Murach's JavaScript and DOM Scripting" should be #1 in your "to buy" list.

Perfect Javascript + JQuery book
This is one of the best technical books I have ever read. It is laid out in a great way, and consequently is very easy to stick with and get through. It is perfect for someone who has a strong programming background, but needs to brush up on web/javascript programming. It has crash courses in css and xhtml. It goes into making web applications that will be cross browser compatible. HIGHLY recommend. ... Read more

Product Description

Customer Reviews (13)

Great asset for all Web developers!
The growth in popularity of JavaScript and many of the available frameworks that make easier the lives of Web developers, have encouraged many developers to use more and more JavaScript code in their pages.

Despite the recent advances in the latest releases of the most common browsers, the intensive use of JavaScript in Web pages may lead to slowdowns that may hurt significantly the usability of Web sites.

Therefore, it is very important that Web developers learn what affects the performance of JavaScript and what you can to improve your JavaScript code to make Web pages as smooth as possible. That is precisely the topic that the High Performance JavaScript book focus.

Let me give an overview of what is covered in each chapter. The first chapter covers the position in the Web pages where JavaScript code should be placed to minimize the delays it may cause to the page loading.

The second chapter talks about the different types of variable scopes and how it affects the execution of the code that accesses variables.

The third chapter discusses the speed of the different ways to access and manipulate the elements of a page using DOM. It also discusses how page element manipulation affects the speed of browsers doing the layout and rendering of the page.

The fourth chapter focus on the implementation of algorithms, the performance of loops, conditional logic and the implementation of recursive tasks.

The fifth chapter talks about string manipulation and in particular using optimized regular expressions to speedup text manipulation.

The sixth chapter focus on building responsive user interfaces. It talks about using timers to schedule regular tasks, as well how to use Web workers to run lengthy tasks in the background.

The seventh chapter discusses about AJAX requests, the performance of using different formats to exchange data with servers and taking advantage of caching to achieve performance gains.

The eighth chapter proposes several JavaScript programming practices that result in more efficient code. For instance it explains that you can use functions as callbacks instead of code strings that need to be evaluated, as well using object or array literal values instead of initalizing their members one by one.

The nineth chapter switches to a slightly different topic that may influence the performance of your JavaScript code, which is the way you build and deploy your projects. It goes through several techniques like minification of JavaScript code, HTTP compression and caching of JavaScript and other types of static files.

Finally, the last chapter talks about several tools and frameworks that may help you to produce better JavaScript code like performance profilers and other tools and extensions available for the different browsers that may help you diagnose and fix your code.

In conclusion, you should always keep in mind the performance of your Web sites definitely influences in the success they can have. The performance of the JavaScript code you use in your pages is certainly one of the factors that affects the performance of your sites.

This is a terrific book for those that have conscience of the importance of writing high performance JavaScript code and want to know all they can do to make your code better.

This is not a very large book, only about 200 pages. However the concentration of valuable information and tips makes it a great asset for all Web developers to have it permanently present in their desks.

Originally reviewed at: http://www.jsclasses.org/reviews/id/059680279X.html

Write High performance JavaScript
In short words this book is a must read, it contains tons of information on JavaScript performance in the browser context, and i think it's a good companion to O'Reilly: High performance web sites, and O'Reilly: even faster web sites, it begins where this books end and contain some information -i afraid to say chapters- from this books and sometimes refer to them but it's not a beginner's book it assumes that you're at least JavaScript intermediate. Chapter 1 is about loading JavaScript files in parallel with other resources of the page, it repeats the same techniques in O'Reilly even faster websites, chapter 2 is about data access and identifier resolution performance ,managing scopes, dynamic scopes, scope chain augmentation and closure memory. this chapter is totally new and will deepen your understanding about how JavaScript scopes work. Chapter 3 written by Stoyan Stefanov the author of O'Reilly: JavaScript Patterbs, is about DOM scripting which is very expensive, present handy techniques for effectively accessing and modifying DOM elements, Modifying the styles of DOM elements and causing less repaints and reflows. Chapter 4 is about optimizing algorithms and flow control. Chapter 5 is about Regular expression and Strings written by Steven Levithan the author of O'Reilly: Regular expressions cook book, this topic is a new world to me, information and techniques i never find in any book, it discusses how Regular engines work and how to use this knowledge to write faster regular expressions, understanding backtracking, runaway backtracking, strings manipulation like trimming and concatenations. Chapter 6 is about Responsive interfaces, and how to solve the issues inherited from the fact that JavaScript execution and User interface updates share the same process. some techniques like using timers, splitting up tasks, and using web workers to execute code outside of the UI thread. Chapter 7 is about Ajax written by Ross Harmes, the best ways to achieve fast client server communications in JavaScript, and how different data formats can affect Ajax performance and why XHR isn't always the best choice. Chapter 8 is a collection of a best practices unique to JavaScript language. Chapter 9 written by Julien Lecomte is about Deploying JavaScript for building a system to automatically minify files and using HTTP compression to deliver them to the browser. chapter 10 written by Matt Sweeney is about browser tools for Profiling and Analyzing JavaScript performance like firebug, chrome developer tools, dynatrace, fiddler, page speed, Yslow, Safari web inspector, IE dveloper tools. overall the book is very good and i recommend it to any front-end engineer.

Will appeal to any Java collection
Collections catering to web developers will find solid detail and advice in Nicholas C. Zakas' HIGH PERFORMANCE JAVASCRIPT, a survey of the basics of identifying problem code and improving scripts by learning how Javascript stores and accesses data. It comes from a Yahoo engineer who works with five other JavaScript experts to help Javascript run efficiently and quickly, and will appeal to any Java collection.

How fast should I try to be?
As others have already pointed out, the book contains a lot of sound advice that may not be ground-breaking for advanced programmers, but is useful for just about everybody.

Overall, the most useful aspect of the book is that it quantifies all of the optimizations that it proposes. I don't feel like designing test-cases to profile every single loop that I write. I also want to avoid premature optimization, because we know how bad that can be. Once you have assimilated Zakas' book, a lot of these little, day-to-day decisions will just come naturally: what kind of loop to use where, whether you should use a timer for some lengthy calculation, etc.

Execution speed is going to be a major consideration as javascript applications become more and more complex. This book definitely helps you think in the right terms.

Great reference and really good tips
This book is a great resource and reference.It is probably not something you will read from front to back but more reference the individual sections when needed.What I did was somewhat scan the entire book first and then revisited each chapter for a clearer picture.What I found was an amazing amount of tips and tricks to have high performing JavaScript in your code.Many may think with frameworks like Dojo you don't need this stuff but that is not the case.You will need to write your own code at one point - unless you only reference Dojo declaratively - and even so, you could always check the Dojo code to see if it is using the techniques suggested in this book!What I really like is how the book explains the current browser landscape and shows performance numbers between the different browsers in most cases.This sort of time stamps the book but it does not invalidate the many examples of making your script perform well.From simple string concatenation to regular expressions, the book has a wide range of tips to help your applications.I recommend this book to anyone writing web applications that use JavaScript for any platform or browser.This could easily enable developer leads to create a checklist of code review items for JavaScript. ... Read more

Product Description

Customer Reviews (6)

Excellent - even for Javascript beginners
Some reviewers felt it wasn't appropriate for beginners.I think the book is targeted for people who have some programming experience, but you don't need ANY Javascript background to find this book immensely helpful.A basic understanding of HTML I think is a must.Beyond that, you could learn Javascript with very little understanding of programming.
Shelley meticulously steps through the language and applications.Though occasionally using something discussed later in the book, she tells you so and where she will discuss it further; I didn't find those few references to be a problem.
Shelley provides real examples every step of the way.Whenever I think she may have made a mistake (and I take pen in hand to tell her so), I find I just didn't read carefully.
Shelley nicely handles the cross-browser issues as well though AFTER reading this book, you may want to think about JQuery as a next step.

Not for beginners
I am trudging through this book right now, and as a beginner who has no prior experience with JavaScript, I can tell you that this book isn't for the beginner.I've gone through a few examples and typed in the code as written and found that a few of the examples don't even work.I'm sure that it was written using some sort of word processing software, so what made it so hard to copy and paste the JavaScript code into a file to check to see if the code actually works?Also, I don't understand why the examples are so complex.After reading and rereading the script examples, I can usually figure it out, but having to do that is why I say that this book is not for the beginner.

The good part about this book, is that I am actually learning the material.The "test" questions at the end of the chapter range from simple to intermediate, and I can answer all of them correctly.I just wish it was a bit easier to read for us beginners.

Not for Beginners!
I have to concur that while this book is marketed as a book for newcomers to javascript, it is too full of unexplained terminology for the beginner. I am very familiar with HTML and CSS, and the introduction to this book claims that should have been good enough for a starting point, but here I am scratching my head about every third sentence and having to run to the web for clarification.

Other "beginning" O'Reilly books I have used relied on a tutorial model that starts with a "hello world" example and builds upon it to introduce more complicated concepts. Powers' book does indeed start with a "hello world" example, but does not build upon it. Instead, each chapter focuses on a particular facet and provides isolated examples that are not connected back to previous examples. It is arranged more like a basic reference text than a learning tool.

Perfect for Javascript Beginners
I always recommend this book to any HTML/CSS coder who is interested in learning Javascript. Intermediate or advanced users should get Professional JavaScript for Web Developers (Wrox Programmer to Programmer) instead.

The book really lays down the basics in a language so easy to grasp by anyone that can operate a computer. It also explains browser incompatibility very well. It's also rife with examples and best practices that help the reader to establish a solid foundation in their approach to using Javascript.

Everyone on my team had to read this book. I highly recommend it.

Solid, well-written book
At 300 pages this book isn't a quick read, but it's certainly smaller than the typical several-hundred page tech book. And that's important if you're trying to come up to speed on a new technology but still have a life to live. And, let's face it, learning new technologies is never "factored into the schedule", so a concise, clear, and well-written book is a good find.
Shelley does a good job covering the basics of the language and pointing out the ever-present bane of web developers: browser incompatibility. (Especially due to Internet Explorer, which has probably elicited more swearing than any other product since Microsoft Word.)
The good thing is she doesn't leave you high and dry, rather she provides clear, reusable helper functions which you can use in your own code to deal with the differences. ... Read more

Product Description

This eagerly anticipated update to the breakout book on JavaScript offers you an in-depth look at the numerous advances to the techniques and technology of the JavaScript language. You'll see why JavaScript's popularity continues to grow while you delve through topics such as debugging tools in Microsoft Visual Studio, FireBug, and Drosera; client-side data storage with cookies, DOM storage, and client-side databases; HTML 5, ECMAScript 3.1, the Selectors API; and design patterns including creational, structural, and behavorial patterns.

... Read more

Customer Reviews (51)

Complete Coverage - review refers to 2nd edition of this book.
For the most part this is an excellent book, the simplicity and clarity of the examples given is mostly excellent, and the coverage feels complete. This book is definitely for experienced JavaScript programmers, and probably other programmers from a similar syntactical based language that will be able to grasp the concepts quickly. Although it does begin with the basics, more as an overview/reminder, it doesn't continue along those lines as you move through the book, for example when covering regular expressions it doesn't tell you why regular expression literals begin and end with a forward slash as you should already know that, equally it doesn't waste time explaining the parts that make up a regular expression, such as repetition characters, position characters etc, as you should already know that too, instead it heads straight into advanced stuff, and this is the case on most topics. The terminology used throughout is definitely aimed at experienced programmers that will instantly understand the commentary; beginners will be baffled as programming terms aren't explained, unless it is specific to JavaScript.

Constructor, prototype, inheritance and many other patterns are discussed with great clarity. Equally the DOM and BOM are very well covered with the many differences amongst the browsers explained with cross browser solutions provided. Events are also given excellent coverage. The theory behind each aspect of JavaScript is often provided, I've always felt such theory is absolutely necessary in order to really get to grips with a language, and this sort of stuff is lacking in many other books, but not here thankfully. You'll walk away not only knowing how to do something and why you should do it that way, but also how it works under the hood.

There are issues (as opposed to downsides), one is that some aspects of the book, especially early on, feel more like you're reading a reference book rather than a tutorial and it does make reading those sections a little difficult from a concentration/interest standpoint due to the dry nature of reference type material. Having said that though it's obvious that completeness was the aim of this book as there is just so much stuff in here, much of it you'll likely never encounter in your working day, although it does leave one feeling somewhat overwhelmed at times. Another potential issue, to those that have no OO programming experience, is that comparisons with JavaScript and OO type features of other languages are made throughout, and again the terminology is applied without explanations, so if you have no OO experience or knowledge you may find parts of the book difficult to understand, clearly the author was trying to anticipate the questions of experienced OO programmers moving over to JavaScript. I call these issues rather than downsides as this is a professional book, in the right target market these issues shouldn't really be a problem.

The area which needs improvement is real-world application of advanced concepts. It's one thing understanding patterns and advanced techniques but knowing when to apply them in a meaningful context is frequently, but not always, lacking. In addition the author will teach a particular concept and then wrap it up in his own utility classes and then throughout the book he'll simply use his utility classes when he needs that particular feature, now this is no doubt the way to do things but whilst I'm learning I would prefer he'd reuse the actual features directly in order to help cement concepts in my mind that I'd previously covered as I go through the book, unfortunately the use of utility classes hides away the concepts you've previously learnt so you have to go back and review. In my view it would have been better if he left his utility classes to the best practices chapter towards the end of the book. On the plus side the author does support the book on the p2p forums and he was extremely helpful and quick to respond when I had questions.

One final note about this book is that it is slightly dated now, for example ECMAScript 4 is referred to in this book as the next standard but this has actually been abandoned for ECMAScript 5, and under EC5 some features have been deprecated in strict mode, such as arguments.callee amongst others, but don't let that put you off as EC5 lacks browser support. For me this book really hits the mark, especially with advanced JavaScript techniques, although I'm going to have to get in lots of practice before I forget it all!

Good one for those who want to learn Javascript itself
I've just finished to read this.I'll recommend it for those who want to learn about Javascript itself.But if you just want to learn recent trends of Javascript,this is not for you. Because this book is too old (published in 2005)to learn about things such as jQuery.

One of the best books about javascript.
Probably the most complete and updated book that you may find about Javascript.

The author made a great job writting about some of the most important topics on javascript development and highlighting the difference among browsers.

Most of the topics are already covered in other javascript books I have read before, but not in the way Nicholas does, he usually goes deeper on every topic.

If you have some knowledge on javascript and want to reach another level, this is the book for you. If you consider yourself a guru, you may enjoy it as well, but definitely, not for newbies.

should be sub-titled "JavaScript: The Good Parts (the long version)"
While I was reading this, I liked to imagine that I was at university and that Douglas Crockford was the insanely popular genius professor that showed up late for lectures, and then either spoke too fast or else mumbled a lot, and then locked himself in his office refusing to answer the door during office hours while he worked on his Next Big Thing that would make everyone oooh and aaah and validate his brilliance.Meanwhile, in that same imaginary university, Nicholas Zakas was the graduate student that served as the TA to that class--and he happened to be equally brilliant and super-accessible and willing to take the time out to explain it all in a way that was thorough and comprehensible.

So that being said, if you consider yourself or would like to consider yourself a professional front-end engineer for web applications (or in any way want to become a JavaScript expert), I cannot recommend this book enough.On the one hand, you have Crockford's JavaScript: The Good Parts--which does a great job of eviscerating JavaScript while at the same time extracting its (well...) its Good Parts--but it's like someone ran the text through a minification utility and made it tokenized and super-dense and stripped out all the comments.And on the other hand, you have Zakas' Professional JavaScript for Web Developers which one might describe as The Good Parts (the long version).

What Zakas gives us--while assuming that you are already doing some professional JavaScript web development--is a good overview of JavaScript/ECMAScript, with special care given to make the text practical.This is not strictly an academic exercise; he is careful to make sure that each example applies to real world scenarios (i.e., web apps running in a browser) and that you are able to take away something useful and meaningful from the text's discussion.In other words, he provides a road map for how to make the most of JavaScript as a language (...since, as a front-end engineer on the web, you're stuck with it.) and how to make it work in all the convoluted, counter-intuitive situations that you are basically guaranteed to encounter (Even if you don't expect to ever work with XML.Even if you do think that the JavaScript 2 and ECMAScript 4 stuff is a little too future-forward/in-the-weeds type stuff.).

In a nutshell, if you are doing professional web development on the front end, this book needs to be on your desk.I can't wait to check out his next book...

Very neat book for those who get confused by Javascript

This is the only book you will need to master javascript if you know some programming.

This one will take care of all the beginner-intermediate-advanced javascript programmer needs if you are not completely new to the concept of OOP.

Javascript used to scare me till now as I had not understood it well due to lack of well written books (complete references make me even more confused so I am not counting them here).

I tried learning javascript by looking at other peoples' code at my work place and on the net but the spaghetti nature of most of them scared me away.

In short the best book around.

Sachin ... Read more

Product Description

Customer Reviews (48)

The best, the best, the best!!!!!!!!!!!!
Another wonderful book in the series HEAD FIRST.
If you know HTML buy this book now.
You will have fun with interesting examples and learn JavaScript from scratch.
This book is for you that is absolute beginner in programming!!!!!!!
THERE IS NOT A REFERENCE BOOK, BUT A LEARNING EXPERIENCE!!!!!!!!!!!

A user friendly introduction hindered by a lack of interactivity
Let me begin by saying that J. Mitchell's review couldn't be more dead on. I too have been extremely pleased with O'Reilly's other Head First titles (especially their near perfect introduction to HTML and CSS). As such, I was really excited to sit down with HF Javascript. Unfortunately, I quickly found that the user interactivity that characterizes other Head First titles was sorely lacking. Elisabeth and Eric Freeman's HF HTML with CSS & XHTML, for example, provided an immersive experience in which every exercise greatly enriched the learning process--while working through the exercises I was actually writing HTML/CSS, and felt as if I was actively discovering the ins and outs of strict XHTML. After a week working through that book, I opened a couple of files and got right to work on some preliminary site designs--I honestly don't believe a semester long university course would have prepared me better.

Sadly, the same cannot be said for HF Javascript. While the book initially appears to adhere to the tried and true Head First program, it fails in the most fundamental category of instruction: hands on participation. While the book provides the reader with a good deal of worthwhile coding examples (via files downloadable from the HF website), these files are already complete, little to no user input required. I often just found myself looking at wholly functional .html files wondering why I was completing most of the exercises by pen inside my book instead of by script on my computer. While the explanatory sections really expanded my understanding of Javascript function, the rest of the book did little to enrich my understanding of how to actually incorporate the language into my own pages. After two somewhat frustrating chapters, I found myself spending more and more time at free tutorial sites like w3schools.com and echoecho.com increasingly relying upon those website's examples and exercises. What has so impressed me about other HF titles in the past are the numerous "light bulb" moments contained in every chapter, moments in which one gets the sense that one isn't simply following along, but rather thoroughly grasping a concept to the point of being able to easily employ it outside of the book's exercises.

All that said, Michael Morrison's entry in the HF series is by no means worthless. If you're looking for a general explanation of Javascript, I could suggest no more concise and clear introduction. Likewise, the downloadable files and in-text examples will provide a good base from which to launch further inquiry on the web (there are a lot of great free Javascript tutorials out there). In fact, with some minor revisions to the exercise sections (i.e. more actual coding, less pen and paper matching/fill in the blank), this book could be incredibly useful--here's hoping for a second edition.

javascript for non-programmers?
Like all the head first books, this one is very readable.But if you have any previous experience programming anything, you will likely find much of the information too trivial (example: 5 pages to describe a "for" loop).
If you want to learn javascript and don't have any programming experience or you are really unsure of your skills, this book may be a good choice.

I always recommend Head First Books
I am learning to build websites on my own, and these books are the only ones that explain complex concepts in a visual format that is appealing to a graphic designer.

Awesome Resource for Visual Learners
My only complaint with this item was that it took over three weeks for USPS to ship it to me from three states away.But that's not the fault of the product or the seller.Other than that - this book is excellent for keeping the attention of those of us who don't respond well to "traditional" learning techniques.It is entertaining and by teaching the same concept in multiple ways, I've found I have a much higher retention rate when I finish a chapter than I have with any other book.I will definitely use this series of titles from here forward if ever I need to learn another coding language or application. ... Read more

Product Description
Once listed in the "nice to have" sections of job postings, these days the knowledge of JavaScript is a deciding factor when it comes to hiring web developers. And rightly so. Where in the past we used to have the occasional few lines of JavaScript embedded in a web page, now we have advanced libraries and extensible architectures, powering the "fat-client", AJAX-type rich internet applications.

JavaScript is the language of the browser, but it's also heavily employed in many other environments: server-side programming, desktop applications, application extensions and widgets. It's a pretty good deal: you learn one language and then code all kinds of different applications. While this book has one chapter specifically dedicated to the web browser environment including DOM, events, and AJAX tutorials, the rest is applicable to all the other environments too.

This book treats JavaScript as a serious object-oriented language, showing you how to build robust, maintainable, and powerful libraries and applications. Along the way, we cover many of the recent innovations such as AJAX, JSON, and interesting design and coding patterns. After reading this book, you'll be prepared to ace your JavaScript job interview and even impress with some bits that the interviewer maybe didn't know. You should read this book if you want to be able to take your JavaScript skills to a new level of sophistication.

What you will learn from this book?

* Learn to think in JavaScript, the language of the web browser
* The basics of object-oriented programming, and how they apply to JavaScript
* Set up and use your training environment (Firebug)
* Master data types, operators, and flow control statements
* Understand functions: usage patterns, variable scope, and built-in functions
* Closures demystified
* Create and use objects
* Understand and use prototypes
* Reuse code with common patterns for inheritance
* Understand and work with the BOM (Browser Object Model)
* The DOM (Document Object Model) - accessing, modifying, adding, and deleting nodes
* Build responsive web pages with AJAX
* JSON (JavaScript Object Notation)
* Listen and respond to browser events
* Apply design patterns to solve common problems
* Adopt coding patterns that unleash the unique power of the language
* Make your programs cleaner, faster, and compatible with other programs and libraries
* Achieve missing object-oriented features in JavaScript such as private properties and methods

Who is this book written for?

The book requires no prior knowledge of JavaScript and works from the ground up to give you a thorough grounding in this powerful language. If you do already know some JavaScript, you will find plenty of eye-openers as you discover just what the language can do.

This book takes a do-it-yourself approach when it comes to writing code, because the best way to really learn a programming language is by writing code. You are encouraged to type code into Firebug's console, see how it works and then tweak it and play around with it. There are practice questions at the end of each chapter to help review what you have learned. ... Read more

Customer Reviews (22)

Object-Oriented JavaScript: Create scalable, reusable high-quality JavaScript applications and librareis
Until I found this book, I hadn't seen any good book about JavaScript.I guess the reason was that most of JavaScript books are written for "page authours".But this book explains behind the scene in detail so that people who have backend programming (Java, C++ etc.) background can understand it.This book helped me a lot, and now I understand jQuery as well.

Greatest Programming Book I've Ever Read!
This is the first review I've ever written on Amazon.After reading this book and seeing how anyone could give it less than 4 stars, I felt compelled to write something.Before reading Object-Oriented JavaScript,never in my life have I read a programming book from cover to cover with such a clear understanding of everything that's going on.I finished the entire book and its examples in less than 5 days, and I absolutely HATE reading books, let alone books about programming.

The author gives amazingly clear and concise examples and explanations of the nuances of the JavaScript language that I've been waiting to understand for years.No page-long routines gone over line by line in the text following the routine, forcing you to flip back and forth to remember what the heck the autor is referring to.Almost every single example, including examples for some of the most confusing concepts to grasp about JavaScript, are gracefully done in ten lines or less almost 100% of the time.

The exercises are challenging but not impossible, and really help you understand the concepts you've just learned.It's extremely rewarding to see the light go off in your head while you crank out code that you wouldn't have been able to read yourself just a few days ago.

I always put off JavaScript and never truly understood why some people loved it so much until I started to realize that it's basically going to become the universal standard for web programming within the next 5 years or so, as more and more applications move from being primarily server driven to browser driven.The thought of having to learn JS scared the daylights out me, because I never really even remotely understood it before.It just seemed to be so different than anything else I was used to, and completely unstructured, without any kind of rules or laws governing what's going on. This book proves my thinking wrong, and it's literally the most important programming book I've ever had.

To anyone complaining that it comes short on its promise ofcreating "scalable, reusable high-quality JavaScript applications and libraries," you obviously misread the title.It's called "Object-Oriented Javascript" for a reason...because that's the whole goal of the book.The idea is to give you the tools to be able to create those "scalable, reusable high-quality JavaScript applications and libraries," not to create them for you.

This book is a "must-have" for any web developer interested in getting into the JS game.If you have a short attention span such as myself, and reading programming books is normally a chore or almost impossible, the concise examples and clear explanations make this book almost tailor-made for you.

This book is a flop
I bought this book along with JavaScript: The good parts by Douglas Crockford. Whereas the Crockford book is light, easy, compact and beautiful, this book is too long, too 'for dummies', too 'cookbook' and just too wrong in its approach to the central parts of JavaScript, namely functions, objects, prototype and inheritance. In touching those concepts in 4 homonymous chapters it demonstrates silly use cases through certainly improvable so-called 'patterns', explains things in a way only to backtrack and say something along the lines of 'but wait! we were wrong!', examples are repeated three, four and more times to show the same situation, calling the same function with different parameters, filling the page with purposeless drivel and white space; everything important about JavaScript is too convoluted to make any sense because if you don't understand a language you shouldn't write about it. If this was the only book I had about JS I would hate the language, for two reasons: first, qualitative, the exposition of central concepts is poor, unsophisticated and overly complicated. Second, quantitative, the book is exceedingly verbose, for example listing every method the basic objects have, and painfully going over each with too many examples. Of course, you have handy appendices where all of it will be repeated again, once more. This information can be looked up online with less cruft on it and the book would have 200 pages less, cost less, kill less trees and give me less of a headache. The remaining chapters (7 onwards), from page 205 till 330, 38% of the book, refer to DOM and BOM and are completely off-topic in a book with this title. In two words: Misleading and expendable. To summarise: If you only read this book you will code awful JavaScript and other (good) JavaScript coders will not love you. I hope you find a better book (hint: read my first sentences again)

Good book for beginners and novices - needs proofreading
Just like the title says, this is a good book about JavaScript.I like the cookbook style of books, but this style is not far behind with copious code examples and exercises at the end of each chapter.One of the most important things you can do is practice practice practice as you're learning a new programming language or technology.The only reason I give it 4 stars is because the book needs to be proofread.There are too many little mistakes here and there in the code examples, and those are unacceptable for a beginner who is trying to learn the language.

Great book for who want to learn OO Javascript
This is a great book for anyone who wants to start OO Javascript. It provides real examples that you can type in Firebug and see results immediately. For those who already have OO Javascript background, this book can serve as great reference.
However, it does not contain lots of advanced topics.
For those who would like to improve their code. I would recommend "JavaScript: The Good Parts" from Douglas Crockford.
Here is the list of JS books from beginner to advance.
1. Object-Oriented JavaScript: Create scalable, reusable high-quality JavaScript applications and libraries
2. JavaScript: The Good Parts
3. Pro JavaScript Design Patterns (Recipes: a Problem-Solution Ap)
... Read more

Product Description

Customer Reviews (38)

Useful beginner book
If you want to learn modern JavaScript development (i.e. JQuery) from scratch then this book is for you. It's written in a very friendly manner and takes you gently from JavaScript "HelloWord" to creating full dynamic web pages using AJAX. Some readers has complained that the author uses plugins to accomplish mundane tasks rather than shoving "the bare metal" - personally I consider this a plus, since I would rather download and use well tested plugin than roll my own.

The book does however have a target audience issue. The author seams split between trying to teach JavaScript to people who have never programmed before, while simultaneous trying to explain advanced web development to more experienced readers. So in the end I must conclude that this is a very good book for beginners, while more experienced web developers might want to read books like jQuery in Action or JavaScript: The Good Parts.

Perfect for Web Designers
I have just completed JavaScript: The Missing Manual. I am surprised at some of the negative reviews about this book. In my opinion, this is absolutely the best book for web designers who want to learn the basics JavaScript and also want to immediately take advantage of the most popular JavaScript library available.

I actually got interested in this book because of some of the negative reviews. I wanted to learn JavaScript quickly because I wanted to use jQuery on my web sites.

Before I bought this book, I read the introductory pages. In the About This Book section, the author says that the book will teach you the basics of JavaScript and programming, which it does. It will not teach you everything you need to know to build sophisticated, interactive Web pages. Instead the book shows you how to use jQuery and save a lot of time. So, after you learn JavaScript basics, you can start using the very cool jQuery plugins and add interactive functionality such as hiding or showing , creating cool lightbox galleries, insertinginteractive google maps on the contact pages, and a lot of other things.

"Think of it this way: You could build a house by cutting down and milling your own lumber, constructing your own windows, doors, and doorframes, manufacturing your own tile, and so on. That 'do-it-yourself' approach is common to a lot of JavaScript books. But who has that kind of time? This book's approach is more like building a house by taking advantage of already built pieces and putting them together using basic skills. The end result will be a beautiful and functional house built in a fraction of the time it would take you to learn every step of the process."

So the question is: How much time do you have to learn JavaScript? If you're a web designer who wants to learn the basics of JavaScript quickly and start using very impressive js scripts, then this book is definitely for you. If you have a couple of years and want to become a JavaScript programmer, then this book is a great starting point. It's a mistake to dismiss this book because the author spends time on jQuery. If you want to be a full-fledge JS programmer, then jQuery can be an enormous help. You can download the uncompressed development version of jQuery and have great examples of sophisticated code to study, code that works and is cross-browser compatible.

You also have to be ready to learn JavaScript. If you don't have strong CSS skills, then you should first learn CSS before tackling JavaScript since CSS selectors are used to select parts of a web page to apply JavaScript (CSS: The Missing Manual is a good way to master CSS.)

One final comment. The author takes great care in clearly explaining Javascript code. The examples all work perfectly. This is a well-written technical book.

Also introduces the jQuery JavaScript framework
This book not only introduces JavaScript (its prime focus), but it also introduces the popular open-source JavaScript framework, jQuery, which supports many free open-source plug-ins found on scripting archives. With jQuery plug-ins, you can code at higher levels through the use of reusable code. The jQuery framework also takes care of many incompatibilities across browsers (like for JavaScript event handling) so the user can focus on his own JavaScript applications.

Painfully informative.
Before you purchase and read this book (like I have) there is one important question you should ask your self: "How do I learn new things?".If it's by simply reading the complicated overview by an expert, than this book might be for you.

However if you're like me and you need to learn, in a hands on way, by performing and piecing the material together for yourself, then I would not recommend this book to you.

McFarland is incredibly knowledgable, but his approach was far too complicated for me to follow, without constantly having to reread every page.The tutorials included with the book were very good however they do tend you baby you a bit and leave you confused about what you have just made.Also they don't cover that much of the material presented.

All in all its not a horrible book if you happen to like his style and don't mind that it is more complicated than most beginners are prepared for.All I can say is that it wasn't for me. It was way more complicated than I found it to be just working with JS for myself and I'm at a loss for almost all of what I read in this book.

Jquery
It's funny, when I first came and read these reviews I had no idea what Jquery was. But I learned. I gave it three stars because the book does not follow what it says...Javascript. Rather, it follows Jquery, a great javascript library. Now you may say, "Hey, Jquery lets you do everything you need to but even quicker and more efficient". That is true, but guess what, HTML5 is coming around the corner and it relies on Javascript coding...REAL javascript coding, and guess what? I don't know enough javascript for it because I learned the 'calculator' way of doing things without learning how to write out the math beforehand...and in HTML5, there are no calculators allowed. ... Read more

Product Description
Essential Skills--Made Easy!

Create dynamic Web pages complete with special effects using today's leading Web development language. JavaScript: A Beginner's Guide, Third Edition gives you step-by-step coverage of the fundamentals, including variables, functions, operators, event handlers, objects, arrays, strings, forms, and frames. You'll also learn about more advanced techniques, including debugging and security. This hands-on guide explains how JavaScript works with XHTML Transitional and covers the new features available in JavaScript. Get started using JavaScript right away with help from this fast-paced tutorial.

Designed for Easy Learning:

• Key Skills & Concepts--Chapter-opening lists of specific skills covered in the chapter
• Ask the Expert--Q & A sections filled with bonus information and helpful tips
• Try This--Hands-on exercises that show you how to apply your skills
• Notes--Extra information related to the topic being covered
• Tips--Helpful reminders or alternate ways of doing things
• Self Tests--End-of-chapter reviews to test your knowledge
• Annotated syntax--Example code with commentary that describes the programming techniques being illustrated

Customer Reviews (13)

Good, but not for Kindle!
JavaScript, A Beginner's Guide, Third Edition
I bought the kindle version to be able to read the book while travelling.
The content is very good as a basic for beginners exactly what i was looking for.
Clear text, clear examples.
Just one (no minor, unfortunately) problem for the kindle user:
all the code examples (the key part for this kind of book) are in the form of an image and the image is totally unreadable on the kindle!
Too small and displayed in a very light gray color.
I had to read the most of it on my PC using Kindle for PC.
It's very frustating to buy a book for the kindle and not to be able to read it fully!
The kindle version of every book should be checked better by the editor staff!

Beginners Javascript
I bought the book also and read it from cover to cover.This is the best tutorial book I have ever read on a beginning programing language.If you dont know anything about javascript, you will have all the basics you need to go ahead and dive into the complex stuff.I cant wait to get another book from this publisher.

A Beginner's Guide to JavaScript
Well, I ordered this book for a college course called: Scripting for Web.I hope to learn how to use and effectively use JavaScript to enhance and create dynamic web pages.It may be similar to PHP but there are some differences.We did an exercise last class, and the instructor didn't know how make comment.I did not want to take a second chance with a teacher that doesn't know what he's doing.So I ordered the book to learn myself.

I'll update the review after I get a feel for this book and it's teaching methods.

This might have been a good beginner's JavaScript book...
... if they had bothered to proofread it! It is full of mistakes. Many sentences don't make any sense at all. It looks like they scanned the real book and threw it into a Kindle edition without checking if OCR jacked up the sentences. Some pages have 3 or 4 sentences with strange repeating text like: "...you should define the function that will be called before you define the function that will be called before you define the function that calls it..." (Locations 1,944-62). There are entire sections that have so many mistakes, I can't understand what the author is trying to say. Unbelievable!

This is probably the publisher's fault, and I feel sorry for Mr. Pollock. It seems like he might have written a pretty good book for JavaScript beginners. I wish I could read it!

JavaScript Beginners Guide, Real Easy, Maybe Too Easy
This was an all-in-all, good book. I have a pretty good technical background with my MS in computer science, but pretty new to Web technologies. Therefore, I was looking for a rather simplistic approach to JavaScript since I have NO background in that area. I always shy away from the "...For Dummies" books since I should at least be beyond that stage in technology, but this book is probably below the Dummies books. No programming background would be needed and not even much technical ability. Although I am biased, I have a hard time thinking how anybody would have trouble understanding this book or doing the exercises. A lot of the examples are overly simplistic and silly, but this could suit a non-programmer type well. As for me, ideally I would have liked a book that talked to programmer types more and was a little deeper. But my objectives were reached with this book: understand JavaScript code I run into, and be able to write little scripts to accomplish things I need to on my site. Before the book was finished I actually implemented some of what I learned to actually solve a problem on my site. That is pretty impressive. ... Read more

Product Description

As a web developer, you’ll already know that JavaScript is a powerful language, allowing you to add an impressive array of dynamic functionality to otherwise static web sites. But there is more power waiting to be unlocked—JavaScript is capable of full object–oriented capabilities, and by applying OOP principles, best practices, and design patterns to your code, you can make it more powerful, more efficient, and easier to work with alone or as part of a team.

With Pro JavaScript Design Patterns, you’ll start with the basics of object–oriented programming in JavaScript applicable to design patterns, including making JavaScript more expressive, inheritance, encapsulation, information hiding, and more. With that covered, you can kick–start your JavaScript development in the second part of the book, where you’ll find detail on how to implement and take advantage of several design patterns in JavaScript, including composites, decorators, façades, adapters, and many more.

Each chapter is packed with real–world examples of how the design patterns are best used and expert advice on writing better code, as well as what to watch out for. Along the way you’ll discover how to create your own libraries and APIs for even more efficient coding.

• Master the basics of object–oriented programming in JavaScript, as they apply to design patterns.
• Apply design patterns to your kick–start your JavaScript development.
• Work through several real–world examples.

What you’ll learn

• How to apply object–oriented programming techniques in JavaScript
• How to take advantage of inheritance, interfaces, and encapsulation and information hiding to kick–start your JavaScript development
• How to implement several design patterns in your JavaScript projects, including factory, façade, bridge, composite, adapter, decorator, flyweight, proxy, command, observer, and chain of responsibility
• How to make your code easier to manage in a team environment, as well as on your own
• How to create your own libraries and APIs

Who is this book for?

This book will be an invaluable learning tool for any experienced JavaScript developer.

About the Apress Pro Series

The Apress Pro series books are practical, professional tutorials to keep you on and moving up the professional ladder.

You have gotten the job, now you need to hone your skills in these tough competitive times. The Apress Pro series expands your skills and expertise in exactly the areas you need. Master the content of a Pro book, and you will always be able to get the job done in a professional development project. Written by experts in their field, Pro series books from Apress give you the hard–won solutions to problems you will face in your professional programming career.

Customer Reviews (21)

Improve JS skills
Excellent book for every Javascript developer who wants to improve his programming skills. It's framework independent so it's usable for all JS developers...

Better than online tutorials.
Great book on design patterns.
Part 1 was the most useful because I discovered new tricks for encapsulation, inheritances and other concepts that you pick up from reading plenty of code. Like did you know in JS 1.3+ that String.replace() can take a function as the second parameter.
However, part 2 of the book seems to be for design patterns for special conditions.
After finishing this book, I corrected a few major bugs that I had in my previous web apps. Thanks to Ross and Dustin. It's a must read for javascript programmers.

Great read
Must warn the reader that I'm not a great JS hacker and probably only a decent engineer in general . . However, having seen (and probably written) quite a bit of hokey and shoddy code to get the job done, I'm hoping I've learned enough to distinguish the good from the bad.

With that being said . . I'd highly recommend this book for all the developers looking to learn and develop a well-structured and organized approach to writing clean Javascript. The first six chapters are an excellent review of OOP principles and how to successfully implement them in Javascript. The rest of the book reads easy since the design patterns are explained well and then integrate different use-cases into each pattern's lesson. Each chapter also has a succinct summary detailing when and how to apply the covered design pattern. Overall, I really enjoyed the book and feel like it's improved my approach to Javascript and coding.

Good ideas, but needs another round of editing
There are some good ideas in this book, and it's worth a quick read, but it is desperate need of strict editing. Some of the concepts are implausible or even harmful, and many of the code examples contains typos that prevent them from being run as shown.

Not as good...
I quit reading this book.
Do not misunderstand me: the writing style is clear and the authors seem to know the topic.
By the way, after having read the "JS Good Parts" and started reading "Secrets of the JS Ninja", i can't help to find the chapters of this book kind of "overengineered".
JS has a beautiful prototypal nature, so why do force it to be like Java? I found some of the patterns useful, but definitively do not like the dependence on the interface pattern (give me open classes please!). Believe me: as Crock and Resig teach us, JS can be used according to its natural mood in a much effortless way. Said that this isn't a bad book, simply not as good... ... Read more

Product Description
JavaScript--the powerful, object-based scripting language that can be embedded directly into HTML pages--has earned its place in the web developer's toolkit, to the extent that it's now considered required knowledge for web developers.You can use JavaScript to create dynamic, interactive applications that run completely within a web browser.JavaScript is also the language of choice for developing Dynamic HTML content.The JavaScript Pocket Reference, 2nd Edition provides a complete overview of the core JavaScript language and client-side scripting environment, as well as quick-reference material on core and client-side objects, methods, and properties.The new edition has been revised to cover JavaScript 1.5, and is particularly useful for developers working with the latest standards-compliant web browsers, such as Internet Explorer 6, Netscape 7, and Mozilla.Ideal as an introduction for beginners and a quick reference for advanced developers, this pocket-sized book is easy to take anywhere and serves as the perfect companion volume to the bestselling JavaScript: The Definitive Guide, 4th Edition.Amazon.com Review
At 4.5 by 7 inches in size and only 89 pages long, the aptlynamed JavaScript Pocket Reference will really almost fit inyour pocket. Use this guide as a companion to turn to when you're indoubt about that function syntax or you're drawing a blank on theJavaScript object model.

The book concisely packs together thesyntax of the scripting language, including summaries of expressionand statement style. The real meat of the tiny title is analphabetical listing of JavaScript objects, along with theirassociated methods, properties, and events. One nice feature of thissection is the attention to the varying support between Microsoft andNetscape browser versions. However, this listing is useful only if youknow what object you want to work with. Missing from the reference isa solutions-based reference to let you refresh your memory about howto do a particular task, such as validate a form field or roll over agraphic when the user moves the mouse.

One drawback is the book'sillustration of the object model--done only in a small diagram. Thisis a bit of a shame since this is one of the key topics mostdevelopers need help with. If you're rather familiar with JavaScript,this pocket reference will be helpful. New coders, however, willlikely find it insufficient. --Stephen W. Plain ... Read more

Customer Reviews (21)

Great Pocket Reference
I read this JavaScript pocket reference twice through in review for an exam, which I passed thanks to this book. It's not the most gripping or exciting read (I was not expecting this. Hahaha.), but it presents a very comprehensive explanation of the JavaScript language and its usage. This book is not a one-stop-shop for learning JevaScript. You will still need to purchase another book that will walk you through the language in a more learning friendly manner. (For that, I would recommend A Beginner's Guide to JavaScript, 3rd Edition, by John Pollock.) This book is designed to be a quick reference for when you need to be reminded of how an object is used, what properties/methods exist for an object, what can be accomplished by an object's properties/methods, etc.

The first 52 pages explain the JavaScript language. It begins with the basics, such as syntax, variables, expressions, operators, statements, etc. Then, the book covers how JavaScript relates to and interacts with the DOM. The 54th page begins the alphabetical API reference, which extends to the end of the book on page 127. Now, this book does not contain an index. I can see this being an issue for some folks. Honestly, an index would be helpful for this book. For instance, what if you know a property or method, but can't remember what object contains said property or method? Normally, an index would point you in the right direction, but with this book, you either have to guess or go to another book or resource, such as Google. The lack of an index is not critical, but rather an inconvenience.

Overall, I am pleased with my purchase of this book and I'm glad I have it on my bookshelf for use when I need it. I would recommend it for any JavaScript developer to have at hand.

In the event you are interested, O'Reilly Media, Inc. has these pocket reference books available for sale in the iTunes Application Store as an application for your iPhone or iPod Touch. They are sold for only a few dollars. If you'd rather have an e-book version, that's the way to go. Of course, you can also purchase this book for the Amazon Kindle.

Lacks an index
The book is really good as a quick review of JavaScript and the topics are well-explained, but not having an index, if even a computer-generated one, is unforgivable! It is hard to find certain functions if you are not sure what object it belongs to.

O'Reilly JavaScript Pocket Reference
Very nice addidion to the reference book. I work at both home and at the office, and instead of carrying all of my reference books with me each day, I find the pocket references very usefull when I need information at the office. Not only this title, but other pocket reference books that I also own from O'Reilly. I would highly recommend this reference.JavaScript Pocket Reference

Well-written pocket reference
I've been learning JavaScript off and on, with some success, for three months.In doing so, I've skimmed about a half-dozen books and tried the following three, so far, "graded" below:

Learning JavaScript (Powers B-)
VQS JavaScript and Ajax (Negrino & Smith C+)
O'Reilly JavaScript Pocket Reference (Flanagan B)

It's hard to find good books on JavaScript and no one should expect a pocket reference to be an instructional book.Despite that, I found this reference guide to be surprisingly helpful at times as I searched for clear explanations of the underlying concepts in learning JavaScript.

Where's the rest?
I realize it's a pocket reference, but this is a brief guide to syntax and then the DOM for the rest of the book. It doesn't cover any of the API stuff like the Date class. It'd be nice to have more information at the price of needing slightly larger pockets. ... Read more

Product Description

Customer Reviews (5)

A well-constructed collection of JavaScript recipes, with forward-looking samples of ECMAScript 5 and HTML5
I have enjoyed other cookbooks in the O'Reilly library of computer texts, so when I saw JavaScript Cookbook by Shelley Powers in the catalog, I jumped at it. The description mentioned that the book would cover HTML5 and ECMAScript 5, so I really wanted to learn the new capabilities of both. I did get to learn a lot, but I wonder if these new features are too new.

Like other cookbooks in the O'Reilly library, this one is organized as a series of specific problems, with their solutions neatly presented and grouped into the major chapters. Each solution has a discussion to flesh out the details. The website has downloadable copies of the examples in the book, which I used to test out the various recipes. ECMAScript 5 is fairly new, and HTML5 is still under development, so I made sure I had the latest stable versions of the major browsers (Firefox, Google Chrome, Internet Explorer, Opera, and Safari) to see how they would cope. The HTML5 features are very sparsely supported as of yet, so those portions of the book should be considered more of a sampling of things to come rather than a definitive set of solutions.

They start out easily enough with recipes for handling JavaScript strings. However, the discussion of String objects and literals obviously implies that the reader is already somewhat familiar with Object terminology and functionality. That makes this book unsuitable for beginners.

While much of the book is applicable to today's browsers, there is a lot of coverage of the new capabilities made available in the new HTML5 specifications. Unfortunately, most browsers either do not support, or only partially support these features, so the information is only useful as a "taste of things to come".

As I step back and reflect on this book, I think that many topics are solutions that cannot be implemented because the typically available browsers don't support the new features yet. If a web page designer wants their site to be available to users now, they need to focus on the features that are well entrenched across the internet. Having so many solutions based on features and capabilities that are still being defined is only useful as academic exercises. I would have preferred that the JavaScript Cookbook be more useful for the state of the web right now. That is why I'm rating it only 3 out of 5.

A lot of javascript solutions
Javascript is similar enough to languages I know that I've just picked up enough of it along the way to get done whatever I needed to. I read this book in hope of getting solutions I could adapt for some of my web programming needs while learning more about what javascript could do now and in HTML5. I was not disappointed as the book met those expectations and then some.

As a cookbook, the book follows a Problem, Solution, Discussion format. The problems addressed are grounded in the real world and the solutions vary from very simple to rather complex. The discussion provides in depth information about the solution and sometimes includes alternatives. Of particular interest to me on the first reading were the chapters on event handling, form elements, and persistence. I was also pleased that the solutions addressed handling the current versions of the four major browsers.

Bottom line: After reading this book I have a better understanding of javascript and what I can do with it. I will be keeping it handy as a source for code snippets as well as a reference for future javascript coding.

Partial read review
I haven't gotten all of the way through this book yet, but I'm enjoying it so far. For someone who has coded in other languages, but with very limited experience in JavaScript, the book is extremely approachable. It is definitely not a "Getting started in programming" book, but for me it has proven very useful in refreshing & building out my knowledge. As always, the Cookbook style book is useful to hold on to for when that specific issue strikes.

I look forward to reading a bit further & then holding on to this title as I try my hand at more adventuresome exercises. If I find anything more to report as I work further through the book (positive or negative), I'll update here...

DISCLOSURE: I received a free review ebook from O'Reilly.

Good jump start to get familar with new APIs
In developing mid to large scale web applications nowadays, it's a common practice to leverage JavaScript frameworks such as Prototype, Scriptaculous and JQuery. As the author of JavaScript Cookbook points out, "in order to use a framework library like jQuery to its best ability, you need to understand what's happening under the hood." JavaScript Cookbook provides a good amount of information on the fundamental and new features of JavaScript. For example, the book covers ECMAScript 5 features (e.g., Array object methods "forEach", "map" and "filter") with concrete use scenarios in the format of classic "cookbook" receipts, accompanied with snippets of code in the context.

Going beyond these isolated "problems", the book also provides insights into what is needed in building real world web applications in terms of good practices and pragmatic idioms. For example, when showing you how to gracefully handle no JavaScript situations, the book provides a "historical" perspective on the existing solutions, how they have been evolved over the time and what establishes the current standard of good practice. The receipt starts with the simple

Time-Saving Store of Scripting Knowledge
§
One bit of advice if you are like me when you get a reference collection of this sort: I immediately flip through the table of contents or the index to get to whatever topic I am currently obsessing on.

In the case of this book, you may want to spend a few minutes in the oft-ignored preface. It contains some noteworthy information on the author's approach. Specifically:
"Many of the examples won't work with IE6. Before I even began the book I decided not to provide support for IE6--including any workaround code."

The author is a bit more forgiving in the case of IE7: "Where IE7 doesn't work, either I provide IE7-specific workarounds in comments in the example code you can download, or I make a note about nonsupport in the recipe--or both."

I work on teams developing browser-based applications for the real world, so IE6 is still absolutely relevant to me. In fact, the corporation for which I honestly sweat is itself "standardized" on IE6 for all employees. Even so, I still recommend this book because of the relevancy of the examples and its forward-looking approach.

The fact that the code download file is about 63 megs compressed should give an idea of how much is contained in this big store of scripting knowledge.
§ ... Read more

Product Description
If you know HTML, this guide will have you building interactive websites quickly. You'll learn how to create responsive, data-driven websites with PHP, MySQL, and JavaScript, regardless of whether you already know how to program. Discover how the powerful combination of PHP and MySQL provides an easy way to build modern websites complete with dynamic data and user interaction. You'll also learn how to add JavaScript to create rich Internet applications and websites.

Learning PHP, MySQL, and JavaScript explains each technology separately, shows you how to combine them, and introduces valuable web programming concepts, including objects, XHTML, cookies, and session management. You'll practice what you've learned with review questions in each chapter, and find a sample social networking platform built with the elements introduced in this book.

This book will help you:

• Understand PHP essentials and the basics of object-oriented programming
• Master MySQL, from database structure to complex queries
• Create web pages with PHP and MySQL by integrating forms and other HTML features
• Learn about JavaScript, from functions and event handling to accessing the Document Object Model
• Use libraries and packages, including the Smarty web template system, PEAR program repository, and the Yahoo! User Interface Library
  
• Make Ajax calls and turn your website into a highly dynamic environment
• Upload and manipulate files and images, validate user input, and secure your applications

Customer Reviews (29)

Why not Jquery, instead of YUI?
Seems like the perfect book for my college web programming course....
except Jquery is now used by 78% of the world (I saw this number on a
very recent review of web technologies.)So I wish the authors would
have use Jquery instead of YUI.Now my students will have to buy a
separate Jquery book.

If you're a beginner, stay away from this book
As a beginner, I was looking for a book to introduce me to PHP, MYSQL, and Javascript. The idea behind the book is great, but the execution is abysmal. Especially when the programs written in the book are filled with errors. Page 233 specifically. The errata page on the website has the author saying that the code on page 233 in the book won't work, but not exactly why. But of course, the code he supplies on the errata page doesn't work either. As a novice, how in the world am I supposed to debug the author's programs! He evidently didn't do it himself, either.


This is just disgraceful. Were the people who gave this book great reviews, already well-versed in PHP, to be able to catch the errors.
Did the people who gave this book great reviews actually do the examples? Were they paid by the O'Reilly to give the book good reviews.

Excellent Book --- Jam-Packed With Valuable Info
This is one of the best books I have ever read as far as how much information it contains and readability.Absolutely the best book for getting started in PHP, MySQL and JavaScript. I will be keeping this book and using it for reference for quite a while.Very highly recommended.

Okay, but...
I bought this based on the reviews, and it was okay, but not great. The first few chapters were very helpful, but I had problems getting the examples to work, even when I pulled them from the publisher site. This book has great potential, and I did learn a lot from it, but was disappointed the further I got into it.

Even the PHP Guru Recommends it
I've been teaching many people how to write PHP code at [...], and I have to say that this is one PHP book that is a great reference for learning PHP.

Although I didn't buy it through Amazon, a friend of mine showed me his, and I am actually quite impressed.

O'Reilly did a nice job with this one! ... Read more

Product Description
For JavaScript developers working on increasingly large and complex projects, effective automated testing is crucial to success. Test-Driven JavaScript Development is a complete, best-practice guide to agile JavaScript testing and quality assurance with the test-driven development (TDD) methodology. Leading agile JavaScript developer Christian Johansen covers all aspects of applying state-of-the-art automated testing in JavaScript environments, walking readers through the entire development lifecycle, from project launch to application deployment, and beyond.

Using real-life examples driven by unit tests, Johansen shows how to use TDD to gain greater confidence in your code base, so you can fearlessly refactor and build more robust, maintainable, and reliable JavaScript code at lower cost. Throughout, he addresses crucial issues ranging from code design to performance optimization, offering realistic solutions for developers, QA specialists, and testers.

Coverage includes
•    Understanding automated testing and TDD
•    Building effective automated testing workflows
•    Testing code for both browsers and servers (using Node.js)
•    Using TDD to build cleaner APIs, better modularized code, and more robust software
•    Writing testable code
•    Using test stubs and mocks to test units in isolation
•    Continuously improving code through refactoring
•    Walking through the construction and automated testing of fully functional software

The accompanying Web site, tddjs.com, contains all of the book’s code listings and additional resources.

... Read more

Product Description

Customer Reviews (26)

This is THE COOKBOOK for creating an app.
In the hit or miss world of buying reference books, this one is a big hit!It's a very practical step-by-step guide to creating an iPhone app and -- most important -- THE EXAMPLES WORK. From nuggets on using -webkit to get the look and feel into the phone user's comfort zone, using JQuery to accomplish self-calling pages so you don't keep activating Safari over and over, to showing you the steps to prepare a webapp to go into the iPhone's icon menu either directly or through iTunes.This is the good stuff.Every programmer I've shown the book to so far immediately orders one.

A little information can be highly profitable
It is always interesting to see why people do what they do and //Building iPhone Apps// showed us why Jonathan Stark is irritated with the apparent need to use higher programming languages in order to program simplistic iPhone apps. After doing some exploring, he found that you could create apps with the same basic coding you would use for designing Web sites.

The book itself is pretty good. There are plenty of coding examples, tips on how to do things better, and instructions on how to do some interesting things with some basic code. It is a neat little book on how to do things you wouldn't expect with some code that looks great but is usually disregarded because of its relative simplicity to learn. This is a great book for that programmer who is looking for something to do on the side, and doesn't mind learning a few new tricks.

Reviewed by: Jamais Jochim

What a great book!
This is a great book. Starts off by telling you pros and cons of native apps v html apps, then explains how to build HTML apps from scratch, and using jQTouch. Clear, easy to follow examples which are nicely broken down and explained.

I wrote an app in a couple of hours using this.

Could have been so much better!
First off, the title is completely misleading. Almost every chapter in the book covers how to build iPhone-specific web applications using HTML 5 and CSS3 specs. The last two chapters, and only the last two chapters, address converting these iPhone web apps into iPhone native apps using PhoneGap and then submitting them to the Apple Store. Even then, the information coveredin these two chapters was rudimentary at best.

I probably shouldn't have had such high expectations, but the reputation of both the publisher and the author has always been stellar in my book. A title like, "Introduction to Building iPhone Web Apps and Converting Then to Native Apps using PhoneGap" would have properly prepared me for the content of the book. The content in and of itself is excellent--as an introduction, but nothing more.

So if you're interested in building iPhone web apps, this book is a great starting point. If you're interested in building iPhone native apps with web technologies, this book might be a letdown considering the level of your expertise developing iPhone web apps.

Short but sweet
This book really hit the sweet-spot for me. It covered all the topics I wanted to know more about but it kept things brief and to the point. I wish more authors would scale back on the blah blah blah and stick to the meat of the topic. Worth every penny. ... Read more

Product Description

Pro JavaScript Techniques is the ultimate JavaScript book for the modern web developer. It provides everything you need to know about modern JavaScript, and shows what JavaScript can do for your web sites. This book doesnt waste any time looking at things you already know, like basic syntax and structures.

Customer Reviews (28)

Great book, is out of the traditionalprogramming-style books
I like very much this book because is not like the traditional programming-style books, who start by teaching like "the basics", the languange structures, etc.

This book deal with the classics problems that all JavaScript programmer has, and don't waste time with the details that you can find yourself in references or searching in google.
Another thing i like a lot is that it explains why the language is like that, the source of the problems, how solve them and the most common issues you will find if you came from traditional object orientated programming.

The only thing i am not agree at all is that John tries to show us how to adapt the language for program as traditional object-orientated languages as Java or C#, because he tries to simulate that functionality with helpers tools.
Here i would like to mention some words of Douglas Crockford:

"JavaScript can be used like a classical language, but it also has a level of expressiveness which is quite unique. We have looked at Classical Inheritance, Swiss Inheritance, Parasitic Inheritance, Class Augmentation, and Object Augmentation. This large set of code reuse patterns comes from a language which is considered smaller and simpler than Java.
Classical objects are hard. The only way to add a new member to a hard object is to create a new class. In JavaScript, objects are soft. A new member can be added to a soft object by simple assignment.
Because objects in JavaScript are so flexible, you will want to think differently about class hierarchies. Deep hierarchies are inappropriate. Shallow hierarchies are efficient and expressive. "

But, the bottomline, if you are a experience programmer and you want start beyond the classic teaching of "if, whiles, etc" and get fast in the aspects of the language that matters, get this book.

Should have been much better
WhileJohn Resig clearly understands javaScript very well, he doesn't put as much effort into writing about it. This book starts out well, but mistakes and unclear explanations take over after the second chapter. The problems in the case studies toward the end of the book are even more frustrating than the typos. As someone else already said "if you can debug the mistakes, you don't need the book."Especially troublesome to me is the lack of support from the publisher, no errata and the code downloads are incorrect ( at least some of them don't even function). The book is not a write off, there is very valuable information and advice. I just am very disappointed in the code examples and their explanations.In addition the book evangelizes OOP, but the examples are all procedural causing even further confusion. Because of the problems I have with the book, I am slightly surprised by the number of 4 and 5 star reviews. Maybe not everyone will be as disappointed as I am.

Good book, not working examples
It is very good book for people with average knowledge of JavaScript. It will teach you several good techniques and many tricks mainly about object oriented programming and using DOM.

Problem of this book are attached examples, that you can download with book. They contain errors. Some of them are not working. It is bad for such a good book.

A must-read for JavaScript developers
If you develop applications with more than 10% JavaScript, be sure to learn to do it the proper way with John's Pro JavaScript Techniques.
Personally I bought it to properly learn JavaScript object oriented principles, but it also covers a in depth AJAX section. That last part may come in less handy because there are so many frameworks available that take care of this but you can of course skip that part.

Because of chapters 2 and 3 alone, I can highly recommended this for anyone developing JavaScript comming from a server-side environment.

Too Cute by Half
John Resig continually goes on about how JavaScript is not a toy language, while constantly writing code in such a way as to demonstrate that it is.Can you do powerful things with JavaScript?Absolutely.Can you demonstrate it to developers coming from non-scripting backgrounds?Not like this.

As stated in some of the other reviews, this book is not for beginners.Fair enough.I have a decent background with other languages including Java, C++, C# and PHP, and some experience with JavaScript, so I figured I could handle it.Unfortunately, that's not the case.

If you're not well versed in the screwy ways JavaScript allows you to do things, this isn't a good book for you.This book demonstrates all the hackish non-sense that many JavaScript developers use, which completely frustrates someone coming from a compiled language background.Instead of being able to focus on the core concepts the author is trying to cover, I ended up spending a great deal of time trying to sort out what the JavaScript code was doing.

I'm quite sure that there are ways to write JavaScript code which makes it understandable, and self documenting.It would have been nice if the author had chosen to write this book that way. ... Read more

Product Description

The World’s Easiest Java Script Tutorial–Fully Updated!

JavaScript by Example, Second Edition, is the easiest, most hands-on way to learn JavaScript. Legendary programming instructor Ellie Quigley has thoroughly updated her classic book to deliver the skills and information today’s JavaScript users need most–including up-to-the-minute coverage of JavaScript programming constructs, CSS, Ajax, JSON, and the latest JavaScript libraries and best practices.

Quigley illuminates every technique with focused, classroom-tested code examples, detailed line-by-line explanations, and real program output. This exceptionally clear, easy-to-understand book takes you from your first script to advanced techniques. It’s the only JavaScript book you’ll ever need!

Customer Reviews (10)

Theory book with little practical use
This book is not for practical people who have an applied purpose with JavaScript.

The major flaw with this book is that the examples used are completely useless for practicality: she uses boring things like moving text around the page when illustrating a concept rather using practical examples.

The best thing about this book are the numerous exercises, you literally start from page 6 with writing your first code example. Also, each chapter is not that long, around 15-20 pages.

As a non-IT person I found the text not too difficult to understand, but honestly, if you are completely new to any sort of programming (C#, VB, etc) you may have to re-read the paragraphs for it to sink in.

If you have a practical purpose in mind for learning JavaScript choose:
Simply JavaScript, it will save you time.
Also, if you know that you really struggle with reading technical texts in computing, use Simply JavaScript.

Pre-requisites for this book by Quigley are: basic HTML/XHTML and some CSS, either from a course or from a book such as Ian LLoyd's Build Your Own Website The Right Way Using HTML & CSS. Obviously the more (X)HTML you know beforehand the better.

Also note that this book is abit old, in "software-years", and so some of the HTML methodology is outdated.
For example the book uses the tag to change the font attributes, something which has become deprecated, or "not recommended", by W3C.
But even with these outdated HTML methods I had no problems getting the coding to work, except for a few XHTML modifications here and there.

Great Book for Javascripters
This is my first Javascript book that I had to purchase for class but when I'm done with class I am going to keep it because it is very helpful when I need help I just refer to it. Sometimes it may not have enough examples of a certain issue you are looking for but it comes with a cd as well. A great buy indeed.

Terrific book.
Terrific book, a little (editing) problems in the book, but if you have a little experience in Javascript they can be overlooked. Actually the few errors keep you on your toes!

Very good if you are the right type of reader for it
Wether or not this book is right for you, really depends on what you need from a Javascript text book. Armed with some basic knowledge of HTML, this was the perfect text to put me up to speed on the topic. There are many examples (as the title implies), giving you an exhaustive treatment of all topics. This treatment doesn't leave anything out, and though it would be nice to have the answers to the exercises, anything which stumps you can be solved by going over the examples again.

There are many explanations for every example given, but it's quite easy to skip around to what you need if you know some of the material already.

Excellent self-study tool.

Pretty good
A few discrepancies between the examples, explanations, and especially the CD, eg: where I think she changed a file or variable name in one place and forgot to change it in the other, so you spend some time trying to reconstruct what she meant to say.
Otherwise well paced, good for learning. ... Read more

Product Description
The perennial bestseller returns with new details for using the latest tools and techniques available with JavaScript

JavaScript is the definitive language for making the Web a dynamic, rich, interactive medium. This guide to JavaScript builds on the success of previous editions and introduces you to many new advances in JavaScript development. The reorganization of the chapters helps streamline your learning process while new examples provide you with updated JavaScript programming techniques.

You'll get all-new coverage of Ajax for remote scripting, JavaScript frameworks, JavaScript and XML, and the latest features in modern Web browsers. Plus, all the featured code has been updated to ensure compliance with the most recent popular Web browsers.

• Introduces you to the latest capabilities of JavaScript, the definitive language for developing dynamic, rich, interactive Web sites
• Features new coverage of data types and variables, JavaScript and XML, Ajax for remote scripting, and popular JavaScript frameworks
• Offers updated code that ensures compliance with the most popular Web browsers
• Includes improved examples on the most up-to-date JavaScript programming techniques

Continuing in the superlative tradition of the first three editions, Beginning JavaScript, Fourth Edition, gets you up to speed on all the new advances in JavaScript development.

Note: CD-ROM/DVD and other supplementary materials are not included as part of eBook file. ... Read more

Customer Reviews (2)

Sloppy copyediting on update
Just put out $30 for _Beginning Javascript_ 4th edition, having started a JavaScript review and realized my first edition of said book was a "bit" dated.

It is frustrating to find, already on p. 7, evidence of sloppy editing after the cut-and-paste of the update. Under the heading "Where do my scripts go?", instead of a general statement introducing the