Comprehensive TypeScript

TypeScript has many resources available on their website to assist you learning the language.

In this tutorial, we'll have a look at the TypeScript handbook, an easy-to-understand TypeScript guide, and the TypeScript Playground, a place where you can write TypeScript and see it compile in real time.

TypeScript is a simple application that can be installed on PC or Mac.

In this tutorial, we'll walk through the process as well as learn about Node and avoid some common pitfalls.

You can compile TypeScript into JavaScript using the command line interface (CLI).

In this tutorial, we'll use our terminal window to compile TypeScript into JavaScript.

We'll also look at a few common command line arguments.

TypeScript is a language that compiles down to JavaScript.

In this tutorial, we'll use the TypeScript playground to see this process in action, and take a sneak preview at numerous TypeScript constructs that are compiled into complex JavaScript code.

TypeScript's strongly typed nature make it perfect for assistance via code hinting, linters, and pre-compilers.

The best way to develop is to have these features integrated right into your text editor, so in this tutorial, we take a look at three great integrated development environments (IDE) for TypeScript - Brackets, IntelliJ and Sublime.

TypeScript is named through a combination of the words "Type" and "JavaScript". This should give the reader a clear understanding of their importance in learning TypeScript programming.

In this tutorial, we introduce types in TypeScript, and learn a bit about the number type.

TypeScript comes packaged with several useful, basic types.

In this tutorial, we become familiar with three basic types - numbers, strings and booleans, including a live code example.

Array types are a powerful basic type available in TypeScript.

In this tutorial, we'll learn about how they're used, and define a type for a variable that is an array containing only numbers.

Enums are another vary useful type available in TypeScript which provide functionality not available in plain JavaScript.

In this tutorial, we'll learn what enums are and do two hands-on examples.

The Any and Void types are the two final TypeScript types that we'll discuss in this section.

Though not particularly useful, they do come in handy from time to time in numerous real-world situations.

This lecture contains the slides used in the section. Feel free to refer to them whenever you need a refresher on types.

Interfaces are a feature common to many typed languages including C# and Java. TypeScript brings a part of these languages, interfaces, to our front end and JavaScript code.

In this tutorial, we'll look at the basic syntax for creating interfaces. We'll also create an interface in our code editor and troubleshoot compiler errors.

TypeScript interfaces can have optional properties. In this tutorial, we'll examine adding optional properties to our interfaces.

Interfaces can be used as powerful tools to define a template for functions.

In this tutorial, we'll examine function interfaces and use one to define a special kind of function.

Interfaces can be used in TypeScript to define several different genres of array, including Dictionaries.

In this tutorial, we will use TypeScript array interfaces to define both a numeric array and a dictionary.

Classes are templates for objects in TypeScript. Class interfaces in TypeScript are templates for classes. They are powerful and not too difficult to use.

In this tutorial, we'll define an interface for a class and use it to generate better code.

One of the most powerful feature of interfaces in TypeScript is that they can extend one another and create modular, DRY (don't-repeat-yourself) templates for code.

In this tutorial, we'll create an interface an extend it to explore modular functionality.

JavaScript is an extremely modular and dynamic language. TypeScript interfaces allow for this with Hybrid interfaces, which define the interface for something that is multiple types at once.

In this tutorial, we'll look at Hybrid interfaces and how they can be used.

A summary of all the slides in this tutorial section, Interfaces.

Classes make up the backbone of most object oriented languages.

TypeScript gives us access to the full range of functionality available to classes. In this tutorial, we'll take a look at what classes are and also try a quick example of a simple class.

Inheritance is a powerful tool that TypeScript developers can use to write more modular code.

In this tutorial, we'll learn about inheritance, and make a simple class that inherits from another class.

Private and public modifiers are tools we can use to make our code more error-resistant and easier to understand.

In this lesson, we'll learn about private and public properties, and create a class with a private property in an example.

Accessor methods are a convenient tool to create clean and easy to understand interfaces.

In this tutorial, we'll look at accessor functions, also known as getter and setter methods, and create an example in which we implement both.

Static methods and properties are yet another handy tool TypeScript adds to our developer's toolbelt which let us write more expressive code.

In this tutorial, we'll learn about static properties, and do an example where we implement them.

This lesson contains the slides for this section as well as the course files.

Modules are a key feature of TypeScript which allows you to share your code between files.

In this tutorial, we'll have a look at a simple module example and construct one in a hands-on workshop.

The purpose of modules in TypeScript is largely to share files between projects.

In this tutorial, we'll use a reference declaration to share modules between two different TypeScript files.

TypeScript comes with powerful support for AMD and Commonjs modules.

In this tutorial, we'll have a look at the elegant import and export syntax, and then try it out in a live code example. As a bonus, we'll have a look at some generated AMD code.

The lecture contains the slides for the section on modules, plus the course files.

TypeScript adds powerful functionality to the existing capabilities of JavaScript functions.

In this video, we'll take a look at what a TypeScript function is and how it relates to JavaScript.

The type system is at the core of what makes TypeScript a useful programming tool. Function types add this functionality to functions.

In this tutorial, we'll have a look at function types, and try a simple example.

Optional and default parameters are a familiar feature for programmers familiar with many languages including C# or JavaScript.

TypeScript also has optional and default parameters. In this tutorial, we'll learn about what optional and default parameters are, create optional and default parameters in a simple example, and then have a look at compiled code to see what's going on under the TypeScript hood.

Rest parameters are a cool ES6 feature that's available to TypeScript users early.

Rest parameters are useful but can be intimidating. In this tutorial, we'll break them down until they are simple tools for writing cleaner code.

Lambdas, also known as fat arrow functions, are a powerful ES6 feature that is also available currently in TypeScript.

Lambdas in TypeScript are extremely useful due to their descriptiveness, terseness, and ease-of-use.

In this tutorial, we'll have a look at Lambdas, and create one in a hands-on example.

The type system in TypeScript is essential. Using the `any` type can be disastrous. Function overloads let us avoid using any while writing better, more sensible code.

In this tutorial, we'll examine overloads, see how they are useful, and make a few in some hands-on examples.

The lecture contains the slides for the section on functions plus the course files.

Generics are a powerful way to render TypeScript code more error resistant. They may be familiar to experienced C# or Java coders.

In this tutorial, we'll look at what TypeScript generics are and try a quick hands on example.

TypeScript's generics and its powerful array type syntax can be combined into a useful means to keep your code free of errors.

In this tutorial, we'll have a look at generic arrays and try out an example.

Interfaces in TypeScript let us create our own types to prevent errors in our code.

Generic interfaces add another layer of customization to TypeScript interfaces. In this tutorial, we'll look at how generic interfaces work and make a few in an exercise.

Generic classes are one of TypeScript's most useful features, and work in a similar manner to regular generics and generic interfaces.

In this tutorial, we'll look at how to create a generic class and have a go at a quick example.

Generics are a useful way of preventing errors in our code. Generic constraints are yet another tool for preventing errors, this time errors in our generics.

We'll look at generic constraints and explore how they work in an example.

This lecture contains the slides on the section on generics as well as the course files.

Gulp is the fastest-growing task runner of 2015 and, of course, TypeScript integration is available.

In this hands-on workshop,we'll install Gulp and Gulp-TypeScript, then use a Gulpfile and the gulp command line argument to generate JavaScript from TypeScript.

We'll also look at the out and target options of Gulp-TypeScript.