Details

Reliable JavaScript

How to Code Safely in the World's Most Dangerous Language
1. Aufl.

von: Lawrence D. Spencer, Seth H. Richards
32,99 €
Verlag:	Wiley
Format:	EPUB
Veröffentl.:	29.06.2015
ISBN/EAN:	9781119028741
Sprache:	englisch
Anzahl Seiten:	528

In den Warenkorb

Als Gutschein

DRM-geschütztes eBook, Sie benötigen z.B. Adobe Digital Editions und eine Adobe ID zum Lesen.

Beschreibungen

Titelbeschreibung

Create more robust applications with a test-first approach to JavaScript 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. <ul> <li>Write more concise and elegant code by thinking in JavaScript</li> <li>Test the implementation and use of common design patterns</li> <li>Master the use of advanced JavaScript features</li> <li>Ensure your code's conformance to your organization's standards</li> </ul> If you're ready to step up your code and develop more complete software solutions, Reliable JavaScript is your essential resource.

Inhaltsverzeichnis

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

Autorenportrait

About the authors 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. Visit us at wrox.com where you have access to free code samples, Programmer to Programmer forums, and discussions on the latest happenings in the industry from around the world.

Back cover copy

Test first, then code, for more robust large-scale JavaScript applications Experienced developers still struggle with the failure of large-scale JavaScript applications that collapse under their own weight. Reliable JavaScript provides the solution in the form of a test-driven workflow that produces robust applications that stand the test of time. This book uses unit tests to explain, demonstrate, and employ a wide variety of JavaScript patterns and architectures. As you follow along, you will become an expert in the test-driven development of JavaScript that is suitable for commercial software. If you are ready to bring a high level of software engineering to your JavaScript development, this book is for you. Reliable JavaScript: <ul> <li>Shows you how to write code that's verified correct the first time, and has the test coverage to remain correct throughout subsequent maintenance</li> <li>Surveys the current landscape of JavaScript frameworks for testing, dependency injection, and aspect-oriented programming</li> <li>Explains testability characteristics and how to construct objects to be testable</li> <li>Demonstrates the implementation and use of common design patterns and advanced JavaScript features and architectures</li> <li>Covers DOM access testing, including excessive updates, excessive access in loops, and XHR/JSONP requests</li> <li>Provides all of the book's code both in the text and on the companion website</li> </ul> Wrox Professional guides are planned and written by working programmers to meet the real-world needs of programmers, developers, and IT professionals. Focused and relevant, they address the issues technology professionals face every day. They provide examples, practical solutions, and expert education in new technologies, all designed to help programmers do a better job.