Typescript: The Complete Developer's Guide

27h 15m 33s
English
Paid

Master Typescript like never before! While other courses might teach you the basic syntax and features of Typescript, this course uniquely demonstrates how to apply Typescript in real-life projects. Learn to build large, successful projects through hands-on examples.

Why Choose This Course?

The Ultimate Guide to Typescript Mastery

Typescript is a 'super-set' of Javascript. If you already know Javascript, you’re ready for this course. Typescript adds crucial features, such as a type system, which lets you catch errors during development, increasing your productivity by detecting bugs early. Beyond types, Typescript helps in structuring extensive codebases and writing genuinely reusable code.

The Challenge of Learning Typescript

Mastering Typescript by only reading the documentation is daunting. Knowing what a 'typed array' or an 'interface' is won't teach you where or how to use these features effectively. This course aims to help you understand why each Typescript feature exists and where exactly to apply them.

The Demand for Typescript Developers

Top companies are eager to hire Typescript developers. Many major web applications today use Typescript, making proficient Typescript engineers very sought-after. Acquiring solid knowledge of Typescript can greatly enhance your employability, adding a rare skill to your portfolio.

Building Your Own Applications

If you're planning on developing your own apps, Typescript will help you structure projects right from the start, preventing accumulation of technical debt. This course emphasizes writing reusable code, focusing on classes and interfaces to create swappable components, allowing easy app reconfiguration with minimal effort.

Learn from Real Industry Experience

Gain insights from the instructor's experience working on one of the largest Typescript projects. Developing plugins for Theia, a large-scale, open-source, browser-based code editor written in Typescript, showcases the true power of Typescript.

Course Testimonials

Don’t just take our word for it—check out our reviews! Engineers like you have found immense success and a new understanding of building scalable web applications.

Course Highlights

This course offers an extensive array of skills. Here's a snapshot of what you'll master:

  • Understand why Composition vs. Inheritance is often misunderstood within the Javascript community.
  • Master the core features of Typescript by working on real-world projects.
  • Build a custom front-end framework from scratch, usable in place of React or Angular for your personal projects.
  • Delve into the complex interplay between classes and interfaces, and learn how these enable incredibly reusable code.
  • Explore deeper into Typescript with decorators, using them to build custom integrations between Typescript and Express.
  • Confidently structure your React and Redux applications by integrating them with Typescript.
  • Bypass documentation for third-party libraries through fluently reading type definition files.
  • Experience the intelligence of Typescript in deeply analyzing your code for errors.

About the Authors

Stephen Grider

Stephen Grider thumbnail
Stephen Grider has been building complex Javascript front ends for top corporations in the San Francisco Bay Area. With an innate ability to simplify complex topics, Stephen has been mentoring engineers beginning their careers in software development for years, and has now expanded that experience onto Udemy, authoring the highest rated React course. He teaches on Udemy to share the knowledge he has gained with other software engineers. Invest in yourself by learning from Stephen's published courses.

udemy

udemy thumbnail
By connecting students all over the world to the best instructors, Udemy is helping individuals reach their goals and pursue their dreams. Udemy is the leading global marketplace for teaching and learning, connecting millions of students to the skills they need to succeed. Udemy helps organizations of all kinds prepare for the ever-evolving future of work. Our curated collection of top-rated business and technical courses gives companies, governments, and nonprofits the power to develop in-house expertise and satisfy employees’ hunger for learning and development.

Watch Online 313 lessons

This is a demo lesson (10:00 remaining)

You can watch up to 10 minutes for free. Subscribe to unlock all 313 lessons in this course and access 10,000+ hours of premium content across all courses.

View Pricing
0:00
/
#1: How to Get Help
All Course Lessons (313)
#Lesson TitleDurationAccess
1
How to Get Help Demo
01:05
2
Typescript Overview
06:20
3
Environment Setup
08:00
4
A First App
04:44
5
Executing Typescript Code
05:04
6
One Quick Change
03:36
7
Catching Errors with Typescript
07:23
8
Catching More Errors!
05:16
9
Do Not Skip - Course Overview
03:37
10
Types
05:13
11
More on Types
05:54
12
Examples of Types
04:50
13
Where Do We Use Types?
00:50
14
Type Annotations and Inference
02:04
15
Annotations with Variables
04:54
16
Object Literal Annotations
06:54
17
Annotations Around Functions
05:57
18
Understanding Inference
03:52
19
The 'Any' Type
07:48
20
Fixing the 'Any' Type
01:50
21
Delayed Initialization
03:06
22
When Inference Doesn't Work
04:38
23
More on Annotations Around Functions
04:57
24
Inference Around Functions
06:09
25
Annotations for Anonymous Functions
01:43
26
Void and Never
02:50
27
Destructuring with Annotations
03:36
28
Annotations Around Objects
07:06
29
Arrays in Typescript
05:06
30
Why Typed Arrays?
04:31
31
Multiple Types in Arrays
02:58
32
When to Use Typed Arrays
00:55
33
Tuples in Typescript
04:06
34
Tuples in Action
05:29
35
Why Tuples?
03:21
36
Interfaces
01:27
37
Long Type Annotations
04:43
38
Fixing Long Annotations with Interfaces
04:37
39
Syntax Around Interfaces
03:32
40
Functions in Interfaces
04:47
41
Code Reuse with Interfaces
04:16
42
General Plan with Interfaces
03:13
43
Classes
03:48
44
Basic Inheritance
03:04
45
Instance Method Modifiers
06:42
46
Fields in Classes
06:19
47
Fields with Inheritance
04:19
48
Where to Use Classes
01:11
49
App Overview
02:46
50
Bundling with Parcel
04:55
51
Project Structure
03:20
52
Generating Random Data
05:30
53
Type Definition Files
05:18
54
Using Type Definition Files
06:21
55
Export Statements in Typescript
05:07
56
Defining a Company
04:44
57
Adding Google Maps Support
07:39
58
Google Maps Integration
04:07
59
Exploring Type Definition Files
12:47
60
Hiding Functionality
06:29
61
Why Use Private Modifiers? Here's Why
08:26
62
Adding Markers
09:19
63
Duplicate Code
02:46
64
One Possible Solution
06:39
65
Restricting Access with Interfaces
05:36
66
Implicit Type Checks
03:27
67
Showing Popup Windows
06:48
68
Updating Interface Definitions
07:12
69
Optional Implements Clauses
06:07
70
App Wrapup
08:09
71
App Overview
01:35
72
Configuring the TS Compiler
07:41
73
Concurrent Compilation and Execution
05:06
74
A Simple Sorting Algorithm
04:48
75
Sorter Scaffolding
03:11
76
Sorting Implementation
05:18
77
Two Huge Issues
07:38
78
Typescript is Really Smart
09:35
79
Type Guards
09:15
80
Why is This Bad?
02:23
81
Extracting Key Logic
07:30
82
Separating Swapping and Comparison
13:59
83
The Big Reveal
04:39
84
Interface Definition
04:49
85
Sorting Arbitrary Collections
11:09
86
Linked List Implementation
24:16
87
Just...One...More...Fix...
04:04
88
Integrating the Sort Method
02:45
89
Issues with Inheritance
06:55
90
Abstract Classes
06:26
91
Why Use Abstract Classes?
04:31
92
Solving All Issues with Abstract Classes
04:01
93
Interfaces vs Abstract Classes
03:24
94
Project Overview
01:46
95
Project Setup
05:58
96
Type Definition Files - Again!
06:46
97
Reading CSV Files
05:06
98
Running an Analysis
04:23
99
Losing Dataset Context
05:13
100
Using Enums
06:20
101
When to Use Enums
07:05
102
Extracting CSV Reading
08:51
103
Data Types
02:34
104
Converting Date Strings to Dates
05:03
105
Converting Row Values
03:38
106
Type Assertions
03:58
107
Describing a Row with a Tuple
07:29
108
Not Done with FileReader Yet!
03:15
109
Understanding Refactor #1
04:36
110
Creating Abstract Classes
04:22
111
Variable Types with Generics
11:29
112
Applying a Type to a Generic Class
04:12
113
Alternate Refactor
04:21
114
Interface-Based Approach
02:05
115
Extracting Match References - Again!
02:34
116
Transforming Data
02:37
117
Updating Reader References
03:40
118
Inheritance vs Composition
03:21
119
More on Inheritance vs Composition
07:23
120
A Huge Misconception Around Composition
14:57
121
Goal Moving Forward
05:17
122
A Composition-Based Approach
06:27
123
Implementing an Analyzer Class
07:25
124
Building the Reporter
05:27
125
Putting It All Together
03:36
126
Generating HTML Reports
05:10
127
One Last Thing!
05:35
128
Oops, My Bad
03:15
129
App Wrapup
03:34
130
More on Generics
05:05
131
Type Inference with Generics
02:50
132
Function Generics
06:06
133
Generic Constraints
05:51
134
App Overview
02:46
135
Parcel Setup
02:43
136
Framework Structure
08:06
137
Designing the User
02:49
138
Retrieving User Properties
06:00
139
Optional Interface Properties
06:38
140
An Eventing System
02:45
141
Listener Support
04:24
142
Storing Event Listeners
05:25
143
Dynamic Array Creation
05:28
144
Triggering Event Callbacks
03:58
145
Adding JSON Server
07:15
146
Understanding REST Conventions
08:53
147
Adding Fetch Functionality
05:13
148
Successfully Fetching Model Data
04:51
149
Saving User Data
08:58
150
Refactoring with Composition
03:49
151
Re-Integrating Eventing
12:50
152
Composition with Nested Objects
02:46
153
A More Complicated Extraction
02:49
154
Options for Adapting Sync
09:33
155
Refactoring Sync
10:42
156
Generic Constraints Around Sync
03:31
157
Connecting Sync Back to User
04:31
158
Optional Properties
07:01
159
Extracting an Attributes Class
03:13
160
The Get Method's Shortcoming
06:19
161
Two Important Rules
07:07
162
An Advanced Generic Constraint
09:37
163
Re-Integrating Attributes
03:19
164
Composition is Delegation
04:40
165
Reminder on Accessors
05:08
166
Passthrough Methods
06:56
167
A Context Issue
08:38
168
Setting Data While Triggering
03:23
169
Fetching User Data
06:27
170
Saving Data
05:39
171
Composition vs Inheritance...Again!
09:03
172
Extracting a Model Class
07:30
173
Extending the User
05:25
174
Final User Refactor
03:49
175
Model Wrapup
03:39
176
Shortened Passthrough Methods
05:40
177
Users Collection
03:27
178
Implementing a Users Collection
03:02
179
Parsing User JSON
07:13
180
Generic User Collection
06:23
181
A Class Method for Collections
02:15
182
View Classes
04:04
183
Building the UserForm
04:46
184
The UserForm's Render Method
03:04
185
Rendering HTML
02:07
186
Defining an Events Map
06:14
187
Binding Event Handlers
07:07
188
Adding Model Properties
04:16
189
Binding Events on Class Name
05:09
190
Adding Methods to the User
04:31
191
Re-Rendering on Model Change
04:57
192
Reading Input Text
04:40
193
Strict Null Checks
06:13
194
Reusable View Logic
12:26
195
Extracting a View Class
04:11
196
Extending with Generic Constraints
12:16
197
Saving Data From a View
03:58
198
UserEdit and UserShow
06:13
199
Nesting with Regions
04:49
200
Mapping Regions
05:41
201
Testing Region Mapping
04:02
202
View Nesting
06:54
203
Collection Views
02:21
204
CollectionView Implementation
16:53
205
App Wrapup
03:36
206
Typescript with JS Libraries
05:35
207
App Overview
03:20
208
Project Setup
03:32
209
Basic Routes with Express
06:32
210
Using an Express Router
03:47
211
Parsing Form Bodies
05:56
212
Why Doesn't Express Play Nicely with TS?
13:56
213
Issues with Type Definition Files
10:17
214
Dealing with Poor Type Defs
06:29
215
Wiring Up Sessions
08:37
216
Checking Login Status
03:20
217
Logging Out
01:10
218
Protecting Routes
04:52
219
A Closer Integration
06:34
220
The Refactoring Process
03:15
221
Prototypes Reminder
08:44
222
Decorators in Typescript
06:49
223
Details on Decorators
07:41
224
Property Descriptors
06:12
225
Wrapping Methods with Descriptors
02:08
226
Decorator Factories
02:47
227
Decorators Around Properties
03:58
228
More on Decorators
07:33
229
A Quick Disclaimer
00:59
230
Project Overview
08:18
231
Why is This Hard?
07:07
232
Solution Overview
05:52
233
Basics of Metadata
08:47
234
Practical Metadata
11:09
235
Let's Refactor!
04:52
236
The 'Get' Decorator
04:26
237
The Controller Decorator
04:21
238
Proof of Concept
05:13
239
A Few Fixups
08:10
240
Defining a RouteBinder
05:05
241
Closed Method Sets with Enums
07:39
242
Metadata Keys
03:44
243
The 'Use' Decorator
08:02
244
Testing Use
03:23
245
Body Validators
05:56
246
Automated Validation
03:26
247
Testing Automated Validation
05:37
248
Fixing Routes
06:04
249
Using Property Descriptors for Type Checking
05:19
250
App Wrapup
01:23
251
React and Redux Overview
06:06
252
App Overview
02:07
253
Generating the App
01:08
254
Simple Components
03:36
255
Interfaces with Props
03:26
256
Handling Component State
02:31
257
Confusing Component State!
10:41
258
Functional Components
03:16
259
Redux Setup
07:32
260
Action Creators with Typescript
06:46
261
Action Types Enum
04:52
262
The Generic Dispatch Function
04:49
263
A Reducer with Enums
06:47
264
Validating Store Structure
05:07
265
Connecting a Component to Redux
06:11
266
Rendering a List
04:37
267
Adding in Delete Functionality
02:55
268
Breaking Out Action Creators
03:22
269
Expressing Actions as Type Union
04:08
270
Type Guards in Reducers
02:49
271
Again, Type Definition Files
03:02
272
Tracking Loading with Component State
04:07
273
App Wrapup
03:39
274
Generating TypeScript Enabled Projects
01:23
275
File Extensions and Starting Up React
04:35
276
Changes with TypeScript
02:34
277
The Big Difference with Props
03:55
278
Explicit Component Type Annotations
05:51
279
Annotations with Children
05:48
280
State with TypeScript
04:42
281
Type Inference with State
05:42
282
Quick Finish to the Example
00:56
283
More on State
04:20
284
Type Unions in State
05:42
285
Inline Event Handlers
03:19
286
Typing Standalone Event Handlers
02:41
287
Handling Drag Events Too!
03:45
288
Applying Types to Refs
05:36
289
More on Refs
04:31
290
App Overview
02:05
291
Project Setup
01:50
292
Redux Store Design
08:54
293
Reducer Setup
08:17
294
Annotating the Return Type
01:27
295
Typing an Action
01:55
296
Separate Interfaces for Actions
04:22
297
Applying Action Interfaces
04:23
298
Adding an Action Type Enum
05:42
299
A Better Way to Organize Code
03:38
300
Adding Action Creators
04:28
301
Adding Request Logic
03:16
302
Applying Typings to Dispatch
02:47
303
Setting Up Exports
04:20
304
Wiring Up to React
03:25
305
Oops... Initial State!
01:04
306
Reminder on Event Types
03:01
307
Calling an Action Creator
03:06
308
Binding Action Creators
04:22
309
Selecting State
04:17
310
Awkward Typings Around React-Redux
04:47
311
Creating a Typed Selector
04:01
312
Consuming Store State
03:03
313
Quick Wrapup - Final Lecture
03:19
Unlock unlimited learning

Get instant access to all 312 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.

Learn more about subscription