JavaScript Course Built for AI-Assisted Learning

This chapter focuses on What JavaScript is and where it runs, A short history: ES5, ES6 and the yearly release cycle, The JavaScript engine, parser and just-in-time compilation and the practice needed to use these concepts confidently in real projects.

• What JavaScript is and where it runs
• A short history: ES5, ES6 and the yearly release cycle
• The JavaScript engine, parser and just-in-time compilation
• Setting up Node.js and a modern editor
• Running scripts in the browser console
• Linking scripts: defer, async and module attributes
• Statements, expressions and semicolon rules
• Comments and self-documenting code
• Strict mode and what it changes
• Declaring variables with let and const
• Why var is avoided in new code
• Naming conventions and readability
• Primitive types: string, number, boolean, null, undefined
• Symbol and BigInt and when they appear
• typeof and its known quirks
• Template literals and string interpolation
• Numbers, floating point precision and Number methods
• Type coercion: implicit versus explicit
• Equality: == against === and Object.is
• Truthy and falsy values
• Nullish coalescing and the logical operators
• Operator precedence and when to add parentheses
• Reading error messages in the console

This chapter focuses on if, else if and else, The conditional (ternary) operator, switch statements and fall-through and the practice needed to use these concepts confidently in real projects.

• if, else if and else
• The conditional (ternary) operator
• switch statements and fall-through
• for, while and do…while loops
• for…of and for…in and the difference between them
• break, continue and labelled statements
• Function declarations versus function expressions
• Parameters, arguments and the arguments object
• Default parameter values
• Rest parameters and the spread syntax
• Return values and early returns
• Arrow functions and concise bodies
• Arrow functions and lexical this
• Immediately invoked function expressions
• Pure functions and side effects
• Higher-order functions
• Callbacks and callback signatures
• Recursion and base cases
• Function composition
• Currying and partial application
• Guard clauses over nested conditionals
• Naming functions for intent

This chapter focuses on Global, function and block scope, The scope chain and identifier resolution, Hoisting of declarations and the practice needed to use these concepts confidently in real projects.

• Global, function and block scope
• The scope chain and identifier resolution
• Hoisting of declarations
• The temporal dead zone
• Shadowing and why it causes bugs
• The execution context and the call stack
• Stack traces and reading them
• What a closure is
• Closures over loop variables
• Private state with closures
• The module pattern
• Memoisation with closures
• Function factories
• Closures and memory retention
• Common closure interview traps
• Lexical environment records
• globalThis and the global object
• Garbage collection basics
• Detecting leaks in the memory panel
• When a closure is the wrong tool
• Debugging scope in DevTools
• Refactoring nested closures for clarity

This chapter focuses on Object literals and shorthand syntax, Property access: dot and bracket notation, Computed property names and the practice needed to use these concepts confidently in real projects.

• Object literals and shorthand syntax
• Property access: dot and bracket notation
• Computed property names
• Optional chaining on deep objects
• Property descriptors and Object.defineProperty
• Enumerable, writable and configurable flags
• Object.freeze, seal and preventExtensions
• Object.keys, values and entries
• Object spread and Object.assign
• Shallow versus deep copies
• structuredClone for deep copies
• The prototype chain
• Object.create and prototype delegation
• Constructor functions and the new operator
• this binding rules in every call form
• call, apply and bind
• ES class syntax and constructors
• Instance fields and static members
• Private class fields with the hash prefix
• Getters and setters
• Class inheritance with extends and super
• Composition over inheritance
• instanceof and duck typing

This chapter focuses on Creating arrays and array literals, Indexing, length and sparse arrays, push, pop, shift and unshift and the practice needed to use these concepts confidently in real projects.

• Creating arrays and array literals
• Indexing, length and sparse arrays
• push, pop, shift and unshift
• slice against splice
• concat, join and reverse
• indexOf, includes, find and findIndex
• filter for selection
• map for transformation
• reduce and accumulator patterns
• reduceRight and when it matters
• some and every
• flat and flatMap
• sort and comparator functions
• Sorting objects by multiple keys
• Array.from and Array.of
• Destructuring arrays and swapping values
• at() and negative indexing
• Immutable array updates
• Map: keys of any type
• Set and deduplication
• WeakMap and WeakSet for private data
• Choosing between array, Map, Set and plain object
• Grouping and indexing data for fast lookup

This chapter focuses on String immutability and common methods, Searching: indexOf, includes, startsWith, endsWith, Slicing: slice, substring and their differences and the practice needed to use these concepts confidently in real projects.

• String immutability and common methods
• Searching: indexOf, includes, startsWith, endsWith
• Slicing: slice, substring and their differences
• split, trim, padStart and padEnd
• replace and replaceAll
• Case conversion and locale awareness
• Unicode, code points and emoji handling
• Number parsing: parseInt, parseFloat and Number
• toFixed, rounding and money formatting
• Math methods you actually use
• Random numbers and ranges
• Date objects and their pitfalls
• Timestamps, time zones and UTC
• Formatting dates with Intl.DateTimeFormat
• Intl.NumberFormat for currency and units
• Date arithmetic and duration handling
• Regular expression literals and the RegExp object
• Character classes, quantifiers and anchors
• Groups, capture groups and named groups
• Flags: g, i, m, s and u
• match, matchAll, test and exec
• Lookahead and lookbehind
• Validating input safely with regex

This chapter focuses on Synchronous versus asynchronous execution, The call stack, task queue and event loop, Microtasks against macrotasks and the practice needed to use these concepts confidently in real projects.

• Synchronous versus asynchronous execution
• The call stack, task queue and event loop
• Microtasks against macrotasks
• setTimeout, setInterval and clearing them
• queueMicrotask and requestAnimationFrame
• Callback style and callback hell
• The Promise object and its three states
• Creating a promise with the executor
• then, catch and finally
• Chaining promises and returning values
• Error propagation through a chain
• Promise.all and fail-fast behaviour
• Promise.allSettled for partial success
• Promise.race and Promise.any
• async functions and implicit promises
• await and sequencing
• Running awaits in parallel correctly
• try/catch with await
• Async iteration with for await…of
• Async generators
• AbortController and cancelling work
• Timeouts, retries and exponential backoff
• Debouncing and throttling async calls

This chapter focuses on The document object model as a tree, Selecting elements with querySelector and friends, Traversing parents, children and siblings and the practice needed to use these concepts confidently in real projects.

• The document object model as a tree
• Selecting elements with querySelector and friends
• Traversing parents, children and siblings
• Creating, cloning and inserting nodes
• textContent, innerText and innerHTML
• Safely rendering user content
• Working with classList and dataset
• Reading and setting attributes and properties
• Inline styles versus class toggling
• Getting layout: offset, client and scroll metrics
• The event model: capturing and bubbling
• addEventListener and its options
• Event objects, target and currentTarget
• preventDefault and stopPropagation
• Event delegation for dynamic lists
• Keyboard, pointer and touch events
• Form events, validation and FormData
• fetch and the Request/Response objects
• JSON handling and error checking
• CORS in practice
• localStorage, sessionStorage and cookies
• The History API and client-side navigation
• IntersectionObserver, ResizeObserver and MutationObserver

This chapter focuses on Why modules exist: the global scope problem, ES module export and import syntax, Named against default exports and the practice needed to use these concepts confidently in real projects.

• Why modules exist: the global scope problem
• ES module export and import syntax
• Named against default exports
• Dynamic import and code splitting
• Module scope and single evaluation
• CommonJS and interoperability
• Circular dependencies and how to avoid them
• Barrel files and their trade-offs
• npm, package.json and semantic versioning
• Lock files and reproducible installs
• Bundlers: what they do and why
• Transpilation and browser targets
• Source maps and debugging built code
• Linting with ESLint
• Formatting with Prettier
• Editor tooling and type-aware hints
• The Error object and its properties
• throw and custom error classes
• try, catch, finally and rethrowing
• Handling errors at the right layer
• Unhandled rejections and global handlers
• Defensive coding without noise
• Logging that helps future debugging

This chapter focuses on Why automated tests change how you refactor, Unit tests, integration tests and the pyramid, Writing a first test with a modern runner and the practice needed to use these concepts confidently in real projects.

• Why automated tests change how you refactor
• Unit tests, integration tests and the pyramid
• Writing a first test with a modern runner
• Arrange, act, assert
• Matchers and useful assertions
• Testing asynchronous code
• Mocks, stubs and spies
• Faking timers and network calls
• Test coverage and what it does not tell you
• Test-driven refactoring in practice
• Measuring performance with the Performance panel
• Reflow, repaint and layout thrashing
• Long tasks and breaking up work
• Efficient DOM updates and batching
• Lazy loading assets and code
• Caching strategies in the browser
• Core Web Vitals and what moves them
• Accessibility checks in the browser
• Project: building the application structure
• Project: data layer and API integration
• Project: state, rendering and interaction
• Project: tests, review and hardening
• Project: build, deploy and walkthrough