BudiBaduQuiziBadu

JavaScript Execution Context Quiz

JavaScript
0 Passed
0% acceptance

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.

40 Questions
~80 minutes
1

Question 1

What does the term "execution context" describe in JavaScript?

A
The conceptual environment in which code is evaluated and executed
B
A DOM node that wraps script tags
C
A compiled binary produced by V8
D
A CSS layout mode
2

Question 2

What is logged by this script?

javascript
console.log('start')
function reportPhase() {
  console.log('function body')
}
reportPhase()
console.log('end')
A
start → function body → end
B
function body → start → end
C
start → end → function body
D
Only start because execution stops
3

Question 3

Which phases does every execution context move through?

A
Creation phase followed by execution phase
B
Compilation phase followed by garbage phase
C
Layout phase followed by paint phase
D
Networking phase followed by rendering phase
4

Question 4

What does this program output?

javascript
const scopeLabel = 'global'
function displayScope() {
  console.log(scopeLabel)
}
displayScope()
A
global
B
undefined
C
Throws ReferenceError
D
function displayScope
5

Question 5

When is the global execution context created?

A
Before any code runs, as soon as the engine loads a script
B
After the first function is invoked
C
Only after DOMContentLoaded fires
D
Only when a module exports something
6

Question 6

Which statement best describes the relationship between the global execution context and globalThis?

A
Global variables declared with var become properties on globalThis in non-module scripts
B
globalThis points to the DOM body element
C
globalThis is only defined in Node.js
D
globalThis always equals undefined
7

Question 7

What happens when this code runs in a non-strict script?

javascript
console.log(color)
var color = 'blue'
A
It logs undefined because the declaration is hoisted during the creation phase
B
It logs blue because assignments hoist with values
C
It throws ReferenceError because var is block scoped
D
It logs null because uninitialized globals default to null
8

Question 8

Why is it recommended to keep the global execution context lightweight?

A
Because everything stored there lives for the lifetime of the page or process and can clog memory
B
Because global contexts execute in parallel threads
C
Because global contexts cannot access the DOM
D
Because the global context cannot reference functions
9

Question 9

What logs here?

javascript
function init() {
  console.log(typeof helper)
  function helper() {}
}
init()
A
function
B
undefined
C
Throws ReferenceError
D
null
10

Question 10

Which data lives inside a function execution context?

A
Arguments object, parameter values, local bindings, outer lexical reference, and the this binding
B
Only global variables
C
Only DOM nodes
D
GPU buffers
11

Question 11

When is a new function execution context pushed onto the call stack?

A
Whenever the function is invoked (called) regardless of how it was defined
B
When the function is declared
C
Only when the function returns a value
D
Only when the function is recursive
12

Question 12

What appears in the console?

javascript
function calcTotal(price) {
  console.log(total)
  var total = price * 2
  return total
}
calcTotal(4)
A
undefined, then the function returns 8
B
ReferenceError
C
0
D
null
13

Question 13

Which tasks happen during the creation phase of a function execution context?

A
Arguments object creation, parameter initialization, hoisting of declarations, and linking to outer lexical environment
B
Running every console.log in the function body
C
Fetching remote modules
D
Rendering the DOM tree
14

Question 14

How does the execution phase differ from the creation phase?

A
Execution phase runs the code line by line, assigning and mutating values that were set up during creation
B
Execution phase determines the this binding
C
Creation phase runs console.log statements
D
Execution phase builds the arguments object
15

Question 15

What prints in this closure example?

javascript
function outer() {
  const label = 'outer scope'
  return function inner() {
    console.log(label)
  }
}
const fn = outer()
fn()
A
outer scope
B
undefined
C
Throws ReferenceError
D
inner
16

Question 16

What does the arguments object capture inside a function context?

A
Array-like access to all arguments provided, even if they lack named parameters
B
Only default parameter values
C
DOM event objects
D
Global variables
17

Question 17

What is logged?

javascript
const region = 'global'
function layerOne() {
  const region = 'layerOne'
  function layerTwo() {
    console.log(region)
  }
  layerTwo()
}
layerOne()
A
layerOne
B
global
C
undefined
D
Throws ReferenceError
18

Question 18

How do the variable environment and lexical environment differ?

A
Variable environment holds var/function bindings for the current context, while lexical environment keeps track of outer references for identifier resolution
B
They are identical names for the DOM tree
C
Variable environment only exists in modules
D
Lexical environment only stores numbers
19

Question 19

What happens if the engine cannot find an identifier in any lexical environment on the scope chain?

A
A ReferenceError is thrown
B
The engine creates a global variable automatically in strict mode
C
The engine converts the identifier to null
D
The identifier is redefined to 0
20

Question 20

Why can excessively deep nesting hurt performance?

A
Identifier resolution must traverse more lexical environments before succeeding
B
Deep nesting triggers garbage collection continuously
C
Deep nesting disables tail-call optimization by specification
D
Deep nesting prevents closures from forming
21

Question 21

What sequence is logged?

javascript
let message = 'outer'
{
  let message = 'block'
  console.log(message)
}
console.log(message)
A
block then outer
B
outer then block
C
block twice
D
ReferenceError twice
22

Question 22

What term describes the fact that a function’s accessible scopes are determined by where it was declared, not where it is called?

A
Lexical (static) scoping
B
Dynamic scoping
C
Temporal scoping
D
Event scoping
23

Question 23

How does JavaScript build the scope chain for a function?

A
It stores a reference to the lexical environment where the function was created, then walks outward as needed
B
It inspects runtime call stack to guess which variables to use
C
It serializes the DOM tree into memory
D
It evaluates every module at once
24

Question 24

What occurs when this code executes?

javascript
console.log(total)
let total = 5
A
ReferenceError due to the temporal dead zone
B
Logs undefined like var hoisting
C
Logs 5
D
Logs null
25

Question 25

Under default binding rules (non-strict), what does this reference inside a standalone function call?

A
The global object
B
undefined
C
The function’s prototype object
D
Whatever object was passed as the first argument
26

Question 26

How is this determined during method invocation?

A
It refers to the object placed before the dot (or bracket) at call time
B
It always refers to the global object
C
It is permanently bound to the prototype
D
It points to the arguments object
27

Question 27

What does this log?

javascript
const counter = {
  count: 0,
  increment() {
    this.count += 1
    return this.count
  }
}
console.log(counter.increment())
A
1
B
0
C
undefined
D
Throws ReferenceError
28

Question 28

How do arrow functions determine this?

A
They capture the lexical this from their defining scope and never create their own
B
They always bind to the global object
C
They prompt the user for a binding
D
They behave like constructors
29

Question 29

Which method allows you to explicitly set this for a single invocation while providing arguments individually?

A
Function.prototype.call
B
Function.prototype.apply
C
Function.prototype.bind
D
Object.create
30

Question 30

What does Function.prototype.bind return?

A
A new function permanently bound to the provided this value and optional leading arguments
B
The original function without changes
C
A boolean
D
An immediately invoked function expression
31

Question 31

What is the call stack?

A
A LIFO structure the engine uses to track active execution contexts
B
A queue for pending network requests
C
A list of DOM mutations awaiting paint
D
A data structure only used in CSS
32

Question 32

When does the engine pop an execution context off the call stack?

A
After the function finishes executing and control returns to its caller
B
Immediately after the function is declared
C
As soon as setTimeout is scheduled
D
Before the function’s return statement runs
33

Question 33

What order is logged?

javascript
function third() {
  console.log('third')
}
function second() {
  third()
  console.log('second')
}
function first() {
  second()
  console.log('first')
}
first()
console.log('global done')
A
third → second → first → global done
B
first → second → third → global done
C
third → first → second → global done
D
global done → third → second → first
34

Question 34

What is a stack overflow in JavaScript?

A
When too many execution contexts accumulate without unwinding, exhausting the engine’s stack size
B
When the DOM has too many elements
C
When a promise rejects
D
When CSS specificity ties
35

Question 35

Why do asynchronous callbacks wait even if they are scheduled immediately?

A
Because the event loop cannot place callbacks onto the call stack until it is empty
B
Because async callbacks skip the call stack entirely
C
Because setTimeout blocks the call stack
D
Because callbacks require user permission
36

Question 36

What does this recursion log?

javascript
function countdown(n) {
  if (n === 0) {
    console.log('done')
    return
  }
  console.log(n)
  countdown(n - 1)
}
countdown(3)
A
3 → 2 → 1 → done
B
done → 1 → 2 → 3
C
3 → done
D
Throws ReferenceError
37

Question 37

How do stack traces in errors relate to execution contexts?

A
They list the sequence of active or recently unwound execution contexts when the error occurred
B
They show the DOM tree at crash time
C
They show network waterfall timing
D
They list CSS selectors currently applied
38

Question 38

What role does the microtask queue (e.g., promises) play relative to the call stack?

A
Microtasks run after the current call stack empties but before the next macrotask
B
Microtasks preempt synchronous functions mid-execution
C
Microtasks live on the same stack frame forever
D
Microtasks only exist in CSS animations
39

Question 39

Why is it valuable to keep call stack depth shallow in synchronous code?

A
Shallow stacks reduce the chance of overflow and make debugging easier
B
The engine refuses to run code if the stack has fewer than five frames
C
Shallow stacks disable garbage collection
D
Stack depth controls CSS specificity
40

Question 40

How can developer tools assist in inspecting execution contexts?

A
Breakpoints stop execution so you can view the call stack, scope chain, and variable bindings for the paused context
B
They automatically refactor code to remove recursion
C
They change the this binding permanently
D
They disable asynchronous callbacks

Other Quiz Categories

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
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
Variable Naming
Data Types Overview
Linked List
11 quizzes
Introduction
Node Structure and Pointer Fundamentals
Singly Linked List

QUIZZES IN JavaScript

1

Basics

40

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.

2

Variables & Data Types

50

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.

3

Operators & Expressions

50

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

4

Strings & String Methods

75

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

5

Numbers & Math Operations

75

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

6

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.

7

Objects & Key/Value Manipulation

75

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.

8

Control Flow (if, else, switch)

50

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.

9

Functions & Parameters

50

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

10

Boolean Logic & Truthy/Falsy

50

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.

11

Type Conversion & Coercion

50

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.

12

Basic Error Types (SyntaxError, TypeError)

40

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.

13

Console API (log, error, table)

40

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.

14

Basic Debugging in Browser DevTools

30

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.

15

Math Object & Random Numbers

50

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.

16

Array Iteration Essentials (forEach)

40

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.

17

Basic Date Handling (Date object)

50

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.

18

Intro to DOM (querySelector & textContent)

40

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.

19

Prototype & Inheritance

75

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.

20

Classes & OOP

50

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.

21

Modules (import/export)

50

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.

22

Error Handling (try, catch, finally)

40

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.

23

Asynchronous JS (Callbacks)

75

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.

24

Promises & Promise Chaining

40

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.

25

Async/Await Deep Understanding

40

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.

26

Execution Context

40

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.

27

Hoisting & Temporal Dead Zone

40

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.

28

Closures & Lexical Environment

40

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

29

Scope Types (Global, Block, Function)

30

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.

30

Event Loop & Microtasks Introduction

50

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

31

Advanced Array Methods (map, filter, reduce)

35

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

32

Spread & Rest Operator Deep Usage

35

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.

33

6 Destructuring Use Cases (Nested, Default)

30

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

34

Template Literals Advanced (Tagged Templates)

35

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.

35

Regular Expressions Basics

35

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

36

Shallow vs Deep Copying Objects

30

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.

37

JSON Handling (stringify, parse pitfalls)

40

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.

38

DOM Events Bubbling & Capturing

30

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

39

Performance Optimization Techniques

35

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.

40

Iterators & Generators (yield, next, custom iterators)

35

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.

41

Async Iteration & for-await-of

35

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.

42

Debounce & Throttle Patterns

35

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.

43

Shadow DOM & Web Components Basics

35

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.

44

Intersection Observer

35

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.

45

MutationObserver: Watching DOM Changes

35

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.

46

Browser Rendering Pipeline

35

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.

47

Security Basics

40

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.