Typescript The Complete Developers Guide

Typescript The Complete Developers Guide

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

Requirements

Basic knowledge of ES2015 Javascript

Description

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 effortLearn 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 communityMaster the fundamental features of Typescript by working on real world projectsWe’ll build a custom front-end framework from scratch that you can use in place of React or Angular on your own personal projectsComprehend the complex interplay between classes and interfaces, and why these two pieces of Typescript enable you to build incredibly reusable codeDive deeper into Typescript with decorators, which we’ll use to build a custom integration between Typescript and ExpressStructure your React and Redux applications more confidently by understanding how to couple them with TypescriptSkip the documentation for third party libraries by fluently reading type definition filesLearn just how smart Typescript is by experiencing how deeply it analyzes your code for errorsI 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.

Overview

Section 1: Getting Started with Typescript

Lecture 1 How to Get Help

Lecture 2 Join Our Community!

Lecture 3 Course Resources

Lecture 4 Typescript Overview

Lecture 5 Environment Setup

Lecture 6 Important Axios Version Information

Lecture 7 A First App

Lecture 8 Executing Typescript Code

Lecture 9 One Quick Change

Lecture 10 Catching Errors with Typescript

Lecture 11 Catching More Errors!

Section 2: What is a Type System?

Lecture 12 Do Not Skip – Course Overview

Lecture 13 Types

Lecture 14 More on Types

Lecture 15 Examples of Types

Lecture 16 Where Do We Use Types?

Section 3: Type Annotations in Action

Lecture 17 Type Annotations and Inference

Lecture 18 Annotations with Variables

Lecture 19 Object Literal Annotations

Lecture 20 Annotations Around Functions

Lecture 21 Understanding Inference

Lecture 22 The ‘Any’ Type

Lecture 23 Fixing the ‘Any’ Type

Lecture 24 Delayed Initialization

Lecture 25 When Inference Doesn’t Work

Section 4: Annotations With Functions and Objects

Lecture 26 More on Annotations Around Functions

Lecture 27 Inference Around Functions

Lecture 28 Annotations for Anonymous Functions

Lecture 29 Void and Never

Lecture 30 Destructuring with Annotations

Lecture 31 Annotations Around Objects

Section 5: Mastering Typed Arrays

Lecture 32 Arrays in Typescript

Lecture 33 Why Typed Arrays?

Lecture 34 Multiple Types in Arrays

Lecture 35 When to Use Typed Arrays

Section 6: Tuples in Typescript

Lecture 36 Tuples in Typescript

Lecture 37 Tuples in Action

Lecture 38 Why Tuples?

Section 7: The All-Important Interface

Lecture 39 Interfaces

Lecture 40 Long Type Annotations

Lecture 41 Fixing Long Annotations with Interfaces

Lecture 42 Syntax Around Interfaces

Lecture 43 Functions in Interfaces

Lecture 44 Code Reuse with Interfaces

Lecture 45 General Plan with Interfaces

Section 8: Building Functionality with Classes

Lecture 46 Classes

Lecture 47 Basic Inheritance

Lecture 48 Instance Method Modifiers

Lecture 49 Fields in Classes

Lecture 50 Fields with Inheritance

Lecture 51 Where to Use Classes

Section 9: Design Patterns with Typescript

Lecture 52 Updated Parcel Instructions

Lecture 53 App Overview

Lecture 54 Bundling with Parcel

Lecture 55 Project Structure

Lecture 56 IMPORTANT Info About Faker Installation

Lecture 57 Generating Random Data

Lecture 58 Type Definition Files

Lecture 59 Using Type Definition Files

Lecture 60 Export Statements in Typescript

Lecture 61 Defining a Company

Lecture 62 Note on Generating an API Key

Lecture 63 Adding Google Maps Support

Lecture 64 Required Update for New @types Library

Lecture 65 Google Maps Integration

Lecture 66 Exploring Type Definition Files

Lecture 67 Hiding Functionality

Lecture 68 Why Use Private Modifiers? Here’s Why

Lecture 69 Adding Markers

Lecture 70 Duplicate Code

Lecture 71 One Possible Solution

Lecture 72 Restricting Access with Interfaces

Lecture 73 Implicit Type Checks

Lecture 74 Showing Popup Windows

Lecture 75 Updating Interface Definitions

Lecture 76 Optional Implements Clauses

Lecture 77 App Wrapup

Section 10: More on Design Patterns

Lecture 78 App Overview

Lecture 79 Configuring the TS Compiler

Lecture 80 Concurrent Compilation and Execution

Lecture 81 A Simple Sorting Algorithm

Lecture 82 Sorter Scaffolding

Lecture 83 Sorting Implementation

Lecture 84 Two Huge Issues

Lecture 85 Typescript is Really Smart

Lecture 86 Type Guards

Lecture 87 Why is This Bad?

Lecture 88 Extracting Key Logic

Lecture 89 Separating Swapping and Comparison

Lecture 90 The Big Reveal

Lecture 91 Interface Definition

Lecture 92 Sorting Arbitrary Collections

Lecture 93 Linked List Implementation

Lecture 94 Completed Linked List Code

Lecture 95 Just…One…More…Fix…

Lecture 96 Integrating the Sort Method

Lecture 97 Issues with Inheritance

Lecture 98 Abstract Classes

Lecture 99 Why Use Abstract Classes?

Lecture 100 Solving All Issues with Abstract Classes

Lecture 101 Interfaces vs Abstract Classes

Section 11: Reusable Code

Lecture 102 Project Overview

Lecture 103 Project Setup

Lecture 104 CSV Data

Lecture 105 Type Definition Files – Again!

Lecture 106 Reading CSV Files

Lecture 107 Running an Analysis

Lecture 108 Losing Dataset Context

Lecture 109 Using Enums

Lecture 110 When to Use Enums

Lecture 111 Extracting CSV Reading

Lecture 112 Data Types

Lecture 113 Converting Date Strings to Dates

Lecture 114 Converting Row Values

Lecture 115 Type Assertions

Lecture 116 Describing a Row with a Tuple

Lecture 117 Not Done with FileReader Yet!

Lecture 118 Understanding Refactor #1

Lecture 119 Creating Abstract Classes

Lecture 120 Variable Types with Generics

Lecture 121 Applying a Type to a Generic Class

Lecture 122 Alternate Refactor

Lecture 123 Interface-Based Approach

Lecture 124 Extracting Match References – Again!

Lecture 125 Transforming Data

Lecture 126 Updating Reader References

Lecture 127 Inheritance vs Composition

Lecture 128 More on Inheritance vs Composition

Lecture 129 A Huge Misconception Around Composition

Lecture 130 Goal Moving Forward

Lecture 131 A Composition-Based Approach

Lecture 132 Implementing an Analyzer Class

Lecture 133 Building the Reporter

Lecture 134 Putting It All Together

Lecture 135 Generating HTML Reports

Lecture 136 One Last Thing!

Lecture 137 Oops, My Bad

Lecture 138 App Wrapup

Section 12: Advanced Generics

Lecture 139 More on Generics

Lecture 140 Type Inference with Generics

Lecture 141 Function Generics

Lecture 142 Generic Constraints

Section 13: Let’s Build a Web Framework

Lecture 143 App Overview

Lecture 144 Parcel Setup

Lecture 145 Framework Structure

Lecture 146 Designing the User

Lecture 147 Retrieving User Properties

Lecture 148 Optional Interface Properties

Lecture 149 An Eventing System

Lecture 150 Listener Support

Lecture 151 Storing Event Listeners

Lecture 152 Dynamic Array Creation

Lecture 153 Triggering Event Callbacks

Lecture 154 Adding JSON Server

Lecture 155 Understanding REST Conventions

Lecture 156 Adding Fetch Functionality

Lecture 157 Successfully Fetching Model Data

Lecture 158 Saving User Data

Lecture 159 Refactoring with Composition

Lecture 160 Re-Integrating Eventing

Lecture 161 Composition with Nested Objects

Lecture 162 A More Complicated Extraction

Lecture 163 Options for Adapting Sync

Lecture 164 Refactoring Sync

Lecture 165 Generic Constraints Around Sync

Lecture 166 Connecting Sync Back to User

Lecture 167 Optional Properties

Lecture 168 Extracting an Attributes Class

Lecture 169 The Get Method’s Shortcoming

Lecture 170 Two Important Rules

Lecture 171 An Advanced Generic Constraint

Lecture 172 Re-Integrating Attributes

Lecture 173 Composition is Delegation

Lecture 174 Reminder on Accessors

Lecture 175 Passthrough Methods

Lecture 176 A Context Issue

Lecture 177 Setting Data While Triggering

Lecture 178 Fetching User Data

Lecture 179 Saving Data

Lecture 180 Composition vs Inheritance…Again!

Lecture 181 Extracting a Model Class

Lecture 182 Extending the User

Lecture 183 Final User Refactor

Lecture 184 Model Wrapup

Lecture 185 Shortened Passthrough Methods

Lecture 186 Users Collection

Lecture 187 Implementing a Users Collection

Lecture 188 Parsing User JSON

Lecture 189 Generic User Collection

Lecture 190 A Class Method for Collections

Lecture 191 View Classes

Lecture 192 Building the UserForm

Lecture 193 The UserForm’s Render Method

Lecture 194 Rendering HTML

Lecture 195 Defining an Events Map

Lecture 196 Binding Event Handlers

Lecture 197 Adding Model Properties

Lecture 198 Binding Events on Class Name

Lecture 199 Adding Methods to the User

Lecture 200 Re-Rendering on Model Change

Lecture 201 Reading Input Text

Lecture 202 Strict Null Checks

Lecture 203 Reusable View Logic

Lecture 204 Extracting a View Class

Lecture 205 Extending with Generic Constraints

Lecture 206 Saving Data From a View

Lecture 207 UserEdit and UserShow

Lecture 208 Nesting with Regions

Lecture 209 Mapping Regions

Lecture 210 Testing Region Mapping

Lecture 211 View Nesting

Lecture 212 Collection Views

Lecture 213 CollectionView Implementation

Lecture 214 App Wrapup

Section 14: Express + Typescript Integration

Lecture 215 Typescript with JS Libraries

Lecture 216 App Overview

Lecture 217 Project Setup

Lecture 218 Basic Routes with Express

Lecture 219 Using an Express Router

Lecture 220 Parsing Form Bodies

Lecture 221 Why Doesn’t Express Play Nicely with TS?

Lecture 222 Issues with Type Definition Files

Lecture 223 Dealing with Poor Type Defs

Lecture 224 Wiring Up Sessions

Lecture 225 Checking Login Status

Lecture 226 Logging Out

Lecture 227 Protecting Routes

Lecture 228 A Closer Integration

Lecture 229 The Refactoring Process

Lecture 230 Prototypes Reminder

Section 15: Decorators

Lecture 231 Note about target environment in tsconfig

Lecture 232 Decorators in Typescript

Lecture 233 Details on Decorators

Lecture 234 Property Descriptors

Lecture 235 Wrapping Methods with Descriptors

Lecture 236 Decorator Factories

Lecture 237 Decorators Around Properties

Lecture 238 More on Decorators

Section 16: Advanced Express and TS Integration

Lecture 239 A Quick Disclaimer

Lecture 240 Project Overview

Lecture 241 Why is This Hard?

Lecture 242 Solution Overview

Lecture 243 Note about target environment in tsconfig

Lecture 244 Basics of Metadata

Lecture 245 Practical Metadata

Lecture 246 Let’s Refactor!

Lecture 247 The ‘Get’ Decorator

Lecture 248 The Controller Decorator

Lecture 249 Proof of Concept

Lecture 250 A Few Fixups

Lecture 251 Defining a RouteBinder

Lecture 252 Closed Method Sets with Enums

Lecture 253 Metadata Keys

Lecture 254 The ‘Use’ Decorator

Lecture 255 Testing Use

Lecture 256 Body Validators

Lecture 257 Automated Validation

Lecture 258 Testing Automated Validation

Lecture 259 Fixing Routes

Lecture 260 Using Property Descriptors for Type Checking

Lecture 261 App Wrapup

Section 17: React and Redux with Typescript

Lecture 262 React and Redux Overview

Lecture 263 App Overview

Lecture 264 Generating the App

Lecture 265 Simple Components

Lecture 266 Interfaces with Props

Lecture 267 Handling Component State

Lecture 268 Confusing Component State!

Lecture 269 Functional Components

Lecture 270 Redux Setup

Lecture 271 Action Creators with Typescript

Lecture 272 Action Types Enum

Lecture 273 The Generic Dispatch Function

Lecture 274 A Reducer with Enums

Lecture 275 Validating Store Structure

Lecture 276 Connecting a Component to Redux

Lecture 277 Rendering a List

Lecture 278 Adding in Delete Functionality

Lecture 279 Breaking Out Action Creators

Lecture 280 Expressing Actions as Type Union

Lecture 281 Type Guards in Reducers

Lecture 282 Wiring up deleteToDo Action

Lecture 283 Again, Type Definition Files

Lecture 284 Tracking Loading with Component State

Lecture 285 App Wrapup

Section 18: Extras

Lecture 286 Bonus!

Any Javascript developer looking to understand how to structure large codebases

Course Information:

Udemy | English | 24h 37m | 9.70 GB
Created by: Stephen Grider

You Can See More Courses in the Developer >> Greetings from CourseDown.com