Effective TypeScript: 62 Specific Ways to Improve Your TypeScript

Description

TypeScript is a typed superset of JavaScript with the potential to solve many of the headaches for which JavaScript is famous. But TypeScript has a learning curve of its own, and understanding how to use it effectively can take time. This book guides you through 62 specific ways to improve your use of TypeScript. Author Dan Vanderkam, a principal software engineer at Sidewalk Labs, shows you how to apply these ideas, following the format popularized by Effective C++ and Effective Java (both from Addison-Wesley). You’ll advance from a beginning or intermediate user familiar with the basics to an advanced user who knows how to use the language well. Effective TypeScript is divided into eight chapters: Getting to Know TypeScript TypeScript’s Type System Type Inference Type Design Working with any Types Declarations and @types Writing and Running Your Code Migrating to TypeScript Copyright Table of Contents Preface Who This Book Is For Why I Wrote This Book How This Book Is Organized Conventions in TypeScript Code Samples Typographical Conventions Used in This Book Using Code Examples O’Reilly Online Learning How to Contact Us Acknowledgments Chapter 1. Getting to Know TypeScript Item 1: Understand the Relationship Between TypeScript and JavaScript Things to Remember Item 2: Know Which TypeScript Options You’re Using Things to Remember Item 3: Understand That Code Generation Is Independent of Types Code with Type Errors Can Produce Output You Cannot Check TypeScript Types at Runtime Type Operations Cannot Affect Runtime Values Runtime Types May Not Be the Same as Declared Types You Cannot Overload a Function Based on TypeScript Types TypeScript Types Have No Effect on Runtime Performance Things to Remember Item 4: Get Comfortable with Structural Typing Things to Remember Item 5: Limit Use of the any Type There’s No Type Safety with any Types any Lets You Break Contracts There Are No Language Services for any Types any Types Mask Bugs When You Refactor Code any Hides Your Type Design any Undermines Confidence in the Type System Things to Remember Chapter 2. TypeScript’s Type System Item 6: Use Your Editor to Interrogate and Explore the Type System Things to Remember Item 7: Think of Types as Sets of Values Things to Remember Item 8: Know How to Tell Whether a Symbol Is in the Type Space or Value Space Things to Remember Item 9: Prefer Type Declarations to Type Assertions Things to Remember Item 10: Avoid Object Wrapper Types (String, Number, Boolean, Symbol, BigInt) Things to Remember Item 11: Recognize the Limits of Excess Property Checking Things to Remember Item 12: Apply Types to Entire Function Expressions When Possible Things to Remember Item 13: Know the Differences Between type and interface Things to Remember Item 14: Use Type Operations and Generics to Avoid Repeating Yourself Things to Remember Item 15: Use Index Signatures for Dynamic Data Things to Remember Item 16: Prefer Arrays, Tuples, and ArrayLike to number Index Signatures Things to Remember Item 17: Use readonly to Avoid Errors Associated with Mutation Things to Remember Item 18: Use Mapped Types to Keep Values in Sync Things to Remember Chapter 3. Type Inference Item 19: Avoid Cluttering Your Code with Inferable Types Things to Remember Item 20: Use Different Variables for Different Types Things to Remember Item 21: Understand Type Widening Things to Remember Item 22: Understand Type Narrowing Things to Remember Item 23: Create Objects All at Once Things to Remember Item 24: Be Consistent in Your Use of Aliases Things to Remember Item 25: Use async Functions Instead of Callbacks for Asynchronous Code Things to Remember Item 26: Understand How Context Is Used in Type Inference Tuple Types Objects Callbacks Things to Remember Item 27: Use Functional Constructs and Libraries to Help Types Flow Things to Remember Chapter 4. Type Design Item 28: Prefer Types That Always Represent Valid States Things to Remember Item 29: Be Liberal in What You Accept and Strict in What You Produce Things to Remember Item 30: Don’t Repeat Type Information in Documentation Things to Remember Item 31: Push Null Values to the Perimeter of Your Types Things to Remember Item 32: Prefer Unions of Interfaces to Interfaces of Unions Things to Remember Item 33: Prefer More Precise Alternatives to String Types Things to Remember Item 34: Prefer Incomplete Types to Inaccurate Types Things to Remember Item 35: Generate Types from APIs and Specs, Not Data Things to Remember Item 36: Name Types Using the Language of Your Problem Domain Things to Remember Item 37: Consider “Brands” for Nominal Typing Things to Remember Chapter 5. Working with any Item 38: Use the Narrowest Possible Scope for any Types Things to Remember Item 39: Prefer More Precise Variants of any to Plain any Things to Remember Item 40: Hide Unsafe Type Assertions in Well-Typed Functions Things to Remember Item 41: Understand Evolving any Things to Remember Item 42: Use unknown Instead of any for Values with an Unknown Type Things to Remember Item 43: Prefer Type-Safe Approaches to Monkey Patching Things to Remember Item 44: Track Your Type Coverage to Prevent Regressions in Type Safety Things to Remember Chapter 6. Types Declarations and @types Item 45: Put TypeScript and @types in devDependencies Things to Remember Item 46: Understand the Three Versions Involved in Type Declarations Things to Remember Item 47: Export All Types That Appear in Public APIs Things to Remember Item 48: Use TSDoc for API Comments Things to Remember Item 49: Provide a Type for this in Callbacks Things to Remember Item 50: Prefer Conditional Types to Overloaded Declarations Things to Remember Item 51: Mirror Types to Sever Dependencies Things to Remember Item 52: Be Aware of the Pitfalls of Testing Types Things to Remember Chapter 7. Writing and Running Your Code Item 53: Prefer ECMAScript Features to TypeScript Features Enums Parameter Properties Namespaces and Triple-Slash Imports Decorators Things to Remember Item 54: Know How to Iterate Over Objects Things to Remember Item 55: Understand the DOM hierarchy Things to Remember Item 56: Don’t Rely on Private to Hide Information Things to Remember Item 57: Use Source Maps to Debug TypeScript Things to Remember Chapter 8. Migrating to TypeScript Item 58: Write Modern JavaScript Use ECMAScript Modules Use Classes Instead of Prototypes Use let/const Instead of var Use for-of or Array Methods Instead of for(;;) Prefer Arrow Functions Over Function Expressions Use Compact Object Literals and Destructuring Assignment Use Default Function Parameters Use async/await Instead of Raw Promises or Callbacks Don’t Put use strict in TypeScript Things to Remember Item 59: Use @ts-check and JSDoc to Experiment with TypeScript Undeclared Globals Unknown Libraries DOM Issues Inaccurate JSDoc Things to Remember Item 60: Use allowJs to Mix TypeScript and JavaScript Things to Remember Item 61: Convert Module by Module Up Your Dependency Graph Undeclared Class Members Values with Changing Types Things to Remember Item 62: Don’t Consider Migration Complete Until You Enable noImplicitAny Things to Remember Index About the Author Colophon