BudiBaduQuiziBadu

TypeScript Optional and Default Parameters Quiz

TypeScript
0 Passed
0% acceptance

A 30-question TypeScript quiz exploring optional parameters, default parameter values, undefined handling, rest parameters, function declaration rules, and parameter type inference.

30 Questions
~60 minutes
1

Question 1

What does a question mark after a parameter name represent?

A
The parameter is optional
B
The parameter must be null
C
The parameter can only be a boolean
D
The parameter is readonly
2

Question 2

What type does an optional parameter implicitly include?

A
undefined
B
null
C
never
D
unknown
3

Question 3

What is the type of msg?

typescript
function log(msg?: string) {
  return msg;
}
A
string | undefined
B
string
C
undefined only
D
never
4

Question 4

Optional parameters must appear:

A
After all required parameters
B
Before all required parameters
C
Anywhere in the list without restriction
D
Only when using enums
5

Question 5

A default parameter value applies when:

A
The argument is explicitly undefined or omitted
B
The argument is null
C
The argument is zero
D
The argument is an empty string
6

Question 6

What value does count receive?

typescript
function increment(count: number = 10) {
  return count;
}
increment();
A
10
B
undefined
C
0
D
null
7

Question 7

What does a default parameter imply about requiredness?

A
A parameter with a default is considered optional
B
It is required even with a default
C
It becomes readonly
D
It must be a number
8

Question 8

What is the type of n?

typescript
function use(n = 5) {
  return n;
}
A
number
B
number | undefined
C
any
D
string
9

Question 9

A parameter cannot be both:

A
Optional and defaulted syntactically at once
B
Used and unused
C
Typed and untyped
D
Function and variable
10

Question 10

Defaults are evaluated:

A
At call time
B
At compile time
C
Only once globally
D
When initializing the file
11

Question 11

What does this return?

typescript
function f(v: number = 3) {
  return f(undefined);
}
A
3
B
undefined
C
NaN
D
0
12

Question 12

Optional parameters implicitly behave like:

A
param?: T is param: T | undefined
B
param?: T is param: T
C
param?: T is param: any
D
param?: T is param: never
13

Question 13

Why must optional parameters come last?

A
To avoid ambiguity in call expressions
B
To reduce compile times
C
To support enums
D
To match JavaScript runtime rules
14

Question 14

Why is this invalid?

typescript
function bad(a?: number, b: string) {}
A
Optional param cannot precede a required one
B
string cannot follow number
C
Functions must have defaults
D
The types conflict automatically
15

Question 15

Overloads often avoid optional parameters when:

A
Call signatures would become ambiguous
B
The function returns void
C
Using object parameters
D
Using arrow functions
16

Question 16

Rest parameters behave like:

A
An always-present array type
B
A literal tuple
C
An undefined-only parameter
D
A union of primitives
17

Question 17

What does this call output?

typescript
function join(sep = ',', ...items: string[]) {
  return items.join(sep);
}
join('-', 'a', 'b');
A
a-b
B
ab
C
undefined
D
error
18

Question 18

Rest parameters cannot be:

A
Followed by additional parameters
B
Used with arrays
C
Used with tuples
D
Typed explicitly
19

Question 19

Why does this compile?

typescript
function show(x?: number) {}
show(undefined);
A
Optional parameters accept undefined
B
All parameters accept undefined
C
undefined coerces to zero
D
The function returns void
20

Question 20

Optional does NOT imply:

A
That null is allowed
B
That undefined is allowed
C
That the parameter can be omitted
D
That narrowing applies
21

Question 21

What value is assigned to rate?

typescript
function calc(total: number, rate = total * 0.1) {
  return rate;
}
calc(50);
A
5
B
undefined
C
0
D
null
22

Question 22

What is true about default parameters?

A
Defaults may rely on earlier parameter values
B
Defaults must be literals
C
Defaults must be functions
D
Defaults cannot use expressions
23

Question 23

When is an optional parameter preferred over a default?

A
When you need to detect whether the argument was provided
B
When you want a computed fallback
C
When the function must always initialize the variable
D
When you need numeric coercion
24

Question 24

Which call distinguishes actual undefined from omission?

typescript
function check(v?: number) {
  return arguments.length;
}
A
arguments.length
B
typeof v
C
v === null
D
v > 0
25

Question 25

Default parameters are useful when:

A
A missing argument should fall back to a known value
B
You must detect omitted arguments
C
You need a required argument
D
You want to forbid undefined
26

Question 26

A parameter with a default is considered:

A
Optional
B
Required
C
never
D
unknown
27

Question 27

Optional parameters should be avoided when:

A
They may cause overload ambiguities
B
They appear last
C
They are typed as numbers
D
They appear in arrow functions
28

Question 28

Which is true about function calls involving default parameters?

A
Parameters with defaults can be skipped using undefined
B
Parameters with defaults cannot use undefined
C
Default parameters must be constants
D
Default parameters cannot follow rest parameters
29

Question 29

Optional parameters are commonly used for:

A
Config objects and flexible APIs
B
Forcing runtime type errors
C
Controlling tuple types
D
Automatic narrowing
30

Question 30

Overall, default parameters help developers by:

A
Providing clear fallback values without requiring callers to supply arguments
B
Removing parameter types
C
Enforcing strict null checks automatically
D
Eliminating undefined

Other Quiz Categories

JavaScript
47 quizzes
Basics
Variables & Data Types
Operators & Expressions
Rust
30 quizzes
Cargo and Project Setup
Variables and Mutability
Data Types
Python
29 quizzes
Introduction & Core Fundamentals
Data Types Overview
Type Casting
Golang
29 quizzes
Basics & Syntax
Data Types & Zero Values
Operators & Expressions
C++
26 quizzes
Basics
Variables & Data Types
Operators & Expression
Java
22 quizzes
Java Basics & JVM Fundamentals
Variables, Data Types & Type Casting
Operators & Expressions
Matlab
21 quizzes
Basics & Environment
Variables and Data Type
Arrays and Matric
SQL Database
15 quizzes
Foundations and Basics
Basic Query Selection
Filter, Sort, and Alias Essentials
PHP
15 quizzes
Syntax Building Blocks
Variable Naming
Data Types Overview
Linked List
11 quizzes
Introduction
Node Structure and Pointer Fundamentals
Singly Linked List

QUIZZES IN TypeScript

1

Introduction and Overview

40

Test your foundational knowledge with 40 questions on TypeScript—covering its purpose, differences from JavaScript, benefits, compilation, and real-world applications.

2

Installation and Configuration

30

A 30-question TypeScript quiz covering installation, project setup, tsconfig.json fundamentals, compiler options, integrating build tools, project organization patterns, and how to run and compile TypeScript effectively.

3

Basic Types and Type Annotations

40

A 40-question TypeScript quiz covering primitive types, type inference, explicit annotations, arrays, tuples, object types, unions, intersections, and literal types.

4

Variables and Constants

35

A 35-question TypeScript & JavaScript quiz covering variable declarations, scope rules, hoisting, reassignment behavior, constants, immutability concepts, shadowing, and best practices for naming variables.

5

Functions and Parameters

30

A 30-question TypeScript quiz covering function declarations, expressions, parameter types, optional and default parameters, rest arguments, and return type handling.

6

Interfaces and Type Aliases

40

A 40-question TypeScript quiz covering interfaces, type aliases, structural typing, merging behavior, call signatures, index signatures, intersections, unions, and interface augmentation.

7

Classes and Objects

40

A 40-question TypeScript quiz focusing on classes, constructors, access modifiers, readonly fields, methods, inheritance, abstract classes, and object-based typing.

8

Enums and Tuples

40

A 40-question TypeScript quiz covering numeric enums, string enums, const enums, reverse mapping, tuple types, readonly tuples, labeled tuples, and practical usage patterns.

9

Union and Intersection Types

40

A 40-question TypeScript quiz covering union types, narrowing, discriminated unions, intersections, type composition, compatibility, and real-world modelling.

10

Literal Types and Type Inference

35

A 35-question TypeScript quiz about literal types, inference behavior, widening rules, const contexts, and practical modelling using specific literal values.

11

Generics

40

A 40-question TypeScript quiz exploring generic type parameters, constraints, generic functions, interfaces, classes, defaults, inference, and advanced patterns.

12

Type Assertions and Type Guards

40

A 40-question TypeScript quiz exploring type assertions, narrowing with guards, typeof checks, instanceof checks, custom predicate guards, discriminated unions, and safe narrowing patterns.

13

Optional and Default Parameters

30

A 30-question TypeScript quiz exploring optional parameters, default parameter values, undefined handling, rest parameters, function declaration rules, and parameter type inference.

14

Readonly and Immutability

30

A 30-question TypeScript quiz covering readonly properties, immutable arrays and tuples, const behavior, structural immutability, shallow freezing, and readonly utility types.

15

Modules and Namespaces

30

A 30-question TypeScript quiz covering ES module imports, exports, module resolution rules, namespaces, namespace merging, ambient modules, and organizational patterns.

16

Decorators

35

A 35-question TypeScript quiz covering decorator fundamentals, class decorators, method and property decorators, decorator factories, metadata reflection, and execution order.

17

Function Overloads

35

A 35-question TypeScript quiz covering overload signatures, implementation signatures, narrowing behavior, return types, and best practices for overloaded functions.

18

Abstract Classes and Access Modifiers

40

A 40-question TypeScript quiz covering abstract classes, abstract methods, public/private/protected access, readonly properties, inheritance behavior, and visibility constraints.

19

Mixins and Composition

40

A 40-question TypeScript quiz covering mixin patterns, composition techniques, mixin constraints, function-based class factories, multiple mixin stacking, and practical patterns.