JavaScript and TypeScript

Does await Promise.resolve() guarantee that the browser paints before execution resumes?

No. It resumes through the microtask queue. Use an execution strategy that actually permits rendering, and verify behavior with a performance trace.

One request in Promise.all rejects. What happens to the other requests?

The aggregate rejects, but other operations are not automatically cancelled. Propagate abort signals where supported and decide whether their results or side effects still matter.

Why does await items.forEach(async item => save(item)) not await all saves?

forEach discards callback return values and returns undefined. Use a sequential for-of loop or explicitly await collected promises, with a concurrency bound for large lists.

Why can fetch resolve successfully for an HTTP 500 response?

Network completion and HTTP success are different. Check response.ok or the expected status before parsing the success payload, and handle error response shapes separately.

A callback created when count is 2 runs after count becomes 5. Why can it still use 2?

It closes over the binding or render environment from its creation. Identify which value should be captured and which must be read at invocation; do not assume callbacks automatically refresh.

Why does changing copy.user.name also change original.user.name after copy = {...original}?

Spread copies only the outer object. Both objects reference the same nested user; copy the path being changed or use a suitable immutable update strategy.

Does const settings = {theme: 'dark'} prevent settings.theme from changing?

No. const prevents reassigning the binding. Runtime immutability requires a separate discipline or mechanism; Object.freeze itself is shallow.

Why is value ?? fallback safer than a logical-OR default for a valid quantity of zero?

Nullish coalescing replaces only null or undefined. Logical OR also replaces false, zero, and an empty string, potentially discarding valid input.

Why should a 64-bit database identifier often cross a JSON API as a string?

JavaScript numbers cannot exactly represent all integers beyond 2^53 - 1. Parsing a large numeric ID can silently change its value; preserve it as a string or use an explicit BigInt encoding contract.

Why is JSON.parse(JSON.stringify(value)) not a general deep-clone operation?

Serialization changes or loses values such as undefined and Date objects, rejects cycles and ordinary BigInt values, and does not preserve arbitrary object types. Choose a clone operation matching the actual data model.

Why should unvalidated JSON enter application code as unknown rather than a trusted interface?

Static annotations do not inspect runtime data. Validate structure and constraints before narrowing it to the domain type; an assertion alone cannot establish the contract.

What runtime protection does response as User provide?

None. It tells the compiler to treat the value as User. Malformed fields remain malformed at runtime and need validation at the boundary.

How can a discriminated union prevent accessing data before a request succeeds?

Give each state a distinct literal tag and define data only on the success variant. Checking the tag narrows the allowed fields and makes invalid state combinations harder to express.

How can never help detect an unhandled new state in a switch?

Pass the default branch's value to a function accepting never. With an exhaustive discriminated union, adding a variant makes that branch's type non-never and produces a compiler error.

Does TypeScript readonly prevent another alias from mutating an object at runtime?

No. It restricts assignments through that typed reference and is erased at runtime. Avoid mutable aliases or enforce runtime immutability when the invariant depends on it.

Why can an array lookup return undefined even when its element type is string?

The index may be outside the array or refer to a hole. Check bounds or absence, and consider noUncheckedIndexedAccess so types expose that possibility.

When is satisfies preferable to a broad type annotation for a configuration literal?

It checks compatibility while generally retaining the expression's more specific inferred shape. It is compile-time checking, not runtime validation or an exact-object guarantee for arbitrary inputs.

Why can a variable with extra fields be passed to a function expecting a smaller object type?

TypeScript largely uses structural compatibility. Excess-property checks for fresh literals are not a universal ban on extra runtime fields; validate or select fields when exactness matters.

Why does try { return failingPromise(); } catch {} fail to catch a later rejection inside that function?

The rejection happens after synchronous control leaves the try. Await inside the try or attach a rejection handler; ensure the caller observes the returned promise as well.