Learn JavaScript —
Beginner to Professional

No experience needed. You will run working JavaScript in lesson 1 and understand how the JS engine executes code by lesson 5.

1. 01Introduction to JavaScript
   • What is JavaScript? Its role alongside HTML and CSS
   • JS engines: V8 (Chrome/Node), SpiderMonkey (Firefox), JavaScriptCore
   • Browser runtime vs Node.js runtime
   • Embedding JS: inline, internal <script>, external src, defer vs async
   • Basic syntax: statements, semicolons, comments (// and /* */)
   • Browser DevTools console — your first JS sandbox
2. 02Variables and Data Types
   • var, let, const — differences, scoping rules, when to use each
   • Primitives: Number, String, Boolean, Null, Undefined, Symbol, BigInt
   • Reference types: Objects and Arrays
   • typeof operator and practical type checking
   • Type coercion (implicit) vs type conversion (explicit)
   • Truthy and falsy values — the 6 falsy values in JavaScript
3. 03Operators and Control Flow
   • Arithmetic, assignment, comparison, logical operators
   • == vs === (loose vs strict equality)
   • Ternary operator, optional chaining (?.), nullish coalescing (??)
   • if/else, switch/case — control flow patterns
   • Loops: for, while, do...while, for...of, for...in
   • break, continue, and labeled statements
4. 04Functions
   • Function declarations vs function expressions
   • Arrow functions (=>) — syntax and this binding difference
   • Parameters, arguments, default parameters, rest (...args)
   • Return values and early returns
   • First-class functions: passing and returning functions
   • IIFE (Immediately Invoked Function Expression)
5. 05Scope, Hoisting, and Closures
   • Global scope, function scope, and block scope
   • Hoisting: how var and function declarations are lifted
   • Temporal Dead Zone (TDZ) with let and const
   • The scope chain and lexical scoping
   • Closures: definition, how they form, why they matter
   • Practical closure patterns: data privacy, factory functions, memoization

Objects, arrays, DOM, and events — the building blocks used in every single JavaScript project, from one-page scripts to full applications.

6. 06Objects and Arrays
   • Object literals, properties, methods, and shorthand syntax
   • this keyword: context in methods, arrow functions, and event handlers
   • Object destructuring and computed property names
   • Spread (...) and rest (...) operators for objects and arrays
   • Array methods: map, filter, reduce, find, findIndex, every, some, flat, flatMap
   • Array destructuring, sorting, and Array.from()
7. 07DOM Manipulation
   • Selecting elements: querySelector, querySelectorAll, getElementById
   • Reading and modifying content: textContent, innerHTML, innerText
   • Modifying attributes: getAttribute, setAttribute, classList, dataset
   • Creating, inserting, and removing elements: createElement, appendChild, remove
   • insertAdjacentHTML and DocumentFragment for performance
   • DOM traversal: parentElement, children, nextSibling, closest
8. 08Events
   • addEventListener and removeEventListener
   • The event object: target, currentTarget, type, key, clientX/Y
   • Event bubbling and capturing — the full propagation model
   • Event delegation — efficient handling for dynamic content
   • preventDefault and stopPropagation
   • Custom events with new CustomEvent() and dispatchEvent
9. 09ES6+ Modern JavaScript
   • Template literals: interpolation and multiline strings
   • Enhanced object literals: shorthand, computed keys, method shorthand
   • Logical assignment: &&=, ||=, ??=
   • ES2022+: Array.at(), Object.hasOwn(), class fields, top-level await
   • ES2024/2025: Promise.withResolvers(), Object.groupBy(), Set.union/intersection
10. 10Iterables, Generators, Map & Set
    • The iterable protocol and Symbol.iterator
    • for...of loop with strings, arrays, Maps, and Sets
    • Generators (function*): yield, next(), and lazy evaluation
    • Map: key-value pairs with any key type — when to use over plain objects
    • Set: unique values, deduplication pattern, Set methods (ES2025)
    • WeakMap and WeakSet for memory-safe object references

Closures, prototypes, the event loop, and async — the topics most tested in JavaScript interviews and that make the difference between beginner and experienced developers.

11. 11Advanced Functions
    • Closures in depth: real-world patterns and common pitfalls
    • Higher-order functions: passing, returning, and composing
    • Currying and partial application
    • Function composition and pipeline patterns
    • Memoization for expensive function calls
    • call(), apply(), and bind() — explicit this binding
12. 12Prototypes and Object-Oriented Programming
    • The prototype chain — how property lookup traverses objects
    • Constructor functions and the new keyword
    • Object.create() and prototypal inheritance
    • ES6 class syntax: constructor, methods, getters, setters
    • Class inheritance: extends, super, method overriding
    • Static methods and private class fields (#)
13. 13Asynchronous JavaScript
    • Callbacks and callback hell — the problem Promises solve
    • Creating Promises: new Promise(), resolve, reject
    • Promise chaining: .then(), .catch(), .finally()
    • Promise combinators: Promise.all(), .race(), .allSettled(), .any()
    • async/await — writing async code in synchronous style
    • Error handling: try/catch/finally in async functions
14. 14The JavaScript Event Loop
    • JavaScript's concurrency model: single-threaded, non-blocking I/O
    • The call stack — how synchronous execution works
    • Web APIs: setTimeout, fetch, DOM events — offloaded from the JS thread
    • Microtask queue (Promises) vs macrotask queue (setTimeout)
    • Event loop iteration: why microtasks always run before macrotasks
    • Practical implications for async/await and Promise execution order

Modules, testing, performance, and design patterns — the skills used in real professional JavaScript codebases at every company.

15. 15JavaScript Modules
    • ES modules: named exports, default exports, import syntax
    • Re-exports, aliased imports, and namespace imports (* as)
    • Dynamic import() for code splitting and lazy loading
    • CommonJS (require/module.exports) vs ES Modules — Node.js context
    • Module bundlers: Webpack and Vite — conceptual overview
16. 16Web APIs
    • Fetch API: GET, POST, headers, JSON, error handling
    • localStorage and sessionStorage: store, get, remove, clear
    • Geolocation API for location-aware web apps
    • Intersection Observer for lazy loading and scroll animations
    • Web Workers: off-thread computation for performance
    • History API, URL API, and the Clipboard API
17. 17Error Handling
    • try/catch/finally — synchronous error handling
    • Error types: SyntaxError, TypeError, ReferenceError, RangeError
    • Custom error classes: class AppError extends Error
    • Async error handling: async/await try/catch and Promise.catch
    • Global handlers: window.onerror, unhandledrejection
18. 18JavaScript Testing with Jest
    • Why testing matters: confidence, documentation, regression prevention
    • Jest: setup, test(), expect(), common matchers
    • Unit testing pure functions and JavaScript modules
    • Mocking: jest.fn(), jest.mock(), spy on dependencies
    • Test-driven development (TDD): red → green → refactor
19. 19Performance Optimization
    • Memory leaks: common causes, detection with Chrome DevTools
    • Garbage collection: mark-and-sweep, how V8 manages memory
    • Debounce and throttle for scroll, resize, and input events
    • Code splitting and dynamic import() for faster page loads
    • requestAnimationFrame for smooth 60fps animations
20. 20JavaScript Design Patterns
    • Module pattern — encapsulation and private data
    • Singleton pattern — single instance enforcement
    • Observer / PubSub — event-driven decoupled architecture
    • Factory pattern — creating objects without specifying class
    • Strategy pattern and MVC/MVVM architectural overview

Introduction to the JS ecosystem beyond the browser — Node.js on the server side and the major frontend frameworks that every JS developer encounters.

21. 21Introduction to Node.js
    • What is Node.js? V8 engine + libuv — JS on the server
    • npm: installing packages, package.json, node_modules, scripts
    • Built-in modules: fs, path, os, http
    • Building a simple HTTP server with Node.js http module
    • How the Node.js event loop differs from the browser
22. 22Modern JavaScript Frameworks Overview
    • Why frameworks exist: component model, state, virtual DOM
    • React: JSX, components, hooks (useState, useEffect), Next.js
    • Vue 3: Composition API, reactive state, Nuxt.js
    • Angular: TypeScript-first, modules, dependency injection
    • Svelte and Solid.js — the future of JS frameworks in 2026
    • React vs Vue vs Angular — how to choose in 2026