Deep Dive: TypeScript

Intro to Type Narrowing (01:14)

Narrowing via typeof Type Guard (00:57)

Exercise: typeof (00:40)

Answers: typeof (00:39)

Narrowing via Truthiness (01:49)

Exercise: Narrowing via Truthiness (00:26)

Answers: Narrowing via Truthiness (00:48)

Narrowing via Equality Checking (01:10)

Exercise: Narrowing via Equality Checking (00:10)

Answers: Narrowing via Equality Checking (00:17)

Narrowing via the in Operator (01:28)

Exercise: Narrowing via the in Operator (00:24)

Answer: Narrowing via the in Operator (00:39)

Narrowing via instanceOf (00:38)

Exercise: Narrowing via instanceOf (00:20)

Answers: Narrowing via instanceOf (00:23)

Narrowing via Control Flow (00:33)

Exercise: Narrowing via Control Flow (00:19)

Answers: Narrowing via Control Flow (00:24)

Narrowing via a Type Predicate (03:12)

Exercise: Narrowing via a Type Predicate (00:53)

Answers: Narrowing via a Type Predicate (01:48)

Narrowing via a Discriminated Union (01:47)

Exercise: Narrowing via a Discriminated Union (00:32)

Answers: Narrowing via a Discriminated Union (00:33)

Narrowing via an Assertion Function (01:22)

Exercise: Narrowing via an Assertion Function (00:36)

Answers: Narrowing via an Assertion Function (00:51)

Narrowing via Exhaustiveness Checking (02:50)

Exercise: Narrowing via Exhaustiveness Checking (00:28)

Answers: Narrowing via Exhaustiveness Checking (00:46)

Narrowing via satisfies (04:30)

Exercise: Narrowing via satisfies (00:56)

Answer: Narrowing via satisfies (01:05)

Narrowing via a Type Assertion (03:45)

Exercise: Narrowing via a Type Assertion (00:47)

Answer: Narrowing via a Type Assertion (01:39)

Narrowing via a Non-null Assertion (02:54)

Exercise: Narrowing via a Non-null Assertion (00:49)

Answers: Narrowing via a Non-null Assertion (00:49)

Typing this (06:24)

Exercise: Typing this (00:34)

Answers: Typing this (00:59)

Summary (03:58)

Intro to Utility Types (00:47)

Pick and Omit (02:21)

Exercise: Pick and Omit (00:31)

Answers: Pick and Omit (00:29)

Partial (02:31)

Exercise: Partial (00:40)

Answers: Partial (01:10)

Required (00:27)

Exercise: Required (00:08)

Answers: Required (00:07)

Readonly and ReadonlyArray (01:15)

Exercise: Readonly and ReadonlyArray (00:38)

Answers: Readonly and ReadonlyArray (01:00)

Exclude (00:33)

Exercise: Exclude (00:26)

Answers: Exclude (00:28)

Extract (01:01)

Exercise: Extract (00:11)

Answers: Extract (00:16)

String Manipulation Utilities (02:03)

Exercise: String Manipulation Utilities (00:16)

Answers: String Manipulation Utilities (00:11)

Other Built-in Utility Types (07:02)

Built-in Utility Types Summary (01:25)

Third-Party Utility Types (00:51)

Intro to Implementing Generics (11:06)

Exercise: Implementing Generics (00:49)

Answers: Implementing Generics (03:01)

Generic Function Types (02:06)

Exercise: Generic Function Types (00:18)

Answers: Generic Function Types (00:51)

Generic Interfaces (04:08)

Exercise: Generic Interfaces (00:34)

Answers: Generic Interfaces (00:58)

Generic Classes (01:08)

Exercise: Generic Classes (00:22)

Answers: Generic Classes (01:10)

Generic Constraints via Extends (08:19)

Exercise: Generic Constraints via Extends (01:20)

Answers: Generic Constraints via Extends (03:37)

Const Modifier (04:29)

Exercise: Const Modifier (00:42)

Answers: Const Modifier (00:59)

Default Type Arguments (05:51)

Exercise: Default Type Arguments (01:14)

Answers: Default Type Arguments (02:26)

Pushing Type Params Down (03:22)

Exercise: Pushing Type Params Down (00:06)

Answers: Pushing Type Params Down (00:21)

Generics Best Practices (03:29)

Exercise: Eliminating Needless Type Arguments (00:13)

Answers: Eliminating Needless Type Arguments (00:10)

Intro to Mapped Types (04:13)

Exercise: Implement a Mapped Type (00:27)

Answers: Implement a Mapped Type (00:10)

Template Literal Types (05:08)

Exercise: Template Literal Types (00:29)

Answers: Template Literal Types (01:06)

keyof (04:53)

Exercise: keyof (00:43)

Answers: keyof (00:50)

typeof (03:19)

Exericse: typeof (00:57)

Answers: typeof (01:42)

Indexed Access (09:10)

Exercise: Indexed Access (00:56)

Answers: Indexed Access (02:40)

Conditional Types (07:06)

Exercise: Conditional Types (00:55)

Answers: Conditional Types (02:21)

infer (10:10)

Exercise: infer (00:47)

Answers: infer (01:37)

Looping via the in Operator (07:59)

Exercise: Looping via the in Operator (00:58)

Answers: Looping via the in Operator (01:57)

Remapping Properties via as (06:10)

Exercise: Remapping Properties via as (00:32)

Answers: Remapping Properties via as (01:11)

Recursion in Mapped Types (01:59)

Exercise: Recursion in Mapped Types (00:43)

Answers: Recursion in Mapped Types (01:22)

JS vs TS Syntax Comparision (04:30)

Intro to Utility Types (00:49)

Exercise: MyPartial (00:29)

Answers: MyPartial (00:30)

Exercise: MyRequired (00:30)

Answers: MyRequired (00:39)

Exercise: MyReadonly (00:28)

Answers: MyReadonly (00:42)

Exercise: MyPick (00:51)

Answers: MyPick (00:40)

Exercise: MyRecord (00:23)

Answers: MyRecord (01:31)

Exercise: MyExclude (00:45)

Answers: MyExclude (01:03)

Exercise: MyExtract (00:36)

Answers: MyExtract (00:28)

Exercise: MyOmit (00:48)

Answers: MyOmit (01:04)

Exercise: MyNonNullable (00:28)

Answers: MyNonNullable (01:34)

Exercise: RecursivePartial (01:05)

Answers: RecursivePartial (01:11)

Intro to Runtime Validation (03:34)

Declaring Zod Schemas (05:23)

Exercise: Declaring Zod Schemas (00:31)

Answers: Declaring Zod Schemas (00:50)

Nullable and Optional (00:42)

Zod Utility Types (00:58)

Implementing Custom Validation via Refine (00:42)

Validating a File via Zod (03:01)

Validating at Runtime in Web Apps (06:06)

Validating URL Params via Zod (03:40)

Validating Forms via Zod (01:24)

Validating localStorage via Zod (01:39)

Validating API Responses via Zod (02:35)

Validating Environment Variables via Zod (02:09)

Suggested Next Steps (00:39)

Understanding Decorator Implementations (01:40)

Intro to Decorators (05:04)

Context Parameter (01:58)

Typing Decorators and Invocation Order (02:21)

Decorating Methods (05:26)

Exercise: Decorating Methods (00:14)

Answers: Decorating Methods (00:43)

Decorating Getters and Setters (04:53)

Exercise: Decorating Getters and Setters (00:16)

Answers: Decorating Getters and Setters (00:38)

Decorating Fields (00:59)

Exercise: Decorating Fields (00:27)

Answers: Decorating Fields (01:15)

Decorating Classes (01:38)

Exercise: Decorating Classes (00:25)

Answers: Decorating Classes (00:35)

Implementing Universal Decorators (02:28)

Accepting Arguments via a Decorator (01:48)

Exercise: Accepting Arguments via a Decorator (00:24)

Answers: Accepting Arguments via a Decorator (01:06)

Composing Multiple Decorators (00:41)

Exercise: Composing Multiple Decorators (00:41)

Answers: Composing Multiple Decorators (01:34)

Decorator Tradeoffs (01:32)

Intro (00:26)

Accepting Random Strings via Loose Autocomplete (02:02)

Exercise: Accepting Random Strings via Loose Autocomplete (00:09)

Answer: Accepting Random Strings via Loose Autocomplete (00:18)

Type-only Imports and Exports (06:36)

Named Tuples (01:29)

Exercise: Named Tuples (00:11)

Answer: Named Tuples (00:12)

Typing Object.keys (01:45)

Understanding Optional Keys vs Optional Values (01:11)

Working with Evolving anys (02:42)

Handling Excess Properties (02:58)

Naming Values and Types the Same (02:44)

Working with JS Array Methods (01:57)

Disabling TypeScript via Comments (02:31)

Typing Symbols (04:31)

Simulating Nominal Types via Branded Types (11:19)

Exercise: Simulating Nominal Types via Branded Types (00:42)

Answers: Simulating Nominal Types via Branded Types (01:11)

Testing Types (06:32)

Exercise: Testing Types (00:21)

Answers: Testing Types (00:33)

Using JSDocs to Type JS Files (07:50)

Exercise: Using JSDocs to Type JS Files (00:12)

Answers: Using JSDocs to Type JS Files (01:12)

Intro to tsconfig Settings (00:22)

Avoiding Configuring From Scratch (01:45)

Migrating from JavaScript to TypeScript (03:03)

Configuring TypeScript for the Strictest Settings (10:54)

Debugging via Sourcemaps (02:46)

Optimizing for Performance (04:37)

Intro (00:15)

Linting TypeScript (01:12)

Typing Errors Effectively (05:15)

Generating Types (01:24)

Wrap up and Next Steps (00:40)