TypeScript for developers

Explore JavaScript types and how TypeScript supports them, including arrays, functions, any and unknown, and type aliases, then apply with a small greeting application.

Master TypeScript primitive types and type inference, from booleans and numbers to arrays and union types, and learn how TS adds unknown, never, tuples, and enums for safer code.

Explore TypeScript arrays and tuples, including declaring string arrays, generic array types, and the map method, while noting a VS Code redeclare warning and the role of modules.

Explore how functions in TypeScript enforce parameter and string return types, address implicit any with noImplicitAny, and use optional parameters, default values, arrow functions, and rest parameters.

Compare the any and unknown types in TypeScript. Any disables type checking, while unknown requires type narrowing to safely handle external data, such as a salary from a service.

Discover how type aliases define object shapes with the type keyword, explore union types like programmer or hr, and understand that types exist only at compile time.

Build a simple TypeScript app that defines an employee type, generates random IDs with crypto, and prints welcome messages to the console in a Node.js workflow.

Explore core TypeScript features in this section, including literal types, type narrowing, optional values, type assertion, type intersection, and enums, as you continue practical practice.

Explore literal and union types in TypeScript, including type literals and unions like programmer, air, or CEO. Learn how return types and type narrowing improve safety in salary calculations.

Explore type narrowing in TypeScript 5, covering literal union types, primitives, classes, and objects, using instance of and type guards for safer code.

Explore optional values in TypeScript 5, including the optional modifier, optional class fields, optional chaining, and optional parameters, with practical examples of salaries and yearly bonuses.

Learn how type assertion in TypeScript forces a value to a different type, using simple, complicated, and QA job types, including single and double assertion techniques.

Explore type intersection and interfaces in TypeScript 5, compare types and interfaces, and learn when to use each, including declaration merging and practical examples.

Explore how TypeScript enums work, their runtime presence, and why safe usage compares values directly. Consider literal types as alternatives and the never type for future exhaustive checks.

Explain the never type in TypeScript, including when intersections yield never, how never arises from exhaustive type narrowing, and using never to enforce exhaustiveness in switch statements for enums.

Explore how TypeScript enables object oriented programming alongside functional patterns, and learn about classes, abstract classes, interfaces, and access modifiers.

Explore how TypeScript models classes with instance variables, methods, constructors, and strict initialization. Understand transpilation to JavaScript, PascalCase naming, and one class per file.

Explore class extension and method overriding in TypeScript, using super calls to initialize base state. Learn how the override keyword prevents typos and enforces correct method overrides, including access modifiers.

Explore TypeScript access modifiers—public, private, and protected—and understand how default public behavior applies to class members. Use private fields, protected access for subclasses, and constructor shortcuts to declare public members.

Explore abstract classes as base blueprints that cannot be instantiated, enforcing a contract via abstract methods like make delivery in a Project class, promoting loose coupling with TypeScript interfaces.

Define contracts with TypeScript interfaces to shape objects and enforce class implementations using implements, enabling strong typing and safer, more flexible software design.

Explore TypeScript generics and how they add parameters to types to reduce code duplication and strengthen type safety, with previews of constraints and generics for multiple types, classes, and interfaces.

Explore how generics establish a contract between function argument and return value types by wrapping any argument into an array, using a generic type T in TypeScript.

Explore two common ways to declare arrays in TypeScript using direct types and generics, then implement generic functions that return strongly typed promises for API responses.

Master bounded generics in TypeScript 5 by using extends to constrain types like objects with a team property, enabling safe, reusable functions and types with default type parameters.

Master TypeScript generics by merging objects with type-safe parameters and spread syntax. Discover how to use multiple generic types, intersection, and improved autocomplete.

Learn generic classes in TypeScript 5 by building a memory database of a generic type T with add and get operations, plus ID-based inheritance.

Explore how generics empower types and interfaces in TypeScript 5, using generic interfaces and a memory database example to illustrate strong typing for arrays and complex structures.

Explore serious types in TypeScript 5 by learning advanced types and generics, including map types, read-only signatures, and built-in utility types, with a hands-on practice session to create advanced types.

Explore immutability in JavaScript and TypeScript, noting that strings are immutable while objects are mutable. Learn to enforce it with const, as const, and read only arrays, including practical examples.

Explore index signatures and records in TypeScript, using dictionary-like objects and the Record utility to build flexible, type-safe data structures for employees and salaries.

Explore how the keyof operator derives key unions from types and enables type-safe property access with generics. See how object keys and get property utilities illustrate strong typing and compile-time guarantees.

Explore TypeScript conditional types through the ternary operator analogy, showing how salary-based examples return arrays or never, and how distributive conditional types affect unions and element types.

Explore the infer functionality in TypeScript 5 and learn to unpack arrays and promises using conditional types. See practical examples that remove prefixes with infer, building powerful type builds.

Explore how TypeScript uses literal types to form string unions from literals and prefixes, like junior programmer or awesome manager, and string manipulation types as lowercase, uppercase, uncapitalized, and capitalize.

Explore mapped types in TypeScript to transform keys, remap, and create read-only or mutable variants, building on generics and utility types to reduce duplication.

Explore TypeScript's mapped types and built-in utility types, including required, partial, and read only, plus the peak utility type, omit, and return type utilities to shape and sanitize data.

Practice advanced TypeScript types using generics and mapped types via the type challenges repository, focusing on building a custom pick type and a deep read only type through recursion.

Explore core JavaScript features, focusing on functions, promises, and asynchronous programming in JavaScript and TypeScript, and prepare for upcoming topics like function overloading.

Learn function overloading in JavaScript and TypeScript, including signatures, optional parameters, and the options object approach to clarify return types and usage.

Understand how this points to the global object and how browser, node, and TypeScript handle it. Compare regular and arrow functions to see how this binding differs, especially in classes.

Master asynchronous functions in TypeScript 5 by demystifying the event loop, promises, and async/await through clear examples of setTimeout and long tasks.

Build and use promises in TypeScript with resolve, reject, try/catch, and explicit return types, then compare sequential and parallel salary lookups using Promise.all while noting unhandled rejection warnings.

Learn how the awaited utility unwraps promise types in TypeScript 5, using return type and promises, including nested promises and simplified promise interfaces.

Delve into the TypeScript ecosystem by mastering modules and module bundling. Learn how to reference code across files with imports, and explore npm, Webpack, and Esbuild.

Understand how to reference code in JavaScript using CommonJS and ES6 modules, with require and import/export, and configure Node.js and browser environments with a local web server.

Explore javascript imports, including named and default exports, and learn about dynamic imports, renaming, and the difference between CommonJS require and ES6 import.

Initialize an npm project and configure TypeScript with tsconfig, compile src to dist, install TypeScript and node types as dev dependencies, and use build and start scripts to run output.

Explore how TypeScript enhances module handling with relative and absolute imports from node modules, trace resolution, and features like import type and import aliases, plus path mappings in tsconfig.

Explore module bundlers that merge multiple JavaScript files into a browser-ready bundle, compile TypeScript, and boost performance and browser compatibility.

Initialize a node project, install TypeScript and node types, configure tsconfig and webpack with ts-loader, create main and util files, and build a bundle in dist as bundle.js.

Create two Webpack configurations—node and web—and separate tsconfig files with npm build scripts to generate two bundles; run them in Node and the browser, addressing Uuid usage.

Explore using esbuild to bundle a TypeScript project, set up node and browser builds, integrate the Uuid library, and understand esbuild’s rapid performance from its Go implementation.

Explore the TypeScript compiler options and tsconfig.json, including what is included or excluded, target, lib, strict checks, source maps, and CLI options.

Learn how to control TypeScript 5 compilation by using include and exclude patterns, configure root and output directories (dist), and keep tests and config files out of final builds.

Learn how TypeScript targets and libs influence emitted JavaScript, affecting code features such as async functions and top level await across modern and older runtimes.

Explore TypeScript's strict checks and how tsconfig settings enforce safe initialization, strict null checks, and unknown vs any, with notes on default behaviors and version changes.

Learn how the TypeScript compiler emits declarations and source maps, uses .d.ts declaration files for documentation, and enables browser and ide debugging of TypeScript code.

Learn to invoke the TypeScript compiler from the CLI, manage multiple tsconfig.json files with extends, and use -P, --watch, and list files to inspect dependencies and sources.

Practice building a simple TypeScript npm package, export it, and observe how types work with NPM while using the dump logger package inside another project.

Develop a basic TypeScript logger package with debug, info, and error methods, using process.stdout and a uuid v4 generator, prepared for local npm packaging.

Learn to build a TypeScript package, export JavaScript and typings via main and types fields, and package with npm pack, using a .npmignore file to exclude source files.

Install and validate a local TypeScript package by building a concise logger, installing from a file, inspecting dependencies like uuid, and running node to see types and instant documentation.