Typescript

Variable declarations using let and const

Variable naming conventions

Type annotations

Type inference

Primitive types

String, number, and Boolean types

Arrays and array typing

Tuples

Object types

The any type

The unknown type

The void type

The never type

Type assertions

Literal types and basic type narrowing

Arithmetic operators

Assignment operators

Comparison operators

Logical operators

Conditional expressions

if, else if, and else

switch statements

Loops and iteration

for, while, and do-while

break and continue

Working with typed conditions

Practical programming exercises

Function declarations and expressions

Parameter types

Return types

Optional parameters

Default parameters

Rest parameters

Arrow functions

Anonymous functions

Function type definitions

Function overloads

Callback functions

Higher-order functions

Handling optional return values

Writing reusable typed functions

Creating and declaring typed arrays

Array methods and iteration

Filtering and transforming array data

Tuple declarations

Readonly arrays and tuples

Object type definitions

Optional object properties

Readonly properties

Nested objects

Object destructuring

Array destructuring

Spread and rest syntax

Type-safe object manipulation

Introduction to interfaces

Defining object interfaces

Optional properties

Readonly properties

Extending interfaces

Interfaces for function types

Interfaces for classes

Introduction to type aliases

Creating reusable type definitions

Union types and intersection types

Interfaces versus type aliases

Practical data model design

Introduction to object-oriented programming

Classes and objects

Properties and methods

Constructors

Access modifiers: public, private, and protected

Readonly class properties

Getters and setters

Static properties and methods

Inheritance

Method overriding

Abstract classes

Implementing interfaces

Encapsulation and abstraction

Organizing classes for reusable application code

Union types

Intersection types

Literal types

Type aliases

Type guards

Narrowing with conditional statements

The typeof operator

The in operator

Discriminated unions

Type predicates

Nullable types and strict null checks

Optional chaining

Nullish coalescing

The keyof operator

The typeof type operator

Indexed access types

Introduction to generics

Generic functions

Generic interfaces

Generic classes

Type parameters

Multiple type parameters

Generic constraints

Using keyof with generics

Default generic types

Generic utility functions

Reusable data structures

Practical examples of type-safe reusable code

Introduction to modules

Exporting variables and functions

Importing modules

Named exports and default exports

Organizing code across files

Module resolution fundamentals

Working with external packages

Introduction to npm packages

Managing dependencies

Project folder structure

Separating application logic

Creating reusable components and utilities

Introduction to enums

Numeric and string enums

Literal unions as alternatives to enums

Introduction to utility types

Partial and Required

Readonly

Pick and Omit

Record

Exclude and Extract

NonNullable

ReturnType and Parameters

Combining utility types

Creating flexible and reusable type definitions

Understanding the TypeScript compiler

The tsc command

Configuring the tsconfig.json file

Target JavaScript versions

Module configuration

Strict mode

Source and output directories

Source maps

Declaration files fundamentals

Compiler errors and warnings

Build workflow

Debugging compilation issues

Organizing development and production builds

Understanding JavaScript and TypeScript compatibility

Using existing JavaScript libraries

Type declarations fundamentals

Introduction to the Document Object Model

Selecting HTML elements

Updating page content

Handling browser events

Working with typed event handlers

Form input handling

Basic client-side validation

Type-safe DOM manipulation

Handling nullable DOM elements

Building interactive browser-based features

Introduction to asynchronous JavaScript

Promises

async and await

Typing asynchronous function return values

Handling asynchronous errors

Introduction to HTTP requests

Fetch API fundamentals

Typing API response data

Interfaces for API models

Working with JSON

Error handling and loading states

Understanding API response validation

Building a basic API-driven feature

Overview of frontend frameworks and libraries

TypeScript integration in frontend projects

Introduction to Angular and TypeScript

Introduction to React with TypeScript

Typing component properties

Typing component state fundamentals

Creating reusable typed components

Understanding event and form types

Organizing frontend application code

Using TypeScript with package-based projects

Understanding framework-specific project configuration

Selecting a project idea

Gathering project requirements

Designing data models and interfaces

Creating the project structure

Implementing typed functions and classes

Applying generics where appropriate

Organizing reusable modules

Integrating an API where appropriate

Handling errors and optional values

Testing and debugging the application

Fixing type errors

Reviewing code quality and maintainability

Preparing project documentation

Demonstrating the completed project