JavaScript: The Good Parts

• #4 in Best Javascript Books

30 Reviews

Sort by: Most Helpful ▲ Date Rating

I'm not sure what I thought this book would be; I guess I assumed it would be along the lines of "C Traps and Pitfalls". At times, however, it seems almost more like an essay.

Certainly, parts of the book are worth five stars. I was especially pleased to see the author's treatment of how null, undefined, and NaN all relate to one another in unexpected ways -- something that has puzzled me in the past. It was also good to see a list of the reserved keywords, some of which I didn't know before, and concrete examples of the dangers of == and != versus === and !==.

An unexpected treat was to read his discussions on the technical aspects and slowness of arrays, bitwise operators, and "with" statements in JavaScript, and the origins of "switch" in FORTRAN IV, and JavaScript's similarity to Lisp, despite its outward resemblance to C.

It was also bemusing to see his example of "flight.equipment && flight.equipment.model" on page 21, as I also learned that same lesson while working on a flight-related application.

Yet, for the head Javascript guy at Yahoo, it seems that a few things are missing. For example, while he does say on page 80 that slice() creates a shallow copy of an array, he does not make it explicitly clear that array2 = array1 will effectively create a pointer, i.e., a copy by reference. To make a truly independent copy of an array, one needs array2 = array1.slice() (no arguments necessary). This caused me a day of frustration when I first learned it.

And was it not Yahoo themselves that determined that scripts should come at the end of a web page to improve load speed? Why is that not in here?

We also have nothing about compression techniques.

On the web, for free, one can read Andy King's superb 2003 article on "Optimizing JavaScript For Execution Speed". And most of the discussion on objects can be learned much more succinctly and with better examples from MDC's "Core JavaScript 1.5 Guide".

One can learn a lot about download optimization from Dean Edwards.

Chapter 4 (Functions) was good; Chapter 2 (Grammar) did nothing for me.

I was also a little disappointed with Appendix B, "The Bad Parts". Most of this dealt with undisciplined programming as opposed to flaws with the language itself. E.g., "switch" statement fall-throughs are bad. Are they? If one of your people creates an unintentional fall-through, then deal with him; don't blame the language. Does Crockford also believe that firearms should be banned because of the potential of misuse, even though they have a valid purpose? How about steak knives? This is kind of like Edsger W. Dijkstra telling us that we can never use GOTO, even though it does have its place.

Further, I've used "continue" statements effectively, albeit not so often. Maybe I'm a bad programmer?

And then, he advises against autoincrements!! (++)

Regarding style, the book is definitely filled with the usual O'Reilly collegiate pompousness that's often good, sometimes not-so-good.

In summary, there are some good parts, but as a whole this is yet another pricey programming book from which I only needed 10 pages.

If you're at the plateau of understanding that it's actually the DOM that's slow and inefficient, and that Javascript is only guilty by association, and that it's actually an elegant little language, then there's probably something in this book for you.

This is a beautiful book.

First of all - at only 170 pages it is short. Even though some of the key points are repeated through the book it's dense with information. You don't need any JavaScript experience, but it's not a "beginning programming" book so if you haven't been programming before this is not the right book for you.

Reading this book a couple of times will give you an appreciation for the JavaScript language that you almost certainly didn't have before. It'll give you tools to write better programs that you and others will actually be able to maintain over time.

I've learned lots of little things that I maybe knew from experience, but now I _know_ and I know why.

This book will help you battle with JavaScript rather than against it.

Do you struggle when creating objects in Javascript?
Do you find the syntax to be non-intuitive and frustrating?
Do you know the difference between using a function as an object vs using an object literal?
Do you know how using object literals can simplify your code and create something similar to namespaces?
Do you know how to augment the type system -- for example, if wanted all strings to have a trim() method?
Do you know why the "new" statement is so dangerous? Do you know an alternative that eliminates the use of "new" entirely?

These are some of the topics that the book touches upon.

This book is aimed at someone with intermediate programming experience that wants to know the best way to create and use objects, arrays, types, etc. Crockford takes his experience with Javascript to show you best practices coding techniques and styles to use with Javascript. In addition, the book provides insights into what makes Javascript so confusing and what can be done about it.

You might ask "Isn't this stuff already covered in other books that I have?" The answer is no. For one, most other books use a psuedo-classical coding style (see below) to explain objects that is a source of confusion.

Javascript can be very confusing, especially for programmers who have extensive experience in other C-based languages (like myself). Writing good Javascript that uses objects, methods, etc. is hard. In Javascript, if you want to create objects, use inheritance and create methods, you have several different ways to write your code and it's difficult to know what the strengths and weaknesses of each are.

Crockford explains the problem plainly. Other C-based languages use class inheritance (Crockford calls this classical inheritance). Javascript, on the other hand, is the only popular language that uses prototype inheritance, which does not have classes. However, the syntax which Javascript uses to create object is Java-like (Crockford calls this pseudo-classical syntax). It's confusing, because it keeps you in a class-based frame of mind while working in a language that has no concept of classes.

Clarifying what's going on with the object model is the best part of this book. Crockford also explains other parts of Javascript that can be problematic and the techniques that he prefers for handling them. I don't necessarily agree with all of them, but the important thing is that he explains his reasoning.

To effectively learn Javascript, I recommend that you buy 1) a book that covers the details of the language and can be used as a reference (e.g. Javascript, the Definitive Guide) and 2) Crockford's book. Advanced programmers might also enjoy Pro Javascript Design Patterns, which shows a number of ways to combine Javascript with some of the GoF patterns. I would avoid any cookbook style books on Javascript, because you're better off using YUI, JQuery or one of the other Javascript libraries than writing your own drag-and-drops, calendars, etc.

There are a series of Yahoo! videos by Crockford that mirror the material in this book and can be found as podcasts under YUI Theater. They contain nearly all of the material in the book and probably a little more. Those videos are:

- Douglas Crockford/An Inconvenient API: The Theory of the DOM (3 parts)
- Douglas Crockford/The JavaScript Programming Language (4 parts)
- Douglas Crockford/Advanced JavaScript (3 parts)
- Douglas Crockford/Javascript The Good Parts

Douglas Crockford is well known for all his work in JavaScript,including numerous articles, tools, and presentations. Over time he has helped define important concepts in JavaScript, such as style, patterns, pitfalls, and generally how to write clear and maintainable JavaScript code.
This book encapsulates a lot of that. A lot of great advice is packed in this short and sweet book. It is also a pleasure to read to boot.
This is not a JavaScript reference book, but instead it is an honest overview of the language features, including the bad stuff that we need to stay clear off.
I'd recommend this book to anyone that thinks JavaScript is just another curly-brace based language.

Serious JavaScript programming requires strong discipline to avoid many pitfalls that are somewhat encouraged by the language itself. The author is very aware of this problem and wrote a small, but very dense book, full of useful advices that comes from somebody who has doing sophisticated JavaScript programming for a long time. Crockford is very opinionated, and I don't always agree 100% with his suggestions, nevertheless, even whenever I disagree, I find his points are worth reading, his opinion is always valuable. This book would serve well both veteran JavaScript developers and programmers that, coming from different languages, may get lost among JavaScript's idiosyncrasies.

This is the first book by Douglas Crockford a Senior Software Archtitect at Yahoo. He is widely known as one of the most knowledgeable on JavaScript apart from the creater of JavaScript (Brendan Eich). Douglas Crockford is the creator of JSON and has written many articles and presentations on JavaScript-related topics in web development.

His book JavaScript: the Good Parts, is a short (145 pages including Appendix) but is very useful for the person who wants to expand his/her JavaScript skills and knowledge. It reviews the basics of the language in the first two chapters and then focus on intermediate and advanced topics such as objects, inheritance, arrays, and methods.

The appendix categorizes the "bad" parts of JavaScript that are not good programming syntax and should be avoided such as global variables, scope, eval function, with statement, undefined variables and so forth.

I really like how Douglas Crockford gives you everything you need in this book that is relevant to how modern developers using JavaScript program and helping you understand it easily and quickly. No long-winded explanations or extra "filler" just to make the book longer. He is right to the point and explains it in a coherent, understandable way no matter what your "technical" level is.

This is a very useful book for the client-side developer who wants either a great reference book or somebody who wants to take their skills to the next level using JavaScript.

A must buy!

I had seen some good reviews of this book but if you think it is going to help you improve your javascript coding a lot think again.

The author starts out telling you how he is the only author that can tell you how to program in javascript - and everyone else is bad.

It does go through what the author considers the "good parts" of javascript and how to use them. He does show some examples as well. I didn't find the examples very compelling. A lot of the good techniques were just showing how to use a small function the author wrote - and most of these I thought would be of limited use.

I did find the appendixes on the "bad parts" to be interesting and useful. I am primarily a java programmer and I never knew that I should not be using == in javascript.

There are some useful parts to this book but I found it to have a lot of fill for such a small book and not a lot of real value.

I bought this book after reading a lot of articles by Douglas Crockford. While the book has very interesting parts and explain in depth things that you take for granted it also has some non-interesting (chapter 8: around 15 pages of "standard methods in standard types" including string.charAt, string.concat, and a lot more).

While I liked the book, I think it was 'filled' with this juiceless chapter because it was already too short (around 145 pages).

I think reading Douglas online is a better deal! See: http://www.crockford.com/

'JavaScript: The Good Parts' is a beautiful book that is a must-buy for all Javascript developers out there. Written with brevity clearly in mind (total is only a scant 150+ pages), this book will teach you how to become a BETTER Javascript developer and know why you want to do some things one way and avoid the pitfalls of doing things the WRONG way.

This book is all about efficiency and cleanliness. Written by one of the main developers of JSON, this book is organized smartly and craftfully. I love the fact that there isn't bloat and it's very easy to get through this book in no time at all. Does that mean you aren't getting your money's worth with this book??? HELLS NO!!

If you want to improve your Javascript developing skillset you owe it to yourself to pick up this book, it's one of the best books on the market in this subject matter.

***** HIGHLY RECOMMENDED

I have to wonder if the positive reviewers actually read much of this, it's so surface. This book will neither teach you javascript nor interest the experience programmer for more than about 15 minutes.

The money could be much better spent on a truly useful book.

Weighing in at 140+ pages of content, this book cuts through the obscurities, pleasantries, and filler found in most technical books. Instead, this book dives straight into the heart of the JavaScript language. It presents the clearest comprehensive explanation of what makes JavaScript a great programming language that I've encountered to date. It nails the important concepts, like JavaScript's: object oriented nature, its classless (pseudoclassical) nature, and functional nature. While covering the fundamentals like JavaScript's: functions, lexical scoping, lambdas, prototypal inheritance, and functional inheritance.

This book's size makes it approachable for all audiences, its style is terse and concise. This book has the potential to do for JavaScript, what Richie's inspirational classic the C Programming Language did for the C language.

JavaScript is the programming language of the web (AJAX), and this book will guide you through the good parts of this often misunderstood language - while this book is an excellent reference, it is not intended to replace JavaScript: The Definitive Guide, you'll do best to have both these books on hand.

If you enjoyed (or are considering) this book then you may want to hear more of what Douglas Crockford has to say, check out his great JavaScript video series on the YUI Theater.

The book is great for a summary of JavaScript's main concepts. Don't be fooled by the title though. "The best parts" is in Douglas Crockford's own opinion. Expect some biases and expect some things to be missing. For example, I wouldn't skip the concept of JSONp from a 2008 JavaScript book, but there's not a single reference to that here.
Get it if you have worked in a high-level language before and you care about writing neat JavaScript.
Skip it if you've been writing JavaScript and you want a comprehensive non-biased reminder or reference book.

This book is for Javascript programmers who have perhaps been at the novice level and now wish to jump up to an intermediate understanding of the language. The language is small but unconventional, and this book tries to help you get your arms around the meatier parts of Javascript. The book tries to get you thinking in Javascript. The author shows you the components of the language and then shows you ways of putting those components together that say something about the design of the language overall. Then, you can go on to designing your own solutions. This is not a reference book and it is not certainly not exhaustive in its discussion of Javascript and its quirks. Instead, this book just contains the things that are really important. It is a rather small book, but it is very clear and illustrative in the concepts that it does cover, and the included examples are complete solutions, not just a line of code here or there. The table of contents are not shown in the product description, so I present that next:

Chapter 1. Good Parts
Section 1.1. Why JavaScript?
Section 1.2. Analyzing JavaScript
Section 1.3. A Simple Testing Ground
Chapter 2. Grammar
Section 2.1. Whitespace
Section 2.2. Names
Section 2.3. Numbers
Section 2.4. Strings
Section 2.5. Statements
Section 2.6. Expressions
Section 2.7. Literals
Section 2.8. Functions
Chapter 3. Objects
Section 3.1. Object Literals
Section 3.2. Retrieval
Section 3.3. Update
Section 3.4. Reference
Section 3.5. Prototype
Section 3.6. Reflection
Section 3.7. Enumeration
Section 3.8. Delete
Section 3.9. Global Abatement
Chapter 4. Functions
Section 4.1. Function Objects
Section 4.2. Function Literal
Section 4.3. Invocation
Section 4.4. Arguments
Section 4.5. Return
Section 4.6. Exceptions
Section 4.7. Augmenting Types
Section 4.8. Recursion
Section 4.9. Scope
Section 4.10. Closure
Section 4.11. Callbacks
Section 4.12. Module
Section 4.13. Cascade
Section 4.14. Curry
Section 4.15. Memorization
Chapter 5. Inheritance
Section 5.1. Pseudoclassical
Section 5.2. Object Specifiers
Section 5.3. Prototypal
Section 5.4. Functional
Section 5.5. Parts
Chapter 6. Arrays
Section 6.1. Array Literals
Section 6.2. Length
Section 6.3. Delete
Section 6.4. Enumeration
Section 6.5. Confusion
Section 6.6. Methods
Section 6.7. Dimensions
Chapter 7. Regular Expressions
Section 7.1. An Example
Section 7.2. Construction
Section 7.3. Elements
Chapter 8. Methods
Chapter 9. Style
Chapter 10. Beautiful Features
Appendix A. Awful Parts
Appendix B. Bad Parts
Appendix C. JSLint
Appendix D. Syntax Diagrams
Appendix E. JSON

If you are new to Javascript I suggest starting with Head First JavaScript (Head First). Once you have read that book, get this book and become someone who thinks in Javascript. At the same time, get JavaScript: The Definitive Guide for the best reference on the language that is in print.

JavaScript: The Definitive Guide has been, for years, the only really good JavaScript book available. It's amazing, since JavaScript is the world's most popular language. Nearly every computer has it.

JavaScript: The Good Parts is well written and terse. I'm an experienced programmer, and have worked with JavaScript for some time now, so I don't know how well it would work for an amateur, but I suspect any programmer that has no JavaScript experience would do very well to read this book first and keep The Definitive Guide as a secondary reference, especially when reading someone else's JavaScript.

I rely heavily on the YUI libraries that Crockford's company puts out, and on Crockford's JSlint.com utility. Put together with the advice in this book, and JavaScript shines as a very nice language.

I'll keep this short and sweet (like the book). This book distills the JavaScript language down to the bare essentials that a programmer will need to write clean, powerful code. It even tells you what to avoid along the way. Douglas Crockford takes a veritable pig of a language and turns it into delicious ham, bacon, and chops.

For someone serious about JavaScript, there are two books to own. JavaScript: The Definitive Guide to learn the language and its syntax (in minute detail), and this book, to learn how to use the language well.

it's amazing that many great people don't know how to teach...somebody who loves this language so much to write so little and not explaining and providing examples......


The same thing you could find online.....


Don't take me wrong, you will learn a thing or two, but that's not the point.

So called diagrams or flow, whatever they are, they are totally useless.

The content in this book is simply incredible, and it should be read by anyone seriously interested in JavaScript. Many of the other reviews have described the content, but I was shocked to see not one mention of the glaring errors in the code examples.

O'Reilly provides a good errata resource, but every other code example in this book has either a missing semicolon that you have to hunt for (most common) or code that is completely wrong. Perhaps none of this has been mentioned due to the strong merits of the content -- but it appears nobody even did a quick review over the code in this book! If you are going to buy this to have on your desk for years to come, buy it on PDF now and wait for the second edition print for the errata corrections.

With that said, I'm not trying to troll on this great book. I want to give a heads up to people so they don't have to work part-time as a copy-editor.

I decided to pick up this book because I had been using Javascript for years as a "garnish" on top of my web development, but usually only in the form of a few hacked-together utility functions and edited scripts. In truth, I was afraid of the language - it appeared to be a very inconsistent, buggy system that took arcane knowledge to master across browsers. After starting to work with a number of JS frameworks, I knew I needed to confront the language and learn it properly.

This book is possibly one of the best technical/programming related books I have had the pleasure of reading. It doesn't try to be a massive encyclopedic volume like most of my other technical books, so I didn't have to devote countless hours and days pushing through lengthy filler. Every section contains brief information about the most critical parts of Javascript you need to begin coding what you need right away in a tidy object-oriented fashion. If you have experience with any other C-based language and understand general OOP concepts, this book will make you fluent in Javascript with the least amount of time and effort on your part!

I've watched all of Douglas' videos on Yahoo YUI Theater and this is the perfect companion.

This is an excellent book, as it concisely illustrates a number of details that would be impossible to find in other books. Moderate/advanced JavaScript programmers will gain the most from this book, it is not particularly geared towards the beginner.

The book has a very specific focus, so do not be deceived into thinking this book covers the entire language. For information like that, Flanagan's JavaScript The Definitive Guide will be better. This book, however, is an excellent discussion of the important features of the language. Highly recommended.

If you are familiar with programming and need to add JavaScript to your tool belt, this book will quickly teach you not only the syntax of JavaScript, but how to best employ it. The book is short but thorough; by focusing only on the "good parts" of JavaScript and giving you design patterns on how to use them, it succeeds in giving you only the information you need to become a good JavaScript programmer, and no more. It will not teach you everything about JavaScript, or help you read badly written JavaScript. The author states that the book is not a reference, but I believe it is more of a reference than a how-to book.

Many of this book's topics are covered at Yahoo's "YUI Theater" in a collection of the author's lectures (http://developer.yahoo.com/yui/theater/ anything by Douglas Crockford). If you are interested in YUI at all, this book will help you understand the conventions used in YUI.

To paraphrase the author, if you want a book that teaches you how to be a horrible JavaScript programmer, get any other JavaScript book.

I bought this book expecting a textbook manual on how to use some JavaScript features. I ended up having an easy to read compilation of thoughts about the whole language, from an experienced Yahoo! member. But the best book feature was the way the author managed to convince us about the concept of "good part". It isn't an evangelic script - it has clear examples of why you should avoid certain language features (e.g., type inference in comparisons), along with sample recipes to make programming in JavaScript a pleasant experience (e.g., how to make good use of closures to encapsulate information within objects).

All in all, if you're into JavaScript (either warming up or as an old-school web developer) you will definitely benefit from the information within this book - and you'll find it light enough to make its reading pleasant!

I purchased this book because I needed to learn JavaScript for a specific project I was given.

JavaScript: The Good Parts is great at describing the great features in JavaScript and what 'features' aren't worth the pain they'll put you through. This book is not a JavaScript reference book.

It provides a framework for building JavaScript applications that avoid common problems. The author describes avoiding problems with global variables (by wrapping them in an object or function), inheritance, and other small but important pitfalls.

I'm definately satisfied with the purchase. My biggest wish is that it was longer and more in-depth, as it's obvious the author has a lot more great JavaScript advice to impart.

For about as long as it's been about, Javascript has endured a plague of poorly written and presented books. "A Million and One Ways to Write a Rollover." Many books will treat writing a function as an advanced move. It is left as an exercise for the reader how to manage ones code when the scale surpasses the trivial.

Douglas Crockford, who works at Yahoo, is unable to leave these questions in the realm of the intellectual, and he is in growing company. The era of large Javascript applications is upon us. By large, I mean applications that are mostly javascript, rather than HTML documents with a splash of code. This is more than mere AJAX. This is true application development, and with the scale must come application scale rigor.

It is to the problems of serious application developers that Crockford addresses the book. This is *not* an introductory book. It is generally assumed that the reader knows what the building blocks are.

Instead, Crockford focuses on issues such as organization, error avoidance, and writing code touched by many developers.

More importantly, Crockford expresses opinions. Technology as a field is never short on opinion, but technology books are a wasteland. Good luck finding a volume that spends much time at all criticizing its subject matter. Crockford pulls no punches. If he doesn't care for a given design decision, he says as much. It is, in a word, refreshing. Would that more books offered such candor.

Even if you disagree with Crockford's answers, the exercise of working through his arguments will teach you to ask better questions.

In exchange, you will learn about some of the more powerful but under-used aspects of Javascript, such as closures and first class functions. Furthermore, Crockford's detailed descriptions will give you clearer insight into exactly how the language really works.

In sum, Javascript: The Good Parts is the sort of book that can move you to the next level in your javascript development. Thank the gods the age of platonic, useless JS books is behind us.

This is not a book for non-programmers or people new to the field. It is a very dense yet approachable review of the very succinct and elegant language inside of what commonly is thought of as JavaScript. Highly recommended if you have previously thought negative things about JavaScript and want to improve you JavaScript skills, especially for those who favor elegant code.

There just isn't enough unique content in this book for it to stand alone and be sold at the book's cover price. To be fair, there's some good content in the book (some), but just not enough to be worthwhile. This entire book could've been a series of blog entries, or perhaps a section in an updated edition of the Rhino book.

I wouldn't recommend buying this book. However, if you're intent on getting a copy, look for used copies or copies at bargain prices (less than $10).

It is easy to write bad code in javascript. This book helps you to avoid potential pitfalls and write clean and structured code.

I was very disapppointed in this book. For the price of the book there was very little content. I am returning this book and buying something with more substance.

This is a book that you can easily read in one sitting. It will run you through parts of JavaScript commonly considered "advanced" and help you become a better JavaScript programmer. Unlike other books on JavaScript which seem interested on pretending JavaScript is a weak and dysfunctional cousin of Java, it embraces the JavaScript object model and teaches you to use it correctly.

I would strongly recommend anyone who intends to write JavaScript code read this book.

JavaScript was developed in a hurry before it could be refined, and thus has more 'bad parts' than most programming languages. Senior JavaScript architect at Yahoo! Douglas Crockford in JavaScript: The Good Parts lends expertise to the topic (he's considered a key expert by many in the field) and provides a survey of the language which enables effective code development. Any library strong in Java development and analysis needs JAVASCRIPT: THE GOOD PARTS.