ECMAScript JavaScript

ECMAScript is the official language standard that defines how JavaScript should work. JavaScript engines (Chrome V8, Firefox SpiderMonkey, etc.) implement this standard.

Not exactly.

• ECMAScript = specification (rules/standard)
• JavaScript = practical implementation of that specification in engines/environments

Because modern JavaScript syntax and behavior come from ECMAScript versions (ES5, ES6/ES2015, and later).

ES6 usually refers to ECMAScript 2015, a major update introducing let/const, classes, modules, arrow functions, etc.

A JavaScript engine parses and executes ECMAScript code. Examples: V8 (Chrome/Node.js), SpiderMonkey (Firefox), JavaScriptCore (Safari).

New language versions try not to break old code. That is why some historical quirks still exist.

Strict mode ("use strict") enables safer parsing and stricter error handling.

It helps catch silent mistakes (like accidental globals) and prevents unsafe patterns.

let and const are lexical declarations; their scope is block-based.

• let: can be reassigned
• const: cannot be reassigned

Use const by default unless value must change.

No. const prevents reassignment of the binding, but object contents can still be mutated unless frozen.

Variables declared with let/const are visible only inside the nearest { ... } block.

Declarations are processed before runtime execution. But let/const exist in Temporal Dead Zone before initialization.

Time between entering scope and declaration line where let/const cannot be accessed.

A non-object value such as string, number, bigint, boolean, undefined, null, symbol.

Objects, arrays, functions, maps, sets, dates, etc. are reference types.

Automatic conversion between types during operations/comparisons.

=== avoids implicit coercion and gives predictable comparisons.

Backtick strings supporting interpolation and multiline text: Hello ${name}

Cleaner string building, readable multiline strings, easier interpolation than concatenation.

Function parameters can have fallback values when arguments are missing or undefined.

...args gathers remaining arguments into a real array.

... expands arrays/iterables/objects into places where multiple values are expected.

Same token, different roles:

• rest collects values
• spread expands values

Syntax for extracting values from arrays/objects into variables.

Less boilerplate, clearer intent, easier parameter handling.

When variable name equals property name: const x = 1; const obj = { x };

Object keys built from expressions: { [dynamicKey]: value }

Safe property/method access without crashing when value is null/undefined.

Returns fallback only for null/undefined (not for 0, false, empty string).

|| treats many valid values (0, "", false) as missing. ?? is often safer for defaults.

Named function defined with function, hoisted with body.

Function assigned to variable; follows variable initialization timing.

Compact function syntax; lexical this; no own arguments.

For object methods needing dynamic this, or constructors (cannot use new with arrows).

Scope determined by where code is written, not where function is called.

Function retaining access to outer lexical variables after outer function returns.

Enable private state, currying, memoization, module-like encapsulation.

Immediately Invoked Function Expression: (function(){ ... })(); Historically used for private scope before modules.

this depends on call-site: method call, plain call, constructor call, explicit bind/call/apply.

Returns new function with fixed this (and optionally prefilled arguments).

Methods like map/filter/reduce/forEach that process elements declaratively.

• map returns new transformed array
• forEach is for side effects and returns undefined

Returns new array of elements passing a test.

Combines array values into one result using accumulator logic.

Returns first matching element or undefined.

• some: at least one element passes
• every: all elements pass

Checks whether array/string contains a value.

A unique primitive often used for non-colliding object keys.

Avoid accidental property name collisions, especially in shared libraries.

Numeric type for integers beyond Number safe range.

They are different numeric domains; explicit conversion is required.

Built-in object for date/time values and formatting/parsing operations.

Standard text format for data exchange. Use JSON.parse and JSON.stringify.

Language mechanism for handling exceptions.

Runs whether error happened or not (cleanup logic).

Creates/propagates an exception manually.

They include message + stack trace and integrate with tooling better.

Runtime type inspection (with known caveats like typeof null === "object").

Checks prototype-chain relationship with constructor function/class.

Internal inheritance link allowing objects to inherit properties/methods.

If property not found on object, engine checks prototype, then prototype’s prototype, etc.

Creates a new object with specified prototype.

Syntactic sugar over prototype-based inheritance with cleaner declarations.

Special method executed when creating instance with new.

Methods available on instances via class prototype.

Methods attached to class itself, not instance objects.

Fields accessible only inside class body, enforced by language syntax.

Controlled property read/write methods appearing like normal property access.

Child class reuses and specializes parent class behavior.

Refers to parent class constructor/methods in subclass context.

Subclass provides its own implementation for inherited method.

Different classes respond differently to same method call interface.

Prevents adding/removing/changing own properties (shallow freeze).

• freeze: no add/remove/change
• seal: no add/remove, but writable props may still change

Copies enumerable own properties from sources to target (shallow copy).

Nested objects are still shared references.

Need explicit strategy for nested structures (e.g., structuredClone in supported environments).

Object is iterable if it provides Symbol.iterator returning iterator object.

Iterator object has next() returning { value, done }.

Functions that pause/resume execution and yield values over time.

Custom iteration, lazy sequences, controlled execution flow.

Pauses generator and emits value to caller.

Delegates yielding control to another iterable/generator.

It consumes iterable protocol (Symbol.iterator).

Key-value collection preserving insertion order; keys can be any value.

Map is better for frequent dynamic key ops and non-string keys.

Collection of unique values with insertion order.

Deduplication, membership testing, set operations patterns.

Hold weak references to objects; allow GC when no strong refs remain.

Because weak references are meaningful only for object lifecycles.

Standard abstraction for future async completion/failure.

Avoid wrapping promises unnecessarily ("promise constructor anti-pattern").

Sequential async transformations via .then() return values/promises.

Thrown errors or rejected promises skip to nearest .catch().

Resolves when all promises resolve; rejects fast on first rejection.

Waits for all to settle, returns status for each (fulfilled/rejected).

Settles as soon as first promise settles.

Resolves on first fulfilled promise; rejects only if all reject.

Always returns a promise.

Any value; non-promise values are wrapped as resolved promise.

Using await directly in ES modules outside async functions.

Queue for promise reactions and queueMicrotask callbacks.

They run before next macrotask/render turn; impacts timing behavior.

ECMAScript defines jobs/microtasks; host (browser/node) defines task scheduling details.

Native import/export with static structure analyzable at parse time.

Enables better tooling, tree shaking, early error detection.

Loads module asynchronously at runtime and returns a promise.

Default: one primary export. Named: multiple explicit exports.

export { x } from "./m.js" or export * from "./m.js" for module composition.

Module that performs actions upon import, not just exporting bindings.

They reduce predictability and complicate testing/startup behavior.

Code correctness depends on import/init order. Avoid by explicit dependencies and initialization APIs.

ES modules are strict by default; no need to declare it.

Specified in ES2015 but not broadly implemented in mainstream engines.

Function processes template parts/interpolations for custom behavior (escaping, i18n, DSLs).

Default used only when extracted value is undefined, not null.

Destructure object/array directly in function parameters for cleaner APIs.

catch { ... } when error variable is unnecessary.

Readable numeric literals with underscores: 1_000_000.

Examples:

• ||= assign if left falsy
• &&= assign if left truthy
• ??= assign if left nullish

Initialize only when value is null/undefined while preserving false/0/"".

Access index with support for negative indexing: arr.at(-1) gives last element.

Reliable own-property check without prototype pitfalls.

obj.method?.() calls only if method exists and is callable.

Right-hand expression may not run if condition not met; be mindful of side effects.

Built-in deep cloning for many structured data types.

Cannot clone functions/DOM nodes in many contexts; behavior depends on type support.

Enables proper Unicode-aware regular expression behavior.

Provides match indices data in supporting environments for advanced parsing/highlighting.

The spec uses abstract operations and pseudo-algorithm steps, not executable JS directly.

Specification-level storage associated with objects (e.g., [[Prototype]], [[PromiseState]]).

Internal object link used for inheritance lookups.

[[Prototype]] is internal slot; __proto__ is legacy accessor to observe/set it.

Metadata describing property behavior: value, writable, enumerable, configurable, get, set.

They control mutability, visibility in iteration, and accessor behavior.

Precise creation/configuration of property descriptors.

Comparison algorithm used in Map/Set/includes where NaN equals NaN.

• == loose with coercion
• = strict but +0 and -0 equal; NaN not equal itself
• Object.is distinguishes +0/-0 and treats NaN equal to NaN

A realm includes global object + intrinsic objects + environment. Different iframes/workers can have different realms.

Constructors differ per realm, so prototype relationships may not match expected realm.

Built-in foundational objects/functions (Array.prototype, Promise, etc.) per realm.

Queue of ECMAScript jobs (notably promise jobs) processed by host event loop integration.

Promises adopt state of returned thenables, not only native Promise instances.

Malicious/buggy then methods can call resolve/reject unexpectedly; promise resolution has defensive semantics.

Formal algorithm deciding how promise settles when resolved with value/thenable/promise.

Rejected promises without handlers may surface global warnings/events and hide logical bugs.

Before execution, module dependency graph is resolved and bindings are connected.

Actual execution of module code after successful linking.

Imported bindings reflect exporter’s current value, not copied snapshot.

Cyclic imports can expose partially initialized bindings. Design modules with clear initialization boundaries.

Can pause dependent module evaluation, affecting startup order/timing.

Abstract model for concurrent execution units (main thread, workers) with separate job queues.

SharedArrayBuffer allows memory shared across agents with Atomics for synchronization.

Prevent race conditions and provide ordering/visibility guarantees.

Two agents access same memory concurrently with at least one write and no proper synchronization.

Without synchronization, one agent may not immediately observe another agent’s writes.

Blocking/wakeup coordination primitives on shared typed arrays (in allowed environments).

Built-in symbols customizing language behavior (Symbol.iterator, Symbol.toStringTag, etc.).

Defines default iteration behavior for for…of and spread operations.

Customizes object-to-primitive conversion logic.

Enables asynchronous iteration consumed by for await…of.

Iterators whose next() returns promises, useful for streaming async data.

Loops over async iterable, awaiting each produced value.

Tokenization -> parsing -> AST/internal representation -> bytecode/JIT execution (engine-specific implementation details).

Code shape impacts performance (hidden classes, inline caches, deopts).

Engine-internal object shape representation for optimizing property access.

Frequent property add/remove/order differences can degrade optimized access paths.

Engine falls back from optimized machine code to slower path when assumptions break.

Unexpected types, shape changes, megamorphic call sites, certain dynamic patterns.

Maintainability first; profile real bottlenecks before low-level tuning.

Build output may change semantics/performance edge cases if targets/plugins misconfigured.

Features evolve through stages; syntax/semantics can change before standardization.

Stage 0 idea -> Stage 1 proposal -> Stage 2 draft -> Stage 3 candidate -> Stage 4 finished (standard).

Check runtime support, use linting, tests, progressive rollout, and fallback/transpile where needed.

Language itself is standardized, but tooling/runtime support differs by environment versions.

Consider readability, team familiarity, browser/runtime matrix, and bundle/tooling impact.

Classify errors as validation, domain, infrastructure, timeout, auth, and unknown to improve handling.

Expect partial failures, handle retries/backoff/cancellation, and preserve user progress where possible.

Knowing not only syntax, but also spec mental models: execution context, binding, prototype mechanics, async job ordering, module linking, and runtime trade-offs.