Effective JavaScript: 68 Specific Ways to Harness the Power of JavaScript

In Effective JavaScript, long-time JavaScript standards committee insider David Herman introduces 30 powerful ways to write more efficient and more robust software with the latest version of JavaScript. Utilizing the concise, scenario-driven style pioneered by Scott Meyers in his best-selling Effective C++, Herman brings together tips, techniques, shortcuts, and realistic code examples available in no other book. Drawing on his profound understanding of JavaScript's design, history, strengths, and weaknesses, Herman focuses on capturing JavaScript's full expressive power. Developers will learn how to: * Utilize little-known best practices for coding and moving code into production * Choose the right JavaScript programming style for each project, and manage the tradeoffs associated with them * Avoid JavaScript's "sharp corners," including problems that can compromise portability * Master JavaScript's prototype-based object-oriented semantics - and avoiding common misconceptions that cause problems * Understand the subtleties and challenges associated with arrays and associative maps * Use JavaScript functions more expressively * Make the most of JavaScript's lexical scoping * Write more scalable, modular applications with high-quality interfaces * And much more

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