TypeScript Pro Essentials

11h 2m 12s
English
Paid

Course description

You've tested the waters with TypeScript, but deep down you know that you're missing something. You've heard that TypeScript is the answer to all the problems that come with JavaScript– things like clunky autocompletion, runtime errors, and scaling for large projects. So why do you still feel like you're not getting the most out of TypeScript? You keep hitting type-related roadblocks, struggle with configuration, and feel limited by your understanding of the more advanced features. You know it's time to push yourself further, but you're not sure where to start. What you've heard about TypeScript is true. It will help you catch errors before they happen, write cleaner code, and refactor with confidence. But to get there, you need a guide.

Read more about the course

Total TypeScript Pro Essentials is what you've been looking for. This workshop is your map to becoming a TypeScript Wizard.

With over 200 lessons in 17 sections, this workshop will help you build a deep understanding of TypeScript at every level.

From configuration and IDE setup, to advanced type manipulation and best practices for application development, Total TypeScript Pro Essentials has it all. Whether you're brand new to TypeScript or have been using it for years, you are sure to take away valuable knowledge and skills from this workshop.

Here’s what’s included:

Introduction to TypeScript

Kickstart your TypeScript setup with a refresher on the core benefits and concepts of TypeScript: initial configuration, the TypeScript compiler, and type inference.

Follow the recommended setup and extensions for your editor, with a focus on Visual Studio Code, and become familiar with features like navigation, autocompletion, refactoring, and writing self-documenting code.

Understand TypeScript's role in the build process, and why browsers need help understanding the syntax. Structure your project to work nicely with the compiler, and configure for working with modern build tools like Vite and hot module replacement (HMR). Practice setting up type checking in a CI/CD pipeline, preventing errors from reaching production.

TypeScript Fundamentals

Reinforce your foundational skills by working with TypeScript's essential types and annotations. You'll work with function parameters and return types, and model data with object literal types, arrays, and tuples. Write reusable type aliases, correctly type async code, and handle data that comes from external sources. Create more flexible types by using unions, intersections, and interfaces.

Write more expressive code that refines types through several narrowing techniques, and recognize the role of any, never, and unknown in your codebase.

Objects, Classes, and Mutability

Types, interfaces, and classes all have their place in TypeScript. Learn the differences between them, and how to choose the right structure for your needs. Work with dynamic data in objects, and and overcome index signature limitations by using mapped types. Practice using essential type helpers like Pick, Omit, and Partial, and how to build your own helper when you need to.

Develop the mental model for how mutability affects type inference and safety. Recognize the benefits of immutable data structures, and how to work around their quirks.

Apply object-oriented programming principles to your TypeScript code. Understand the role of classes, constructors, and access modifiers, and how to use inheritance and composition to build complex systems that follow real-world design patterns.

Working with the Compiler

Harness the power of the TypeScript compiler to derive types from values, while furthering your understanding of type inference. Create new kinds of type aliases, and use indexed access types to target nested properties.

Recognize when TypeScript needs your help through type annotations and assertions, and the purpose of as, asserts, and satisfies. Apply these techniques to real-world scenarios like working with DOM APIs, parsing JSON, and creating configuration objects.

Understanding the Environment

Distinguish between TypeScript modules and scripts, and prevent global scope pollution. Provide types for JavaScript files and third-party libraries, and understand the role of ambient declarations.

Safely modify global interfaces like Window through declaration merging, work with namespaces like JSX, and understand when to use .d.ts type definition files vs. modules.

Learn best practices for configuring TypeScript's behavior based on the type of project you're working on. Adjust strictness levels, module resolution, and generate type declaration files. Use TypeScript as a linter, and optimize build performance for large projects.

Advanced Application Development

Understand the core differences between CommonJS (CJS) and ES Modules (ESM), and how TypeScript handles module syntax. Learn to use file extensions for guiding module resolution, and configure TypeScript settings for more consistent behavior. Make informed decisions about when to adopt ESM into your projects, and build libraries that support both CJS and ESM consumers for maximum compatibility.

Practice domain modeling by representing real-world concepts and encoding business logic within your types. Establish single sources of truth for type definitions, and create reusable generic type utilities. Enforce stricter type checking with well-placed constraints.

Combine generics and function overloads for maximum flexibility, and create custom type guards and predicates to enhance type inference. Create type-safe APIs with template literal types, mapped types, and custom error types.

Watch Online

Join premium to watch
Go to premium
# Title Duration
1 001 TypeScript's Relationship with JavaScript 04:25
2 002 JavaScript vs. TypeScript in the Build Process 02:55
3 003 Essential Tools for TypeScript Development 01:43
4 004 Set up Node.js and VS Code 01:33
5 005 Installing pnpm for Package Management 03:01
6 006 Installing t 01:19
7 007 Unexpected Token Error in the Browser 00:48
8 008 Browsers Can't Understand TypeScript Syntax 01:20
9 009 Convert a TypeScript File into a JavaScript File 01:06
10 010 Compile TypeScript to JavaScript with the TypeScript CLI 04:05
11 011 Automating TypeScript Compilation 00:48
12 012 Use tsc's Watch Mode to Automatically Compile TypeScript Files 01:24
13 013 Compiling TypeScript Files to a Directory 01:09
14 014 Configure the Output Directory for Compiled Files 01:11
15 015 Use Vite for a Frontend App with TypeScript 01:47
16 016 Configure Vite for a Vanilla TypeScript Project 02:56
17 017 Comparing Vite with tsc 01:03
18 018 TypeScript as a Linter 03:33
19 019 TypeScript in a CI-CD System 03:41
20 020 Should TypeScript Block Your Dev Server_ 04:47
21 021 Quickly Create Scripts with tsx 01:44
22 022 Understanding Function Errors 00:51
23 023 Fixing Errors in the 01:05
24 024 Annotating Empty Parameters 00:37
25 025 Annotating Function Parameters 01:15
26 026 Basic Types in TypeScript 00:56
27 027 TypeScript Basic Types 01:37
28 028 Optional Function Parameters 00:51
29 029 Optional Function Parameters in TypeScript 00:57
30 030 Default Parameters in JavaScript Functions 00:45
31 031 Add a Default Parameter 01:27
32 032 Typing Object Literals 00:43
33 033 Annotating with {} 01:47
34 034 Making Object Property Types Optional 00:52
35 035 Specifying Optional Properties 00:55
36 036 A Single Source of Truth for Type Definitions 00:53
37 037 Creating 01:30
38 038 Add an Array to an Object 00:53
39 039 Two Syntaxes for Arrays 01:46
40 040 Arrays of Objects in TypeScript 00:48
41 041 Representing an Array of Objects 02:12
42 042 Rest Parameters in TypeScript 00:37
43 043 Using Rest Parameters in TypeScript 01:01
44 044 Tuples for Precise Array Structures in TypeScript 01:20
45 045 Using Tuple Syntax in TypeScript 01:22
46 046 Using Optional Tuple Members in TypeScript 00:50
47 047 Working with Optional Tuple Members in TypeScript 01:34
48 048 The Controversial 01:07
49 049 The Dangers of Using _any_ 02:06
50 050 Function Types 01:25
51 051 Function Types for Type Aliases in TypeScript 01:45
52 052 Typing an Event Listener 00:46
53 053 The 01:52
54 054 Restricting 00:50
55 055 Creating Typed Sets 02:16
56 056 Type Checking Maps 00:52
57 057 Adding Types to Maps 01:48
58 058 Debugging JSON Parsing 00:39
59 059 Decoding the JSON.parse Error 01:20
60 060 Typing Fetch API Responses in Async Functions 01:11
61 061 Adding Types to an Async Function 02:27
62 062 Understanding How TypeScript Works in Your IDE 01:16
63 063 Introspecting Variables and Declarations in TypeScript 01:19
64 064 Hovering Over a Function Call 00:28
65 065 Fixing Errors with Hovering 01:32
66 066 Adding Documentation for Hovers 00:33
67 067 TSDoc Comments 01:41
68 068 Manually Triggering Autocomplete 01:19
69 069 The Control + Space Shortcut 01:32
70 070 TypeScript's Approach to Errors 03:43
71 071 Quick Renaming in VS Code 01:51
72 072 Navigating Code with _Go to Definition_ 02:29
73 073 Fast Imports in VS Code 00:53
74 074 Using Autocomplete and Quick Fix to Import Variables 02:12
75 075 Organizing Imports in Large Files 00:39
76 076 The Organize Imports Hotkey in VS Code 01:12
77 077 Quick Fix Refactoring 00:54
78 078 Refactoring with Quick Fixes 01:44
79 079 Automatic Code Formatting with Prettier 02:08
80 080 Restarting the TypeScript Server in VS Code 01:17
81 081 Handling Null Values in TypeScript 01:01
82 082 Introducing Union Types in TypeScript 01:14
83 083 Diving Deeper into Unions and Assignability 00:49
84 084 Restricting Function Parameters 00:55
85 085 Combining Literal & Union Types 01:57
86 086 Literal Type Assignability 01:06
87 087 Combining Union Types in TypeScript 01:29
88 088 Create New Types By Combining Unions 01:08
89 089 How Big Can a Union Be_ 01:11
90 090 Resolving Literal Types to Wider Types 02:21
91 091 Narrowing Unions with 02:12
92 092 Conditional Narrowing in TypeScript 01:09
93 093 Different Approaches for Narrowing Inputs 02:50
94 094 Narrowing with Boolean Won't Work 01:05
95 095 Gotchas When Narrowing a Map in TypeScript 01:00
96 096 Correctly Narrowing a Map in TypeScript 01:41
97 097 Narrowing by Throwing Errors 00:59
98 098 Throwing Errors to Narrow 01:43
99 099 Narrowing with 01:30
100 100 Dynamically Handling Different API Responses in TypeScript 01:41
101 101 Introducing the Unknown Type in TypeScript 02:08
102 102 Dealing with Unknown Errors in TypeScript 01:40
103 103 Narrowing with 02:15
104 104 Narrowing Unknown in a Large Conditional Statement 01:16
105 105 Narrowing Unknown Types in TypeScript 02:56
106 106 Introducing the 02:24
107 107 Solving the Never Type in TypeScript 00:28
108 108 Empty Arrays and the Never Type in TypeScript 01:46
109 109 Narrowing Return Types with TypeScript 01:31
110 110 Returning 02:39
111 111 Narrowing in Different Scopes 01:29
112 112 Narrowing Behavior Across Scopes 04:08
113 113 Handling Separate But Related Types 01:42
114 114 Improving Type Safety with Discriminated Unions in TypeScript 04:17
115 115 Destructuring a Discriminated Union in TypeScript 00:53
116 116 Limitations of Destructuring Discriminated Unions 02:59
117 117 Narrowing a Discriminated Union with a Switch 01:05
118 118 Refactoring to a Switch Statement 02:20
119 119 The switch (true) Pattern in TypeScript 01:21
120 120 Refining Types with Discriminated Unions of Tuples 01:50
121 121 Handle Error and Success States by Narrowing 02:42
122 122 Discriminated Booleans 00:55
123 123 Discriminated Unions with Boolean Discriminators 01:09
124 124 Adding Defaults to a Discriminated Union 00:59
125 125 Handling Optional Parameters in Discriminated Unions 03:52
126 126 Should You Provide Function Return Types_ 04:51
127 127 Extending Objects in TypeScript 02:09
128 128 Use the Intersection Operator to Extend an Object Type in TypeScript 00:49
129 129 Extend an Object Using Interfaces in TypeScript 00:54
130 130 Extending Interfaces to Create Hierarchies in TypeScript 01:50
131 131 Extending Incompatible Properties 00:53
132 132 Comparing Intersections and Interface Extends 03:20
133 133 Comparing Intersection and Interface Extends in TypeScript 02:11
134 134 Allow Dynamic Keys in TypeScript Types 01:00
135 135 Dynamic Keys with Index Signatures and Record Types 03:42
136 136 Allow Any String Key while Supporting Default Properties 00:41
137 137 Add an Index Signature to an Interface 01:33
138 138 Supporting Different Types of Keys in TypeScript 01:46
139 139 Using the PropertyKey Type in TypeScript 00:51
140 140 Restricting Object Keys in TypeScript 01:09
141 141 Records and Mapped Types in TypeScript 02:52
142 142 An Issue with Duplicate Interfaces 00:51
143 143 Declaration Merging in TypeScript Interfaces 03:09
144 144 Working with Partial Data from a Type 01:37
145 145 Manage Subtypes with the Pick Utility Type 02:56
146 146 Exclude a Property from an Interface 00:50
147 147 The Omit Utility Type in TypeScript 01:29
148 148 A Quirk of Omit in TypeScript 01:49
149 149 Understanding Distributive Omit and Pick in TypeScript 03:06
150 150 Excluding Fields from a TypeScript Type 00:55
151 151 The Partial Utility Type in TypeScript 01:08
152 152 Making Type Properties Required in TypeScript 00:48
153 153 Specifying a Type with Shared Properties in TypeScript 01:24
154 154 Common Keys of Unions of Objects in TypeScript 01:28
155 155 Fixing a Type Assignment Inference Error 01:02
156 156 Inference differences between let and const 02:10
157 157 Object Property Inference 00:49
158 158 Understanding Object Properties and Assignability in TypeScript 02:44
159 159 Creating Read-only Properties 00:28
160 160 Specifying Read-only Object Properties 01:03
161 161 Using a Type Helper to Create Read-only Properties 00:52
162 162 Use the Readonly Type Helper to Create Read-Only Objects in TypeScript 00:50
163 163 Deeply Apply Read-only Properties to an Object in TypeScript 01:23
164 164 Using as const to Deeply Apply Read-only Properties to an Object in TypeScript 01:18
165 165 Comparing Object.freeze with as const 00:55
166 166 Deeply Apply Read-only Properties with as const 01:36
167 167 Prevent Array Mutation in TypeScript 00:47
168 168 Two Ways to Create Read-Only Arrays in TypeScript 01:37
169 169 Distinguishing Assignability Between Read-Only and Mutable Arrays 02:02
170 170 Fixing Unsafe Tuples 01:32
171 171 Specifying a readonly Tuple 01:54
172 172 Use the ts-reset Library to Improve Readonly Array Handling in TypeScript 02:11
173 173 Improve Type Inference for an Async Function 01:20
174 174 Two Options for Improving Promise Return Types in TypeScript 02:03
175 175 Infer Strings as Their Literal Types in Objects with as const 01:55
176 176 Classes in TypeScript 00:51
177 177 Creating a Class with Default Properties 02:46
178 178 Implement Class Methods in TypeScript 00:55
179 179 Declaring Methods in TypeScript Classes 01:31
180 180 Creating Constructors for Classes in TypeScript 00:36
181 181 Receive Arguments in Class Constructors 01:42
182 182 Getter Methods in TypeScript 01:01
183 183 Adding a Getter to a Class in TypeScript 01:42
184 184 Public and Private Properties in TypeScript 00:54
185 185 Prevent Access to Private Properties in Classes 01:54
186 186 Setter Methods in TypeScript 00:54
187 187 Add a Setter to a TypeScript Class 01:26
188 188 Extending Classes in TypeScript 01:32
189 189 Inheriting Properties from Other Classes in TypeScript 04:12
190 190 Overriding Methods in TypeScript 03:05
191 191 Ensure a Class Adheres to a Contract 00:47
192 192 Implementing Interfaces in TypeScript with Classes 02:15
193 193 Using 01:10
194 194 Annotating 02:54
195 195 Intro to TypeScript-only Features 00:53
196 196 Parameter Properties in TypeScript 01:43
197 197 Working with Enums in TypeScript 01:46
198 198 Create an Enum in TypeScript 02:51
199 199 String Enums in TypeScript 01:15
200 200 Creating a String Enum in TypeScript 02:28
201 201 Const Enums in TypeScript 04:16
202 202 Namespaces in TypeScript 02:52
203 203 Merging Namespaces in TypeScript 01:31
204 204 Declaration Merging with Interfaces Inside of Namespaces 01:15
205 205 When to Prefer ES Features to TS Features 04:43
206 206 Introduction to Deriving Types in TypeScript 00:44
207 207 The keyof Operator 00:58
208 208 Flowing Types with the keyof Operator 01:23
209 209 The typeof Operator 01:34
210 210 Combine keyof and typeof to Derive Types 02:21
211 211 No Creating Runtime Values from Types 02:04
212 212 Deriving Types with Classes 00:58
213 213 Using typeof with Classes in TypeScript 02:16
214 214 Enums as Types and Values in TypeScript 00:53
215 215 The this Keyword in TypeScript 01:38
216 216 Using the Same Name for Values and Types in TypeScript 02:10
217 217 Creating Types from Complex Function Parameters 01:38
218 218 Use the Parameters Type to Extract Function Parameters 01:39
219 219 Extracting Return Types from Functions 00:34
220 220 Using the ReturnType Type Helper 00:43
221 221 Extract the Return Type from an Async Function 00:47
222 222 Unwrap Promises with the Awaited Type Helper 01:01
223 223 Access Specific Values in an as const Object 01:22
224 224 Use an Indexed Access Type to Access a Property 02:23
225 225 Pass a Union to an Indexed Access Type 00:43
226 226 Unions and Indexed Access Types in TypeScript 01:56
227 227 Extract a Union of All Values from an Object 00:39
228 228 Pass keyof into an Indexed Access Type 02:38
229 229 Create a Union from an as const Array 01:23
230 230 Pass a Primitive to an Indexed Access Type 02:04
231 231 Required vs Unnecessary Annotations 00:42
232 232 Simplifying TypeScript Annotations 04:18
233 233 Provide Additional Information to TypeScript 01:12
234 234 The _as_ and _as any_ Keywords in TypeScript 04:11
235 235 Global Typings use any 01:08
236 236 Preventing 'any' Type Issues from Global Typings 03:18
237 237 The Limits of as in TypeScript 02:22
238 238 Non-null Assertions 01:02
239 239 Adding a Non-null Assertion 03:16
240 240 The @ts-ignore Directive in TypeScript 03:16
241 241 The @ts-expect-error Directive in TypeScript 03:34
242 242 The @ts-nocheck Directive in TypeScript 01:47
243 243 Improve Type Annotations with the satisfies Operator 01:33
244 244 The satisfies Operator in TypeScript 02:29
245 245 Using satisfies with keyof and typeof in TypeScript 00:37
246 246 Specify Type Constraints with the satisfies Operator 01:31
247 247 Comparing as, satisfies, and Variable Annotations in TypeScript 01:30
248 248 When to Use as, satisfies, and Variable Annotations in TypeScript 04:15
249 249 The satisfies Keyword and Deeply Read-Only Objects in TypeScript 01:04
250 250 Combine as const with satisfies for Read-Only Objects 02:01
251 251 Accept Anything Except Null or Undefined 00:52
252 252 The Empty Object Type 03:03
253 253 Typing a Truly Empty Object 01:00
254 254 Handling a Truly Empty Object in TypeScript 02:45
255 255 Excess Property Warnings in TypeScript 01:08
256 256 Techniques for Triggering Excess Property Warnings in TypeScript 04:03
257 257 Excess Properties in Functions 01:11
258 258 Understanding Unexpected Properties in TypeScript 03:15
259 259 Object.keys and Object.entries in TypeScript 03:47
260 260 Iterating Over Object Keys in TypeScript 01:14
261 261 Techniques for Iterating Over Object Keys 03:42
262 262 Evolving Types using the 01:03
263 263 The Evolving 01:44
264 264 The Evolving 01:42
265 265 Function Parameter Comparisons in TypeScript 00:53
266 266 Understanding TypeScript's Function Parameter Comparisons 03:09
267 267 Typing Functions with Object Params 00:53
268 268 Typing Arrays of Functions with Object Params 01:40
269 269 Properly Typing an Object of Functions 01:48
270 270 Handling Union of Functions with Incompatible Types in TypeScript 02:13
271 271 Unions of Function Return Types 01:41
272 272 Annotating the Errors Thrown by a Function 01:13
273 273 Techniques for Annotating Errors in TypeScript 02:15
274 274 Understanding Modules and Scripts in TypeScript 02:27
275 275 Enforcing Module Usage in TypeScript 00:47
276 276 Update tsconfig for Modules 01:12
277 277 Declaration Files in TypeScript 01:40
278 278 Declaration Files Can Be Modules or Scripts 02:27
279 279 Using Declaration Files with JavaScript in TypeScript 00:57
280 280 Typing a JavaScript Module 02:29
281 281 Type Variables Declared Elsewhere 01:16
282 282 Ambient Context and the declare Keyword in TypeScript 02:32
283 283 Global Scope Declarations in TypeScript 00:58
284 284 Understanding Global Declarations in TypeScript 02:39
285 285 Configuring the lib Compiler Option 00:32
286 286 Setting a Compiler Target in tsconfig.json 05:14
287 287 DOM Typing Configuration in TypeScript 00:34
288 288 Update tsconfig.json to include DOM typings 02:16
289 289 Update DOM Typing to Include Iterable 00:39
290 290 Configuring TypeScript for DOM Iteration 01:22
291 291 Modifying TypeScript Global Scope 01:27
292 292 Adding Types to the Global Scope 02:58
293 293 Adding Type Definitions for External Libraries 00:38
294 294 Install Type Definitions from DefinitelyTyped 03:46
295 295 Integrating TypeScript with Node 01:11
296 296 Modifying process.env Typing in TypeScript 02:13
297 297 Updating Node.ProcessEnv 03:17
298 298 Types that Ship With Libraries 01:43
299 299 Declaring Module Types in TypeScript 01:01
300 300 The declare module Syntax in TypeScript 01:42
301 301 Importing and Typing Non-Code Files in TypeScript 00:59
302 302 Use Wildcards in TypeScript Module Declarations 02:29
303 303 TSConfig Options and Declaration Files 00:59
304 304 Understanding skipLibCheck in TypeScript 04:04
305 305 Should You Use Declaration Files to Store Your Types_ 02:30
306 306 Recommended Base Configuration 03:26
307 307 Understanding Isolated Modules in TypeScript 03:27
308 308 Index Access Settings 00:51
309 309 Making Code Safer with No Unchecked Indexed Access 01:30
310 310 Using TypeScript as a Linter 01:11
311 311 The noEmit Option in tsconfig.json 02:06
312 312 Module NodeNext with Extensions 04:22
313 313 The moduleResolution Option in tsconfig.json 05:08
314 314 Enforcing Import Syntax 01:07
315 315 The Verbatim Module Syntax in TSConfig 03:22
316 316 Verbatim Module Syntax Enforces Import Type 02:52
317 317 Understanding lib and target in TypeScript Configuration 03:46
318 318 Bundle Your Code for Library Use 01:20
319 319 Emitting TypeScript Declaration Files 01:05
320 320 Navigate to Source Files Instead of Declaration Files 01:04
321 321 Utilizing Declaration Maps in TypeScript 01:29
322 322 Configure JSX Support in TypeScript 00:37
323 323 Update tsconfig.json to Support JSX 02:31
324 324 Multiple TypeScript Configurations 00:39
325 325 Managing Multiple tsconfig Files 01:19
326 326 Globals are Tied to a Single Configuration 00:51
327 327 Share Configuration Across Multiple tsconfig Files 00:36
328 328 Extending a Base TypeScript Configuration 01:45
329 329 TypeScript Project References 02:38
330 330 Organizing TypeScript Configurations with Project References 06:00
331 331 Designing Your Types 01:14
332 332 Introduction to Generic Types 01:35
333 333 Implement a Generic Type 03:59
334 334 Generics with Multiple Type Parameters 00:51
335 335 Add Multiple Type Arguments to a Generic Type 01:52
336 336 Handle Errors with a Generic Result Type 01:57
337 337 Default Type Parameters in Generics 01:10
338 338 Specify a Default Type Parameter 01:42
339 339 Add Constraints to a Type Parameter 01:11
340 340 Constraining Type Parameters 02:46
341 341 Build a Stricter Omit Type 01:06
342 342 Constrain Keys in a StrictOmit Type Helper 01:38
343 343 Template Literal Types in TypeScript 01:03
344 344 Constrain Strings to Match a Pattern with Template Literal Types 02:10
345 345 Represent All Possible Type Combinations with Template Literals 00:38
346 346 Passing Unions to Template Literal Types 01:59
347 347 Derive Types with Mapped Types 01:04
348 348 Use a Mapped Type to Create a New Object Shape 03:21
349 349 Remapping Keys in TypeScript Map Types 01:13
350 350 Combine the 02:28
351 351 Introduction to the Utilities Folder 01:55
352 352 Generic Functions Without Inference 01:07
353 353 Make a Function Generic 01:54
354 354 Default Parameter Types for Generic Functions 00:51
355 355 Setting a Default Parameter Type for Generic Functions 00:40
356 356 Inference in Generic Functions 01:09
357 357 Enable Generic Functions to Better Infer Types 03:39
358 358 Type Parameter Constraints with Generic Functions 01:22
359 359 Add Constraints to Generic Functions with the extends Keyword 02:45
360 360 Combining Generic Types with Generic Functions 01:16
361 361 Refactoring for Generic Types and Functions 02:15
362 362 Multiple Type Arguments in Generic Functions 01:08
363 363 Type Inference in Function Parameters 04:16
364 364 Using Type Predicates to Create Reusable Type Guards 01:26
365 365 Annotate a Return Type with a Type Predicate 03:23
366 366 Understanding Assertion Functions in TypeScript 01:35
367 367 Asserting Types with Type Predicates 02:09
368 368 Adapt a Function to Handle Different Types of Arguments 01:22
369 369 Implement Function Overloads 04:29

Comments

0 comments

Want to join the conversation?

Sign in to comment

Similar courses

TypeScript Fundamentals

TypeScript Fundamentals

Sources: ultimatecourses.com
Boost your productivity. Dive into the TypeScript language through this comprehensive introduction, and realise the many benefits of adopting static types. We'l
2 hours 54 minutes 15 seconds
Practical Typescript

Practical Typescript

Sources: udemy
Dive into the world of TypeScript with our "Practical TypeScript" course, designed for developers seeking a comprehensive understanding from the basics to...
20 hours 10 minutes 11 seconds
Understanding TypeScript - 2023 Edition

Understanding TypeScript - 2023 Edition

Sources: udemy, Academind Pro
Learn what TypeScript is, why it really is a powerful Addition to JavaScript, what its Features are and how to use it! And whilst doing so, also understand what you're actually ...
14 hours 54 minutes 54 seconds