Understanding TypeScript

Module Introduction

Using Node.js To Run JavaScript Code

Project Setup

Working with Types & Exploring Built-in Types

Vanilla JavaScript Has Types, Too!

Type Inference vs Type Assignment

Assigning Types To Function Parameters

The "any" Type

Understanding Union Types

Arrays & Types

Advanced Array Types

A First Glimpse At Generic Types - Alternative Array Type Declaration

Making Sense of Tuples

Object Types

Tricky: The "Must Not Be Null" Type

Flexible Objects with the Record Type

Working with Enums

Being Specific With Literal Types

Type Aliases & Custom Types

Function Return Value Types

The "void" Type

The "never" Type

Functions As Types

Null & undefined - Special Types

Inferred null & A First Look At Type Narrowing

Forced "Not Null" And Optional Chaining

Type Casting

The "unknown" Type

Optional Values & TypeScript

Nullish Coalescing

Module Introduction

TypeScript Project Setup & Creating a tsconfig.json File

Exploring tsconfig Options: Target & Libs

Controlling File Input & Emission

Configuring Type Checking

Configuring Code Quality Checks

Example tsconfig.json & Deep Dive

Compiling with tsconfig

Using TypeScript's Watch Mode

Installing Type Packages

Module Introduction

Using Node.js To Run Compiled JS Code

Getting Started & First Steps

Creating a First Custom Type

Defining a Function with a Union Type Return Value

Adding Application Logic

Connecting Functions & Passing Values

Compilation & Execution

Module Introduction

"let" and "const"

Arrow Functions

Default Function Parameters

The Spread Operator (...)

Rest Parameters

Array & Object Destructuring

How Code Gets Compiled & Wrap Up

Useful Resources & Links

Module Introduction

What are Classes?

Creating a First Class

A Useful TypeScript Shortcut & Compiling to JavaScript

Making Sense of "public" and "private"

Marking Fields as "readonly"

Understanding Getters

Setting Values with Setters

Exploring Static Properties & Methods

Understanding Inheritance

The "protected" Modifier

Making Sense Of Abstract Classes

Introducing Interfaces

Creating a First Interface

Interfaces As Object Types

Interfaces vs Type Aliases & Understanding Declaration Merging

Using Interfaces To Define Function Types

Implementing Interfaces

Ensuring Base Types with Interfaces

Extending Interfaces

How Interfaces Get (Not) Compiled To JavaScript

Module Introduction

Intersection Types

More on Type Guards

Discriminated Unions

Type Guards via "instanceof"

"Outsourcing" Type Guards & Using Type Predicates

Function Overloads

Working with Function Overloads

Making Sense of Index Types

Constant Types with "as const"

Revisiting the "Record" Type

The "satisfies" Keyword

Advanced Types

Module Introduction

A Generic Type We Already Know

Understanding Generic Types

Creating & Using a Generic Type

Generic Functions & Inference

Working with Multiple Generic Parameters

Generics & Constraints

Constraints & Multiple Generic Types

Working with Generic Classes & Interfaces

Summary

Module Introduction

What Is A Linked List?

Creating List & Node Classes

Making the Class Generic

Adding an "add" Method

Adding Items More Efficiently

Accessing the Data & Compiling + Running the Code

Finishing the Linked List

Module Introduction

Using "typeof"

"typeof" & A More Useful Example

Another Great Use-case for "typeof"

Extracting Keys with "keyof"

"keyof" & A More Useful Example

Understanding Indexed Access Types

Accessing Array Elements with Indexed Access Types

Introducing Mapped Types

Readonly Types & Optional Mapping

Exploring Template Literal Types

Introducing Conditional Types

Conditional Types - Another Example

Making Sense of the "infer" Keyword

TypeScript's Got You Covered: Built-in Utility Types

Module Introduction

What Are Decorators? And ECMAScript Decorators vs Experimental Decorators

Exploring Different Types of Decorators

Building a First Decorator

Building a Class Decorators That Edits a Class

Understanding Decorator Code Execution Order

Creating a Method Decorator

Using Decorators To Solve A Common Problem

Implementing A Decorator-based Solution: autobind

Replacing Methods with Decorators

Introducing the Field Decorator

Building Configurable Decorators with Factories

Onwards to Experimental Decorators

Module Introduction

A First Class Decorator

Working with Decorator Factories

Building More Useful Decorators

Adding Multiple Decorators

Diving into Property Decorators

Accessor & Parameter Decorators

When Do Decorators Execute?

Returning (and changing) a Class in a Class Decorator

Other Decorator Return Types

Example: Creating an "Autobind" Decorator

Validation with Decorators - First Steps

Validation with Decorators - Finished

Fixing a Validator Bug

Wrap Up

Useful Resources & Links

Module Introduction

Getting Started

DOM Element Selection & OOP Rendering

Interacting with DOM Elements

Creating & Using an "Autobind" Decorator

Fetching User Input

Creating a Re-Usable Validation Functionality

Rendering Project Lists

Managing Application State with Singletons

More Classes & Custom Types

Filtering Projects with Enums

Adding Inheritance & Generics

Rendering Project Items with a Class

Using a Getter

Utilizing Interfaces to Implement Drag & Drop

Drag Events & Reflecting the Current State in the UI

Adding a Droppable Area

Finishing Drag & Drop

Wrap Up

Useful Resources & Links

Module Introduction

Writing Module Code - Your Options

Working with Namespaces

Organizing Files & Folders

A Problem with Namespace Imports

Using ES Modules

Configuring tsconfig

Understanding various Import & Export Syntaxes

How Does Code In Modules Execute?

Understanding "type" Imports

Wrap Up

Useful Resources & Links

Module Introduction

The Problem With The TypeScript Compiler

Building with Webpack or ESBuild

Introducing Vite

Using Vite

Installing TypeScript on a Per-Project Basis

Making Sense of .d.ts Files

Importing non-TS Files

Wrap Up

About This Section

Module Introduction

What is Webpack & Why do we need it?

Installing Webpack & Important Dependencies

Adding Entry & Output Configuration

Adding TypeScript Support with the ts-loader Package

Adjust Webpack Config

Finishing the Setup & Adding webpack-dev-server

Adding a Production Workflow

Wrap Up

Useful Resources & Links

Module Introduction

Problem: Using JavaScript (!) Libraries with TypeScript

Solution: Installing @types Packages

Exploring .d.ts Files

Diving Deeper Into .d.ts Files

Using "declare" Manually

There Are Libraries With Great TypeScript Support!

Exploring Zod As a TypeScript-first Library

Diving Deeper Into Zod

Runtime vs Compile-time Types with Zod

Module Introduction

Project Setup

Getting User Input

Setting Up a Google API Key

Using Axios to Fetch Coordinates for an Entered Address

Rendering a Map with Google Maps (incl. Types!)

Working with Maps without a Credit Card

Useful Resources & Links

Module Introduction

Setting Up a React + TypeScript Project

Typing Components & Props

Using Components & Props

The Special "children" Prop & Optional Props

Adding Another Components With Props

Component Functions & Types - An Alternative

Managing State

Passing Functions As Props

Handling Form Submission

Working with Refs

More Function Passing & State Updating

Fixing a Typo

Wrap Up

Module Introduction

Node & TypeScript: Options & Alternatives

Setting up a Project

First Server & Working with Node Types

Adding & Using Express (+ Types)

Managing Data with Help of TypeScript

Adding & Testing a First Route

Finishing The Basic App

Native Node.js TypeScript Support (Without Compilation!)

Type Stripping vs Type Transformation

Exploring Alternative Runtimes Like Bun

Thanks for being part of the course!

LEGACY Lectures Below

Module Introduction

Using Types

TypeScript Types vs JavaScript Types

Important: Type Casing

Working with Numbers, Strings & Booleans

Type Assignment & Type Inference

Understanding Types

Object Types

Nested Objects & Types

Arrays Types

Working with Tuples

Working with Enums

The "any" Type

Union Types

Literal Types

Type Aliases / Custom Types

Type Aliases & Object Types

Core Types & Concepts

Function Return Types & "void"

Functions as Types

Function Types & Callbacks

Functions & Types

The "unknown" Type

The "never" Type

Wrap Up

Useful Resources & Links

Where Should You Go Next?

LEGACY Lectures Below

Module Introduction

Using "Watch Mode"

Compiling the Entire Project / Multiple Files

Including & Excluding Files

Setting a Compilation Target

Understanding TypeScript Core Libs

More Configuration & Compilation Options

Working with Source Maps

RootDir and outDir

Stop Emitting Files on Compilation Errors

Strict Compilation

Code Quality Options

Debugging with Visual Studio Code

Wrap Up

Useful Resources & Links

Where Should You Go Next?

LEGACY Lectures Below

Module Introduction

What are Classes?

Creating a First Class

Compiling to JavaScript

Constructor Functions & The "this" Keyword

"private" and "public" Access Modifiers

Shorthand Initialization

"readonly" Properties

Class Basics

Inheritance

Overriding Properties & The "protected" Modifier

Getters & Setters

Static Methods & Properties

Abstract Classes

Singletons & Private Constructors

Classes - A Summary

Classes

A First Interface

Using Interfaces with Classes

Why Interfaces?

Readonly Interface Properties

Extending Interfaces

Interfaces as Function Types

Optional Parameters & Properties

Compiling Interfaces to JavaScript

Interfaces

Wrap Up

Useful Resources & Links

Where Should You Go Next?

LEGACY Lectures Below

Module Introduction

Built-in Generics & What are Generics?

Creating a Generic Function

Working with Constraints

Another Generic Function

The "keyof" Constraint

Generic Classes

A First Summary

Generic Utility Types

Generic Types vs Union Types

Generics

Useful Resources & Links

Where Should You Go Next?