ECMAScript Learning Lab

Read a concept. Predict the output. Run the example. Make it your own.

A hands-on JavaScript and ECMAScript reference for developers who want to understand language behavior through small, focused programs. Explore fundamentals, functions, objects, modules and modern APIs, then reinforce each topic with practice.

Quick start · Learning paths · Study routine · Module catalog · Verification

What you will find

• Topic-focused folders that keep explanations and examples together.
• An extended catalog documenting 119 additional modules, 1,190 runnable examples and 1,785 unsolved exercises.
• Progressive examples: the modules guide moves from easy programs to harder cases and a real-world or interview example.
• Practice and revision: module READMEs explain concepts, execution instructions and questions to check your understanding.
• Runtime-aware verification: unsupported native APIs are reported separately as skipped.

Quick start

Install Node.js and Git, then clone the repository:

git clone https://github.com/devendraghag/ecma_repository.git
cd ecma_repository
node --version
node modules/01-named-import.js

The last command runs the first ECMAScript modules example. Read the module guide, explore the remaining examples, then try practice.js.

Use a current Node.js release. Support for newer APIs varies by runtime; check the relevant module notes if a feature is unavailable. Run the Node-based course verifier directly:

node scripts/verify-course.cjs

Choose a learning path

Your goal	Suggested starting points
Build a strong foundation	Data types → Type conversion → Equality → Array basics
Understand functions and scope	Functions → Lexical scope → Call → Apply → Bind
Write modular JavaScript	Modules → Classes → Inheritance → Dynamic import
Explore objects and collections	Prototypes → Property descriptors → Collection iteration → Proxy
Study advanced language behavior	Typed arrays → ArrayBuffer → DataView → Async generators

Returning for interview revision? Pick a topic, explain its rules aloud, predict an example output, and attempt a practice exercise before checking the guide.

A simple study routine

1. Read the topic README and its important rules.
2. Predict the output before executing an example.
3. Run the program and explain any difference from your prediction.
4. Experiment locally by changing one input or condition.
5. Practice with the module exercises and revision questions.

For Java developers: compare actual JavaScript behavior rather than assuming a direct Java equivalent. Pay particular attention to dynamic typing, coercion, prototypes, lexical scope and asynchronous execution.

Try a 20-minute learning session

• 5 minutes: read one module explanation and its rules.
• 5 minutes: predict and run two examples.
• 5 minutes: vary an input and explain the result.
• 5 minutes: attempt one exercise without copying the solution.

Keep a note of the behavior that surprised you and revisit it the next day.

Module catalog

The full index below preserves the course links and edition labels. Use it as a reference after choosing a starting point above.

Additional modules

These 119 modules extend the original course with 1190 runnable examples and 1785 unsolved exercises. Each folder has ten formatted examples, a README, and practice.js.

Folder	Topic	Edition
modules	ECMAScript Modules	ES2015
typed-arrays	Typed Arrays	ES2015–ES2025
array-buffer	ArrayBuffer	ES2015
data-view	DataView	ES2015
bigint-typed-arrays	BigInt Typed Arrays	ES2020
classes	Classes and Class Expressions	ES2015
class-inheritance	Class Inheritance	ES2015
class-static-methods	Static Methods	ES2015
proxy	Proxy	ES2015
reflect	Reflect	ES2015
symbol-registry	Symbol Registry	ES2015
symbol-hooks	Well Known Symbol Hooks	ES2015+
object-is	Object is	ES2015
object-get-own-property-symbols	Object getOwnPropertySymbols	ES2015
object-set-prototype-of	Object setPrototypeOf	ES2015
object-literal-prototype	Object Literal Prototype	ES2015
array-fill	Array fill	ES2015
array-copy-within	Array copyWithin	ES2015
array-iterators	Array Iterators	ES2015
number-methods	Number Methods	ES2015
math-es2015	Math ES2015 Additions	ES2015
unicode-strings	Unicode Strings	ES2015
string-raw	String raw	ES2015
regexp-unicode-sticky	RegExp Unicode and Sticky Flags	ES2015
new-target	new.target	ES2015
generator-interaction	Generator Interaction	ES2015
temporal-dead-zone	Temporal Dead Zone	ES2015
collection-iteration	Map and Set Iteration APIs	ES2015
tail-calls	Tail Position and Iterative Alternatives	ES2015
shared-array-buffer	SharedArrayBuffer	ES2017
atomics	Atomics	ES2017
trailing-commas	Trailing Commas	ES2017
regexp-dot-all	RegExp dotAll	ES2018
regexp-named-groups	RegExp Named Capture Groups	ES2018
regexp-lookbehind	RegExp Lookbehind	ES2018
regexp-unicode-properties	RegExp Unicode Property Escapes	ES2018
tagged-template-escapes	Tagged Template Escape Semantics	ES2018
optional-catch-binding	Optional Catch Binding	ES2019
symbol-description	Symbol description	ES2019
function-to-string	Function toString	ES2019
stable-sort	Stable Sorting	ES2019
json-unicode-semantics	JSON Unicode Improvements	ES2019
dynamic-import	Dynamic import	ES2020
import-meta	import.meta	ES2020
global-this	globalThis	ES2020
string-match-all	String matchAll	ES2020
for-in-order	for in Enumeration Order	ES2020
string-replace-all	String replaceAll	ES2021
finalization-registry	FinalizationRegistry	ES2021
aggregate-error	AggregateError	ES2021
class-fields	Public and Private Class Fields	ES2022
regexp-match-indices	RegExp Match Indices	ES2022
typed-array-modern-methods	Modern Typed Array Methods	ES2022–ES2023
symbols-in-weak-collections	Symbols in Weak Collections	ES2023
object-group-by	Object groupBy	ES2024
map-group-by	Map groupBy	ES2024
promise-with-resolvers	Promise withResolvers	ES2024
resizable-array-buffer	Resizable ArrayBuffer	ES2024
growable-shared-array-buffer	Growable SharedArrayBuffer	ES2024
array-buffer-transfer	ArrayBuffer Transfer	ES2024
atomics-wait-async	Atomics waitAsync	ES2024
well-formed-strings	Well Formed Unicode Strings	ES2024
regexp-unicode-sets	RegExp Unicode Sets	ES2024
iterator-helpers	Iterator Helpers	ES2025
set-methods	Native Set Operations	ES2025
json-modules	JSON Modules and Import Attributes	ES2025
regexp-escape	RegExp escape	ES2025
regexp-modifiers	RegExp Scoped Modifiers	ES2025
regexp-duplicate-names	RegExp Duplicate Named Groups	ES2025
promise-try	Promise try	ES2025
float16	Float16 Numeric APIs	ES2025
array-from-async	Array fromAsync	ES2026
iterator-concat	Iterator concat	ES2026
math-sum-precise	Math sumPrecise	ES2026
error-is-error	Error isError	ES2026
map-get-or-insert	Map getOrInsert	ES2026
weakmap-get-or-insert	WeakMap getOrInsert	ES2026
uint8array-base64	Uint8Array Base64 Conversion	ES2026
uint8array-hex	Uint8Array Hex Conversion	ES2026
json-parse-source	JSON parse Source Access	ES2026
json-raw	Raw JSON	ES2026
data-types	Data Types	ES1+
type-conversion	Type Conversion	ES1+
equality-comparison	Equality and Comparison	ES1+
number-behavior	Number Behavior	ES1+
operators	Additional Operators	ES1+
operator-precedence	Operator Precedence	ES1+
switch	Switch Statements	ES3
do-while	Do While	ES3
labelled-statements	Labelled Statements	ES3
try-catch-finally	Try Catch Finally	ES3
function-call	Function call	ES3
function-apply	Function apply	ES3
function-bind	Function bind	ES5
arguments-object	Arguments Object	ES1+
function-constructor	Function Constructor	ES1+
eval	Direct and Indirect eval	ES1+
regular-expressions	Regular Expressions	ES3
date	Date and Time	ES1+
number-parsing	Number Parsing	ES1+
uri-encoding	URI Encoding	ES3
array-basics	Array Basics	ES1+
string-basics	String Basics	ES1+
math-basics	Math Basics	ES1+
object-prototypes	Object Prototypes	ES1+
strict-mode	Strict Mode	ES5
object-accessors	Getters and Setters	ES5
property-descriptors	Property Descriptors	ES5
object-inspection	Object Inspection	ES3–ES2017
object-integrity	Object Integrity	ES5
array-is-array	Array isArray	ES5
array-index-of	Array Index Searches	ES5
array-reduce-right	Array reduceRight	ES5
json-parse	JSON parse	ES5
json-stringify-options	JSON stringify Options	ES5
hashbang	Hashbang Scripts	ES2023
function-metadata	Function Metadata and Name Inference	ES2015+
async-generator-interaction	Async Generator Interaction	ES2018
error-types	Built-in Error Types	ES3+

Verification

Run node scripts/verify-course.cjs. Native APIs unavailable in the current runtime are reported separately as skipped, not passed. See verification results. Expected outputs are authored in the catalog, not copied from execution results.

Maintenance

The scripts/catalog-*.cjs files define the new course content. Run node scripts/generate-course.cjs to regenerate these modules. The generator uses an installed Prettier package, COURSE_PRETTIER_PATH, or the existing local fallback recorded in the script. Runtime verification uses only Node.js.

Existing modules

The original root feature folders, function, lexical-scope, and additional original modules remain part of the course.

Scope

This course covers language-level features through ES2026. It does not claim conformance with every normative algorithm or runtime implementation detail. ES2027 features such as Temporal and explicit resource management are outside this batch.