book

Total Typescript

by Matt Pocock, Taylor Bell

April 2026

Intermediate to advanced

432 pages

8h 21m

English

No Starch Press

Read now

Unlock full access

Title Page
Copyright
Dedication
About the Authors and the Technical Reviewers
Foreword
Introduction
The Birth of TypeScriptWhy Now?Who Is This Book For?What We’ll CoverOnline ResourcesThe Book’s Exercises@ts-expect-errorVitest
Part I: Getting Started
1. Kickstart Your Typescript Setup
What’s Different About TypeScript?A High-Level View of How TypeScript WorksTools for TypeScript DevelopmentInstalling Node.jsInstalling the pnpm Package ManagerInstalling TypeScriptSummary
2. Ide Superpowers
AutocompleteManual AutocompleteExercise 2-1: AutocompleteTypeScript Error CheckingRuntime ErrorsNon-Runtime ErrorsWarning LocationsMultiline ErrorsIntrospecting Variables and DeclarationsExercise 2-2: Hovering Over a Function CallJSDoc CommentsExercise 2-3: Adding Documentation for HoversNavigating with Go to Definition and Go to ReferencesRename SymbolAutomatic ImportsQuick FixesRestarting the VS Code ServerWorking in JavaScriptExercise 2-4: Quick Fix RefactoringSummary
3. Typescript in the Development Pipeline
The Problem with TypeScript in the BrowserTranspiling TypeScriptInitializing a TypeScript ProjectRunning tscDoes TypeScript Change Your JavaScript?A Note on Version ControlRunning TypeScript in Watch ModeErrors in the TypeScript CLITypeScript with Modern FrameworksTypeScript as a LinterSummary

Part II: Fundamentals
4. Essential Types and Annotations
Type AnnotationsThe Basic TypesFunction Parameter AnnotationsVariable AnnotationsType InferenceThe any TypeExercise 4-1: Basic Types with Function ParametersExercise 4-2: Annotating Empty ParametersExercise 4-3: The Basic TypesExercise 4-4: The any TypeObject Literal TypesOptional Object PropertiesExercise 4-5: Object Literal TypesExercise 4-6: Optional Property TypesType AliasesSharing Types Across ModulesExercise 4-7: The type KeywordArraysArrays of ObjectsTuplesNamed TuplesExercise 4-8: Array TypeExercise 4-9: Arrays of ObjectsExercise 4-10: TuplesExercise 4-11: Optional Members of TuplesPassing Types to FunctionsPassing Types to SetNot All Functions Can Receive TypesExercise 4-12: Passing Types to MapExercise 4-13: JSON.parse() Can’t Receive Type ArgumentsTyping FunctionsOptional ParametersDefault ParametersFunction Return TypesRest ParametersFunction TypesThe void TypeAsync FunctionsExercise 4-14: Optional Function ParametersExercise 4-15: Default Function ParametersExercise 4-16: Rest ParametersExercise 4-17: Function TypesExercise 4-18: Functions Returning voidExercise 4-19: void vs. undefinedExercise 4-20: Async FunctionsSummary
5. Unions, Literals, and Narrowing
Union TypesDeclaring Union TypesLiteral TypesCombining Unions with UnionsExercise 5-1: string or nullExercise 5-2: Restricting Function ParametersWide and Narrow TypesUnions Are Wider Than Their MembersThe Process of NarrowingExercise 5-3: Narrowing with if StatementsExercise 5-4: Throwing Errors to NarrowExercise 5-5: Using in to NarrowThe unknown and never TypesThe Widest Type: unknownThe Difference Between unknown and anyThe Narrowest Type: neverExercise 5-6: Narrowing Errors with instanceofExercise 5-7: Narrowing unknown to a ValueDiscriminated UnionsThe Problem: The Bag of OptionalsThe Solution: Discriminated UnionsExercise 5-8: Destructuring a Discriminated UnionExercise 5-9: Narrowing a Discriminated Union with a switch StatementExercise 5-10: Discriminated TuplesExercise 5-11: Handling Defaults with a Discriminated UnionSummary
Part III: Objects, Classes, and Mutability
6. Objects
Extending ObjectsIntersection TypesInterfacesIntersections vs. interface extendsTypes vs. InterfacesExercise 6-1: Creating an Intersection TypeExercise 6-2: Extending InterfacesDynamic Object KeysIndex SignaturesThe Record TypeA Combination of Known and Dynamic KeysThe PropertyKey TypeExercise 6-3: Using an Index Signature for Dynamic KeysExercise 6-4: Default Properties with Dynamic KeysExercise 6-5: Restricting Object Keys with RecordsExercise 6-6: Dynamic Key SupportReducing Duplication with Utility TypesThe Partial TypeThe Required TypeThe Pick TypeThe Omit TypeUnion Types with Omit and PickExercise 6-7: Expecting Certain PropertiesExercise 6-8: Updating a ProductSummary
7. Mutability
Mutability and InferenceHow TypeScript Infers letHow TypeScript Infers constObject Property InferenceReadonly Object PropertiesExercise 7-1: Inference with an Array of ObjectsExercise 7-2: Avoiding Array MutationExercise 7-3: An Unsafe TupleDeep Immutability with as constas const vs. Variable Annotationas const vs. Object.freezeExercise 7-4: Inferring Literal Values in ArraysSummary
8. Classes
Creating a ClassAdding a ConstructorAdding Arguments to the ConstructorUsing a Class as a TypeProperties in ClassesClass Property Initializersreadonly Class PropertiesOptional Class Propertiespublic and private PropertiesClass MethodsClass InheritanceExtending a Classprotected PropertiesSafe Overrides with overrideThe implements KeywordAbstract ClassesAbstract MethodsExercise 8-1: Creating a ClassExercise 8-2: Implementing Class MethodsExercise 8-3: Implementing a GetterExercise 8-4: Implementing a SetterExercise 8-5: Extending a ClassSummary
9. Typescript-Only Features
Class Parameter PropertiesEnumsNumeric EnumsString EnumsEnums Are StrangeShould You Use Enums?NamespacesHow Namespaces CompileMerging NamespacesShould You Use Namespaces?Type-Only NamespacesWhen to Use ECMAScript vs. TypeScriptThe Future of TypeScript: Erasable Syntax OnlySummary
Part IV: Working With the Compiler
10. Deriving Types
Deriving Types from Other TypesThe keyof OperatorThe typeof OperatorYou Can’t Create Values from TypesIndexed Access TypesChaining Multiple Indexed Access TypesPassing a Union to an Indexed Access TypeGetting an Object’s Values with keyofUsing as const for JavaScript-Style EnumsEnums Require You to Pass the Enum ValueEnums Are NominalWhich Approach Should You Use?Exercise 10-1: Reducing Key RepetitionExercise 10-2: Deriving a Type from a ValueExercise 10-3: Accessing Specific ValuesExercise 10-4: Unions with Indexed Access TypesExercise 10-5: Extract a Union of All ValuesExercise 10-6: Creating a Union from an as const ArrayDeriving Types from FunctionsParametersReturnTypeAwaitedWhy Derive Types from Functions?Exercise 10-7: A Single Source of TruthExercise 10-8: Typing Based on a Return ValueExercise 10-9: Unwrapping a PromiseTransforming Derived TypesExcludeNonNullableExtractDeriving vs. DecouplingWhen Decoupling Makes SenseWhen Deriving Makes SenseSummary
11. Annotations and Assertions
Annotating Variables vs. ValuesAnnotating Values with satisfiesNarrowing Values with satisfiesAssertions: Forcing the Type of ValuesThe as AssertionThe Non-Null AssertionError Suppression Directives@ts-expect-error@ts-ignore@ts-nocheckSuppressing Errors vs. as anyWhen to Suppress ErrorsWhen You Know More Than TypeScriptWhen TypeScript Is Being “Dumb”When You Don’t Understand the ErrorExercise 11-1: Providing Additional Info to TypeScriptExercise 11-2: Solving Issues with AssertionsExercise 11-3: Enforcing a Valid ConfigurationExercise 11-4: Variable Annotation vs. as vs. satisfiesExercise 11-5: Creating a Deeply Read-Only ObjectSummary
12. The Weird Parts
The Evolving any TypeExcess Property WarningsNo Excess Property Checks on VariablesNo Excess Property Checks When Comparing FunctionsOpen vs. Closed Object TypesFresh and Stale ObjectsObject Keys Are Loosely TypedThe Empty Object TypeThe Type and Value WorldsClasses Can Cross Between WorldsEnums Can Cross Between WorldsThe this Keyword Can Cross Between WorldsNaming Types and Values the SameUsing this in FunctionsArrow Functions Don’t Support thisFunction AssignabilityUnions of Functions Intersect ParametersExercise 12-1: Accepting Anything Except null and undefinedExercise 12-2: Detecting Excess Properties in an ObjectExercise 12-3: Detecting Excess Properties in a FunctionExercise 12-4: Iterating over ObjectsExercise 12-5: Function Parameter ComparisonsExercise 12-6: Unions of Functions with Object ParamsExercise 12-7: Unions of Functions with Incompatible ParametersSummary
Part V: Understanding the Environment
13. Modules, Scripts, and Declaration Files
Understanding Modules and ScriptsModules Have Local ScopeScripts Have Global ScopeTypeScript Guesses Which to UseForcing Modules with moduleDetectionDeclaration FilesDeclaration Files Describe JavaScriptDeclaration Files Can Add to the Global ScopeDeclaration Files Can’t Contain ImplementationsThe declare KeywordTyping Global VariablesScoping Global Variables to One FileMore Ways to declareModule Augmentation vs. Module OverridingDeclaration Files You Don’t ControlTypeScript’s TypesDOM TypesTypes That Ship with LibrariesDefinitelyTypedThe skipLibCheck Config OptionAuthoring Declaration FilesShould You Store Your Types in Declaration Files?Is Using Global Types a Good Idea?Exercise 13-1: Typing a JavaScript ModuleExercise 13-2: Ambient ContextExercise 13-3: Modifying windowExercise 13-4: Modifying process.envSummary
14. Configuring Typescript
Recommended ConfigurationAdditional Configuration OptionsThe Complete Base ConfigurationBase OptionstargetesModuleInteropisolatedModulesStrictness OptionsnoUncheckedIndexedAccessOther Strictness OptionsThe Two Choices for moduleNodeNextPreservenoEmitSource MapsTranspiling Code for Library UseoutDirCreating Declaration FilesDeclaration MapsjsxA Note on Node’s TypeScript SupportManaging Multiple TypeScript ConfigurationsHow TypeScript Finds tsconfig.jsonExtending Configurations--projectProject ReferencesSummary
Part VI: Advanced Application Development
15. Designing Your Types
Generic TypesMultiple Type ParametersAll Type Arguments Must Be ProvidedDefault Type ParametersType Parameter ConstraintsTemplate Literal Types in TypeScriptCombining Template Literal Types with Union TypesTransforming String TypesConditional TypesMapped TypesKey Remapping with asUsing Mapped Types with Union TypesExercise 15-1: Creating a DataShape Type HelperExercise 15-2: Typing PromiseFuncExercise 15-3: Working with the Result TypeExercise 15-4: Constraining the Result TypeExercise 15-5: A Stricter Omit TypeExercise 15-6: Route MatchingExercise 15-7: Sandwich PermutationsExercise 15-8: Attribute GettersExercise 15-9: Renaming Keys in a Mapped TypeSummary
16. Building Powerful Shared Utilities
Generic FunctionsGeneric Function Type Alias vs. Generic TypeMissing or Conflicting Type ArgumentsThere Is No Such Thing as a “Generic”The Problem Generic Functions SolveDebugging the Inferred Type of Generic FunctionsType Parameter DefaultsConstraining Type ParametersType PredicatesAssertion FunctionsFunction OverloadsThe Implementation SignatureFunction Overloads vs. UnionsExercise 16-1: Making a Function GenericExercise 16-2: Default Type ArgumentsExercise 16-3: Inference in Generic FunctionsExercise 16-4: Type Parameter ConstraintsExercise 16-5: Combining Generic Types and FunctionsExercise 16-6: Multiple Type Arguments in a Generic FunctionExercise 16-7: Assertion FunctionsSummary
Index

Content preview from Total Typescript

11 ANNOTATIONS AND ASSERTIONS

A hooded figure holds a glass vial full of a dark bubbling liquid, which emits smoke.

Throughout this book, you’ve been using relatively simple type annotations to specify what types your variables and functions should have, or you’ve allowed TypeScript to infer types on its own. But sometimes you need to lie to TypeScript. In this chapter, you will learn different ways to communicate with the compiler with annotations and assertions: techniques that allow you to affect type inference and force TypeScript to treat values as certain types.

Annotating Variables vs. Values

There’s a difference in TypeScript between annotating variables and annotating values. The way they conflict can be confusing, ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 0642572230289Errata Page

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Total Typescript

by Matt Pocock, Taylor Bell