Understanding TypeScript
4.7 (1,893 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
10,486 students enrolled
Wishlisted Wishlist

Please confirm that you want to add Understanding TypeScript to your Wishlist.

Add to Wishlist

Understanding TypeScript

Don't limit the Usage of TypeScript to Angular 2! Learn the Basics, its Features, Workflows and how to use it!
Bestselling
4.7 (1,893 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
10,486 students enrolled
Last updated 1/2017
English
English
Current price: $10 Original price: $110 Discount: 91% off
5 hours left at this price!
30-Day Money-Back Guarantee
Includes:
  • 7 hours on-demand video
  • 8 Articles
  • 26 Supplemental Resources
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
What Will I 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
View Curriculum
Requirements
  • JavaScript Knowledge is required, though you don't need to be an Expert
  • OOP Experience is a Plus but not required
  • ES6 Knowledge is a Plus but not required
Description

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 Workflows using Gulp or Webpack.

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 integrate TypeScript into your Gulp or Webpack Workflow
  • Or how to set up a plain-TypeScript Workflow
  • How to use TypeScript together with ReactJS
Who is the target audience?
  • This Course is for every Student who wants to extend his Horizon beyond vanilla JavaScript
  • Everyone learning Angular 2 should definitely understand how TypeScript works
Students Who Viewed This Course Also Viewed
Curriculum For This Course
137 Lectures
06:47:33
+
Getting Started
7 Lectures 21:24

Let me introduce you to this Course!

Preview 02:10

The most important question first: What is TypeScript?

Preview 03:23

So now that we know what TypeScript is, it's time to understand why we may want to use it. And if we want to use it - then how do we do that?

Preview 03:48

Installing TypeScript is a breeze - this lecture will get you there!

Preview 02:15

Yay, we installed TypeScript! Time to start using it on our machine!

Preview 02:47

For this Course we'll be using a Workspace which makes learning TypeScript very comfortable and easy. Watch this video to learn how to set it up. Finished Workspace can be found attached to this lecture!

Setting up the Course Workspace
06:17

Learn how to get the most out of the Q&A section and the Course Materials!

Asking Questions & Course Materials
00:44
+
Using Types for a better Code
22 Lectures 55:25

Let me give you a brief introduction to this module.

Preview 00:46

Time to get to know Types - learn how TypeScript works with them and understand the first basic Type: String.

Preview 02:23

TypeScript of course also knows Numbers and Booleans. This lecture explains how to use these Types.

Preview 01:42

Until now, we saw how TypeScript infers Types. We don't have to stick to this method - we may also assign Types directly.

Assigning Types Explicitly
02:12

Arrays work together with Types smoothly. Learn more about this connection, in this lecture.

Arrays and Types
03:07

Tuples are a new Type, added by TypeScript. Learn more about it and its usage, in this video.

Tuples
01:58

This lecture explains what Enums are and how you may use them in your code.

Enums
03:53

TypeScript has a special Type: The "Any" Type. This lecture explores what this Type does, how and, very importantly, when to use it.

The "Any" Type
01:44

TypeScript gets compiled to plain JavaScript. How does this work if JavaScript doesn't have strong typings? This lecture explores this question.

Understanding the created JavaScript Code
01:40

Of course you may also use Types in Functions. This lecture explores how this works and you may make sure that your Function Arguments and Return Values have the proper Types.

Using Types in Functions (Arguments & Return Values)
04:38

Functions may also be Types. Sounds strange? Learn more in this lecture!

Functions as Types
04:03

Objects are such an important part of JavaScript - of course you may also use them in conjunction with Types. This video dives into the question on how to do that.

Objects and Types
04:54

We learned a lot about Types and how we may use them. Time to put it all together and use them on a more complex Object.

Example: Putting it all together in a Complex Object
01:30

You may also save more complex Type definitions in your own, custom Type, using a Type Alias.

Creating custom Types with Type Aliases
02:32

You are not limited to one possible Type per variable. This lecture explains how to enable the assignment of multiple Types.

Allowing multiple Types with Union Types
02:09

JavaScript doesn't have strong typings, but it does have Types. Hence you can check the Type of a variable during Runtime. This lecture shows you how.

Checking for Types during Runtime
02:05

TypeScript 2.0 added a new Type => "never". What does this Type do and why might you use it? This lecture dives into these questions.

The "never" Type (added with TypeScript 2.0)
01:55

Prior to TypeScript 2.0, all Types were nullable - which means you could set them to "null". You can change this behavior when using TS 2.0 +. This lectures explores how to work with "null" then.

Nullable Types (added with TypeScript 2.0)
06:24

Time to train the things you learned!

Module Exercise: Problem
00:47


Did you solve the Module Exercise? Here's my Solution.

Module Exercise: Solution
04:03

Let me give you a brief Summary of this Module.

Module Summary
00:50
+
Understanding the TypeScript Compiler
9 Lectures 13:26

Let me give you a brief Module Introduction.

Introduction
00:34

Learn how your TypeScript Code actually gets compiled and what to watch out for.

How Code gets Compiled
01:56

You may change the way the Compiler behaves once Errors occur - this video shows you how!

Changing the Compiler Behavior on Errors
02:13

TypeScript makes Debugging easy - you can quickly enable Source Maps in your Compiler Options as this lecture shows you.

Debugging your TypeScript Code using Source Maps
02:12

If you define a variable without any Type attached to it (and without an initial value), it is of Type "Any". This behavior can be suppressed and this lecture explains how to do this.

Avoiding implicit "Any"
01:42

There are a lot of other Compiler Options. A lot of them will probably never be used by you. This lecture explains where to learn more about them.

More Compiler Options
01:00

The Compiler got even smarter with the Release of TS 2.0. This lecture explains some new features and how it may now help you even more!

Compiler Improvements with TypeScript 2.0
03:09

In this Article, you'll find useful links regarding the TypeScript Compiler

Resource: Compiler Documentation
00:07

Let me give you a brief Summary of that Module.

Module Summary
00:33
+
TypeScript and ES6
16 Lectures 54:24

Let me give you a brief Module Introduction.

Preview 01:48

Learn how to find out if your favorite ES6 Feature is supported by TypeScript.

ES6 & TypeScript Compatibility
00:08

Two great new Additions with ES6 are "let" and "const". What that is? How to use it? Learn more in this lecture!

Preview 04:12

With "let" and "const" comes the Block Scope. This lecture explores this topic.

Preview 02:43

Another very important new Feature are "Arrow Functions". This lecture dives into this topic and shows how to use them.

Arrow Functions
03:40

Haven't gotten enough of Arrow Functions? Here you go.

Arrow Functions - Variations
01:49

With ES6, Functions (all Functions, not only Arrow Functions) may use Default Parameters. Let's dive into this topic together.

Functions and Default Parameters
04:11

We got a new Operator with ES6: The Spread Operator. Learn more about it, in this lecture.

The Spread Operator
03:40

And another new Operator added with ES6. Time to learn it!

The Rest Operator
05:16

"Destructuring" is another nice Feature introduced by ES6. Let's explore it together.

Destructuring Arrays
03:40

You may not only destructure Arrays, but also Objects. This lecture explains how to do this.

Destructuring Objects
03:09

Strings just got more flexible! Template Literals make the usage of Strings easier/ more flexible. Let's see what you can do with Template Literals.

Template Literals
04:07

There are more ES6 Features - and this is no ES6 Course.

Other ES6 Features
01:09

Time to train the things learned!

Module Exercise: Problem
00:41

Did you solve the Module Exercise? Let's see my Solution.

Module Exercise: Solution
13:19

Time for a brief Module Summary.

Module Summary
00:52
+
Using Classes to create Objects
14 Lectures 56:03

Let me give you a brief Introduction to this Module.

Introduction
00:31

Let's start with the basics: How to create Classes and how to fill them with some life in the form of Properties.

Creating Classes and Class Properties
08:19

Classes not only have properties, they also have some Methods. Time to learn about the creation of such. Also, you may want to control the Access level a Property or Method has. This lecture shows you how to do that.

Class Methods and Access Modifiers
04:44

Inheritance is one of the key concepts when using Classes. Learn how to use it, in this lecture.

Inheritance
03:00

There are some special things to know regarding the usage of Inheritance and Constructors. This lecture will enlighten you.

Inheritance and Constructors
01:57

Time for a brief Wrap Up of the topic of Inheritance.

Inheritance Wrap Up
02:04

TypeScript supports Getters and Setters on Class Properties and this lecture shows you how to use them.

Getters & Setters
05:47

You don't have to instantiate all Classes, you may also create static Properties and Methods which can be accessed directly on the Class itself. This lecture explores this possibility.

Static Properties and Methods
03:39

There's a special type of Classes: The "abstract" Class. Let's dive into it, in this lecture.

Abstract Classes
05:56

TypeScript 2.0 added the possibility of marking constructors as private. Why would you want to do that? This lectures dives into that question.

Private Constructors & Singletons (added with TypeScript 2.0)
02:55

You already know Getters and Setters. TypeScript 2.0 makes the creation of readonly properties even simpler. Learn more in this lecture!

"readonly" Properties (added with TypeScript 2.0)
02:14

Training Time!

Module Exercise: Problem
00:40

Were you successful regarding the Module Exercise? Let's have a look at the Problem posed.

Module Exercise: Solution
13:27

Module Summary
00:50
+
Namespaces and Modules
12 Lectures 40:16

Let me give you a brief Module Introduction.

Introduction
00:52

Let's start with Namespaces and explore what they are.

An Introduction to Namespaces
06:38

Namespaces are typically not used in one File only, so let's see how we may use them with Multiple Files.

Namespaces and Multiple Files
05:04

When using Multiple Files, we need to Import our Namespaces. Let's explore this topic together.

Namespace Imports
02:40

There are some other, advanced topics I want to share about Namespaces.

More on Namespaces
02:25

Namespaces are great but they also have some limitations - let's have a look at those in this video.

Limitations of Namespaces
01:44

Now what are Modules? How do they differ from Namespaces? Let's dive into this topic.

Modules
04:02

Unlike Namespaces, Modules need to be loaded as an extra File during runtime. Let's learn how to configure our project to support this.

Loading Modules
09:00

There are plenty of options of Importing and Exporting Modules. Let's have a look at them.

Importing & Exporting Modules
02:36

TypeScript supports various Module Resolutions. This lecture dives into this topic.

Module Resolution
02:26

Time for the ultimate Namespace vs Modules Wrap Up!

Namespaces vs Modules - Wrap Up
02:10

Let me give you a brief Module Summary.

Module Summary
00:39
+
Doing Contract Work with Interfaces
9 Lectures 25:43

Let me give you a brief Module Introduction.

Introduction
00:50

What are Interfaces? And ... why? Let's dive into these questions together.

The Basics about Interfaces
05:54

Interfaces may define Properties. Actually, they often do that. This lectures shows you how to do that.

Interfaces and Properties
05:07

We're not limited to Properties, of course an Interface may also define methods. Let's have a look at that, too.

Interfaces and Methods
02:20

A common usage of Interfaces, is, to implement them in a Class. This lecture shows how this works.

Using Interfaces with Classes
03:45

Interfaces also support Function Types, so let's explore how to use this Feature.

Interfaces and Function Types
03:19

Interfaces may inherit from Interfaces. Sounds strange? This lecture explains how this works.

Interface Inheritance
02:20

There's an interesting thing happening when compiling Interfaces. Let's see what it is.

What happens once Interfaces get Compiled
01:41

Let me give you a brief Module Summary.

Module Summary
00:27
+
Generics
12 Lectures 32:02

Let me give you a brief Module Introduction.

Introduction
00:51

Why and What? Let's see what Generics are all about.

Why and What?
04:19

Let's start simple by creating a Generic Function, using TypeScript Generics.

Creating a Generic Function
03:23

There actually exists a built-in Generic Type: Arrays. Let's learn more about it.

A built-in Generic Type: Arrays
01:51

Time to dive deeper into Generics and Arrays.

Generic Types and Arrays
01:31

Time to create our own Generic Type and see how it works!

Using Generic Types
02:32

A common place to use Generics are Classes. This lecture shows you how to connect both concepts.

Creating a Generic Class
04:07

Even a Generic Type may have limits. You set them - with Constraint. Time to dive into this topic.

Constraints
03:02

You're not limited to only one Generic Type, this lecture teaches you how to use multiple ones.

Using more than one Generic type
02:44

Time to get your hands dirty on Generics!

Module Exercise: Problem
00:25

Were you successful? Let's compare Solutions!

Module Exercise: Solution
06:14

Let me give you a brief Module Summary.

Module Summary
01:03
+
Behind the Scenes with Decorators
10 Lectures 31:19

Time for the Module Introduction.

Introduction
01:10

One of the most common places for a Decorator are Classes. This lecture teaches you how to create a Decorator and attach it to a Class.

Creating a Class Decorator
04:52

You may also attach Decorator Factories. This may sound way more complicated than it actually is.

Decorator Factories
03:25

Time to create our first really useful Decorator.

Creating a useful Decorator
03:03

You may attach and use more than one Decorator, so let's do this in this lecture.

Using Multiple Decorators
01:05

Let me summarize what we learned thus far.

A first Summary
02:13

You're not limited to decorating your Classes - Methods also work, as this lecture shows you.

Method Decorators
05:13

Classes and Methods ... what if you want to decorate a Property? Well, here you go.

Property Decorators
04:35

And there's life beyond Classes, Methods and Properties - you may also decorate your Method Parameters!

Parameter Decorators
04:23

Let me give you a brief Module Summary.

Module Summary
01:20
+
Using JavaScript Libraries (like jQuery) with TypeScript
8 Lectures 19:14

Let me give you a brief Module Introduction.

Introduction
01:25

Before hooking it up to TypeScript, a third-party of Library must of course be installed. Let's see how this works.

Installing a Third-Party Library
01:14

We're using TypeScript, hence we're importing things. No <script> imports in the index.html file. This lecture shows you how to add a third-party Library.

Importing the Library
04:44

We need a Way to understand what the JavaScript Library offers us. TypeScript Definition Files help us with that as this lecture shows.

Translating JavaScript to TypeScript with TypeScript Definition Files
02:09

You may simply download the required TypeScript Definition Files. This may be fine for smaller projects (with only one or two external libraries, but it quickly gets inconvenient).

Option 1: Manually download TypeScript Definition Files
02:20

There's a better way to get and handle your TypeScript Definition Files: The Typings Packager. Let's see it in action.

Option 2: Managing TypeScript Defintion Files with the "typings" Package
03:30

With TypeScript 2.0, you don't need to use external packages like the "Typings" package anymore. This lecture teaches you how to manage your Types with only TS and npm.

Easier Type Management with TypeScript 2.0
03:10

Time for a brief Module Summary.

Module Summary
00:42
3 More Sections
About the Instructor
Maximilian Schwarzmüller
4.7 Average rating
43,034 Reviews
131,888 Students
15 Courses
Professional Web Developer and Instructor

Experience as Web Developer

Starting out at the age of 13 I never stopped learning new programming skills and languages. Early I started creating websites for friends and just for fun as well. This passion has since lasted and lead to my decision of working as a freelance web developer and consultant. The success and fun I have in this job is immense and really keeps that passion burningly alive.

Starting web development on the backend (PHP with Laravel, NodeJS) I also became more and more of a frontend developer using modern frameworks like Angular or VueJS 2 in a lot of projects. I love both worlds nowadays!

As a self-taught developer I had the chance to broaden my horizon by studying Business Administration where I hold a Master's degree. That enabled me to work in a major strategy consultancy as well as a bank. While learning, that I enjoy development more than these fields, the time in this sector greatly improved my overall experience and skills.

Experience as Instructor

As a self-taught professional I really know the hard parts and the difficult topics when learning new or improving on already-known languages. This background and experience enables me to focus on the most relevant key concepts and topics. My track record of many 5-star rated courses, more than 100.000 students on Udemy as well as a successful YouTube channel is the best proof for that.

Whether working as development instructor or teaching Business Administration I always received great feedback. The most rewarding experience is to see how people find new, better jobs, build awesome web applications, acquire amazing projects or simply enjoy their hobby with the help of my content.