TypeScript TypeScript Functions & Modules

Question 1

What is the correct way to define function overloads in TypeScript?

Accepted Answer

Declare multiple call signatures before a single implementation signature

Answer

Define multiple function bodies with the same name

Answer

Use the `overload` keyword before each variant

Answer

Use union types in both parameter and return positions only

Question 2

Which syntax correctly marks a function parameter as optional in TypeScript?

Accepted Answer

function greet(name?: string): string

Answer

function greet(name: string = optional): string

Answer

function greet(optional name: string): string

Answer

function greet(name: string | void): string

Question 3

What does a `never` return type indicate in TypeScript?

Accepted Answer

The function never completes normally — it always throws or loops forever

Answer

The function returns undefined when it completes

Answer

The function always returns null

Answer

The function has no explicit return statement

Question 4

How are rest parameters typed in TypeScript?

Accepted Answer

function f(...args: string[]): void

Answer

function f(...args: any): void

Answer

function f(...args: Array): void

Answer

function f(args...: string): void

Question 5

How does `this` behave inside an arrow function in TypeScript?

Accepted Answer

It inherits `this` from the enclosing lexical scope at definition time

Answer

It is always bound to the global object

Answer

It is always typed as `undefined` in strict mode

Answer

It is typed as `any` unless explicitly annotated

Question 6

What does a `void` return type signify in TypeScript?

Accepted Answer

The return value of the function is not intended to be observed or used

Answer

The function must return `null` explicitly

Answer

The function cannot contain any return statement

Answer

The function returns `undefined` only when called with no arguments

Question 7

Which syntax correctly declares a generic function in TypeScript?

Accepted Answer

function identity<T>(arg: T): T { return arg; }

Answer

function identity[T](arg: T): T { return arg; }

Answer

generic function identity(T)(arg: T): T { return arg; }

Answer

function identity(arg: generic): generic { return arg; }