Effective TypeScript 2nd Edition Book Cover

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.

Effective TypeScript (2nd Edition) guides you through 83 specific ways to improve your use of TypeScript, following the format popularized by Effective C++ and Effective Java. The second edition is thoroughly revised and updated to reflect the way that TypeScript is used 2024. Buy it today!

Already have the Book? Visit the GitHub project to see all of the code snippets from the book in one place. You can also report any errors you've found.

If you're interested in a TypeScript book talk at your company, please reach out via Twitter or email.

Buy 2nd Edition Subscribe

Praise for Effective TypeScript

Effective TypeScript explores the most common questions we see when working with TypeScript and provides practical, results-oriented advice. Regardless of your level of TypeScript experience, you can learn something from this book.

Ryan Cavanaugh, Engineering Lead for TypeScript at Microsoft

This book is packed with practical recipes and must be kept on the desk of every TypeScript eveloper. Even if you think you know TypeScript already, get this book and you won't regret it.

Yakov Fain, Java Champion

I have been working with TypeScript for two years, and with Flow for five. And it happens that I provided technical feedback for this book. It was a joy read. The items in the book provide specific, actionable advice that will help to deepen your understanding of TypeScript, and Dan's explanations are clear and concise. There is a lot of useful information, but my favorite part is Chapter 4, Type Design. Even as an experienced hotshot I learned a number of new things. And the advice sticks with me in my day-to-day work. For example I make an effort to apply types to entire function expressions, and in some cases I do so by using specialized React event handler types that this book pointed me to. Plus Dan convinced me to switch my @type dependencies to devDependencies.

Jesse Hallett, Senior Software Engineer, Originate, Inc.

The book hit me in exactly the right spot. I'm an experienced developer and I've worked with JS on and off for many years, but my structured TS education is limited to the official tutorial. I was able to figure out most of it along the way (TS is intuitive if you have good JS knowledge and realize how it works, Google and SO helped a lot too), but this approach also left me with a lot of gaps in my knowledge, many of which I don't even realize I have. This book excels at plugging such gaps.

Now I have to go and refactor some of my code in the light of what I've learned.

Matěj Zábský

Read more reviews on Goodreads and Amazon.

Recent Blog Posts

See All Posts.

Item 36: Use a Distinct Type for Special Values

It's tempting to use "", 0 or -1 as special values: an empty string might represent text that hasn't loaded yet, or -1 could stand in for a missing number. In TypeScript, this is almost always a bad idea. Special values need to be handled specially, and giving them a distinct type, such as null, allows TypeScript to enforce that you do so. Continue reading »

Now Available: Effective TypeScript, Second Edition

Fully updated, thoroughly revised, now with 50% more book! Continue reading »

The Making of a TypeScript Feature: Inferring Type Predicates

Over the past few months I became a TypeScript contributor and implemented a new feature, type predicate inference, that should be one of the headliners for TypeScript 5.5. This post tells the story of how that happened: why I wanted to contribute to TypeScript, the journey to implementing the feature and getting the PR merged, and what I've learned along the way.

This is not a short read, but it will give you a good sense of what it's like to become a TypeScript contributor and develop a new feature.

Continue reading »

Flow Nodes: How Type Inference Is Implemented

If a variable gets a type but no one looks at it, does it really get a type at all?

This post looks at how type inference is implemented in the TypeScript compiler. It's of some interest to anyone who uses TypeScript and is curious how it works, but it will be most relevant to developers who want to contribute to TypeScript itself.

Continue reading »

The Hidden Side of Type Predicates

Type guards are a powerful tool for improving TypeScript's built-in control flow analysis. This post looks at when it's appropriate to use a type predicate, and in particular what it means when a type predicate returns false. Continue reading »

Effective TypeScript Talk at Etsy (Dec 2020)

Back in 2020 I gave a whole series of Effective TypeScript talks at companies that were interested in the language and the book. The talk that I gave at Etsy in December of 2020 was one of the most fun. It was recorded and is now available to watch. It's about an hour.

Continue reading »

Don't Write Traditional Getter and Setter Methods in JavaScript and TypeScript

Getter and setter methods (getFoo, setFoo) are common in Java and considered a best practice. But they're a code smell that's best avoided in JavaScript and TypeScript because the problem they solve in Java does not exist in JS/TS. This post looks at what that problem is and how you can solve it in TypeScript without imposing the boilerplate of getters and setters.

Continue reading »

Using infer to unpack nested types

TypeScript's infer keyword can infer quite a bit more than you might expect. It's extremely effective at extracting types from the sort of nested structures that you might get from codegen or an API specification. Continue reading »

Overload on the type of this to specialize generics (The Lost Item)

I cut one item from Effective TypeScript during the final stages of editing. Four years later, it's time for it to see the light of day! It's a trick for specializing generic types for certain subtypes of their type parameters. This post shows how it works, why it's indispensible for wrapper types, and also explains why I cut it from the book. Continue reading »

The Saga of the Closure Compiler, and Why TypeScript Won

This post looks at the Closure Compiler, Google's tool from the mid-2000s for adding types to JavaScript. It looks at how its focus on minification led to very different design choices than TypeScript, and how this and a few other factors led to TypeScript becoming the ubiquitous solution for JavaScript + types. The Closure Compiler represents an alternative path that JavaScript could have taken, and it gives us perspective on TypeScript as it exists today. Continue reading »

Older Posts

2021-01-09

For new TypeScript content every ~month, including new examples, sample items, videos and book updates, choose one of these ways to stay in touch:

Subscribe to the Newsletter Follow @danvdk RSS

Table of Contents

In an Effective-style book, the title of each item is a specific piece of advice. This means that the Table of Contents forms a summary of all the advice in the book. If any item piques your curiosity and you want to learn more, order a copy.

Chapter 1: Getting to Know TypeScript

Before we dive into the details, this chapter helps you understand the big picture of TypeScript. What is it and how should you think about it? How does it relate to JavaScript? Are its types nullable or are they not? What's this about any? And ducks?

  1. Understand the Relationship Between TypeScript and JavaScript
  2. Know Which TypeScript Options You're Using
  3. Understand That Code Generation Is Independent of Types
  4. Get Comfortable with Structural Typing
  5. Limit Use of the any Type

Chapter 2: TypeScript’s Type System

This chapter walks you through the nuts and bolts of TypeScript's type system: how to think about it, how to use it, choices you'll need to make, and features you should avoid. TypeScript's type system is surprisingly powerful and able to express things you might not expect a type system to be able to. The items in this chapter will give you a solid foundation to build upon as you write TypeScript and read the rest of this book.

  1. Use Your Editor to Interrogate and Explore the Type System
  2. Think of Types as Sets of Values
  3. Know How to Tell Whether a Symbol Is in the Type Space or Value Space
  4. Prefer Type Annotations to Type Assertions
  5. Avoid Object Wrapper Types (String, Number, Boolean, Symbol, BigInt)
  6. Distinguish Excess Property Checking from Type Checking
  7. Apply Types to Entire Function Expressions When Possible
  8. Know the Differences Between type and interface
  9. Use readonly to Avoid Errors Associated with Mutation
  10. Use Type Operations and Generic Types to Avoid Repeating Yourself
  11. Prefer More Precise Alternatives to Index Signatures
  12. Avoid Numeric Index Signatures

Chapter 3: Type Inference

This chapter shows you some of the problems that can arise with type inference and how to fix them. After reading it, you should have a good understanding of how TypeScript infers types, when you still need to write type declarations, and when it's a good idea to write type declarations even when a type can be inferred.

  1. Avoid Cluttering Your Code with Inferable Types
  2. Use Different Variables for Different Types
  3. Understand How a Variable Gets Its Type
  4. Create Objects All at Once
  5. Understand Type Narrowing
  6. Be Consistent in Your Use of Aliases
  7. Understand How Context Is Used in Type Inference
  8. Understand Evolving Types
  9. Use Functional Constructs and Libraries to Help Types Flow
  10. Use async Functions Instead of Callbacks to Improve Type Flow
  11. Use Classes and Currying to Create New Inference Sites

Chapter 4: Type Design

Code is difficult to understand if you can't see the data or data types on which it operates. This is one of the great advantages of a type system: by writing out types, you make them visible to readers of your code. And this makes your code understandable. Other chapters cover the nuts and bolts of TypeScript types: using them, inferring them, and writing declarations with them. This chapter discusses the design of the types themselves. The examples in this chapter are all written with TypeScript in mind, but most of the ideas are more broadly applicable.

  1. Prefer Types That Always Represent Valid States
  2. Be Liberal in What You Accept and Strict in What You Produce
  3. Don’t Repeat Type Information in Documentation
  4. Avoid Including null or undefined in Type Aliases
  5. Push Null Values to the Perimeter of Your Types
  6. Prefer Unions of Interfaces to Interfaces with Unions
  7. Prefer More Precise Alternatives to String Types
  8. Use a Distinct Type for Special Values
  9. Limit the Use of Optional Properties
  10. Avoid Repeated Parameters of the Same Type
  11. Prefer Unifying Types to Modeling Differences
  12. Prefer Imprecise Types to Inaccurate Types
  13. Name Types Using the Language of Your Problem Domain
  14. Avoid Types Based on Anecdotal Data

Chapter 5: Unsoundness and the any Type

Type systems were traditionally binary affairs: either a language had a fully static type system or a fully dynamic one. TypeScript blurs the line, because its type system is optional and gradual. You can add types to parts of your program but not others. This is essential for migrating existing JavaScript codebases to TypeScript bit by bit. Key to this is the any type, which effectively disables type checking for parts of your code. It is both powerful and prone to abuse. Learning to use any wisely is essential for writing effective TypeScript. This chapter walks you through how to limit the downsides of any while still retaining its benefits.

  1. Use the Narrowest Possible Scope for any Types
  2. Prefer More Precise Variants of any to Plain any
  3. Hide Unsafe Type Assertions in Well-Typed Functions
  4. Use unknown Instead of any for Values with an Unknown Type
  5. Prefer Type-Safe Approaches to Monkey Patching
  6. Avoid Soundness Traps
  7. Track Your Type Coverage to Prevent Regressions in Type Safety

Chapter 6: Generics and Type-Level Programming

TypeScript's type system is designed to model the runtime behavior of JavaScript code. Because JavaScript is so dynamic and permissive, this has pushed TypeScript's type system to develop increasingly powerful capabilities. This includes logic for mapping between types. When you add generic type aliases to the mix, TypeScript's type system becomes powerful enough that you can think of it as its own independent programming language. This chapter will help you decide whether it's necessary to use generic types and presents some alternatives. Used well, type-level code can improve other developers' experiences without their ever needing to know that there's fancy type-level code involved.

  1. Think of Generics as Functions Between Types
  2. Avoid Unnecessary Type Parameters
  3. Prefer Conditional Types to Overload Signatures
  4. Know How to Control the Distribution of Unions over Conditional Types
  5. Use Template Literal Types to Model DSLs and Relationships Between Strings
  6. Write Tests for Your Types
  7. Pay Attention to How Types Display
  8. Prefer Tail-Recursive Generic Types
  9. Consider Codegen as an Alternative to Complex Types

Chapter 7: TypeScript Recipes

As the TypeScript community has grown, developers have come up with more and more tricks for solving specific problems. Some of these "recipes" leverage TypeScript's type checker to catch new categories of mistakes, such as values getting out of sync or nonexhaustive conditionals. Others are tricks for modeling patterns that TypeScript struggles with on its own: iterating over objects, filtering null values from Arrays, or modeling variadic functions. By applying the recipes in this chapter, you'll help TypeScript catch more real problems with fewer false positives.

  1. Use never Types to Perform Exhaustiveness Checking
  2. Know How to Iterate Over Objects
  3. Use Record Types to Keep Values in Sync
  4. Use Rest Parameters and Tuple Types to Model Variadic Functions
  5. Use Optional never Properties to Model Exclusive Or
  6. Consider Brands for Nominal Typing

Chapter 8: Type Declarations and @types

Dependency management can be confusing in any language, and TypeScript is no exception. This chapter will help you build a mental model for how dependencies work in TypeScript and show you how to work through some of the issues that can come up with them. It will also help you craft your own type declaration files to publish and share with others. By writing great type declarations, you can help not just your own project but the entire TypeScript community.

  1. Put TypeScript and @types in devDependencies
  2. Understand the Three Versions Involved in Type Declarations
  3. Export All Types That Appear in Public APIs
  4. Use TSDoc for API Comments
  5. Provide a Type for this in Callbacks if It's Part of Their API
  6. Mirror Types to Sever Dependencies
  7. Use Module Augmentation to Improve Types

Chapter 9: Writing and Running Your Code

This chapter is a bit of a grab bag: it covers some issues that come up in writing code (not types) as well as issues you may run into when you run your code.

  1. Prefer ECMAScript Features to TypeScript Features
  2. Use Source Maps to Debug TypeScript
  3. Know How to Reconstruct Types at Runtime
  4. Understand the DOM Hierarchy
  5. Create an Accurate Model of Your Environment
  6. Understand the Relationship Between Type Checking and Unit Testing
  7. Pay Attention to Compiler Performance

Chapter 10: Modernization and Migration

You've heard that TypeScript is great. You also know from painful experience that maintaining your 15-year-old, 100,000-line JavaScript library isn't. If only it could become a TypeScript library! This chapter offers some advice about migrating your JavaScript project to TypeScript without losing your sanity and abandoning the effort.

  1. Write Modern JavaScript
  2. Use @ts-check and JSDoc to Experiment with TypeScript
  3. Use allowJs to Mix TypeScript and JavaScript
  4. Convert Module by Module Up Your Dependency Graph
  5. Don't Consider Migration Complete Until You Enable noImplicitAny

About the Author

Dan Vanderkam

Dan Vanderkam is an independent software developer based in upstate New York. He was previously a principal software engineer at Sidewalk Labs and a senior staff software engineer at Google. He also worked on open source genome visualizations at Mount Sinai's Icahn School of Medicine, as well as on Google search features used by billions of people (search for sunset nyc or population of france). He has a long history of working on open source projects, including the popular dygraphs library and source-map-explorer, a tool for visualizing JavaScript code size.

When he's not programming, Dan enjoys rock climbing at the nearby Shawangunk Ridge, hiking in the Catskills, and birdwatching all around the world. He also writes on Medium and at danvk.org. He earned his bachelor's in Computer Science from Rice University in Houston, Texas, and lives in Wallkill, New York.

Follow @danvdk Subscribe