Question 1

What is TypeScript and how does it benefit JavaScript developers?

Accepted Answer

TypeScript is a strongly typed superset of JavaScript that compiles down to clean, plain JavaScript. It benefits developers by adding static typing, allowing type-related errors to be caught at compile time (during code editing) rather than at runtime. It also enhances the developer experience with robust IDE autocompletion, refactoring tools, and clear API self-documentation.

Question 2

Explain the differences between Interface and Type in TypeScript.

Accepted Answer

Both declare custom object structures, but they have key differences:
1. Interfaces support declaration merging (declaring the same interface twice merges their fields), whereas Types cannot be redeclared.
2. Types support union and intersection operations: `type ID = string | number`. Interfaces are preferred for standard object declarations, and Types for complex structures.

Question 3

What is type inference in TypeScript?

Accepted Answer

Type inference is TypeScript's ability to deduce the type of a variable automatically based on its initial value, without requiring explicit type annotations. For example, if you write `let x = 5`, TypeScript automatically infers that `x` is a `number`.

Question 4

What is the 'any' type, and why should it be avoided?

Accepted Answer

The `any` type disables type checking for a variable, instructing TypeScript to allow any operations on it. Using `any` defeats the purpose of TypeScript, exposing the application to runtime type crashes. Use `unknown` instead when handling dynamic variables.

Question 5

What is the difference between 'unknown' and 'any'?

Accepted Answer

Both represent values of any type. However, `any` is completely unchecked, while `unknown` is safe. You cannot perform operations on an `unknown` variable (like accessing attributes or invoking it) without first narrowing its type using type guards or assertions.

Question 6

Explain Union types and Intersection types.

Accepted Answer

Union types (`A | B`) allow a variable to hold any one of several types. Intersection types (`A & B`) combine multiple type definitions into a single type containing all properties of the intersected types.

Question 7

What is the 'never' type in TypeScript and when is it used?

Accepted Answer

The `never` type represents values that will never occur. It is used to declare return types for functions that never return (e.g. infinite loops or functions that always throw errors) and for exhaustive checks in switch blocks.

Question 8

Explain Tuple types in TypeScript.

Accepted Answer

Tuples are arrays with a fixed number of elements, where the types of each element are known and ordered: `const coords: [number, number] = [40.7, -74.0]`. Attempting to insert a different type or wrong length throws errors.

Question 9

What are Enums in TypeScript and their compiler outputs?

Accepted Answer

Enums allow declaring named constants: `enum Status { Active, Inactive }`. By default, they compile to JavaScript objects supporting reverse lookups, unless declared as `const enum`, which has zero runtime footprint because it compiles to raw values.

Question 10

What is the purpose of the tsconfig.json file?

Accepted Answer

`tsconfig.json` is the configuration file for the TypeScript compiler (`tsc`). It specifies compiler options, directories to include or exclude, output directories, and type-checking rules (like `strict`).

Question 11

Explain optional properties and optional chaining in TypeScript.

Accepted Answer

Optional properties are defined using `?` in types: `interface User { age?: number }`. Optional chaining (`user?.profile?.name`) evaluates to `undefined` if any reference in the chain is nullish, preventing null pointer crashes.

Question 12

What are Type Assertions in TypeScript?

Accepted Answer

Type Assertions (`value as string` or `<string>value`) instruct the compiler to treat a variable as a specific type, overriding type inference. They do not perform any runtime checks or modifications.

Question 13

Explain read-only properties and Readonly utility types.

Accepted Answer

The `readonly` modifier makes object properties immutable after initialization: `interface Config { readonly port: number }`. The `Readonly<T>` utility type makes all properties of an object type read-only.

Question 14

What is the difference between void and never return types?

Accepted Answer

`void` means a function completes execution but returns no value (returns `undefined` implicitly). `never` means the function never completes execution (e.g., it crashes or loops infinitely).

Question 15

What are declaration files (.d.ts) in TypeScript?

Accepted Answer

Declaration files contain only type definitions and no runtime code. They are used to describe the shape of JavaScript code (like third-party npm modules) so TypeScript can provide compile-time checking for them.

Question 16

Explain string and numeric literal types.

Accepted Answer

Literal types restrict variables to exact values: `type Action = 'ADD' | 'REMOVE'`. A variable of type `Action` can only hold those exact strings, preventing typos.

Question 17

What is the 'as const' assertion?

Accepted Answer

The `as const` assertion creates a readonly literal type. It prevents widening of arrays and objects into generic types, making all nested properties readonly constants.

Question 18

Explain the non-null assertion operator (!).

Accepted Answer

The non-null assertion operator (`!`) tells the compiler that a variable is not `null` or `undefined`, overriding strict null check warnings. It should be used sparingly since it can hide runtime bugs.

Question 19

What is type widening in TypeScript?

Accepted Answer

Type widening is when TypeScript assigns a wider type to a variable than its literal value (e.g., inferring `let x = 'hello'` as `string` instead of `'hello'`), permitting reassignment to other strings.

Question 20

Explain how TypeScript compiles class property access modifiers.

Accepted Answer

TypeScript supports `public`, `private`, and `protected` modifiers. They restrict access during compilation, but compile down to standard JS classes where all fields are public, unless ES6 private fields (`#`) are used.

Question 21

Explain Generics in TypeScript and write a generic utility function.

Accepted Answer

Generics allow components and functions to work with multiple types rather than a single type, creating reusable code that maintains type safety. You pass the type parameter using angle brackets:
```typescript
function getFirstElement<T>(arr: T[]): T | undefined {
  return arr[0];
}
```
This ensures that if you pass an array of numbers, the return type is checked as a number, and if you pass strings, it is treated as a string.

Question 22

What are Type Guards in TypeScript? Write a custom type guard.

Accepted Answer

Type Guards narrow the type of a variable within a conditional block. A custom type guard uses a type predicate (`parameterName is Type`) as its return type:
```typescript
interface User { name: string; email: string }

function isUser(obj: any): obj is User {
  return obj && typeof obj.name === 'string' && typeof obj.email === 'string';
}
```
When called inside an `if` block, TypeScript automatically assumes the variable is a `User` inside that scope.

Question 23

Explain TypeScript Utility Types: Partial, Required, Pick, and Omit.

Accepted Answer

TypeScript includes built-in utility types to transform types: - `Partial` makes all properties of `T` optional. - `Required` makes all properties of `T` required. - `Pick` creates a type by selecting a specific set of keys `K` from `T`. - `Omit` creates a type by removing a specific set of keys `K` from `T`.

Question 24

What is mapped type in TypeScript? Write an example.

Accepted Answer

Mapped types allow you to create new types based on the properties of an existing type, iterating over keys using `keyof`:
```typescript
type ReadOnlyUser<T> = {
  readonly [P in keyof T]: T[P];
};
```
This maps over each key `P` in type `T` and appends the `readonly` flag.

Question 25

Explain index signatures and Record types.

Accepted Answer

Index signatures define type boundaries for objects where key names are unknown: `interface Settings { [key: string]: boolean }`. The `Record` utility is a shortcut for the same pattern: `const config: Record = { debug: true }`.

Question 26

Explain how to test TypeScript components using mock type interfaces.

Accepted Answer

In tests, you assert values against typed mock structures. Use utility types like `DeepPartial<T>` to create incomplete mocks of large interfaces without compiler errors, and check return structures against target signatures.

Question 27

What are index access types and keyof operations?

Accepted Answer

`keyof` extracts a union of keys from an object type: `type UserKeys = keyof User`. Index access types extract the type of a specific property: `type Age = User['age']`, which helps share nested type references.

Question 28

How does TypeScript perform type compatibility checks?

Accepted Answer

TypeScript uses structural typing (duck typing). Two types are compatible if they share the same structure, regardless of nominal declarations. If an object has all properties required by an interface, it is compatible.

Question 29

Explain how to debug TypeScript compilation speeds.

Accepted Answer

To profile slow builds, run compilation with `--diagnostics` or `--generateCpuProfile`. This outputs parser and checker durations, helping locate complex recursive types or excessive import paths.

Question 30

What are conditional types in TypeScript?

Accepted Answer

Conditional types select types based on a condition: `Type extends OtherType ? TrueType : FalseType`. They enable creating dynamic type mappings that resolve based on parameter types.

Question 31

Explain how to configure path aliases in tsconfig.json.

Accepted Answer

Set the `baseUrl` property and specify patterns under `paths`. This maps modules (e.g. `@services/*` to `./src/services/*`), keeping imports clean and independent of relative folder levels.

Question 32

What is the difference between type guard and type assertion?

Accepted Answer

A type guard performs checks at runtime to narrow types inside conditional blocks safely. A type assertion is a compile-time cast that forces the compiler to trust your type, bypassing safety checks.

Question 33

Explain template literal types in TypeScript.

Accepted Answer

Template literal types construct custom types by combining string components using template syntax: `type Event = `on${'Click' | 'Hover'}``. This yields the union `'onClick' | 'onHover'`.

Question 34

What is the readonly array modifier?

Accepted Answer

The `ReadonlyArray<T>` type defines an immutable array. Modifying elements or calling mutator methods (like `push`, `pop`, `reverse`) throws compiler errors, preventing state mutation bugs.

Question 35

How do you define types for third-party JS modules without types?

Accepted Answer

Create a local declaration file (e.g. `declarations.d.ts`) and declare the module: `declare module 'untyped-library';`. This prevents compilation errors and types imports from it as `any`.

Question 36

What is the difference between keyof and typeof?

Accepted Answer

`typeof` extracts a type representation from a JavaScript variable value: `type UserType = typeof userObj`. `keyof` extracts a union of keys from a TypeScript type definition.

Question 37

How do you enforce strict type checking in configurations?

Accepted Answer

Enable `strict: true` in `tsconfig.json`. This turns on checks like `noImplicitAny`, `strictNullChecks`, and `strictFunctionTypes` to guarantee strict type safety.

Question 38

Explain the Parameters and ReturnType utility types.

Accepted Answer

- `Parameters` extracts parameter types from a function type `T` as a tuple. - `ReturnType` extracts the return type of function type `T`, which is useful when mapping async actions.

Question 39

What is compile-time type-safety vs runtime type-safety?

Accepted Answer

TypeScript ensures compile-time safety; types are stripped at compilation and do not exist at runtime. Runtime safety requires executing code validators (like Zod) to check variables.

Question 40

How do you debug TypeScript types using compiler utility options?

Accepted Answer

Use options like `noImplicitReturns` and `noUnusedLocals` in `tsconfig.json` to highlight structural errors and clean up unused code imports automatically during builds.

TypeScript Interview Questions for Freshers (2026)

What is TypeScript and Why is it Critical in Modern Engineering?

TypeScript Lifecycle Visualizer

Core Architectural Concepts in TypeScript

Static Type Checking

Generics & Constraints

Union & Intersection Types

Utility Types (Partial, Pick)

Type Guards & Assertions

check_circleWhy Modern Companies Choose TypeScript

lightbulbStrategic Preparation Tips

errorCrucial Mistakes to Avoid

trending_upHiring Trends & Career Outlook (2026)

Basics