
About Course
Typescript is a “superset” of Javascript. This means that if you already know Javascript, you are ready to take this course.
Typescript adds several important features to Javascript, including the type system. This type system is intended to help you catch bugs at design time, not at runtime.
This means you’ll be twice as productive by spotting bugs earlier in development. But beyond the type system, Typescript also provides several tools for structuring large codebases and writing truly reusable code. Learning Typescript just by reading the documentation is not easy.
While you may know what a “typed array” or “interface” is, the documentation doesn’t show you where to use these functions or how to use them effectively. The goal of this course is to help you understand why each Typescript feature exists and exactly where to use them. Leading companies are eagerly awaiting Typescript developers.
Some of the largest web applications today are built using Typescript. Employers struggle to find engineers fluent in this advanced system.
A good knowledge of Typescript will make you much more employable by giving you unique skills that few other engineers have.
What Will You Learn?
- Master design patterns for building large applications
- Understand composition and inheritance and when to use them
- Learn to reuse code based on classes and interfaces
- Learn to put together reusable templates for your own Typescript projects
Course Content
Introduction
-
Introduction
-
IMPORTANT! FAQ – Frequently Asked Questions
Introduction to TypeScript
-
A quick tour of TypeScript
-
Installing the development environment
-
First application
-
Running TypeScript code
-
Small code change
-
Finding errors with TypeScript
-
Finding even more bugs!
What is a type system?
-
Course Overview
-
Types
-
More about types
-
Examples of types
-
Where are types used
-
Project files
Type annotations in action
-
Type Annotations and Type Inference
-
Variable Annotations
-
Correcting ‘any’ type’
-
Lazy initialization
-
When type inference doesn’t work
-
Project files
Annotations for functions and objects
-
More about function annotations
-
Type inference for functions
-
Annotations for different kinds of functions
-
Void & Never
-
Destructuring
-
Annotations for objects
-
Project files
Typed Arrays
-
Arrays in TypeScript
-
What are arrays used for in TypeScript?
-
Arrays with values of different types
-
When to use typed arrays?
-
Project files
Tuples in TypeScript
-
Tuples in TypeScript
-
Tuples in action
-
What are they for?
-
Project files
Interfaces are the most important part of TypeScript
-
Interfaces
-
Long type annotations
-
Correcting long annotations using interfaces
-
Interface syntax
-
Functions in interfaces
-
Reusing Code Using Interfaces
-
Interface plan
-
Project files
Creating functionality using classes
-
Classes
-
Inheritance Basics
-
Object Method Modifiers
-
Fields in classes
-
Fields and inheritance
-
Where classes are used
-
Project files
Using Design Patterns in TypeScript
-
Brief overview of the application
-
Running an application using Parcel
-
Project structure
-
Random Data Generation
-
Type Definition Files
-
Using Type Definition Files
-
Export to TypeScript
-
Creating the Company class
-
Restricting access using interfaces
-
Implicit type checking
-
Show pop-ups
-
Updating an Interface Definition
-
Adding the implements keyword
-
Let’s sum it up
-
Project files
More about Design Patterns in TypeScript
-
Brief overview of the application
-
TypeScript compiler configuration
-
Simultaneous compilation and execution of code
-
Simple sorting algorithm
-
Class Sorter()
-
Implementation of sorting
-
Two problems
-
TypeScript is really smart
-
Type protection
-
Integrating the sort() method
-
Problems with inheritance
-
Abstract classes
-
Why use abstract classes?
-
Solving all problems with abstract classes
-
Interfaces vs Abstract Classes
-
Project files
Reusable code
-
Brief overview of the project
-
Setting up the project structure
-
CSV file
-
Type definition files again
-
Reading CSV files
-
Data analysis
-
Loss of data context
-
Using Enums
-
When to use Enums
-
Extracting logic for reading CSV data
-
Data types
-
Data transformation
-
Update Reader links
-
Inheritance vs Composition
-
More about Inheritance vs Composition
-
A very common misunderstanding of the concept of composition
-
Let’s move on
-
Composition-based approach
-
Let’s sum it up
-
Project files
Advanced Generics
-
More about Generics
-
Type Inference and Generics
-
Functions and Generics
-
Generic Constraints
-
Project files
Express & TypeScript
-
TypeScript & JS libraries
-
Application overview
-
Setting up the project structure
-
Create in Express Root Route
-
Creating a session
-
login & logout
-
Route Protected
-
Tighter integration of TS & Express
-
Refactoring
-
Classes & Prototypes
-
Project files
-
Decorators
-
Decorators and Properties
-
More about decorators
-
Project files
-
Express & TypeScript – Advanced
-
Important Note
-
Project overview
-
Why is this difficult?
-
Solution Overview
-
Metadata Basics
-
Practical example with metadata
-
Let’s start refactoring
-
Get decorator
-
Project results
-
Project files
React / Redux & TypeScript
-
Overview of React and Redux
-
Application overview
-
Creating an application
-
Simple Component
-
Interfaces & Props
-
Processing Component State
-
Unclear component state
-
Functional components
-
Installing Redux
-
Action Creators & TypeScript
-
ActionTypes Enum
-
Type Guard in Reducers
-
Binding deleteTodo Action
-
Type definition files again
-
Load Tracking Using Component State
-
Project results
-
Project files