Understanding TypeScript – 2022 Edition

Understanding TypeScript – 2022 Edition

English | MP4 | AVC 1280×720 | AAC 48KHz 2ch | 198 lectures (14h 58m) | 3.68 GB

Don’t limit the Usage of TypeScript to Angular! Learn the Basics, its Features, Workflows and how to use it!

This course was completely updated, reflects the latest version of TypeScript and incorporated tons of student feedback.

Most People know TypeScript from Angular 2+. It’s the Language you have to use there, right?

It’s more than that!

Learn what TypeScript is, why it really is a powerful Addition to JavaScript, what its Features are and how to use it! And whilst doing so, also understand what you’re actually doing in your Angular 2+ Code.

This Course takes you from the very Basics and its most important Feature (Types!) to the Point where you’re able to use TypeScript in any of your Projects. ReactJS Projects included!

As TypeScript is developed by Microsoft and strongly advertised used by Angular 2+ (Google), it’s here to stay.

Gain an Edge today and be amongst the First to really understand TypeScript!

A Journey into the Future

As TypeScript code can be compiled to ES5, you’ll be amazed by the many next-gen Features you can start using Today. Be it ES6 Features like Destructuring or Arrow Functions, Decorators, Generics and Interfaces or Modules – TypeScript has them all!

In this Course, we’ll not stop after the Basics. You will learn about more advanced Features and also how to set up Workflows with TypeScript. This includes a TypeScript-only Workflow as well as a Webpack Workflow.

You’ll also learn that you’re not limited to Angular 2+ or plain JavaScript/ TypeScript Projects. A complete Module covers how to use TypeScript with ReactJS to benefit from its Features, there, too.

Practice what you Learn

Watching Videos is a great Way to Learn. And to a lot of Students, it’s the best Way. If you also want to practice the Things you learn, this Course offers you Exercises (and Solutions) in many of the Course Modules.

So much Content!

I’m not a Fan of these Courses which teach you the Basics and then leave you alone. In this Course you’ll get insights into:

  • Types and how to use them
  • How the TypeScript Compiler works
  • ES6 Features in TypeScript
  • Classes in TypeScript
  • Namespaces and Modules
  • Interfaces
  • Generics
  • Decorators
  • How to integrate Third-Party JavaScript Libraries into your TypeScript Project
  • How to set up a TypeScript project with Webpack
  • Or how to set up a plain-TypeScript Workflow
  • How to use TypeScript together with ReactJS
  • How to use TypeScript together with Node/ Express
  • Real projects and use-cases!

What you’ll learn

  • Use TypeScript and its Features like Types, ES6 Support, Classes, Modules, Interfaces and much more in any of their Projects
  • Understand what TypeScript really is about and how it works
  • Why TypeScript offers a real advantage over vanilla JavaScript
  • Learn TypeScript both in theory as well as applied to real use-cases and projects
  • Learn how to combine TypeScript with ReactJS or NodeJS / Express
Table of Contents

Getting Started
1 Welcome to the Course
2 What Is TypeScript & Why Should You Use It
3 Join Our Learning Community
4 Installing & Using TypeScript
5 TypeScript Advantages – Overview
6 Course Outline
7 How To Get The Most Out Of The Course
8 Setting Up A Code Editor IDE
9 The Course Project Setup

TypeScript Basics & Basic Types
10 Module Introduction
11 Using Types
12 TypeScript Types vs JavaScript Types
13 Important Type Casing
14 Working with Numbers, Strings & Booleans
15 Type Assignment & Type Inference
16 Object Types
17 Nested Objects & Types
18 Arrays Types
19 Working with Tuples
20 Working with Enums
21 The any Type
22 Union Types
23 Literal Types
24 Type Aliases Custom Types
25 Type Aliases & Object Types
26 Function Return Types & void
27 Functions as Types
28 Function Types & Callbacks
29 The unknown Type
30 The never Type
31 Wrap Up
32 Useful Resources & Links

The TypeScript Compiler (and its Configuration)
33 Module Introduction
34 Using Watch Mode
35 Compiling the Entire Project Multiple Files
36 Including & Excluding Files
37 Setting a Compilation Target
38 Understanding TypeScript Core Libs
39 More Configuration & Compilation Options
40 Working with Source Maps
41 rootDir and outDir
42 Stop Emitting Files on Compilation Errors
43 Strict Compilation
44 Code Quality Options
45 Debugging with Visual Studio Code
46 Wrap Up
47 Useful Resources & Links

Next-generation JavaScript & TypeScript
48 Module Introduction
49 let and const
50 Arrow Functions
51 Default Function Parameters
52 The Spread Operator (…)
53 Rest Parameters
54 Array & Object Destructuring
55 How Code Gets Compiled & Wrap Up
56 Useful Resources & Links

Classes & Interfaces
57 Module Introduction
58 What are Classes
59 Creating a First Class
60 Compiling to JavaScript
61 Constructor Functions & The this Keyword
62 private and public Access Modifiers
63 Shorthand Initialization
64 readonly Properties
65 Inheritance
66 Overriding Properties & The protected Modifier
67 Getters & Setters
68 Static Methods & Properties
69 Abstract Classes
70 Singletons & Private Constructors
71 Classes – A Summary
72 A First Interface
73 Using Interfaces with Classes
74 Why Interfaces
75 Readonly Interface Properties
76 Extending Interfaces
77 Interfaces as Function Types
78 Optional Parameters & Properties
79 Compiling Interfaces to JavaScript
80 Wrap Up
81 Useful Resources & Links

Advanced Types
82 Module Introduction
83 Intersection Types
84 More on Type Guards
85 Discriminated Unions
86 Type Casting
87 Index Properties
88 Function Overloads
89 Optional Chaining
90 Nullish Coalescing
91 Wrap Up
92 Useful Resources & Links

93 Module Introduction
94 Built-in Generics & What are Generics
95 Creating a Generic Function
96 Working with Constraints
97 Another Generic Function
98 The keyof Constraint
99 Generic Classes
100 A First Summary
101 Generic Utility Types
102 Generic Types vs Union Types
103 Useful Resources & Links

104 Module Introduction
105 A First Class Decorator
106 Working with Decorator Factories
107 Building More Useful Decorators
108 Adding Multiple Decorators
109 Diving into Property Decorators
110 Accessor & Parameter Decorators
111 When Do Decorators Execute
112 Returning (and changing) a Class in a Class Decorator
113 Other Decorator Return Types
114 Example Creating an Autobind Decorator
115 Validation with Decorators – First Steps
116 Validation with Decorators – Finished
117 Fixing a Validator Bug
118 Wrap Up
119 Useful Resources & Links

Practice Time Let’s build a Drag & Drop Project
120 Module Introduction
121 Getting Started
122 DOM Element Selection & OOP Rendering
123 Interacting with DOM Elements
124 Creating & Using an Autobind Decorator
125 Fetching User Input
126 Creating a Re-Usable Validation Functionality
127 Rendering Project Lists
128 Managing Application State with Singletons
129 More Classes & Custom Types
130 Filtering Projects with Enums
131 Adding Inheritance & Generics
132 Rendering Project Items with a Class
133 Using a Getter
134 Utilizing Interfaces to Implement Drag & Drop
135 Drag Events & Reflecting the Current State in the UI
136 Adding a Droppable Area
137 Finishing Drag & Drop
138 Wrap Up
139 Useful Resources & Links

Modules & Namespaces
140 Module Introduction
141 Writing Module Code – Your Options
142 Working with Namespaces
143 Organizing Files & Folders
144 A Problem with Namespace Imports
145 Important Use Chrome or Firefox
146 Using ES Modules
147 Understanding various Import & Export Syntaxes
148 How Does Code In Modules Execute
149 Wrap Up
150 Useful Resources & Links

Using Webpack with TypeScript
151 Module Introduction
152 What is Webpack & Why do we need it
153 A Note About NodeJS
154 Installing Webpack & Important Dependencies
155 Adding Entry & Output Configuration
156 Adding TypeScript Support with the ts-loader Package
157 Finishing the Setup & Adding webpack-dev-server
158 Adding a Production Workflow
159 Wrap Up
160 Useful Resources & Links

rd Party Libraries & TypeScript
161 Module Introduction
162 Using JavaScript ( ) Libraries with TypeScript
163 Using declare as a Last Resort
164 No Types Needed class-transformer
165 TypeScript-embracing class-validator
166 Wrap Up
167 Useful Resources & Links

Time to Practice Let’s build a Select & Share a Place App (incl. Google Maps)
168 Module Introduction
169 Project Setup
170 Getting User Input
171 Setting Up a Google API Key
172 Using Axios to Fetch Coordinates for an Entered Address
173 Rendering a Map with Google Maps (incl. Types )
174 Working with Maps without a Credit Card
175 Useful Resources & Links

React.js & TypeScript
176 Module Introduction
177 Setting Up a React + TypeScript Project
178 How Do React + TypeScript Work Together
179 Working with Props and Types for Props
180 Getting User Input with refs
181 Cross-Component Communication
182 Working with State & Types
183 Managing State Better
184 More Props & State Work
185 Adding Styling
186 Types for other React Features (e.g. Redux or Routing)
187 Wrap Up
188 Useful Resources & Links

Node.js + Express & TypeScript
189 Module Introduction
190 Executing TypeScript Code with Node.js
191 Setting up a Project
192 Finished Setup & Working with Types (in Node + Express Apps)
193 Adding Middleware & Types
194 Working with Controllers & Parsing Request Bodies
195 More CRUD Operations
196 Wrap Up
197 Useful Resources & Links

Course Roundup
198 Roundup