JavaScript Output Questions
What Does This Code Print?

Synchronous code runs before setTimeout

Promise microtask before setTimeout macrotask

Promise chain passes values

Two Promise chains interleave in microtask queue

await suspends function — caller continues

setTimeout fires in delay order

Promise executor runs synchronously

Nested setTimeout creates new macrotask

Promise.then is always async — even when resolved

async function always returns a Promise

Multiple awaits — each is a microtask suspension

Promise.reject caught by .catch — chain continues

Promise.all preserves order

queueMicrotask runs before setTimeout

throw inside .then becomes rejection, caught by .catch

async try/catch catches awaited rejection

Deep Copy vs Shallow Copy in Promise Resolution

Understanding Call Stack Flow with Nested Function Calls

Deep Copy vs Shallow Copy with Promises

Deep Copy and Shallow Copy in Asynchronous Operations

Chaining Promises with Optional Chaining and Nullish Coalescing

Resolving Nested Promises with Optional Chaining and Nullish Coalescing

Classic var in loop with setTimeout

let in loop — each iteration gets own binding

IIFE captures loop variable

Closure mutation persists across calls

let block scope — inner does not leak

var leaks out of block, let does not

Independent counter factory instances

Closure captures binding not snapshot

var inside function shadows outer

Curried closure

Shared closure state across methods

for...in includes inherited properties, for...of does not

Function is called with arguments object

Method call — this is the calling object

Arrow function has no own this — inherits lexically

bind permanently fixes this — call cannot override it

call vs apply — same result, different syntax

Arrow callback inside method preserves this

Method chaining — return this

this in nested object — direct parent wins

bind with partial application

Class method loses this when destructured

new vs plain call — different returns

var declaration hoisted as undefined

Function declaration fully hoisted

Function expression not hoisted

Local var shadows outer — from start of function

Function declaration takes priority over var in hoisting

which function declaration wins?

var escapes block, let does not

Plus operator: string concat vs numeric add

Loose equality edge cases with null

typeof for common values

Truthy and falsy — empty array and object are truthy

Unary plus converts to number

null comparison inconsistency

Short circuit: || vs ?? difference

Object valueOf for arithmetic, toString for template

parseInt stops at first invalid character

String comparison is lexicographic

Array coercion with plus operator

NaN is not equal to anything including itself

Object equality is reference-based

String spread — unicode-safe character split

JavaScript Optional Chaining and Nullish Coalescing