Typescript: The Complete Developer’s Guide

38.00$ 199.00$

  • EUR: € 32.35

Status: Instant Deliver    

Sales Page: https://www.udemy.com/course/typescript-the-complete-developers-guide/

Typescript Online Course: The Complete Developer’s Guide

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.
Who this course is for:
Any Javascript developer looking to understand how to structure large codebases

Here What You’ll Get:

  • 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
  • Course content
  • –Getting Started with Typescript
    41:20
  • How to Get Help
    01:04
  • Typescript Overview
    06:19
  • Environment Setup
    07:59
  • 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?
    20:18
  • Do Not Skip – Course Overview
    03:36
  • 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
    40:53
  • 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
    26:15
  • 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
    13:26
  • 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
    12:52
  • Tuples in Typescript
    04:04
  • Tuples in Action
    05:28
  • Why Tuples?
    03:20
  • –The All-Important Interface
    26:28
  • 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
    25:16
  • 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
    02:13:35
  • App Overview
    02:45
  • Bundling with Parcel
    04:55
  • Project Structure
    03:19
  • Generating Random Data
    05:29
  • Type Definition Files
    05:17
  • Using Type Definition Files
    06:20
  • Export Statements inTypescript
    05:06
  • Defining a Company
    04:43
  • Note on Generating an API Key
    00:24
  • Adding Google Maps Support
    07:38
  • 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
    02:34:35
  • 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
    04:00
  • Interfaces vs Abstract Classes
    03:23
  • 8 more sections