Built-in utility types (Partial, Required, etc.)

TypeScript's built-in utility types provide powerful type manipulation capabilities: `Partial` makes properties optional, `Required` does the opposite by making properties mandatory, `Readonly` enforces immutability, `Pick` selects specific properties from a type, `Record` constructs key-value types, `Exclude` filters out assignable types, `Extract` retrieves assignable types, `Omit` removes type properties, `NonNullable` excludes `null` and `undefined`, `Parameters` extracts function parameter types, `ReturnType` gets function return types, `InstanceType` obtains constructor instance types, `ThisParameterType` extracts a function's `this` parameter, `OmitThisParameter` removes a function's `this` parameter, and `ConstructorParameters` retrieves constructor parameter types. These utility types, based on generics and conditional types, greatly simplify complex type operations and enhance development efficiency.

Basic concepts of mapping types

TypeScript's mapped types are a powerful tool for creating new types based on existing ones. They generate new types by iterating over the properties of an existing type and applying transformation rules. The basic syntax uses the `in` keyword to traverse union types. Common built-in mapped types include `Partial`, `Required`, and `Readonly`, which can manipulate property modifiers, such as adding or removing optional and readonly modifiers. TypeScript 4.1 introduced key remapping, allowing property names to be modified. Mapped types can also be combined with conditional types to achieve complex transformations, such as filtering properties or creating nullable properties. Practical applications include generating form types or wrapping API responses. Advanced patterns involve recursive mapping, union type mapping, and integration with template literal types. Utility types like `Pick`, `Omit`, and `Record` are implemented using mapped types. They can also work with type predicates and generic constraints to create more precise type guards and safer APIs. However, performance issues should be considered when handling large or deeply nested types.

Index access type

The indexed access type is a mechanism in TypeScript that retrieves the type of a property from another type through indexing. The syntax is `T[K]`, where `T` is a type and `K` is a type that can serve as an index, typically a string literal or a union type. It supports nested property access and access to array or tuple types, and can be combined with generics to implement type-safe property access functions. Indexed access types can also be used with union types, mapped types, and conditional types to achieve complex type operations, such as dynamic property access and deep property access. Practical applications include type-safe property access, component Props extraction, and API response handling. However, it is important to note that the index must be a known property name—accessing non-existent properties or dynamically computed property names requires type guards. These features make indexed access types a powerful and flexible tool in TypeScript's type system.

The `typeof` type operator

In TypeScript, the `typeof` type operator is used in type contexts to obtain the type of a variable or property. It differs from the JavaScript `typeof` operator. For variables declared with `let` or `var`, `typeof` retrieves the type annotation or inferred type, while for `const`-declared primitive variables, it yields the literal type. `typeof` can capture the complete structural type of objects and arrays, as well as the type signature of functions. It can also be used in scenarios like type guards, enums, classes, and modules. When combined with generics or advanced types, its functionality becomes even more powerful. Essentially, `typeof` is a type query operator that maintains type synchronization, but it has some limitations—such as inability to retrieve dynamically determined runtime types and capturing only the last signature for function overloads.

The `keyof` operator

TypeScript's `keyof` operator is a powerful type query tool that extracts the collection of keys from an object type, generating a union type of string or numeric literals. It is primarily used for dynamic property access and in generic scenarios. The basic usage involves applying it to an object type, returning a union type of all accessible key names. When combined with generics, it enables flexible type constraints, such as in generic functions that dynamically access object properties. It also works with complex nested types, allowing chained operations to retrieve deep key name types. It is often paired with mapped types to create type transformations, like making all properties optional or read-only. The `keyof` operator is applicable to class types as well, though care must be taken to distinguish between instance and constructor types. When handling special types like arrays or literals, its behavior may differ. It can also be used in type guards, conditional types, and index signatures. Practical applications include type-safe Redux actions, dynamic form validation, and more. Combined with template literal types, it can create interesting type compositions. Special behaviors arise when dealing with `never` and `unknown` types. It can also be paired with the `typeof` operator to obtain the key types of runtime objects. Performance considerations are important when using `keyof`, especially with large or deeply nested types.

Type checking of classes

TypeScript's type checking system is its core feature, ensuring type correctness through static code analysis. It supports all JavaScript primitive types and provides additional checking capabilities. Interfaces are the primary tool for complex type checking, while class type checking covers properties, methods, and access modifiers. Generics enable the creation of reusable components while maintaining type safety. Advanced types include union types, type aliases, intersection types, and more. Type guards narrow type scope to improve precision. Mapped types and conditional types offer powerful type transformation capabilities. The type system is based on structural typing, providing flexibility. Declaration merging affects type checking behavior. The module system has full type checking support, and decorators can be attached to class declarations, methods, properties, etc.

Private fields and naming conventions

In TypeScript, private fields are used to encapsulate internal class implementation details, preventing direct external access or modification. There are three main implementation approaches: the traditional underscore prefix, the `private` modifier, and the ES standard hash prefix. The traditional method only enforces checks at compile time and remains accessible at runtime. The WeakMap approach achieves true runtime privacy but has complex syntax. ES private fields offer concise syntax and true privacy but require support from newer engines. Private fields have specific behaviors and considerations in type checking, design patterns, testing, performance, interoperability with JavaScript, decorators, inheritance, interfaces, module systems, reflection, and more. Common naming conventions include underscore prefixes or hash prefixes, and accessor methods often follow the `get`/`set` pattern. Practical applications include protecting balance and account information in a bank account class. During testing, private fields can be accessed via type assertions. Performance varies across implementations, with ES private fields being well-optimized in modern engines.

Instance types and class types

In TypeScript, instance types and class types are core concepts of the type system. The instance type refers to the type of an object after a class is instantiated, containing instance properties and methods. The class type refers to the type of the class itself, used for operations on the class, such as factory functions, class decorators, etc. Use `typeof` to obtain the class type, which appears as a constructor signature describing how to create instances. Generic classes generate different instance types for different parameters but share the same class type. In inheritance, the instance type of a subclass includes members of the parent class, and private fields affect type compatibility. Abstract classes can serve as both class types and instance types but cannot be instantiated. Interfaces can describe the structure of class types, including static and instance members. `typeof` can obtain the class type, including static members. Utility types like `ConstructorParameters` and `InstanceType` handle constructor parameters and instance types. Decorators receive class types to modify class behavior. Mapped types and conditional types can be applied to class types to generate new types or perform type judgments.

Constructor function type

In TypeScript, constructor function types are used to describe the definitions of class constructors, specifying the parameter types required when creating class instances and the return type. They are typically used with the `new` keyword. The syntax for constructor function types involves adding the `new` keyword before the parameter list. They are commonly used in scenarios like factory functions and class decorators. These types can be broken down into two parts: the construct signature and the instance type. They support generics to enhance flexibility and ensure that subclasses meet construction requirements when dealing with class inheritance. They are particularly useful in mixin patterns. Advanced features like parameter destructuring and optional parameters are also supported. Interfaces can include construct signatures to describe constructor functions. TypeScript can infer instance types from constructor function types. Special representations are needed when handling abstract classes and private constructors. They can also represent overloaded constructors. When combined with conditional types and mapped types, more flexible constructor types can be created.

The relationship between classes and interfaces

In TypeScript, classes and interfaces are core tools for building complex type systems. Classes provide concrete implementations, while interfaces define behavioral contracts. Classes support inheritance, encapsulation, and polymorphism, whereas interfaces are purely type definitions without implementations. Classes can implement interfaces to satisfy contracts, and interfaces can inherit from classes to reuse structures. There are significant differences between classes and interfaces in terms of instantiation, inheritance, and runtime behavior. When an interface inherits a class with private members, only subclasses can implement that interface. Interfaces support describing mixed types like functions, objects, and index signatures. Abstract classes sit between regular classes and interfaces, allowing partial implementations. Interfaces with the same name automatically merge, while classes have both static and instance parts—interfaces can only constrain instance parts. Interfaces can describe function types and indexable types, differing fundamentally from type aliases. Interfaces can define read-only properties, and classes can implement multiple interfaces. Interface properties can be marked as optional, and interfaces can describe complex object structures.