Autoplay
Autocomplete
Previous Lesson
Complete and Continue
Typescript: The Complete Developer's Guide [LEGACY]
Getting Started with Typescript
TypeScript: The Complete Developer's Guide (1:34)
Exercise: Meet Your Classmates and Instructor
Typescript Overview (6:19)
Environment Setup (7:59)
A First App (4:42)
Executing Typescript Code (5:03)
One Quick Change (3:35)
Catching Errors with Typescript (7:22)
Catching More Errors! (5:15)
Set Your Learning Streak Goal
What is a Type System?
Do Not Skip - Course Overview (3:35)
Types (5:12)
More on Types (5:53)
Examples of Types (4:48)
Where Do We Use Types? (0:49)
Type Annotations in Action
Type Annotations and Inference (2:03)
Annotations with Variables (4:53)
Object Literal Annotations (6:53)
Annotations Around Functions (5:55)
Understanding Inference (3:50)
The 'Any' Type (7:47)
Fixing the 'Any' Type (1:49)
Delayed Initialization (3:04)
When Inference Doesn't Work (4:36)
Annotations With Functions and Objects
More on Annotations around Functions (4:55)
Inference Around Functions (6:07)
Annotations for Anonymous Functions (1:42)
Void and Never (2:48)
Destructuring with Annotations (3:35)
Annotations Around Objects (7:05)
Implement a New Life System
Mastering Typed Arrays
Arrays in Typescript (5:04)
Why Typed Arrays? (4:30)
Multiple Types in Arrays (2:57)
When to Use Typed Arrays (0:53)
Tuples in Typescript
Tuples in Typescript (4:04)
Tuples in Action (5:27)
Why Tuples? (3:20)
The All-Important Interface
Interfaces (1:26)
Long Type Annotations (4:41)
Fixing Long Annotations with Interfaces (4:36)
Syntax Around Interfaces (3:30)
Functions in Interfaces (4:45)
Code Reuse with Interfaces (4:15)
General Plan with Interfaces (3:11)
Building Functionality with Classes
Classes (3:46)
Basic Inheritance (3:02)
Instance Method Modifiers (6:40)
Fields in Classes (6:18)
Fields with Inheritance (4:18)
Where to Use Classes (1:09)
Design Patterns with Typescript
App Overview (2:44)
Bundling with Parcel (4:54)
Project Structure (3:19)
Generating Random Data (5:29)
Type Definition Files (5:17)
Using Type Definition Files (6:20)
Export Statements in Typescript (5:05)
Defining a Company (4:42)
Note on Generating an API Key
Adding Google Maps Support (7:38)
Google Maps Integration (4:05)
Exploring Type Definition Files (12:46)
Hiding Functionality (6:28)
Why Use Private Modifiers? Here's Why (8:25)
Adding Markers (9:18)
Duplicate Code (2:44)
One Possible Solution (6:37)
Restricting Access with Interfaces (5:35)
Implicit Type Checks (3:26)
Showing Popup Windows (6:47)
Updating Interface Definitions (7:11)
Optional Implements Clauses (6:06)
App Wrapup (8:07)
More on Design Patterns
App Overview (1:34)
Configuring the TS Compiler (7:40)
Concurrent Compilation and Execution (5:05)
A Simple Sorting Algorithm (4:46)
Sorter Scaffolding (3:10)
Sorting Implementation (5:16)
Two Huge Issues (7:37)
Typescript Is Really Smart (9:34)
Type Guards (9:13)
Why is This Bad? (2:22)
Extracting Key Logic (7:29)
Separating Swapping and Comparison (13:57)
The Big Reveal (4:37)
Interface Definition (4:48)
Sorting Arbitrary Collections (11:08)
Linked List Implementation (24:15)
Completed Linked List Code
Just...One...More...Fix... (4:02)
Integrating the Sort Method (2:44)
Issues with Inheritance (6:54)
Abstract Classes (6:25)
Why Use Abstract Classes? (4:29)
Solving All Issues with Abstract Classes (3:59)
Interfaces vs Abstract Classes (3:22)
Reusable Code
Project Overview (1:45)
Project Setup (5:57)
CSV Data
Type Definition Files - Again! (6:44)
Reading CSV Files (5:04)
Running an Analysis (4:21)
Losing Dataset Context (5:11)
Using Enums (6:18)
When to Use Enums (7:03)
Extracting CSV Reading (8:49)
Data Types (2:33)
Converting Date Strings to Dates (5:01)
Converting Row Values (3:36)
Type Assertions (3:56)
Describing a Row with a Tuple (7:27)
Not Done with FileReader Yet! (3:14)
Understanding Refactor #1 (4:34)
Creating Abstract Classes (4:21)
Variable Types with Generics (11:27)
Applying a Type to a Generic Class (4:10)
Alternate Refactor (4:19)
Interface-Based Approach (2:03)
Extracting Match References - Again! (2:32)
Transforming Data (2:35)
Updating Reader References (3:38)
Inheritance vs Composition (3:19)
More on Inheritance vs Composition (7:22)
A Huge Misconception Around Composition (14:56)
Goal Moving Forward (5:15)
A Composition-Based Approach (6:25)
Implementing an Analyzer Class (7:24)
Building the Reporter (5:26)
Putting It All Together (3:35)
Generating HTML Reports (5:08)
One Last Thing! (5:34)
Oops, My Bad! (3:14)
App Wrapup (3:33)
Advanced Generics
More on Generics (5:04)
Type Inference with Generics (2:49)
Function Generics (6:05)
Generic Constraints (5:50)
Let's Build a Web Framework
App Overview (2:45)
Parcel Setup (2:42)
Framework Structure (8:05)
Designing the User (2:48)
Retrieving User Properties (5:58)
Optional Interface Properties (6:36)
An Eventing System (2:44)
Listener Support (4:23)
Storing Event Listeners (5:24)
Dynamic Array Creation (5:26)
Triggering Event Callbacks (3:56)
Adding JSON Server (7:14)
Understanding REST Conventions (8:51)
Adding Fetch Functionality (5:12)
Successfully Fetching Model Data (4:50)
Saving User Data (8:56)
Refactoring with Composition (3:48)
Re-Integrating Eventing (12:49)
Composition with Nested Objects (2:44)
A More Complicated Extraction (2:48)
Options for Adapting Sync (9:31)
Refactoring Sync (10:40)
Generic Constraints Around Sync (3:30)
Connecting Sync Back to User (4:30)
Optional Properties (7:00)
Extracting an Attributes Class (3:12)
The Get Method's Shortcoming (6:18)
Two Important Rules (7:06)
An Advanced Generic Constraint (9:36)
Re-Integrating Attributes (3:17)
Composition is Delegation (4:39)
Reminder on Accessors (5:07)
Passthrough Methods (6:55)
A Context Issue (8:37)
Setting Data While Triggering (3:22)
Fetching User Data (6:26)
Saving Data (5:38)
Composition vs Inheritance...Again! (9:02)
Extracting a Model Class (7:29)
Extending the User (5:24)
Final User Refactor (3:48)
Model Wrapup (3:38)
Shortened Passthrough Methods (5:38)
Users Collection (3:25)
Implementing a Users Collection (3:01)
Parsing User JSON (7:12)
Generic User Collection (6:22)
A Class Method for Collections (2:14)
View Classes (4:03)
Building the UserForm (4:45)
The UserForm's Render Method (3:03)
Rendering HTML (2:06)
Defining an Events Map (6:13)
Binding Event Handlers (7:06)
Adding Model Properties (4:15)
Binding Events on Class Name (5:07)
Adding Methods to the User (4:30)
Re-Rendering on Model Change (4:56)
Reading Input Text (4:39)
Strict Null Checks (6:11)
Reusable View Logic (12:25)
Extracting a View Class (4:10)
Extending with Generic Constraints (12:14)
Saving Data From a View (3:57)
UserEdit and UserShow (6:12)
Nesting with Regions (4:48)
Mapping Regions (5:40)
Testing Region Mapping (4:01)
View Nesting (6:53)
Collection Views (2:20)
CollectionView Implementation (16:52)
App Wrapup (3:35)
Express + Typescript Integration
Typescript with JS Libraries (5:34)
App Overview (3:19)
Project Setup (3:31)
Basic Routes with Express (6:31)
Using an Express Router (3:45)
Parsing Form Bodies (5:55)
Why Doesn't Express Play Nicely with TS? (13:55)
Issues with Type Definition Files (10:16)
Dealing with Poor Type Defs (6:28)
Wiring Up Sessions (8:35)
Checking Login Status (3:19)
Logging Out (1:09)
Protecting Routes (4:51)
A Closer Integration (6:33)
The Refactoring Process (3:14)
Prototypes Reminder (8:43)
Decorators
Decorators in Typescript (6:48)
Details on Decorators (7:40)
Property Descriptors (6:11)
Wrapping Methods with Descriptors (2:07)
Decorator Factories (2:46)
Decorators Around Properties (3:57)
More on Decorators (7:31)
Advanced Express and TS Integration
A Quick Disclaimer (0:58)
Project Overview (8:17)
Why is This Hard? (7:06)
Solution Overview (5:51)
Basics of Metadata (8:46)
Practical Metadata (11:08)
Let's Refactor! (4:51)
The 'Get' Decorator (4:24)
The Controller Decorator (4:20)
Proof of Concept (5:12)
A Few Fixups (8:09)
Defining a RouteBinder (5:03)
Closed Method Sets with Enums (7:38)
Metadata Keys (3:43)
The 'Use' Decorator (8:01)
Testing Use (3:22)
Body Validators (5:55)
Automated Validation (3:25)
Testing Automated Validation (5:36)
Fixing Routes (6:02)
Using Property Descriptors for Type Checking (5:17)
App Wrapup (1:22)
React and Redux with Typescript
React and Redux Overview (6:04)
App Overview (2:05)
Generating the App (1:07)
Simple Components (3:35)
Interfaces with Props (3:24)
Handling Component State (2:29)
Confusing Component State! (10:39)
Functional Components (3:15)
Redux Setup (7:31)
Action Creators with Typescript (6:44)
Action Types Enum (4:51)
The Generic Dispatch Function (4:48)
A Reducer with Enums (6:45)
Validating Store Structure (5:05)
Connecting a Component to Redux (6:09)
Rendering a List (4:36)
Adding in Delete Functionality (2:53)
Breaking Out Action Creators (3:20)
Expressing Actions as Type Union (4:06)
Type Guards in Reducers (2:47)
Wiring up deleteToDo Action
Again, Type Definition Files (3:00)
Tracking Loading with Component State (4:05)
App Wrapup (3:37)
Where To Go From Here ?
Become An Alumni
Endorsements On LinkedIN
Learning Guideline
Web Developer Monthly
The Get Method's Shortcoming
This lecture is available exclusively for ZTM Academy members.
If you're already a member,
you'll need to login
.
Join ZTM To Unlock All Lectures