31. In how many ways can variables be declared in TypeScript?

Variables in TypeScript can be declared in 3 ways:

1. var

var is the traditional JavaScript variable declaration.

var username = "Jitendra";

Characteristics

• Function scoped
• Can be redeclared
• Can be reassigned

2. let

let was introduced in ES6.

let age = 25;

Characteristics

• Block scoped
• Cannot be redeclared in same scope
• Can be reassigned

3. const

Used for fixed values.

const PI = 3.14;

Characteristics

• Block scoped
• Cannot be redeclared
• Cannot be reassigned

Important Interview Point

Modern TypeScript applications mainly use:

• let
• const

Avoid excessive use of:

• var

One-Line Interview Answer

“Variables in TypeScript can be declared using var, let, and const.”

*32. How do you declare explicitly typed variables?

Explicit typing means manually specifying the data type of a variable during declaration.

Syntax

let variableName: type = value;

Examples

String Variable

let username: string = "Jitendra";

Number Variable

let age: number = 25;

Boolean Variable

let isLoggedIn: boolean = true;

---

Benefits

• Improves readability
• Prevents invalid assignments
• Provides better type safety

Invalid Example

let salary: number = "50000";

TypeScript will show an error because:

• string cannot be assigned to number

Important Interview Point

Explicit typing is heavily used in:

• Enterprise applications
• APIs
• Large codebases

One-Line Interview Answer

“Explicitly typed variables are declared by manually specifying their data types using : syntax.”

*33. What are arrays in TypeScript and how do they behave?

Arrays in TypeScript are collections used to store multiple values of the same type.

TypeScript adds type safety to arrays.

Syntax

Method 1

let numbers: number[] = [1, 2, 3];

Method 2

let numbers: Array<number> = [1, 2, 3];

Example

let fruits: string[] = ["Apple", "Banana", "Mango"];

Array Behavior

• Arrays are dynamic in size.
• Elements are accessed using indexes.
• TypeScript ensures only specified types are added.

Invalid Example

let marks: number[] = [90, 80];

marks.push("Hello"); // Error

Common Array Methods

Important Interview Point

TypeScript arrays provide:

• Type safety
• Better IntelliSense
• Error prevention

One-Line Interview Answer

“Arrays in TypeScript are typed collections that store multiple values of the same data type.”

34. What are tuples in TypeScript?

Tuples are special arrays with:

• fixed size
• fixed order
• fixed data types

Each element can have a different type.

Syntax

let user: [string, number];

Example

let employee: [string, number] = ["Jitendra", 101];

Here:

• First value → string
• Second value → number

Invalid Example

let employee: [string, number] = [101, "Jitendra"];

Type mismatch occurs because order matters.

Tuple vs Array

Common Use Cases

• API responses
• Database records
• Key-value pairs

Important Interview Point

Interviewers commonly ask:

“Difference between tuple and array.”

One-Line Interview Answer

“A tuple is a fixed-size typed array where each element can have a different type.”

35. How do you create objects in TypeScript?

Objects in TypeScript are created using key-value pairs with defined types.

Syntax

let objectName: {
    property: type;
};

Example

let employee: {
    id: number;
    name: string;
} = {
    id: 101,
    name: "Jitendra"
};

Using Interface (Recommended)

interface User {
    id: number;
    name: string;
}

let user: User = {
    id: 1,
    name: "Rahul"
};

Benefits

• Better structure
• Improved readability
• Type safety

Important Interview Point

In real projects, objects are usually created using:

• interfaces
• type aliases
• classes

One-Line Interview Answer

“Objects in TypeScript are created using typed key-value pairs.”

36. How do you define optional object properties?

Optional properties are properties that may or may not exist in an object.

They are defined using the ? operator.

Syntax

propertyName?: type;

Example

interface User {
    name: string;
    age?: number;
}

Valid Objects

let user1: User = {
    name: "Jitendra"
};

let user2: User = {
    name: "Rahul",
    age: 25
};

Benefits

• Flexible object creation
• Useful for APIs/forms
• Reduces unnecessary properties

Important Interview Point

Optional properties are widely used in:

• React props
• API response models
• Form handling

One-Line Interview Answer

“Optional properties are defined using ? and may or may not exist in an object.”

*37. What are enums in TypeScript?

Enums are used to define a set of named constants.

They improve code readability and maintainability.

Syntax

enum EnumName {
    Value1,
    Value2
}

Example

enum Direction {
    Up,
    Down,
    Left,
    Right
}

Access Enum Values

console.log(Direction.Up);

Output:

0

String Enum Example

enum Status {
    Success = "SUCCESS",
    Failed = "FAILED"
}

Benefits

• Better readability
• Avoids hardcoded values
• Easier maintenance

Important Interview Point

Enums are commonly used for:

• status codes
• user roles
• application states

One-Line Interview Answer

“Enums are named constants used to represent a group of related values.”

38. Explain template literals in TypeScript.

Template literals are strings enclosed using backticks ` `.

They allow:

• string interpolation
• multi-line strings
• embedded expressions

Syntax

`Hello ${value}`

Example

let name = "Jitendra";

let message = `Hello ${name}`;

Multi-Line Example

let text = `
Welcome
to
TypeScript
`;

Benefits

• Cleaner string formatting
• Easier variable embedding
• Better readability

Important Interview Point

Template literals are heavily used in:

• React
• Dynamic HTML generation
• API messages

One-Line Interview Answer

“Template literals allow embedded expressions and multi-line strings using backticks.”

*39. How do you declare functions with typed annotations?

In TypeScript, function parameters and return types can be explicitly typed.

This improves:

• readability
• type safety
• error checking

Syntax

function functionName(parameter: type): returnType {
}

Example

function add(a: number, b: number): number {
    return a + b;
}

Void Return Example

function printMessage(message: string): void {
    console.log(message);
}

Optional Parameter Example

function greet(name?: string): void {
    console.log(name);
}

Benefits

• Prevents invalid arguments
• Better IntelliSense
• Easier debugging

Important Interview Point

Typed annotations are very important in:

• APIs
• enterprise applications
• reusable functions

One-Line Interview Answer

“Functions with typed annotations define parameter types and return types explicitly.”

*40. What are arrow/lambda functions in TypeScript?

Arrow functions are shorter syntax versions of regular functions introduced in ES6.

They are also called:

• lambda functions
• fat arrow functions

Syntax

const functionName = (parameters) => {
};

Example

const add = (a: number, b: number): number => {
    return a + b;
};

Shorter Version

const square = (num: number): number => num * num;

Benefits

• Shorter syntax
• Cleaner code
• Automatically binds this

Regular Function vs Arrow Function

Important Interview Point

Interviewers frequently ask:

“Difference between regular functions and arrow functions.”

Focus especially on:

• syntax
• this keyword behavior

One-Line Interview Answer

“Arrow functions are concise functions that use => syntax and inherit this from the parent scope.”

41. How do you define optional parameters in functions?

Optional parameters are function parameters that are not mandatory while calling the function.

They are defined using the ? symbol.

Syntax

function functionName(parameter?: type) {
}

Example

function greet(name?: string): void {
    console.log(`Hello ${name}`);
}

Function Calls

greet("Jitendra");
greet();

Both are valid.

Important Rules

• Optional parameters should come after required parameters.
• They may contain undefined if no value is passed.

Invalid Example

function test(a?: number, b: number) {}

This causes an error because optional parameters cannot appear before required parameters.

Important Interview Point

Optional parameters are commonly used in:

• APIs
• utility functions
• reusable components

One-Line Interview Answer

“Optional parameters are parameters that may or may not receive values and are defined using ?.”

42. What are default parameters in TypeScript?

Default parameters allow assigning default values to function parameters.

If no argument is passed, the default value is used.

Syntax

function functionName(parameter: type = value) {
}

Example

function greet(name: string = "Guest"): void {
    console.log(`Hello ${name}`);
}

Function Calls

greet("Jitendra"); // Hello Jitendra
greet();           // Hello Guest

Benefits

• Reduces undefined values
• Simplifies function calls
• Improves readability

Important Interview Point

Difference between:

• Optional parameter → may be undefined
• Default parameter → always has a value

One-Line Interview Answer

“Default parameters assign predefined values to parameters when no argument is passed.”

43. What are rest parameters in TypeScript?

Rest parameters allow a function to accept multiple arguments as an array.

They are represented using ... (spread operator syntax).

Syntax

function functionName(...parameter: type[]) {
}

Example

function sum(...numbers: number[]): number {
    return numbers.reduce((a, b) => a + b, 0);
}

Function Call

sum(10, 20, 30);

Benefits

• Handles variable number of arguments
• Cleaner code
• Flexible functions

Important Interview Point

Rest parameters store all extra arguments inside an array.

One-Line Interview Answer

“Rest parameters allow functions to accept multiple values as a single array parameter.”

44. What are the rules for rest parameters?*

TypeScript follows specific rules for rest parameters.

Rules for Rest Parameters

1. Only One Rest Parameter Allowed

✅ Correct:

function test(...numbers: number[]) {}

❌ Incorrect:

function test(...a: number[], ...b: number[]) {}

2. Rest Parameter Must Be Last

✅ Correct:

function test(name: string, ...marks: number[]) {}

❌ Incorrect:

function test(...marks: number[], name: string) {}

3. Rest Parameter Is Always an Array

function print(...names: string[]) {
    console.log(names);
}

Important Interview Point

Rest parameters improve flexibility in reusable functions.

One-Line Interview Answer

“A function can have only one rest parameter, and it must be the last parameter.”

45. What are anonymous functions in TypeScript?*

Anonymous functions are functions without a name.

They are usually:

• assigned to variables
• passed as arguments
• used as callbacks

Example

let greet = function (): void {
    console.log("Hello");
};

Example with Parameters

let add = function (a: number, b: number): number {
    return a + b;
};

Common Use Cases

• Callback functions
• Event handlers
• Array methods

Example in setTimeout

setTimeout(function () {
    console.log("Executed");
}, 1000);

Important Interview Point

Arrow functions are modern alternatives to anonymous functions.

One-Line Interview Answer

“Anonymous functions are functions without names, often stored in variables or used as callbacks.”

46. What are scopes/variable scopes in TypeScript?

Scope defines the accessibility and lifetime of variables in a program.

TypeScript mainly supports:

• Global Scope
• Function Scope
• Block Scope

1. Global Scope

Variables declared outside functions or blocks.

let username = "Jitendra";

Accessible everywhere.

2. Function Scope

Variables declared inside functions.

function test() {
    var age = 25;
}

Accessible only inside the function.

3. Block Scope

Variables declared using:

• let
• const

inside blocks {}.

if (true) {
    let city = "Patna";
}

Accessible only inside the block.

Important Interview Point

• var → function scope
• let and const → block scope

Interview Tip

Interviewers frequently ask:

“Difference between var, let, and const scope.”

One-Line Interview Answer

“Scope determines where variables can be accessed in a TypeScript program.”

*47. What are interfaces in TypeScript?

Interfaces define the structure or contract of an object.

They specify:

• properties
• methods
• data types

without implementing them.

Syntax

interface InterfaceName {
    property: type;
}

Example

interface User {
    id: number;
    name: string;
}

let employee: User = {
    id: 101,
    name: "Jitendra"
};

Interface with Function

interface MathOperation {
    (a: number, b: number): number;
}

Benefits

• Improves code consistency
• Enhances maintainability
• Supports abstraction

Important Interview Point

Interfaces are heavily used in:

• Angular
• React props
• APIs
• enterprise applications

Difference Between Interface and Type Alias

One-Line Interview Answer

“Interfaces define the structure or blueprint of objects in TypeScript.”

*48. What are classes in TypeScript?

Classes are blueprints for creating objects.

TypeScript classes support:

• properties
• methods
• constructors
• inheritance
• access modifiers

Syntax

class ClassName {
}

Example

class Employee {
    name: string;

    constructor(name: string) {
        this.name = name;
    }

    display(): void {
        console.log(this.name);
    }
}

Create Object

let emp = new Employee("Jitendra");
emp.display();

Benefits

• Code reusability
• Encapsulation
• Better organization

Important Interview Point

Classes are one of the core OOP features supported by TypeScript.

One-Line Interview Answer

“Classes are templates used to create objects with properties and methods.”

*49. What are access modifiers in TypeScript?

Access modifiers control the accessibility of class members.

TypeScript provides:

• public
• private
• protected

1. public

Accessible from anywhere.

class User {
    public name: string = "Jitendra";
}

2. private

Accessible only inside the same class.

class User {
    private password: string = "123";
}

3. protected

Accessible:

• inside class
• inside derived classes

class Person {
    protected age: number = 25;
}

Access Modifier Comparison

Important Interview Point

By default, members are:

public

One-Line Interview Answer

“Access modifiers control the visibility and accessibility of class properties and methods.”

*50. What object-oriented principles are supported by TypeScript?

TypeScript supports all major Object-Oriented Programming (OOP) principles.

Main OOP Principles in TypeScript

1. Encapsulation

Using access modifiers to protect data.

class User {
    private password: string = "123";
}

2. Inheritance

Child class inherits parent properties.

class Animal {
    move() {}
}

class Dog extends Animal {}

3. Polymorphism

Method overriding.

class Animal {
    sound() {
        console.log("Animal Sound");
    }
}

class Dog extends Animal {
    sound() {
        console.log("Bark");
    }
}

4. Abstraction

Using interfaces or abstract classes.

interface Shape {
    area(): number;
}

Important Interview Point

TypeScript provides strong OOP support compared to JavaScript.

One-Line Interview Answer

“TypeScript supports encapsulation, inheritance, polymorphism, and abstraction.”

51. What object-oriented terms are supported by TypeScript?

TypeScript supports most major Object-Oriented Programming (OOP) concepts.

Main OOP Terms Supported in TypeScript

Example

class Employee {
    constructor(public name: string) {}
}

Important Interview Point

TypeScript provides stronger OOP support than JavaScript because it includes:

• interfaces
• access modifiers
• abstract classes
• strong typing

One-Line Interview Answer

“TypeScript supports OOP concepts like classes, objects, inheritance, polymorphism, abstraction, and encapsulation.”

*52. What is inheritance in TypeScript?

Inheritance is an OOP feature where one class acquires properties and methods of another class.

It promotes:

• code reusability
• hierarchical relationships

Syntax

class Child extends Parent {
}

Example

class Animal {
    move(): void {
        console.log("Moving");
    }
}

class Dog extends Animal {
    bark(): void {
        console.log("Barking");
    }
}

Create Object

let dog = new Dog();

dog.move();
dog.bark();

Benefits

• Reduces duplicate code
• Improves maintainability
• Supports reusability

Types of Inheritance Supported

• Single inheritance
• Multilevel inheritance
• Hierarchical inheritance

(TypeScript does not support multiple class inheritance directly.)

Important Interview Point

TypeScript uses the extends keyword for inheritance.

One-Line Interview Answer

“Inheritance allows a child class to reuse properties and methods of a parent class.”

*53. What is method overriding in TypeScript?

Method overriding occurs when a child class provides its own implementation of a parent class method.

Example

class Animal {
    sound(): void {
        console.log("Animal Sound");
    }
}

class Dog extends Animal {
    sound(): void {
        console.log("Bark");
    }
}

Output

let dog = new Dog();
dog.sound();

Result:

Bark

Benefits

• Supports runtime polymorphism
• Allows customized behavior
• Improves flexibility

Important Interview Point

The child method must have:

• same name
• same parameters
• compatible return type

One-Line Interview Answer

“Method overriding allows a child class to redefine a parent class method.”

54. What are getters and setters in TypeScript?

Getters and setters are special methods used to:

• read object properties
• update object properties safely

They provide controlled access to class data.

Getter

Used to retrieve values.

Setter

Used to modify values.

Example

class Employee {
    private _salary: number = 0;

    get salary(): number {
        return this._salary;
    }

    set salary(value: number) {
        this._salary = value;
    }
}

Usage

let emp = new Employee();

emp.salary = 50000;

console.log(emp.salary);

Benefits

• Data encapsulation
• Validation before assignment
• Controlled property access

Important Interview Point

Getters and setters are commonly used with private variables.

One-Line Interview Answer

“Getters and setters provide controlled access to class properties.”

55. Can we create immutable/read-only object properties?

Yes. TypeScript allows creating immutable or read-only properties using the readonly modifier.

Once initialized, readonly properties cannot be modified.

Example

class User {
    readonly id: number = 101;
}

Invalid Modification

user.id = 200;

This causes an error.

Interface Example

interface Employee {
    readonly empId: number;
}

Benefits

• Prevents accidental modifications
• Improves data safety
• Useful for constants and IDs

Important Interview Point

Readonly properties can only be assigned:

• during declaration
• inside constructor

One-Line Interview Answer

“Yes, immutable properties can be created using the readonly modifier.”

*56. What is the readonly modifier in TypeScript?

The readonly modifier makes a property immutable after initialization.

Once assigned, the value cannot be changed.

Syntax

readonly propertyName: type;

---

Example

class Employee {
    readonly company: string = "OpenAI";
}

---

Invalid Operation

employee.company = "Google";

This produces an error.

Readonly in Constructor

class User {
    readonly id: number;

    constructor(id: number) {
        this.id = id;
    }
}

---

Benefits

• Data protection
• Prevents accidental updates
• Improves code reliability

Important Interview Point

Readonly variables differ from const:

• const → variable immutable
• readonly → object property immutable

One-Line Interview Answer

“The readonly modifier prevents modification of class or object properties after initialization.”

57. What is JSX in TypeScript?

JSX stands for:

JavaScript XML

It is a syntax extension that allows writing HTML-like code inside JavaScript or TypeScript.

JSX is mainly used with React Official Website.

Example

const element = <h1>Hello TypeScript</h1>;

Why JSX Is Used

• Easier UI development
• Cleaner component structure
• Better readability

JSX in TypeScript

TypeScript supports JSX using:

.tsx

files.

Important Interview Point

JSX is not valid HTML or JavaScript directly.
It gets compiled into JavaScript function calls.

One-Line Interview Answer

“JSX is an XML-like syntax used with React to create UI components inside TypeScript.”

*58. What is the difference between .ts and .tsx files?

Both .ts and .tsx are TypeScript files, but they serve different purposes.

Difference Table

Example of .ts

let age: number = 25;

Example of .tsx

const App = () => {
    return <h1>Hello</h1>;
};

Important Interview Point

Use:

• .ts → normal TypeScript
• .tsx → React components with JSX

One-Line Interview Answer

“.ts files contain TypeScript code, while .tsx files contain TypeScript with JSX syntax.”

59. What JSX modes are supported by TypeScript?*

TypeScript supports multiple JSX compilation modes through the jsx option in tsconfig.json.

Common JSX Modes

Example

{
  "compilerOptions": {
    "jsx": "react-jsx"
  }
}

Commonly Used Mode

Modern React projects mostly use:

react-jsx

Important Interview Point

react-jsx was introduced with React 17 to avoid importing React manually in every file.

One-Line Interview Answer

“TypeScript supports JSX modes like react, react-jsx, preserve, and react-native.”

*60. What are modules in TypeScript?

Modules are reusable files that contain:

• variables
• functions
• classes
• interfaces

Modules help organize code into smaller, maintainable parts.

Why Modules Are Used

• Avoid global scope pollution
• Improve maintainability
• Enable code reuse

Export Example

export function add(a: number, b: number): number {
    return a + b;
}

Import Example

import { add } from "./math";

console.log(add(10, 20));

Types of Modules

Benefits

• Better code organization
• Reusability
• Easier maintenance

Important Interview Point

Modern TypeScript applications mainly use:

• ES Modules
• import/export syntax

One-Line Interview Answer

“Modules are reusable TypeScript files that organize code using import and export statements.”