Typescript: The Complete Developer’s Guide

Typescript: The Complete Developer’s Guide
Typescript: The Complete Developer’s Guide
English | MP4 | AVC 1280×720 | AAC 48KHz 2ch | 24.5 Hours | 10.4 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 Typescript Overview
3 Environment Setup
4 A First App
5 Executing Typescript Code
6 One Quick Change
7 Catching Errors with Typescript
8 Catching More Errors!

What is a Type System?
9 Do Not Skip – Course Overview
10 Types
11 More on Types
12 Examples of Types
13 Where Do We Use Types?

Type Annotations in Action
14 Type Annotations and Inference
15 Annotations with Variables
16 Object Literal Annotations
17 Annotations Around Functions
18 Understanding Inference
19 The ‘Any’ Type
20 Fixing the ‘Any’ Type
21 Delayed Initialization
22 When Inference Doesn’t Work

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

Mastering Typed Arrays
29 Arrays in Typescript
30 Why Typed Arrays?
31 Multiple Types in Arrays
32 When to Use Typed Arrays

Tuples in Typescript
33 Tuples in Typescript
34 Tuples in Action
35 Why Tuples?

The All-Important Interface
36 Interfaces
37 Long Type Annotations
38 Fixing Long Annotations with Interfaces
39 Syntax Around Interfaces
40 Functions in Interfaces
41 Code Reuse with Interfaces
42 General Plan with Interfaces

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

Design Patterns with Typescript
49 App Overview
50 Bundling with Parcel
51 Project Structure
52 Generating Random Data
53 Type Definition Files
54 Using Type Definition Files
55 Export Statements inTypescript
56 Defining a Company
57 Note on Generating an API Key
58 Adding Google Maps Support
59 Google Maps Integration
60 Exploring Type Definition Files
61 Hiding Functionality
62 Why Use Private Modifiers? Here’s Why
63 Adding Markers
64 Duplicate Code
65 One Possible Solution
66 Restricting Access with Interfaces
67 Implicit Type Checks
68 Showing Popup Windows
69 Updating Interface Definitions
70 Optional Implements Clauses
71 App Wrapup

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

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

Advanced Generics
133 More on Generics
134 Type Inference with Generics
135 Function Generics
136 Generic Constraints

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

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

Decorators
225 Decorators in Typescript
226 Details on Decorators
227 Property Descriptors
228 Wrapping Methods with Descriptors
229 Decorator Factories
230 Decorators Around Properties
231 More on Decorators

Advanced Express and TS Integration
232 A Quick Disclaimer
233 Project Overview
234 Why is This Hard?
235 Solution Overview
236 Basics of Metadata
237 Practical Metadata
238 Let’s Refactor!
239 The ‘Get’ Decorator
240 The Controller Decorator
241 Proof of Concept
242 A Few Fixups
243 Defining a RouteBinder
244 Closed Method Sets with Enums
245 Metadata Keys
246 The ‘Use’ Decorator
247 Testing Use
248 Body Validators
249 Automated Validation
250 Testing Automated Validation
251 Fixing Routes
252 Using Property Descriptors for Type Checking
253 App Wrapup

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