Typescript Bootcamp- Beginner To Advanced (2024 Edition)

Typescript Bootcamp: Beginner To Advanced (2024 Edition), available at $94.99, has an average rating of 4.61, with 141 lectures, 7 quizzes, based on 822 reviews, and has 6025 subscribers.

You will learn about Code in Github repository with downloadable ZIP files per section Learn the Typescript language in depth, including its most advanced features Build practical real-world project in both the backend and the frontend Every feature covered, including: Object Oriented Programming, Generics, Decorators Build a Secure Node REST API with Express and TypeORM This course is ideal for individuals who are Frontend developers looking to learn the language is taking over frontend development or Backend developers doing a transition to full stack development or Javascript Developers looking to learn Typescript or Node Developers looking to learn how to leverage Typescript or Frontend Developers looking to learn how to use Typescript to build a backend It is particularly useful for Frontend developers looking to learn the language is taking over frontend development or Backend developers doing a transition to full stack development or Javascript Developers looking to learn Typescript or Node Developers looking to learn how to leverage Typescript or Frontend Developers looking to learn how to use Typescript to build a backend.

Enroll now: Typescript Bootcamp: Beginner To Advanced (2024 Edition)

Summary

Title: Typescript Bootcamp: Beginner To Advanced (2024 Edition)

Price: $94.99

Average Rating: 4.61

Number of Lectures: 141

Number of Quizzes: 7

Number of Published Lectures: 141

Number of Published Quizzes: 7

Number of Curriculum Items: 148

Number of Published Curriculum Objects: 148

Original Price: $74.99

Quality Status: approved

Status: Live

What You Will Learn

Code in Github repository with downloadable ZIP files per section

Learn the Typescript language in depth, including its most advanced features

Build practical real-world project in both the backend and the frontend

Every feature covered, including: Object Oriented Programming, Generics, Decorators

Build a Secure Node REST API with Express and TypeORM

Who Should Attend

Frontend developers looking to learn the language is taking over frontend development

Backend developers doing a transition to full stack development

Javascript Developers looking to learn Typescript

Node Developers looking to learn how to leverage Typescript

Frontend Developers looking to learn how to use Typescript to build a backend

Target Audiences

Frontend developers looking to learn the language is taking over frontend development

Backend developers doing a transition to full stack development

Javascript Developers looking to learn Typescript

Node Developers looking to learn how to leverage Typescript

Frontend Developers looking to learn how to use Typescript to build a backend

This course covers in-depth the Typescript language and includes several practical projects. It comes with a running Github repo.

This Course in a Nutshell

One of the biggest novelties in the Javascript frontend development space in the last few years is that the use of Typescript has become almost universal.

To the point that it almost does not make sense anymore to start a new project and not use Typescript, given its huge advantages, and almost no downsides.

And this includes projects not only in Node, but also in React, Angular, and any other Javascript-based frontend framework.

Typescript is a strongly typed language that is a superset of Javascript, meaning that Javascript programs are valid Typescript programs (depending on the settings we use for the compiler), but not the other way around.

So in a nutshell, this means that you can see Typescript as a better and improved version of Javascript.

But even though superficially similar, Typescript due to its powerful type system is actually a completely different language than Javascript.

The static type system of Typescript provides many advantages as it allows us to catch many program errors at development instead of at runtime, and it enables powerful development tooling such as precise auto-completion and different types of refactoring.

But to benefit from the power of the type system, we actually don’t have to add type annotations everywhere and end up with code that looks like Java or C#, and sacrifice flexibility, development speed and readability.

The type system can automatically infer the types of most variables automatically, without us having to declare them explicitly, meaning that we can essentially write type-safe Javascript-like code with minimal type annotations.

This powerful type inference is really the killer language feature that makes Typescript the preferred way of starting both a frontend and a backend project today: we get all the benefits of a static type system essentially for free, with no downsides.

Course Overview

This course is divided into multiple sections, that you can take directly depending on your previous level of familiarity with the language. So there are multiple learning paths available for you, depending on your previous experience.

The course will start with a deep dive into all the language features starting with the most basic ones but covering also in detail the most advanced features.

So if you are already familiar with some of the features you can skip ahead, and focus only on the features that you aren’t aware of yet.

We will present the language features from the most elementary ones to the most advanced, and we will cover first the features that are most commonly used.

For completeness, we will also cover a lot of features that are rarely used, but we will point that out explicitly, especially if it’s a feature that you are very unlikely to ever use while coding at the application level.

Besides the language features, we are going to dedicate a full section to the configuration of the Typescript compiler, and go over every option you have available.

We will make it clear when a compiler feature is rarely needed when compared with features that you will be using all the time.

We will still cover everything for completeness, but we want to give you the option to focus only on the most commonly used compiler options if that is what you prefer.

After this initial section covering all language features, we are going to cover also in detail Object-oriented programming, Generics and Decorators, each in their own section.

These 3 sections are mostly independent of the rest of the course and can be taken separately.

After the language sections, we enter the part of the course that covers practical projects.

These practical projects are as close to what you would develop in the real world as possible. This means that these are still small projects that you can comfortably build without spending too much time, but they contain all the building blocks and illustrate all the same design elements that you would have to put in place in a real application.

For example, we are going to build a complete example of a REST API in Node using Typescript and TypeORM, a Typescript-friendly ORM for Node. The server will be designed will all the typical elements of a production system in mind.

For example, the API will be fully secure, and it will require the user to be properly authenticated with a JWT. The API will support multiple levels of access, from a read-only user to an admin user that can edit the data.

Next, once the backend is completed, we are going to build also a couple of frontends with Typescript, namely an Angular frontend, each one in its own separate project.

This way, you will have built your complete system (both frontend and backend) using only one single common language: Typescript.

Table of Contents

This course will go over the following topics:

Introduction to Typescript

The Typescript Type System

The most powerful feature of Typescript: type inference

In-depth coverage of all the Typescript language features, from the most simple to the most advanced

In-depth coverage of all the features available in the Typescript compiler

Object-oriented programming

Typescript Generics in depth

Typescript Decorators in depth

Practical Typescript Project  – Secure Node REST API with TypeORM

What Will You Learn In this Course?

In this course, you will learn everything that you need to know to build both the backend and the frontend of your application using the same language: Typescript.

You will know all the features of the language in-depth, and you will be aware of the distinction between the features that you will be using almost every day, from the features that you will only sparingly use.

You will also know in detail the multiple features that you have available in the Typescript compiler.

You will know how to build real-world projects with Typescript, including how to develop your backend with Node and Typescript, and also how to build your frontend in Typescript using modern frameworks.

Have a look at the course free lessons below, and please enjoy the course!

Course Curriculum

Chapter 1: Introduction To Typescript

Lecture 1: Typescript: The Ultimate Bootcamp – Helicopter View

Lecture 2: IMPORTANT

Lecture 3: Setting Up the Development Environment – Node, Git and IDE

Lecture 4: Why Typescript? Understand the Key Benefits of the Language

Lecture 5: Compiling Your First Typescript Program

Lecture 6: The Typescript compiler noEmitOnError flag

Lecture 7: Running a Typescript Program in a Browser

Chapter 2: Deep Dive Into The Typescript Type System

Lecture 1: Understanding the differences between const, let and var

Lecture 2: Typescript primitive types – numbers, strings and booleans

Lecture 3: Typescript Template Strings

Lecture 4: Understanding Type Inference – The most powerful feature of Typescript

Lecture 5: When to use Typescript Type Annotations and Why

Lecture 6: Typescript Static Type System vs Javascript Dynamic Type System

Lecture 7: Typescript Primitive Types – Objects

Lecture 8: Typescript Nested Object Types

Lecture 9: Understanding the Differences Between Null and Undefined

Lecture 10: Typescript Optional Chaining – How To Avoid Null-Related Errors

Lecture 11: Understanding The Typescript Null Coalescing Operator

Lecture 12: Typescript Optional Chaining – Best Practices For When To Use It Or Not

Lecture 13: Typescript Primitive Types – Arrays

Lecture 14: Typescript Enums – Our First Custom Type

Lecture 15: Understanding The Typescript Any Type – And Why You Should Avoid It

Lecture 16: Avoid Implicit Any Types With The noImplicitAny Compiler Flag

Lecture 17: Understanding Typescript Union Types – Nullable Variables

Lecture 18: Typescript Non Null Assertion Operator

Lecture 19: Typescript Strict Null Checks and the strictNullChecks Compiler Flag

Lecture 20: Understanding Typescript Literal Types – When Are They Useful?

Lecture 21: Understanding Typescript Type Aliases – Our First Custom Type

Lecture 22: Typescript Interfaces – Defining Custom Object Types

Lecture 23: Typescript Type Aliases vs Interfaces – When to Use Which And Why?

Lecture 24: Understanding Typescript Type Assertions

Chapter 3: Deep Dive Into Typescript Modules, Imports and Exports

Lecture 1: Introduction To Typescript Modules – Exports and Imports

Lecture 2: Typescript Module Re-Exports – Building an Import Barrel

Lecture 3: Typescript Modules – Default Exports And The Import As Syntax

Chapter 4: Typescript – Commonly Used Language Features

Lecture 1: Arrow Functions vs Normal Functions – Understanding The This Context

Lecture 2: Typescript Default Function Parameters

Lecture 3: The Typescript Object Spread Operator

Lecture 4: Typescript Object Destructuring

Lecture 5: Typescript Array Spread and Destructuring Operators

Lecture 6: Typescript Rest Function Arguments

Lecture 7: Debugging Typescript In The Browser – Step-By-Step Tutorial

Lecture 8: Debugging Typescript In Node – Step-By-Step Tutorial

Lecture 9: Typescript Shorthand Object Creation Notation

Chapter 5: Typescript Functions In Depth

Lecture 1: Introduction to Typescript Functions

Lecture 2: Typescript Functions At Runtime – Function Values

Lecture 3: Typescript Custom Function Types

Chapter 6: Typescript Advanced Language Features

Lecture 1: Typescript Tuples – How To Use Them?

Lecture 2: Understanding The Typescript Unknown Type

Lecture 3: Understanding Typescript Type Narrowing and Type Predicates

Lecture 4: Understanding Typescript Never Type

Lecture 5: Typescript Intersection Types

Chapter 7: Typescript Compiler Option In Depth (tsconfig.json)

Lecture 1: Introduction to tsconfig.json – The target Property

Lecture 2: Using a Custom Name for the Compiler Configuration File

Lecture 3: Controlling What Files To Compile – The files tsconfig.json property

Lecture 4: Controlling What Files To Compile – include and exclude

Lecture 5: The tsconfig.json outdir and rootDir properties

Lecture 6: The tsconfig.json module property

Lecture 7: Choosing What Libraries To Include Wth tsconfig.json lib and nolib properties

Lecture 8: Typescript Compiler baseUrl Option

Lecture 9: Understanding typeRoots, types and the skipLibCheck Compiler Options

Lecture 10: Including Plain Javascript in a Typescript project – allowJs and checkJs

Lecture 11: Typescript Compiler – Miscellaneous Options

Chapter 8: Object Oriented Programming in Typescript

Lecture 1: Introduction To Typescript Classes

Lecture 2: Writing Our First Typescript Class – The Constructor

Lecture 3: Typescript Classes – Member Variables

Lecture 4: Typescript Read-Only Class Member Variables

Lecture 5: Typescript Getters and Setters

Lecture 6: Does Typescript Support Multiple Constructors?

Lecture 7: Understanding The This Keyword When Used In a Class

Lecture 8: Understanding Typescript Static Variables

Lecture 9: Understanding Typescript Static Class Methods

Lecture 10: Introduction To Object Oriented Inheritance

Lecture 11: The Extends Keyword – Creating a Child Class

Lecture 12: Understanding the Protected Keyword

Lecture 13: Typescript Abstract Classes

Lecture 14: Objected-Oriented Interfaces

Lecture 15: The Singleton In Typescript – An Object-Oriented Design Pattern

Chapter 9: Typescript Generics In Depth

Lecture 1: New Section – Introduction To Typescript Generics

Lecture 2: Commonly Used Generic Libraries

Lecture 3: The Typescript Optional Interface

Lecture 4: The Typescript Read Only Interface

Lecture 5: Introduction To Generic Functions

Lecture 6: Generic Functions With Multiple Generic Parameters

Lecture 7: Typescript Generics – Type Constraints and the extends Keyword

Instructors

Angular University
Best Selling Angular Courses | 200k+ students | 17 courses

Rating Distribution

1 stars: 11 votes

2 stars: 18 votes

3 stars: 74 votes

4 stars: 274 votes

5 stars: 445 votes

Frequently Asked Questions

How long do I have access to the course materials?

You can view and review the lecture materials indefinitely, like an on-demand channel.

Can I take my courses with me wherever I go?

Definitely! If you have an internet connection, courses on Udemy are available on any device at any time. If you don’t have an internet connection, some instructors also let their students download course lectures. That’s up to the instructor though, so make sure you get on their good side!