microsoft/TypeScript-HandbookArchived

Features

• TypeScript Learning Paths - Serves as a comprehensive educational resource for learning TypeScript syntax and its type system.
• Type-Based Data Modeling - Provides techniques for creating reusable structures and shorthand aliases to model complex data shapes.
• Literal Types - Explains how to limit variables or parameters to specific constant string or numeric values.
• External Library Type Mappings - Covers the use of declaration files to provide type safety for external JavaScript libraries.
• Compiler Configurations - Provides detailed configuration of compiler behavior and module resolution via JSON settings.
• Static Code Analyzers - Provides instructions on using static analysis to identify potential errors and bugs before program execution.
• TypeScript Configurations - Covers the configuration of the TypeScript compiler and build pipelines to target specific JavaScript environments.
• Strictness Levels - Allows adjustment of type validation strictness to balance leniency with rigorous error checking.
• Ambient Type Declarations - Teaches how to write declaration files using API patterns to enable type-checking for JavaScript libraries.
• TypeScript Transpilers - Explains the high-speed transpilation of TypeScript source files into plain JavaScript.
• Conditional Types - Explains how to use conditional types to determine resulting types based on input assignability.
• Function Signature Declarations - Teaches how to define function types and overloads to ensure type-safe imports.
• Function Overloading - Guides the specification of multiple valid signatures for a single function to support varied input and output types.
• Function Signatures - Details the specification of input parameters and return types to ensure function type safety.
• Function Type Definitions - Provides detailed methods for specifying expected parameters and return types for functions.
• Generic Classes - Teaches how to create classes with type parameters for flexible, type-safe instantiation.
• Generic Components - Details the creation of functions, interfaces, or classes that maintain type precision across various input types.
• Generic Types - Provides comprehensive guidance on using type parameters to create reusable functions, classes, and types.
• Generic Functions - Explains how to establish type correspondence between input and output values using type parameters in functions.
• Generic Type Constraints - Explains how to restrict type parameters to types that satisfy a specific shape for compile-time safety.
• Conditional Type Constraints - Covers the narrowing of generic types within specific logical branches to ensure required properties.
• Type Parameter Inference - Explains how the compiler automatically infers generic type arguments based on provided values.
• Interfaces - Explains how to define interfaces to enforce object shapes and structural type safety.
• JavaScript Compilers - Transforms high-level typed source code into executable JavaScript.
• JavaScript Module Type Signatures - Guides the creation of type signatures for JavaScript codebases using CommonJS and ES Module patterns.
• JavaScript Static Analysis - Guides users on validating standard JavaScript files for type errors using configuration files and JSDoc.
• Source-to-JavaScript Transpilers - Provides guidance on converting typed TypeScript source files into plain JavaScript for runtime compatibility.
• Discriminated Unions - Explains how to use tagged unions to differentiate between members of a union type for safe runtime access.
• External Library Definitions - Describes how to use ambient declarations to map the shapes of external JavaScript libraries for type safety.
• Generic Containers - Describes how to define data structures using type parameters to hold varying types safely.
• Type Aliases - Provides instructions for creating reusable named aliases for complex or frequently used type definitions.
• Type Narrowing - Describes how to refine variable types through runtime checks and control-flow analysis.
• Explicit Variable Typing - Teaches the use of type annotations to specify expected data shapes for variables and function arguments.
• Module Export and Import Systems - Provides comprehensive guidance on sharing variables, functions, and types using ES module and CommonJS patterns.
• Module Organization - Guides the organization of code into reusable modules and manages interoperability between different module systems.
• Module Output Customizations - Explains how to configure the JavaScript version and module format of emitted code for runtime compatibility.
• Nullability Handling - Teaches how to handle absent values using strict null checks and non-null assertion operators.
• Object Key Extractors - Explains how to generate a union of literal keys from an object type using the keyof operator.
• Object Type Transformations - Details how to modify property names during type transformation using template literals and conditional types.
• Primitive Types - Covers the use of basic built-in primitive types like string, number, and boolean for type safety.
• JSDoc Type Checking - Details the integration of type safety into existing JavaScript projects using JSDoc annotations and declaration files.
• Conditional Types - Details the use of conditional types to evaluate types against logical conditions during the compilation process.
• Declaration Merging - Covers declaration merging, allowing multiple declarations of the same name to be combined into one entity.
• Source Code Compilers - Provides the core capability of transforming TypeScript source code into JavaScript.
• Static Type Definitions - Demonstrates how to assign specific data types to variables and functions to catch errors during development.
• String Literal Type Manipulations - Details how to automate type definitions using conditional types, mapped types, and template literals.
• Structural Class Compatibility - Explains how the type system determines compatibility between classes based on their members rather than names.
• Third Party Library Typing - Provides instructions on integrating third-party type declarations via package managers for external library analysis.
• Type Assertions - Provides techniques for overriding inferred types when the developer has specific knowledge of a value's type.
• Type Casting - Demonstrates how to force a value to be treated as a specific type via type tags.
• Type Checking Bypasses - Explains the use of special types to disable compiler errors for specific values.
• Type Declaration Files - Provides comprehensive guidance on writing declaration files to enable type safety for external JavaScript dependencies.
• Type Declaration Specification - Describes how to specify valid types and signatures for JavaScript code using declaration files.
• Type Inference from Values - Teaches how to extract type information from existing values to ensure consistency between data and types.
• Type Checking - Covers the process of verifying if a value satisfies a specific type during compilation.
• Union Types - Covers combining multiple types into one to represent a value that may be any of the specified members.
• User-Defined Types - Details the construction of custom types, interfaces, and generics to enforce data shapes.
• External Library Type Declarations - Explains how to create type definitions for JavaScript libraries via global variables, modular imports, or UMD patterns.
• Object Type Composition - Provides instructions on using interfaces and intersections to compose and extend object types.
• Object Types - Explains how to specify required properties and types for objects using various declaration methods.
• Type Aliases - Provides guidance on creating shorthand names for complex types to improve code maintainability.
• Static Type Error Detectors - Implements static analysis to identify type errors and structural incompatibilities without executing the program.
• TypeScript Advanced Type Features - Guides the design of complex data structures using advanced features like generics, conditional types, and mapped types.
• Type Transformations - Covers the use of mapped types to create new types by iterating over and transforming an existing type's keys.
• Declaration Merging - Explains how to add new members to existing interfaces or classes by declaring another interface with the same name.
• Mapped Type Transformations - Describes the use of mapped types to iterate over keys and transform object structures.
• JSDoc Type Annotations - Enables static type checking of standard JavaScript files using JSDoc annotations.
• Automated Type Generation - Supports the automatic generation of .d.ts files from source code to provide static type information.
• Structural Typing and Inference - Provides a comprehensive guide to TypeScript's structural type system where compatibility is based on object shape.
• Advanced Type Transformations - Provides a guide to modeling complex data using conditional and mapped type transformations.
• Static Type Checking - Details how to perform static type checking to verify consistency and generate declaration files.
• Intersection Types - Describes how to combine multiple types into a single type that requires all members using intersection operators.
• Optional Property Declarations - Explains the syntax for declaring optional properties in object types to make them non-mandatory.
• Compilation Pipelines - Describes how to orchestrate the transformation of source code into browser-ready assets via compilation pipelines.
• Generic Type Defaults - Explains how to provide fallback types for generic parameters to make them optional for consumers.
• Editor Productivity Enhancements - Leverages the type system to provide auto-complete, jump-to-symbol, and refactoring capabilities within JavaScript editors.
• Declaration Generation - Explains how to generate type declaration files from JavaScript using JSDoc to enable type-powered editor experiences.
• Code Intelligence Providers - Enables real-time code completion and navigation by providing semantic code intelligence based on type information.
• Dependency Declarations - Provides guidance on using directives and import statements to declare external library dependencies for correct type resolution.
• Module Interoperability - Explains how to bridge the functional gap and ensure compatibility between CommonJS and ES module systems.
• Class Inheritance - Covers extending base classes to derive new classes that inherit all parent properties and methods.
• Generic Base Class Extension - Demonstrates how to pass type arguments to a base class when inheriting from a generic parent.
• Class Member Access - Covers the use of visibility modifiers to define public, private, and protected class properties.
• Static Methods - Describes how to define properties and methods that belong to the class constructor rather than instances.
• Class Method Overrides - Guides the explicit identification of methods that replace implementations from a base class.
• Static This-Context Typing - Shows how to statically enforce the calling context using explicit this parameters and arrow functions.
• Incremental Compilation - Describes the incremental compilation model that re-compiles only affected parts of a project to speed up development.
• Index Signatures - Describes how to use index signatures to define objects with unknown property names.
• Interface Contract Implementations - Describes using the implements clause to ensure a class satisfies a specific interface contract.
• Module Resolvers - Details the use of configurable lookup engines to resolve import strings to actual files using various strategies.
• CommonJS-ESM Interoperability - Covers the interoperability between different module systems like ESM and CommonJS.
• Downlevel Compilers - Explains the process of rewriting modern language features into older JavaScript versions for legacy environment support.
• Exhaustiveness Checks - Demonstrates how to use the never type to ensure all members of a discriminated union are handled.
• Excess Property Checks - Explains excess property checking to identify bugs when passing extra properties to typed object literals.
• Type-Only Imports - Describes how to import type signatures without adding runtime code or triggering module resolution.
• Cross-Package Type Imports - Guides the management of required type definition packages via package metadata.
• Namespace-Type Merging - Explains how to create a single declaration that possesses properties of both a namespace and another type.
• Type Namespace Organization - Shows how to group related types and values into logical hierarchies using dotted notation to prevent global scope pollution.
• Namespace Merging - Describes how to join multiple namespaces with the same name to combine their exported members.
• Fixed Length Array Definitions - Guides the use of tuple types to specify arrays with a fixed length and specific element types.
• Custom Type Guards - Provides instructions on creating user-defined functions with type predicates for manual type narrowing.
• This-Based Type Guards - Details how to use this-based type guards in method return types to narrow instance types in conditional blocks.
• Constructor Parameter Properties - Provides guidance on using parameter properties to automatically create and assign class fields via visibility modifiers.
• Read-Only Properties - Explains the syntax for declaring class properties that cannot be reassigned after their initial assignment.
• Type Declaration Registries - Describes how to map JavaScript packages to type definition files for distribution to consumers.
• Global Type Augmentations - Explains how to extend the global namespace with custom type definitions to support libraries that modify built-in prototypes.
• Ambient Module Augmentations - Explains type definition patterns for extending third-party library signatures using declaration files.
• Abstract Classes - Explains the creation of base classes that lack implementations to force derived classes to provide logic.
• Declaration Files - Explains how to mirror a JavaScript library's directory structure within declaration files to support deep imports.
• Type Component Extraction - Covers advanced type manipulation using the infer keyword to extract return types or element types.
• String Literal Construction - Details how to create new string literal types by combining concrete strings or unions.
• Template Literal Types - Explains the use of template literal types for string interpolation and pattern validation at compile time.
• Class Member Annotations - Details how to define class properties and methods with type annotations and read-only modifiers.
• Decorator Annotations - Covers attaching decorators to classes and members to modify or observe their definitions at runtime.
• Custom Decorator Definitions - Details the use of decorator factories to pass custom arguments and configure decorator behavior.
• Distributive Conditional Types - Covers how conditional types distribute over unions to enable advanced type mapping.
• Complex Module Type Definitions - Teaches how to create custom types and generics within declaration files for rich JavaScript API type information.
• Member Visibility Control - Guides the use of public, protected, and private modifiers to encapsulate internals from external code.
• Optional Parameter Markers - Explains how to mark function parameters as optional or provide default values for flexible API design.
• Decorator Composition - Explains how to apply multiple decorators to a single declaration and the order of their execution.
• Decorator Metadata Emission - Describes emitting design-time type metadata for decorated declarations to support runtime reflection.
• Template Literal Types - Explains how to derive and constrain types using string patterns and template literals.
• Constant Enums - Details the use of constant enumerations to improve performance by inlining values at compile time.
• Object Property Type Extractors - Explains how to extract specific property types from an object using keyof operators and indexed access types.
• DOM Element Typing - Provides instructions on applying strict TypeScript types to HTML and SVG elements for safer DOM manipulation.
• JSX Transformers - Details the transformation of JSX syntax into standard JavaScript function calls.
• JSX Type Definitions - Explains how to customize the expected return types of JSX expressions and components via interface overrides.
• Programming Languages - Official documentation for language features and usage.
• Learning Resources - The official comprehensive guide for learning language syntax and features.

Star history