JavaScript Type Conversion & Coercion Quiz

0 Passed

0% acceptance

Explore 50 JavaScript questions that test implicit coercion, explicit casts, string and number conversions, truthy/falsy evaluations, equality quirks, arithmetic side effects, ToPrimitive algorithms, JSON behavior, and the most common pitfalls developers hit when the engine reshapes data types.

50 Questions

~100 minutes

Question 1

Which built-in function converts any value to a string explicitly?

String(value)

value.toChars()

parseString(value)

JSON.stringifyWithoutQuotes(value)

Question 2

What does typeof return for the result of Number("42")?

"number"

"string"

"object"

"bigint"

Question 3

Which statement describes implicit type coercion?

The engine automatically converts values during operations without an explicit request.

Developers call a conversion function manually.

Values throw errors instead of converting.

Only strict mode files can use it.

Question 4

Which ECMAScript abstract operation governs how objects turn into primitives during coercion?

ToPrimitive

ToInteger

ToObject

ToJSON

Question 5

When does JavaScript invoke valueOf on an object?

During ToPrimitive when the preferred type is number

Only when calling JSON.stringify

Whenever you log the object

Never; valueOf is ignored

Question 6

What is the result of "5" - 1?

"51"

"5-1"

NaN

Question 7

How does JavaScript evaluate [] + {}?

"[object Object]"

NaN

Throws TypeError

Question 8

What does {} + [] evaluate to in most runtimes?

"[object Object]"

NaN

An error

Question 9

What is the output of the following code?

javascript

console.log(null + 5)

null5

NaN

Throws TypeError

Question 10

Which expression demonstrates implicit string coercion?

"Score: " + 7

7 - "2"

"5" * 2

Boolean(1)

Question 11

Which API converts a value to an integer by truncating fractional parts toward zero?

parseInt

Math.floor

Number.parseFloat

Boolean

Question 12

What does Number.parseFloat("12.34px") return?

12.34

"12.34px"

NaN

Question 13

How can you convert a boolean to a string without calling String()?

boolean + ""

+boolean

!!boolean

Boolean(boolean)

Question 14

What is the safest way to convert a string to an integer in base 10?

parseInt(value, 10)

parseInt(value)

Number(value, 10)

value | 0 without checks

Question 15

Which method converts numbers to strings with a specified number of decimal places?

num.toFixed(2)

String(num, 2)

num.toPrecision() only

parseFloat(num)

Question 16

What does String(undefined) return?

"undefined"

null

Throws TypeError

Question 17

How does template literal interpolation handle objects with custom toString?

javascript

const obj = { toString: () => 'custom' }
console.log(`Value: ${obj}`)

Value: custom

Value: [object Object]

Value: undefined

Throws TypeError

Question 18

Which expression coerces a number to a string by concatenation?

"" + 42

42 - ""

42 * "1"

+42

Question 19

Why can toString on numbers throw an error?

Because calling (0).toString() without parentheses may parse as a decimal literal

Because numbers do not implement toString

Because toString removes decimals

Because toString returns undefined

Question 20

What string results from ({}).toString()?

"[object Object]"

"{}"

"object"

It throws

Question 21

What does Number(true) evaluate to?

NaN

Throws TypeError

Question 22

What is the result of +"-0"?

-0

NaN

"-0"

Question 23

Which value becomes NaN when passed to Number()?

"foo"

" 42 "

null

true

Question 24

What does parseInt("0x10", 16) return?

NaN

Question 25

Which operator can quickly truncate a floating number to 32-bit signed integer?

value | 0

value + ""

!!value

value ** 0

Question 26

Which list contains only falsy values during boolean conversion?

false, 0, "", null, undefined, NaN

false, [], {}, ""

false, "false", 0

false, -1, 0

Question 27

What does Boolean("0") return?

true

false

NaN

Question 28

What is the boolean value of !!null?

false

true

null

undefined

Question 29

Which expression leverages short-circuit evaluation to assign a default only when value is falsy?

const result = value || "default"

const result = value && "default"

const result = value ?? "default"

const result = value ? value : "default"

Question 30

Why might you prefer ?? over || for defaults?

Because ?? treats 0 and "" as valid values and only falls back for null or undefined

Because ?? is faster

Because || cannot be used in strict mode

Because ?? converts everything to boolean first

Question 31

What does "5" + 3 evaluate to?

"53"

"8"

NaN

Question 32

What is the result of [] == false?

true

false

undefined

Throws TypeError

Question 33

Which equality operator skips type coercion?

===

Question 34

What does "0" == false evaluate to?

true

false

Throws TypeError

undefined

Question 35

Which comparison causes numeric coercion on both operands?

"2" > 1

"2" + 1

1 + "2"

"2" === 2

Question 36

What does true * 2 evaluate to?

true2

NaN

Throws TypeError

Question 37

Which expression results in NaN due to coercion rules?

"foo" * 3

"3" * 2

null * 5

true * 4

Question 38

How does JavaScript evaluate "5" > "12"?

true

false

NaN

Throws TypeError

Question 39

What does [] == ![] evaluate to?

true

false

undefined

Throws TypeError

Question 40

Which comparison returns false?

null == undefined

null == 0

0 == false

"\n" == 0

Question 41

What does JSON.stringify({ valueOf() { return 2 } }) return?

"{}"

"2"

undefined

Throws TypeError

Question 42

How can you customize ToPrimitive for an object?

Define Symbol.toPrimitive on the object or its prototype

Override JSON.stringify

Use Object.seal

Set __proto__ to null

Question 43

What does the following code log?

javascript

const obj = {
  valueOf() {
    return 5
  },
  toString() {
    return 'seven'
  }
}
console.log(`${obj}`)

seven

[object Object]

Throws TypeError

Question 44

What is the result of +new Date("2020-01-01")?

The Unix timestamp for that date

NaN

A Date object

A string representation

Question 45

Which method is used by JSON.stringify when an object defines toJSON?

It calls toJSON if present and stringifies the returned value

It ignores toJSON entirely

It calls valueOf only

It requires Symbol.toPrimitive

Question 46

Why can using +obj where obj is an object be risky?

Because ToPrimitive may not return a numeric string, resulting in NaN

Because it throws a syntax error

Because objects are immutable

Because unary plus converts to boolean

Question 47

What is a common bug when using parseInt on array.map results?

parseInt receives the array index as the radix argument

parseInt cannot parse negative numbers

parseInt mutates the array

parseInt always returns NaN inside map

Question 48

Why should equality comparisons avoid mixing == with objects and primitives?

Because objects may implement custom coercion that produces surprising primitives

Because == is slower

Because objects cannot be compared at all

Because === throws on objects

Question 49

What happens when adding a number to undefined?

NaN

undefined

The number itself

Throws TypeError

Question 50

What is a safer strategy when dealing with user input that could be numeric or string data?

Validate and explicitly convert with Number(), parseInt, or parseFloat before using the value

Rely on implicit coercion wherever possible

Use == so the engine does the work

Store everything as JSON and parse repeatedly

Other Quiz Categories

Rust

30 quizzes

Cargo and Project Setup

Variables and Mutability

Data Types

Python

29 quizzes

Introduction & Core Fundamentals

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

TypeScript

19 quizzes

Introduction and Overview

Installation and Configuration

Basic Types and Type Annotations

SQL Database

15 quizzes

Foundations and Basics

Basic Query Selection

Filter, Sort, and Alias Essentials

PHP

15 quizzes

Syntax Building Blocks

Node Structure and Pointer Fundamentals

Singly Linked List

QUIZZES IN JavaScript

Basics

A beginner-friendly quiz to evaluate your understanding of core JavaScript fundamentals including variables, data types, operators, and foundational syntax. This quiz builds the base for mastering more advanced JavaScript concepts.

Variables & Data Types

A focused JavaScript quiz dedicated to variables, scope, primitive values, reference types, and type conversion. Use this set to check how well you understand declarations, assignments, comparison rules, and everyday runtime behaviour.

Operators & Expressions

A detailed JavaScript quiz exploring arithmetic, comparison, logical, bitwise, and assignment operators through practical expressions and tricky evaluation scenarios.

Strings & String Methods

Tackle 75 JavaScript string challenges that cover formatting, slicing, searching, pattern matching, and Unicode-safe manipulation to solidify everyday text-processing skills.

Numbers & Math Operations

Master 75 JavaScript questions that cover numeric literals, parsing, formatting, math utilities, and the edge cases every engineer hits when working with numbers.

Arrays & Basic Array Methods

100

Tackle 100 JavaScript array questions that range from everyday indexing to tricky splice mutations and iteration strategies. Forty questions supply runnable code so you can reason through exact behaviour before answering.

Objects & Key/Value Manipulation

Explore 75 JavaScript object questions that cover construction, property access, mutation, introspection, cloning, and immutability. Thirty questions include runnable snippets so you can reason through exact behaviour before answering.

Control Flow (if, else, switch)

Explore 50 JavaScript control-flow questions covering branching, truthiness, equality pitfalls, nested decisions, switch mechanics, fallthrough, and short-circuit expressions. Twenty questions include runnable snippets so you can reason about exact evaluation before answering.

Functions & Parameters

Explore 50 JavaScript function questions covering declarations, expressions, arrow functions, scopes, parameters, defaults, rest arguments, return values, closures, and execution flow.

Boolean Logic & Truthy/Falsy

Explore 50 JavaScript questions covering boolean values, logical operators, comparison pitfalls, truthy/falsy coercion, short-circuit flow, optional chaining, nullish coalescing, ternaries, and real-world conditional patterns.

Type Conversion & Coercion

Basic Error Types (SyntaxError, TypeError)

Explore 40 JavaScript questions covering SyntaxError definitions, parsing mistakes, prevention strategies, TypeError causes, undefined versus null access issues, strict mode implications, debugging stacks, try/catch usage, and best practices for runtime resilience.

Console API (log, error, table)

Explore 40 questions that cover console.log, console.error, console.table, message formatting, styling, grouping, timing, assertions, debugging workflows, clearing output, and practical logging best practices in JavaScript.

Basic Debugging in Browser DevTools

Understand 30 questions covering how to open DevTools, inspect the DOM, use the console, set and manage breakpoints, step through code, inspect the call stack, monitor network calls, leverage overrides, analyze performance and memory, debug event listeners, and work in responsive design mode.

Math Object & Random Numbers

Explore 50 JavaScript questions covering Math constants, rounding methods, min/max, exponentiation, roots, absolute values, sign detection, trig/log functions, random generation, range helpers, conceptual seeding, randomization patterns, and performance tips for numerical code.

Array Iteration Essentials (forEach)

Cover 40 questions on how Array.forEach works, callback parameters, side effects, mutation patterns, differences versus loops and map/filter, thisArg usage, arrow callbacks, early-exit limitations, nested iterations, object handling, common patterns, debugging techniques, and best practices.

Basic Date Handling (Date object)

Answer 50 questions on JavaScript Date basics: creating instances, timestamps, extracting components, setting values, parsing strings, basic formatting, Date.now, arithmetic, time zones, UTC helpers, comparisons, ISO conversion, and common pitfalls.

Intro to DOM (querySelector & textContent)

Answer 40 questions covering DOM fundamentals, document structure, element selection with querySelector/querySelectorAll, CSS selector usage, reading and updating textContent, handling null results, safe DOM manipulation, and best practices.

Prototype & Inheritance

Tackle 75 questions covering prototype chain fundamentals, __proto__ vs prototype, constructor functions, adding and overriding prototype methods, Object.create patterns, class syntax with extends/super, distinguishing instance vs prototype data, checking inheritance relationships, understanding this, performance considerations, pitfalls, and best practices.

Classes & OOP

Work through 50 questions on class syntax, constructors, instance and static members, getters/setters, inheritance with extends/super, private fields, composition vs inheritance, using this, creating multiple instances, basic design patterns, and best practices.

Modules (import/export)

Answer 50 questions on ES modules: named vs default exports, import syntax variations, renaming, exporting functions/classes/constants, re-exporting, module scope, namespace imports, dynamic import(), browser/module loading, resolution rules, Node.js ESM/CommonJS, bundling basics, and best practices.

Error Handling (try, catch, finally)

Tackle 40 questions on why try/catch exists, how to structure catch/finally blocks, inspecting error objects, throwing custom errors, handling specific cases, nesting handlers, and modern best practices.

Asynchronous JS (Callbacks)

Answer 75 questions on asynchronous JavaScript callbacks: fundamentals, error-first patterns, execution order, callback hell, timers, DOM and I/O callbacks, higher-order functions, data passing, chaining, and modern replacements like Promises.

Promises & Promise Chaining

Tackle 40 questions about JavaScript Promises: states, creating promises, then/catch/finally, value chaining, error propagation, avoiding callback hell, Promise.all, Promise.race, and coordinating multiple async operations.

Async/Await Deep Understanding

Answer 40 questions on async/await internals: how async functions work, await behavior, try/catch error handling, sequential vs parallel flows, awaiting multiple promises, mixing with raw promises, event loop interaction, return values, pitfalls, and best practices.

Execution Context

Dive into 40 questions covering how JavaScript builds global and function execution contexts, creation and execution phases, lexical and variable environments, scope chains, hoisting, this binding, and call stack behavior.

Hoisting & Temporal Dead Zone

Tackle 40 questions covering hoisting concepts, var behavior, function declaration hoisting, function expressions, let/const characteristics, temporal dead zone pitfalls, runtime errors, and best practices.

Closures & Lexical Environment

Study 40 JavaScript questions on lexical scoping, scope chains, closure creation, accessing outer variables, state preservation, memory considerations, and avoiding accidental closures.

Scope Types (Global, Block, Function)

Learn 30 questions that analyze JavaScript global scope, function scope, block scope, var quirks, visibility rules, shadowing, scope chains, and best practices for managing identifiers.

Event Loop & Microtasks Introduction

Answer 50 questions about the JavaScript event loop, call stack, macrotasks, microtasks, promise timing, rendering, async APIs, starvation risks, and debugging workflows.

Advanced Array Methods (map, filter, reduce)

Answer 35 questions that dive into map transformations, filter logic, reduce accumulations, callback signatures, immutability, chaining, patterns, performance trade-offs, and behavior comparisons.

Spread & Rest Operator Deep Usage

Answer 35 questions exploring spread on arrays and objects, cloning behavior, combining collections, rest parameters, destructuring techniques, pitfalls, performance trade-offs, and modern practical patterns.

6 Destructuring Use Cases (Nested, Default)

Tackle 30 questions on nested object/array destructuring, defaults, renaming bindings, destructuring parameters, and skipping positions.

Template Literals Advanced (Tagged Templates)

Answer 35 questions digging into template literal basics, tagged function mechanics, string/value processing, security sanitization, custom formatting, localization, DSL construction, and performance trade-offs.

Regular Expressions Basics

Answer 35 questions covering regex literal vs constructor syntax, metacharacters, character classes, quantifiers, anchors, grouping, escaping, and JS testing/matching methods.

Shallow vs Deep Copying Objects

Answer 30 questions comparing shallow copy techniques, deep copy strategies, spread/Object.assign behavior, JSON and structuredClone approaches, reference vs value semantics, and common pitfalls like cyclic structures.

JSON Handling (stringify, parse pitfalls)

Answer 40 questions covering JSON.stringify basics, JSON.parse behavior, handling undefined and functions, circular structure errors, Date serialization, number precision, reviver/replacer usage, and safe parsing practices.

DOM Events Bubbling & Capturing

Answer 30 questions on event propagation phases, capturing basics, target behavior, bubbling mechanics, addEventListener options, stopping propagation, preventing default actions, and event delegation techniques.

Performance Optimization Techniques

Answer 35 questions on minimizing reflows, debouncing/throttling, faster loops, efficient structures, avoiding leaks, web workers, lazy loading, caching, cutting re-renders, and profiling with DevTools.

Iterators & Generators (yield, next, custom iterators)

Answer 35 questions covering iterator protocol basics, next() behavior, iterable objects, generator syntax, yield mechanics, execution control, passing values, custom iterators, lazy generator use cases, and async-iterator differences.

Async Iteration & for-await-of

Answer 35 questions covering the async iterator protocol, Symbol.asyncIterator, async generator syntax, yield vs yield*, promise handling, for-await-of mechanics, error management, streaming data scenarios, and using async generators with fetch.

Debounce & Throttle Patterns

Answer 35 questions covering debounce timing, throttle intervals, leading/trailing triggers, preventing noisy events, scroll/input use cases, manual implementations, pitfalls, and UI performance gains.

Shadow DOM & Web Components Basics

Answer 35 questions on custom element fundamentals, shadow DOM encapsulation, open vs closed roots, templates and slots, style isolation, lifecycle callbacks, reusable component design, and light/shadow DOM interaction.

Intersection Observer

Answer 35 questions covering observers and targets, threshold/rootMargin tuning, lazy-loading patterns, visibility detection, cleanup best practices, entry properties, performance wins vs scroll events, and common use cases like infinite scroll, animations, and analytics.

MutationObserver: Watching DOM Changes

Test your knowledge with 35 questions on MutationObserver—covering DOM observation, configuration options, attribute and child tracking, subtree monitoring, mutation records, cleanup, performance, and real-world use cases.

Browser Rendering Pipeline

Test your understanding of how browsers render web pages with 35 questions covering HTML/CSS/JS parsing, the Critical Rendering Path, layout, painting, compositing, and performance optimizations.

Security Basics

Test your knowledge with 40 questions on web security fundamentals—covering XSS types, prevention strategies, CSRF mechanics, and defense techniques like tokens, SameSite cookies, and Content Security Policy.

JavaScript Type Conversion & Coercion Quiz

Question 1

Question 2

Question 3

Question 4

Question 5

Question 6

Question 7

Question 8

Question 9

Question 10

Question 11

Question 12

Question 13

Question 14

Question 15

Question 16

Question 17

Question 18

Question 19

Question 20

Question 21

Question 22

Question 23

Question 24

Question 25

Question 26

Question 27

Question 28

Question 29

Question 30

Question 31

Question 32

Question 33

Question 34

Question 35

Question 36

Question 37

Question 38

Question 39

Question 40

Question 41

Question 42

Question 43

Question 44

Question 45

Question 46

Question 47

Question 48

Question 49

Question 50

About This Javascript Type Conversion & Coercion Quiz

Other Quiz Categories

QUIZZES IN JavaScript

Basics

Variables & Data Types

Operators & Expressions

Strings & String Methods

Numbers & Math Operations

Arrays & Basic Array Methods

Objects & Key/Value Manipulation

Control Flow (if, else, switch)

Functions & Parameters

Boolean Logic & Truthy/Falsy

Type Conversion & Coercion

Basic Error Types (SyntaxError, TypeError)

Console API (log, error, table)

Basic Debugging in Browser DevTools

Math Object & Random Numbers

Array Iteration Essentials (forEach)

Basic Date Handling (Date object)

Intro to DOM (querySelector & textContent)

Prototype & Inheritance

Classes & OOP

Modules (import/export)

Error Handling (try, catch, finally)

Asynchronous JS (Callbacks)

Promises & Promise Chaining

Async/Await Deep Understanding

Execution Context