Effective JavaScript
68 Specific Ways to Harness the Power of JavaScript
Will be published approx. on 12. December 2012
Book
Paperback/Softback
240 pages
978-0-321-81218-6 (ISBN)
Description
"It's uncommon to have a programming language wonk who can speak in such comfortable and friendly language as David does. His walk through the syntax and semantics of JavaScript is both charming and hugely insightful; reminders of gotchas complement realistic use cases, paced at a comfortable curve. You'll find when you finish the book that you've gained a strong and comprehensive sense of mastery."
-Paul Irish, developer advocate, Google Chrome
"This is not a book for those looking for shortcuts; rather it is hard-won experience distilled into a guided tour. It's one of the few books on JS that I'll recommend without hesitation."
-Alex Russell, TC39 member, software engineer, Google
In order to truly master JavaScript, you need to learn how to work effectively with the language's flexible, expressive features and how to avoid its pitfalls. No matter how long you've been writing JavaScript code, Effective JavaScript will help deepen your understanding of this powerful language, so you can build more predictable, reliable, and maintainable programs.
Author David Herman, with his years of experience on Ecma's JavaScript standardization committee, illuminates the language's inner workings as never before-helping you take full advantage of JavaScript's expressiveness. Reflecting the latest versions of the JavaScript standard, the book offers well-proven techniques and best practices you'll rely on for years to come.
Effective JavaScript is organized around 68 proven approaches for writing better JavaScript, backed by concrete examples. You'll learn how to choose the right programming style for each project, manage unanticipated problems, and work more successfully with every facet of JavaScript programming from data structures to concurrency. Key features include
Better ways to use prototype-based object-oriented programming
Subtleties and solutions for working with arrays and dictionary objects
Precise and practical explanations of JavaScript's functions and variable scoping semantics
Useful JavaScript programming patterns and idioms, such as options objects and method chaining
In-depth guidance on using JavaScript's unique "run-to-completion" approach to concurrency
-Paul Irish, developer advocate, Google Chrome
"This is not a book for those looking for shortcuts; rather it is hard-won experience distilled into a guided tour. It's one of the few books on JS that I'll recommend without hesitation."
-Alex Russell, TC39 member, software engineer, Google
In order to truly master JavaScript, you need to learn how to work effectively with the language's flexible, expressive features and how to avoid its pitfalls. No matter how long you've been writing JavaScript code, Effective JavaScript will help deepen your understanding of this powerful language, so you can build more predictable, reliable, and maintainable programs.
Author David Herman, with his years of experience on Ecma's JavaScript standardization committee, illuminates the language's inner workings as never before-helping you take full advantage of JavaScript's expressiveness. Reflecting the latest versions of the JavaScript standard, the book offers well-proven techniques and best practices you'll rely on for years to come.
Effective JavaScript is organized around 68 proven approaches for writing better JavaScript, backed by concrete examples. You'll learn how to choose the right programming style for each project, manage unanticipated problems, and work more successfully with every facet of JavaScript programming from data structures to concurrency. Key features include
Better ways to use prototype-based object-oriented programming
Subtleties and solutions for working with arrays and dictionary objects
Precise and practical explanations of JavaScript's functions and variable scoping semantics
Useful JavaScript programming patterns and idioms, such as options objects and method chaining
In-depth guidance on using JavaScript's unique "run-to-completion" approach to concurrency
Reviews / Votes
"Living up to the expectation of an Effective Software Development Series programming book, Effective JavaScript by Dave Herman is a must-read for anyone who wants to do serious JavaScript programming. The book provides detailed explanations of the inner workings of JavaScript, which helps readers take better advantage of the language."-Erik Arvidsson, senior software engineer
"Before reading Effective JavaScript, I thought it would be just another book on how to write better JavaScript. But this book delivers that and so much more-it gives you a deep understanding of the language. And this is crucial. Without that understanding you'll know absolutely nothing whatever about the language itself. You'll only know how other programmers write their code.
"Read this book if you want to become a really good JavaScript developer. I, for one, wish I had it when I first started writing JavaScript."
-Anton Kovalyov, developer of JSHint
"If you're looking for a book that gives you formal but highly readable insights into the JavaScript language, look no further. Intermediate JavaScript developers will find a treasure trove of knowledge inside, and even highly skilled JavaScripters are almost guaranteed to learn a thing or ten. For experienced practitioners of other languages looking to dive headfirst into JavaScript, this book is a mustread for quickly getting up to speed. No matter what your background, though, author Dave Herman does a fantastic job of exploring JavaScript-its beautiful parts, its warts, and everything in between."
-Rebecca Murphey, senior JavaScript developer, Bocoup
"Effective JavaScript is essential reading for anyone who understands that JavaScript is no mere toy and wants to fully grasp the power it has to offer. Dave Herman brings users a deep, studied, and practical understanding of the language, guiding them through example after example to help them come to the same conclusions he has. This is not a book for those looking for shortcuts; rather, it is hard-won experience distilled into a guided tour. It's one of the few books on JavaScript that I'll recommend without hesitation."
-Alex Russell, TC39 member, software engineer, Google
"Rarely does anyone have the opportunity to study alongside a master in their craft. This book is just that-the JavaScript equivalent of a time-traveling philosopher visiting fifth century BC to study with Plato."
-Rick Waldron, JavaScript evangelist, Bocoup
More details
Series
Language
English
Place of publication
New Jersey
United States
Publishing group
Pearson Education (US)
Target group
Professional and scholarly
College/higher education
Dimensions
Height: 234 mm
Width: 176 mm
Thickness: 12 mm
Weight
300 gr
ISBN-13
978-0-321-81218-6 (9780321812186)
Schweitzer Classification
Other editions
Additional editions
David Herman
Effective JavaScript
E-Book
11/2012
1st Edition
Addison Wesley
€41.99
Available for download
E-Book
11/2012
1st Edition
Addison Wesley
€41.99
Available for download
Person
David Herman is a principal researcher at Mozilla Research. He holds a BA in computer science from Grinnell College, and an MS and PhD in computer science from Northeastern University. David serves on Ecma TC39, the committee responsible for the standardization of JavaScript.
Content
Foreword xiii
Preface xv
Acknowledgments xvii
About the Author xix
Chapter 1: Accustoming Yourself to JavaScript 1
Item 1: Know Which JavaScript You Are Using 1
Item 2: Understand JavaScript's Floating-Point Numbers 7
Item 3: Beware of Implicit Coercions 9
Item 4: Prefer Primitives to Object Wrappers 15
Item 5: Avoid using == with Mixed Types 16
Item 6: Learn the Limits of Semicolon Insertion 19
Item 7: Think of Strings As Sequences of 16-Bit Code Units 25
Chapter 2: Variable Scope 31
Item 8: Minimize Use of the Global Object 31
Item 9: Always Declare Local Variables 34
Item 10: Avoid with 35
Item 11: Get Comfortable with Closures 39
Item 12: Understand Variable Hoisting 42
Item 13: Use Immediately Invoked Function Expressions to Create Local Scopes 44
Item 14: Beware of Unportable Scoping of Named Function Expressions 47
Item 15: Beware of Unportable Scoping of Block-Local Function Declarations 50
Item 16: Avoid Creating Local Variables with eval 52
Item 17: Prefer Indirect eval to Direct eval 54
Chapter 3: Working with Functions 57
Item 18: Understand the Difference between Function, Method, and Constructor Calls 57
Item 19: Get Comfortable Using Higher-Order Functions 60
Item 20: Use call to Call Methods with a Custom Receiver 63
Item 21: Use apply to Call Functions with Different Numbers of Arguments 65
Item 22: Use arguments to Create Variadic Functions 67
Item 23: Never Modify the arguments Object 68
Item 24: Use a Variable to Save a Reference to arguments 70
Item 25: Use bind to Extract Methods with a Fixed Receiver 72
Item 26: Use bind to Curry Functions 74
Item 27: Prefer Closures to Strings for Encapsulating Code 75
Item 28: Avoid Relying on the toString Method of Functions 77
Item 29: Avoid Nonstandard Stack Inspection Properties 79
Chapter 4: Objects and Prototypes 83
Item 30: Understand the Difference between prototype, getPrototypeOf, and__proto__ 83
Item 31: Prefer Object.getPrototypeOf to __proto__ 87
Item 32: Never Modify __proto__ 88
Item 33: Make Your Constructors new-Agnostic 89
Item 34: Store Methods on Prototypes 92
Item 35: Use Closures to Store Private Data 94
Item 36: Store Instance State Only on Instance Objects 95
Item 37: Recognize the Implicit Binding of this 98
Item 38: Call Superclass Constructors from Subclass Constructors 101
Item 39: Never Reuse Superclass Property Names 105
Item 40: Avoid Inheriting from Standard Classes 106
Item 41: Treat Prototypes As an Implementation Detail 109
Item 42: Avoid Reckless Monkey-Patching 110
Chapter 5: Arrays and Dictionaries 113
Item 43: Build Lightweight Dictionaries from Direct Instances of Object 113
Item 44: Use null Prototypes to Prevent Prototype Pollution 116
Item 45: Use hasOwnProperty to Protect Against Prototype Pollution 118
Item 46: Prefer Arrays to Dictionaries for Ordered Collections 123
Item 47: Never Add Enumerable Properties to Object.prototype 125
Item 48: Avoid Modifying an Object during Enumeration 127
Item 49: Prefer for Loops to for...in Loops for Array Iteration 132
Item 50: Prefer Iteration Methods to Loops 133
Item 51: Reuse Generic Array Methods on Array-Like Objects 138
Item 52: Prefer Array Literals to the Array Constructor 140
Chapter 6: Library and API Design 143
Item 53: Maintain Consistent Conventions 143
Item 54: Treat undefined As "No Value" 144
Item 55: Accept Options Objects for Keyword Arguments 149
Item 56: Avoid Unnecessary State 153
Item 57: Use Structural Typing for Flexible Interfaces 156
Item 58: Distinguish between Array and Array-Like 160
Item 59: Avoid Excessive Coercion 164
Item 60: Support Method Chaining 167
Chapter 7: Concurrency 171
Item 61: Don't Block the Event Queue on I/O 172
Item 62: Use Nested or Named Callbacks for Asynchronous Sequencing 175
Item 63: Be Aware of Dropped Errors 179
Item 64: Use Recursion for Asynchronous Loops 183
Item 65: Don't Block the Event Queue on Computation 186
Item 66: Use a Counter to Perform Concurrent Operations 190
Item 67: Never Call Asynchronous Callbacks Synchronously 194
Item 68: Use Promises for Cleaner Asynchronous Logic 197
Index 201
Preface xv
Acknowledgments xvii
About the Author xix
Chapter 1: Accustoming Yourself to JavaScript 1
Item 1: Know Which JavaScript You Are Using 1
Item 2: Understand JavaScript's Floating-Point Numbers 7
Item 3: Beware of Implicit Coercions 9
Item 4: Prefer Primitives to Object Wrappers 15
Item 5: Avoid using == with Mixed Types 16
Item 6: Learn the Limits of Semicolon Insertion 19
Item 7: Think of Strings As Sequences of 16-Bit Code Units 25
Chapter 2: Variable Scope 31
Item 8: Minimize Use of the Global Object 31
Item 9: Always Declare Local Variables 34
Item 10: Avoid with 35
Item 11: Get Comfortable with Closures 39
Item 12: Understand Variable Hoisting 42
Item 13: Use Immediately Invoked Function Expressions to Create Local Scopes 44
Item 14: Beware of Unportable Scoping of Named Function Expressions 47
Item 15: Beware of Unportable Scoping of Block-Local Function Declarations 50
Item 16: Avoid Creating Local Variables with eval 52
Item 17: Prefer Indirect eval to Direct eval 54
Chapter 3: Working with Functions 57
Item 18: Understand the Difference between Function, Method, and Constructor Calls 57
Item 19: Get Comfortable Using Higher-Order Functions 60
Item 20: Use call to Call Methods with a Custom Receiver 63
Item 21: Use apply to Call Functions with Different Numbers of Arguments 65
Item 22: Use arguments to Create Variadic Functions 67
Item 23: Never Modify the arguments Object 68
Item 24: Use a Variable to Save a Reference to arguments 70
Item 25: Use bind to Extract Methods with a Fixed Receiver 72
Item 26: Use bind to Curry Functions 74
Item 27: Prefer Closures to Strings for Encapsulating Code 75
Item 28: Avoid Relying on the toString Method of Functions 77
Item 29: Avoid Nonstandard Stack Inspection Properties 79
Chapter 4: Objects and Prototypes 83
Item 30: Understand the Difference between prototype, getPrototypeOf, and__proto__ 83
Item 31: Prefer Object.getPrototypeOf to __proto__ 87
Item 32: Never Modify __proto__ 88
Item 33: Make Your Constructors new-Agnostic 89
Item 34: Store Methods on Prototypes 92
Item 35: Use Closures to Store Private Data 94
Item 36: Store Instance State Only on Instance Objects 95
Item 37: Recognize the Implicit Binding of this 98
Item 38: Call Superclass Constructors from Subclass Constructors 101
Item 39: Never Reuse Superclass Property Names 105
Item 40: Avoid Inheriting from Standard Classes 106
Item 41: Treat Prototypes As an Implementation Detail 109
Item 42: Avoid Reckless Monkey-Patching 110
Chapter 5: Arrays and Dictionaries 113
Item 43: Build Lightweight Dictionaries from Direct Instances of Object 113
Item 44: Use null Prototypes to Prevent Prototype Pollution 116
Item 45: Use hasOwnProperty to Protect Against Prototype Pollution 118
Item 46: Prefer Arrays to Dictionaries for Ordered Collections 123
Item 47: Never Add Enumerable Properties to Object.prototype 125
Item 48: Avoid Modifying an Object during Enumeration 127
Item 49: Prefer for Loops to for...in Loops for Array Iteration 132
Item 50: Prefer Iteration Methods to Loops 133
Item 51: Reuse Generic Array Methods on Array-Like Objects 138
Item 52: Prefer Array Literals to the Array Constructor 140
Chapter 6: Library and API Design 143
Item 53: Maintain Consistent Conventions 143
Item 54: Treat undefined As "No Value" 144
Item 55: Accept Options Objects for Keyword Arguments 149
Item 56: Avoid Unnecessary State 153
Item 57: Use Structural Typing for Flexible Interfaces 156
Item 58: Distinguish between Array and Array-Like 160
Item 59: Avoid Excessive Coercion 164
Item 60: Support Method Chaining 167
Chapter 7: Concurrency 171
Item 61: Don't Block the Event Queue on I/O 172
Item 62: Use Nested or Named Callbacks for Asynchronous Sequencing 175
Item 63: Be Aware of Dropped Errors 179
Item 64: Use Recursion for Asynchronous Loops 183
Item 65: Don't Block the Event Queue on Computation 186
Item 66: Use a Counter to Perform Concurrent Operations 190
Item 67: Never Call Asynchronous Callbacks Synchronously 194
Item 68: Use Promises for Cleaner Asynchronous Logic 197
Index 201