JavaScript Advanced

Build specialised classes on top of general ones — without copy-pasting a single method.

Attach helpers to the class itself with static — and truly lock internal data away with # private fields.

Where do methods actually live? Meet the prototype chain — the mechanism behind every class, array method, and string method you've ever used.

Put the whole module together — classes, getters, inheritance, statics, and private fields in realistic mini-programs.

The three kinds of failure, the anatomy of an error message, and how to read a stack trace like a map back to the bug.

Stop one bad line from killing your whole program — catch exceptions, recover gracefully, and guarantee cleanup.

Throw your own exceptions when callers break your rules — and build custom error classes that say exactly what went wrong.

Rejections, .catch(), try/catch with await — and the famous fetch gotcha that bites every JavaScript developer once.

A purpose-built key-value collection — any key type, a real size, guaranteed order, and no inherited surprises.

A collection that physically cannot contain duplicates — plus the one-line array dedupe every developer should know.

How objects become text and text becomes objects — stringify, parse, and the round-trip every API request makes.

Persist settings, drafts, and progress in the browser — the JSON + localStorage combo behind every 'it remembered me!' moment.

Create dates, read their parts (mind the zero-indexed months!), measure durations with timestamps, and format for humans and machines.

Describe text patterns instead of exact text — your first regex, the test() method, and the i flag.

The real regex vocabulary: \d \w \s and [sets] for WHAT to match, + * ? {n} for HOW MANY.

Go beyond yes/no: extract the matched text with match() and capture groups, find ALL matches with the g flag, and rewrite text with replace.

Read, predict, and complete real-world patterns — validation, extraction, and cleanup recipes you'll reuse for years.

The machinery behind every setTimeout and promise you've ever used — call stack, queues, and the loop that connects them.

Stop only consuming promises — manufacture them: new Promise, resolve/reject, the wait() helper, and promisifying callback APIs.

Run promises in parallel instead of one-by-one — Promise.all, allSettled, race, and any, plus the sequential-await trap.

setInterval, cancelling timers — and the two rate-limiting patterns (debounce & throttle) behind every smooth search box.

Event-loop tracing, combinator choices, and a real retry-with-delay helper — the whole module in working code.

The one-giant-file problem, the global-scope disaster it causes, and the module idea that fixed JavaScript for good.

Named exports, the default export, renaming with as — the sharing syntax you'll write every single day.

Packages, package.json, node_modules, semver, and the folder layout you'll find in virtually every JavaScript repo on Earth.

The backpack every function carries — private state without classes, function factories, and the pattern behind debounce.

Base case, recursive case, the call stack in action — and the nested-data problems where loops give up and recursion shines.

Functions in, functions out — build your own map, write function-makers, and see the pattern that unifies half this course.

What for...of actually does — the next() contract, why strings/Maps/Sets all 'just work', and making your own objects loopable.

function* and yield — functions that pause mid-run and resume on demand, making iterators trivial and infinite sequences possible.

Beyond console.log: the console's power tools, breakpoints with the debugger keyword, and the hypothesis-driven method professionals actually use.

Code that checks your code — test/expect, arrange-act-assert, edge cases, and why pure functions are a tester's best friend.

Code is read far more than it's written — naming that carries meaning, guard clauses, honest functions, and comments that explain why.

One real program — a habit tracker — built from classes, private fields, Map, JSON, localStorage, error handling, async, and closures. Plus your road ahead.