Facebook Twitter Pinterest <Einbetten>
EUR 27,49
  • Alle Preisangaben inkl. MwSt.
Nur noch 4 auf Lager (mehr ist unterwegs).
Verkauf und Versand durch Amazon. Geschenkverpackung verfügbar.
Learning JavaScript Desig... ist in Ihrem Einkaufwagen hinzugefügt worden
Möchten Sie verkaufen?
Zur Rückseite klappen Zur Vorderseite klappen
Hörprobe Wird gespielt... Angehalten   Sie hören eine Hörprobe des Audible Hörbuch-Downloads.
Mehr erfahren
Alle 2 Bilder anzeigen

Learning JavaScript Design Patterns (Englisch) Taschenbuch – 21. August 2012

4.0 von 5 Sternen 1 Kundenrezension

Alle Formate und Ausgaben anzeigen Andere Formate und Ausgaben ausblenden
Neu ab Gebraucht ab
Kindle Edition
"Bitte wiederholen"
"Bitte wiederholen"
EUR 27,49
EUR 18,74 EUR 24,61
60 neu ab EUR 18,74 6 gebraucht ab EUR 24,61
click to open popover

Wird oft zusammen gekauft

  • Learning JavaScript Design Patterns
  • +
  • JavaScript Patterns
  • +
  • JavaScript: The Good Parts: Working with the Shallow Grain of JavaScript
Gesamtpreis: EUR 69,43
Die ausgewählten Artikel zusammen kaufen

Es wird kein Kindle Gerät benötigt. Laden Sie eine der kostenlosen Kindle Apps herunter und beginnen Sie, Kindle-Bücher auf Ihrem Smartphone, Tablet und Computer zu lesen.

  • Apple
  • Android
  • Windows Phone

Geben Sie Ihre Mobiltelefonnummer ein, um die kostenfreie App zu beziehen.

Jeder kann Kindle Bücher lesen — selbst ohne ein Kindle-Gerät — mit der KOSTENFREIEN Kindle App für Smartphones, Tablets und Computer.



Über den Autor und weitere Mitwirkende

Addy Osmani is a Developer Programs Engineer at Google, working on tools for improving how developers create applications. He's also a member of the jQuery team where he assists with documentation and our learning site project. Some of his other OS work has included contributions to Modernizr and other similar projects. Personal projects include TodoMVC, which helps developers compare JavaScript MVC frameworks and jQuery UI Bootstrap. He also wrote 'Developing Backbone.js Applications' and 'Learning JavaScript Design Patterns' and occasionally tech review books like 'JavaScript Web Applications'. His personal blog is addyosmani.com/blog/.


4.0 von 5 Sternen
5 Sterne
4 Sterne
3 Sterne
2 Sterne
1 Stern
Siehe die Kundenrezension
Sagen Sie Ihre Meinung zu diesem Artikel


Format: Taschenbuch
Das Buch hätte das Potential zum Hit, die Design Patterns sind zahlreich, nützlich und vor allem Modern, das heisst nicht nur für "classical" Objektorientierung geschrieben, wie zum Beispiel das Buch "Pro Javascript Design Patterns" von Harmes und Diaz.
Das Buch bietet eine gute Übersicht über das Thema und eine ganze umfangreiche Sektion wie sich viele Pattern mithilfe JQuery schneller implementieren lassen.
Der Tonfall ist sachlich und freundlich (finde ich wichtig).

Leider sind auf fast jeder Seite Fehler zu finden, entweder zeigen die Illustrationen etwas falsches, oder der Code ist fehlerhaft.

Dennoch kann man das Buch zum Kauf empfehlen.
Kommentar 2 Personen fanden diese Informationen hilfreich. War diese Rezension für Sie hilfreich? Ja Nein Feedback senden...
Vielen Dank für Ihr Feedback.
Wir konnten Ihre Stimmabgabe leider nicht speichern. Bitte erneut versuchen
Missbrauch melden

Die hilfreichsten Kundenrezensionen auf Amazon.com (beta)

Amazon.com: 4.3 von 5 Sternen 13 Rezensionen
13 von 15 Kunden fanden die folgende Rezension hilfreich
3.0 von 5 Sternen Bookmark the free version online 2. Oktober 2012
Von Matthew Reed - Veröffentlicht auf Amazon.com
Format: Kindle Edition
Since I started re-learning JavaScript after an absence of 7 or 8 years, I've found all sorts of great free resources online and purchased a ton of great books (JavaScript: The Good Parts, Maintainable JavaScript, Secrets of the JavaScript Ninjas, JavaScript Web Applications, and JavaScript for Web Developers); I've read two of them so far. This new book, Learning JavaScript Patterns by Addy Osmani, was released both freely via Creative Commons on the internet and through O'Reilly, and I decided to add it to my stack. (Full disclosure: I got the ebook for free from O'Reilly).

I found much of the book helpful, but it suffers from being uneven and unfocused. There are 14 chapters in the book but 80% of the content is in chapters 9 through 13. The first 8 chapters and introductory, repetitive, and short. It would have been better to have a single 10 or 15 page introduction than eight 2 page chapters. Even beginners could safely skip to chapter 9.

Unlike other Pattern books that are systematically organized, it is hard to understand the structure of the book. In the introductory chapters a table is given of the patterns described in the rest of the book, but it doesn't include page references. Sometimes patterns are mentioned before they are actually described. The GOF patterns described rely, as you would expect, on Design Patterns by Gamma et al., but I don't think the author described well how (or if) these patterns fit into JavaScript other than showing an implementation. The chapter on User Interface patterns was good, heavily relies on Martin Fowler's work, but seemed out of place where it was located. The jQuery Plug-in Design Patterns chapter, was excellent and new, at least, to me.

The best chapter in the book is chapter 12, "Design Patterns in jQuery." It describes patterns by showing them in use in jQuery, and providing commentary on the actual source. If the entire book had been organized like chapter 12, this would be a five star review.

One nice thing about the book is the many references included. Almost everything was backed up by at least one, sometimes several, blog posts or articles by experts.

The eBook originally had many errors in its diagrams, but O'Reilly has updated it recently, and most of the problems seem to be fixed. I was disappointed with the kindle version which I read on my iPod; I had to switch to the PDF at times to understand the book. Usually O'Reilly creates excellently formatted eBooks, so that was surprising.

There was a lot of good in this book, especially in the later chapters, but I would have a hard time recommending it for purchase, when the content is available online in a searchable form for free.
34 von 43 Kunden fanden die folgende Rezension hilfreich
2.0 von 5 Sternen like a curated blog post round-up, with some "phoned in" editing 16. September 2012
Von R. Friesel Jr. - Veröffentlicht auf Amazon.com
Format: Taschenbuch
Addy Osmani's "Learning JavaScript Design Patterns" reads like a Greatest Hits album of blog posts--if someone made a Greatest Hits album of blog posts from JavaScript pedants. What I mean by that is that, if you're already widely reading JavaScript developer blogs, then it's unlikely that you will encounter anything new in here; however, if you're new to the subject matter, you're much more likely to find the text valuable. This makes the book something of a well-curated "round-up" of the best design pattern related blog posts, articles, and code demonstrations from the past couple years. And while this is probably the book's greatest strength, it's also the reason that people who are already familiar with Addy Osmani's work will wind up feeling disappointed; it comes off as something of a review, and if you've been following Osmani, then your expectations are probably pretty high.

Don't get me wrong, there *is* a highlight reel here. Osmani's pedagogical streak comes across in so many places--it's clear that he has a passion for this material, and that he is equally passionate about helping people develop their skills as front-end developers. Throughout the first eight chapters (which really should have just been merged into one), he does a fantastic job of defining what constitutes a pattern, of explaining why we (as front-end developers) should care about and study design patterns, and of what makes something an "anti-pattern". Chapter Nine (the "walking tour" of the Gang of Four patterns) has the right balance between discussing the theoretical details behind a given pattern, and an illustration of its practical application. The most critical follow-up to Chapter Nine is found in Chapter Twelve, which essentially takes jQuery and uses it as a case study for those design patterns in action. Lastly, you can think of Osmani as providing a curator's role with this book; there are many places in the text where he is citing work from others as either illustrating a particular facet of a design pattern, or else as building on it in some important way.

Unfortunately, I also think that the editorial staff (both the technical reviewers, and the copy editors) really phoned it in with this book. The heading levels within individual chapters do not always have a clear correspondence with the level of importance for that section; there are a few syntax errors in the code examples, some of which are easy to spot in the electronic version (because of syntax highlighting); and speaking of syntax highlighting, it's inconsistently applied throughout the text of the electronic edition.

The preface indicates that the book's target audience is intermediate level JavaScript developers, and while I mostly agree with that, there's also a non-trivial amount of text looking specifically at jQuery which makes me think "jQuery developer" and not "JavaScript developer". (That's *maybe* a bit of an unfair critique...)

Putting all of this together, I believe that if I were forced to choose, I would recommend Stoyan Stefanov's "JavaScript Patterns" over Osmani's "Learning JavaScript Design Patterns". Don't get me wrong: if your bookshelf as room for both, then it's worth it to explore both; each covers subject matter than the other does not, but in the places where they overlap, I find that Stefanov's book rings a little bit more rigorous. Osmani's book seems a bit more current with respect to citing specific technologies, but that also suggests to me that it will feel out-dated just a little more quickly.

(Full disclosure: I received an electronic copy of this book from the publisher in exchange for writing a review.)
2 von 3 Kunden fanden die folgende Rezension hilfreich
4.0 von 5 Sternen Great book for applying Design Patterns using JavaScript 5. Oktober 2012
Von David Witherspoon - Veröffentlicht auf Amazon.com
Format: Taschenbuch
"Learning JavaScript Design Patterns" by Addy Osmani provides a great explanation of how to apply well known design patterns using JavaScript. The author does an excellent job of the format of explaining how the design pattern works, the pros and cons of the design pattern, and provides specific code examples of implementing the algorithm. You could almost say that the book is close to a cookbook, but it provides even more details about how the design pattern works than a typical cookbook would. I would not recommend this for the beginner or novice JavaScript developer due to the fact that some of the implementations of the design patterns might be difficult to follow. If you are an experienced JavaScript developer, then this would be a great book to get if you are looking at applying well known design patterns to your everyday solutions to solving problems. Personally, I am a big fan of design patterns due to the fact that they are proven solutions to problems and are easily understood by other people that understand design patterns. I really enjoyed Chapter 12 that explained design patterns in jQuery.

Overall, I feel that this book will help any JavaScript developer accelerate the quality of code that they produce by make it easier for other developers to understand what you are trying to achieve. Design patterns in any language help you express a solution to a problem and better communication with the rest of the developers in your group. Therefore, I would recommend this book for anyone that is interested in being a JavaScript developer or is a JavaScript developer and wants to take the level of code that they produce to the next level.
1 von 2 Kunden fanden die folgende Rezension hilfreich
4.0 von 5 Sternen Great for "growing" JavaScript developers; a reference I return to regularly. 15. November 2014
Von H. Paul Robertson - Veröffentlicht auf Amazon.com
Format: Taschenbuch
I got this book hoping to learn some good ways to structure my JavaScript code. This book helped me tremendously with that, and also with other needs that have arisen as my JS coding has become progressively more complex.

The sections that were particularly valuable to me include:
- Module patterns
- the MV* comparisons
- "Modern" modular patterns (AMD and CommonJS)

Before I started reading this book I was concerned that it would be another "here's the list of GOF 'Design Patterns' translated to [language XYZ]" but it's not that at all. This book is JavaScript first, "design patterns" second. Obviously the content of the book is design patterns. However, the selection of the patterns and the explanations for how to use them are driven by the language and the tasks that are common for JavaScript programming, not just by a list of patterns that are "famous" or are used in other books.

My only complaint about this book is that in some cases the information is specific to particular frameworks or libraries, to a fault. For example, in the section on Module patterns, it covers implementations in several frameworks -- YUI, MooTools, Dojo, etc. But of course frameworks come and go all the time, so I'd rather not have to read them and make a judgement about whether to learn the approach in one or the other framework. In another case, in the PubSub implementation section, the most coverage is given to a specific implementation (Ben Alman's PubSub) but I would have preferred to get more discussion about general implementation approaches (e.g. with a generic, basic implementation) rather than skipping straight into "here's a version with all the bells and whistles" without enough detail about why a particular feature is useful.

Overall it's a great book, one that I've returned to again and again. In fact, as I write this I realized that I'm facing another case of "what's a good way to design my code to do XYZ in JavaScript" and I'm realizing I ought to look and see if it's covered in this book, in which case I'll probably find a good answer!
1 von 2 Kunden fanden die folgende Rezension hilfreich
4.0 von 5 Sternen Learning JavaScript Design Patterns 24. September 2012
Von J. W. Rine - Veröffentlicht auf Amazon.com
Format: Taschenbuch
Learning JavaScript Design Patterns, by Addy Osmani, examines object oriented software design and applies those design principles to the JavaScript language. A design pattern is a reusable solution to a commonly occurring problem in software development. They are flexible guides to best practices that developers implement in their applications. A design pattern is essentially a template for problem solving. While they are not exact solutions to a problem, a design pattern is a guide to a solution.

When web applications move beyond trivial into complex, object oriented programming can provide methods to organize and structure code. JavaScript design patterns can provide reuse-ability of code. Abstraction and encapsulation of code are two advantages to using design patterns in JavaScript. Using object oriented code produces a more modular code that is less likely to clash with other sections of code in the project. Modularity and encapsulation help to prevent an application from falling prey to becoming a mass of spaghetti code that is hard to debug and maintain.

I enjoyed the book's format. Early on the author explains design patterns in a historical context with code examples that relate to Javascript. Later, models and various frameworks are examined with links to additonal resources. The design patterns outlined in chapter 9 receive additonal examples in the chapter on jQuery. I would recommend the book for intermediate to advanced JavaScript coders. The material will not be useful for those with little experience or new to JavaScript.

Disclosure: I received a free e-book copy for review purposes.
Waren diese Rezensionen hilfreich? Wir wollen von Ihnen hören.