Reliable JavaScript
John Wiley & Sons (Verlag)
978-1-119-02872-7 (ISBN)
- Titel ist leider vergriffen;
keine Neuauflage - Artikel merken
Reliable JavaScript, How to Code Safely in the World's Most Dangerous Language demonstrates how to create test-driven development for large-scale JavaScript applications that will stand the test of time and stay accurate through long-term use and maintenance.
Taking a test-first approach to software architecture, this book walks you through several patterns and practices and explains what they are supposed to do by having you write unit tests. Write the code to pass the unit tests, so you not only develop your technique for structuring large-scale applications, but you also learn how to test your work.
You'll come away with hands-on practice that results in code that is correct from the start, and has the test coverage to ensure that it stays correct during subsequent maintenance. All code is provided both in the text and on the web, so you can immediately get started designing more complete, robust applications.
JavaScript has graduated from field-validation scripts to full-scale applications, but many developers still approach their work as if they were writing simple scripts.
If you're one of those developers, this book is the solution you need to whip your code into shape and create JavaScript applications that work.
- Write more concise and elegant code by thinking in JavaScript
- Test the implementation and use of common design patterns
- Master the use of advanced JavaScript features
- Ensure your code's conformance to your organization's standards
If you're ready to step up your code and develop more complete software solutions, Reliable JavaScript is your essential resource.
Larry Spencer leads an international team of developers at ScerIS, a software and services company near Boston. He has over 35 years' experience as an executive, developer, consultant, teacher, and frequent presenter at programming conferences.
Seth Richards has been crafting software professionally since 2002. His past work focused on web-based, enterprise-class geographic information system applications.
INTRODUCTION xxi
PART I: LAYING A SOLID FOUNDATION
CHAPTER 1: PRACTICING SKILLFUL SOFTWARE 3
Writing Code That Starts Correct 4
Mastering the Features of JavaScript 4
Case Study: D3.js 5
JavaScript Is Single-Threaded 15
Avoiding JavaScript’s Pitfalls in Larger Systems 16
Scripts Are Not Modules 16
Nested Functions Control Scope 16
Coding by Contract 17
Applying the Principles of Software Engineering 18
The SOLID Principles 18
The DRY Principle 21
Writing Code That Stays Correct 22
Investing for the Future with Unit Tests 22
Practicing Test-Driven Development 23
Engineering Your Code to Be Easy to Test 24
Summary 27
CHAPTER 2: TOOLING UP 29
Using a Testing Framework 29
Identifying Incorrect Code 33
Designing for Testability 35
Writing the Minimum Required Code 36
Safe Maintenance and Refactoring 36
Runnable Specification 37
Current Open-Source and Commercial Frameworks 37
QUnit 37
D.O.H. 38
Introducing Jasmine 39
Suites and Specs 39
Expectations and Matchers 41
Spies 41
Using a Dependency-Injection Framework 45
What Is Dependency Injection? 45
Making Your Code More Reliable with Dependency Injection 46
Mastering Dependency Injection 47
Case Study: Writing a Lightweight Dependency-Injection Framework 47
Using a Dependency-Injection Framework 55
Current Dependency-Injection Frameworks 56
RequireJS 56
AngularJS 57
Using an Aspect Toolkit 58
Case Study: Caching with and without AOP 58
Implementing Caching without AOP 58
Making Your Code More Reliable with AOP 60
Case Study: Building the Aop.js Module 60
Other AOP Libraries 72
AspectJS 72
AopJS jQuery Plugin 73
YUI’s Do Class 73
Conclusion 73
Using a Code-Checking Tool 73
Making Your Code More Reliable with Linting Tools 74
Introducing JSHint 76
Using JSHint 76
If You Don’t Run It, Bugs Will Come 79
Alternatives to JSHint 79
JSLint 79
ESLint 79
Strict Mode 80
Summary 80
CHAPTER 3: CONSTRUCTING RELIABLE OBJECTS 81
Using Primitives 81
Using Object Literals 83
Using the Module Pattern 84
Creating Modules ]at ]Will 84
Creating Immediate ]Execution Modules 85
Creating Reliable Modules 86
Using Object Prototypes and Prototypal Inheritance 87
The Default Object Prototype 87
Prototypal Inheritance 88
Prototype Chains 88
Creating Objects with New 89
The new Object Creation Pattern 89
Potential for Bad Things to Happen 90
Enforcing the Use of new 90
Using Classical Inheritance 95
Emulating Classical Inheritance 95
Repetition Killed the Kangaroo 96
Using Functional Inheritance 98
Monkey ]Patching 100
Summary 102
PART II: TESTING PATTERN-BASED CODE
CHAPTER 4: REVIEWING THE BENEFITS OF PATTERNS 107
Case Study 107
Producing More Elegant Code by Using a Broader Vocabulary 108
Producing Reliable Code with Well-Engineered, Well-Tested Building Blocks 109
Summary 110
CHAPTER 5: ENSURING CORRECT USE OF THE CALLBACK PATTERN 111
Understanding the Pattern Through Unit Tests 112
Writing and Testing Code That Uses Callback Functions 112
Writing and Testing Callback Functions 117
Avoiding Problems 121
Flattening the Callback Arrow 121
Minding this 123
Summary 128
CHAPTER 6: ENSURING CORRECT USE OF THE PROMISE PATTERN 129
Understanding Promises Through Unit Tests 130
Using a Promise 130
Constructing and Returning a Promise 135
Testing an XMLHttpRequest 138
Chaining Promises 141
Using a Promise Wrapper 142
Understanding States and Fates 143
Distinguishing Standard Promises from jQuery Promises 143
Summary 143
CHAPTER 7: ENSURING CORRECT USE OF PARTIAL FUNCTION APPLICATION 145
Unit-Testing a Partial Function Application 145
Creating an Aspect for Partial Function Application 147
Distinguishing Between Partial Function Application and Currying 149
Currying 149
Partial Function Application 149
Summary 150
CHAPTER 8: ENSURING CORRECT USE OF THE MEMOIZATION PATTERN 151
Understanding the Pattern Through Unit Tests 152
Adding Memoization with AOP 155
Creating the Memoization Aspect 155
Applying the returnValueCache Aspect to restaurantApi 159
Summary 160
CHAPTER 9: ENSURING CORRECT IMPLEMENTATION OF THE SINGLETON PATTERN 161
Understanding the Pattern Through Unit Tests 162
Implementing a Singleton Shared Cache with an Object Literal 162
Implementing a Singleton Shared Cache with a Module 166
Summary 170
CHAPTER 10: ENSURING CORRECT IMPLEMENTATION OF THE FACTORY PATTERN 173
Writing Unit Tests for a Factory 173
Implementing the Factory Pattern 179
Considering Other Factory Types 181
Summary 181
CHAPTER 11: ENSURING CORRECT IMPLEMENTATION AND USE OF THE SANDBOX PATTERN 183
Understanding the Pattern Through Unit Tests 184
Creating a Widget Sandbox 185
Instantiating a Widget Sandbox 185
Providing Tools to the Widget via the Sandbox 187
Creating and Testing Sandbox Tools 197
Creating Functions for Use with a Sandbox 201
Summary 203
CHAPTER 12: ENSURING CORRECT IMPLEMENTATION OF THE DECORATOR PATTERN 205
Developing a Decorator the Test ]Driven Way 207
Writing a Fake for the Decorated Object 207
Writing Tests for Pass ]Through of Errors 208
Writing a Do ]Nothing Decorator 209
Adding Pass ]Through Functionality to the Decorator 210
Verifying Pass ]Through of Successes 213
Adding the Decorator’s Features 215
Generalizing the Decorator 222
Summary 222
CHAPTER 13: ENSURING CORRECT IMPLEMENTATION OF THE STRATEGY PATTERN 223
Understanding the Pattern Through Unit Tests 223
Implementing the transportScheduler Without the Strategy Pattern 224
Implementing the transportScheduler Using the Strategy Pattern 226
Creating transportScheduler Using Test ]Driven Development 227
Creating a Strategy for Use with transportScheduler 235
Summary 237
CHAPTER 14: ENSURING CORRECT IMPLEMENTATION OF THE PROXY PATTERN 239
Developing a Proxy the Test ]Driven Way 240
Summary 256
CHAPTER 15: ENSURING CORRECT IMPLEMENTATION OF CHAINABLE METHODS 257
Understanding the Pattern Through Unit Tests 259
Chaining then 266
Summary 267
PART III: TESTING AND WRITING WITH ADVANCED JAVASCRIPT FEATURES
CHAPTER 16: CONFORMING TO INTERFACES IN AN INTERFACE-FREE LANGUAGE 271
Understanding the Benefits of Interfaces 272
Understanding the Interface Segregation Principle 273
Using Test-Driven Development to Create a Contract Registry 275
Defining a Contract 275
Determining Whether a Contract Is Fulfilled 278
Asserting That a Contract Is Fulfi lled 282
Bypassing Contract Enforcement 283
Creating an Aspect to Enforce a Contract on a Returned (Created) Object 283
Summary 288
CHAPTER 17: ENSURING CORRECT ARGUMENT TYPES 289
Introduction 289
Understanding the Opportunities and Risks Posed by JavaScript’s Type-Free Parameters 290
Extending the ContractRegistry to Check Arguments 290
Scoping Out the Task 291
Determining Whether Every Variable in a Set Fulfi lls Its Contract 291
Asserting That Every Variable in a Set Fulfi lls Its Contract 300
Packaging Argument-Checking in an Aspect 301
Supporting Contract Libraries 303
Putting It All Together 303
Creating the Contracts Modules 304
Creating the Application’s ContractRegistry 307
Bypassing Contracts for Production 307
Comparing the Aspect-Oriented Solution to a Static Solution 307
Considering the Advantages of TypeScript 308
Considering the Advantages of Aspects 308
Summary 308
CHAPTER 18: ENSURING CORRECT USE OF CALL, APPLY, AND BIND 311
Exploring How this Is Bound 312
Default Binding 312
Default Binding and strict Mode 313
Implicit Binding 314
new Binding 316
Explicit Binding 317
Creating and Testing Code That Uses call, apply, and bind 317
Using call and apply 318
Creating an Array.prototype.forEach Polyfill Using Test-Driven Development 320
Using bind 329
Summary 334
CHAPTER 19: ENSURING THE CORRECT USE OF METHODBORROWING 335
Ensuring the Borrowing Object Is Suitable 336
Making the Borrowed Function Qualify the Borrower 336
Attaching an Aspect to the Borrowed Object 338
Using a borrow() Method 342
Adding an Object ]Validator to the ContractRegistry 342
Anticipating Side Effects on the Borrower 343
Considering Side Effects from an Isolated Function 343
Considering Side Effects from a Function That Calls Other Functions 345
Anticipating Side Effects on the Donor Object 351
Summary 351
CHAPTER 20: ENSURING CORRECT USE OF MIXINS 353
Creating and Using Mixins 355
Creating and Using a Traditional Mixin 356
Creating the extend Function Using Test ]driven Development 356
Creating a Traditional Mixin Using Test ]driven Development 367
Creating and Using a Functional Mixin 373
Summary 380
CHAPTER 21: TESTING ADVANCED PROGRAM ARCHITECTURES 383
Ensuring Reliable Use of the Observer Pattern 384
Examining the Observer Pattern 384
Enhancing the Reliability of the Observer Pattern 391
Ensuring Reliable Use of the Mediator Pattern 395
Examining the Mediator Pattern 396
Enhancing the Reliability of Mediator-Based Code 397
Developing a Colleague 398
Testing a Colleague 399
Segregating the Mediator’s Interfaces 402
Deciding Where to Put the Contracts 403
Ensuring the Colleague Gets a Mediator with the Expected Interface 404
Developing a Mediator 406
Testing the Mediator 408
Summary 410
PART IV: SPECIAL SUBJECTS IN TESTING
CHAPTER 22: TESTING ADVANCED PROGRAM ARCHITECTURES 383
Ensuring Reliable Use of the Observer Pattern 384
Examining the Observer Pattern 384
Enhancing the Reliability of the Observer Pattern 391
Ensuring Reliable Use of the Mediator Pattern 395
Examining the Mediator Pattern 396
Enhancing the Reliability of Mediator-Based Code 397
Developing a Colleague 398
Testing a Colleague 399
Segregating the Mediator’s Interfaces 402
Deciding Where to Put the Contracts 403
Ensuring the Colleague Gets a Mediator with the Expected Interface 404
Developing a Mediator 406
Testing the Mediator 408
Summary 410
CHAPTER 23: ENSURING CONFORMANCE TO STANDARDS 435
Using ESLint 436
Installing ESLint 436
Installing Node and npm 436
Installing ESLint Using npm 439
Running ESLint 439
Executing ESLint on a Single File 442
Executing ESLint on All the JavaScript Files in a Directory 443
Enforcing Coding Standards with ESLint 444
Creating a Custom ESLint Rule 445
Running ESLint with Custom Rules 448
Enforcing Architectural Divisions 449
The Family-Secret Technique 450
The Imprinting Technique 452
The Mission Impossible Technique 454
The Magic Wand Technique 459
Do Not Use the Call Stack Technique 460
Other Techniques 460
Other Architectures 460
Summary 460
PART V: SUMMARY
CHAPTER 24: SUMMARY OF THE PRINCIPLES OF TEST-DRIVEN DEVELOPMENT 465
Recalling Why Test-Driven Development Is Worthwhile 465
Practicing Test-Driven Development 466
Writing Unit-Testable Code 466
Mastering the Mechanics of Test-Driven Development 466
Writing the Test Before the Code 467
Keeping Your Tests DRY 467
Testing Error Conditions First 467
Testing the Simple before the Complex 467
Being Specifi c 467
Testing Just One Thing 468
Your Test Data Are Just As Important As the Test 468
Using Jasmine Effectively 468
Testing the Patterns in This Book 468
Testing Aspect-Oriented Programming 468
Testing Object Construction 469
Testing Callbacks 469
Testing Promise-Based Code 469
Testing a Partial Function Application 470
Testing Memoization 470
Testing a Singleton 470
Testing a Factory Method 470
Testing a Sandbox 470
Testing the Decorator Pattern 471
Testing the Strategy Pattern 471
Testing the Proxy Pattern 471
Testing Chainable Methods 471
Testing Conformance to an Interface 472
Testing the Use of call and apply 472
Testing the Method-Borrowing Pattern 472
Testing Mixins 472
Testing Mediators and Observers 473
Testing DOM Access 473
Tests to Enforce Architectural Divisions 473
Summary 473
CHAPTER 25: SUMMARY OF JAVASCRIPT IDIOMS IN THIS BOOK 475
Reviewing Objects 475
Object Properties May Be Added and Removed 476
Objects May Be Used as a Dictionary 476
Reviewing Variables 477
Variable Declarations Are Hoisted 477
Variables Have Function Scope 478
Reviewing Functions 481
Functions Are Objects 481
Functions Declarations Are Hoisted 481
Functions Don’t Have Return Types 482
Functions May Be Anonymous 482
Functions May Be Nested 483
Functions May Be Invoked with Any Number of Arguments 484
Functions May Be Invoked Immediately 485
Reviewing Boolean Operations 486
Types May Be Coerced When Testing Equality 486
Values May Be Truthy or Falsy 487
Summary 487
INDEX 489
| Verlagsort | New York |
|---|---|
| Sprache | englisch |
| Maße | 188 x 234 mm |
| Gewicht | 886 g |
| Einbandart | kartoniert |
| Themenwelt | Informatik ► Web / Internet ► JavaScript |
| Schlagworte | JavaScript • JavaScript; Handbuch/Lehrbuch |
| ISBN-10 | 1-119-02872-8 / 1119028728 |
| ISBN-13 | 978-1-119-02872-7 / 9781119028727 |
| Zustand | Neuware |
| Haben Sie eine Frage zum Produkt? |
aus dem Bereich
