 Courses from Marius Schulz

Using TypeScript in your project has never been easier than it is today. The TypeScript team has continually added features to allow you to reap the benefits of static typing while reducing the overhead to get there.

This course will teach you these new language features TypeScript has to offer. You'll use optional chaining, handle undefined behavior with the unknown type and assertion functions, create private classes, handle tuple (and other data types) types, as well as learn about conditional types. 

You'll also learn how to prevent type widening with TypeScript's new const assertions and efficiently type string literals through the use of template literals.

All of these skills will be brought together into examples that Marius will show you how to apply these new TypeScript features to real-world problems.


TypeScript is a typed superset of JavaScript that compiles to plain JavaScript.

typescript

Advanced TypeScript Fundamentals

ES2015 brought a native Promise to the JavaScript standard library. In this course, we’re going to take an in-depth look at how to use promises to model various kinds of asynchronous operations.

First, we’re going to explore how to create promises using the Promise constructor or the Promise.resolve() or Promise.reject() methods. Then, we’re going to see how to chain promises together using .then(), .catch(), and .finally(). We’re going to compare various error handling strategies along the way. We’re going to wrap up this course by taking a look at how to deal with multiple promises using Promise.all() and Promise.race() and how to await a promise using the await operator.

JavaScript® (often shortened to JS) is a lightweight, interpreted, object-oriented language with first-class functions, most known as the scripting language for Web pages, but used in many non-browser environments as well such as node.js or Apache CouchDB. It is a prototype-based, multi-paradigm scripting language that is dynamic, and supports object-oriented, imperative, and functional programming styles.

javascript

JavaScript Promises in Depth


This course explores the capabilities of TypeScript’s type system and shows how to use advanced static types in practice. For example, you’ll learn how to write safer code by using non-nullable types and being explicit about `null` and `undefined` in the type system. 

You’ll also see how the compiler analyzes control flow to determine the most specific type for a variable at any given location.

In addition to that, you’ll learn about the `readonly` modifier and the special `object` and `never` types. This course also inspects string enums, literal types, discriminated unions, and static types for the rest and spread operators. 

Finally, you’ll see how to type dynamic property access using the `keyof` operator and how to create new types by applying transformation functions to existing ones.

Advanced Static Types in TypeScript

JavaScript’s `this` keyword is a source of confusion for new and experienced developers alike. It can be frustrating if, for some reason, `this` doesn’t point to the context that was intended. 

This course will help you understand JavaScript’s `this` mechanism in-depth. Marius will take us through all of the ways `this` will change its values, from why many libraries use "use strict" to how arrow functions take its outer execution context’s `this`. 

Over 8 lessons, you’ll learn:

- how JavaScript implicitly sets the `this` context, and how we can set it ourselves
- that the call-site of a function determines the `this` value of that function invocation 
- how to call a function with a specific `this` value
- how to create functions that always remain tied to a specific this context
- how `this` is treated within arrow functions and classes

Following the course, `this` will feel less frustrating, more intuitive, and far more useful in your day-to-day. 

Understand JavaScript's this Keyword in Depth

In this course we will learn how to use the ES2017 async and await keywords to write asynchronous code that is more readable and easier to follow than equivalent code based on long promise chains or deeply nested callbacks. 

The await operator takes a promise and then pauses the function execution until that promise is settled which allows for an async function to read like sequential synchronous code.

This course will start by showing us how to convert a function doing a simple HTTP request into an async function using async/await. By the end of the course we will be able to loop over asynchronous data sources using a `for-await-of` async generator function.

Asynchronous JavaScript with async/await

This lesson introduces the `--strictNullChecks` compiler option and explains how non-nullable types differ from nullable types. It also illustrates how you can write safer code by being explicit about `null` and `undefined` in the type system.

Restrict null and undefined via Non-Nullable-Types in TypeScript

Some functions may have different return types depending on the types of the arguments with which they’re invoked. Using TypeScript’s function overloads, you can create an overload for each allowed combination of parameter and return types. This way, all type-correct signatures of a function are encoded in the type system and can be surfaced by the TypeScript Language Service within your editor.

Overload a Function with TypeScript’s Overload Signatures

As of TypeScript 2.4, it is now possible to define string enums, or more precisely, enums with string members. Just like any other numeric enum, string enums can be made constant using the `const` modifier so that they disappear entirely from the generated JavaScript; in this case, all enum values will be inlined into the output.

Collect Related Strings in a String Enum in TypeScript

TypeScript’s *discriminated union types* (aka *tagged union types*) allow you to model a finite set of alternative object shapes in the type system. The compiler helps you introduce fewer bugs by only exposing properties that are known to be safe to access at a given location. This lesson shows you how to define a generic `Result<T>` type with a success case and a failure case. It also illustrates how you could use discriminated unions to model various payment methods.

Model Alternatives with Discriminated Union Types in TypeScript

The `keyof` operator produces a union type of all known, public property names of a given type. You can use it together with *lookup types* (aka *indexed access types*) to statically model dynamic property access in the type system.

Query Properties with keyof and Lookup Types in TypeScript

One aspect of control flow based type analysis is that the TypeScript compiler narrows the type of a variable within a type guard. 

This lesson explores how you can define functions and type predicates to create your own type guards similar to the `Array.isArray()` method.

Define Custom Type Guard Functions in TypeScript

TypeScript 2.0 introduced the `readonly` modifier which can be added to a property or index signature declaration. It helps prevent against unintended property assignments. This lesson gives various use cases for `readonly` and shows what the generated JavaScript code looks like.

Make Properties and Index Signatures Readonly in TypeScript

*Mapped types* are a powerful and unique feature of TypeScript's type system. They allow you to create a new type by transforming all properties of an existing type according to a given transformation function. In this lesson, we'll cover mapped types like `Readonly<T>` or `Partial<T>` that ship with the TypeScript compiler, and we'll also explore how to create our own type transformations.

Transform Existing Types Using Mapped Types in TypeScript

TypeScript supports rest and spread properties for objects, which are slated for standardization in ECMAScript 2018. It automatically infers *rest and spread types* so that you can use object spread and rest elements in a statically typed manner without having to manually add type annotations.

Infer Types for Rest and Spread Properties in TypeScript

TypeScript 2.2 introduced the `object`, a type that represents any non-primitive type. It can be used to more accurately type methods such as `Object.create`. Don't confuse it with the `Object` type or `{}`, the empty object type, though!

Represent Non-Primitive Types with TypeScript’s object Type

The TypeScript compiler analyzes the control flow of your program to determine the most precise type for a variable at any given location. 

This lesson shows control flow based type analysis in action and explains how type guards and jumps in control flow affect the type that is inferred.

Understand TypeScript’s Control Flow Based Type Analysis

A literal type is a type that represents exactly one value, e.g. one specific string or number. You can combine literal types with union types to model a finite set of valid values for a variable. In this lesson, we explore the all kinds of literal types in TypeScript:

- String literal types
- Numeric literal types
- Boolean literal types
- Enum literal types

Specify Exact Values with TypeScript’s Literal Types

Dealing with the special `NaN` value can be tricky in JavaScript. It behaves like a number and not a number at the same time. This lesson explains how to identify it using the `isNaN` function or the `Number.isNaN` method.

Identify and Deal with NaN in JavaScript

TypeScript 2.0 introduced a new primitive type called `never`, the type of values that never occur. It helps model the completion behavior of functions more accurately and can also be used for exhaustiveness checking.

Use TypeScript’s never Type for Exhaustiveness Checking

In this lesson, we’re exploring how asynchronous functions can be seamlessly called within a promise chain — just like any other function that returns a promise.

Call an Asynchronous Function in a Promise Chain

Any function can be made asynchronous, including function expressions, arrow functions, and methods. This lesson shows the syntax for each of the function types.

Marius Schulz

Search Results