Learn JavaScript

Run your first JavaScript in the browser console, in a web page and with Node.js.

The seven primitive types, objects, typeof, and which values count as truthy or falsy.

Declare variables with const and let, know what var does differently, and what const really protects.

Arithmetic, comparison and logical operators, and why you use === instead of ==.

Create strings, interpolate with template literals and use the everyday string methods.

How JavaScript numbers work, parsing and formatting them, and when you need BigInt.

Branch with if/else, the ternary operator and switch.

Repeat work with for, while, for...of and for...in, and control it with break and continue.

Declare functions, pass parameters with defaults, return values and treat functions as values.

Write compact functions with =>, use implicit returns and know how arrows differ from regular functions.

Understand lexical scope, block vs function scope, hoisting and the temporal dead zone.

Functions remember the variables of the scope they were created in — use that for private state and factories.

Learn the rules that decide what this refers to, and how call, apply, bind and arrows change it.

Throw and catch errors, clean up with finally, create custom error types and add causes.

Split code into ES modules with named and default exports, static and dynamic imports.

Create arrays, read and update elements, and add, remove and find items.

Group related data in objects: create them, read and update properties, add methods and iterate.

Safely read through possibly-missing values with ?. and supply defaults with ?? and ??=.

Transform, filter, search, sort and group arrays with callback-based methods instead of hand-written loops.

Unpack arrays and objects into variables, and use ... to copy, merge and collect values.

Convert between JavaScript values and JSON text with JSON.stringify and JSON.parse, and know what gets lost.

Use Map for key–value lookups with any key type and Set for unique values, including the new set operations.

Avoid accidental mutation with change-by-copy methods, structuredClone and Object.freeze — and know their limits.

Select elements with querySelector, change their text, classes and attributes, and create new ones.

React to clicks, input and form submissions with addEventListener and the event object.

Understand capture and bubbling, target vs currentTarget, and handle many elements with one listener.

Define classes with constructors, methods, fields, private members, static members and inheritance.

See how property lookup walks the prototype chain and how classes, Object.create and built-ins fit on top of it.

Schedule work with setTimeout and setInterval and see why JavaScript code never blocks waiting.

Represent future results with promises: chain then/catch/finally and combine them with Promise.all and friends.

Write asynchronous code that reads top to bottom with async functions, await and try/catch.

Request data from APIs with fetch, handle HTTP errors properly, send JSON and cancel requests.

Understand the call stack, task queue and microtask queue, and predict the order async code runs in.

Consume streams of asynchronous values with for await...of and produce them with async generators.

Implement the iteration protocol, write generator functions with yield and chain lazy iterator helpers.

Create collision-free property keys with Symbol and customise language behaviour via well-known symbols.

Intercept fundamental object operations with Proxy traps and forward them correctly with Reflect.

Match, extract and replace text with regular expressions, named groups and flags.

Reason precisely about ToPrimitive, + and ==, -0 and NaN, SameValueZero and property order using the spec's abstract operations.

Profile before optimising, measure with the Performance API and fix the usual culprits: algorithms, layout and the main thread.

Follow code from source to bytecode to optimised machine code, and see what makes engines speculate and deoptimise.

Learn how engines give objects shapes, cache property lookups per call site, and what makes code polymorphic or megamorphic.

How engines reclaim memory by reachability, how generational GC works, and how to find and fix leaks.

Learn the spec's model of realms, agents and job queues, and why instanceof fails across iframes.

Share memory between workers with SharedArrayBuffer, avoid data races with Atomics, and coordinate with wait/notify.