I own the kindle and paperback versions of this book. An exceptional book!

This is a must have if you are serious about javascript programming. It is NOT a beginner's book and it doesnt waste whole chapters on a beginning javascript tutorial. To read this book, you should already know something about using prototypes and closures in js.

The first part of the book covers basic elements of the language such as types and declarations, for loops etc but this is a more advanced treatment. I learned something in every one of these sections. For example I had never really understood variable hoisting before.

After that the book seems to cover all the topics in Crockford's Javascript The Good parts, but with more explanation. His writing is clear and straightforward. Many software authors really dont know how to write clear English and give rambling, confusing explanations. On the other end of the scale, I found Crockford's book a bit cryptic at times. Why would you do inheritance this way?? Stefanov explains. You don't really need Crockford's book if you have this one. But JS The Good Parts is a classic.

The code examples are short and succint. This is not a cook book, nor a book with apps stretching over pages. In one chapter he does cover a complete app in some detail. But for the most part the code is short easily readable snippets well chosen to make his point. But this is not a code snippet resource. The examples he does give are written for clarity and are not optimized. Nor are they cluttered with code for dealing with special cases. You can find more sophisticated implementations of all these ideas on the web. The goal is to get the core idea.

The last part of the book covers such useful things as deployment, remote scripting and loading which are all very useful.

OReilly is currently offering a special deal where if you buy the kindle version, you can then buy the printed version for $5 !!. Which means you can get both for less than Amazon's price for the book alone. In addition, OReilly allows you to download, for free, unrestricted copies of the book in PDF & Mobi format. This deal is a no brainer. Note: OReilly's price for the ebook is much higher than Amazon's, but if you buy it from Amazon , you still get all these extras.

Cons: Doesn't cover ECMA 5 which is just coming out and includes some significant features and changes. I can't fault the author for that and the book is well worth it anyway. Doesn't discuss memory management which is a significant issue for the current version of JS with circular references causing memory leaks. This problem may go away in the new generation of browsers. Dunno. The book doesnt have a code download site. Even though this is not a cook book, I consider this a serious fault. It's nice to cut and past examples into a JS console and play with them as you read. Kindle for PC does not allow cut and paste. But in mitigation, The author's site has the code for the complete apps. I would have knocked off a star for this but in light of OReilly's generous offer and the fact that I would have rated this book 6 stars, I decided to let it go :)

Master and beginner JavaScript developers alike have a reason to thank Stoyan Stefanov- he did a fantastic job surveying the JavaScript landscape and mapping out key strategies for us to use in writing JavaScript applications large and small. He explains JavaScript and how to use it properly very well in this book.

"JavaScript Patterns" is a thoughtful, thorough, and written manual on developing JavaScript applications in a patterns-based way. It excels in three main areas:

First, it explains with clear examples the difference between classical (e.g. class-like as in C++, Java, C#) language idioms of which many of us are indoctrinated and the more modern, functional, loose-type style of JavaScript. It is a good sell, as he argues convincingly for a more free and open understanding of what an Object can be in a Object-Orientated architecture. Most worth noting is how it so clearly explains the variety, prominence, and role of Functions in the language.

Second, it clearly shows through example many of the JavaScript "gotchas" like counter-intuitive hoisting rules and issues with unexpected typecasting. Each point comes with an example sophisticated enough to get the point across but without unneeded detail.

Finally, it dives into richer examples of the classical design patterns (Singleton, Factory, Decorator...) and how to apply them in JavaScript well using many of the OO patterns discussed earlier in the text.

High value in each Chapter

The "signal to noise" ratio in this text is very high. Very often authors, most notably Crockford, will go down a rabbit hole of pedantic unimportant threads. Stefanov keeps us on a focused course dedicating the most time to the subjects that really are core and matter in the language: Functions, Global Scope and Modules, building Objects.

The two exceptions to this are as follows:

His survey of Classical inheritance patterns is too involved. He spends many pages discussing the minutiae of slight differences in applying classical inheritance patterns to JavaScript, only to later argue that none of them should be used. That could have been explained to us without the long fruitless journey.

Some of the example Applications he uses to explain the patterns could have been refactored and simplified. Most notably his extended "Proxy" example missed the mark in trying to get the core pattern across because it was lost in too much unneeded application detail.

CoffeeScript and JavaScript

"JavaScript Patterns" is an absolute excellent text and can serve those writing server-side applications with JavaScript along with those using CoffeeScript to abbreviate the language. Even though CoffeeScript isn't mentioned, it explains the patterns that CoffeeScript uses when it compiles to JavaScript. To better understand what CoffeeScript is doing, read this book.

If you're a JavaScript developer, you would be wise to have this on your bookshelf--nestled nicely between JavaScript: The Good Parts and High Performance JavaScript (Build Faster Web Application Interfaces). The three make a nice little troika.

And read them in that order: The Good Parts, Patterns, and then High Performance.

Here's why:

What Stefanov gives us with this book is effectively an overview [1] of best practices for JavaScript development, going over the benefits and gotchas of certain important language features, and translating those into design and implementation patterns. Many of these patterns are language-agnostic--and you're likely to recognize them from "The Gang of Four"--but Stefanov puts them in their JavaScript party dresses and takes them out to the ball. Wisely, Stefanov also presents these patterns in an environment/host-independent fashion, so the lessons you learn about encapsulation or inheritance or performance should be equally valid regardless of whether you're coding for the browser [2] or NodeJS or some image exporting automation for Adobe Illustrator. Stefanov is also a lucid and concise author, clearly illustrating his points about these design patterns; the text is accessible--easy to follow and digest--and he is careful to clearly define words and terms that might be ambiguous or commonly misunderstood (e.g., "function expression" vs. "function declaration" vs. "function literal").

JavaScript patterns makes a great transition guide for intermediate developers--the men and women who have stopped confusing jQuery-the-library with JavaScript-the-language--the folks who are ready to re-evaluate their approach software development with JavaScript. This is for the folks that made it through Crockford's The Good Parts knowing that they learned something but also feeling less-than-certain about how to apply that something. This is the follow-on; JavaScript Patterns is the application of those lessons. And then after you've written your clean, maintainable, scalable applications--then you make the jump to Zakas' High Performance JavaScript to tune things just a little bit further.

So you're probably wondering then: if you recommend it so highly, why only four stars?

The four stars comes mostly from two niggling points:

(1) Relative to The Good Parts and High Performance, JavaScript Patterns was not published in the order that I recommend reading them. As a consequence, since I'd read the others (and quite a few others above and beyond those two), there is quite a bit of information in there that I'd seen before. This is not a Bad Thing; sometimes it pays to see information presented again--to help it sink in or else to gain another perspective on it. And in some cases Stefanov offers an as-good-or-better explanation on certain topics/techniques as others writing in the field (e.g., his examples for memoization and currying rival Crockford's, and his explanation of the pub/sub pattern (and custom event design) is more concise than the one Zakas presents in Professional JavaScript for Web Developers). Sometimes (and I've written this before) you were just hoping for... just a little bit more.

(2) And this is super nit-picky but... The book could have taken another quick editorial pass for spelling and grammar. The one that stuck out at me was right in the intro to Chapter 6: "But it's important to keep the end goal in mind--we want to reuse cod;." Indeed.

---

1 : An in-depth overview, but an overview nonetheless.

2 : Stefanov is careful to "keep the browser out of it" and dedicates only one chapter (Chapter 8: DOM and Browser Patterns) to the subject; though everyone's favorite host environment does creep in a couple of times, in a couple of examples.

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 take a 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.

A good read if you want to know why Javascript is a terrible language. The author spends a good deal of the book talking about how his pattern won't work in all cases because of some quirks in JS. There are also times when the author gives a couple of different implementations for some pattern he is explaining. I expect the author of a book like this to take a more aggressive approach and say, "there may be other ways to do this, but this is the best way...". At times it felt like he didn't want to offend someone by asserting that his pattern implementation was the best.

There are a lot of nuggets in this book. I particularly like the discussion of variable scope and how you have to apply three different rules, but even then there are cases where scope is ambiguous. Holy cow, what a hot mess is JS. And in a foreach loop having to check if the entity is owned by the set or an interpreter artifact? Really? There's no way to get just the stuff you want? And I love <sarcasm> the way typos don't generate errors but just become new properties of an object. In fact, it seems that nothing generates an error. You really have to watch your code in a JS debugger to know that its working.

The bottom line, for me, from this book is that I can do almost anything I want in JScript and I can do it in any number of different and confusing ways. A diligent, smart programmer who provides their own discipline in design and implementation can write beautiful code. But if someone falls for the dark side and takes the easy approach or uses quirks of the language, then the resulting code could be indecipherable. My own vow: I will never agree to extend or support someone else's JScript until I've had a good long look at it. If I find any little oddities then I will not spend my life force trying to correct it.

This book delivers exactly what it promises: patterns and antipatterns in JavaScript with a detailed discussion and code examples. It's designed to help serious developers of large scale applications, not casual front-end developers per say. I found that most of the book grappled with the quirks and syntax of the language and dealt with somewhat abstract examples. Don't expect advice for getting started with jQuery.

Some of the earlier chapters cover some really helpful ideas for caching and also using facade methods for backwards compatible changes to APIs. The author also discusses best practices, pros/cons of different coding patterns for creating publicly consumable APIs in JavaScript.

Chapter 7, dealing with Design Patterns was my favorite because it dealt with the philosophical approaches to problems that startups and web-app developers face all the time: how to make code maintainable that triggers many events? (Answer: the "Observer" pattern). How to avoid "God Objects" in JS? One section provides a juicy example of refactoring a very concrete code sample to use proxies and caching for a performance boost. I've almost never seen a JavaScript book, blog, or article tackle refactoring. Typically, they show you one step at a time with no mistakes, and no need to revisit the code later. Stoyan Stefanov has instead tried to show you the true face of JavaScript development with it's messiness and ever changing project requirements.

Only the last chapter deals directly with Web development, and the book deliberately remains platform agnostic everywhere else (ex: applicable to NodeJS, Rhino, and web browsers). However, this last chapter deals extensively with best practices for deployment of JavaScript -- a complicated and much neglected topic. It also discusses event delegation and capability sniffing for event handling. If you use Dojo, jQuery, or any other library, this information is probably unnecessary since the library will have all these features baked in and exposed through well documented APIs.

I would say the primary audience is Java developers moving to JavaScript. If you're looking to develop or refactor a major JavaScript library and you're trying to use "classes" in JavaScript, step away from the keyboard and buy this book. If you're curious about JavaScript's prototypal inheritance, first-class functions, or other odd quirks of the language you've noticed, this book will talk about that at length. If you're building simple interactions on the web, this is probably not the book for you.

I've wanted to brush up on my javascript so I purchased this book. My background is that I'm a programmer and I'm familiar with javascript but never had to do anything serious with it. I wanted a book to get me to the next level and I'd say I've gotten there now.

You'll learn simple practices like using console.log along with firebug instead of using alerts to debug your program. You'll learn patterns that will help you make your code more professional and standard. You'll learn functions and objects inside and out, and learn about scope (closure) within javascript. You'll learn basically everything you need to go from being a novice to something intermediate or advanced.

This book was very well written. It was so easy to read, the tone of the author was light and non-complicated. I can imagine him being a very good teacher because he doesn't waste your time but also explains in clear detail.

As soon as I finished this book, I started doing some complex work in javascript and used it as a quick reference. Worked out great and I'm really happy.

Buy it, it really is great and worth the money. Took me a little less than 2 months to get through it all, but this was my reading it on and off for no more than 30 minutes at a time. It is an easy read, you don't need to be on a computer while reading it (a big plus!).

This book (along with Crockford's JS Good Parts) has good learning material to digest once you have begun reading and writing JavaScript after a few months. The book's best chapters are related to general JS best practices and it touches on important concepts such as namespacing, modules, GoF design patterns, and API development that are of immediate practical use. However, the book does not go into much depth of solving browser problems and application scenarios, so I cannot give it higher marks.

This book explains JS patterns and basic concepts very clearly with examples. Topics are organised so wisely that it will generate interest to read the book. One of my best JS book so far. I recommend to all who has basic JS knowledge.

I really appreciate that book. It simple and don't use too much reference about main JS library such jQuery. It give advice about how to with good practice. It's easy to read and have a good place on my nightstand

I recommend this book and mainly all the book of that collection.

Ich entwickle serverseitig viel mit PHP5, u.a. für ein CMS-Framework. Javascript habe ich bisher lediglich für kleinere Applikationen/Animationen und im Zusammenhang mit Web-Formularen auf dem Browser eingesetzt. Natürlich kenne ich Flanagans einführendes Standardwerk. Und natürlich setze ich JQuery ein. Als extrem nützliches Framework überlagert und verdeckt JQuery aber die inherenten Möglichkeiten von Javascript durch eigene Strukturen und Interfaces.

Da ich nun immer mehr mit Ajax arbeite und hierfür eine Art "Miniframework" auf der Client-Seite aufbaue, habe ich begonnen, mich mehr und mehr um grundsätzliche Strukturierungs- Möglichkeiten und Patterns von Javascript zu kümmern. Dabei bin ich dann auf das Buch von S. Stefanov gestoßen. Und habe es in vielerlei Hinsicht als eine kleine Offenbarung empfunden.

Ich fand beim ersten Einstieg, dass der Autor ein ziemliches Tempo vorlegt und dass der Text sehr "dicht" geschrieben ist . Die ersten 50 Seiten sind zwar schnell überflogen. Aber das Niveau steigt dann schnell an. Kapitel 4, das versucht, dem Leser Funktionen als Objekte näher zu bringen, habe ich als ein Schlüsselkapitel empfunden. Alles, was danach kommt, fand ich erst dann in vielen Punkten spannend und lehrreich, nachdem ich Kapitel 4 nach zweimaligem Lesen ordentlich verdaut hatte. Aber so soll es sein - Mitdenken des Lesers ist zu Recht gefordert und es schadet nicht, immer mal wieder zurückzublättern.

Ich persönlich fand das Spektrum an Struktur-, Reuse- und Design-"Patterns", die der Autor beispielhaft in den Kapiteln 6 und 7 diskutiert, als relativ praxisnah, weil man die Beispiele schnell auf eigene Anforderungen übertragen kann. Hat man zudem einmal eine "Pattern"-Lektüre wie etwa das ebenfalls ausgezeichnete Buch "PHP Design Patterns" von Stefan Schmidt hinter sich gebracht, so wird man sich freuen, zu einigen der dort diskutierten Haupt-Patterns nun eine entsprechende Variante unter Javascript vorgestellt zu bekommen. Spätestens jetzt kann man sich vorstellen, Javascript auch in ganz anderen Umgebungen als einem Browser einzusetzen. Kapitel 8 zu DOM und dem browserspezifischen Einsatz von Javascript fand ich ein wenig kurz geraten. Aber das trübt den sehr guten Gesamteindruck nicht wesentlich.

Ich habe Stefanovs Buch inzwischen zum zweiten Mal gelesen. Und finde es nun exzellent. Der dichte Stil erwies sich beim erneuten Durchgang plötzlich als Vorteil. Ich finde auch, dass sich einem die didaktische Gedankenführung des Autors erst beim zweiten Lesen so richtig erschließt. Mein Respekt vor der Autor ist bei der zweiten Lektüre noch gestiegen.

Fazit: Der Autor macht es einem im ersten Anlauf sicher nicht leicht, ihm zu folgen. Aber die Anstrengung, die der Leser investieren muss, lohnt sich wirklich: Javascript hat durch das Buch für mich eine neue Bedeutung bekommen. Ich bewerte das Buch deshalb als ausgezeichnete Lektüre.

Avoids falling into the trap of simple 'hello world!' tutorials. Instead the focus is upon on well designed code and good practices for writing maintainable JavaScript code. If you already understand the basics of programming (even if you're completely new to JavaScript) I'd suggest skipping the simple tutorials and jumping into this, it's both easy to follow and very informative.

ottimo libro per chi inizia a programmare in javascript. mi ha aperto un mondo che non conoscevo. un must da avere tra i propri libri