TypeScript

TypeScript is a statically typed superset of JavaScript that adds type checking and other developer tooling improvements.

TypeScript helps catch bugs earlier, improves tooling, and makes large codebases easier to maintain.

A superset is a language that extends another language without removing its features.

TypeScript is compiled to JavaScript before execution, so the runtime is still JavaScript.

The TypeScript compiler, usually invoked as `tsc`, converts TypeScript code into JavaScript.

`tsconfig.json` configures the TypeScript compiler and project settings.

`strict` enables stricter checks like `noImplicitAny`, `strictNullChecks`, and others.

It disallows implicit `any` types, which helps catch mistakes earlier.

It prevents `null` and `undefined` from being assigned to types unless explicitly allowed.

JavaScript is the language executed by browsers and Node.js with dynamic typing.

Types describe the kind of value a variable or function can hold.

They improve readability, catch bugs, and enable editor support.

A variable stores a value that can be used later in code.

`let` declares a block-scoped variable.

`const` declares a block-scoped constant that cannot be reassigned.

`let` can be reassigned; `const` cannot be reassigned.

A primitive type is a basic value type, such as `string`, `number`, `boolean`, `null`, `undefined`, or `symbol`.

`string` represents textual data.

`number` represents numeric values, including integers and decimals.

`boolean` represents `true` or `false`.

`null` represents an intentional absence of a value.

`undefined` means a value has not been assigned yet.

`any` disables type checking for a value and should be used carefully.

Because it removes the safety TypeScript provides.

A function is a reusable block of logic.

Example: `function greet(name: string): string { return name; }`

A parameter is a value passed into a function.

A return type describes the value a function returns.

A function signature includes the parameter types and return type.

An object type defines the shape of an object, including properties and their types.

An interface declares the structure of an object, function, or class contract.

A type alias gives a name to a type, such as a primitive, object, or union.

An array is a collection of values.

It is an array of numbers.

It is a shorthand for an array of numbers.

A tuple is an array with a fixed number of positions and potentially different types.

An enum defines a set of named constants.

A union allows a value to be one of several types.

An intersection combines multiple types into one.

`unknown` is a type that represents values without knowing their type, requiring a type check before use.

`never` represents values that never occur, such as a function that always throws.

`void` means a function returns no meaningful value.

`??` returns the right side only when the left side is `null` or `undefined`.

`?.` safely accesses nested property values without crashing on `null` or `undefined`.

`as` tells TypeScript to treat a value as a specific type.

A type assertion is a compile-time declaration that a value has a given type.

A const assertion preserves literal types and prevents widening.

`readonly` prevents reassignment of a property after initialization.

A class is a template for creating objects with data and methods.

A method is a function defined on a class.

A constructor initializes a new instance of a class.

A property is a value stored on an object or class instance.

`public` means the property or method is accessible from outside the class.

`private` restricts access to the class itself.

`protected` allows access only inside the class and subclasses.

Inheritance allows a class to extend another class and reuse its behavior.

A generic allows types to be parameterized and reused across multiple values.

It represents an array of values of type `T`.

A generic function accepts type parameters for flexibility.

A module is a TypeScript file that can export and import code.

`export` makes a value available to other modules.

`import` brings values from another module into the current file.

A default export is the main exported value from a module.

A named export exposes a particular symbol from a module.

A namespace groups values and types under a common name.

`ts-node` runs TypeScript files directly without a build step.

`tsc` is the TypeScript compiler.

Transpile means converting TypeScript to JavaScript.

It sets the JavaScript version the compiler emits.

It sets the module system emitted, such as CommonJS or ESNext.

A literal type is a specific value such as `"admin"` or `42`.

It allows a type to be built from string patterns.

`keyof` gets the keys of an object type.

`typeof` gets the type of a value or expression.

It narrows values to literal types and prevents mutation.

A type guard narrows a union to a more specific type at runtime.

It checks whether a property exists on an object.

`instanceof` checks whether an object is an instance of a class.

`satisfies` checks that a value matches a type without widening it.

A declaration file provides type definitions for JavaScript libraries.

It is the extension for TypeScript declaration files.

`lib` configures which standard-library type definitions are included.

It includes browser APIs and types such as `window` and `document`.

It enables the latest ECMAScript type definitions.

Incremental compilation stores build information to speed up future compiles.

Because browsers and Node.js do not natively run TypeScript.

A package like `@types/node` or `@types/react` provides TypeScript types for a JS library.

`npm` is the package manager used to install JavaScript and TypeScript dependencies.

An import used only for types, often written as `import type`.

It is used to represent impossible states, often in exhaustive checks.

An index signature allows an object to have dynamic keys with a given type.

`Record<K, T>` creates an object type with keys of type `K` and values of type `T`.

`Partial<T>` makes all properties optional.

`Required<T>` makes all properties required.

`Pick<T, K>` creates a type using only selected keys.

`Omit<T, K>` creates a type without selected keys.

It is an array type whose contents cannot be mutated.

It extracts values from arrays or objects into variables.

Example: `const { name } = user;`

Example: `const [first, second] = items;`

Type inference lets TypeScript infer types automatically without explicit annotation.

It reduces boilerplate while keeping type safety.

Contextual typing infers types from the surrounding code, such as function arguments or object literals.

Function overloads let one function accept multiple signatures.

To model APIs that accept different parameter combinations.

A rest parameter collects multiple arguments into an array.

A spread operator expands arrays or object values into other arrays or objects.

A labeled tuple element gives names to tuple positions.

TypeScript can model `this` within methods and functions.

A field initializer assigns an initial value to a class property.

A getter computes a property value dynamically.

A setter assigns a value when a property is set.

An abstract class cannot be instantiated directly and may define abstract methods.

An abstract method must be implemented by subclasses.

It inherits the properties and methods of the base interface.

It promises to satisfy the interface contract.

A subclass provides a new implementation of a parent method.

Polymorphism allows different objects to be handled through a shared interface or base class.

A discriminated union uses a common property to distinguish variants.

It is used to assert that all union variants have been handled.

A mapped type transforms all properties of an existing type.

It lets you derive a new object type from the keys of an existing type.

It is the type for template literal strings with dynamic substitutions.

A conditional type creates a type based on a condition.

`infer` extracts a type from another type within a conditional type.

It is a tuple type that can accept a variable number of elements.

A generic constraint limits which types can be used for a generic parameter.

Example: `T extends Record<string, unknown>`.

It is a fallback type used if no type is explicitly provided.

Declaration merging combines multiple declarations of the same symbol.

It allows multiple interface declarations to be combined.

It adds extra declarations to an existing module.

It imports only types and excludes runtime JS output.

It exports a type only, without any runtime value.

Interfaces are open and mergeable; type aliases are more flexible but not mergeable.

TypeScript checks compatibility by structure rather than by inheritance hierarchy alone.

It allows compatible object shapes to be used interchangeably.

Duck typing is the idea that if an object has the needed properties and methods, it is considered compatible.

A function type describes a callable value.

A callback type is a function passed as a parameter to another function.

An async function returns a Promise.

It represents a future value of type `T`.

`await` waits for a promise to resolve before continuing.

It handles runtime errors in synchronous and async code.

A Promise that fails and causes an error path in async code.

`unknown` is safer because it requires checking before use.

It represents an object with string keys and unknown values.

A readonly array prevents mutation.

TypeScript narrows a union based on literal values.

It ensures a switch statement handles every possible variant.

In JavaScript, numeric enums create reverse mappings, which can be surprising.

A string enum holds string values.

They are often simpler and easier to reason about in modern TypeScript.

A type predicate is an assertion used by type guards to narrow types.

A function that returns `value is SomeType`.

It is a type predicate form that asserts a condition rather than returning a narrowed value.

It often appears when parsing unknown data from external sources.

It uses optional chaining and checks to prevent `null` or `undefined` errors.

Type widening broadens a literal into a wider primitive type.

Type narrowing refines a broader type into a more specific one.

Example: `T["prop"]` selects the type of a property.

It produces the keys common to the union.

It gets the return type of a function type.

It gets the parameter tuple of a function type.

It gets the constructor parameter tuple of a class type.

It gets the instance type of a constructor function or class.

An interface can extend a class type and inherit members from it.

Compatibility is impacted by private fields, because TypeScript checks that private members match exactly.

It is accessible within the class and derived classes.

TypeScript chooses the most appropriate overload signature for a call.

A default generic lets a type parameter have a default if not specified.

It models the calling context explicitly in function signatures.

It can be used to model fluent APIs.

It is common when elements are typed more generally than their actual interface.

It ensures object literal shapes match a type without losing specific literal types.

It preserves literal values and prevents accidental widening.

It is when TypeScript generates `.d.ts` files for compile output.

It generates declaration files alongside output JavaScript.

It emits only type declaration files, not JavaScript.

TypeScript types are erased at runtime; they only exist for tooling and static checks.

A function that takes or returns functions.

It combines small functions into a larger pipeline.

Currying transforms a function with multiple arguments into a sequence of functions taking one argument at a time.

It is a design pattern for wrapping values and chaining operations, often represented by `Promise`, `Maybe`, or custom types.

A `Result` type often encodes success or failure without throwing exceptions.

`Either` is a type representing two possible outcomes, often used for error handling.

It models optional values without `null`/`undefined` checks everywhere.

It is using types themselves to express computations and constraints.

A type that refers to itself, such as a tree or linked list.

Example: `type Tree = { value: string; children: Tree[] }`

It allows renaming keys or creating derived object shapes.

It allows building object keys or types from string patterns.

A branded type uses a unique property to distinguish semantically different values with the same runtime representation.

A nominal system distinguishes types by name, not just shape.

TypeScript is mostly structural, though brands can emulate nominal behavior.

A type-level function computes a new type based on input types.

It extracts a type from a conditional type and helps create complex type utilities.

It distributes over unions, which can change the resulting type behavior.

It augments the global namespace in TypeScript.

TypeScript is not just about types; it is about creating safer, more expressive, and more maintainable code while still running on JavaScript runtimes.