Mô tả

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.

Bạn sẽ học được gì

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

Yêu cầu

  • Basic knowledge of ES2015 Javascript

Nội dung khoá học

20 sections

Getting Started with Typescript

11 lectures
How to Get Help
01:04
Join Our Community!
00:07
Course Resources
00:38
Typescript Overview
06:19
Environment Setup
07:59
Important Axios Version Information
00:12
A First App
04:43
Executing Typescript Code
05:03
One Quick Change
03:35
Catching Errors with Typescript
07:22
Catching More Errors!
05:15

What is a Type System?

6 lectures
Do Not Skip - Course Overview
03:35
Types
05:12
More on Types
05:53
Examples of Types
04:48
Where Do We Use Types?
00:49
Types
3 questions

Type Annotations in Action

9 lectures
Type Annotations and Inference
02:03
Annotations with Variables
04:53
Object Literal Annotations
06:53
Annotations Around Functions
05:55
Understanding Inference
03:51
The 'Any' Type
07:47
Fixing the 'Any' Type
01:49
Delayed Initialization
03:05
When Inference Doesn't Work
04:37

Annotations With Functions and Objects

6 lectures
More on Annotations Around Functions
04:56
Inference Around Functions
06:08
Annotations for Anonymous Functions
01:42
Void and Never
02:49
Destructuring with Annotations
03:35
Annotations Around Objects
07:05

Mastering Typed Arrays

4 lectures
Arrays in Typescript
05:05
Why Typed Arrays?
04:30
Multiple Types in Arrays
02:57
When to Use Typed Arrays
00:54

Tuples in Typescript

3 lectures
Tuples in Typescript
04:04
Tuples in Action
05:28
Why Tuples?
03:20

The All-Important Interface

8 lectures
Interfaces
01:26
Long Type Annotations
04:42
Fixing Long Annotations with Interfaces
04:36
Syntax Around Interfaces
03:31
Functions in Interfaces
04:46
Code Reuse with Interfaces
04:15
General Plan with Interfaces
03:12
Interfaces
5 questions

Building Functionality with Classes

6 lectures
Classes
03:47
Basic Inheritance
03:03
Instance Method Modifiers
06:41
Fields in Classes
06:18
Fields with Inheritance
04:18
Where to Use Classes
01:09

Design Patterns with Typescript

26 lectures
Updated Parcel Instructions
00:13
App Overview
02:45
Bundling with Parcel
04:54
Project Structure
03:19
IMPORTANT Info About Faker Installation
00:25
Generating Random Data
05:29
Type Definition Files
05:17
Using Type Definition Files
06:20
Export Statements in Typescript
05:06
Defining a Company
04:43
Note on Generating an API Key
00:27
Adding Google Maps Support
07:38
Required Update for New @types Library
00:18
Google Maps Integration
04:06
Exploring Type Definition Files
12:46
Hiding Functionality
06:28
Why Use Private Modifiers? Here's Why
08:25
Adding Markers
09:18
Duplicate Code
02:45
One Possible Solution
06:38
Restricting Access with Interfaces
05:35
Implicit Type Checks
03:26
Showing Popup Windows
06:47
Updating Interface Definitions
07:11
Optional Implements Clauses
06:06
App Wrapup
08:08

More on Design Patterns

24 lectures
App Overview
01:34
Configuring the TS Compiler
07:40
Concurrent Compilation and Execution
05:05
A Simple Sorting Algorithm
04:47
Sorter Scaffolding
03:10
Sorting Implementation
05:17
Two Huge Issues
07:37
Typescript is Really Smart
09:34
Type Guards
09:13
Why is This Bad?
02:22
Extracting Key Logic
07:29
Separating Swapping and Comparison
13:58
The Big Reveal
04:38
Interface Definition
04:48
Sorting Arbitrary Collections
11:08
Linked List Implementation
24:15
Completed Linked List Code
00:01
Just...One...More...Fix...
04:03
Integrating the Sort Method
02:44
Issues with Inheritance
06:54
Abstract Classes
06:25
Why Use Abstract Classes?
04:30
Solving All Issues with Abstract Classes
03:59
Interfaces vs Abstract Classes
03:23

Reusable Code

37 lectures
Project Overview
01:45
Project Setup
05:57
CSV Data
00:01
Type Definition Files - Again!
06:45
Reading CSV Files
05:04
Running an Analysis
04:22
Losing Dataset Context
05:12
Using Enums
06:19
When to Use Enums
07:04
Extracting CSV Reading
08:50
Data Types
02:33
Converting Date Strings to Dates
05:02
Converting Row Values
03:37
Type Assertions
03:57
Describing a Row with a Tuple
07:28
Not Done with FileReader Yet!
03:14
Understanding Refactor #1
04:35
Creating Abstract Classes
04:21
Variable Types with Generics
11:27
Applying a Type to a Generic Class
04:11
Alternate Refactor
04:20
Interface-Based Approach
02:04
Extracting Match References - Again!
02:33
Transforming Data
02:36
Updating Reader References
03:39
Inheritance vs Composition
03:20
More on Inheritance vs Composition
07:22
A Huge Misconception Around Composition
14:56
Goal Moving Forward
05:16
A Composition-Based Approach
06:26
Implementing an Analyzer Class
07:24
Building the Reporter
05:26
Putting It All Together
03:35
Generating HTML Reports
05:09
One Last Thing!
05:34
Oops, My Bad
03:14
App Wrapup
03:33

Advanced Generics

4 lectures
More on Generics
05:04
Type Inference with Generics
02:49
Function Generics
06:05
Generic Constraints
05:50

Let's Build a Web Framework

76 lectures
App Overview
02:45
Reminder on Using Parcel with npx
00:20
Parcel Setup
02:42
Framework Structure
08:05
Designing the User
02:48
Retrieving User Properties
05:59
Optional Interface Properties
06:36
An Eventing System
02:44
Listener Support
04:23
Storing Event Listeners
05:24
Dynamic Array Creation
05:27
Triggering Event Callbacks
03:56
Small Update for JSON server and Parcel Start Script
00:21
Adding JSON Server
07:14
Understanding REST Conventions
08:52
Adding Fetch Functionality
05:12
Successfully Fetching Model Data
04:50
Saving User Data
08:57
Refactoring with Composition
03:48
Re-Integrating Eventing
12:49
Composition with Nested Objects
02:45
A More Complicated Extraction
02:48
Options for Adapting Sync
09:31
Refactoring Sync
10:40
Generic Constraints Around Sync
03:30
Connecting Sync Back to User
04:29
Optional Properties
07:00
No overload matches this call - this.data
00:31
Extracting an Attributes Class
03:12
The Get Method's Shortcoming
06:18
Two Important Rules
07:06
An Advanced Generic Constraint
09:35
Re-Integrating Attributes
03:17
Composition is Delegation
04:39
Reminder on Accessors
05:07
Passthrough Methods
06:55
A Context Issue
08:37
Setting Data While Triggering
03:22
Fetching User Data
06:26
Saving Data
05:38
Composition vs Inheritance...Again!
09:02
Extracting a Model Class
07:29
Extending the User
05:24
Final User Refactor
03:48
Model Wrapup
03:38
Shortened Passthrough Methods
05:38
Users Collection
03:25
Implementing a Users Collection
03:01
Parsing User JSON
07:12
Generic User Collection
06:22
A Class Method for Collections
02:14
View Classes
04:03
Building the UserForm
04:45
The UserForm's Render Method
03:03
Rendering HTML
02:06
Defining an Events Map
06:13
Binding Event Handlers
07:06
Adding Model Properties
04:15
Binding Events on Class Name
05:07
Adding Methods to the User
04:30
Re-Rendering on Model Change
04:56
Reading Input Text
04:39
Strict Null Checks
06:11
Reusable View Logic
12:25
Extracting a View Class
04:10
Type 'K' does not satisfy the constraint 'HasId'.ts
00:32
Extending with Generic Constraints
12:14
Saving Data From a View
03:57
UserEdit and UserShow
06:12
Nesting with Regions
04:48
Mapping Regions
05:40
Testing Region Mapping
04:00
View Nesting
06:53
Collection Views
02:20
CollectionView Implementation
16:52
App Wrapup
03:35

Express + Typescript Integration

16 lectures
Typescript with JS Libraries
05:34
App Overview
03:19
Project Setup
03:31
Basic Routes with Express
06:31
Using an Express Router
03:45
Parsing Form Bodies
05:55
Why Doesn't Express Play Nicely with TS?
13:55
Issues with Type Definition Files
10:16
Dealing with Poor Type Defs
06:28
Wiring Up Sessions
08:35
Checking Login Status
03:19
Logging Out
01:09
Protecting Routes
04:51
A Closer Integration
06:33
The Refactoring Process
03:14
Prototypes Reminder
08:43

Decorators

8 lectures
Note about target environment in tsconfig
00:20
Decorators in Typescript
06:48
Details on Decorators
07:40
Property Descriptors
06:11
Wrapping Methods with Descriptors
02:07
Decorator Factories
02:46
Decorators Around Properties
03:57
More on Decorators
07:31

Advanced Express and TS Integration

24 lectures
A Quick Disclaimer
00:58
Project Overview
08:17
Why is This Hard?
07:06
Solution Overview
05:51
Note about target environment in tsconfig
00:19
Basics of Metadata
08:46
Practical Metadata
11:08
Let's Refactor!
04:51
The 'Get' Decorator
04:24
ES2016 Fix for Controller Decorator
00:29
The Controller Decorator
04:20
Proof of Concept
05:12
A Few Fixups
08:09
Defining a RouteBinder
05:03
Closed Method Sets with Enums
07:38
Metadata Keys
03:43
The 'Use' Decorator
08:01
Testing Use
03:22
Body Validators
05:55
Automated Validation
03:25
Testing Automated Validation
05:36
Fixing Routes
06:02
Using Property Descriptors for Type Checking
05:17
App Wrapup
01:22

React and Redux Class Components with Typescript

26 lectures
React and Redux Overview
06:05
App Overview
02:06
Generating the App
01:07
ReactDOM warning with React v18
00:31
Simple Components
03:35
Interfaces with Props
03:25
Handling Component State
02:30
Confusing Component State!
10:40
Functional Components
03:15
createStore Strikethrough in Code Editor
00:22
Redux Setup
07:31
Action Creators with Typescript
06:45
Action Types Enum
04:51
The Generic Dispatch Function
04:48
A Reducer with Enums
06:46
Validating Store Structure
05:06
Connecting a Component to Redux
06:10
Rendering a List
04:36
Adding in Delete Functionality
02:53
Breaking Out Action Creators
03:20
Expressing Actions as Type Union
04:07
Type Guards in Reducers
02:48
Wiring up deleteToDo Action
01:07
Again, Type Definition Files
03:01
Tracking Loading with Component State
04:06
App Wrapup
03:38

React Functional Components with TypeScript

18 lectures
Generating TypeScript Enabled Projects
01:22
ReactDOM warning with React v18
00:33
File Extensions and Starting Up React
04:34
Changes with TypeScript
02:33
The Big Difference with Props
03:53
Explicit Component Type Annotations
05:50
Property 'children' does not exist
00:19
Annotations with Children
05:47
State with TypeScript
04:41
Type Inference with State
05:41
Quick Finish to the Example
00:55
More on State
04:19
Type Unions in State
05:41
Inline Event Handlers
03:18
Typing Standalone Event Handlers
02:39
Handling Drag Events Too!
03:43
Applying Types to Refs
05:35
More on Refs
04:29

Redux with Functional Components and TypeScript

28 lectures
App Overview
02:04
Updated Install Command and Versions for React 18
00:11
Project Setup
01:49
Redux Store Design
08:53
Reducer Setup
08:16
Annotating the Return Type
01:26
Typing an Action
01:54
Separate Interfaces for Actions
04:21
Applying Action Interfaces
04:22
Adding an Action Type Enum
05:41
A Better Way to Organize Code
03:36
Small Update for Try / Catch Block
00:15
Adding Action Creators
04:27
Adding Request Logic
03:14
Applying Typings to Dispatch
02:46
createStore Strikethrough in Code Editor
00:22
Setting Up Exports
04:19
Wiring Up to React
03:24
Oops... Initial State!
01:03
Reminder on Event Types
02:59
TypeScript Error When Dispatching Action
00:24
Calling an Action Creator
03:05
Binding Action Creators
04:21
Selecting State
04:16
Awkward Typings Around React-Redux
04:46
Creating a Typed Selector
04:00
Consuming Store State
03:02
Quick Wrapup - Final Lecture
03:18

Extras

1 lectures
Bonus!
00:33

Đánh giá của học viên

Chưa có đánh giá
Course Rating
5
0%
4
0%
3
0%
2
0%
1
0%

Bình luận khách hàng

Viết Bình Luận

Bạn đánh giá khoá học này thế nào?

image

Đăng ký get khoá học Udemy - Unica - Gitiho giá chỉ 50k!

Get khoá học giá rẻ ngay trước khi bị fix.