Typescript: The Complete Developer’s Guide

Typescript: The Complete Developer’s Guide

English | MP4 | AVC 1280×720 | AAC 44KHz 2ch | 284 lectures (24h 37m) | 9.80 GB

Master Typescript by learning popular design patterns and building complex projects. Includes React and Express!

Composition vs Inheritance? You’ll understand it. Build your own web framework? You’ll do it. Typescript with React/Redux? It’s here!

This is the best course online for mastering Typescript.

Every other course online teaches you the basic syntax and features of Typescript, but only this course will show you how to apply Typescript on real projects, instructing you how to build large, successful projects through example.

Typescript is a ‘super-set’ of Javascript. That means that if you already know Javascript, you are ready to take this course. Typescript adds in several important features to Javascript, including a type system. This type system is designed to help you catch errors during development, rather than when you are running your code. That means you’ll be twice as productive by catching bugs earlier in development. But besides the type system, Typescript also provides several tools for structuring large codebases and writing truly reusable code.

Mastering Typescript by reading the documentation alone is challenging. Although you might know what a ‘typed array’ or an ‘interface’ is, the documentation (and other courses!) don’t show you where to use this features, or how to use them effectively. The goal of this course is to help you understand why each feature of Typescript exists, and exactly where to use them.

Top companies are hungry for Typescript developers. Some of the largest web apps today are being built with Typescript. Employers are scrambling to find engineers who are fluent with this cutting edge system. Solid knowledge of Typescript will make you far more employable, by giving you a unique skill that few other engineers possess.

Planning on building your own apps? Using Typescript will help you structure your project correctly from day one, ensuring that you won’t be crushed under technical debt at some critical stage of your company. In this course, you’ll learn how to write reusable code, with a tremendous emphasis on leveraging classes and interfaces to make swappable ‘widgets’. You will be able to reconfigure your apps on the fly to build wildly different features with only a minimum amount of effort

Learn from someone who has worked on one of the largest Typescript projects around. On professional projects of my own, I have developed plugins for an open-source, browser-based code editor called Theia. The Theia project is absolutely gargantuan in scale, encompassing hundreds of thousands of lines of code, all written in Typescript. This project works only thanks to the power of Typescript.

But don’t just take my word for it – check out the reviews for this course! You’ll see that other engineers, just like yourself, have had great success and acquired a new understanding of how to build scalable web applications.

There is just too much content in this course to summarize in a few short words, but here is a partial listing of the different skills you’ll master:

  • Understand why Composition vs Inheritance is the most mis-understood topic in the Javascript community
  • Master the fundamental features of Typescript by working on real world projects
  • We’ll build a custom front-end framework from scratch that you can use in place of React or Angular on your own personal projects
  • Comprehend the complex interplay between classes and interfaces, and why these two pieces of Typescript enable you to build incredibly reusable code
  • Dive deeper into Typescript with decorators, which we’ll use to build a custom integration between Typescript and Express
  • Structure your React and Redux applications more confidently by understanding how to couple them with Typescript
  • Skip the documentation for third party libraries by fluently reading type definition files
  • Learn just how smart Typescript is by experiencing how deeply it analyzes your code for errors

I learned Typescript years ago by hard trial-and-error. Now you can learn at 5x the speed I did. This is the course that I wish I had when I first got started with Typescript.

What you’ll learn

  • Master design patterns for building large applications
  • Integrate Typescript into React/Redux or Express projects
  • Understand Composition vs Inheritance, and when to use each
  • Write reusable code powered by classes and interfaces
  • Assemble reusable boilerplates for your own Typescript projects
Table of Contents

Getting Started with Typescript
1 How to Get Help
2 Join Our Community
3 Course Resources
4 Typescript Overview
5 Environment Setup
6 A First App
7 Executing Typescript Code
8 One Quick Change
9 Catching Errors with Typescript
10 Catching More Errors

What is a Type System
11 Do Not Skip Course Overview
12 Types
13 More on Types
14 Examples of Types
15 Where Do We Use Types

Type Annotations in Action
16 Type Annotations and Inference
17 Annotations with Variables
18 Object Literal Annotations
19 Annotations Around Functions
20 Understanding Inference
21 The Any Type
22 Fixing the Any Type
23 Delayed Initialization
24 When Inference Doesnt Work

Annotations With Functions and Objects
25 More on Annotations Around Functions
26 Inference Around Functions
27 Annotations for Anonymous Functions
28 Void and Never
29 Destructuring with Annotations
30 Annotations Around Objects

Mastering Typed Arrays
31 Arrays in Typescript
32 Why Typed Arrays
33 Multiple Types in Arrays
34 When to Use Typed Arrays

Tuples in Typescript
35 Tuples in Typescript
36 Tuples in Action
37 Why Tuples

The AllImportant Interface
38 Interfaces
39 Long Type Annotations
40 Fixing Long Annotations with Interfaces
41 Syntax Around Interfaces
42 Functions in Interfaces
43 Code Reuse with Interfaces
44 General Plan with Interfaces

Building Functionality with Classes
45 Classes
46 Basic Inheritance
47 Instance Method Modifiers
48 Fields in Classes
49 Fields with Inheritance
50 Where to Use Classes

Design Patterns with Typescript
51 App Overview
52 Bundling with Parcel
53 Project Structure
54 IMPORTANT Info About Faker Installation
55 Generating Random Data
56 Type Definition Files
57 Using Type Definition Files
58 Export Statements inTypescript
59 Defining a Company
60 Note on Generating an API Key
61 Adding Google Maps Support
62 Required Update for New types Library
63 Google Maps Integration
64 Exploring Type Definition Files
65 Hiding Functionality
66 Why Use Private Modifiers Heres Why
67 Adding Markers
68 Duplicate Code
69 One Possible Solution
70 Restricting Access with Interfaces
71 Implicit Type Checks
72 Showing Popup Windows
73 Updating Interface Definitions
74 Optional Implements Clauses
75 App Wrapup

More on Design Patterns
76 App Overview
77 Configuring the TS Compiler
78 Concurrent Compilation and Execution
79 A Simple Sorting Algorithm
80 Sorter Scaffolding
81 Sorting Implementation
82 Two Huge Issues
83 Typescript is Really Smart
84 Type Guards
85 Why is This Bad
86 Extracting Key Logic
87 Separating Swapping and Comparison
88 The Big Reveal
89 Interface Definition
90 Sorting Arbitrary Collections
91 Linked List Implementation
92 Completed Linked List Code
93 JustOneMoreFix
94 Integrating the Sort Method
95 Issues with Inheritance
96 Abstract Classes
97 Why Use Abstract Classes
98 Solving All Issues with Abstract Classes
99 Interfaces vs Abstract Classes

Reusable Code
100 Project Overview
101 Project Setup
102 CSV Data
103 Type Definition Files Again
104 Reading CSV Files
105 Running an Analysis
106 Losing Dataset Context
107 Using Enums
108 When to Use Enums
109 Extracting CSV Reading
110 Data Types
111 Converting Date Strings to Dates
112 Converting Row Values
113 Type Assertions
114 Describing a Row with a Tuple
115 Not Done with FileReader Yet
116 Understanding Refactor 1
117 Creating Abstract Classes
118 Variable Types with Generics
119 Applying a Type to a Generic Class
120 Alternate Refactor
121 InterfaceBased Approach
122 Extracting Match References Again
123 Transforming Data
124 Updating Reader References
125 Inheritance vs Composition
126 More on Inheritance vs Composition
127 A Huge Misconception Around Composition
128 Goal Moving Forward
129 A CompositionBased Approach
130 Implementing an Analyzer Class
131 Building the Reporter
132 Putting It All Together
133 Generating HTML Reports
134 One Last Thing
135 Oops My Bad
136 App Wrapup

Advanced Generics
137 More on Generics
138 Type Inference with Generics
139 Function Generics
140 Generic Constraints

Lets Build a Web Framework
141 App Overview
142 Parcel Setup
143 Framework Structure
144 Designing the User
145 Retrieving User Properties
146 Optional Interface Properties
147 An Eventing System
148 Listener Support
149 Storing Event Listeners
150 Dynamic Array Creation
151 Triggering Event Callbacks
152 Adding JSON Server
153 Understanding REST Conventions
154 Adding Fetch Functionality
155 Successfully Fetching Model Data
156 Saving User Data
157 Refactoring with Composition
158 ReIntegrating Eventing
159 Composition with Nested Objects
160 A More Complicated Extraction
161 Options for Adapting Sync
162 Refactoring Sync
163 Generic Constraints Around Sync
164 Connecting Sync Back to User
165 Optional Properties
166 Extracting an Attributes Class
167 The Get Methods Shortcoming
168 Two Important Rules
169 An Advanced Generic Constraint
170 ReIntegrating Attributes
171 Composition is Delegation
172 Reminder on Accessors
173 Passthrough Methods
174 A Context Issue
175 Setting Data While Triggering
176 Fetching User Data
177 Saving Data
178 Composition vs InheritanceAgain
179 Extracting a Model Class
180 Extending the User
181 Final User Refactor
182 Model Wrapup
183 Shortened Passthrough Methods
184 Users Collection
185 Implementing a Users Collection
186 Parsing User JSON
187 Generic User Collection
188 A Class Method for Collections
189 View Classes
190 Building the UserForm
191 The UserForms Render Method
192 Rendering HTML
193 Defining an Events Map
194 Binding Event Handlers
195 Adding Model Properties
196 Binding Events on Class Name
197 Adding Methods to the User
198 ReRendering on Model Change
199 Reading Input Text
200 Strict Null Checks
201 Reusable View Logic
202 Extracting a View Class
203 Extending with Generic Constraints
204 Saving Data From a View
205 UserEdit and UserShow
206 Nesting with Regions
207 Mapping Regions
208 Testing Region Mapping
209 View Nesting
210 Collection Views
211 CollectionView Implementation
212 App Wrapup

Express Typescript Integration
213 Typescript with JS Libraries
214 App Overview
215 Project Setup
216 Basic Routes with Express
217 Using an Express Router
218 Parsing Form Bodies
219 Why Doesnt Express Play Nicely with TS
220 Issues with Type Definition Files
221 Dealing with Poor Type Defs
222 Wiring Up Sessions
223 Checking Login Status
224 Logging Out
225 Protecting Routes
226 A Closer Integration
227 The Refactoring Process
228 Prototypes Reminder

229 Note about target environment in tsconfig
230 Decorators in Typescript
231 Details on Decorators
232 Property Descriptors
233 Wrapping Methods with Descriptors
234 Decorator Factories
235 Decorators Around Properties
236 More on Decorators

Advanced Express and TS Integration
237 A Quick Disclaimer
238 Project Overview
239 Why is This Hard
240 Solution Overview
241 Note about target environment in tsconfig
242 Basics of Metadata
243 Practical Metadata
244 Lets Refactor
245 The Get Decorator
246 The Controller Decorator
247 Proof of Concept
248 A Few Fixups
249 Defining a RouteBinder
250 Closed Method Sets with Enums
251 Metadata Keys
252 The Use Decorator
253 Testing Use
254 Body Validators
255 Automated Validation
256 Testing Automated Validation
257 Fixing Routes
258 Using Property Descriptors for Type Checking
259 App Wrapup

React and Redux with Typescript
260 React and Redux Overview
261 App Overview
262 Generating the App
263 Simple Components
264 Interfaces with Props
265 Handling Component State
266 Confusing Component State
267 Functional Components
268 Redux Setup
269 Action Creators with Typescript
270 Action Types Enum
271 The Generic Dispatch Function
272 A Reducer with Enums
273 Validating Store Structure
274 Connecting a Component to Redux
275 Rendering a List
276 Adding in Delete Functionality
277 Breaking Out Action Creators
278 Expressing Actions as Type Union
279 Type Guards in Reducers
280 Wiring up deleteToDo Action
281 Again Type Definition Files
282 Tracking Loading with Component State
283 App Wrapup

284 Bonus