JS Mastery

What you'll learn

• Basics BayValues, variables, operators, strings, decisions and loops: the grammar every other topic builds on.
• Function ForestReusable logic: declarations, arrows, scope, hoisting, closures, callbacks and recursion.
• Data DunesArrays, objects, destructuring, spread and rest, Map and Set, and JSON.
• Intermediate Islesthis, prototypes, classes, inheritance, errors, modules, iterators, generators and regular expressions.
• DOM JungleFind, change and create page elements, then react to clicks, keys and forms.
• Async ArchipelagoThe event loop, timers, callbacks, promises, async/await and fetching data.
• Advanced AbyssCurrying, memoization, debounce, Proxy, Symbols, WeakMap, patterns, immutability, FP and performance.

Course outline

7 units and 69 lessons. Each lesson has a short read with examples you run, a quiz, and coding problems tested in your browser; most have a step-through visualizer.

1. 1

   Unit 1:Basics Bay

   Values, variables, operators, strings, decisions and loops: the grammar every other topic builds on.

   Free
   1. 1
      Hello, JavaScript What JS is, where it runs, and how to print with console.log.
      1 problem
   2. 2
      Variables: let, const, var Name values so you can reuse and change them.
      1 problem
   3. 3
      Data Types and typeof Strings, numbers, booleans, null, undefined, symbols, bigints and objects.
      1 problem
   4. 4
      Operators Arithmetic, comparison, logical, nullish and optional chaining.
      1 problem
   5. 5
      Type Coercion and Equality When JavaScript converts types on its own, the rules of ==, and why === is the default.
      1 problem
   6. 6
      Strings and Template Literals Build, slice, search and transform text.
      1 problem
   7. 7
      Numbers and Math Floating point, rounding, parsing, random numbers.
      1 problem
   8. 8
      Conditionals if/else, the ternary operator, switch, truthy and falsy.
      1 problem
   9. 9
      Loops for, while, do...while, for...of, for...in, break and continue.
      1 problem
2. 2

   Unit 2:Function Forest

   Reusable logic: declarations, arrows, scope, hoisting, closures, callbacks and recursion.

   Free
   1. 1
      Functions Declarations, expressions, parameters, defaults and return values.
      1 problem
   2. 2
      Arrow Functions Short syntax, implicit returns and how arrows differ.
      1 problem
   3. 3
      Scope Global, function and block scope, plus the scope chain.
      1 problem
   4. 4
      Hoisting and the TDZ Why some things work before they are declared, and some do not.
      1 problem
   5. 5
      Closures Functions that remember the variables around them.
      1 problem
   6. 6
      Callbacks and Higher-Order Functions Passing functions in, returning functions out.
      1 problem
   7. 7
      Recursion Functions that call themselves to solve smaller problems.
      1 problem
3. 3

   Unit 3:Data Dunes

   Arrays, objects, destructuring, spread and rest, Map and Set, and JSON.

   Pro
   1. 1
      Arrays Ordered lists: create, read, add, remove and copy.
      1 problem
   2. 2
      Array Methods: map, filter, reduce Transform, select, combine, search and sort data.
      1 problem
   3. 3
      Objects Key/value records: properties, methods, iteration and copying.
      1 problem
   4. 4
      Destructuring Unpack arrays and objects into variables in one line.
      1 problem
   5. 5
      Spread and Rest The three dots: expand values out or gather them in.
      1 problem
   6. 6
      Map and Set Keyed collections with any key type, and unique-value sets.
      1 problem
   7. 7
      JSON Turn data into text and back with JSON.stringify and JSON.parse.
      1 problem
   8. 8
      Dates, Times and Intl What a Date really stores, the month and time-zone traps, date arithmetic in UTC, and formatting with Intl.
      1 problem
4. 4

   Unit 4:Intermediate Isles

   this, prototypes, classes, inheritance, errors, modules, iterators, generators and regular expressions.

   Pro
   1. 1
      The this Keyword How this is decided at call time, and call, apply and bind.
      1 problem
   2. 2
      Prototypes The prototype chain: how objects share behaviour.
      1 problem
   3. 3
      Classes Constructors, methods, getters and setters, static and private fields.
      1 problem
   4. 4
      Inheritance extends, super, overriding methods and instanceof.
      1 problem
   5. 5
      Getters, Setters and Property Descriptors Computed properties with get/set, the hidden flags on every property, and seal against freeze.
      1 problem
   6. 6
      Strict Mode, globalThis and Class Features What strict mode changes, the one name for the global object, private methods, static blocks, #x in obj and new.target.
      1 problem
   7. 7
      Error Handling try, catch, finally, throw and custom error types.
      1 problem
   8. 8
      Modules import and export, and the module pattern that came before.
      1 problem
   9. 9
      ES Modules in Depth Static imports, live bindings, one evaluation per module, cycles, dynamic import() and top-level await.
      1 problem
   10. 10
       Iterators and Generators The iteration protocol, function*, yield and lazy sequences.
       1 problem
   11. 11
       Regular Expressions Patterns for searching, validating and replacing text.
       1 problem
   12. 12
       Regex II: Lookaround, Named Groups, Flags Match what comes before or after without consuming it, name your groups, and use the s, u, y and d flags.
       1 problem
   13. 13
       Tagged Templates and String.raw A function in front of a template literal receives its pieces, so it can escape, translate or build anything.
       1 problem
5. 5

   Unit 5:DOM Jungle

   Find, change and create page elements, then react to clicks, keys and forms.

   Pro
   1. 1
      Selecting Elements querySelector, querySelectorAll and walking the DOM tree.
      1 problem
   2. 2
      Changing the Page textContent, classList, attributes, styles, creating and removing nodes.
      1 problem
   3. 3
      Events addEventListener, the event object, keyboard input and preventDefault.
      1 problem
   4. 4
      Bubbling and Delegation How events travel, and handling many elements with one listener.
      1 problem
   5. 5
      Forms and Validation Read inputs, handle submit, validate and show feedback.
      1 problem
   6. 6
      Custom Events, Observers and Animation Frames Send your own events, react to DOM changes and visibility, and draw in step with the screen.
      1 problem
   7. 7
      Web Components and Shadow DOM Define your own HTML elements with custom elements, and encapsulate their markup and styles in a shadow root.
      1 problem
   8. 8
      Browser Storage: localStorage and IndexedDB Saving data in the browser: the Web Storage API, handling failures, IndexedDB for bigger data, and what never to store.
      1 problem
   9. 9
      Web Security Basics: XSS and Friends Why untrusted text must never become code: safe DOM APIs, escaping, URL allow-lists, CSP and prototype pollution.
      1 problem
6. 6

   Unit 6:Async Archipelago

   The event loop, timers, callbacks, promises, async/await and fetching data.

   Pro
   1. 1
      The Event Loop Call stack, task queue, microtasks: why async code runs when it does.
      1 problem
   2. 2
      Timers and Async Callbacks setTimeout, setInterval, error-first callbacks and callback hell.
      1 problem
   3. 3
      Promises Creating, resolving, chaining and catching promises.
      1 problem
   4. 4
      Promise.all, race, any, allSettled Run async work in parallel and combine the results.
      1 problem
   5. 5
      async / await Write promise code that reads like synchronous code.
      1 problem
   6. 6
      Async Iterators and Generators Pull values that arrive over time with for await...of, and produce them with async function*.
      1 problem
   7. 7
      Fetching Data The fetch API, JSON responses, errors, loading states and AbortController.
      1 problem
   8. 8
      HTTP, URLs and CORS What a request and response contain, status codes, building URLs safely, JSON requests, and why CORS exists.
      1 problem
   9. 9
      Web Workers and Message Passing Run heavy work on another thread, and talk to it with structured-cloned messages.
      1 problem
7. 7

   Unit 7:Advanced Abyss

   Currying, memoization, debounce, Proxy, Symbols, WeakMap, patterns, immutability, FP and performance.

   Pro
   1. 1
      Currying and Partial Application Turn f(a, b, c) into f(a)(b)(c) and pre-fill arguments.
      1 problem
   2. 2
      Memoization Cache function results to skip repeated work.
      1 problem
   3. 3
      Debounce and Throttle Control how often a function runs during bursts of events.
      1 problem
   4. 4
      Proxy and Reflect Intercept property access, assignment and more.
      1 problem
   5. 5
      Symbols Unique keys, hidden properties and well-known symbols.
      1 problem
   6. 6
      Memory and Garbage Collection What keeps a value alive, how mark-and-sweep frees the rest, the usual leaks, and how to avoid them.
      1 problem
   7. 7
      WeakMap, WeakSet and WeakRef Attach data to objects without keeping them alive.
      1 problem
   8. 8
      Binary Data: Bitwise Flags, Typed Arrays, DataView Pack options into bits, read and write raw bytes with typed arrays, and parse binary formats with DataView.
      1 problem
   9. 9
      Design Patterns Singleton, factory, observer and strategy in modern JavaScript.
      1 problem
   10. 10
       Immutability Update data without changing it: freeze, copies, structuredClone.
       1 problem
   11. 11
       Functional Programming Pure functions, composition, pipe and point-free style.
       1 problem
   12. 12
       Performance Big-O thinking, measuring, and avoiding needless work.
       1 problem
   13. 13
       Testing Basics: Build a Tiny Test Runner What a unit test is, how assertions and runners work, and how to write tests that catch real bugs.
       1 problem
   14. 14
       Modern JavaScript: ES2020 to ES2025 The recent additions worth knowing: logical assignment, groupBy, findLast, withResolvers, error causes, Set methods and more.
       1 problem